=============================================================================== 02006208 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 2006208: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 200620c: 03 00 80 61 sethi %hi(0x2018400), %g1 2006210: e0 00 61 54 ld [ %g1 + 0x154 ], %l0 ! 2018554 <_API_extensions_List> 2006214: 82 10 61 54 or %g1, 0x154, %g1 2006218: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 200621c: 80 a4 00 11 cmp %l0, %l1 2006220: 02 80 00 0c be 2006250 <_API_extensions_Run_postdriver+0x48><== NEVER TAKEN 2006224: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 2006228: c2 04 20 0c ld [ %l0 + 0xc ], %g1 200622c: 80 a0 60 00 cmp %g1, 0 2006230: 22 80 00 05 be,a 2006244 <_API_extensions_Run_postdriver+0x3c><== NEVER TAKEN 2006234: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postdriver_hook)(); 2006238: 9f c0 40 00 call %g1 200623c: 01 00 00 00 nop Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 2006240: e0 04 00 00 ld [ %l0 ], %l0 { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 2006244: 80 a4 00 11 cmp %l0, %l1 2006248: 32 bf ff f9 bne,a 200622c <_API_extensions_Run_postdriver+0x24> 200624c: c2 04 20 0c ld [ %l0 + 0xc ], %g1 2006250: 81 c7 e0 08 ret 2006254: 81 e8 00 00 restore =============================================================================== 02006258 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 2006258: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 200625c: 03 00 80 61 sethi %hi(0x2018400), %g1 2006260: e0 00 61 54 ld [ %g1 + 0x154 ], %l0 ! 2018554 <_API_extensions_List> 2006264: 82 10 61 54 or %g1, 0x154, %g1 2006268: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 200626c: 80 a4 00 11 cmp %l0, %l1 2006270: 02 80 00 0d be 20062a4 <_API_extensions_Run_postswitch+0x4c><== NEVER TAKEN 2006274: 03 00 80 60 sethi %hi(0x2018000), %g1 the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); 2006278: a4 10 63 d4 or %g1, 0x3d4, %l2 ! 20183d4 <_Thread_Executing> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 200627c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2006280: 80 a0 60 00 cmp %g1, 0 2006284: 22 80 00 05 be,a 2006298 <_API_extensions_Run_postswitch+0x40><== NEVER TAKEN 2006288: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 200628c: 9f c0 40 00 call %g1 2006290: d0 04 80 00 ld [ %l2 ], %o0 Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 2006294: e0 04 00 00 ld [ %l0 ], %l0 { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 2006298: 80 a4 00 11 cmp %l0, %l1 200629c: 32 bf ff f9 bne,a 2006280 <_API_extensions_Run_postswitch+0x28> 20062a0: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 20062a4: 81 c7 e0 08 ret 20062a8: 81 e8 00 00 restore =============================================================================== 020061b8 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 20061b8: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 20061bc: 03 00 80 61 sethi %hi(0x2018400), %g1 20061c0: e0 00 61 54 ld [ %g1 + 0x154 ], %l0 ! 2018554 <_API_extensions_List> 20061c4: 82 10 61 54 or %g1, 0x154, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 20061c8: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 20061cc: 80 a4 00 11 cmp %l0, %l1 20061d0: 02 80 00 0c be 2006200 <_API_extensions_Run_predriver+0x48><== NEVER TAKEN 20061d4: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 20061d8: c2 04 20 08 ld [ %l0 + 8 ], %g1 20061dc: 80 a0 60 00 cmp %g1, 0 20061e0: 22 80 00 05 be,a 20061f4 <_API_extensions_Run_predriver+0x3c><== ALWAYS TAKEN 20061e4: e0 04 00 00 ld [ %l0 ], %l0 (*the_extension->predriver_hook)(); 20061e8: 9f c0 40 00 call %g1 <== NOT EXECUTED 20061ec: 01 00 00 00 nop <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 20061f0: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 20061f4: 80 a4 00 11 cmp %l0, %l1 20061f8: 32 bf ff f9 bne,a 20061dc <_API_extensions_Run_predriver+0x24> 20061fc: c2 04 20 08 ld [ %l0 + 8 ], %g1 2006200: 81 c7 e0 08 ret 2006204: 81 e8 00 00 restore =============================================================================== 02008500 <_CORE_RWLock_Obtain_for_reading>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 2008500: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing = _Thread_Executing; 2008504: 03 00 80 6b sethi %hi(0x201ac00), %g1 * If unlocked, then OK to read. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 2008508: 7f ff ea 55 call 2002e5c 200850c: e0 00 62 b4 ld [ %g1 + 0x2b4 ], %l0 ! 201aeb4 <_Thread_Executing> 2008510: a2 10 00 08 mov %o0, %l1 switch ( the_rwlock->current_state ) { 2008514: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 2008518: 80 a0 60 00 cmp %g1, 0 200851c: 12 80 00 0c bne 200854c <_CORE_RWLock_Obtain_for_reading+0x4c> 2008520: 80 a0 60 01 cmp %g1, 1 case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; the_rwlock->number_of_readers += 1; 2008524: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 2008528: 84 10 20 01 mov 1, %g2 the_rwlock->number_of_readers += 1; 200852c: 82 00 60 01 inc %g1 */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 2008530: c4 26 20 44 st %g2, [ %i0 + 0x44 ] the_rwlock->number_of_readers += 1; 2008534: c2 26 20 48 st %g1, [ %i0 + 0x48 ] _ISR_Enable( level ); 2008538: 7f ff ea 4d call 2002e6c 200853c: 01 00 00 00 nop executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 2008540: c0 24 20 34 clr [ %l0 + 0x34 ] 2008544: 81 c7 e0 08 ret 2008548: 81 e8 00 00 restore * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { 200854c: 02 80 00 15 be 20085a0 <_CORE_RWLock_Obtain_for_reading+0xa0> 2008550: 80 8e a0 ff btst 0xff, %i2 /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 2008554: 02 80 00 0d be 2008588 <_CORE_RWLock_Obtain_for_reading+0x88> 2008558: 82 10 20 01 mov 1, %g1 * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; executing->Wait.id = id; 200855c: f2 24 20 20 st %i1, [ %l0 + 0x20 ] executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 2008560: c0 24 20 34 clr [ %l0 + 0x34 ] /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 2008564: f0 24 20 44 st %i0, [ %l0 + 0x44 ] executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; 2008568: c0 24 20 30 clr [ %l0 + 0x30 ] 200856c: c2 26 20 30 st %g1, [ %i0 + 0x30 ] executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); 2008570: 90 10 00 11 mov %l1, %o0 2008574: 7f ff ea 3e call 2002e6c 2008578: 35 00 80 21 sethi %hi(0x2008400), %i2 _Thread_queue_Enqueue_with_handler( 200857c: b2 10 00 1b mov %i3, %i1 2008580: 40 00 06 eb call 200a12c <_Thread_queue_Enqueue_with_handler> 2008584: 95 ee a3 50 restore %i2, 0x350, %o2 /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { _ISR_Enable( level ); 2008588: 7f ff ea 39 call 2002e6c 200858c: 90 10 00 11 mov %l1, %o0 executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 2008590: 82 10 20 02 mov 2, %g1 2008594: c2 24 20 34 st %g1, [ %l0 + 0x34 ] 2008598: 81 c7 e0 08 ret 200859c: 81 e8 00 00 restore executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; return; case CORE_RWLOCK_LOCKED_FOR_READING: { Thread_Control *waiter; waiter = _Thread_queue_First( &the_rwlock->Wait_queue ); 20085a0: 40 00 07 f6 call 200a578 <_Thread_queue_First> 20085a4: 90 10 00 18 mov %i0, %o0 if ( !waiter ) { 20085a8: 80 a2 20 00 cmp %o0, 0 20085ac: 12 bf ff ea bne 2008554 <_CORE_RWLock_Obtain_for_reading+0x54><== NEVER TAKEN 20085b0: 80 8e a0 ff btst 0xff, %i2 the_rwlock->number_of_readers += 1; 20085b4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20085b8: 82 00 60 01 inc %g1 20085bc: c2 26 20 48 st %g1, [ %i0 + 0x48 ] _ISR_Enable( level ); 20085c0: 7f ff ea 2b call 2002e6c 20085c4: 90 10 00 11 mov %l1, %o0 executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 20085c8: c0 24 20 34 clr [ %l0 + 0x34 ] 20085cc: 81 c7 e0 08 ret 20085d0: 81 e8 00 00 restore =============================================================================== 02008658 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 2008658: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing = _Thread_Executing; 200865c: 03 00 80 6b sethi %hi(0x201ac00), %g1 * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 2008660: 7f ff e9 ff call 2002e5c 2008664: e0 00 62 b4 ld [ %g1 + 0x2b4 ], %l0 ! 201aeb4 <_Thread_Executing> 2008668: 84 10 00 08 mov %o0, %g2 if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 200866c: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 2008670: 80 a0 60 00 cmp %g1, 0 2008674: 02 80 00 2d be 2008728 <_CORE_RWLock_Release+0xd0> <== NEVER TAKEN 2008678: 80 a0 60 01 cmp %g1, 1 _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 200867c: 22 80 00 23 be,a 2008708 <_CORE_RWLock_Release+0xb0> 2008680: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 return CORE_RWLOCK_SUCCESSFUL; } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 2008684: c0 24 20 34 clr [ %l0 + 0x34 ] /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 2008688: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 200868c: 7f ff e9 f8 call 2002e6c 2008690: 90 10 00 02 mov %g2, %o0 next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 2008694: 40 00 06 42 call 2009f9c <_Thread_queue_Dequeue> 2008698: 90 10 00 18 mov %i0, %o0 if ( next ) { 200869c: 80 a2 20 00 cmp %o0, 0 20086a0: 02 80 00 18 be 2008700 <_CORE_RWLock_Release+0xa8> 20086a4: 01 00 00 00 nop if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 20086a8: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 20086ac: 80 a0 60 01 cmp %g1, 1 20086b0: 02 80 00 24 be 2008740 <_CORE_RWLock_Release+0xe8> 20086b4: 84 10 20 01 mov 1, %g2 } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 20086b8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20086bc: 82 00 60 01 inc %g1 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 20086c0: c4 26 20 44 st %g2, [ %i0 + 0x44 ] } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 20086c4: 10 80 00 0a b 20086ec <_CORE_RWLock_Release+0x94> 20086c8: c2 26 20 48 st %g1, [ %i0 + 0x48 ] /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); if ( !next || 20086cc: 80 a0 60 01 cmp %g1, 1 20086d0: 02 80 00 0c be 2008700 <_CORE_RWLock_Release+0xa8> <== NEVER TAKEN 20086d4: 92 10 00 08 mov %o0, %o1 next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 20086d8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 20086dc: 90 10 00 18 mov %i0, %o0 while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); if ( !next || next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 20086e0: 82 00 60 01 inc %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 20086e4: 40 00 07 54 call 200a434 <_Thread_queue_Extract> 20086e8: c2 26 20 48 st %g1, [ %i0 + 0x48 ] /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); 20086ec: 40 00 07 a3 call 200a578 <_Thread_queue_First> 20086f0: 90 10 00 18 mov %i0, %o0 if ( !next || 20086f4: 80 a2 20 00 cmp %o0, 0 20086f8: 32 bf ff f5 bne,a 20086cc <_CORE_RWLock_Release+0x74> 20086fc: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 2008700: 81 c7 e0 08 ret 2008704: 91 e8 20 00 restore %g0, 0, %o0 _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { the_rwlock->number_of_readers -= 1; 2008708: 82 00 7f ff add %g1, -1, %g1 if ( the_rwlock->number_of_readers != 0 ) { 200870c: 80 a0 60 00 cmp %g1, 0 2008710: 02 bf ff dd be 2008684 <_CORE_RWLock_Release+0x2c> 2008714: c2 26 20 48 st %g1, [ %i0 + 0x48 ] /* must be unlocked again */ _ISR_Enable( level ); 2008718: 7f ff e9 d5 call 2002e6c 200871c: b0 10 20 00 clr %i0 } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 2008720: 81 c7 e0 08 ret 2008724: 81 e8 00 00 restore * If any thread is waiting, then we wait. */ _ISR_Disable( level ); if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ _ISR_Enable( level ); 2008728: 7f ff e9 d1 call 2002e6c <== NOT EXECUTED 200872c: b0 10 20 00 clr %i0 <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 2008730: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2008734: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 2008738: 81 c7 e0 08 ret <== NOT EXECUTED 200873c: 81 e8 00 00 restore <== NOT EXECUTED next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); if ( next ) { if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 2008740: 82 10 20 02 mov 2, %g1 2008744: c2 26 20 44 st %g1, [ %i0 + 0x44 ] } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 2008748: 81 c7 e0 08 ret 200874c: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 02008750 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 2008750: 9d e3 bf 90 save %sp, -112, %sp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 2008754: 90 10 00 18 mov %i0, %o0 2008758: 40 00 05 25 call 2009bec <_Thread_Get> 200875c: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 2008760: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008764: 80 a0 60 00 cmp %g1, 0 2008768: 12 80 00 08 bne 2008788 <_CORE_RWLock_Timeout+0x38> <== NEVER TAKEN 200876c: 01 00 00 00 nop #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 2008770: 40 00 07 c9 call 200a694 <_Thread_queue_Process_timeout> 2008774: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2008778: 05 00 80 6b sethi %hi(0x201ac00), %g2 200877c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 201adf0 <_Thread_Dispatch_disable_level> 2008780: 82 00 7f ff add %g1, -1, %g1 2008784: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 2008788: 81 c7 e0 08 ret 200878c: 81 e8 00 00 restore =============================================================================== 02007610 <_CORE_barrier_Wait>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 2007610: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 2007614: 03 00 80 67 sethi %hi(0x2019c00), %g1 2007618: e2 00 60 34 ld [ %g1 + 0x34 ], %l1 ! 2019c34 <_Thread_Executing> Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 200761c: b4 10 00 1c mov %i4, %i2 Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 2007620: c0 24 60 34 clr [ %l1 + 0x34 ] _ISR_Disable( level ); 2007624: 7f ff ec 4f call 2002760 2007628: a0 10 00 18 mov %i0, %l0 Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 200762c: a4 10 00 19 mov %i1, %l2 Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; _ISR_Disable( level ); 2007630: 86 10 00 08 mov %o0, %g3 the_barrier->number_of_waiting_threads++; 2007634: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 if ( the_barrier->number_of_waiting_threads == 2007638: c4 06 20 44 ld [ %i0 + 0x44 ], %g2 ISR_Level level; executing = _Thread_Executing; executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; _ISR_Disable( level ); the_barrier->number_of_waiting_threads++; 200763c: 82 00 60 01 inc %g1 if ( the_barrier->number_of_waiting_threads == 2007640: 80 a0 40 02 cmp %g1, %g2 2007644: 12 80 00 06 bne 200765c <_CORE_barrier_Wait+0x4c> 2007648: c2 26 20 48 st %g1, [ %i0 + 0x48 ] the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 200764c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 2007650: 80 a0 60 00 cmp %g1, 0 2007654: 02 80 00 0d be 2007688 <_CORE_barrier_Wait+0x78> <== ALWAYS TAKEN 2007658: 82 10 20 01 mov 1, %g1 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 200765c: 82 10 20 01 mov 1, %g1 } } _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; 2007660: e4 24 60 20 st %l2, [ %l1 + 0x20 ] return; } } _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; 2007664: e0 24 60 44 st %l0, [ %l1 + 0x44 ] 2007668: c2 24 20 30 st %g1, [ %l0 + 0x30 ] executing->Wait.id = id; _ISR_Enable( level ); 200766c: 90 10 00 03 mov %g3, %o0 2007670: 7f ff ec 40 call 2002770 2007674: 35 00 80 25 sethi %hi(0x2009400), %i2 _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 2007678: b0 10 00 10 mov %l0, %i0 200767c: b2 10 00 1b mov %i3, %i1 2007680: 40 00 07 41 call 2009384 <_Thread_queue_Enqueue_with_handler> 2007684: 95 ee a3 dc restore %i2, 0x3dc, %o2 _ISR_Disable( level ); the_barrier->number_of_waiting_threads++; if ( the_barrier->number_of_waiting_threads == the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; 2007688: c2 24 60 34 st %g1, [ %l1 + 0x34 ] _ISR_Enable( level ); 200768c: 7f ff ec 39 call 2002770 2007690: 01 00 00 00 nop _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 2007694: 40 00 17 3b call 200d380 <_CORE_barrier_Release> 2007698: 81 e8 00 00 restore =============================================================================== 020127a4 <_CORE_message_queue_Broadcast>: size_t size, Objects_Id id, CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, uint32_t *count ) { 20127a4: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 20127a8: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 size_t size, Objects_Id id, CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, uint32_t *count ) { 20127ac: a4 10 00 18 mov %i0, %l2 Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 20127b0: 80 a0 40 1a cmp %g1, %i2 20127b4: 0a 80 00 17 bcs 2012810 <_CORE_message_queue_Broadcast+0x6c><== NEVER TAKEN 20127b8: b0 10 20 01 mov 1, %i0 * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 20127bc: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1 20127c0: 80 a0 60 00 cmp %g1, 0 20127c4: 02 80 00 0a be 20127ec <_CORE_message_queue_Broadcast+0x48><== ALWAYS TAKEN 20127c8: a2 10 20 00 clr %l1 *count = 0; 20127cc: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED 20127d0: 81 c7 e0 08 ret <== NOT EXECUTED 20127d4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 20127d8: d0 04 20 2c ld [ %l0 + 0x2c ], %o0 20127dc: 40 00 23 f1 call 201b7a0 20127e0: a2 04 60 01 inc %l1 buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 20127e4: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 20127e8: f4 20 40 00 st %i2, [ %g1 ] * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { 20127ec: 40 00 0a 40 call 20150ec <_Thread_queue_Dequeue> 20127f0: 90 10 00 12 mov %l2, %o0 20127f4: 92 10 00 19 mov %i1, %o1 20127f8: a0 10 00 08 mov %o0, %l0 20127fc: 80 a2 20 00 cmp %o0, 0 2012800: 12 bf ff f6 bne 20127d8 <_CORE_message_queue_Broadcast+0x34> 2012804: 94 10 00 1a mov %i2, %o2 if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 2012808: e2 27 40 00 st %l1, [ %i5 ] 201280c: b0 10 20 00 clr %i0 return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 2012810: 81 c7 e0 08 ret 2012814: 81 e8 00 00 restore =============================================================================== 02012554 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { 2012554: 9d e3 bf 98 save %sp, -104, %sp size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; the_message_queue->number_of_pending_messages = 0; 2012558: c0 26 20 48 clr [ %i0 + 0x48 ] ) { size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 201255c: f4 26 20 44 st %i2, [ %i0 + 0x44 ] the_message_queue->number_of_pending_messages = 0; the_message_queue->maximum_message_size = maximum_message_size; 2012560: f6 26 20 4c st %i3, [ %i0 + 0x4c ] CORE_message_queue_Control *the_message_queue, CORE_message_queue_Notify_Handler the_handler, void *the_argument ) { the_message_queue->notify_handler = the_handler; 2012564: c0 26 20 60 clr [ %i0 + 0x60 ] the_message_queue->notify_argument = the_argument; 2012568: c0 26 20 64 clr [ %i0 + 0x64 ] * Round size up to multiple of a pointer for chain init and * check for overflow on adding overhead to each message. */ allocated_message_size = maximum_message_size; if (allocated_message_size & (sizeof(uint32_t) - 1)) { 201256c: 80 8e e0 03 btst 3, %i3 2012570: 02 80 00 09 be 2012594 <_CORE_message_queue_Initialize+0x40> 2012574: a0 10 00 1b mov %i3, %l0 allocated_message_size += sizeof(uint32_t); 2012578: 82 06 e0 04 add %i3, 4, %g1 allocated_message_size &= ~(sizeof(uint32_t) - 1); 201257c: a0 08 7f fc and %g1, -4, %l0 } if (allocated_message_size < maximum_message_size) 2012580: 80 a6 c0 10 cmp %i3, %l0 2012584: 08 80 00 05 bleu 2012598 <_CORE_message_queue_Initialize+0x44><== ALWAYS TAKEN 2012588: b6 04 20 14 add %l0, 0x14, %i3 STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; } 201258c: 81 c7 e0 08 ret 2012590: 91 e8 20 00 restore %g0, 0, %o0 /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * 2012594: b6 04 20 14 add %l0, 0x14, %i3 2012598: 92 10 00 1a mov %i2, %o1 201259c: 40 00 29 d0 call 201ccdc <.umul> 20125a0: 90 10 00 1b mov %i3, %o0 (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 20125a4: 80 a2 00 10 cmp %o0, %l0 20125a8: 0a bf ff f9 bcs 201258c <_CORE_message_queue_Initialize+0x38><== NEVER TAKEN 20125ac: 01 00 00 00 nop return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 20125b0: 7f ff f3 80 call 200f3b0 <_Workspace_Allocate> 20125b4: 01 00 00 00 nop _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 20125b8: 80 a2 20 00 cmp %o0, 0 20125bc: 02 bf ff f4 be 201258c <_CORE_message_queue_Initialize+0x38> 20125c0: d0 26 20 5c st %o0, [ %i0 + 0x5c ] /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 20125c4: 92 10 00 08 mov %o0, %o1 20125c8: 94 10 00 1a mov %i2, %o2 20125cc: 90 06 20 68 add %i0, 0x68, %o0 20125d0: 7f ff ff 73 call 201239c <_Chain_Initialize> 20125d4: 96 10 00 1b mov %i3, %o3 allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 20125d8: c2 06 40 00 ld [ %i1 ], %g1 Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 20125dc: 84 06 20 50 add %i0, 0x50, %g2 20125e0: 82 18 60 01 xor %g1, 1, %g1 20125e4: 80 a0 00 01 cmp %g0, %g1 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 20125e8: 82 06 20 54 add %i0, 0x54, %g1 the_chain->permanent_null = NULL; 20125ec: c0 26 20 54 clr [ %i0 + 0x54 ] 20125f0: 90 10 00 18 mov %i0, %o0 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 20125f4: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 20125f8: c4 26 20 58 st %g2, [ %i0 + 0x58 ] 20125fc: 92 60 3f ff subx %g0, -1, %o1 2012600: 94 10 20 80 mov 0x80, %o2 2012604: 96 10 20 06 mov 6, %o3 2012608: 7f ff ef c6 call 200e520 <_Thread_queue_Initialize> 201260c: b0 10 20 01 mov 1, %i0 2012610: 81 c7 e0 08 ret 2012614: 81 e8 00 00 restore =============================================================================== 0200c2a0 <_CORE_message_queue_Submit>: CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 200c2a0: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 200c2a4: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 200c2a8: a2 10 00 18 mov %i0, %l1 ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 200c2ac: 80 a0 40 1a cmp %g1, %i2 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 200c2b0: e4 0f a0 5f ldub [ %fp + 0x5f ], %l2 ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 200c2b4: 0a 80 00 22 bcs 200c33c <_CORE_message_queue_Submit+0x9c> 200c2b8: b0 10 20 01 mov 1, %i0 /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 200c2bc: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 200c2c0: 80 a0 a0 00 cmp %g2, 0 200c2c4: 02 80 00 22 be 200c34c <_CORE_message_queue_Submit+0xac> 200c2c8: 01 00 00 00 nop /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 200c2cc: c2 04 60 44 ld [ %l1 + 0x44 ], %g1 200c2d0: 80 a0 40 02 cmp %g1, %g2 200c2d4: 18 80 00 2b bgu 200c380 <_CORE_message_queue_Submit+0xe0> 200c2d8: 80 a4 a0 00 cmp %l2, 0 * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { 200c2dc: 02 80 00 18 be 200c33c <_CORE_message_queue_Submit+0x9c> 200c2e0: b0 10 20 02 mov 2, %i0 /* * Do NOT block on a send if the caller is in an ISR. It is * deadly to block in an ISR. */ if ( _ISR_Is_in_progress() ) { 200c2e4: 03 00 80 8a sethi %hi(0x2022800), %g1 200c2e8: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 2022ba0 <_ISR_Nest_level> 200c2ec: 80 a0 a0 00 cmp %g2, 0 200c2f0: 32 80 00 13 bne,a 200c33c <_CORE_message_queue_Submit+0x9c><== NEVER TAKEN 200c2f4: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED * it as a variable. Doing this emphasizes how dangerous it * would be to use this variable prior to here. */ { Thread_Control *executing = _Thread_Executing; 200c2f8: 03 00 80 8a sethi %hi(0x2022800), %g1 _ISR_Disable( level ); 200c2fc: 7f ff e8 6d call 20064b0 200c300: e0 00 63 c4 ld [ %g1 + 0x3c4 ], %l0 ! 2022bc4 <_Thread_Executing> 200c304: 82 10 20 01 mov 1, %g1 200c308: c2 24 60 30 st %g1, [ %l1 + 0x30 ] _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; executing->Wait.id = id; executing->Wait.return_argument_second.immutable_object = buffer; executing->Wait.option = (uint32_t) size; executing->Wait.count = submit_type; 200c30c: fa 24 20 24 st %i5, [ %l0 + 0x24 ] Thread_Control *executing = _Thread_Executing; _ISR_Disable( level ); _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; executing->Wait.id = id; 200c310: f6 24 20 20 st %i3, [ %l0 + 0x20 ] executing->Wait.return_argument_second.immutable_object = buffer; 200c314: f2 24 20 2c st %i1, [ %l0 + 0x2c ] executing->Wait.option = (uint32_t) size; 200c318: f4 24 20 30 st %i2, [ %l0 + 0x30 ] { Thread_Control *executing = _Thread_Executing; _ISR_Disable( level ); _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 200c31c: e2 24 20 44 st %l1, [ %l0 + 0x44 ] executing->Wait.id = id; executing->Wait.return_argument_second.immutable_object = buffer; executing->Wait.option = (uint32_t) size; executing->Wait.count = submit_type; _ISR_Enable( level ); 200c320: 7f ff e8 68 call 20064c0 200c324: b0 10 20 07 mov 7, %i0 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 200c328: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 200c32c: 90 10 00 11 mov %l1, %o0 200c330: 15 00 80 39 sethi %hi(0x200e400), %o2 200c334: 40 00 07 a4 call 200e1c4 <_Thread_queue_Enqueue_with_handler> 200c338: 94 12 a2 1c or %o2, 0x21c, %o2 ! 200e61c <_Thread_queue_Timeout> 200c33c: 81 c7 e0 08 ret 200c340: 81 e8 00 00 restore } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 200c344: 81 c7 e0 08 ret <== NOT EXECUTED 200c348: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 200c34c: 40 00 07 3a call 200e034 <_Thread_queue_Dequeue> 200c350: 90 10 00 11 mov %l1, %o0 if ( the_thread ) { 200c354: a0 92 20 00 orcc %o0, 0, %l0 200c358: 02 80 00 1b be 200c3c4 <_CORE_message_queue_Submit+0x124> 200c35c: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 200c360: d0 04 20 2c ld [ %l0 + 0x2c ], %o0 200c364: 40 00 22 07 call 2014b80 200c368: 94 10 00 1a mov %i2, %o2 _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 200c36c: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 the_thread->Wait.count = submit_type; 200c370: fa 24 20 24 st %i5, [ %l0 + 0x24 ] _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 200c374: f4 20 40 00 st %i2, [ %g1 ] the_thread->Wait.count = submit_type; 200c378: 81 c7 e0 08 ret 200c37c: 91 e8 20 00 restore %g0, 0, %o0 RTEMS_INLINE_ROUTINE CORE_message_queue_Buffer_control * _CORE_message_queue_Allocate_message_buffer ( CORE_message_queue_Control *the_message_queue ) { return (CORE_message_queue_Buffer_control *) 200c380: 40 00 17 f4 call 2012350 <_Chain_Get> 200c384: 90 04 60 68 add %l1, 0x68, %o0 /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 200c388: a0 92 20 00 orcc %o0, 0, %l0 200c38c: 02 bf ff ee be 200c344 <_CORE_message_queue_Submit+0xa4> <== NEVER TAKEN 200c390: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 200c394: 94 10 00 1a mov %i2, %o2 200c398: 40 00 21 fa call 2014b80 200c39c: 90 04 20 10 add %l0, 0x10, %o0 size ); the_message->Contents.size = size; the_message->priority = submit_type; _CORE_message_queue_Insert_message( 200c3a0: 90 10 00 11 mov %l1, %o0 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 200c3a4: f4 24 20 0c st %i2, [ %l0 + 0xc ] the_message->priority = submit_type; 200c3a8: fa 24 20 08 st %i5, [ %l0 + 8 ] _CORE_message_queue_Insert_message( 200c3ac: 92 10 00 10 mov %l0, %o1 200c3b0: 94 10 00 1d mov %i5, %o2 200c3b4: 40 00 18 12 call 20123fc <_CORE_message_queue_Insert_message> 200c3b8: b0 10 20 00 clr %i0 200c3bc: 81 c7 e0 08 ret 200c3c0: 81 e8 00 00 restore * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); if ( the_thread ) { 200c3c4: 10 bf ff c2 b 200c2cc <_CORE_message_queue_Submit+0x2c> 200c3c8: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 =============================================================================== 020063fc <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 20063fc: 9d e3 bf 98 save %sp, -104, %sp /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006400: c2 06 40 00 ld [ %i1 ], %g1 CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 2006404: 90 10 00 18 mov %i0, %o0 /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006408: c2 26 20 40 st %g1, [ %i0 + 0x40 ] 200640c: c4 06 60 04 ld [ %i1 + 4 ], %g2 the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 2006410: 80 a6 a0 00 cmp %i2, 0 /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006414: c4 26 20 44 st %g2, [ %i0 + 0x44 ] 2006418: c6 06 60 08 ld [ %i1 + 8 ], %g3 200641c: c6 26 20 48 st %g3, [ %i0 + 0x48 ] 2006420: c2 06 60 0c ld [ %i1 + 0xc ], %g1 the_mutex->lock = initial_lock; 2006424: f4 26 20 50 st %i2, [ %i0 + 0x50 ] /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006428: c2 26 20 4c st %g1, [ %i0 + 0x4c ] the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 200642c: 12 80 00 1f bne 20064a8 <_CORE_mutex_Initialize+0xac> 2006430: c0 26 20 58 clr [ %i0 + 0x58 ] the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; 2006434: 03 00 80 60 sethi %hi(0x2018000), %g1 2006438: c8 00 63 d4 ld [ %g1 + 0x3d4 ], %g4 ! 20183d4 <_Thread_Executing> the_mutex->Attributes = *the_mutex_attributes; the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; 200643c: 84 10 20 01 mov 1, %g2 2006440: c4 26 20 54 st %g2, [ %i0 + 0x54 ] the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; 2006444: c2 01 20 08 ld [ %g4 + 8 ], %g1 the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; 2006448: c8 26 20 5c st %g4, [ %i0 + 0x5c ] the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200644c: 80 a0 e0 02 cmp %g3, 2 2006450: 02 80 00 05 be 2006464 <_CORE_mutex_Initialize+0x68> 2006454: c2 26 20 60 st %g1, [ %i0 + 0x60 ] 2006458: 80 a0 e0 03 cmp %g3, 3 200645c: 32 80 00 17 bne,a 20064b8 <_CORE_mutex_Initialize+0xbc> <== ALWAYS TAKEN 2006460: c2 06 60 08 ld [ %i1 + 8 ], %g1 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 2006464: c4 01 20 14 ld [ %g4 + 0x14 ], %g2 2006468: c2 02 20 4c ld [ %o0 + 0x4c ], %g1 200646c: 80 a0 80 01 cmp %g2, %g1 2006470: 0a 80 00 0c bcs 20064a0 <_CORE_mutex_Initialize+0xa4> <== NEVER TAKEN 2006474: b0 10 20 06 mov 6, %i0 _Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = _Thread_Executing->current_priority; #endif _Thread_Executing->resource_count++; 2006478: c2 01 20 1c ld [ %g4 + 0x1c ], %g1 the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 200647c: 94 10 24 00 mov 0x400, %o2 _Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = _Thread_Executing->current_priority; #endif _Thread_Executing->resource_count++; 2006480: 82 00 60 01 inc %g1 2006484: c2 21 20 1c st %g1, [ %g4 + 0x1c ] the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 2006488: c2 06 60 08 ld [ %i1 + 8 ], %g1 200648c: 96 10 20 05 mov 5, %o3 2006490: 80 a0 00 01 cmp %g0, %g1 2006494: b0 10 20 00 clr %i0 2006498: 40 00 08 13 call 20084e4 <_Thread_queue_Initialize> 200649c: 92 40 20 00 addx %g0, 0, %o1 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 20064a0: 81 c7 e0 08 ret 20064a4: 81 e8 00 00 restore #endif _Thread_Executing->resource_count++; } } else { the_mutex->nest_count = 0; 20064a8: c0 26 20 54 clr [ %i0 + 0x54 ] the_mutex->holder = NULL; 20064ac: c0 26 20 5c clr [ %i0 + 0x5c ] the_mutex->holder_id = 0; 20064b0: c0 26 20 60 clr [ %i0 + 0x60 ] } _Thread_queue_Initialize( 20064b4: c2 06 60 08 ld [ %i1 + 8 ], %g1 20064b8: 94 10 24 00 mov 0x400, %o2 20064bc: 80 a0 00 01 cmp %g0, %g1 20064c0: 96 10 20 05 mov 5, %o3 20064c4: 92 40 20 00 addx %g0, 0, %o1 20064c8: 40 00 08 07 call 20084e4 <_Thread_queue_Initialize> 20064cc: b0 10 20 00 clr %i0 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 20064d0: 81 c7 e0 08 ret 20064d4: 81 e8 00 00 restore =============================================================================== 02006564 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 2006564: 9d e3 bf 98 save %sp, -104, %sp _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 2006568: 21 00 80 60 sethi %hi(0x2018000), %l0 200656c: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 ! 2018310 <_Thread_Dispatch_disable_level> 2006570: 80 a0 60 00 cmp %g1, 0 2006574: 02 80 00 05 be 2006588 <_CORE_mutex_Seize+0x24> 2006578: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 200657c: 80 8e a0 ff btst 0xff, %i2 2006580: 12 80 00 1a bne 20065e8 <_CORE_mutex_Seize+0x84> <== ALWAYS TAKEN 2006584: 03 00 80 61 sethi %hi(0x2018400), %g1 2006588: 90 10 00 18 mov %i0, %o0 200658c: 40 00 16 c8 call 200c0ac <_CORE_mutex_Seize_interrupt_trylock> 2006590: 92 07 a0 54 add %fp, 0x54, %o1 2006594: 80 a2 20 00 cmp %o0, 0 2006598: 02 80 00 12 be 20065e0 <_CORE_mutex_Seize+0x7c> 200659c: 80 8e a0 ff btst 0xff, %i2 20065a0: 02 80 00 1a be 2006608 <_CORE_mutex_Seize+0xa4> 20065a4: 01 00 00 00 nop 20065a8: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 20065ac: 05 00 80 60 sethi %hi(0x2018000), %g2 20065b0: c6 00 a3 d4 ld [ %g2 + 0x3d4 ], %g3 ! 20183d4 <_Thread_Executing> 20065b4: 82 00 60 01 inc %g1 20065b8: f2 20 e0 20 st %i1, [ %g3 + 0x20 ] 20065bc: c2 24 23 10 st %g1, [ %l0 + 0x310 ] 20065c0: f0 20 e0 44 st %i0, [ %g3 + 0x44 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 20065c4: 82 10 20 01 mov 1, %g1 20065c8: c2 26 20 30 st %g1, [ %i0 + 0x30 ] 20065cc: 7f ff ee 0a call 2001df4 20065d0: d0 07 a0 54 ld [ %fp + 0x54 ], %o0 20065d4: 90 10 00 18 mov %i0, %o0 20065d8: 7f ff ff c0 call 20064d8 <_CORE_mutex_Seize_interrupt_blocking> 20065dc: 92 10 00 1b mov %i3, %o1 20065e0: 81 c7 e0 08 ret 20065e4: 81 e8 00 00 restore 20065e8: c4 00 60 b4 ld [ %g1 + 0xb4 ], %g2 20065ec: 80 a0 a0 01 cmp %g2, 1 20065f0: 28 bf ff e7 bleu,a 200658c <_CORE_mutex_Seize+0x28> 20065f4: 90 10 00 18 mov %i0, %o0 20065f8: 90 10 20 00 clr %o0 20065fc: 92 10 20 00 clr %o1 2006600: 40 00 01 69 call 2006ba4 <_Internal_error_Occurred> 2006604: 94 10 20 13 mov 0x13, %o2 2006608: 7f ff ed fb call 2001df4 200660c: d0 07 a0 54 ld [ %fp + 0x54 ], %o0 2006610: 03 00 80 60 sethi %hi(0x2018000), %g1 2006614: c6 00 63 d4 ld [ %g1 + 0x3d4 ], %g3 ! 20183d4 <_Thread_Executing> 2006618: 84 10 20 01 mov 1, %g2 200661c: c4 20 e0 34 st %g2, [ %g3 + 0x34 ] 2006620: 81 c7 e0 08 ret 2006624: 81 e8 00 00 restore =============================================================================== 0200c0ac <_CORE_mutex_Seize_interrupt_trylock>: #if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__) int _CORE_mutex_Seize_interrupt_trylock( CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { 200c0ac: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200c0b0: 03 00 80 60 sethi %hi(0x2018000), %g1 200c0b4: c6 00 63 d4 ld [ %g1 + 0x3d4 ], %g3 ! 20183d4 <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 200c0b8: d0 06 40 00 ld [ %i1 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200c0bc: c0 20 e0 34 clr [ %g3 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200c0c0: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 200c0c4: 80 a0 60 00 cmp %g1, 0 200c0c8: 22 80 00 12 be,a 200c110 <_CORE_mutex_Seize_interrupt_trylock+0x64> 200c0cc: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 200c0d0: c0 26 20 50 clr [ %i0 + 0x50 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200c0d4: c2 00 e0 08 ld [ %g3 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 200c0d8: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200c0dc: c2 26 20 60 st %g1, [ %i0 + 0x60 ] executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; 200c0e0: c6 26 20 5c st %g3, [ %i0 + 0x5c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 200c0e4: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200c0e8: 80 a0 a0 02 cmp %g2, 2 200c0ec: 02 80 00 0e be 200c124 <_CORE_mutex_Seize_interrupt_trylock+0x78> 200c0f0: c2 26 20 54 st %g1, [ %i0 + 0x54 ] 200c0f4: 80 a0 a0 03 cmp %g2, 3 200c0f8: 22 80 00 0d be,a 200c12c <_CORE_mutex_Seize_interrupt_trylock+0x80> 200c0fc: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 executing->resource_count++; } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 200c100: 7f ff d7 3d call 2001df4 200c104: b0 10 20 00 clr %i0 200c108: 81 c7 e0 08 ret 200c10c: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 200c110: 80 a0 c0 01 cmp %g3, %g1 200c114: 22 80 00 2a be,a 200c1bc <_CORE_mutex_Seize_interrupt_trylock+0x110> 200c118: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 200c11c: 81 c7 e0 08 ret 200c120: 91 e8 20 01 restore %g0, 1, %o0 _Chain_Prepend_unprotected( &executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = executing->current_priority; #endif executing->resource_count++; 200c124: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200c128: 80 a0 a0 03 cmp %g2, 3 _Chain_Prepend_unprotected( &executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = executing->current_priority; #endif executing->resource_count++; 200c12c: 82 00 60 01 inc %g1 } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200c130: 12 bf ff f4 bne 200c100 <_CORE_mutex_Seize_interrupt_trylock+0x54> 200c134: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 200c138: c4 06 20 4c ld [ %i0 + 0x4c ], %g2 current = executing->current_priority; 200c13c: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 if ( current == ceiling ) { 200c140: 80 a0 80 01 cmp %g2, %g1 200c144: 02 80 00 2f be 200c200 <_CORE_mutex_Seize_interrupt_trylock+0x154><== NEVER TAKEN 200c148: 01 00 00 00 nop _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 200c14c: 1a 80 00 11 bcc 200c190 <_CORE_mutex_Seize_interrupt_trylock+0xe4> 200c150: 82 10 20 06 mov 6, %g1 ! 6 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200c154: 05 00 80 60 sethi %hi(0x2018000), %g2 200c158: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2018310 <_Thread_Dispatch_disable_level> 200c15c: 82 00 60 01 inc %g1 200c160: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] _Thread_Disable_dispatch(); _ISR_Enable( level ); 200c164: 7f ff d7 24 call 2001df4 200c168: 01 00 00 00 nop _Thread_Change_priority( 200c16c: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 200c170: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 200c174: 94 10 20 00 clr %o2 200c178: 7f ff ed 10 call 20075b8 <_Thread_Change_priority> 200c17c: b0 10 20 00 clr %i0 the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 200c180: 7f ff ee a4 call 2007c10 <_Thread_Enable_dispatch> 200c184: 01 00 00 00 nop 200c188: 81 c7 e0 08 ret 200c18c: 81 e8 00 00 restore return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200c190: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] the_mutex->lock = CORE_MUTEX_UNLOCKED; the_mutex->nest_count = 0; /* undo locking above */ 200c194: c0 26 20 54 clr [ %i0 + 0x54 ] _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 200c198: 84 10 20 01 mov 1, %g2 200c19c: c4 26 20 50 st %g2, [ %i0 + 0x50 ] the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 200c1a0: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 200c1a4: 82 00 7f ff add %g1, -1, %g1 200c1a8: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] _ISR_Enable( level ); 200c1ac: 7f ff d7 12 call 2001df4 200c1b0: b0 10 20 00 clr %i0 200c1b4: 81 c7 e0 08 ret 200c1b8: 81 e8 00 00 restore * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200c1bc: 80 a0 60 00 cmp %g1, 0 200c1c0: 22 80 00 0a be,a 200c1e8 <_CORE_mutex_Seize_interrupt_trylock+0x13c> 200c1c4: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 200c1c8: 80 a0 60 01 cmp %g1, 1 200c1cc: 12 bf ff d4 bne 200c11c <_CORE_mutex_Seize_interrupt_trylock+0x70> 200c1d0: 82 10 20 02 mov 2, %g1 case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200c1d4: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] _ISR_Enable( level ); 200c1d8: 7f ff d7 07 call 2001df4 200c1dc: b0 10 20 00 clr %i0 200c1e0: 81 c7 e0 08 ret 200c1e4: 81 e8 00 00 restore * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 200c1e8: 82 00 60 01 inc %g1 200c1ec: c2 26 20 54 st %g1, [ %i0 + 0x54 ] _ISR_Enable( level ); 200c1f0: 7f ff d7 01 call 2001df4 200c1f4: b0 10 20 00 clr %i0 200c1f8: 81 c7 e0 08 ret 200c1fc: 81 e8 00 00 restore Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 200c200: 7f ff d6 fd call 2001df4 <== NOT EXECUTED 200c204: b0 10 20 00 clr %i0 <== NOT EXECUTED 200c208: 81 c7 e0 08 ret <== NOT EXECUTED 200c20c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02006628 <_CORE_mutex_Surrender>: CORE_mutex_Status _CORE_mutex_Surrender( CORE_mutex_Control *the_mutex, Objects_Id id, CORE_mutex_API_mp_support_callout api_mutex_mp_support ) { 2006628: 9d e3 bf 98 save %sp, -104, %sp * allowed when the mutex in quetion is FIFO or simple Priority * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) { 200662c: c2 0e 20 44 ldub [ %i0 + 0x44 ], %g1 CORE_mutex_Status _CORE_mutex_Surrender( CORE_mutex_Control *the_mutex, Objects_Id id, CORE_mutex_API_mp_support_callout api_mutex_mp_support ) { 2006630: a0 10 00 18 mov %i0, %l0 * allowed when the mutex in quetion is FIFO or simple Priority * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) { 2006634: 80 a0 60 00 cmp %g1, 0 2006638: 02 80 00 07 be 2006654 <_CORE_mutex_Surrender+0x2c> 200663c: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 if ( !_Thread_Is_executing( holder ) ) 2006640: 03 00 80 60 sethi %hi(0x2018000), %g1 2006644: c4 00 63 d4 ld [ %g1 + 0x3d4 ], %g2 ! 20183d4 <_Thread_Executing> 2006648: 80 a2 00 02 cmp %o0, %g2 200664c: 12 80 00 2e bne 2006704 <_CORE_mutex_Surrender+0xdc> 2006650: b0 10 20 03 mov 3, %i0 return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 2006654: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 2006658: 80 a0 60 00 cmp %g1, 0 200665c: 02 80 00 22 be 20066e4 <_CORE_mutex_Surrender+0xbc> 2006660: 82 00 7f ff add %g1, -1, %g1 return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; if ( the_mutex->nest_count != 0 ) { 2006664: 80 a0 60 00 cmp %g1, 0 2006668: 12 80 00 21 bne 20066ec <_CORE_mutex_Surrender+0xc4> 200666c: c2 24 20 54 st %g1, [ %l0 + 0x54 ] */ RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 2006670: c4 04 20 48 ld [ %l0 + 0x48 ], %g2 /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2006674: 80 a0 a0 02 cmp %g2, 2 2006678: 02 80 00 31 be 200673c <_CORE_mutex_Surrender+0x114> 200667c: 80 a0 a0 03 cmp %g2, 3 2006680: 22 80 00 30 be,a 2006740 <_CORE_mutex_Surrender+0x118> 2006684: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; } the_mutex->holder = NULL; 2006688: c0 24 20 5c clr [ %l0 + 0x5c ] /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200668c: 80 a0 a0 02 cmp %g2, 2 2006690: 02 80 00 1f be 200670c <_CORE_mutex_Surrender+0xe4> 2006694: c0 24 20 60 clr [ %l0 + 0x60 ] 2006698: 80 a0 a0 03 cmp %g2, 3 200669c: 22 80 00 1d be,a 2006710 <_CORE_mutex_Surrender+0xe8> 20066a0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 /* * Now we check if another thread was waiting for this mutex. If so, * transfer the mutex to that thread. */ if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) { 20066a4: 40 00 06 55 call 2007ff8 <_Thread_queue_Dequeue> 20066a8: 90 10 00 10 mov %l0, %o0 20066ac: 86 92 20 00 orcc %o0, 0, %g3 20066b0: 02 80 00 37 be 200678c <_CORE_mutex_Surrender+0x164> 20066b4: 82 10 20 01 mov 1, %g1 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 20066b8: c2 00 e0 08 ld [ %g3 + 8 ], %g1 the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 20066bc: c4 04 20 48 ld [ %l0 + 0x48 ], %g2 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 20066c0: c2 24 20 60 st %g1, [ %l0 + 0x60 ] } else #endif { the_mutex->holder = the_thread; 20066c4: c6 24 20 5c st %g3, [ %l0 + 0x5c ] the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; 20066c8: 82 10 20 01 mov 1, %g1 switch ( the_mutex->Attributes.discipline ) { 20066cc: 80 a0 a0 02 cmp %g2, 2 20066d0: 02 80 00 2a be 2006778 <_CORE_mutex_Surrender+0x150> 20066d4: c2 24 20 54 st %g1, [ %l0 + 0x54 ] 20066d8: 80 a0 a0 03 cmp %g2, 3 20066dc: 22 80 00 1c be,a 200674c <_CORE_mutex_Surrender+0x124> 20066e0: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 20066e4: 81 c7 e0 08 ret 20066e8: 91 e8 20 00 restore %g0, 0, %o0 return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; if ( the_mutex->nest_count != 0 ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20066ec: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 20066f0: 80 a0 60 00 cmp %g1, 0 20066f4: 02 bf ff fc be 20066e4 <_CORE_mutex_Surrender+0xbc> <== ALWAYS TAKEN 20066f8: 80 a0 60 01 cmp %g1, 1 20066fc: 12 bf ff dd bne 2006670 <_CORE_mutex_Surrender+0x48> <== NOT EXECUTED 2006700: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 2006704: 81 c7 e0 08 ret 2006708: 81 e8 00 00 restore _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { #ifdef __RTEMS_STRICT_ORDER_MUTEX__ if(the_mutex->queue.priority_before != holder->current_priority) _Thread_Change_priority(holder,the_mutex->queue.priority_before,TRUE); #endif if ( holder->resource_count == 0 && 200670c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006710: 80 a0 60 00 cmp %g1, 0 2006714: 12 bf ff e4 bne 20066a4 <_CORE_mutex_Surrender+0x7c> 2006718: 01 00 00 00 nop 200671c: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 2006720: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2006724: 80 a2 40 01 cmp %o1, %g1 2006728: 02 bf ff df be 20066a4 <_CORE_mutex_Surrender+0x7c> 200672c: 01 00 00 00 nop holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 2006730: 40 00 03 a2 call 20075b8 <_Thread_Change_priority> 2006734: 94 10 20 01 mov 1, %o2 ! 1 2006738: 30 bf ff db b,a 20066a4 <_CORE_mutex_Surrender+0x7c> the_mutex->nest_count++; return CORE_MUTEX_RELEASE_NOT_ORDER; } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; 200673c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006740: 82 00 7f ff add %g1, -1, %g1 2006744: 10 bf ff d1 b 2006688 <_CORE_mutex_Surrender+0x60> 2006748: c2 22 20 1c st %g1, [ %o0 + 0x1c ] #ifdef __RTEMS_STRICT_ORDER_MUTEX__ _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue); the_mutex->queue.priority_before = the_thread->current_priority; #endif the_thread->resource_count++; if (the_mutex->Attributes.priority_ceiling < 200674c: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2 case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: #ifdef __RTEMS_STRICT_ORDER_MUTEX__ _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue); the_mutex->queue.priority_before = the_thread->current_priority; #endif the_thread->resource_count++; 2006750: 82 00 60 01 inc %g1 2006754: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if (the_mutex->Attributes.priority_ceiling < 2006758: d2 04 20 4c ld [ %l0 + 0x4c ], %o1 200675c: 80 a2 40 02 cmp %o1, %g2 2006760: 1a bf ff e1 bcc 20066e4 <_CORE_mutex_Surrender+0xbc> <== NEVER TAKEN 2006764: 94 10 20 00 clr %o2 the_thread->current_priority){ _Thread_Change_priority( 2006768: 40 00 03 94 call 20075b8 <_Thread_Change_priority> 200676c: b0 10 20 00 clr %i0 2006770: 81 c7 e0 08 ret 2006774: 81 e8 00 00 restore case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: #ifdef __RTEMS_STRICT_ORDER_MUTEX__ _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue); the_mutex->queue.priority_before = the_thread->current_priority; #endif the_thread->resource_count++; 2006778: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 200677c: 82 00 60 01 inc %g1 2006780: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] 2006784: 81 c7 e0 08 ret 2006788: 91 e8 20 00 restore %g0, 0, %o0 } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 200678c: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 2006790: 81 c7 e0 08 ret 2006794: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 020067e4 <_CORE_semaphore_Surrender>: CORE_semaphore_Status _CORE_semaphore_Surrender( CORE_semaphore_Control *the_semaphore, Objects_Id id, CORE_semaphore_API_mp_support_callout api_semaphore_mp_support ) { 20067e4: 9d e3 bf 98 save %sp, -104, %sp 20067e8: a0 10 00 18 mov %i0, %l0 ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 20067ec: b0 10 20 00 clr %i0 20067f0: 40 00 06 02 call 2007ff8 <_Thread_queue_Dequeue> 20067f4: 90 10 00 10 mov %l0, %o0 20067f8: 80 a2 20 00 cmp %o0, 0 20067fc: 02 80 00 04 be 200680c <_CORE_semaphore_Surrender+0x28> 2006800: 01 00 00 00 nop status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 2006804: 81 c7 e0 08 ret 2006808: 81 e8 00 00 restore if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 200680c: 7f ff ed 76 call 2001de4 2006810: 01 00 00 00 nop if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 2006814: c4 04 20 48 ld [ %l0 + 0x48 ], %g2 2006818: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 200681c: 80 a0 80 01 cmp %g2, %g1 2006820: 0a 80 00 06 bcs 2006838 <_CORE_semaphore_Surrender+0x54> <== ALWAYS TAKEN 2006824: b0 10 20 04 mov 4, %i0 the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 2006828: 7f ff ed 73 call 2001df4 200682c: 01 00 00 00 nop } return status; } 2006830: 81 c7 e0 08 ret 2006834: 81 e8 00 00 restore #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 2006838: 82 00 a0 01 add %g2, 1, %g1 200683c: b0 10 20 00 clr %i0 2006840: 10 bf ff fa b 2006828 <_CORE_semaphore_Surrender+0x44> 2006844: c2 24 20 48 st %g1, [ %l0 + 0x48 ] =============================================================================== 020071c8 <_CORE_spinlock_Release>: */ CORE_spinlock_Status _CORE_spinlock_Release( CORE_spinlock_Control *the_spinlock ) { 20071c8: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 20071cc: 7f ff ec dd call 2002540 20071d0: 01 00 00 00 nop /* * It must locked before it can be unlocked. */ if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 20071d4: c2 06 20 04 ld [ %i0 + 4 ], %g1 20071d8: 80 a0 60 00 cmp %g1, 0 20071dc: 02 80 00 0c be 200720c <_CORE_spinlock_Release+0x44> 20071e0: 03 00 80 50 sethi %hi(0x2014000), %g1 } /* * It must locked by the current thread before it can be unlocked. */ if ( the_spinlock->holder != _Thread_Executing->Object.id ) { 20071e4: c4 00 62 74 ld [ %g1 + 0x274 ], %g2 ! 2014274 <_Thread_Executing> 20071e8: c6 06 20 0c ld [ %i0 + 0xc ], %g3 20071ec: c2 00 a0 08 ld [ %g2 + 8 ], %g1 20071f0: 80 a0 c0 01 cmp %g3, %g1 20071f4: 02 80 00 0a be 200721c <_CORE_spinlock_Release+0x54> <== ALWAYS TAKEN 20071f8: 01 00 00 00 nop _ISR_Enable( level ); 20071fc: 7f ff ec d5 call 2002550 <== NOT EXECUTED 2007200: b0 10 20 02 mov 2, %i0 ! 2 <== NOT EXECUTED 2007204: 81 c7 e0 08 ret <== NOT EXECUTED 2007208: 81 e8 00 00 restore <== NOT EXECUTED /* * It must locked before it can be unlocked. */ if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { _ISR_Enable( level ); 200720c: 7f ff ec d1 call 2002550 2007210: b0 10 20 06 mov 6, %i0 2007214: 81 c7 e0 08 ret 2007218: 81 e8 00 00 restore } /* * Let it be unlocked. */ the_spinlock->users -= 1; 200721c: c2 06 20 08 ld [ %i0 + 8 ], %g1 2007220: 82 00 7f ff add %g1, -1, %g1 2007224: c2 26 20 08 st %g1, [ %i0 + 8 ] the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; 2007228: c0 26 20 04 clr [ %i0 + 4 ] the_spinlock->holder = 0; 200722c: c0 26 20 0c clr [ %i0 + 0xc ] _ISR_Enable( level ); 2007230: 7f ff ec c8 call 2002550 2007234: b0 10 20 00 clr %i0 return CORE_SPINLOCK_SUCCESSFUL; } 2007238: 81 c7 e0 08 ret 200723c: 81 e8 00 00 restore =============================================================================== 02007240 <_CORE_spinlock_Wait>: CORE_spinlock_Status _CORE_spinlock_Wait( CORE_spinlock_Control *the_spinlock, bool wait, Watchdog_Interval timeout ) { 2007240: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; 2007244: 05 00 80 50 sethi %hi(0x2014000), %g2 2007248: c2 00 a3 04 ld [ %g2 + 0x304 ], %g1 ! 2014304 <_Watchdog_Ticks_since_boot> 200724c: a2 10 a3 04 or %g2, 0x304, %l1 _ISR_Disable( level ); 2007250: 7f ff ec bc call 2002540 2007254: a0 06 80 01 add %i2, %g1, %l0 2007258: 88 10 00 08 mov %o0, %g4 if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 200725c: c2 06 20 04 ld [ %i0 + 4 ], %g1 2007260: 80 a0 60 01 cmp %g1, 1 2007264: 02 80 00 34 be 2007334 <_CORE_spinlock_Wait+0xf4> 2007268: 03 00 80 50 sethi %hi(0x2014000), %g1 (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 200726c: c2 06 20 08 ld [ %i0 + 8 ], %g1 2007270: 82 00 60 01 inc %g1 2007274: c2 26 20 08 st %g1, [ %i0 + 8 ] for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 2007278: c4 06 20 04 ld [ %i0 + 4 ], %g2 200727c: 80 a0 a0 00 cmp %g2, 0 2007280: 02 80 00 1a be 20072e8 <_CORE_spinlock_Wait+0xa8> 2007284: 80 8e 60 ff btst 0xff, %i1 2007288: 03 00 80 50 sethi %hi(0x2014000), %g1 } /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { 200728c: 02 80 00 22 be 2007314 <_CORE_spinlock_Wait+0xd4> <== NEVER TAKEN 2007290: b2 10 61 b0 or %g1, 0x1b0, %i1 ! 20141b0 <_Thread_Dispatch_disable_level> } /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { 2007294: 80 a6 a0 00 cmp %i2, 0 2007298: 02 80 00 06 be 20072b0 <_CORE_spinlock_Wait+0x70> <== ALWAYS TAKEN 200729c: 01 00 00 00 nop 20072a0: c2 04 40 00 ld [ %l1 ], %g1 <== NOT EXECUTED 20072a4: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 20072a8: 08 80 00 2d bleu 200735c <_CORE_spinlock_Wait+0x11c> <== NOT EXECUTED 20072ac: 01 00 00 00 nop <== NOT EXECUTED * * A spinlock cannot be deleted while it is being used so we are * safe from deletion. */ _ISR_Enable( level ); 20072b0: 7f ff ec a8 call 2002550 20072b4: 90 10 00 04 mov %g4, %o0 /* An ISR could occur here */ _Thread_Enable_dispatch(); 20072b8: 40 00 04 f5 call 200868c <_Thread_Enable_dispatch> 20072bc: 01 00 00 00 nop 20072c0: c2 06 40 00 ld [ %i1 ], %g1 20072c4: 82 00 60 01 inc %g1 20072c8: c2 26 40 00 st %g1, [ %i1 ] /* Another thread could get dispatched here */ /* Reenter the critical sections so we can attempt the lock again. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 20072cc: 7f ff ec 9d call 2002540 20072d0: 01 00 00 00 nop 20072d4: 88 10 00 08 mov %o0, %g4 _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 20072d8: c2 06 20 04 ld [ %i0 + 4 ], %g1 20072dc: 80 a0 60 00 cmp %g1, 0 20072e0: 12 bf ff ee bne 2007298 <_CORE_spinlock_Wait+0x58> 20072e4: 80 a6 a0 00 cmp %i2, 0 the_spinlock->lock = CORE_SPINLOCK_LOCKED; the_spinlock->holder = _Thread_Executing->Object.id; 20072e8: 03 00 80 50 sethi %hi(0x2014000), %g1 20072ec: c6 00 62 74 ld [ %g1 + 0x274 ], %g3 ! 2014274 <_Thread_Executing> return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { the_spinlock->lock = CORE_SPINLOCK_LOCKED; 20072f0: 84 10 20 01 mov 1, %g2 20072f4: c4 26 20 04 st %g2, [ %i0 + 4 ] the_spinlock->holder = _Thread_Executing->Object.id; 20072f8: c2 00 e0 08 ld [ %g3 + 8 ], %g1 20072fc: c2 26 20 0c st %g1, [ %i0 + 0xc ] _ISR_Enable( level ); 2007300: b0 10 20 00 clr %i0 2007304: 7f ff ec 93 call 2002550 2007308: 90 10 00 04 mov %g4, %o0 200730c: 81 c7 e0 08 ret 2007310: 81 e8 00 00 restore /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { the_spinlock->users -= 1; 2007314: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 2007318: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200731c: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 2007320: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 2007324: 7f ff ec 8b call 2002550 <== NOT EXECUTED 2007328: 90 10 00 04 mov %g4, %o0 <== NOT EXECUTED 200732c: 81 c7 e0 08 ret <== NOT EXECUTED 2007330: 81 e8 00 00 restore <== NOT EXECUTED { ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; _ISR_Disable( level ); if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 2007334: c4 00 62 74 ld [ %g1 + 0x274 ], %g2 2007338: c6 06 20 0c ld [ %i0 + 0xc ], %g3 200733c: c2 00 a0 08 ld [ %g2 + 8 ], %g1 2007340: 80 a0 c0 01 cmp %g3, %g1 2007344: 12 bf ff ca bne 200726c <_CORE_spinlock_Wait+0x2c> 2007348: 01 00 00 00 nop (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); 200734c: 7f ff ec 81 call 2002550 2007350: b0 10 20 01 mov 1, %i0 ! 1 2007354: 81 c7 e0 08 ret 2007358: 81 e8 00 00 restore /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { the_spinlock->users -= 1; 200735c: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 2007360: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2007364: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 2007368: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED 200736c: 7f ff ec 79 call 2002550 <== NOT EXECUTED 2007370: 90 10 00 04 mov %g4, %o0 <== NOT EXECUTED 2007374: 81 c7 e0 08 ret <== NOT EXECUTED 2007378: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 0200c04c <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 200c04c: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *current; Chain_Node *next; count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; 200c050: c0 26 20 04 clr [ %i0 + 4 ] Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 200c054: 90 10 00 1b mov %i3, %o0 count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; next = starting_address; while ( count-- ) { 200c058: 80 a6 a0 00 cmp %i2, 0 200c05c: 02 80 00 0f be 200c098 <_Chain_Initialize+0x4c> <== NEVER TAKEN 200c060: 84 10 00 18 mov %i0, %g2 200c064: b4 06 bf ff add %i2, -1, %i2 200c068: 82 10 00 19 mov %i1, %g1 200c06c: 92 10 00 1a mov %i2, %o1 current->next = next; next->previous = current; 200c070: c4 20 60 04 st %g2, [ %g1 + 4 ] count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; next = starting_address; while ( count-- ) { current->next = next; 200c074: c2 20 80 00 st %g1, [ %g2 ] count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; next = starting_address; while ( count-- ) { 200c078: 80 a6 a0 00 cmp %i2, 0 Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 200c07c: 84 10 00 01 mov %g1, %g2 200c080: b4 06 bf ff add %i2, -1, %i2 count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; next = starting_address; while ( count-- ) { 200c084: 12 bf ff fb bne 200c070 <_Chain_Initialize+0x24> 200c088: 82 00 40 08 add %g1, %o0, %g1 200c08c: 40 00 21 32 call 2014554 <.umul> 200c090: 01 00 00 00 nop 200c094: 84 06 40 08 add %i1, %o0, %g2 next->previous = current; current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = _Chain_Tail( the_chain ); 200c098: 82 06 20 04 add %i0, 4, %g1 200c09c: c2 20 80 00 st %g1, [ %g2 ] the_chain->last = current; 200c0a0: c4 26 20 08 st %g2, [ %i0 + 8 ] } 200c0a4: 81 c7 e0 08 ret 200c0a8: 81 e8 00 00 restore =============================================================================== 0200bf6c <_Debug_Is_enabled>: */ bool _Debug_Is_enabled( rtems_debug_control level ) { 200bf6c: 03 00 80 60 sethi %hi(0x2018000), %g1 <== NOT EXECUTED 200bf70: c4 00 63 d8 ld [ %g1 + 0x3d8 ], %g2 ! 20183d8 <_Debug_Level><== NOT EXECUTED 200bf74: 90 0a 00 02 and %o0, %g2, %o0 <== NOT EXECUTED 200bf78: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED return (_Debug_Level & level) ? true : false; } 200bf7c: 81 c3 e0 08 retl <== NOT EXECUTED 200bf80: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 020051dc <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 20051dc: 9d e3 bf 98 save %sp, -104, %sp rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Thread_blocking_operation_States sync_state; executing = _Thread_Executing; 20051e0: 03 00 80 60 sethi %hi(0x2018000), %g1 20051e4: e0 00 63 d4 ld [ %g1 + 0x3d4 ], %l0 ! 20183d4 <_Thread_Executing> executing->Wait.return_code = RTEMS_SUCCESSFUL; 20051e8: c0 24 20 34 clr [ %l0 + 0x34 ] api = executing->API_Extensions[ THREAD_API_RTEMS ]; _ISR_Disable( level ); 20051ec: 7f ff f2 fe call 2001de4 20051f0: e4 04 21 68 ld [ %l0 + 0x168 ], %l2 pending_events = api->pending_events; 20051f4: c2 04 80 00 ld [ %l2 ], %g1 seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 20051f8: a2 8e 00 01 andcc %i0, %g1, %l1 20051fc: 02 80 00 07 be 2005218 <_Event_Seize+0x3c> 2005200: 80 8e 60 01 btst 1, %i1 2005204: 80 a6 00 11 cmp %i0, %l1 2005208: 02 80 00 23 be 2005294 <_Event_Seize+0xb8> 200520c: 80 8e 60 02 btst 2, %i1 2005210: 12 80 00 21 bne 2005294 <_Event_Seize+0xb8> <== ALWAYS TAKEN 2005214: 80 8e 60 01 btst 1, %i1 _ISR_Enable( level ); *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 2005218: 12 80 00 18 bne 2005278 <_Event_Seize+0x9c> 200521c: 82 10 20 01 mov 1, %g1 executing->Wait.return_code = RTEMS_UNSATISFIED; *event_out = seized_events; return; } _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 2005220: 23 00 80 63 sethi %hi(0x2018c00), %l1 executing->Wait.option = (uint32_t) option_set; 2005224: f2 24 20 30 st %i1, [ %l0 + 0x30 ] executing->Wait.count = (uint32_t) event_in; 2005228: f0 24 20 24 st %i0, [ %l0 + 0x24 ] executing->Wait.return_argument = event_out; 200522c: f6 24 20 28 st %i3, [ %l0 + 0x28 ] executing->Wait.return_code = RTEMS_UNSATISFIED; *event_out = seized_events; return; } _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 2005230: c2 24 60 30 st %g1, [ %l1 + 0x30 ] executing->Wait.option = (uint32_t) option_set; executing->Wait.count = (uint32_t) event_in; executing->Wait.return_argument = event_out; _ISR_Enable( level ); 2005234: 7f ff f2 f0 call 2001df4 2005238: 01 00 00 00 nop if ( ticks ) { 200523c: 80 a6 a0 00 cmp %i2, 0 2005240: 32 80 00 1c bne,a 20052b0 <_Event_Seize+0xd4> 2005244: c2 04 20 08 ld [ %l0 + 8 ], %g1 NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 2005248: 90 10 00 10 mov %l0, %o0 200524c: 40 00 0d 0f call 2008688 <_Thread_Set_state> 2005250: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 2005254: 7f ff f2 e4 call 2001de4 2005258: 01 00 00 00 nop sync_state = _Event_Sync_state; 200525c: f0 04 60 30 ld [ %l1 + 0x30 ], %i0 _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 2005260: c0 24 60 30 clr [ %l1 + 0x30 ] if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 2005264: 80 a6 20 01 cmp %i0, 1 2005268: 02 80 00 27 be 2005304 <_Event_Seize+0x128> 200526c: b2 10 00 10 mov %l0, %i1 * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 2005270: 40 00 08 bb call 200755c <_Thread_blocking_operation_Cancel> 2005274: 95 e8 00 08 restore %g0, %o0, %o2 *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 2005278: 7f ff f2 df call 2001df4 200527c: 01 00 00 00 nop executing->Wait.return_code = RTEMS_UNSATISFIED; 2005280: 82 10 20 0d mov 0xd, %g1 ! d 2005284: c2 24 20 34 st %g1, [ %l0 + 0x34 ] *event_out = seized_events; 2005288: e2 26 c0 00 st %l1, [ %i3 ] 200528c: 81 c7 e0 08 ret 2005290: 81 e8 00 00 restore pending_events = api->pending_events; seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 2005294: 82 28 40 11 andn %g1, %l1, %g1 2005298: c2 24 80 00 st %g1, [ %l2 ] _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 200529c: 7f ff f2 d6 call 2001df4 20052a0: 01 00 00 00 nop *event_out = seized_events; 20052a4: e2 26 c0 00 st %l1, [ %i3 ] 20052a8: 81 c7 e0 08 ret 20052ac: 81 e8 00 00 restore ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20052b0: 92 04 20 48 add %l0, 0x48, %o1 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 20052b4: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 20052b8: 03 00 80 15 sethi %hi(0x2005400), %g1 20052bc: 82 10 60 b0 or %g1, 0xb0, %g1 ! 20054b0 <_Event_Timeout> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20052c0: f4 24 20 54 st %i2, [ %l0 + 0x54 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 20052c4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20052c8: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 20052cc: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20052d0: 11 00 80 60 sethi %hi(0x2018000), %o0 20052d4: 40 00 0f 05 call 2008ee8 <_Watchdog_Insert> 20052d8: 90 12 23 f4 or %o0, 0x3f4, %o0 ! 20183f4 <_Watchdog_Ticks_chain> NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 20052dc: 90 10 00 10 mov %l0, %o0 20052e0: 40 00 0c ea call 2008688 <_Thread_Set_state> 20052e4: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 20052e8: 7f ff f2 bf call 2001de4 20052ec: 01 00 00 00 nop sync_state = _Event_Sync_state; 20052f0: f0 04 60 30 ld [ %l1 + 0x30 ], %i0 _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 20052f4: c0 24 60 30 clr [ %l1 + 0x30 ] if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 20052f8: 80 a6 20 01 cmp %i0, 1 20052fc: 12 bf ff dd bne 2005270 <_Event_Seize+0x94> 2005300: b2 10 00 10 mov %l0, %i1 _ISR_Enable( level ); 2005304: 7f ff f2 bc call 2001df4 2005308: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 02005368 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 2005368: 9d e3 bf 98 save %sp, -104, %sp rtems_event_set event_condition; rtems_event_set seized_events; rtems_option option_set; RTEMS_API_Control *api; api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 200536c: f2 06 21 68 ld [ %i0 + 0x168 ], %i1 option_set = (rtems_option) the_thread->Wait.option; _ISR_Disable( level ); 2005370: 7f ff f2 9d call 2001de4 2005374: e2 06 20 30 ld [ %i0 + 0x30 ], %l1 2005378: a0 10 00 08 mov %o0, %l0 pending_events = api->pending_events; 200537c: c8 06 40 00 ld [ %i1 ], %g4 event_condition = (rtems_event_set) the_thread->Wait.count; 2005380: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 2005384: 9a 88 c0 04 andcc %g3, %g4, %o5 2005388: 02 80 00 28 be 2005428 <_Event_Surrender+0xc0> 200538c: 03 00 80 60 sethi %hi(0x2018000), %g1 /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 2005390: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 20183b0 <_ISR_Nest_level> 2005394: 80 a0 a0 00 cmp %g2, 0 2005398: 22 80 00 08 be,a 20053b8 <_Event_Surrender+0x50> 200539c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 20053a0: 03 00 80 60 sethi %hi(0x2018000), %g1 20053a4: c4 00 63 d4 ld [ %g1 + 0x3d4 ], %g2 ! 20183d4 <_Thread_Executing> 20053a8: 80 a6 00 02 cmp %i0, %g2 20053ac: 02 80 00 2a be 2005454 <_Event_Surrender+0xec> 20053b0: 19 00 80 63 sethi %hi(0x2018c00), %o4 } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 20053b4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 20053b8: 80 88 61 00 btst 0x100, %g1 20053bc: 02 80 00 19 be 2005420 <_Event_Surrender+0xb8> <== NEVER TAKEN 20053c0: 80 a0 c0 0d cmp %g3, %o5 if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 20053c4: 02 80 00 04 be 20053d4 <_Event_Surrender+0x6c> 20053c8: 80 8c 60 02 btst 2, %l1 20053cc: 02 80 00 15 be 2005420 <_Event_Surrender+0xb8> <== NEVER TAKEN 20053d0: 01 00 00 00 nop api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 20053d4: 82 29 00 0d andn %g4, %o5, %g1 the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 20053d8: c4 06 20 28 ld [ %i0 + 0x28 ], %g2 /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 20053dc: c2 26 40 00 st %g1, [ %i1 ] the_thread->Wait.count = 0; 20053e0: c0 26 20 24 clr [ %i0 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 20053e4: da 20 80 00 st %o5, [ %g2 ] _ISR_Flash( level ); 20053e8: 7f ff f2 83 call 2001df4 20053ec: 90 10 00 10 mov %l0, %o0 20053f0: 7f ff f2 7d call 2001de4 20053f4: 01 00 00 00 nop if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 20053f8: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 20053fc: 80 a0 60 02 cmp %g1, 2 2005400: 02 80 00 0c be 2005430 <_Event_Surrender+0xc8> 2005404: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 2005408: 90 10 00 10 mov %l0, %o0 200540c: 7f ff f2 7a call 2001df4 2005410: 33 04 00 ff sethi %hi(0x1003fc00), %i1 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2005414: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 2005418: 40 00 08 e5 call 20077ac <_Thread_Clear_state> 200541c: 81 e8 00 00 restore _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 2005420: 7f ff f2 75 call 2001df4 <== NOT EXECUTED 2005424: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { _ISR_Enable( level ); 2005428: 7f ff f2 73 call 2001df4 200542c: 91 e8 00 08 restore %g0, %o0, %o0 RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 2005430: c2 26 20 50 st %g1, [ %i0 + 0x50 ] if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 2005434: 7f ff f2 70 call 2001df4 2005438: 90 10 00 10 mov %l0, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 200543c: 40 00 0f 16 call 2009094 <_Watchdog_Remove> 2005440: 90 06 20 48 add %i0, 0x48, %o0 2005444: 33 04 00 ff sethi %hi(0x1003fc00), %i1 2005448: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200544c: 40 00 08 d8 call 20077ac <_Thread_Clear_state> 2005450: 81 e8 00 00 restore /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 2005454: c2 03 20 30 ld [ %o4 + 0x30 ], %g1 2005458: 80 a0 60 01 cmp %g1, 1 200545c: 02 80 00 07 be 2005478 <_Event_Surrender+0x110> 2005460: 80 a0 c0 0d cmp %g3, %o5 2005464: c2 03 20 30 ld [ %o4 + 0x30 ], %g1 2005468: 80 a0 60 02 cmp %g1, 2 200546c: 32 bf ff d3 bne,a 20053b8 <_Event_Surrender+0x50> <== ALWAYS TAKEN 2005470: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 2005474: 80 a0 c0 0d cmp %g3, %o5 <== NOT EXECUTED 2005478: 02 80 00 04 be 2005488 <_Event_Surrender+0x120> <== ALWAYS TAKEN 200547c: 80 8c 60 02 btst 2, %l1 2005480: 02 80 00 09 be 20054a4 <_Event_Surrender+0x13c> <== NOT EXECUTED 2005484: 01 00 00 00 nop <== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 2005488: 82 29 00 0d andn %g4, %o5, %g1 the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 200548c: c4 06 20 28 ld [ %i0 + 0x28 ], %g2 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 2005490: c2 26 40 00 st %g1, [ %i1 ] the_thread->Wait.count = 0; 2005494: c0 26 20 24 clr [ %i0 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 2005498: 82 10 20 03 mov 3, %g1 ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 200549c: da 20 80 00 st %o5, [ %g2 ] _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 20054a0: c2 23 20 30 st %g1, [ %o4 + 0x30 ] } _ISR_Enable( level ); 20054a4: 7f ff f2 54 call 2001df4 20054a8: 91 e8 00 10 restore %g0, %l0, %o0 =============================================================================== 020054b0 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 20054b0: 9d e3 bf 90 save %sp, -112, %sp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 20054b4: 90 10 00 18 mov %i0, %o0 20054b8: 40 00 09 e4 call 2007c48 <_Thread_Get> 20054bc: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 20054c0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20054c4: 80 a0 60 00 cmp %g1, 0 20054c8: 12 80 00 19 bne 200552c <_Event_Timeout+0x7c> <== NEVER TAKEN 20054cc: b0 10 00 08 mov %o0, %i0 * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 20054d0: 7f ff f2 45 call 2001de4 20054d4: 01 00 00 00 nop 20054d8: 86 10 00 08 mov %o0, %g3 if ( !the_thread->Wait.count ) { /* verify thread is waiting */ 20054dc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 20054e0: 80 a0 60 00 cmp %g1, 0 20054e4: 02 80 00 14 be 2005534 <_Event_Timeout+0x84> <== NEVER TAKEN 20054e8: 03 00 80 60 sethi %hi(0x2018000), %g1 _ISR_Enable( level ); return; } the_thread->Wait.count = 0; if ( _Thread_Is_executing( the_thread ) ) { 20054ec: c4 00 63 d4 ld [ %g1 + 0x3d4 ], %g2 ! 20183d4 <_Thread_Executing> 20054f0: 80 a6 00 02 cmp %i0, %g2 20054f4: 02 80 00 18 be 2005554 <_Event_Timeout+0xa4> 20054f8: c0 26 20 24 clr [ %i0 + 0x24 ] (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } } the_thread->Wait.return_code = RTEMS_TIMEOUT; 20054fc: 82 10 20 06 mov 6, %g1 2005500: c2 26 20 34 st %g1, [ %i0 + 0x34 ] _ISR_Enable( level ); 2005504: 7f ff f2 3c call 2001df4 2005508: 90 10 00 03 mov %g3, %o0 200550c: 90 10 00 18 mov %i0, %o0 2005510: 13 04 00 ff sethi %hi(0x1003fc00), %o1 2005514: 40 00 08 a6 call 20077ac <_Thread_Clear_state> 2005518: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 200551c: 05 00 80 60 sethi %hi(0x2018000), %g2 2005520: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2018310 <_Thread_Dispatch_disable_level> 2005524: 82 00 7f ff add %g1, -1, %g1 2005528: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] 200552c: 81 c7 e0 08 ret 2005530: 81 e8 00 00 restore 2005534: 05 00 80 60 sethi %hi(0x2018000), %g2 <== NOT EXECUTED 2005538: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2018310 <_Thread_Dispatch_disable_level><== NOT EXECUTED 200553c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2005540: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] <== NOT EXECUTED _ISR_Disable( level ); if ( !the_thread->Wait.count ) { /* verify thread is waiting */ _Thread_Unnest_dispatch(); _ISR_Enable( level ); 2005544: 7f ff f2 2c call 2001df4 <== NOT EXECUTED 2005548: 01 00 00 00 nop <== NOT EXECUTED 200554c: 81 c7 e0 08 ret <== NOT EXECUTED 2005550: 81 e8 00 00 restore <== NOT EXECUTED return; } the_thread->Wait.count = 0; if ( _Thread_Is_executing( the_thread ) ) { Thread_blocking_operation_States sync = _Event_Sync_state; 2005554: 05 00 80 63 sethi %hi(0x2018c00), %g2 2005558: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 ! 2018c30 <_Event_Sync_state> if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) || 200555c: 80 a0 60 01 cmp %g1, 1 2005560: 38 bf ff e8 bgu,a 2005500 <_Event_Timeout+0x50> <== NEVER TAKEN 2005564: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 2005568: 82 10 20 02 mov 2, %g1 200556c: c2 20 a0 30 st %g1, [ %g2 + 0x30 ] } } the_thread->Wait.return_code = RTEMS_TIMEOUT; 2005570: 10 bf ff e4 b 2005500 <_Event_Timeout+0x50> 2005574: 82 10 20 06 mov 6, %g1 =============================================================================== 0200c274 <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 200c274: 9d e3 bf 98 save %sp, -104, %sp Heap_Block *the_block; void *ptr = NULL; Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); the_size = 200c278: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 200c27c: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 200c280: 90 10 00 19 mov %i1, %o0 200c284: 7f ff ea 08 call 2006aa4 <_Heap_Calc_block_size> 200c288: a0 10 00 18 mov %i0, %l0 _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 200c28c: 80 a2 20 00 cmp %o0, 0 200c290: 02 80 00 2c be 200c340 <_Heap_Allocate+0xcc> <== NEVER TAKEN 200c294: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 200c298: f0 06 20 08 ld [ %i0 + 8 ], %i0 return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 200c29c: 80 a4 00 18 cmp %l0, %i0 200c2a0: 02 80 00 28 be 200c340 <_Heap_Allocate+0xcc> 200c2a4: b2 10 20 00 clr %i1 /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 200c2a8: c2 06 20 04 ld [ %i0 + 4 ], %g1 200c2ac: 80 a2 00 01 cmp %o0, %g1 200c2b0: 18 80 00 18 bgu 200c310 <_Heap_Allocate+0x9c> 200c2b4: a2 10 20 00 clr %l1 (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 200c2b8: 94 10 00 08 mov %o0, %o2 200c2bc: 92 10 00 18 mov %i0, %o1 200c2c0: 7f ff ea 0d call 2006af4 <_Heap_Block_allocate> 200c2c4: 90 10 00 10 mov %l0, %o0 ptr = _Heap_User_area(the_block); stats->allocs += 1; 200c2c8: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 stats->searches += search_count + 1; 200c2cc: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); ptr = _Heap_User_area(the_block); stats->allocs += 1; 200c2d0: 82 00 60 01 inc %g1 stats->searches += search_count + 1; 200c2d4: 84 00 a0 01 inc %g2 if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); ptr = _Heap_User_area(the_block); stats->allocs += 1; 200c2d8: c2 24 20 48 st %g1, [ %l0 + 0x48 ] stats->searches += search_count + 1; 200c2dc: 84 00 80 19 add %g2, %i1, %g2 200c2e0: b0 06 20 08 add %i0, 8, %i0 200c2e4: c4 24 20 4c st %g2, [ %l0 + 0x4c ] _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 200c2e8: c2 04 20 44 ld [ %l0 + 0x44 ], %g1 200c2ec: 80 a0 40 11 cmp %g1, %l1 200c2f0: 2a 80 00 02 bcs,a 200c2f8 <_Heap_Allocate+0x84> 200c2f4: e2 24 20 44 st %l1, [ %l0 + 0x44 ] stats->max_search = search_count; return ptr; } 200c2f8: 81 c7 e0 08 ret 200c2fc: 81 e8 00 00 restore /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 200c300: c2 06 20 04 ld [ %i0 + 4 ], %g1 200c304: 80 a2 00 01 cmp %o0, %g1 200c308: 08 80 00 10 bleu 200c348 <_Heap_Allocate+0xd4> 200c30c: 94 10 00 08 mov %o0, %o2 return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 200c310: f0 06 20 08 ld [ %i0 + 8 ], %i0 if(the_size == 0) return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 200c314: 80 a4 00 18 cmp %l0, %i0 200c318: 12 bf ff fa bne 200c300 <_Heap_Allocate+0x8c> 200c31c: b2 06 60 01 inc %i1 _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 200c320: c2 04 20 44 ld [ %l0 + 0x44 ], %g1 if(the_size == 0) return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 200c324: a2 10 00 19 mov %i1, %l1 _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 200c328: 80 a0 40 11 cmp %g1, %l1 200c32c: 1a bf ff f3 bcc 200c2f8 <_Heap_Allocate+0x84> 200c330: b0 10 20 00 clr %i0 stats->max_search = search_count; 200c334: e2 24 20 44 st %l1, [ %l0 + 0x44 ] 200c338: 81 c7 e0 08 ret 200c33c: 81 e8 00 00 restore return ptr; } 200c340: 81 c7 e0 08 ret 200c344: 91 e8 20 00 restore %g0, 0, %o0 _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 200c348: 92 10 00 18 mov %i0, %o1 200c34c: 7f ff e9 ea call 2006af4 <_Heap_Block_allocate> 200c350: 90 10 00 10 mov %l0, %o0 ptr = _Heap_User_area(the_block); stats->allocs += 1; 200c354: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 stats->searches += search_count + 1; 200c358: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); ptr = _Heap_User_area(the_block); stats->allocs += 1; 200c35c: 82 00 60 01 inc %g1 stats->searches += search_count + 1; 200c360: 84 00 a0 01 inc %g2 /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 200c364: a2 10 00 19 mov %i1, %l1 (void)_Heap_Block_allocate(the_heap, the_block, the_size ); ptr = _Heap_User_area(the_block); stats->allocs += 1; stats->searches += search_count + 1; 200c368: 84 00 80 19 add %g2, %i1, %g2 if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); ptr = _Heap_User_area(the_block); stats->allocs += 1; 200c36c: c2 24 20 48 st %g1, [ %l0 + 0x48 ] stats->searches += search_count + 1; 200c370: c4 24 20 4c st %g2, [ %l0 + 0x4c ] 200c374: 10 bf ff dd b 200c2e8 <_Heap_Allocate+0x74> 200c378: b0 06 20 08 add %i0, 8, %i0 =============================================================================== 02008bbc <_Heap_Allocate_aligned>: void *_Heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 2008bbc: 9d e3 bf 98 save %sp, -104, %sp uint32_t search_count; Heap_Block *the_block; void *user_ptr = NULL; uint32_t const page_size = the_heap->page_size; 2008bc0: ec 06 20 10 ld [ %i0 + 0x10 ], %l6 Heap_Block *const tail = _Heap_Tail(the_heap); uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET; uint32_t const the_size = _Heap_Calc_block_size(size, page_size, the_heap->min_block_size); 2008bc4: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 2008bc8: 90 10 00 19 mov %i1, %o0 2008bcc: 92 10 00 16 mov %l6, %o1 2008bd0: 40 00 01 82 call 20091d8 <_Heap_Calc_block_size> 2008bd4: aa 10 00 18 mov %i0, %l5 if(the_size == 0) 2008bd8: ae 92 20 00 orcc %o0, 0, %l7 2008bdc: 02 80 00 69 be 2008d80 <_Heap_Allocate_aligned+0x1c4> <== NEVER TAKEN 2008be0: b2 06 7f fc add %i1, -4, %i1 return NULL; if(alignment == 0) 2008be4: 80 a6 a0 00 cmp %i2, 0 2008be8: 22 80 00 02 be,a 2008bf0 <_Heap_Allocate_aligned+0x34> 2008bec: b4 10 20 08 mov 8, %i2 */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 2008bf0: e2 05 60 08 ld [ %l5 + 8 ], %l1 alignment = CPU_ALIGNMENT; /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 2008bf4: 80 a5 40 11 cmp %l5, %l1 2008bf8: 02 80 00 62 be 2008d80 <_Heap_Allocate_aligned+0x1c4> <== NEVER TAKEN 2008bfc: a8 10 20 00 clr %l4 */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 2008c00: c2 04 60 04 ld [ %l1 + 4 ], %g1 _H_uptr_t *value, uint32_t alignment ) { _H_uptr_t v = *value; *value = v - (v % alignment); 2008c04: 92 10 00 1a mov %i2, %o1 */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 2008c08: a4 08 7f fe and %g1, -2, %l2 /* Calculate 'aligned_user_addr' that will become the user pointer we return. It should be at least 'end_to_user_offs' bytes less than the the 'block_end' and should be aligned on 'alignment' boundary. Calculations are from the 'block_end' as we are going to split free block so that the upper part of the block becomes used block. */ _H_uptr_t const block_end = _H_p2u(the_block) + block_size; 2008c0c: a6 04 40 12 add %l1, %l2, %l3 uint32_t const block_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); if(block_size >= the_size) { /* the_block is large enough. */ 2008c10: 80 a5 c0 12 cmp %l7, %l2 return. It should be at least 'end_to_user_offs' bytes less than the the 'block_end' and should be aligned on 'alignment' boundary. Calculations are from the 'block_end' as we are going to split free block so that the upper part of the block becomes used block. */ _H_uptr_t const block_end = _H_p2u(the_block) + block_size; aligned_user_addr = block_end - end_to_user_offs; 2008c14: a0 24 c0 19 sub %l3, %i1, %l0 uint32_t const block_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); if(block_size >= the_size) { /* the_block is large enough. */ 2008c18: 18 80 00 22 bgu 2008ca0 <_Heap_Allocate_aligned+0xe4> 2008c1c: 90 10 00 10 mov %l0, %o0 _H_uptr_t *value, uint32_t alignment ) { _H_uptr_t v = *value; *value = v - (v % alignment); 2008c20: 40 00 40 bb call 2018f0c <.urem> 2008c24: 01 00 00 00 nop _H_uptr_t user_addr; _H_uptr_t aligned_user_addr; _H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block)); 2008c28: 92 10 00 16 mov %l6, %o1 2008c2c: b0 24 00 08 sub %l0, %o0, %i0 2008c30: 40 00 40 b7 call 2018f0c <.urem> 2008c34: 90 10 00 18 mov %i0, %o0 2008c38: a0 04 60 08 add %l1, 8, %l0 2008c3c: 84 26 00 08 sub %i0, %o0, %g2 only at 'page_size' aligned addresses */ user_addr = aligned_user_addr; _Heap_Align_down_uptr(&user_addr, page_size); /* Make sure 'user_addr' calculated didn't run out of 'the_block'. */ if(user_addr >= user_area) { 2008c40: 80 a4 00 02 cmp %l0, %g2 2008c44: 38 80 00 18 bgu,a 2008ca4 <_Heap_Allocate_aligned+0xe8> 2008c48: e2 04 60 08 ld [ %l1 + 8 ], %l1 /* The block seems to be acceptable. Check if the remainder of 'the_block' is less than 'min_block_size' so that 'the_block' won't actually be split at the address we assume. */ if(user_addr - user_area < the_heap->min_block_size) { 2008c4c: fa 05 60 14 ld [ %l5 + 0x14 ], %i5 2008c50: 82 20 80 10 sub %g2, %l0, %g1 2008c54: 80 a0 40 1d cmp %g1, %i5 2008c58: 1a 80 00 1e bcc 2008cd0 <_Heap_Allocate_aligned+0x114> 2008c5c: 80 a6 20 00 cmp %i0, 0 'aligned_user_addr' to be outside of [0,page_size) range. If we do, we will need to store this distance somewhere to be able to resurrect the block address from the user pointer. (Having the distance within [0,page_size) range allows resurrection by aligning user pointer down to the nearest 'page_size' boundary.) */ if(aligned_user_addr - user_addr >= page_size) { 2008c60: 82 26 00 10 sub %i0, %l0, %g1 uint32_t alignment ) { _H_uptr_t v = *value; uint32_t a = alignment; _H_uptr_t r = v % a; 2008c64: 90 10 00 10 mov %l0, %o0 2008c68: 92 10 00 1a mov %i2, %o1 2008c6c: 80 a5 80 01 cmp %l6, %g1 2008c70: 18 80 00 17 bgu 2008ccc <_Heap_Allocate_aligned+0x110> 2008c74: 84 10 00 10 mov %l0, %g2 2008c78: 40 00 40 a5 call 2018f0c <.urem> 2008c7c: 01 00 00 00 nop /* The user pointer will be too far from 'user_addr'. See if we can make 'aligned_user_addr' to be close enough to the 'user_addr'. */ aligned_user_addr = user_addr; _Heap_Align_up_uptr(&aligned_user_addr, alignment); if(aligned_user_addr - user_addr >= page_size) { 2008c80: 84 10 00 10 mov %l0, %g2 *value = r ? v - r + a : v; 2008c84: 88 92 20 00 orcc %o0, 0, %g4 2008c88: 86 10 20 00 clr %g3 2008c8c: 12 80 00 35 bne 2008d60 <_Heap_Allocate_aligned+0x1a4> <== ALWAYS TAKEN 2008c90: 90 10 00 10 mov %l0, %o0 2008c94: 80 a5 80 03 cmp %l6, %g3 <== NOT EXECUTED 2008c98: 38 80 00 0d bgu,a 2008ccc <_Heap_Allocate_aligned+0x110> <== NOT EXECUTED 2008c9c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 2008ca0: e2 04 60 08 ld [ %l1 + 8 ], %l1 alignment = CPU_ALIGNMENT; /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 2008ca4: 80 a5 40 11 cmp %l5, %l1 2008ca8: 12 bf ff d6 bne 2008c00 <_Heap_Allocate_aligned+0x44> 2008cac: a8 05 20 01 inc %l4 2008cb0: 90 10 20 00 clr %o0 } } } } if(stats->max_search < search_count) 2008cb4: c2 05 60 44 ld [ %l5 + 0x44 ], %g1 2008cb8: 80 a0 40 14 cmp %g1, %l4 2008cbc: 2a 80 00 02 bcs,a 2008cc4 <_Heap_Allocate_aligned+0x108> 2008cc0: e8 25 60 44 st %l4, [ %l5 + 0x44 ] stats->max_search = search_count; return user_ptr; } 2008cc4: 81 c7 e0 08 ret 2008cc8: 91 e8 00 08 restore %g0, %o0, %o0 aligned_user_addr = 0; } } } if(aligned_user_addr) { 2008ccc: 80 a6 20 00 cmp %i0, 0 2008cd0: 22 bf ff f5 be,a 2008ca4 <_Heap_Allocate_aligned+0xe8> <== NEVER TAKEN 2008cd4: e2 04 60 08 ld [ %l1 + 8 ], %l1 <== NOT EXECUTED /* The block is indeed acceptable: calculate the size of the block to be allocated and perform allocation. */ uint32_t const alloc_size = block_end - user_addr + HEAP_BLOCK_USER_OFFSET; 2008cd8: 82 04 e0 08 add %l3, 8, %g1 2008cdc: 88 20 40 02 sub %g1, %g2, %g4 Heap_Block *the_block, uint32_t alloc_size) { Heap_Statistics *const stats = &the_heap->stats; uint32_t const block_size = _Heap_Block_size(the_block); uint32_t const the_rest = block_size - alloc_size; 2008ce0: 84 24 80 04 sub %l2, %g4, %g2 _HAssert(_Heap_Is_aligned(block_size, the_heap->page_size)); _HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size)); _HAssert(alloc_size <= block_size); _HAssert(_Heap_Is_prev_used(the_block)); if(the_rest >= the_heap->min_block_size) { 2008ce4: 80 a0 80 1d cmp %g2, %i5 2008ce8: 2a 80 00 29 bcs,a 2008d8c <_Heap_Allocate_aligned+0x1d0> 2008cec: c6 04 60 08 ld [ %l1 + 8 ], %g3 /* Split the block so that lower part is still free, and upper part becomes used. */ the_block->size = the_rest | HEAP_PREV_USED; 2008cf0: 82 10 a0 01 or %g2, 1, %g1 2008cf4: c2 24 60 04 st %g1, [ %l1 + 4 ] RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( void *base, uint32_t offset ) { return (void *)((char *)base + offset); 2008cf8: a2 04 40 02 add %l1, %g2, %l1 the_block = _Heap_Block_at(the_block, the_rest); the_block->prev_size = the_rest; 2008cfc: c4 24 40 00 st %g2, [ %l1 ] the_block->size = alloc_size; 2008d00: c8 24 60 04 st %g4, [ %l1 + 4 ] RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 2008d04: 84 04 40 04 add %l1, %g4, %g2 _Heap_Block_remove(the_block); alloc_size = block_size; stats->free_blocks -= 1; } /* Mark the block as used (in the next block). */ _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; 2008d08: c2 00 a0 04 ld [ %g2 + 4 ], %g1 2008d0c: 82 10 60 01 or %g1, 1, %g1 2008d10: c2 20 a0 04 st %g1, [ %g2 + 4 ] /* Update statistics */ stats->free_size -= alloc_size; 2008d14: c6 05 60 30 ld [ %l5 + 0x30 ], %g3 if(stats->min_free_size > stats->free_size) 2008d18: c2 05 60 34 ld [ %l5 + 0x34 ], %g1 stats->free_blocks -= 1; } /* Mark the block as used (in the next block). */ _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; /* Update statistics */ stats->free_size -= alloc_size; 2008d1c: 86 20 c0 04 sub %g3, %g4, %g3 if(stats->min_free_size > stats->free_size) 2008d20: 80 a0 c0 01 cmp %g3, %g1 2008d24: 1a 80 00 03 bcc 2008d30 <_Heap_Allocate_aligned+0x174> 2008d28: c6 25 60 30 st %g3, [ %l5 + 0x30 ] stats->min_free_size = stats->free_size; 2008d2c: c6 25 60 34 st %g3, [ %l5 + 0x34 ] stats->used_blocks += 1; 2008d30: c2 05 60 40 ld [ %l5 + 0x40 ], %g1 _HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment)); the_block = block_allocate(the_heap, the_block, alloc_size); stats->searches += search_count + 1; 2008d34: c6 05 60 4c ld [ %l5 + 0x4c ], %g3 stats->allocs += 1; 2008d38: c4 05 60 48 ld [ %l5 + 0x48 ], %g2 _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; /* Update statistics */ stats->free_size -= alloc_size; if(stats->min_free_size > stats->free_size) stats->min_free_size = stats->free_size; stats->used_blocks += 1; 2008d3c: 82 00 60 01 inc %g1 _HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment)); the_block = block_allocate(the_heap, the_block, alloc_size); stats->searches += search_count + 1; 2008d40: 86 00 e0 01 inc %g3 stats->allocs += 1; 2008d44: 84 00 a0 01 inc %g2 _HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment)); the_block = block_allocate(the_heap, the_block, alloc_size); stats->searches += search_count + 1; 2008d48: 86 00 c0 14 add %g3, %l4, %g3 _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; /* Update statistics */ stats->free_size -= alloc_size; if(stats->min_free_size > stats->free_size) stats->min_free_size = stats->free_size; stats->used_blocks += 1; 2008d4c: c2 25 60 40 st %g1, [ %l5 + 0x40 ] _HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment)); the_block = block_allocate(the_heap, the_block, alloc_size); stats->searches += search_count + 1; stats->allocs += 1; 2008d50: c4 25 60 48 st %g2, [ %l5 + 0x48 ] _HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment)); the_block = block_allocate(the_heap, the_block, alloc_size); stats->searches += search_count + 1; 2008d54: c6 25 60 4c st %g3, [ %l5 + 0x4c ] stats->allocs += 1; check_result(the_heap, the_block, user_addr, aligned_user_addr, size); user_ptr = (void*)aligned_user_addr; 2008d58: 10 bf ff d7 b 2008cb4 <_Heap_Allocate_aligned+0xf8> 2008d5c: 90 10 00 18 mov %i0, %o0 ) { _H_uptr_t v = *value; uint32_t a = alignment; _H_uptr_t r = v % a; *value = r ? v - r + a : v; 2008d60: 82 04 00 1a add %l0, %i2, %g1 2008d64: 90 20 40 04 sub %g1, %g4, %o0 2008d68: 86 22 00 10 sub %o0, %l0, %g3 /* The user pointer will be too far from 'user_addr'. See if we can make 'aligned_user_addr' to be close enough to the 'user_addr'. */ aligned_user_addr = user_addr; _Heap_Align_up_uptr(&aligned_user_addr, alignment); if(aligned_user_addr - user_addr >= page_size) { 2008d6c: 80 a5 80 03 cmp %l6, %g3 2008d70: 28 bf ff cd bleu,a 2008ca4 <_Heap_Allocate_aligned+0xe8> <== ALWAYS TAKEN 2008d74: e2 04 60 08 ld [ %l1 + 8 ], %l1 2008d78: 10 bf ff d5 b 2008ccc <_Heap_Allocate_aligned+0x110> <== NOT EXECUTED 2008d7c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED } } } if(stats->max_search < search_count) stats->max_search = search_count; 2008d80: 90 10 20 00 clr %o0 <== NOT EXECUTED return user_ptr; } 2008d84: 81 c7 e0 08 ret <== NOT EXECUTED 2008d88: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED ) { Heap_Block *block = the_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; 2008d8c: c4 04 60 0c ld [ %l1 + 0xc ], %g2 /* Don't split the block as remainder is either zero or too small to be used as a separate free block. Change 'alloc_size' to the size of the block and remove the block from the list of free blocks. */ _Heap_Block_remove(the_block); alloc_size = block_size; stats->free_blocks -= 1; 2008d90: c2 05 60 38 ld [ %l5 + 0x38 ], %g1 prev->next = next; next->prev = prev; 2008d94: c4 20 e0 0c st %g2, [ %g3 + 0xc ] 2008d98: 82 00 7f ff add %g1, -1, %g1 { Heap_Block *block = the_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; prev->next = next; 2008d9c: c6 20 a0 08 st %g3, [ %g2 + 8 ] 2008da0: c2 25 60 38 st %g1, [ %l5 + 0x38 ] 2008da4: 10 bf ff d8 b 2008d04 <_Heap_Allocate_aligned+0x148> 2008da8: 88 10 00 12 mov %l2, %g4 =============================================================================== 0200ece4 <_Heap_Extend>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t *amount_extended ) { 200ece4: 9d e3 bf 98 save %sp, -104, %sp * 5. non-contiguous higher address (NOT SUPPORTED) * * As noted, this code only supports (4). */ if ( starting_address >= the_heap->begin && /* case 3 */ 200ece8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 200ecec: 80 a0 40 19 cmp %g1, %i1 200ecf0: 08 80 00 08 bleu 200ed10 <_Heap_Extend+0x2c> 200ecf4: a2 10 00 18 mov %i0, %l1 200ecf8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 starting_address < the_heap->end ) return HEAP_EXTEND_ERROR; if ( starting_address != the_heap->end ) 200ecfc: 80 a6 40 01 cmp %i1, %g1 200ed00: 02 80 00 0b be 200ed2c <_Heap_Extend+0x48> <== NEVER TAKEN 200ed04: b0 10 20 02 mov 2, %i0 stats->frees -= 1; /* Don't count subsequent call as actual free() */ _Heap_Free( the_heap, _Heap_User_area( old_final ) ); return HEAP_EXTEND_SUCCESSFUL; } 200ed08: 81 c7 e0 08 ret 200ed0c: 81 e8 00 00 restore * 5. non-contiguous higher address (NOT SUPPORTED) * * As noted, this code only supports (4). */ if ( starting_address >= the_heap->begin && /* case 3 */ 200ed10: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 200ed14: 80 a6 40 01 cmp %i1, %g1 200ed18: 0a bf ff fc bcs 200ed08 <_Heap_Extend+0x24> 200ed1c: b0 10 20 01 mov 1, %i0 starting_address < the_heap->end ) return HEAP_EXTEND_ERROR; if ( starting_address != the_heap->end ) 200ed20: 80 a6 40 01 cmp %i1, %g1 200ed24: 12 bf ff f9 bne 200ed08 <_Heap_Extend+0x24> 200ed28: b0 10 20 02 mov 2, %i0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 200ed2c: d2 04 60 10 ld [ %l1 + 0x10 ], %o1 * Currently only case 4 should make it to this point. * The basic trick is to make the extend area look like a used * block and free it. */ old_final = the_heap->final; 200ed30: e4 04 60 24 ld [ %l1 + 0x24 ], %l2 200ed34: 82 06 40 1a add %i1, %i2, %g1 the_heap->end = _Addresses_Add_offset( the_heap->end, size ); the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD; 200ed38: a0 20 40 12 sub %g1, %l2, %l0 * The basic trick is to make the extend area look like a used * block and free it. */ old_final = the_heap->final; the_heap->end = _Addresses_Add_offset( the_heap->end, size ); 200ed3c: c2 24 60 1c st %g1, [ %l1 + 0x1c ] the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD; 200ed40: a0 04 3f f8 add %l0, -8, %l0 200ed44: 40 00 28 72 call 2018f0c <.urem> 200ed48: 90 10 00 10 mov %l0, %o0 _Heap_Align_down( &the_size, the_heap->page_size ); *amount_extended = size; 200ed4c: f4 26 c0 00 st %i2, [ %i3 ] if( the_size < the_heap->min_block_size ) 200ed50: c2 04 60 14 ld [ %l1 + 0x14 ], %g1 200ed54: a0 24 00 08 sub %l0, %o0, %l0 200ed58: 80 a0 40 10 cmp %g1, %l0 200ed5c: 18 bf ff eb bgu 200ed08 <_Heap_Extend+0x24> <== NEVER TAKEN 200ed60: b0 10 20 00 clr %i0 return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); 200ed64: c2 04 a0 04 ld [ %l2 + 4 ], %g1 new_final = _Heap_Block_at( old_final, the_size ); new_final->size = HEAP_PREV_USED; 200ed68: 84 10 20 01 mov 1, %g2 *amount_extended = size; if( the_size < the_heap->min_block_size ) return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); 200ed6c: 82 08 60 01 and %g1, 1, %g1 200ed70: 82 14 00 01 or %l0, %g1, %g1 200ed74: c2 24 a0 04 st %g1, [ %l2 + 4 ] RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200ed78: 88 04 80 10 add %l2, %l0, %g4 new_final = _Heap_Block_at( old_final, the_size ); new_final->size = HEAP_PREV_USED; 200ed7c: c4 21 20 04 st %g2, [ %g4 + 4 ] the_heap->final = new_final; stats->size += size; 200ed80: c2 04 60 2c ld [ %l1 + 0x2c ], %g1 stats->used_blocks += 1; 200ed84: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 stats->frees -= 1; /* Don't count subsequent call as actual free() */ 200ed88: c6 04 60 50 ld [ %l1 + 0x50 ], %g3 old_final->size = the_size | (old_final->size & HEAP_PREV_USED); new_final = _Heap_Block_at( old_final, the_size ); new_final->size = HEAP_PREV_USED; the_heap->final = new_final; stats->size += size; 200ed8c: 82 00 40 1a add %g1, %i2, %g1 stats->used_blocks += 1; 200ed90: 84 00 a0 01 inc %g2 stats->frees -= 1; /* Don't count subsequent call as actual free() */ 200ed94: 86 00 ff ff add %g3, -1, %g3 return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); new_final = _Heap_Block_at( old_final, the_size ); new_final->size = HEAP_PREV_USED; the_heap->final = new_final; 200ed98: c8 24 60 24 st %g4, [ %l1 + 0x24 ] stats->size += size; 200ed9c: c2 24 60 2c st %g1, [ %l1 + 0x2c ] stats->used_blocks += 1; 200eda0: c4 24 60 40 st %g2, [ %l1 + 0x40 ] stats->frees -= 1; /* Don't count subsequent call as actual free() */ 200eda4: c6 24 60 50 st %g3, [ %l1 + 0x50 ] _Heap_Free( the_heap, _Heap_User_area( old_final ) ); 200eda8: 90 10 00 11 mov %l1, %o0 200edac: 7f ff e8 42 call 2008eb4 <_Heap_Free> 200edb0: 92 04 a0 08 add %l2, 8, %o1 return HEAP_EXTEND_SUCCESSFUL; } 200edb4: 81 c7 e0 08 ret 200edb8: 81 e8 00 00 restore =============================================================================== 0200c37c <_Heap_Free>: bool _Heap_Free( Heap_Control *the_heap, void *starting_address ) { 200c37c: 9d e3 bf 98 save %sp, -104, %sp uint32_t the_size; uint32_t next_size; Heap_Statistics *const stats = &the_heap->stats; bool next_is_free; if ( !_Addresses_Is_in_range( 200c380: e4 06 20 20 ld [ %i0 + 0x20 ], %l2 200c384: e2 06 20 24 ld [ %i0 + 0x24 ], %l1 200c388: 80 a6 40 12 cmp %i1, %l2 200c38c: 84 60 3f ff subx %g0, -1, %g2 200c390: 80 a4 40 19 cmp %l1, %i1 200c394: 82 60 3f ff subx %g0, -1, %g1 200c398: 80 88 80 01 btst %g2, %g1 200c39c: 02 80 00 42 be 200c4a4 <_Heap_Free+0x128> 200c3a0: 01 00 00 00 nop /* The address passed could be greater than the block address plus * HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user * pointers. To get rid of this offset we need to align the address down * to the nearest 'page_size' boundary. */ _Heap_Align_down_uptr ( &addr, the_heap->page_size ); *the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET); 200c3a4: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 200c3a8: 40 00 21 51 call 20148ec <.urem> 200c3ac: 90 10 00 19 mov %i1, %o0 200c3b0: a0 06 7f f8 add %i1, -8, %l0 200c3b4: 90 24 00 08 sub %l0, %o0, %o0 return( FALSE ); } _Heap_Start_of_block( the_heap, starting_address, &the_block ); if ( !_Heap_Is_block_in( the_heap, the_block ) ) { 200c3b8: 80 a2 00 12 cmp %o0, %l2 200c3bc: 84 60 3f ff subx %g0, -1, %g2 200c3c0: 80 a4 40 08 cmp %l1, %o0 200c3c4: 82 60 3f ff subx %g0, -1, %g1 200c3c8: 80 88 80 01 btst %g2, %g1 200c3cc: 02 80 00 36 be 200c4a4 <_Heap_Free+0x128> <== NEVER TAKEN 200c3d0: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 200c3d4: c6 02 20 04 ld [ %o0 + 4 ], %g3 200c3d8: 9a 08 ff fe and %g3, -2, %o5 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200c3dc: 88 02 00 0d add %o0, %o5, %g4 } the_size = _Heap_Block_size( the_block ); next_block = _Heap_Block_at( the_block, the_size ); if ( !_Heap_Is_block_in( the_heap, next_block ) ) { 200c3e0: 80 a1 00 12 cmp %g4, %l2 200c3e4: 84 60 3f ff subx %g0, -1, %g2 200c3e8: 80 a4 40 04 cmp %l1, %g4 200c3ec: 82 60 3f ff subx %g0, -1, %g1 200c3f0: 80 88 80 01 btst %g2, %g1 200c3f4: 02 80 00 2c be 200c4a4 <_Heap_Free+0x128> <== NEVER TAKEN 200c3f8: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used ( Heap_Block *the_block ) { return (the_block->size & HEAP_PREV_USED); 200c3fc: c2 01 20 04 ld [ %g4 + 4 ], %g1 _HAssert( FALSE ); return( FALSE ); } if ( !_Heap_Is_prev_used( next_block ) ) { 200c400: 80 88 60 01 btst 1, %g1 200c404: 02 80 00 28 be 200c4a4 <_Heap_Free+0x128> <== NEVER TAKEN 200c408: 92 08 7f fe and %g1, -2, %o1 _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 200c40c: 80 a4 40 04 cmp %l1, %g4 200c410: 08 80 00 06 bleu 200c428 <_Heap_Free+0xac> 200c414: 98 10 20 00 clr %o4 200c418: 84 01 00 09 add %g4, %o1, %g2 200c41c: c2 00 a0 04 ld [ %g2 + 4 ], %g1 200c420: 82 18 60 01 xor %g1, 1, %g1 200c424: 98 08 60 01 and %g1, 1, %o4 !_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size)); if ( !_Heap_Is_prev_used( the_block ) ) { 200c428: 80 88 e0 01 btst 1, %g3 200c42c: 12 80 00 20 bne 200c4ac <_Heap_Free+0x130> 200c430: 80 8b 20 ff btst 0xff, %o4 uint32_t const prev_size = the_block->prev_size; 200c434: d4 02 00 00 ld [ %o0 ], %o2 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200c438: 96 22 00 0a sub %o0, %o2, %o3 Heap_Block *const prev_block = _Heap_Block_at( the_block, -prev_size ); if ( !_Heap_Is_block_in( the_heap, prev_block ) ) { 200c43c: 80 a2 c0 12 cmp %o3, %l2 200c440: 84 60 3f ff subx %g0, -1, %g2 200c444: 80 a4 40 0b cmp %l1, %o3 200c448: 82 60 3f ff subx %g0, -1, %g1 200c44c: 80 88 80 01 btst %g2, %g1 200c450: 02 80 00 15 be 200c4a4 <_Heap_Free+0x128> <== NEVER TAKEN 200c454: 01 00 00 00 nop return( FALSE ); } /* As we always coalesce free blocks, the block that preceedes prev_block must have been used. */ if ( !_Heap_Is_prev_used ( prev_block) ) { 200c458: c2 02 e0 04 ld [ %o3 + 4 ], %g1 200c45c: 80 88 60 01 btst 1, %g1 200c460: 02 80 00 11 be 200c4a4 <_Heap_Free+0x128> <== NEVER TAKEN 200c464: 80 8b 20 ff btst 0xff, %o4 _HAssert( FALSE ); return( FALSE ); } if ( next_is_free ) { /* coalesce both */ 200c468: 02 80 00 3a be 200c550 <_Heap_Free+0x1d4> 200c46c: 86 03 40 0a add %o5, %o2, %g3 uint32_t const size = the_size + prev_size + next_size; _Heap_Block_remove( next_block ); stats->free_blocks -= 1; 200c470: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 ) { Heap_Block *block = the_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; 200c474: c6 01 20 0c ld [ %g4 + 0xc ], %g3 Heap_Block *the_block ) { Heap_Block *block = the_block; Heap_Block *next = block->next; 200c478: c4 01 20 08 ld [ %g4 + 8 ], %g2 200c47c: 82 00 7f ff add %g1, -1, %g1 200c480: c2 26 20 38 st %g1, [ %i0 + 0x38 ] Heap_Block *prev = block->prev; prev->next = next; next->prev = prev; 200c484: c6 20 a0 0c st %g3, [ %g2 + 0xc ] _HAssert( FALSE ); return( FALSE ); } if ( next_is_free ) { /* coalesce both */ uint32_t const size = the_size + prev_size + next_size; 200c488: 82 03 40 09 add %o5, %o1, %g1 { Heap_Block *block = the_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; prev->next = next; 200c48c: c4 20 e0 08 st %g2, [ %g3 + 8 ] 200c490: 82 00 40 0a add %g1, %o2, %g1 _Heap_Block_remove( next_block ); stats->free_blocks -= 1; prev_block->size = size | HEAP_PREV_USED; next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; 200c494: c2 22 c0 01 st %g1, [ %o3 + %g1 ] if ( next_is_free ) { /* coalesce both */ uint32_t const size = the_size + prev_size + next_size; _Heap_Block_remove( next_block ); stats->free_blocks -= 1; prev_block->size = size | HEAP_PREV_USED; 200c498: 82 10 60 01 or %g1, 1, %g1 200c49c: 10 80 00 10 b 200c4dc <_Heap_Free+0x160> 200c4a0: c2 22 e0 04 st %g1, [ %o3 + 4 ] stats->used_blocks -= 1; stats->free_size += the_size; stats->frees += 1; return( TRUE ); } 200c4a4: 81 c7 e0 08 ret 200c4a8: 91 e8 20 00 restore %g0, 0, %o0 prev_block->size = size | HEAP_PREV_USED; next_block->size &= ~HEAP_PREV_USED; next_block->prev_size = size; } } else if ( next_is_free ) { /* coalesce next */ 200c4ac: 02 80 00 17 be 200c508 <_Heap_Free+0x18c> 200c4b0: 82 13 60 01 or %o5, 1, %g1 Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; 200c4b4: c2 01 20 0c ld [ %g4 + 0xc ], %g1 Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; 200c4b8: c4 01 20 08 ld [ %g4 + 8 ], %g2 Heap_Block *prev = block->prev; block = new_block; block->next = next; block->prev = prev; 200c4bc: c2 22 20 0c st %g1, [ %o0 + 0xc ] Heap_Block *block = old_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; block = new_block; block->next = next; 200c4c0: c4 22 20 08 st %g2, [ %o0 + 8 ] block->prev = prev; next->prev = prev->next = block; 200c4c4: d0 20 60 08 st %o0, [ %g1 + 8 ] 200c4c8: d0 20 a0 0c st %o0, [ %g2 + 0xc ] uint32_t const size = the_size + next_size; 200c4cc: 82 02 40 0d add %o1, %o5, %g1 _Heap_Block_replace( next_block, the_block ); the_block->size = size | HEAP_PREV_USED; next_block = _Heap_Block_at( the_block, size ); next_block->prev_size = size; 200c4d0: c2 22 00 01 st %g1, [ %o0 + %g1 ] } } else if ( next_is_free ) { /* coalesce next */ uint32_t const size = the_size + next_size; _Heap_Block_replace( next_block, the_block ); the_block->size = size | HEAP_PREV_USED; 200c4d4: 82 10 60 01 or %g1, 1, %g1 200c4d8: c2 22 20 04 st %g1, [ %o0 + 4 ] stats->free_blocks += 1; if ( stats->max_free_blocks < stats->free_blocks ) stats->max_free_blocks = stats->free_blocks; } stats->used_blocks -= 1; 200c4dc: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 stats->free_size += the_size; 200c4e0: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 stats->frees += 1; 200c4e4: c6 06 20 50 ld [ %i0 + 0x50 ], %g3 if ( stats->max_free_blocks < stats->free_blocks ) stats->max_free_blocks = stats->free_blocks; } stats->used_blocks -= 1; stats->free_size += the_size; 200c4e8: 84 00 80 0d add %g2, %o5, %g2 stats->free_blocks += 1; if ( stats->max_free_blocks < stats->free_blocks ) stats->max_free_blocks = stats->free_blocks; } stats->used_blocks -= 1; 200c4ec: 82 00 7f ff add %g1, -1, %g1 stats->free_size += the_size; 200c4f0: c4 26 20 30 st %g2, [ %i0 + 0x30 ] stats->free_blocks += 1; if ( stats->max_free_blocks < stats->free_blocks ) stats->max_free_blocks = stats->free_blocks; } stats->used_blocks -= 1; 200c4f4: c2 26 20 40 st %g1, [ %i0 + 0x40 ] stats->free_size += the_size; stats->frees += 1; 200c4f8: 86 00 e0 01 inc %g3 200c4fc: c6 26 20 50 st %g3, [ %i0 + 0x50 ] 200c500: 81 c7 e0 08 ret 200c504: 91 e8 20 01 restore %g0, 1, %o0 } else { /* no coalesce */ /* Add 'the_block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Block_insert_after( _Heap_Head( the_heap), the_block ); the_block->size = the_size | HEAP_PREV_USED; 200c508: c2 22 20 04 st %g1, [ %o0 + 4 ] next_block->size &= ~HEAP_PREV_USED; 200c50c: c4 01 20 04 ld [ %g4 + 4 ], %g2 ) { Heap_Block *prev = prev_block; Heap_Block *block = the_block; Heap_Block *next = prev->next; 200c510: c6 06 20 08 ld [ %i0 + 8 ], %g3 next_block->prev_size = the_size; 200c514: da 22 00 0d st %o5, [ %o0 + %o5 ] else { /* no coalesce */ /* Add 'the_block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Block_insert_after( _Heap_Head( the_heap), the_block ); the_block->size = the_size | HEAP_PREV_USED; next_block->size &= ~HEAP_PREV_USED; 200c518: 84 08 bf fe and %g2, -2, %g2 200c51c: c4 21 20 04 st %g2, [ %g4 + 4 ] next_block->prev_size = the_size; stats->free_blocks += 1; 200c520: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 block->next = next; 200c524: c6 22 20 08 st %g3, [ %o0 + 8 ] block->prev = prev; 200c528: f0 22 20 0c st %i0, [ %o0 + 0xc ] if ( stats->max_free_blocks < stats->free_blocks ) 200c52c: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 _Heap_Block_insert_after( _Heap_Head( the_heap), the_block ); the_block->size = the_size | HEAP_PREV_USED; next_block->size &= ~HEAP_PREV_USED; next_block->prev_size = the_size; stats->free_blocks += 1; 200c530: 82 00 60 01 inc %g1 next->prev = prev->next = block; 200c534: d0 20 e0 0c st %o0, [ %g3 + 0xc ] 200c538: d0 26 20 08 st %o0, [ %i0 + 8 ] if ( stats->max_free_blocks < stats->free_blocks ) 200c53c: 80 a0 40 02 cmp %g1, %g2 200c540: 08 bf ff e7 bleu 200c4dc <_Heap_Free+0x160> 200c544: c2 26 20 38 st %g1, [ %i0 + 0x38 ] stats->max_free_blocks = stats->free_blocks; 200c548: 10 bf ff e5 b 200c4dc <_Heap_Free+0x160> 200c54c: c2 26 20 3c st %g1, [ %i0 + 0x3c ] _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; } else { /* coalesce prev */ uint32_t const size = the_size + prev_size; prev_block->size = size | HEAP_PREV_USED; 200c550: 84 10 e0 01 or %g3, 1, %g2 200c554: c4 22 e0 04 st %g2, [ %o3 + 4 ] next_block->size &= ~HEAP_PREV_USED; 200c558: c2 01 20 04 ld [ %g4 + 4 ], %g1 next_block->prev_size = size; 200c55c: c6 22 00 0d st %g3, [ %o0 + %o5 ] next_block->prev_size = size; } else { /* coalesce prev */ uint32_t const size = the_size + prev_size; prev_block->size = size | HEAP_PREV_USED; next_block->size &= ~HEAP_PREV_USED; 200c560: 82 08 7f fe and %g1, -2, %g1 200c564: 10 bf ff de b 200c4dc <_Heap_Free+0x160> 200c568: c2 21 20 04 st %g1, [ %g4 + 4 ] =============================================================================== 0200edbc <_Heap_Get_free_information>: */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 200edbc: da 02 20 08 ld [ %o0 + 8 ], %o5 ) { Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 200edc0: c0 22 40 00 clr [ %o1 ] info->largest = 0; 200edc4: c0 22 60 04 clr [ %o1 + 4 ] info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; 200edc8: 80 a2 00 0d cmp %o0, %o5 200edcc: 02 80 00 12 be 200ee14 <_Heap_Get_free_information+0x58> <== NEVER TAKEN 200edd0: c0 22 60 08 clr [ %o1 + 8 ] 200edd4: 88 10 20 00 clr %g4 200edd8: 86 10 20 00 clr %g3 */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 200eddc: c2 03 60 04 ld [ %o5 + 4 ], %g1 /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; info->total += the_size; if ( info->largest < the_size ) 200ede0: c4 02 60 04 ld [ %o1 + 4 ], %g2 200ede4: 82 08 7f fe and %g1, -2, %g1 uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 200ede8: 88 01 20 01 inc %g4 info->total += the_size; 200edec: 86 00 c0 01 add %g3, %g1, %g3 uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 200edf0: c8 22 40 00 st %g4, [ %o1 ] info->total += the_size; if ( info->largest < the_size ) 200edf4: 80 a0 80 01 cmp %g2, %g1 200edf8: 1a 80 00 03 bcc 200ee04 <_Heap_Get_free_information+0x48> <== NEVER TAKEN 200edfc: c6 22 60 08 st %g3, [ %o1 + 8 ] info->largest = the_size; 200ee00: c2 22 60 04 st %g1, [ %o1 + 4 ] info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 200ee04: da 03 60 08 ld [ %o5 + 8 ], %o5 info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; 200ee08: 80 a2 00 0d cmp %o0, %o5 200ee0c: 32 bf ff f5 bne,a 200ede0 <_Heap_Get_free_information+0x24> 200ee10: c2 03 60 04 ld [ %o5 + 4 ], %g1 200ee14: 81 c3 e0 08 retl =============================================================================== 0200ee1c <_Heap_Get_information>: Heap_Control *the_heap, Heap_Information_block *the_info ) { Heap_Block *the_block = the_heap->start; Heap_Block *const end = the_heap->final; 200ee1c: d6 02 20 24 ld [ %o0 + 0x24 ], %o3 Heap_Get_information_status _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { Heap_Block *the_block = the_heap->start; 200ee20: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 Heap_Block *const end = the_heap->final; _HAssert(the_block->prev_size == HEAP_PREV_USED); _HAssert(_Heap_Is_prev_used(the_block)); the_info->Free.number = 0; 200ee24: c0 22 40 00 clr [ %o1 ] the_info->Free.total = 0; 200ee28: c0 22 60 08 clr [ %o1 + 8 ] the_info->Free.largest = 0; 200ee2c: c0 22 60 04 clr [ %o1 + 4 ] the_info->Used.number = 0; 200ee30: c0 22 60 0c clr [ %o1 + 0xc ] the_info->Used.total = 0; 200ee34: c0 22 60 14 clr [ %o1 + 0x14 ] the_info->Used.largest = 0; while ( the_block != end ) { 200ee38: 80 a0 40 0b cmp %g1, %o3 200ee3c: 02 80 00 26 be 200eed4 <_Heap_Get_information+0xb8> <== NEVER TAKEN 200ee40: c0 22 60 10 clr [ %o1 + 0x10 ] 200ee44: 10 80 00 0e b 200ee7c <_Heap_Get_information+0x60> 200ee48: d8 00 60 04 ld [ %g1 + 4 ], %o4 uint32_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); if ( _Heap_Is_prev_used(next_block) ) { the_info->Used.number++; the_info->Used.total += the_size; 200ee4c: c4 02 60 14 ld [ %o1 + 0x14 ], %g2 if ( the_info->Used.largest < the_size ) 200ee50: c6 02 60 10 ld [ %o1 + 0x10 ], %g3 while ( the_block != end ) { uint32_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); if ( _Heap_Is_prev_used(next_block) ) { the_info->Used.number++; 200ee54: 82 00 60 01 inc %g1 the_info->Used.total += the_size; 200ee58: 84 00 80 04 add %g2, %g4, %g2 while ( the_block != end ) { uint32_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); if ( _Heap_Is_prev_used(next_block) ) { the_info->Used.number++; 200ee5c: c2 22 60 0c st %g1, [ %o1 + 0xc ] the_info->Used.total += the_size; if ( the_info->Used.largest < the_size ) 200ee60: 80 a0 c0 04 cmp %g3, %g4 200ee64: 1a 80 00 03 bcc 200ee70 <_Heap_Get_information+0x54> 200ee68: c4 22 60 14 st %g2, [ %o1 + 0x14 ] the_info->Used.largest = the_size; 200ee6c: c8 22 60 10 st %g4, [ %o1 + 0x10 ] the_info->Free.largest = 0; the_info->Used.number = 0; the_info->Used.total = 0; the_info->Used.largest = 0; while ( the_block != end ) { 200ee70: 80 a2 c0 0d cmp %o3, %o5 200ee74: 02 80 00 18 be 200eed4 <_Heap_Get_information+0xb8> 200ee78: 82 10 00 0d mov %o5, %g1 200ee7c: 88 0b 3f fe and %o4, -2, %g4 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200ee80: 9a 00 40 04 add %g1, %g4, %o5 */ RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used ( Heap_Block *the_block ) { return (the_block->size & HEAP_PREV_USED); 200ee84: d8 03 60 04 ld [ %o5 + 4 ], %o4 uint32_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); if ( _Heap_Is_prev_used(next_block) ) { 200ee88: 80 8b 20 01 btst 1, %o4 200ee8c: 32 bf ff f0 bne,a 200ee4c <_Heap_Get_information+0x30> 200ee90: c2 02 60 0c ld [ %o1 + 0xc ], %g1 the_info->Used.number++; the_info->Used.total += the_size; if ( the_info->Used.largest < the_size ) the_info->Used.largest = the_size; } else { the_info->Free.number++; 200ee94: c2 02 40 00 ld [ %o1 ], %g1 the_info->Free.total += the_size; 200ee98: c4 02 60 08 ld [ %o1 + 8 ], %g2 if ( the_info->Free.largest < the_size ) 200ee9c: c6 02 60 04 ld [ %o1 + 4 ], %g3 the_info->Used.number++; the_info->Used.total += the_size; if ( the_info->Used.largest < the_size ) the_info->Used.largest = the_size; } else { the_info->Free.number++; 200eea0: 82 00 60 01 inc %g1 the_info->Free.total += the_size; 200eea4: 84 00 80 04 add %g2, %g4, %g2 the_info->Used.number++; the_info->Used.total += the_size; if ( the_info->Used.largest < the_size ) the_info->Used.largest = the_size; } else { the_info->Free.number++; 200eea8: c2 22 40 00 st %g1, [ %o1 ] the_info->Free.total += the_size; if ( the_info->Free.largest < the_size ) 200eeac: 80 a0 c0 04 cmp %g3, %g4 200eeb0: 1a 80 00 03 bcc 200eebc <_Heap_Get_information+0xa0> <== NEVER TAKEN 200eeb4: c4 22 60 08 st %g2, [ %o1 + 8 ] the_info->Free.largest = the_size; 200eeb8: c8 22 60 04 st %g4, [ %o1 + 4 ] if ( the_size != next_block->prev_size ) 200eebc: c2 03 40 00 ld [ %o5 ], %g1 200eec0: 80 a0 40 04 cmp %g1, %g4 200eec4: 02 bf ff ec be 200ee74 <_Heap_Get_information+0x58> <== ALWAYS TAKEN 200eec8: 80 a2 c0 0d cmp %o3, %o5 200eecc: 81 c3 e0 08 retl <== NOT EXECUTED 200eed0: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED } /* Handle the last dummy block. Don't consider this block to be "used" as client never allocated it. Make 'Used.total' contain this blocks' overhead though. */ the_info->Used.total += HEAP_OVERHEAD; 200eed4: c2 02 60 14 ld [ %o1 + 0x14 ], %g1 200eed8: 90 10 20 00 clr %o0 200eedc: 82 00 60 08 add %g1, 8, %g1 return HEAP_GET_INFORMATION_SUCCESSFUL; } 200eee0: 81 c3 e0 08 retl 200eee4: c2 22 60 14 st %g1, [ %o1 + 0x14 ] =============================================================================== 02006970 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 2006970: 9d e3 bf 98 save %sp, -104, %sp _H_uptr_t start; _H_uptr_t aligned_start; uint32_t overhead; Heap_Statistics *const stats = &the_heap->stats; if (page_size == 0) 2006974: 80 a6 e0 00 cmp %i3, 0 2006978: 12 80 00 43 bne 2006a84 <_Heap_Initialize+0x114> 200697c: 84 8e e0 07 andcc %i3, 7, %g2 2006980: b6 10 20 08 mov 8, %i3 2006984: a2 10 20 00 clr %l1 /* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET (value of user pointer) is aligned on 'page_size' boundary. Make sure resulting 'aligned_start' is not below 'starting_address'. */ start = _H_p2u(starting_address); aligned_start = start + HEAP_BLOCK_USER_OFFSET; 2006988: a0 06 60 08 add %i1, 8, %l0 uint32_t alignment ) { _H_uptr_t v = *value; uint32_t a = alignment; _H_uptr_t r = v % a; 200698c: 92 10 00 1b mov %i3, %o1 2006990: 40 00 37 d7 call 20148ec <.urem> 2006994: 90 10 00 10 mov %l0, %o0 *value = r ? v - r + a : v; 2006998: 80 a2 20 00 cmp %o0, 0 200699c: 22 80 00 05 be,a 20069b0 <_Heap_Initialize+0x40> 20069a0: 82 06 e0 10 add %i3, 0x10, %g1 20069a4: 82 06 c0 10 add %i3, %l0, %g1 20069a8: a0 20 40 08 sub %g1, %o0, %l0 ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 20069ac: 82 06 e0 10 add %i3, 0x10, %g1 20069b0: 80 a4 60 00 cmp %l1, 0 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 20069b4: a4 04 3f f8 add %l0, -8, %l2 20069b8: 12 80 00 03 bne 20069c4 <_Heap_Initialize+0x54> 20069bc: 82 20 40 11 sub %g1, %l1, %g1 20069c0: 82 10 20 10 mov 0x10, %g1 20069c4: c2 26 20 14 st %g1, [ %i0 + 0x14 ] /* Calculate 'the_size' -- size of the first block so that there is enough space at the end for the permanent last block. It is equal to 'size' minus total overhead aligned down to the nearest multiple of 'page_size'. */ overhead = HEAP_OVERHEAD + (aligned_start - start); 20069c8: 82 24 80 19 sub %l2, %i1, %g1 20069cc: 82 00 60 08 add %g1, 8, %g1 if ( size < overhead ) 20069d0: 80 a0 40 1a cmp %g1, %i2 20069d4: 18 80 00 2a bgu 2006a7c <_Heap_Initialize+0x10c> <== NEVER TAKEN 20069d8: a0 26 80 01 sub %i2, %g1, %l0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 20069dc: 92 10 00 1b mov %i3, %o1 20069e0: 40 00 37 c3 call 20148ec <.urem> 20069e4: 90 10 00 10 mov %l0, %o0 return 0; /* Too small area for the heap */ the_size = size - overhead; _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 20069e8: a0 a4 00 08 subcc %l0, %o0, %l0 20069ec: 02 80 00 24 be 2006a7c <_Heap_Initialize+0x10c> 20069f0: 09 00 80 5f sethi %hi(0x2017c00), %g4 return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 20069f4: f6 26 20 10 st %i3, [ %i0 + 0x10 ] the_heap->begin = starting_address; the_heap->end = starting_address + size; the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 20069f8: f6 24 80 00 st %i3, [ %l2 ] the_block->size = the_size | HEAP_PREV_USED; 20069fc: 82 14 20 01 or %l0, 1, %g1 stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 2006a00: c6 01 23 dc ld [ %g4 + 0x3dc ], %g3 the_heap->end = starting_address + size; the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; 2006a04: c2 24 a0 04 st %g1, [ %l2 + 4 ] _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ 2006a08: e0 24 80 10 st %l0, [ %l2 + %l0 ] RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( void *base, uint32_t offset ) { return (void *)((char *)base + offset); 2006a0c: 9a 04 80 10 add %l2, %l0, %o5 the_block->size = page_size; 2006a10: f6 23 60 04 st %i3, [ %o5 + 4 ] the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; the_block->next = _Heap_Tail( the_heap ); 2006a14: f0 24 a0 08 st %i0, [ %l2 + 8 ] the_block->prev = _Heap_Head( the_heap ); 2006a18: f0 24 a0 0c st %i0, [ %l2 + 0xc ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 2006a1c: c6 26 20 28 st %g3, [ %i0 + 0x28 ] the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ the_block->size = page_size; stats->size = size; 2006a20: f4 26 20 2c st %i2, [ %i0 + 0x2c ] stats->free_size = the_size; 2006a24: e0 26 20 30 st %l0, [ %i0 + 0x30 ] stats->min_free_size = the_size; 2006a28: e0 26 20 34 st %l0, [ %i0 + 0x34 ] stats->free_blocks = 1; stats->max_free_blocks = 1; stats->used_blocks = 0; 2006a2c: c0 26 20 40 clr [ %i0 + 0x40 ] stats->max_search = 0; 2006a30: c0 26 20 44 clr [ %i0 + 0x44 ] stats->allocs = 0; 2006a34: c0 26 20 48 clr [ %i0 + 0x48 ] stats->searches = 0; 2006a38: c0 26 20 4c clr [ %i0 + 0x4c ] stats->frees = 0; 2006a3c: c0 26 20 50 clr [ %i0 + 0x50 ] stats->resizes = 0; 2006a40: c0 26 20 54 clr [ %i0 + 0x54 ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 2006a44: 84 10 20 01 mov 1, %g2 stats->max_free_blocks = 1; 2006a48: c4 26 20 3c st %g2, [ %i0 + 0x3c ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 2006a4c: c4 26 20 38 st %g2, [ %i0 + 0x38 ] if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 2006a50: 82 06 40 1a add %i1, %i2, %g1 stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 2006a54: 86 00 e0 01 inc %g3 if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 2006a58: c2 26 20 1c st %g1, [ %i0 + 0x1c ] _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; 2006a5c: f2 26 20 18 st %i1, [ %i0 + 0x18 ] the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; the_block->next = _Heap_Tail( the_heap ); the_block->prev = _Heap_Head( the_heap ); _Heap_Head(the_heap)->next = the_block; 2006a60: e4 26 20 08 st %l2, [ %i0 + 8 ] _Heap_Tail(the_heap)->prev = the_block; 2006a64: e4 26 20 0c st %l2, [ %i0 + 0xc ] the_heap->start = the_block; 2006a68: e4 26 20 20 st %l2, [ %i0 + 0x20 ] _HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT)); _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ 2006a6c: da 26 20 24 st %o5, [ %i0 + 0x24 ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 2006a70: c6 21 23 dc st %g3, [ %g4 + 0x3dc ] return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 2006a74: 81 c7 e0 08 ret 2006a78: 91 ec 3f fc restore %l0, -4, %o0 } 2006a7c: 81 c7 e0 08 ret 2006a80: 91 e8 20 00 restore %g0, 0, %o0 ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 2006a84: 02 80 00 04 be 2006a94 <_Heap_Initialize+0x124> 2006a88: 90 10 20 10 mov 0x10, %o0 2006a8c: 82 06 e0 08 add %i3, 8, %g1 2006a90: b6 20 40 02 sub %g1, %g2, %i3 2006a94: 40 00 37 96 call 20148ec <.urem> 2006a98: 92 10 00 1b mov %i3, %o1 2006a9c: 10 bf ff bb b 2006988 <_Heap_Initialize+0x18> 2006aa0: a2 10 00 08 mov %o0, %l1 =============================================================================== 02015a9c <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 2015a9c: 9d e3 bf 98 save %sp, -104, %sp Heap_Block *next_next_block; uint32_t old_block_size; uint32_t old_user_size; uint32_t prev_used_flag; Heap_Statistics *const stats = &the_heap->stats; uint32_t const min_block_size = the_heap->min_block_size; 2015aa0: ec 06 20 14 ld [ %i0 + 0x14 ], %l6 uint32_t const page_size = the_heap->page_size; 2015aa4: ea 06 20 10 ld [ %i0 + 0x10 ], %l5 *old_mem_size = 0; 2015aa8: c0 26 c0 00 clr [ %i3 ] *avail_mem_size = 0; 2015aac: c0 27 00 00 clr [ %i4 ] /* The address passed could be greater than the block address plus * HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user * pointers. To get rid of this offset we need to align the address down * to the nearest 'page_size' boundary. */ _Heap_Align_down_uptr ( &addr, the_heap->page_size ); *the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET); 2015ab0: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 2015ab4: 7f ff fb 8e call 20148ec <.urem> 2015ab8: 90 10 00 19 mov %i1, %o0 RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in ( Heap_Control *the_heap, Heap_Block *the_block ) { return _Addresses_Is_in_range( the_block, the_heap->start, the_heap->final ); 2015abc: c8 06 20 20 ld [ %i0 + 0x20 ], %g4 2015ac0: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 /* The address passed could be greater than the block address plus * HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user * pointers. To get rid of this offset we need to align the address down * to the nearest 'page_size' boundary. */ _Heap_Align_down_uptr ( &addr, the_heap->page_size ); *the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET); 2015ac4: 82 06 7f f8 add %i1, -8, %g1 2015ac8: a2 20 40 08 sub %g1, %o0, %l1 _Heap_Start_of_block(the_heap, starting_address, &the_block); _HAssert(_Heap_Is_block_in(the_heap, the_block)); if (!_Heap_Is_block_in(the_heap, the_block)) 2015acc: 80 a4 40 04 cmp %l1, %g4 2015ad0: 84 60 3f ff subx %g0, -1, %g2 2015ad4: 80 a0 c0 11 cmp %g3, %l1 2015ad8: 82 60 3f ff subx %g0, -1, %g1 2015adc: 80 88 80 01 btst %g2, %g1 2015ae0: 02 80 00 2f be 2015b9c <_Heap_Resize_block+0x100> 2015ae4: a6 10 00 18 mov %i0, %l3 return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 2015ae8: da 04 60 04 ld [ %l1 + 4 ], %o5 */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 2015aec: b0 0b 7f fe and %o5, -2, %i0 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 2015af0: a4 04 40 18 add %l1, %i0, %l2 old_block_size = _Heap_Block_size(the_block); next_block = _Heap_Block_at(the_block, old_block_size); _HAssert(_Heap_Is_block_in(the_heap, next_block)); _HAssert(_Heap_Is_prev_used(next_block)); if ( !_Heap_Is_block_in(the_heap, next_block) || 2015af4: 80 a4 80 04 cmp %l2, %g4 2015af8: 84 60 3f ff subx %g0, -1, %g2 2015afc: 80 a0 c0 12 cmp %g3, %l2 2015b00: 82 60 3f ff subx %g0, -1, %g1 2015b04: 80 88 80 01 btst %g2, %g1 2015b08: 02 80 00 25 be 2015b9c <_Heap_Resize_block+0x100> <== NEVER TAKEN 2015b0c: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used ( Heap_Block *the_block ) { return (the_block->size & HEAP_PREV_USED); 2015b10: c2 04 a0 04 ld [ %l2 + 4 ], %g1 2015b14: 80 88 60 01 btst 1, %g1 2015b18: 02 80 00 21 be 2015b9c <_Heap_Resize_block+0x100> <== NEVER TAKEN 2015b1c: ae 08 7f fe and %g1, -2, %l7 !_Heap_Is_prev_used(next_block)) return HEAP_RESIZE_FATAL_ERROR; next_block_size = _Heap_Block_size(next_block); next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || 2015b20: 80 a0 c0 12 cmp %g3, %l2 2015b24: a8 10 20 01 mov 1, %l4 2015b28: 02 80 00 04 be 2015b38 <_Heap_Resize_block+0x9c> <== NEVER TAKEN 2015b2c: 82 04 80 17 add %l2, %l7, %g1 2015b30: c2 00 60 04 ld [ %g1 + 4 ], %g1 2015b34: a8 08 60 01 and %g1, 1, %l4 _Heap_Is_prev_used(next_next_block); /* See _Heap_Size_of_user_area() source for explanations */ old_user_size = _Addresses_Subtract(next_block, starting_address) 2015b38: 82 24 80 19 sub %l2, %i1, %g1 2015b3c: 82 00 60 04 add %g1, 4, %g1 + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 2015b40: c2 26 c0 00 st %g1, [ %i3 ] if (size > old_user_size) { 2015b44: 80 a0 40 1a cmp %g1, %i2 2015b48: 1a 80 00 17 bcc 2015ba4 <_Heap_Resize_block+0x108> 2015b4c: b6 0b 60 01 and %o5, 1, %i3 /* Need to extend the block: allocate part of the next block and then merge 'the_block' and allocated block together. */ if (next_is_used) /* Next block is in use, -- no way to extend */ 2015b50: 80 8d 20 ff btst 0xff, %l4 2015b54: 12 80 00 10 bne 2015b94 <_Heap_Resize_block+0xf8> 2015b58: a0 26 80 01 sub %i2, %g1, %l0 uint32_t alignment ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; 2015b5c: 92 10 00 15 mov %l5, %o1 2015b60: 7f ff fb 63 call 20148ec <.urem> 2015b64: 90 10 00 10 mov %l0, %o0 *value = r ? v - r + a : v; 2015b68: 80 a2 20 00 cmp %o0, 0 2015b6c: 02 80 00 05 be 2015b80 <_Heap_Resize_block+0xe4> <== NEVER TAKEN 2015b70: 80 a4 00 16 cmp %l0, %l6 2015b74: 82 04 00 15 add %l0, %l5, %g1 2015b78: a0 20 40 08 sub %g1, %o0, %l0 2015b7c: 80 a4 00 16 cmp %l0, %l6 2015b80: 0a 80 00 2e bcs 2015c38 <_Heap_Resize_block+0x19c> <== ALWAYS TAKEN 2015b84: 90 10 00 10 mov %l0, %o0 else { uint32_t add_block_size = size - old_user_size; _Heap_Align_up(&add_block_size, page_size); if (add_block_size < min_block_size) add_block_size = min_block_size; if (add_block_size > next_block_size) 2015b88: 80 a5 c0 08 cmp %l7, %o0 2015b8c: 1a 80 00 32 bcc 2015c54 <_Heap_Resize_block+0x1b8> <== ALWAYS TAKEN 2015b90: 94 10 00 08 mov %o0, %o2 } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; } 2015b94: 81 c7 e0 08 ret 2015b98: 91 e8 20 01 restore %g0, 1, %o0 } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 2015b9c: 81 c7 e0 08 ret 2015ba0: 91 e8 20 02 restore %g0, 2, %o0 --stats->used_blocks; } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 2015ba4: a0 20 40 1a sub %g1, %i2, %l0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 2015ba8: 92 10 00 15 mov %l5, %o1 2015bac: 7f ff fb 50 call 20148ec <.urem> 2015bb0: 90 10 00 10 mov %l0, %o0 _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 2015bb4: a0 a4 00 08 subcc %l0, %o0, %l0 2015bb8: 22 80 00 1c be,a 2015c28 <_Heap_Resize_block+0x18c> 2015bbc: c2 04 e0 54 ld [ %l3 + 0x54 ], %g1 /* To free some memory the block should be shortened so that it can can hold 'size' user bytes and still remain not shorter than 'min_block_size'. */ uint32_t new_block_size = old_block_size - free_block_size; 2015bc0: 84 26 00 10 sub %i0, %l0, %g2 if (new_block_size < min_block_size) { 2015bc4: 80 a5 80 02 cmp %l6, %g2 2015bc8: 18 80 00 1e bgu 2015c40 <_Heap_Resize_block+0x1a4> 2015bcc: 82 25 80 02 sub %l6, %g2, %g1 _HAssert(new_block_size >= min_block_size); _HAssert(new_block_size + free_block_size == old_block_size); _HAssert(_Heap_Is_aligned(new_block_size, page_size)); _HAssert(_Heap_Is_aligned(free_block_size, page_size)); if (!next_is_used) { 2015bd0: 80 8d 20 ff btst 0xff, %l4 2015bd4: 12 80 00 2a bne 2015c7c <_Heap_Resize_block+0x1e0> <== NEVER TAKEN 2015bd8: 80 a5 80 10 cmp %l6, %l0 Heap_Block *const new_next_block = _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 2015bdc: 82 10 80 1b or %g2, %i3, %g1 2015be0: c2 24 60 04 st %g1, [ %l1 + 4 ] RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 2015be4: 86 04 40 02 add %l1, %g2, %g3 Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; 2015be8: d8 04 a0 0c ld [ %l2 + 0xc ], %o4 if (!next_is_used) { /* Extend the next block to the low addresses by 'free_block_size' */ Heap_Block *const new_next_block = _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; 2015bec: 88 04 00 17 add %l0, %l7, %g4 Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; 2015bf0: da 04 a0 08 ld [ %l2 + 8 ], %o5 _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; new_next_block->size = new_next_block_size | HEAP_PREV_USED; next_next_block->prev_size = new_next_block_size; 2015bf4: c8 24 80 17 st %g4, [ %l2 + %l7 ] _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; new_next_block->size = new_next_block_size | HEAP_PREV_USED; 2015bf8: 84 11 20 01 or %g4, 1, %g2 2015bfc: c4 20 e0 04 st %g2, [ %g3 + 4 ] next_next_block->prev_size = new_next_block_size; _Heap_Block_replace(next_block, new_next_block); the_heap->stats.free_size += free_block_size; 2015c00: c2 04 e0 30 ld [ %l3 + 0x30 ], %g1 Heap_Block *prev = block->prev; block = new_block; block->next = next; 2015c04: da 20 e0 08 st %o5, [ %g3 + 8 ] 2015c08: 82 00 40 10 add %g1, %l0, %g1 block->prev = prev; 2015c0c: d8 20 e0 0c st %o4, [ %g3 + 0xc ] 2015c10: c2 24 e0 30 st %g1, [ %l3 + 0x30 ] *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 2015c14: 88 01 3f fc add %g4, -4, %g4 next->prev = prev->next = block; 2015c18: c6 23 60 0c st %g3, [ %o5 + 0xc ] 2015c1c: c6 23 20 08 st %g3, [ %o4 + 8 ] 2015c20: c8 27 00 00 st %g4, [ %i4 ] *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 2015c24: c2 04 e0 54 ld [ %l3 + 0x54 ], %g1 2015c28: 82 00 60 01 inc %g1 2015c2c: c2 24 e0 54 st %g1, [ %l3 + 0x54 ] 2015c30: 81 c7 e0 08 ret 2015c34: 91 e8 20 00 restore %g0, 0, %o0 ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 2015c38: 10 bf ff d4 b 2015b88 <_Heap_Resize_block+0xec> 2015c3c: 90 10 00 16 mov %l6, %o0 if (new_block_size < min_block_size) { uint32_t delta = min_block_size - new_block_size; _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 2015c40: a0 a4 00 01 subcc %l0, %g1, %l0 2015c44: 12 bf ff e3 bne 2015bd0 <_Heap_Resize_block+0x134> <== NEVER TAKEN 2015c48: 84 00 80 01 add %g2, %g1, %g2 *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 2015c4c: 10 bf ff f7 b 2015c28 <_Heap_Resize_block+0x18c> 2015c50: c2 04 e0 54 ld [ %l3 + 0x54 ], %g1 _Heap_Align_up(&add_block_size, page_size); if (add_block_size < min_block_size) add_block_size = min_block_size; if (add_block_size > next_block_size) return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 2015c54: 92 10 00 12 mov %l2, %o1 2015c58: 7f ff c3 a7 call 2006af4 <_Heap_Block_allocate> 2015c5c: 90 10 00 13 mov %l3, %o0 _Heap_Block_allocate(the_heap, next_block, add_block_size); /* Merge two subsequent blocks */ the_block->size = (old_block_size + add_block_size) | prev_used_flag; 2015c60: 90 02 00 18 add %o0, %i0, %o0 2015c64: 90 12 00 1b or %o0, %i3, %o0 2015c68: d0 24 60 04 st %o0, [ %l1 + 4 ] --stats->used_blocks; 2015c6c: c2 04 e0 40 ld [ %l3 + 0x40 ], %g1 2015c70: 82 00 7f ff add %g1, -1, %g1 2015c74: 10 bf ff ec b 2015c24 <_Heap_Resize_block+0x188> 2015c78: c2 24 e0 40 st %g1, [ %l3 + 0x40 ] next_next_block->prev_size = new_next_block_size; _Heap_Block_replace(next_block, new_next_block); the_heap->stats.free_size += free_block_size; *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; } else if (free_block_size >= min_block_size) { 2015c7c: 38 bf ff eb bgu,a 2015c28 <_Heap_Resize_block+0x18c> <== NOT EXECUTED 2015c80: c2 04 e0 54 ld [ %l3 + 0x54 ], %g1 <== NOT EXECUTED /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; 2015c84: 82 10 80 1b or %g2, %i3, %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 2015c88: 92 04 40 02 add %l1, %g2, %o1 <== NOT EXECUTED 2015c8c: c2 24 60 04 st %g1, [ %l1 + 4 ] <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 2015c90: 84 14 20 01 or %l0, 1, %g2 <== NOT EXECUTED 2015c94: c4 22 60 04 st %g2, [ %o1 + 4 ] <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 2015c98: c2 04 e0 40 ld [ %l3 + 0x40 ], %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 2015c9c: c4 04 e0 50 ld [ %l3 + 0x50 ], %g2 <== NOT EXECUTED } else if (free_block_size >= min_block_size) { /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; ++stats->used_blocks; /* We have created used block */ 2015ca0: 82 00 60 01 inc %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 2015ca4: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED } else if (free_block_size >= min_block_size) { /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; ++stats->used_blocks; /* We have created used block */ 2015ca8: c2 24 e0 40 st %g1, [ %l3 + 0x40 ] <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 2015cac: c4 24 e0 50 st %g2, [ %l3 + 0x50 ] <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 2015cb0: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 2015cb4: 7f ff d9 b2 call 200c37c <_Heap_Free> <== NOT EXECUTED 2015cb8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 2015cbc: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED 2015cc0: 10 bf ff d9 b 2015c24 <_Heap_Resize_block+0x188> <== NOT EXECUTED 2015cc4: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED =============================================================================== 02015cc8 <_Heap_Size_of_user_area>: bool _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 2015cc8: 9d e3 bf 98 save %sp, -104, %sp Heap_Block *the_block; Heap_Block *next_block; uint32_t the_size; if ( !_Addresses_Is_in_range( 2015ccc: e0 06 20 20 ld [ %i0 + 0x20 ], %l0 2015cd0: e2 06 20 24 ld [ %i0 + 0x24 ], %l1 2015cd4: 80 a6 40 10 cmp %i1, %l0 2015cd8: 84 60 3f ff subx %g0, -1, %g2 2015cdc: 80 a4 40 19 cmp %l1, %i1 2015ce0: 82 60 3f ff subx %g0, -1, %g1 2015ce4: 80 88 80 01 btst %g2, %g1 2015ce8: 02 80 00 20 be 2015d68 <_Heap_Size_of_user_area+0xa0> 2015cec: 01 00 00 00 nop /* The address passed could be greater than the block address plus * HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user * pointers. To get rid of this offset we need to align the address down * to the nearest 'page_size' boundary. */ _Heap_Align_down_uptr ( &addr, the_heap->page_size ); *the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET); 2015cf0: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 2015cf4: 7f ff fa fe call 20148ec <.urem> 2015cf8: 90 10 00 19 mov %i1, %o0 2015cfc: 82 06 7f f8 add %i1, -8, %g1 2015d00: 86 20 40 08 sub %g1, %o0, %g3 return( FALSE ); _Heap_Start_of_block( the_heap, starting_address, &the_block ); _HAssert(_Heap_Is_block_in( the_heap, the_block )); if ( !_Heap_Is_block_in( the_heap, the_block ) ) 2015d04: 80 a0 c0 10 cmp %g3, %l0 2015d08: 84 60 3f ff subx %g0, -1, %g2 2015d0c: 80 a4 40 03 cmp %l1, %g3 2015d10: 82 60 3f ff subx %g0, -1, %g1 2015d14: 80 88 80 01 btst %g2, %g1 2015d18: 02 80 00 14 be 2015d68 <_Heap_Size_of_user_area+0xa0> <== NEVER TAKEN 2015d1c: 01 00 00 00 nop RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 2015d20: c2 00 e0 04 ld [ %g3 + 4 ], %g1 2015d24: 82 08 7f fe and %g1, -2, %g1 2015d28: 90 00 c0 01 add %g3, %g1, %o0 the_size = _Heap_Block_size( the_block ); next_block = _Heap_Block_at( the_block, the_size ); _HAssert(_Heap_Is_block_in( the_heap, next_block )); _HAssert(_Heap_Is_prev_used( next_block )); if ( 2015d2c: 80 a2 00 10 cmp %o0, %l0 2015d30: 84 60 3f ff subx %g0, -1, %g2 2015d34: 80 a4 40 08 cmp %l1, %o0 2015d38: 82 60 3f ff subx %g0, -1, %g1 2015d3c: 80 88 80 01 btst %g2, %g1 2015d40: 02 80 00 0a be 2015d68 <_Heap_Size_of_user_area+0xa0> <== NEVER TAKEN 2015d44: 01 00 00 00 nop 2015d48: c2 02 20 04 ld [ %o0 + 4 ], %g1 2015d4c: 80 88 60 01 btst 1, %g1 2015d50: 02 80 00 06 be 2015d68 <_Heap_Size_of_user_area+0xa0> <== NEVER TAKEN 2015d54: 82 22 00 19 sub %o0, %i1, %g1 and then add correction equal to the offset of the 'size' field of the 'Heap_Block' structure. The correction is due to the fact that 'prev_size' field of the next block is actually used as user accessible area of 'the_block'. */ *size = _Addresses_Subtract ( next_block, starting_address ) 2015d58: 82 00 60 04 add %g1, 4, %g1 2015d5c: c2 26 80 00 st %g1, [ %i2 ] 2015d60: 81 c7 e0 08 ret 2015d64: 91 e8 20 01 restore %g0, 1, %o0 + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); } 2015d68: 81 c7 e0 08 ret 2015d6c: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 0200ef90 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 200ef90: 9d e3 bf 98 save %sp, -104, %sp /* if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) 200ef94: 80 a6 60 00 cmp %i1, 0 Heap_Control *the_heap, int source, bool do_dump ) { Heap_Block *the_block = the_heap->start; 200ef98: e2 06 20 20 ld [ %i0 + 0x20 ], %l1 /* if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) 200ef9c: 06 80 00 8c bl 200f1cc <_Heap_Walk+0x23c> <== NEVER TAKEN 200efa0: ec 06 20 24 ld [ %i0 + 0x24 ], %l6 /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { 200efa4: c2 04 60 04 ld [ %l1 + 4 ], %g1 200efa8: 80 88 60 01 btst 1, %g1 200efac: 02 80 00 81 be 200f1b0 <_Heap_Walk+0x220> <== NEVER TAKEN 200efb0: a6 10 20 00 clr %l3 printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source); error = 1; } if (the_block->prev_size != the_heap->page_size) { 200efb4: c4 04 40 00 ld [ %l1 ], %g2 200efb8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 200efbc: 80 a0 80 01 cmp %g2, %g1 200efc0: 02 80 00 08 be 200efe0 <_Heap_Walk+0x50> <== ALWAYS TAKEN 200efc4: 80 a4 40 16 cmp %l1, %l6 printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); 200efc8: 11 00 80 6f sethi %hi(0x201bc00), %o0 <== NOT EXECUTED 200efcc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200efd0: 90 12 22 e0 or %o0, 0x2e0, %o0 <== NOT EXECUTED 200efd4: 7f ff d7 3d call 2004cc8 <== NOT EXECUTED 200efd8: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED error = 1; } while ( the_block != end ) { 200efdc: 80 a4 40 16 cmp %l1, %l6 <== NOT EXECUTED 200efe0: 22 80 00 63 be,a 200f16c <_Heap_Walk+0x1dc> <== NEVER TAKEN 200efe4: a2 10 00 16 mov %l6, %l1 <== NOT EXECUTED printk(" prev_size %d", the_block->prev_size); else printk(" (prev_size) %d", the_block->prev_size); } if (!_Heap_Is_block_in(the_heap, next_block)) { 200efe8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 200efec: c8 04 60 04 ld [ %l1 + 4 ], %g4 200eff0: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 200eff4: a4 09 3f fe and %g4, -2, %l2 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200eff8: a0 04 40 12 add %l1, %l2, %l0 200effc: 80 a4 00 01 cmp %l0, %g1 200f000: 84 60 3f ff subx %g0, -1, %g2 200f004: 80 a0 c0 10 cmp %g3, %l0 200f008: 82 60 3f ff subx %g0, -1, %g1 200f00c: 80 88 80 01 btst %g2, %g1 200f010: 02 80 00 77 be 200f1ec <_Heap_Walk+0x25c> <== NEVER TAKEN 200f014: 03 00 80 6c sethi %hi(0x201b000), %g1 Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); printk("PASS: %d !the_block not in the free list", source); 200f018: 05 00 80 6f sethi %hi(0x201bc00), %g2 { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); 200f01c: ba 10 60 b0 or %g1, 0xb0, %i5 printk("PASS: %d !the_block not in the free list", source); 200f020: ae 10 a3 a0 or %g2, 0x3a0, %l7 printk("PASS: %d !front and back sizes don't match", source); error = 1; } if (!prev_used) { if (do_dump || error) printk("\n"); printk("PASS: %d !two consecutive blocks are free", source); 200f024: 03 00 80 6f sethi %hi(0x201bc00), %g1 if (!_Heap_Is_prev_used(next_block)) { if (do_dump) printk( " prev %p next %p", the_block->prev, the_block->next); if (_Heap_Block_size(the_block) != next_block->prev_size) { if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 200f028: 05 00 80 6f sethi %hi(0x201bc00), %g2 */ RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used ( Heap_Block *the_block ) { return (the_block->size & HEAP_PREV_USED); 200f02c: a8 09 20 01 and %g4, 1, %l4 error = 1; } if (!prev_used) { if (do_dump || error) printk("\n"); printk("PASS: %d !two consecutive blocks are free", source); 200f030: b8 10 63 70 or %g1, 0x370, %i4 if (!_Heap_Is_prev_used(next_block)) { if (do_dump) printk( " prev %p next %p", the_block->prev, the_block->next); if (_Heap_Block_size(the_block) != next_block->prev_size) { if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 200f034: b6 10 a3 40 or %g2, 0x340, %i3 200f038: aa 10 00 10 mov %l0, %l5 printk("PASS: %d !block %p is out of heap\n", source, next_block); error = 1; break; } if (!_Heap_Is_prev_used(next_block)) { 200f03c: c2 04 20 04 ld [ %l0 + 4 ], %g1 200f040: 80 88 60 01 btst 1, %g1 200f044: 12 80 00 20 bne 200f0c4 <_Heap_Walk+0x134> 200f048: 80 a4 e0 00 cmp %l3, 0 if (do_dump) printk( " prev %p next %p", the_block->prev, the_block->next); if (_Heap_Block_size(the_block) != next_block->prev_size) { 200f04c: c2 04 00 00 ld [ %l0 ], %g1 200f050: 80 a0 40 12 cmp %g1, %l2 200f054: 02 80 00 07 be 200f070 <_Heap_Walk+0xe0> <== ALWAYS TAKEN 200f058: 80 8d 20 ff btst 0xff, %l4 if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 200f05c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 200f060: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200f064: 7f ff d7 19 call 2004cc8 <== NOT EXECUTED 200f068: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED error = 1; } if (!prev_used) { 200f06c: 80 8d 20 ff btst 0xff, %l4 <== NOT EXECUTED 200f070: 32 80 00 0a bne,a 200f098 <_Heap_Walk+0x108> <== ALWAYS TAKEN 200f074: c2 06 20 08 ld [ %i0 + 8 ], %g1 if (do_dump || error) printk("\n"); 200f078: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED 200f07c: 12 80 00 49 bne 200f1a0 <_Heap_Walk+0x210> <== NOT EXECUTED 200f080: 01 00 00 00 nop <== NOT EXECUTED printk("PASS: %d !two consecutive blocks are free", source); 200f084: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 200f088: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200f08c: 7f ff d7 0f call 2004cc8 <== NOT EXECUTED 200f090: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 200f094: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED error = 1; } { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) 200f098: 80 a0 40 11 cmp %g1, %l1 200f09c: 02 80 00 0a be 200f0c4 <_Heap_Walk+0x134> 200f0a0: 80 a4 e0 00 cmp %l3, 0 200f0a4: 80 a6 00 01 cmp %i0, %g1 200f0a8: 02 80 00 58 be 200f208 <_Heap_Walk+0x278> <== NEVER TAKEN 200f0ac: 80 a0 40 11 cmp %g1, %l1 block = block->next; 200f0b0: c2 00 60 08 ld [ %g1 + 8 ], %g1 error = 1; } { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) 200f0b4: 80 a0 40 11 cmp %g1, %l1 200f0b8: 12 bf ff fc bne 200f0a8 <_Heap_Walk+0x118> 200f0bc: 80 a6 00 01 cmp %i0, %g1 error = 1; } } } if (do_dump || error) printk("\n"); 200f0c0: 80 a4 e0 00 cmp %l3, 0 200f0c4: 32 80 00 58 bne,a 200f224 <_Heap_Walk+0x294> <== NEVER TAKEN 200f0c8: 27 00 80 6c sethi %hi(0x201b000), %l3 <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 200f0cc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 200f0d0: 80 a0 40 12 cmp %g1, %l2 200f0d4: 18 80 00 40 bgu 200f1d4 <_Heap_Walk+0x244> <== NEVER TAKEN 200f0d8: 11 00 80 6f sethi %hi(0x201bc00), %o0 printk("PASS: %d !block size is too small\n", source); error = 1; break; } if (!_Heap_Is_aligned( the_size, the_heap->page_size)) { 200f0dc: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 200f0e0: 40 00 27 8b call 2018f0c <.urem> 200f0e4: 90 10 00 12 mov %l2, %o0 200f0e8: 80 a2 20 00 cmp %o0, 0 200f0ec: 12 80 00 15 bne 200f140 <_Heap_Walk+0x1b0> <== NEVER TAKEN 200f0f0: 80 a4 e0 00 cmp %l3, 0 printk("PASS: %d !block size is misaligned\n", source); error = 1; } if (++passes > (do_dump ? 10 : 0) && error) 200f0f4: 12 80 00 17 bne 200f150 <_Heap_Walk+0x1c0> <== NEVER TAKEN 200f0f8: 80 a5 80 10 cmp %l6, %l0 if (the_block->prev_size != the_heap->page_size) { printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); error = 1; } while ( the_block != end ) { 200f0fc: 02 80 00 1c be 200f16c <_Heap_Walk+0x1dc> 200f100: a2 10 00 16 mov %l6, %l1 */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 200f104: c8 04 20 04 ld [ %l0 + 4 ], %g4 printk(" prev_size %d", the_block->prev_size); else printk(" (prev_size) %d", the_block->prev_size); } if (!_Heap_Is_block_in(the_heap, next_block)) { 200f108: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 200f10c: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 200f110: a4 09 3f fe and %g4, -2, %l2 200f114: a0 04 00 12 add %l0, %l2, %l0 200f118: 80 a4 00 01 cmp %l0, %g1 200f11c: 84 60 3f ff subx %g0, -1, %g2 200f120: 80 a0 c0 10 cmp %g3, %l0 200f124: 82 60 3f ff subx %g0, -1, %g1 200f128: 80 88 80 01 btst %g2, %g1 200f12c: 02 80 00 2f be 200f1e8 <_Heap_Walk+0x258> <== NEVER TAKEN 200f130: a8 09 20 01 and %g4, 1, %l4 */ RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used ( Heap_Block *the_block ) { return (the_block->size & HEAP_PREV_USED); 200f134: a2 10 00 15 mov %l5, %l1 200f138: 10 bf ff c1 b 200f03c <_Heap_Walk+0xac> 200f13c: aa 10 00 10 mov %l0, %l5 printk("PASS: %d !block size is too small\n", source); error = 1; break; } if (!_Heap_Is_aligned( the_size, the_heap->page_size)) { printk("PASS: %d !block size is misaligned\n", source); 200f140: 11 00 80 6f sethi %hi(0x201bc00), %o0 <== NOT EXECUTED 200f144: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200f148: 7f ff d6 e0 call 2004cc8 <== NOT EXECUTED 200f14c: 90 12 23 f8 or %o0, 0x3f8, %o0 <== NOT EXECUTED the_block = next_block; } if (the_block != end) { printk("PASS: %d !last block address isn't equal to 'final' %p %p\n", 200f150: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED 200f154: 11 00 80 70 sethi %hi(0x201c000), %o0 <== NOT EXECUTED 200f158: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200f15c: 90 12 20 20 or %o0, 0x20, %o0 <== NOT EXECUTED 200f160: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED 200f164: 7f ff d6 d9 call 2004cc8 <== NOT EXECUTED 200f168: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 200f16c: d6 06 20 10 ld [ %i0 + 0x10 ], %o3 */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 200f170: c2 04 60 04 ld [ %l1 + 4 ], %g1 200f174: 94 08 7f fe and %g1, -2, %o2 200f178: 80 a2 c0 0a cmp %o3, %o2 200f17c: 02 80 00 07 be 200f198 <_Heap_Walk+0x208> <== ALWAYS TAKEN 200f180: b0 10 00 13 mov %l3, %i0 printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 200f184: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200f188: 11 00 80 70 sethi %hi(0x201c000), %o0 <== NOT EXECUTED 200f18c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED 200f190: 7f ff d6 ce call 2004cc8 <== NOT EXECUTED 200f194: 90 12 20 60 or %o0, 0x60, %o0 <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 200f198: 81 c7 e0 08 ret 200f19c: 81 e8 00 00 restore if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); error = 1; } if (!prev_used) { if (do_dump || error) printk("\n"); 200f1a0: 7f ff d6 ca call 2004cc8 <== NOT EXECUTED 200f1a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED printk("PASS: %d !two consecutive blocks are free", source); 200f1a8: 10 bf ff b8 b 200f088 <_Heap_Walk+0xf8> <== NOT EXECUTED 200f1ac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source); 200f1b0: 11 00 80 6f sethi %hi(0x201bc00), %o0 <== NOT EXECUTED 200f1b4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200f1b8: 90 12 22 a8 or %o0, 0x2a8, %o0 <== NOT EXECUTED 200f1bc: 7f ff d6 c3 call 2004cc8 <== NOT EXECUTED 200f1c0: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED error = 1; } if (the_block->prev_size != the_heap->page_size) { 200f1c4: 10 bf ff 7d b 200efb8 <_Heap_Walk+0x28> <== NOT EXECUTED 200f1c8: c4 04 40 00 ld [ %l1 ], %g2 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) source = the_heap->stats.instance; 200f1cc: 10 bf ff 76 b 200efa4 <_Heap_Walk+0x14> <== NOT EXECUTED 200f1d0: f2 06 20 28 ld [ %i0 + 0x28 ], %i1 <== NOT EXECUTED } if (do_dump || error) printk("\n"); if (the_size < the_heap->min_block_size) { printk("PASS: %d !block size is too small\n", source); 200f1d4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200f1d8: 7f ff d6 bc call 2004cc8 <== NOT EXECUTED 200f1dc: 90 12 23 d0 or %o0, 0x3d0, %o0 <== NOT EXECUTED the_block = next_block; } if (the_block != end) { printk("PASS: %d !last block address isn't equal to 'final' %p %p\n", 200f1e0: 10 bf ff dd b 200f154 <_Heap_Walk+0x1c4> <== NOT EXECUTED 200f1e4: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used ( Heap_Block *the_block ) { return (the_block->size & HEAP_PREV_USED); 200f1e8: a2 10 00 15 mov %l5, %l1 <== NOT EXECUTED printk(" (prev_size) %d", the_block->prev_size); } if (!_Heap_Is_block_in(the_heap, next_block)) { if (do_dump) printk("\n"); printk("PASS: %d !block %p is out of heap\n", source, next_block); 200f1ec: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 200f1f0: 11 00 80 6f sethi %hi(0x201bc00), %o0 <== NOT EXECUTED 200f1f4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200f1f8: 7f ff d6 b4 call 2004cc8 <== NOT EXECUTED 200f1fc: 90 12 23 18 or %o0, 0x318, %o0 <== NOT EXECUTED the_block = next_block; } if (the_block != end) { printk("PASS: %d !last block address isn't equal to 'final' %p %p\n", 200f200: 10 bf ff d5 b 200f154 <_Heap_Walk+0x1c4> <== NOT EXECUTED 200f204: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) block = block->next; if(block != the_block) { 200f208: 02 bf ff ae be 200f0c0 <_Heap_Walk+0x130> <== NOT EXECUTED 200f20c: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED if (do_dump || error) printk("\n"); 200f210: 12 80 00 0a bne 200f238 <_Heap_Walk+0x2a8> <== NOT EXECUTED 200f214: 27 00 80 6c sethi %hi(0x201b000), %l3 <== NOT EXECUTED printk("PASS: %d !the_block not in the free list", source); 200f218: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED 200f21c: 7f ff d6 ab call 2004cc8 <== NOT EXECUTED 200f220: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 200f224: 90 14 e0 b0 or %l3, 0xb0, %o0 <== NOT EXECUTED 200f228: 7f ff d6 a8 call 2004cc8 <== NOT EXECUTED 200f22c: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 200f230: 10 bf ff a8 b 200f0d0 <_Heap_Walk+0x140> <== NOT EXECUTED 200f234: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); 200f238: 7f ff d6 a4 call 2004cc8 <== NOT EXECUTED 200f23c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED printk("PASS: %d !the_block not in the free list", source); 200f240: 10 bf ff f7 b 200f21c <_Heap_Walk+0x28c> <== NOT EXECUTED 200f244: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED =============================================================================== 02005f90 <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 2005f90: 9d e3 bf 98 save %sp, -104, %sp rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 2005f94: 03 00 80 63 sethi %hi(0x2018c00), %g1 2005f98: c4 00 60 74 ld [ %g1 + 0x74 ], %g2 ! 2018c74 <_IO_Number_of_drivers> 2005f9c: 80 a0 a0 00 cmp %g2, 0 2005fa0: 02 80 00 0c be 2005fd0 <_IO_Initialize_all_drivers+0x40> <== NEVER TAKEN 2005fa4: a2 10 60 74 or %g1, 0x74, %l1 2005fa8: a0 10 20 00 clr %l0 (void) rtems_io_initialize( major, 0, NULL ); 2005fac: 90 10 00 10 mov %l0, %o0 2005fb0: 92 10 20 00 clr %o1 2005fb4: 40 00 17 f4 call 200bf84 2005fb8: 94 10 20 00 clr %o2 void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 2005fbc: c2 04 40 00 ld [ %l1 ], %g1 2005fc0: a0 04 20 01 inc %l0 2005fc4: 80 a0 40 10 cmp %g1, %l0 2005fc8: 18 bf ff fa bgu 2005fb0 <_IO_Initialize_all_drivers+0x20> 2005fcc: 90 10 00 10 mov %l0, %o0 2005fd0: 81 c7 e0 08 ret 2005fd4: 81 e8 00 00 restore =============================================================================== 02005fd8 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 2005fd8: 9d e3 bf 98 save %sp, -104, %sp /* * If the user claims there are less drivers than are actually in * the table, then let's just go with the table's count. */ if ( number_of_drivers <= drivers_in_table ) 2005fdc: 80 a6 80 19 cmp %i2, %i1 2005fe0: 18 80 00 08 bgu 2006000 <_IO_Manager_initialization+0x28> 2005fe4: 83 2e a0 03 sll %i2, 3, %g1 * If the maximum number of driver is the same as the number in the * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; 2005fe8: 03 00 80 63 sethi %hi(0x2018c00), %g1 _IO_Number_of_drivers = number_of_drivers; 2005fec: 05 00 80 63 sethi %hi(0x2018c00), %g2 * If the maximum number of driver is the same as the number in the * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; 2005ff0: f0 20 60 78 st %i0, [ %g1 + 0x78 ] _IO_Number_of_drivers = number_of_drivers; 2005ff4: f2 20 a0 74 st %i1, [ %g2 + 0x74 ] 2005ff8: 81 c7 e0 08 ret 2005ffc: 81 e8 00 00 restore /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 2006000: a1 2e a0 05 sll %i2, 5, %l0 2006004: a0 24 00 01 sub %l0, %g1, %l0 2006008: 40 00 0c 92 call 2009250 <_Workspace_Allocate_or_fatal_error> 200600c: 90 10 00 10 mov %l0, %o0 _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 2006010: 03 00 80 63 sethi %hi(0x2018c00), %g1 memset( 2006014: 94 10 00 10 mov %l0, %o2 _IO_Driver_address_table = (rtems_driver_address_table *) _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 2006018: f4 20 60 74 st %i2, [ %g1 + 0x74 ] /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 200601c: 21 00 80 63 sethi %hi(0x2018c00), %l0 _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 2006020: 92 10 20 00 clr %o1 2006024: 40 00 20 e6 call 200e3bc 2006028: d0 24 20 78 st %o0, [ %l0 + 0x78 ] _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 200602c: 80 a6 60 00 cmp %i1, 0 2006030: 02 bf ff f2 be 2005ff8 <_IO_Manager_initialization+0x20> <== NEVER TAKEN 2006034: d4 04 20 78 ld [ %l0 + 0x78 ], %o2 _IO_Driver_address_table[index] = driver_table[index]; 2006038: 96 10 20 00 clr %o3 200603c: 98 10 20 00 clr %o4 2006040: c2 06 00 0c ld [ %i0 + %o4 ], %g1 2006044: 9a 06 00 0c add %i0, %o4, %o5 2006048: c2 22 80 0c st %g1, [ %o2 + %o4 ] 200604c: c4 03 60 04 ld [ %o5 + 4 ], %g2 2006050: 86 02 80 0c add %o2, %o4, %g3 2006054: c4 20 e0 04 st %g2, [ %g3 + 4 ] 2006058: c2 03 60 08 ld [ %o5 + 8 ], %g1 memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 200605c: 96 02 e0 01 inc %o3 _IO_Driver_address_table[index] = driver_table[index]; 2006060: c2 20 e0 08 st %g1, [ %g3 + 8 ] 2006064: c4 03 60 0c ld [ %o5 + 0xc ], %g2 memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006068: 98 03 20 18 add %o4, 0x18, %o4 _IO_Driver_address_table[index] = driver_table[index]; 200606c: c4 20 e0 0c st %g2, [ %g3 + 0xc ] 2006070: c8 03 60 10 ld [ %o5 + 0x10 ], %g4 memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006074: 80 a6 40 0b cmp %i1, %o3 _IO_Driver_address_table[index] = driver_table[index]; 2006078: c8 20 e0 10 st %g4, [ %g3 + 0x10 ] 200607c: c2 03 60 14 ld [ %o5 + 0x14 ], %g1 memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006080: 18 bf ff f0 bgu 2006040 <_IO_Manager_initialization+0x68> 2006084: c2 20 e0 14 st %g1, [ %g3 + 0x14 ] 2006088: 81 c7 e0 08 ret 200608c: 81 e8 00 00 restore =============================================================================== 02006c64 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 2006c64: 9d e3 bf 98 save %sp, -104, %sp * If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) 2006c68: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 2006c6c: a0 10 00 18 mov %i0, %l0 * If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) 2006c70: 80 a0 60 00 cmp %g1, 0 2006c74: 02 80 00 1d be 2006ce8 <_Objects_Allocate+0x84> <== NEVER TAKEN 2006c78: b0 10 20 00 clr %i0 /* * OK. The manager should be initialized and configured to have objects. * With any luck, it is safe to attempt to allocate an object. */ the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 2006c7c: a2 04 20 20 add %l0, 0x20, %l1 2006c80: 40 00 14 e0 call 200c000 <_Chain_Get> 2006c84: 90 10 00 11 mov %l1, %o0 if ( information->auto_extend ) { 2006c88: c2 0c 20 12 ldub [ %l0 + 0x12 ], %g1 2006c8c: 80 a0 60 00 cmp %g1, 0 2006c90: 02 80 00 16 be 2006ce8 <_Objects_Allocate+0x84> 2006c94: b0 10 00 08 mov %o0, %i0 /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 2006c98: 80 a2 20 00 cmp %o0, 0 2006c9c: 02 80 00 15 be 2006cf0 <_Objects_Allocate+0x8c> 2006ca0: 01 00 00 00 nop } if ( the_object ) { uint32_t block; block = _Objects_Get_index( the_object->id ) - 2006ca4: c4 06 20 08 ld [ %i0 + 8 ], %g2 2006ca8: d0 04 20 08 ld [ %l0 + 8 ], %o0 _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 2006cac: d2 04 20 14 ld [ %l0 + 0x14 ], %o1 } if ( the_object ) { uint32_t block; block = _Objects_Get_index( the_object->id ) - 2006cb0: 03 00 00 3f sethi %hi(0xfc00), %g1 2006cb4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2006cb8: 84 08 80 01 and %g2, %g1, %g2 2006cbc: 90 0a 00 01 and %o0, %g1, %o0 _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 2006cc0: 40 00 36 5f call 201463c <.udiv> 2006cc4: 90 20 80 08 sub %g2, %o0, %o0 2006cc8: c6 04 20 30 ld [ %l0 + 0x30 ], %g3 2006ccc: 91 2a 20 02 sll %o0, 2, %o0 information->inactive--; 2006cd0: c2 14 20 2c lduh [ %l0 + 0x2c ], %g1 block = _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 2006cd4: c4 00 c0 08 ld [ %g3 + %o0 ], %g2 information->inactive--; 2006cd8: 82 00 7f ff add %g1, -1, %g1 block = _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 2006cdc: 84 00 bf ff add %g2, -1, %g2 information->inactive--; 2006ce0: c2 34 20 2c sth %g1, [ %l0 + 0x2c ] block = _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 2006ce4: c4 20 c0 08 st %g2, [ %g3 + %o0 ] information->inactive--; } } return the_object; } 2006ce8: 81 c7 e0 08 ret 2006cec: 81 e8 00 00 restore * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { _Objects_Extend_information( information ); 2006cf0: 40 00 00 14 call 2006d40 <_Objects_Extend_information> 2006cf4: 90 10 00 10 mov %l0, %o0 the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 2006cf8: 40 00 14 c2 call 200c000 <_Chain_Get> 2006cfc: 90 10 00 11 mov %l1, %o0 } if ( the_object ) { 2006d00: b0 92 20 00 orcc %o0, 0, %i0 2006d04: 32 bf ff e9 bne,a 2006ca8 <_Objects_Allocate+0x44> <== ALWAYS TAKEN 2006d08: c4 06 20 08 ld [ %i0 + 8 ], %g2 information->inactive--; } } return the_object; } 2006d0c: 81 c7 e0 08 ret <== NOT EXECUTED 2006d10: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02006d40 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 2006d40: 9d e3 bf 88 save %sp, -120, %sp */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_index( Objects_Id id ) { return (id >> OBJECTS_INDEX_START_BIT) & OBJECTS_INDEX_VALID_BITS; 2006d44: c4 06 20 08 ld [ %i0 + 8 ], %g2 minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; if ( information->maximum < minimum_index ) 2006d48: ea 16 20 10 lduh [ %i0 + 0x10 ], %l5 2006d4c: 03 00 00 3f sethi %hi(0xfc00), %g1 2006d50: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2006d54: a8 08 80 01 and %g2, %g1, %l4 2006d58: 80 a5 40 14 cmp %l5, %l4 2006d5c: 1a 80 00 79 bcc 2006f40 <_Objects_Extend_information+0x200> 2006d60: e0 06 20 14 ld [ %i0 + 0x14 ], %l0 2006d64: a6 10 00 14 mov %l4, %l3 2006d68: a4 10 20 00 clr %l2 2006d6c: a2 10 20 00 clr %l1 2006d70: ac 10 20 01 mov 1, %l6 2006d74: 90 10 20 03 mov 3, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2006d78: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1 2006d7c: 80 a0 60 00 cmp %g1, 0 2006d80: 12 80 00 8d bne 2006fb4 <_Objects_Extend_information+0x274> 2006d84: ba 04 00 15 add %l0, %l5, %i5 if ( !object_blocks ) return; } else { object_blocks = (void**) 2006d88: 90 02 00 14 add %o0, %l4, %o0 2006d8c: 90 02 00 1d add %o0, %i5, %o0 2006d90: 40 00 09 30 call 2009250 <_Workspace_Allocate_or_fatal_error> 2006d94: 91 2a 20 02 sll %o0, 2, %o0 2006d98: ae 10 00 08 mov %o0, %l7 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 2006d9c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 2006da0: 85 2d a0 02 sll %l6, 2, %g2 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 2006da4: 80 a0 40 14 cmp %g1, %l4 /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 2006da8: ac 05 c0 02 add %l7, %g2, %l6 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 2006dac: 18 80 00 94 bgu 2006ffc <_Objects_Extend_information+0x2bc> 2006db0: a0 05 80 02 add %l6, %g2, %l0 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 2006db4: 80 a5 20 00 cmp %l4, 0 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 2006db8: 84 10 20 00 clr %g2 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 2006dbc: 02 80 00 08 be 2006ddc <_Objects_Extend_information+0x9c> <== NEVER TAKEN 2006dc0: ab 2c a0 02 sll %l2, 2, %l5 local_table[ index ] = NULL; 2006dc4: 83 28 a0 02 sll %g2, 2, %g1 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 2006dc8: 84 00 a0 01 inc %g2 2006dcc: 80 a0 80 14 cmp %g2, %l4 2006dd0: 0a bf ff fd bcs 2006dc4 <_Objects_Extend_information+0x84><== NEVER TAKEN 2006dd4: c0 24 00 01 clr [ %l0 + %g1 ] 2006dd8: ab 2c a0 02 sll %l2, 2, %l5 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; 2006ddc: c0 25 80 15 clr [ %l6 + %l5 ] for ( index=index_base ; index < ( information->allocation_size + index_base ); 2006de0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 2006de4: 86 04 c0 01 add %l3, %g1, %g3 2006de8: 80 a4 c0 03 cmp %l3, %g3 2006dec: 1a 80 00 0a bcc 2006e14 <_Objects_Extend_information+0xd4><== NEVER TAKEN 2006df0: c0 25 c0 15 clr [ %l7 + %l5 ] 2006df4: 83 2c e0 02 sll %l3, 2, %g1 2006df8: 84 04 00 01 add %l0, %g1, %g2 2006dfc: 82 10 00 13 mov %l3, %g1 index++ ) { local_table[ index ] = NULL; 2006e00: c0 20 80 00 clr [ %g2 ] object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 2006e04: 82 00 60 01 inc %g1 object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); 2006e08: 80 a0 40 03 cmp %g1, %g3 2006e0c: 0a bf ff fd bcs 2006e00 <_Objects_Extend_information+0xc0> 2006e10: 84 00 a0 04 add %g2, 4, %g2 index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 2006e14: 7f ff eb f4 call 2001de4 2006e18: 01 00 00 00 nop information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2006e1c: c2 06 00 00 ld [ %i0 ], %g1 2006e20: c8 16 20 04 lduh [ %i0 + 4 ], %g4 old_tables = information->object_blocks; information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->local_table = local_table; 2006e24: e0 26 20 1c st %l0, [ %i0 + 0x1c ] information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2006e28: 89 29 20 1b sll %g4, 0x1b, %g4 2006e2c: 87 2f 60 10 sll %i5, 0x10, %g3 local_table[ index ] = NULL; } _ISR_Disable( level ); old_tables = information->object_blocks; 2006e30: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2006e34: 87 30 e0 10 srl %g3, 0x10, %g3 2006e38: 05 00 00 40 sethi %hi(0x10000), %g2 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; 2006e3c: ec 26 20 30 st %l6, [ %i0 + 0x30 ] information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2006e40: 83 28 60 18 sll %g1, 0x18, %g1 old_tables = information->object_blocks; information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->local_table = local_table; information->maximum = maximum; 2006e44: fa 36 20 10 sth %i5, [ %i0 + 0x10 ] information->maximum_id = _Objects_Build_id( 2006e48: 82 10 40 02 or %g1, %g2, %g1 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; 2006e4c: ee 26 20 34 st %l7, [ %i0 + 0x34 ] information->inactive_per_block = inactive_per_block; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2006e50: 82 10 40 04 or %g1, %g4, %g1 2006e54: 82 10 40 03 or %g1, %g3, %g1 2006e58: c2 26 20 0c st %g1, [ %i0 + 0xc ] information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 2006e5c: 7f ff eb e6 call 2001df4 2006e60: 01 00 00 00 nop if ( old_tables ) 2006e64: 80 a4 20 00 cmp %l0, 0 2006e68: 22 80 00 05 be,a 2006e7c <_Objects_Extend_information+0x13c> 2006e6c: e0 06 20 14 ld [ %i0 + 0x14 ], %l0 _Workspace_Free( old_tables ); 2006e70: 40 00 08 ea call 2009218 <_Workspace_Free> 2006e74: 90 10 00 10 mov %l0, %o0 2006e78: e0 06 20 14 ld [ %i0 + 0x14 ], %l0 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 2006e7c: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1 2006e80: 80 a0 60 00 cmp %g1, 0 2006e84: 02 80 00 55 be 2006fd8 <_Objects_Extend_information+0x298> 2006e88: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 information->object_blocks[ block ] = 2006e8c: 90 10 00 10 mov %l0, %o0 2006e90: 40 00 35 b1 call 2014554 <.umul> 2006e94: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 2006e98: 40 00 08 e7 call 2009234 <_Workspace_Allocate> 2006e9c: a9 2c 60 02 sll %l1, 2, %l4 _Workspace_Allocate( (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 2006ea0: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { information->object_blocks[ block ] = 2006ea4: d0 24 00 14 st %o0, [ %l0 + %l4 ] _Workspace_Allocate( (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 2006ea8: d2 00 40 14 ld [ %g1 + %l4 ], %o1 2006eac: 80 a2 60 00 cmp %o1, 0 2006eb0: 02 80 00 64 be 2007040 <_Objects_Extend_information+0x300><== NEVER TAKEN 2006eb4: 01 00 00 00 nop /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2006eb8: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 2006ebc: d6 06 20 18 ld [ %i0 + 0x18 ], %o3 information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 2006ec0: a0 10 00 13 mov %l3, %l0 2006ec4: a2 06 20 20 add %i0, 0x20, %l1 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2006ec8: a6 07 bf ec add %fp, -20, %l3 index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 2006ecc: 25 00 00 40 sethi %hi(0x10000), %l2 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2006ed0: 40 00 14 5f call 200c04c <_Chain_Initialize> 2006ed4: 90 10 00 13 mov %l3, %o0 2006ed8: 30 80 00 0c b,a 2006f08 <_Objects_Extend_information+0x1c8> index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 2006edc: c4 16 20 04 lduh [ %i0 + 4 ], %g2 2006ee0: 83 28 60 18 sll %g1, 0x18, %g1 2006ee4: 85 28 a0 1b sll %g2, 0x1b, %g2 2006ee8: 82 10 40 12 or %g1, %l2, %g1 2006eec: 82 10 40 02 or %g1, %g2, %g1 2006ef0: 82 10 40 10 or %g1, %l0, %g1 information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 2006ef4: 92 10 00 08 mov %o0, %o1 index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 2006ef8: c2 22 20 08 st %g1, [ %o0 + 8 ] index ); _Chain_Append( &information->Inactive, &the_object->Node ); index++; 2006efc: a0 04 20 01 inc %l0 information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 2006f00: 7f ff fd 2f call 20063bc <_Chain_Append> 2006f04: 90 10 00 11 mov %l1, %o0 * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 2006f08: 40 00 14 3e call 200c000 <_Chain_Get> 2006f0c: 90 10 00 13 mov %l3, %o0 2006f10: 80 a2 20 00 cmp %o0, 0 2006f14: 32 bf ff f2 bne,a 2006edc <_Objects_Extend_information+0x19c> 2006f18: c2 06 00 00 ld [ %i0 ], %g1 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 2006f1c: c6 06 20 30 ld [ %i0 + 0x30 ], %g3 2006f20: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 information->inactive += information->allocation_size; 2006f24: c8 16 20 2c lduh [ %i0 + 0x2c ], %g4 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 2006f28: c4 20 c0 14 st %g2, [ %g3 + %l4 ] information->inactive += information->allocation_size; 2006f2c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 2006f30: 82 00 40 04 add %g1, %g4, %g1 2006f34: c2 36 20 2c sth %g1, [ %i0 + 0x2c ] 2006f38: 81 c7 e0 08 ret 2006f3c: 81 e8 00 00 restore block = 0; if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; 2006f40: 90 10 00 15 mov %l5, %o0 2006f44: 40 00 35 be call 201463c <.udiv> 2006f48: 92 10 00 10 mov %l0, %o1 for ( ; block < block_count; block++ ) { 2006f4c: a4 92 20 00 orcc %o0, 0, %l2 2006f50: 02 80 00 3e be 2007048 <_Objects_Extend_information+0x308><== NEVER TAKEN 2006f54: a6 10 00 14 mov %l4, %l3 if ( information->object_blocks[ block ] == NULL ) 2006f58: c4 06 20 34 ld [ %i0 + 0x34 ], %g2 2006f5c: c2 00 80 00 ld [ %g2 ], %g1 2006f60: 80 a0 60 00 cmp %g1, 0 2006f64: 12 80 00 08 bne 2006f84 <_Objects_Extend_information+0x244><== ALWAYS TAKEN 2006f68: a2 10 20 00 clr %l1 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 2006f6c: 10 80 00 0c b 2006f9c <_Objects_Extend_information+0x25c> <== NOT EXECUTED 2006f70: 80 a4 c0 15 cmp %l3, %l5 <== NOT EXECUTED block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 2006f74: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2006f78: 80 a0 60 00 cmp %g1, 0 2006f7c: 02 80 00 08 be 2006f9c <_Objects_Extend_information+0x25c> 2006f80: 80 a4 c0 15 cmp %l3, %l5 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 2006f84: a2 04 60 01 inc %l1 if ( information->object_blocks[ block ] == NULL ) break; else index_base += information->allocation_size; 2006f88: a6 04 c0 10 add %l3, %l0, %l3 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 2006f8c: 80 a4 80 11 cmp %l2, %l1 2006f90: 18 bf ff f9 bgu 2006f74 <_Objects_Extend_information+0x234> 2006f94: 83 2c 60 02 sll %l1, 2, %g1 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 2006f98: 80 a4 c0 15 cmp %l3, %l5 2006f9c: 2a bf ff b9 bcs,a 2006e80 <_Objects_Extend_information+0x140> 2006fa0: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1 2006fa4: ac 04 a0 01 add %l2, 1, %l6 2006fa8: 83 2d a0 01 sll %l6, 1, %g1 2006fac: 10 bf ff 73 b 2006d78 <_Objects_Extend_information+0x38> 2006fb0: 90 00 40 16 add %g1, %l6, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { object_blocks = (void**) 2006fb4: 90 02 00 14 add %o0, %l4, %o0 2006fb8: 90 02 00 1d add %o0, %i5, %o0 2006fbc: 40 00 08 9e call 2009234 <_Workspace_Allocate> 2006fc0: 91 2a 20 02 sll %o0, 2, %o0 block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 2006fc4: ae 92 20 00 orcc %o0, 0, %l7 2006fc8: 32 bf ff 76 bne,a 2006da0 <_Objects_Extend_information+0x60><== ALWAYS TAKEN 2006fcc: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 2006fd0: 81 c7 e0 08 ret <== NOT EXECUTED 2006fd4: 81 e8 00 00 restore <== NOT EXECUTED if ( !information->object_blocks[ block ] ) return; } else { information->object_blocks[ block ] = 2006fd8: 90 10 00 10 mov %l0, %o0 2006fdc: 40 00 35 5e call 2014554 <.umul> 2006fe0: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 2006fe4: 40 00 08 9b call 2009250 <_Workspace_Allocate_or_fatal_error> 2006fe8: a9 2c 60 02 sll %l1, 2, %l4 2006fec: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 2006ff0: d0 24 00 14 st %o0, [ %l0 + %l4 ] 2006ff4: 10 bf ff b1 b 2006eb8 <_Objects_Extend_information+0x178> 2006ff8: d2 00 40 14 ld [ %g1 + %l4 ], %o1 /* * Copy each section of the table over. This has to be performed as * separate parts as size of each block has changed. */ memcpy( object_blocks, 2006ffc: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 2007000: ab 2c a0 02 sll %l2, 2, %l5 2007004: 90 10 00 17 mov %l7, %o0 2007008: 40 00 1c b4 call 200e2d8 200700c: 94 10 00 15 mov %l5, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 2007010: d2 06 20 30 ld [ %i0 + 0x30 ], %o1 2007014: 94 10 00 15 mov %l5, %o2 2007018: 40 00 1c b0 call 200e2d8 200701c: 90 10 00 16 mov %l6, %o0 information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 2007020: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 2007024: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 2007028: 94 05 00 0a add %l4, %o2, %o2 200702c: 90 10 00 10 mov %l0, %o0 2007030: 40 00 1c aa call 200e2d8 2007034: 95 2a a0 02 sll %o2, 2, %o2 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; 2007038: 10 bf ff 6a b 2006de0 <_Objects_Extend_information+0xa0> 200703c: c0 25 80 15 clr [ %l6 + %l5 ] 2007040: 81 c7 e0 08 ret <== NOT EXECUTED 2007044: 81 e8 00 00 restore <== NOT EXECUTED if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 2007048: 10 bf ff d4 b 2006f98 <_Objects_Extend_information+0x258> <== NOT EXECUTED 200704c: a2 10 20 00 clr %l1 <== NOT EXECUTED =============================================================================== 02007100 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint32_t the_class ) { 2007100: 9d e3 bf 98 save %sp, -104, %sp */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 2007104: 82 06 3f ff add %i0, -1, %g1 2007108: 80 a0 60 03 cmp %g1, 3 200710c: 38 80 00 1e bgu,a 2007184 <_Objects_Get_information+0x84> 2007110: b0 10 20 00 clr %i0 int the_class_api_maximum; if ( !_Objects_Is_api_valid( the_api ) ) return NULL; if ( !the_class ) 2007114: 80 a6 60 00 cmp %i1, 0 2007118: 12 80 00 04 bne 2007128 <_Objects_Get_information+0x28> 200711c: 01 00 00 00 nop if ( info->maximum == 0 ) return NULL; #endif return info; } 2007120: 81 c7 e0 08 ret 2007124: 91 e8 20 00 restore %g0, 0, %o0 return NULL; if ( !the_class ) return NULL; the_class_api_maximum = _Objects_API_maximum_class( the_api ); 2007128: 40 00 15 11 call 200c56c <_Objects_API_maximum_class> 200712c: 90 10 00 18 mov %i0, %o0 if ( the_class_api_maximum < 0 || 2007130: 80 a2 20 00 cmp %o0, 0 2007134: 06 bf ff fb bl 2007120 <_Objects_Get_information+0x20> <== NEVER TAKEN 2007138: 80 a2 00 19 cmp %o0, %i1 200713c: 2a 80 00 12 bcs,a 2007184 <_Objects_Get_information+0x84><== NEVER TAKEN 2007140: b0 10 20 00 clr %i0 <== NOT EXECUTED the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 2007144: 85 2e 20 02 sll %i0, 2, %g2 2007148: 03 00 80 60 sethi %hi(0x2018000), %g1 200714c: 82 10 62 70 or %g1, 0x270, %g1 ! 2018270 <_Objects_Information_table> 2007150: c4 00 40 02 ld [ %g1 + %g2 ], %g2 2007154: 80 a0 a0 00 cmp %g2, 0 2007158: 02 80 00 0b be 2007184 <_Objects_Get_information+0x84> <== NEVER TAKEN 200715c: b0 10 20 00 clr %i0 return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 2007160: 83 2e 60 02 sll %i1, 2, %g1 2007164: f0 00 80 01 ld [ %g2 + %g1 ], %i0 if ( !info ) 2007168: 80 a6 20 00 cmp %i0, 0 200716c: 02 80 00 06 be 2007184 <_Objects_Get_information+0x84> <== NEVER TAKEN 2007170: 01 00 00 00 nop * In a multprocessing configuration, we may access remote objects. * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( info->maximum == 0 ) 2007174: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 2007178: 80 a0 60 00 cmp %g1, 0 200717c: 22 80 00 02 be,a 2007184 <_Objects_Get_information+0x84> 2007180: b0 10 20 00 clr %i0 return NULL; #endif return info; } 2007184: 81 c7 e0 08 ret 2007188: 81 e8 00 00 restore =============================================================================== 02008a7c <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 2008a7c: 9d e3 bf 88 save %sp, -120, %sp 2008a80: 90 10 00 18 mov %i0, %o0 char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 2008a84: 80 a6 60 00 cmp %i1, 0 2008a88: 12 80 00 04 bne 2008a98 <_Objects_Get_name_as_string+0x1c> 2008a8c: b0 10 00 1a mov %i2, %i0 _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 2008a90: 81 c7 e0 08 ret 2008a94: 91 e8 20 00 restore %g0, 0, %o0 Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 2008a98: 80 a6 a0 00 cmp %i2, 0 2008a9c: 02 80 00 38 be 2008b7c <_Objects_Get_name_as_string+0x100> 2008aa0: b4 92 20 00 orcc %o0, 0, %i2 return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 2008aa4: 12 80 00 04 bne 2008ab4 <_Objects_Get_name_as_string+0x38> 2008aa8: 03 00 80 93 sethi %hi(0x2024c00), %g1 2008aac: c4 00 62 24 ld [ %g1 + 0x224 ], %g2 ! 2024e24 <_Thread_Executing> 2008ab0: f4 00 a0 08 ld [ %g2 + 8 ], %i2 information = _Objects_Get_information_id( tmpId ); 2008ab4: 7f ff ff aa call 200895c <_Objects_Get_information_id> 2008ab8: 90 10 00 1a mov %i2, %o0 if ( !information ) 2008abc: a0 92 20 00 orcc %o0, 0, %l0 2008ac0: 22 80 00 2f be,a 2008b7c <_Objects_Get_name_as_string+0x100> 2008ac4: b0 10 20 00 clr %i0 return NULL; the_object = _Objects_Get( information, tmpId, &location ); 2008ac8: 92 10 00 1a mov %i2, %o1 2008acc: 40 00 00 38 call 2008bac <_Objects_Get> 2008ad0: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 2008ad4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008ad8: 80 a0 60 00 cmp %g1, 0 2008adc: 32 80 00 28 bne,a 2008b7c <_Objects_Get_name_as_string+0x100> 2008ae0: b0 10 20 00 clr %i0 case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 2008ae4: c2 0c 20 38 ldub [ %l0 + 0x38 ], %g1 2008ae8: 80 a0 60 00 cmp %g1, 0 2008aec: 22 80 00 26 be,a 2008b84 <_Objects_Get_name_as_string+0x108> 2008af0: c2 02 20 0c ld [ %o0 + 0xc ], %g1 s = the_object->name.name_p; 2008af4: d0 02 20 0c ld [ %o0 + 0xc ], %o0 lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 2008af8: 80 a2 20 00 cmp %o0, 0 2008afc: 02 80 00 1e be 2008b74 <_Objects_Get_name_as_string+0xf8> 2008b00: 98 10 00 18 mov %i0, %o4 for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 2008b04: 96 86 7f ff addcc %i1, -1, %o3 2008b08: 02 80 00 1b be 2008b74 <_Objects_Get_name_as_string+0xf8> <== NEVER TAKEN 2008b0c: 98 10 00 18 mov %i0, %o4 2008b10: da 0a 00 00 ldub [ %o0 ], %o5 2008b14: 85 2b 60 18 sll %o5, 0x18, %g2 2008b18: 80 a0 a0 00 cmp %g2, 0 2008b1c: 02 80 00 16 be 2008b74 <_Objects_Get_name_as_string+0xf8> 2008b20: 03 00 80 71 sethi %hi(0x201c400), %g1 2008b24: 98 10 00 18 mov %i0, %o4 2008b28: 94 10 62 d0 or %g1, 0x2d0, %o2 2008b2c: 10 80 00 07 b 2008b48 <_Objects_Get_name_as_string+0xcc> 2008b30: 88 10 20 00 clr %g4 2008b34: da 0a 00 04 ldub [ %o0 + %g4 ], %o5 2008b38: 85 2b 60 18 sll %o5, 0x18, %g2 2008b3c: 80 a0 a0 00 cmp %g2, 0 2008b40: 02 80 00 0d be 2008b74 <_Objects_Get_name_as_string+0xf8> 2008b44: 01 00 00 00 nop *d = (isprint(*s)) ? *s : '*'; 2008b48: c2 02 80 00 ld [ %o2 ], %g1 2008b4c: 85 38 a0 18 sra %g2, 0x18, %g2 2008b50: c6 48 40 02 ldsb [ %g1 + %g2 ], %g3 2008b54: 80 88 e0 97 btst 0x97, %g3 2008b58: 12 80 00 03 bne 2008b64 <_Objects_Get_name_as_string+0xe8> 2008b5c: 88 01 20 01 inc %g4 2008b60: 9a 10 20 2a mov 0x2a, %o5 2008b64: da 2b 00 00 stb %o5, [ %o4 ] s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 2008b68: 80 a1 00 0b cmp %g4, %o3 2008b6c: 0a bf ff f2 bcs 2008b34 <_Objects_Get_name_as_string+0xb8> 2008b70: 98 03 20 01 inc %o4 *d = (isprint(*s)) ? *s : '*'; } } *d = '\0'; _Thread_Enable_dispatch(); 2008b74: 40 00 02 63 call 2009500 <_Thread_Enable_dispatch> 2008b78: c0 2b 00 00 clrb [ %o4 ] 2008b7c: 81 c7 e0 08 ret 2008b80: 81 e8 00 00 restore lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 2008b84: c0 2f bf ec clrb [ %fp + -20 ] if ( information->is_string ) { s = the_object->name.name_p; } else { uint32_t u32_name = (uint32_t) the_object->name.name_u32; lname[ 0 ] = (u32_name >> 24) & 0xff; 2008b88: 85 30 60 18 srl %g1, 0x18, %g2 lname[ 1 ] = (u32_name >> 16) & 0xff; 2008b8c: 87 30 60 10 srl %g1, 0x10, %g3 lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; 2008b90: c2 2f bf eb stb %g1, [ %fp + -21 ] if ( information->is_string ) { s = the_object->name.name_p; } else { uint32_t u32_name = (uint32_t) the_object->name.name_u32; lname[ 0 ] = (u32_name >> 24) & 0xff; 2008b94: c4 2f bf e8 stb %g2, [ %fp + -24 ] lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 2008b98: 83 30 60 08 srl %g1, 8, %g1 s = the_object->name.name_p; } else { uint32_t u32_name = (uint32_t) the_object->name.name_u32; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; 2008b9c: c6 2f bf e9 stb %g3, [ %fp + -23 ] lname[ 2 ] = (u32_name >> 8) & 0xff; 2008ba0: c2 2f bf ea stb %g1, [ %fp + -22 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 2008ba4: 10 bf ff d8 b 2008b04 <_Objects_Get_name_as_string+0x88> 2008ba8: 90 07 bf e8 add %fp, -24, %o0 =============================================================================== 020142b0 <_Objects_Get_no_protection>: /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 20142b0: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->maximum >= index ) { 20142b4: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 20142b8: 92 22 40 01 sub %o1, %g1, %o1 20142bc: 82 02 60 01 add %o1, 1, %g1 if ( information->maximum >= index ) { 20142c0: 80 a0 40 02 cmp %g1, %g2 20142c4: 18 80 00 09 bgu 20142e8 <_Objects_Get_no_protection+0x38> 20142c8: 83 28 60 02 sll %g1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 20142cc: c4 02 20 1c ld [ %o0 + 0x1c ], %g2 20142d0: d0 00 80 01 ld [ %g2 + %g1 ], %o0 20142d4: 80 a2 20 00 cmp %o0, 0 20142d8: 02 80 00 05 be 20142ec <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN 20142dc: 82 10 20 01 mov 1, %g1 *location = OBJECTS_LOCAL; 20142e0: 81 c3 e0 08 retl 20142e4: c0 22 80 00 clr [ %o2 ] /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 20142e8: 82 10 20 01 mov 1, %g1 20142ec: 90 10 20 00 clr %o0 return NULL; } 20142f0: 81 c3 e0 08 retl 20142f4: c2 22 80 00 st %g1, [ %o2 ] =============================================================================== 02008504 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 2008504: 9d e3 bf 90 save %sp, -112, %sp 2008508: 92 10 00 18 mov %i0, %o1 Objects_Id tmpId; Objects_Information *information; Objects_Control *the_object = (Objects_Control *) 0; Objects_Locations ignored_location; if ( !name ) 200850c: 80 a6 60 00 cmp %i1, 0 2008510: 02 80 00 24 be 20085a0 <_Objects_Id_to_name+0x9c> <== NEVER TAKEN 2008514: b0 10 20 01 mov 1, %i0 return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 2008518: 80 a2 60 00 cmp %o1, 0 200851c: 02 80 00 26 be 20085b4 <_Objects_Id_to_name+0xb0> 2008520: 03 00 80 72 sethi %hi(0x201c800), %g1 */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2008524: 83 32 60 18 srl %o1, 0x18, %g1 2008528: 82 08 60 07 and %g1, 7, %g1 */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 200852c: 84 00 7f ff add %g1, -1, %g2 2008530: 80 a0 a0 03 cmp %g2, 3 2008534: 38 80 00 1b bgu,a 20085a0 <_Objects_Id_to_name+0x9c> 2008538: b0 10 20 03 mov 3, %i0 the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 200853c: 85 28 60 02 sll %g1, 2, %g2 2008540: 03 00 80 72 sethi %hi(0x201c800), %g1 2008544: 82 10 60 80 or %g1, 0x80, %g1 ! 201c880 <_Objects_Information_table> 2008548: c4 00 40 02 ld [ %g1 + %g2 ], %g2 200854c: 80 a0 a0 00 cmp %g2, 0 2008550: 02 80 00 16 be 20085a8 <_Objects_Id_to_name+0xa4> <== NEVER TAKEN 2008554: 83 32 60 1b srl %o1, 0x1b, %g1 return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 2008558: 83 28 60 02 sll %g1, 2, %g1 200855c: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( !information ) 2008560: 80 a2 20 00 cmp %o0, 0 2008564: 02 80 00 0f be 20085a0 <_Objects_Id_to_name+0x9c> <== NEVER TAKEN 2008568: b0 10 20 03 mov 3, %i0 return OBJECTS_INVALID_ID; if ( information->is_string ) 200856c: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1 2008570: 80 a0 60 00 cmp %g1, 0 2008574: 12 80 00 0e bne 20085ac <_Objects_Id_to_name+0xa8> <== NEVER TAKEN 2008578: 01 00 00 00 nop return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &ignored_location ); 200857c: 7f ff ff c5 call 2008490 <_Objects_Get> 2008580: 94 07 bf f4 add %fp, -12, %o2 if ( !the_object ) 2008584: 80 a2 20 00 cmp %o0, 0 2008588: 22 80 00 06 be,a 20085a0 <_Objects_Id_to_name+0x9c> 200858c: b0 10 20 03 mov 3, %i0 return OBJECTS_INVALID_ID; *name = the_object->name; 2008590: c2 02 20 0c ld [ %o0 + 0xc ], %g1 _Thread_Enable_dispatch(); 2008594: b0 10 20 00 clr %i0 2008598: 40 00 02 77 call 2008f74 <_Thread_Enable_dispatch> 200859c: c2 26 40 00 st %g1, [ %i1 ] 20085a0: 81 c7 e0 08 ret 20085a4: 81 e8 00 00 restore return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 20085a8: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED } 20085ac: 81 c7 e0 08 ret <== NOT EXECUTED 20085b0: 81 e8 00 00 restore <== NOT EXECUTED Objects_Locations ignored_location; if ( !name ) return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 20085b4: c4 00 61 e4 ld [ %g1 + 0x1e4 ], %g2 20085b8: d2 00 a0 08 ld [ %g2 + 8 ], %o1 */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 20085bc: 83 32 60 18 srl %o1, 0x18, %g1 20085c0: 82 08 60 07 and %g1, 7, %g1 */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 20085c4: 84 00 7f ff add %g1, -1, %g2 20085c8: 80 a0 a0 03 cmp %g2, 3 20085cc: 38 bf ff f5 bgu,a 20085a0 <_Objects_Id_to_name+0x9c> <== NEVER TAKEN 20085d0: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 20085d4: 10 bf ff db b 2008540 <_Objects_Id_to_name+0x3c> 20085d8: 85 28 60 02 sll %g1, 2, %g2 =============================================================================== 02012b8c <_Objects_Name_to_id_string>: Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string( Objects_Information *information, const char *name, Objects_Id *id ) { 2012b8c: 9d e3 bf 98 save %sp, -104, %sp 2012b90: a8 10 00 18 mov %i0, %l4 uint32_t index; uint32_t name_length; /* ASSERT: information->is_string == TRUE */ if ( !id ) 2012b94: 80 a6 a0 00 cmp %i2, 0 2012b98: 02 80 00 1d be 2012c0c <_Objects_Name_to_id_string+0x80> <== NEVER TAKEN 2012b9c: b0 10 20 02 mov 2, %i0 return OBJECTS_INVALID_ADDRESS; if ( !name ) 2012ba0: 80 a6 60 00 cmp %i1, 0 2012ba4: 22 80 00 1a be,a 2012c0c <_Objects_Name_to_id_string+0x80><== NEVER TAKEN 2012ba8: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { 2012bac: e6 15 20 10 lduh [ %l4 + 0x10 ], %l3 2012bb0: 80 a4 e0 00 cmp %l3, 0 2012bb4: 22 80 00 16 be,a 2012c0c <_Objects_Name_to_id_string+0x80><== NEVER TAKEN 2012bb8: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 2012bbc: e4 05 20 1c ld [ %l4 + 0x1c ], %l2 2012bc0: a0 10 20 01 mov 1, %l0 the_object = information->local_table[ index ]; 2012bc4: 83 2c 20 02 sll %l0, 2, %g1 2012bc8: e2 04 80 01 ld [ %l2 + %g1 ], %l1 if ( !the_object ) 2012bcc: 80 a4 60 00 cmp %l1, 0 2012bd0: 02 80 00 0b be 2012bfc <_Objects_Name_to_id_string+0x70> 2012bd4: a0 04 20 01 inc %l0 continue; if ( !the_object->name.name_p ) 2012bd8: d2 04 60 0c ld [ %l1 + 0xc ], %o1 2012bdc: 80 a2 60 00 cmp %o1, 0 2012be0: 02 80 00 07 be 2012bfc <_Objects_Name_to_id_string+0x70> 2012be4: 90 10 00 19 mov %i1, %o0 continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { 2012be8: 40 00 0c e4 call 2015f78 2012bec: d4 15 20 3a lduh [ %l4 + 0x3a ], %o2 2012bf0: 80 a2 20 00 cmp %o0, 0 2012bf4: 22 80 00 08 be,a 2012c14 <_Objects_Name_to_id_string+0x88> 2012bf8: c2 04 60 08 ld [ %l1 + 8 ], %g1 return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 2012bfc: 80 a4 00 13 cmp %l0, %l3 2012c00: 08 bf ff f2 bleu 2012bc8 <_Objects_Name_to_id_string+0x3c> 2012c04: 83 2c 20 02 sll %l0, 2, %g1 2012c08: b0 10 20 01 mov 1, %i0 } } } return OBJECTS_INVALID_NAME; } 2012c0c: 81 c7 e0 08 ret 2012c10: 81 e8 00 00 restore if ( !the_object->name.name_p ) continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { *id = the_object->id; 2012c14: c2 26 80 00 st %g1, [ %i2 ] 2012c18: 81 c7 e0 08 ret 2012c1c: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 02007384 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 2007384: 86 10 00 08 mov %o0, %g3 Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 2007388: 80 a2 e0 00 cmp %o3, 0 200738c: 02 80 00 20 be 200740c <_Objects_Name_to_id_u32+0x88> 2007390: 90 10 20 02 mov 2, %o0 return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 2007394: 80 a2 60 00 cmp %o1, 0 2007398: 22 80 00 1d be,a 200740c <_Objects_Name_to_id_u32+0x88> 200739c: 90 10 20 01 mov 1, %o0 return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 20073a0: c2 10 e0 10 lduh [ %g3 + 0x10 ], %g1 20073a4: 85 28 60 10 sll %g1, 0x10, %g2 20073a8: 80 a0 a0 00 cmp %g2, 0 20073ac: 22 80 00 18 be,a 200740c <_Objects_Name_to_id_u32+0x88> <== NEVER TAKEN 20073b0: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 20073b4: 80 a2 a0 00 cmp %o2, 0 20073b8: 12 80 00 17 bne 2007414 <_Objects_Name_to_id_u32+0x90> 20073bc: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 20073c0: 89 30 a0 10 srl %g2, 0x10, %g4 20073c4: 80 a1 20 00 cmp %g4, 0 20073c8: 02 80 00 11 be 200740c <_Objects_Name_to_id_u32+0x88> <== NEVER TAKEN 20073cc: 90 10 20 01 mov 1, %o0 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 20073d0: d0 00 e0 1c ld [ %g3 + 0x1c ], %o0 20073d4: 86 10 20 01 mov 1, %g3 if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; 20073d8: 83 28 e0 02 sll %g3, 2, %g1 20073dc: c4 02 00 01 ld [ %o0 + %g1 ], %g2 if ( !the_object ) 20073e0: 80 a0 a0 00 cmp %g2, 0 20073e4: 02 80 00 06 be 20073fc <_Objects_Name_to_id_u32+0x78> 20073e8: 86 00 e0 01 inc %g3 continue; if ( name == the_object->name.name_u32 ) { 20073ec: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 20073f0: 80 a0 40 09 cmp %g1, %o1 20073f4: 22 80 00 0f be,a 2007430 <_Objects_Name_to_id_u32+0xac> 20073f8: c2 00 a0 08 ld [ %g2 + 8 ], %g1 search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 20073fc: 80 a0 c0 04 cmp %g3, %g4 2007400: 08 bf ff f7 bleu 20073dc <_Objects_Name_to_id_u32+0x58> 2007404: 83 28 e0 02 sll %g3, 2, %g1 2007408: 90 10 20 01 mov 1, %o0 name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 200740c: 81 c3 e0 08 retl 2007410: 01 00 00 00 nop if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007414: 82 10 63 ff or %g1, 0x3ff, %g1 2007418: 80 a2 80 01 cmp %o2, %g1 200741c: 02 bf ff e9 be 20073c0 <_Objects_Name_to_id_u32+0x3c> 2007420: 80 a2 a0 01 cmp %o2, 1 2007424: 02 bf ff e7 be 20073c0 <_Objects_Name_to_id_u32+0x3c> 2007428: 90 10 20 01 mov 1, %o0 200742c: 30 bf ff f8 b,a 200740c <_Objects_Name_to_id_u32+0x88> the_object = information->local_table[ index ]; if ( !the_object ) continue; if ( name == the_object->name.name_u32 ) { *id = the_object->id; 2007430: 90 10 20 00 clr %o0 2007434: 81 c3 e0 08 retl 2007438: c2 22 c0 00 st %g1, [ %o3 ] =============================================================================== 02007afc <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 2007afc: 9d e3 bf 98 save %sp, -104, %sp size_t length; const char *s; s = name; length = strnlen( name, information->name_length ) + 1; 2007b00: d2 16 20 3a lduh [ %i0 + 0x3a ], %o1 2007b04: 40 00 22 78 call 20104e4 2007b08: 90 10 00 1a mov %i2, %o0 if ( information->is_string ) { 2007b0c: c2 0e 20 38 ldub [ %i0 + 0x38 ], %g1 2007b10: 80 a0 60 00 cmp %g1, 0 2007b14: 12 80 00 21 bne 2007b98 <_Objects_Set_name+0x9c> 2007b18: a0 02 20 01 add %o0, 1, %l0 strncpy( d, name, length ); d[ length ] = '\0'; the_object->name.name_p = d; } else { the_object->name.name_u32 = _Objects_Build_name( 2007b1c: 03 08 08 08 sethi %hi(0x20202000), %g1 2007b20: 80 a4 20 00 cmp %l0, 0 2007b24: 02 80 00 19 be 2007b88 <_Objects_Set_name+0x8c> <== NEVER TAKEN 2007b28: 82 10 60 20 or %g1, 0x20, %g1 2007b2c: c4 4e 80 00 ldsb [ %i2 ], %g2 2007b30: 03 00 08 08 sethi %hi(0x202000), %g1 2007b34: 87 28 a0 18 sll %g2, 0x18, %g3 2007b38: 82 10 60 20 or %g1, 0x20, %g1 2007b3c: 80 a4 20 01 cmp %l0, 1 2007b40: 02 80 00 12 be 2007b88 <_Objects_Set_name+0x8c> 2007b44: 82 10 c0 01 or %g3, %g1, %g1 2007b48: c4 4e a0 01 ldsb [ %i2 + 1 ], %g2 2007b4c: 03 00 00 08 sethi %hi(0x2000), %g1 2007b50: 85 28 a0 10 sll %g2, 0x10, %g2 2007b54: 82 10 60 20 or %g1, 0x20, %g1 2007b58: 84 10 80 03 or %g2, %g3, %g2 2007b5c: 80 a4 20 02 cmp %l0, 2 2007b60: 02 80 00 0a be 2007b88 <_Objects_Set_name+0x8c> 2007b64: 82 10 80 01 or %g2, %g1, %g1 2007b68: c2 4e a0 02 ldsb [ %i2 + 2 ], %g1 2007b6c: 80 a4 20 03 cmp %l0, 3 2007b70: 83 28 60 08 sll %g1, 8, %g1 2007b74: 84 10 80 01 or %g2, %g1, %g2 2007b78: 02 80 00 04 be 2007b88 <_Objects_Set_name+0x8c> 2007b7c: 82 10 a0 20 or %g2, 0x20, %g1 2007b80: c2 4e a0 03 ldsb [ %i2 + 3 ], %g1 2007b84: 82 10 80 01 or %g2, %g1, %g1 2007b88: c2 26 60 0c st %g1, [ %i1 + 0xc ] 2007b8c: b0 10 20 01 mov 1, %i0 ); } return TRUE; } 2007b90: 81 c7 e0 08 ret 2007b94: 81 e8 00 00 restore length = strnlen( name, information->name_length ) + 1; if ( information->is_string ) { char *d; d = _Workspace_Allocate( length ); 2007b98: 90 10 00 10 mov %l0, %o0 2007b9c: 40 00 07 90 call 20099dc <_Workspace_Allocate> 2007ba0: b0 10 20 00 clr %i0 if ( !d ) 2007ba4: a2 92 20 00 orcc %o0, 0, %l1 2007ba8: 02 bf ff fa be 2007b90 <_Objects_Set_name+0x94> <== NEVER TAKEN 2007bac: 01 00 00 00 nop return FALSE; if ( the_object->name.name_p ) { 2007bb0: d0 06 60 0c ld [ %i1 + 0xc ], %o0 2007bb4: 80 a2 20 00 cmp %o0, 0 2007bb8: 02 80 00 06 be 2007bd0 <_Objects_Set_name+0xd4> 2007bbc: 92 10 00 1a mov %i2, %o1 _Workspace_Free( (void *)the_object->name.name_p ); 2007bc0: 40 00 07 80 call 20099c0 <_Workspace_Free> 2007bc4: 01 00 00 00 nop the_object->name.name_p = NULL; 2007bc8: c0 26 60 0c clr [ %i1 + 0xc ] } strncpy( d, name, length ); 2007bcc: 92 10 00 1a mov %i2, %o1 2007bd0: 90 10 00 11 mov %l1, %o0 2007bd4: 40 00 22 0a call 20103fc 2007bd8: 94 10 00 10 mov %l0, %o2 d[ length ] = '\0'; 2007bdc: c0 2c 40 10 clrb [ %l1 + %l0 ] the_object->name.name_p = d; 2007be0: e2 26 60 0c st %l1, [ %i1 + 0xc ] 2007be4: 81 c7 e0 08 ret 2007be8: 91 e8 20 01 restore %g0, 1, %o0 =============================================================================== 02007444 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 2007444: 9d e3 bf 98 save %sp, -104, %sp */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_index( Objects_Id id ) { return (id >> OBJECTS_INDEX_START_BIT) & OBJECTS_INDEX_VALID_BITS; 2007448: c4 06 20 08 ld [ %i0 + 8 ], %g2 /* * Search the list to find block or chunnk with all objects inactive. */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; 200744c: e0 06 20 14 ld [ %i0 + 0x14 ], %l0 2007450: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0 2007454: 03 00 00 3f sethi %hi(0xfc00), %g1 2007458: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200745c: 92 10 00 10 mov %l0, %o1 2007460: a4 08 80 01 and %g2, %g1, %l2 2007464: 40 00 34 76 call 201463c <.udiv> 2007468: 90 22 00 12 sub %o0, %l2, %o0 for ( block = 0; block < block_count; block++ ) { 200746c: 80 a2 20 00 cmp %o0, 0 2007470: 02 80 00 12 be 20074b8 <_Objects_Shrink_information+0x74> <== NEVER TAKEN 2007474: 84 10 20 00 clr %g2 if ( information->inactive_per_block[ block ] == information->allocation_size ) { 2007478: c6 06 20 30 ld [ %i0 + 0x30 ], %g3 200747c: c2 00 c0 00 ld [ %g3 ], %g1 2007480: 80 a4 00 01 cmp %l0, %g1 2007484: 12 80 00 09 bne 20074a8 <_Objects_Shrink_information+0x64><== ALWAYS TAKEN 2007488: a2 10 20 04 mov 4, %l1 200748c: 10 80 00 0d b 20074c0 <_Objects_Shrink_information+0x7c> <== NOT EXECUTED 2007490: a2 10 20 00 clr %l1 <== NOT EXECUTED information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 2007494: a4 04 80 10 add %l2, %l0, %l2 index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == information->allocation_size ) { 2007498: 80 a4 00 01 cmp %l0, %g1 200749c: 02 80 00 09 be 20074c0 <_Objects_Shrink_information+0x7c> 20074a0: 82 04 60 04 add %l1, 4, %g1 20074a4: a2 10 00 01 mov %g1, %l1 */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 20074a8: 84 00 a0 01 inc %g2 20074ac: 80 a2 00 02 cmp %o0, %g2 20074b0: 38 bf ff f9 bgu,a 2007494 <_Objects_Shrink_information+0x50> 20074b4: c2 00 c0 11 ld [ %g3 + %l1 ], %g1 20074b8: 81 c7 e0 08 ret 20074bc: 81 e8 00 00 restore 20074c0: 03 00 00 3f sethi %hi(0xfc00), %g1 /* * XXX - Not to sure how to use a chain where you need to iterate and * and remove elements. */ the_object = (Objects_Control *) information->Inactive.first; 20074c4: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 20074c8: 10 80 00 0f b 2007504 <_Objects_Shrink_information+0xc0> 20074cc: a6 10 63 ff or %g1, 0x3ff, %l3 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 20074d0: 82 04 80 01 add %l2, %g1, %g1 20074d4: 80 a0 40 03 cmp %g1, %g3 20074d8: 08 80 00 10 bleu 2007518 <_Objects_Shrink_information+0xd4> 20074dc: 90 10 00 02 mov %g2, %o0 if ( !_Chain_Is_last( &the_object->Node ) ) the_object = (Objects_Control *) the_object->Node.next; else the_object = NULL; _Chain_Extract( &extract_me->Node ); 20074e0: 40 00 12 be call 200bfd8 <_Chain_Extract> 20074e4: e0 00 80 00 ld [ %g2 ], %l0 } else { the_object = (Objects_Control *) the_object->Node.next; } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 20074e8: 80 a4 20 00 cmp %l0, 0 20074ec: 22 80 00 10 be,a 200752c <_Objects_Shrink_information+0xe8><== NEVER TAKEN 20074f0: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED 20074f4: c2 04 00 00 ld [ %l0 ], %g1 20074f8: 80 a0 60 00 cmp %g1, 0 20074fc: 02 80 00 0b be 2007528 <_Objects_Shrink_information+0xe4> 2007500: 84 10 00 10 mov %l0, %g2 2007504: c2 00 a0 08 ld [ %g2 + 8 ], %g1 2007508: 86 08 40 13 and %g1, %l3, %g3 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 200750c: 80 a0 c0 12 cmp %g3, %l2 2007510: 3a bf ff f0 bcc,a 20074d0 <_Objects_Shrink_information+0x8c> 2007514: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 2007518: e0 00 80 00 ld [ %g2 ], %l0 } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 200751c: 80 a4 20 00 cmp %l0, 0 2007520: 32 bf ff f6 bne,a 20074f8 <_Objects_Shrink_information+0xb4><== ALWAYS TAKEN 2007524: c2 04 00 00 ld [ %l0 ], %g1 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 2007528: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 200752c: 40 00 07 3b call 2009218 <_Workspace_Free> 2007530: d0 00 40 11 ld [ %g1 + %l1 ], %o0 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 2007534: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 information->inactive -= information->allocation_size; 2007538: c2 16 20 2c lduh [ %i0 + 0x2c ], %g1 * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 200753c: c0 20 80 11 clr [ %g2 + %l1 ] /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->object_blocks[ block ] = NULL; 2007540: c6 06 20 34 ld [ %i0 + 0x34 ], %g3 information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2007544: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->object_blocks[ block ] = NULL; 2007548: c0 20 c0 11 clr [ %g3 + %l1 ] information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 200754c: 82 20 40 02 sub %g1, %g2, %g1 2007550: c2 36 20 2c sth %g1, [ %i0 + 0x2c ] 2007554: 81 c7 e0 08 ret 2007558: 81 e8 00 00 restore =============================================================================== 02006090 <_POSIX_API_Initialize>: void _POSIX_API_Initialize( rtems_configuration_table *configuration_table ) { 2006090: 9d e3 bf 98 save %sp, -104, %sp /* XXX need to assert here based on size assumptions */ assert( sizeof(pthread_t) == sizeof(Objects_Id) ); api_configuration = configuration_table->POSIX_api_configuration; 2006094: f0 06 20 44 ld [ %i0 + 0x44 ], %i0 if ( !api_configuration ) 2006098: 80 a6 20 00 cmp %i0, 0 200609c: 02 80 00 1f be 2006118 <_POSIX_API_Initialize+0x88> <== NEVER TAKEN 20060a0: 03 00 80 59 sethi %hi(0x2016400), %g1 api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; _POSIX_signals_Manager_Initialization( 20060a4: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 api_configuration = configuration_table->POSIX_api_configuration; if ( !api_configuration ) api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; 20060a8: 05 00 80 60 sethi %hi(0x2018000), %g2 20060ac: 03 00 80 61 sethi %hi(0x2018400), %g1 20060b0: 82 10 63 e4 or %g1, 0x3e4, %g1 ! 20187e4 <_POSIX_Objects> _POSIX_signals_Manager_Initialization( 20060b4: 40 00 15 1b call 200b520 <_POSIX_signals_Manager_Initialization> 20060b8: c2 20 a2 7c st %g1, [ %g2 + 0x27c ] api_configuration->maximum_queued_signals ); _POSIX_Threads_Manager_initialization( 20060bc: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 20060c0: d4 06 20 30 ld [ %i0 + 0x30 ], %o2 20060c4: 40 00 15 a3 call 200b750 <_POSIX_Threads_Manager_initialization> 20060c8: d0 06 00 00 ld [ %i0 ], %o0 api_configuration->maximum_threads, api_configuration->number_of_initialization_threads, api_configuration->User_initialization_threads_table ); _POSIX_Condition_variables_Manager_initialization( 20060cc: 40 00 14 be call 200b3c4 <_POSIX_Condition_variables_Manager_initialization> 20060d0: d0 06 20 08 ld [ %i0 + 8 ], %o0 api_configuration->maximum_condition_variables ); _POSIX_Key_Manager_initialization( api_configuration->maximum_keys ); 20060d4: 40 00 14 c9 call 200b3f8 <_POSIX_Key_Manager_initialization> 20060d8: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _POSIX_Mutex_Manager_initialization( 20060dc: 40 00 14 ea call 200b484 <_POSIX_Mutex_Manager_initialization> 20060e0: d0 06 20 04 ld [ %i0 + 4 ], %o0 api_configuration->maximum_mutexes ); _POSIX_Message_queue_Manager_initialization( 20060e4: 40 00 14 d2 call 200b42c <_POSIX_Message_queue_Manager_initialization> 20060e8: d0 06 20 18 ld [ %i0 + 0x18 ], %o0 api_configuration->maximum_message_queues ); _POSIX_Semaphore_Manager_initialization( 20060ec: 40 00 16 60 call 200ba6c <_POSIX_Semaphore_Manager_initialization> 20060f0: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 api_configuration->maximum_semaphores ); _POSIX_Timer_Manager_initialization( api_configuration->maximum_timers ); 20060f4: 40 00 16 51 call 200ba38 <_POSIX_Timer_Manager_initialization> 20060f8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); 20060fc: 40 00 14 ef call 200b4b8 <_POSIX_Barrier_Manager_initialization> 2006100: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); 2006104: 40 00 14 fa call 200b4ec <_POSIX_RWLock_Manager_initialization> 2006108: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 200610c: f0 06 20 28 ld [ %i0 + 0x28 ], %i0 2006110: 40 00 15 79 call 200b6f4 <_POSIX_Spinlock_Manager_initialization> 2006114: 81 e8 00 00 restore /* XXX need to assert here based on size assumptions */ assert( sizeof(pthread_t) == sizeof(Objects_Id) ); api_configuration = configuration_table->POSIX_api_configuration; if ( !api_configuration ) 2006118: 10 bf ff e3 b 20060a4 <_POSIX_API_Initialize+0x14> <== NOT EXECUTED 200611c: b0 10 63 00 or %g1, 0x300, %i0 <== NOT EXECUTED =============================================================================== 02006204 <_POSIX_Condition_variables_Get>: POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get ( pthread_cond_t *cond, Objects_Locations *location ) { 2006204: 9d e3 bf 98 save %sp, -104, %sp Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 2006208: 80 a6 20 00 cmp %i0, 0 200620c: 02 80 00 12 be 2006254 <_POSIX_Condition_variables_Get+0x50> 2006210: b4 10 00 19 mov %i1, %i2 *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 2006214: f2 06 00 00 ld [ %i0 ], %i1 2006218: 80 a6 7f ff cmp %i1, -1 200621c: 02 80 00 05 be 2006230 <_POSIX_Condition_variables_Get+0x2c><== NEVER TAKEN 2006220: 90 10 00 18 mov %i0, %o0 /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 2006224: 31 00 80 5e sethi %hi(0x2017800), %i0 2006228: 40 00 0c 52 call 2009370 <_Objects_Get> 200622c: 91 ee 22 44 restore %i0, 0x244, %o0 if ( *id == PTHREAD_COND_INITIALIZER ) { /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 2006230: 40 00 00 0d call 2006264 <== NOT EXECUTED 2006234: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 2006238: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200623c: 12 80 00 07 bne 2006258 <_POSIX_Condition_variables_Get+0x54><== NOT EXECUTED 2006240: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2006244: f2 06 00 00 ld [ %i0 ], %i1 <== NOT EXECUTED /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 2006248: 31 00 80 5e sethi %hi(0x2017800), %i0 <== NOT EXECUTED 200624c: 40 00 0c 49 call 2009370 <_Objects_Get> <== NOT EXECUTED 2006250: 91 ee 22 44 restore %i0, 0x244, %o0 <== NOT EXECUTED * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); if ( status ) { *location = OBJECTS_ERROR; 2006254: 82 10 20 01 mov 1, %g1 2006258: c2 26 80 00 st %g1, [ %i2 ] * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) _Objects_Get( &_POSIX_Condition_variables_Information, *id, location ); } 200625c: 81 c7 e0 08 ret 2006260: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 0200641c <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, bool already_timedout ) { 200641c: 9d e3 bf 90 save %sp, -112, %sp register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 2006420: a0 07 bf f4 add %fp, -12, %l0 2006424: 90 10 00 19 mov %i1, %o0 2006428: 40 00 00 7f call 2006624 <_POSIX_Mutex_Get> 200642c: 92 10 00 10 mov %l0, %o1 2006430: 80 a2 20 00 cmp %o0, 0 2006434: 22 80 00 18 be,a 2006494 <_POSIX_Condition_variables_Wait_support+0x78> 2006438: b0 10 20 16 mov 0x16, %i0 */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 200643c: 03 00 80 5d sethi %hi(0x2017400), %g1 2006440: c4 00 61 b0 ld [ %g1 + 0x1b0 ], %g2 ! 20175b0 <_Thread_Dispatch_disable_level> return EINVAL; } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); 2006444: 92 10 00 10 mov %l0, %o1 2006448: 84 00 bf ff add %g2, -1, %g2 200644c: 90 10 00 18 mov %i0, %o0 2006450: c4 20 61 b0 st %g2, [ %g1 + 0x1b0 ] 2006454: 7f ff ff 6c call 2006204 <_POSIX_Condition_variables_Get> 2006458: 01 00 00 00 nop switch ( location ) { 200645c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006460: 80 a0 60 00 cmp %g1, 0 2006464: 12 80 00 1a bne 20064cc <_POSIX_Condition_variables_Wait_support+0xb0> 2006468: a2 10 00 08 mov %o0, %l1 case OBJECTS_LOCAL: if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { 200646c: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 2006470: 80 a0 a0 00 cmp %g2, 0 2006474: 02 80 00 0a be 200649c <_POSIX_Condition_variables_Wait_support+0x80> 2006478: 01 00 00 00 nop 200647c: c2 06 40 00 ld [ %i1 ], %g1 2006480: 80 a0 80 01 cmp %g2, %g1 2006484: 02 80 00 06 be 200649c <_POSIX_Condition_variables_Wait_support+0x80><== ALWAYS TAKEN 2006488: 01 00 00 00 nop _Thread_Enable_dispatch(); 200648c: 40 00 0e 0e call 2009cc4 <_Thread_Enable_dispatch> <== NOT EXECUTED 2006490: b0 10 20 16 mov 0x16, %i0 ! 16 <== NOT EXECUTED 2006494: 81 c7 e0 08 ret 2006498: 81 e8 00 00 restore return EINVAL; } (void) pthread_mutex_unlock( mutex ); 200649c: 40 00 00 ff call 2006898 20064a0: 90 10 00 19 mov %i1, %o0 _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 20064a4: 80 8e e0 ff btst 0xff, %i3 20064a8: 22 80 00 0b be,a 20064d4 <_POSIX_Condition_variables_Wait_support+0xb8> 20064ac: c2 06 40 00 ld [ %i1 ], %g1 status = _Thread_Executing->Wait.return_code; if ( status && status != ETIMEDOUT ) return status; } else { _Thread_Enable_dispatch(); 20064b0: 40 00 0e 05 call 2009cc4 <_Thread_Enable_dispatch> 20064b4: b0 10 20 74 mov 0x74, %i0 /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 20064b8: 40 00 00 d7 call 2006814 20064bc: 90 10 00 19 mov %i1, %o0 if ( mutex_status ) 20064c0: 80 a2 20 00 cmp %o0, 0 20064c4: 02 80 00 1c be 2006534 <_POSIX_Condition_variables_Wait_support+0x118> 20064c8: 01 00 00 00 nop case OBJECTS_ERROR: break; } return EINVAL; } 20064cc: 81 c7 e0 08 ret 20064d0: 91 e8 20 16 restore %g0, 0x16, %o0 if ( !already_timedout ) { the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 20064d4: 21 00 80 5d sethi %hi(0x2017400), %l0 return EINVAL; } */ if ( !already_timedout ) { the_cond->Mutex = *mutex; 20064d8: c2 24 60 14 st %g1, [ %l1 + 0x14 ] _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 20064dc: c4 04 22 74 ld [ %l0 + 0x274 ], %g2 _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; 20064e0: c8 06 00 00 ld [ %i0 ], %g4 if ( !already_timedout ) { the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; _Thread_Executing->Wait.queue = &the_cond->Wait_queue; 20064e4: 86 04 60 18 add %l1, 0x18, %g3 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 20064e8: 82 10 20 01 mov 1, %g1 _Thread_Executing->Wait.id = *cond; _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 20064ec: 92 10 00 1a mov %i2, %o1 20064f0: 90 10 00 03 mov %g3, %o0 20064f4: 15 00 80 29 sethi %hi(0x200a400), %o2 20064f8: 94 12 a3 14 or %o2, 0x314, %o2 ! 200a714 <_Thread_queue_Timeout> 20064fc: c2 24 60 48 st %g1, [ %l1 + 0x48 ] the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; 2006500: c8 20 a0 20 st %g4, [ %g2 + 0x20 ] if ( !already_timedout ) { the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 2006504: c0 20 a0 34 clr [ %g2 + 0x34 ] _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 2006508: 40 00 0f 4d call 200a23c <_Thread_queue_Enqueue_with_handler> 200650c: c6 20 a0 44 st %g3, [ %g2 + 0x44 ] _Thread_Enable_dispatch(); 2006510: 40 00 0d ed call 2009cc4 <_Thread_Enable_dispatch> 2006514: 01 00 00 00 nop /* * Switch ourself out because we blocked as a result of the * _Thread_queue_Enqueue. */ status = _Thread_Executing->Wait.return_code; 2006518: c2 04 22 74 ld [ %l0 + 0x274 ], %g1 200651c: f0 00 60 34 ld [ %g1 + 0x34 ], %i0 if ( status && status != ETIMEDOUT ) 2006520: 80 a6 20 00 cmp %i0, 0 2006524: 02 bf ff e5 be 20064b8 <_POSIX_Condition_variables_Wait_support+0x9c> 2006528: 80 a6 20 74 cmp %i0, 0x74 200652c: 02 bf ff e3 be 20064b8 <_POSIX_Condition_variables_Wait_support+0x9c><== ALWAYS TAKEN 2006530: 01 00 00 00 nop case OBJECTS_ERROR: break; } return EINVAL; } 2006534: 81 c7 e0 08 ret 2006538: 81 e8 00 00 restore =============================================================================== 0200d134 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 200d134: 9d e3 bf 98 save %sp, -104, %sp */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 200d138: 03 00 80 61 sethi %hi(0x2018400), %g1 uint32_t iterations; bool are_all_null; POSIX_Keys_Control *the_key; void *value; thread_index = _Objects_Get_index( thread->Object.id ); 200d13c: c6 06 20 08 ld [ %i0 + 8 ], %g3 200d140: a4 10 63 64 or %g1, 0x364, %l2 200d144: c2 14 a0 10 lduh [ %l2 + 0x10 ], %g1 200d148: 85 30 e0 18 srl %g3, 0x18, %g2 200d14c: 89 28 60 10 sll %g1, 0x10, %g4 200d150: 84 08 a0 07 and %g2, 7, %g2 the_key = (POSIX_Keys_Control *) _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { value = the_key->Values[ thread_api ][ thread_index ]; 200d154: 03 00 00 3f sethi %hi(0xfc00), %g1 200d158: 84 00 a0 06 add %g2, 6, %g2 200d15c: 82 10 63 ff or %g1, 0x3ff, %g1 200d160: ab 28 a0 02 sll %g2, 2, %l5 200d164: 86 08 c0 01 and %g3, %g1, %g3 200d168: a8 10 20 00 clr %l4 200d16c: a7 28 e0 02 sll %g3, 2, %l3 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 200d170: 80 a1 20 00 cmp %g4, 0 200d174: 02 80 00 29 be 200d218 <_POSIX_Keys_Run_destructors+0xe4> 200d178: a0 10 20 01 mov 1, %l0 200d17c: a2 10 20 01 mov 1, %l1 the_key = (POSIX_Keys_Control *) 200d180: c4 04 a0 1c ld [ %l2 + 0x1c ], %g2 200d184: 83 2c 20 02 sll %l0, 2, %g1 200d188: f0 00 80 01 ld [ %g2 + %g1 ], %i0 _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { 200d18c: 80 a6 20 00 cmp %i0, 0 200d190: 02 80 00 16 be 200d1e8 <_POSIX_Keys_Run_destructors+0xb4> 200d194: a0 04 20 01 inc %l0 200d198: c2 0e 20 10 ldub [ %i0 + 0x10 ], %g1 200d19c: 80 a0 60 00 cmp %g1, 0 200d1a0: 22 80 00 13 be,a 200d1ec <_POSIX_Keys_Run_destructors+0xb8><== NEVER TAKEN 200d1a4: c2 14 a0 10 lduh [ %l2 + 0x10 ], %g1 <== NOT EXECUTED 200d1a8: c6 06 20 14 ld [ %i0 + 0x14 ], %g3 200d1ac: 80 a0 e0 00 cmp %g3, 0 200d1b0: 22 80 00 0f be,a 200d1ec <_POSIX_Keys_Run_destructors+0xb8><== NEVER TAKEN 200d1b4: c2 14 a0 10 lduh [ %l2 + 0x10 ], %g1 <== NOT EXECUTED value = the_key->Values[ thread_api ][ thread_index ]; 200d1b8: c2 06 00 15 ld [ %i0 + %l5 ], %g1 200d1bc: c4 00 40 13 ld [ %g1 + %l3 ], %g2 if ( value ) { 200d1c0: 90 90 a0 00 orcc %g2, 0, %o0 200d1c4: 22 80 00 0a be,a 200d1ec <_POSIX_Keys_Run_destructors+0xb8><== NEVER TAKEN 200d1c8: c2 14 a0 10 lduh [ %l2 + 0x10 ], %g1 <== NOT EXECUTED (*the_key->destructor)( value ); 200d1cc: 9f c0 c0 00 call %g3 200d1d0: 01 00 00 00 nop if ( the_key->Values[ thread_api ][ thread_index ] ) 200d1d4: c2 06 00 15 ld [ %i0 + %l5 ], %g1 200d1d8: c4 00 40 13 ld [ %g1 + %l3 ], %g2 200d1dc: 80 a0 00 02 cmp %g0, %g2 200d1e0: 82 40 3f ff addx %g0, -1, %g1 200d1e4: a2 0c 40 01 and %l1, %g1, %l1 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 200d1e8: c2 14 a0 10 lduh [ %l2 + 0x10 ], %g1 200d1ec: 89 28 60 10 sll %g1, 0x10, %g4 200d1f0: 83 31 20 10 srl %g4, 0x10, %g1 200d1f4: 80 a0 40 10 cmp %g1, %l0 200d1f8: 3a bf ff e3 bcc,a 200d184 <_POSIX_Keys_Run_destructors+0x50> 200d1fc: c4 04 a0 1c ld [ %l2 + 0x1c ], %g2 are_all_null = FALSE; } } } if ( are_all_null == TRUE ) 200d200: 80 8c 60 ff btst 0xff, %l1 200d204: 12 80 00 05 bne 200d218 <_POSIX_Keys_Run_destructors+0xe4> 200d208: a8 05 20 01 inc %l4 * loop. It seems rude to unnecessarily lock up a system. * * Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99. */ if ( iterations >= PTHREAD_DESTRUCTOR_ITERATIONS ) 200d20c: 80 a5 20 04 cmp %l4, 4 200d210: 12 bf ff d9 bne 200d174 <_POSIX_Keys_Run_destructors+0x40> 200d214: 80 a1 20 00 cmp %g4, 0 200d218: 81 c7 e0 08 ret 200d21c: 81 e8 00 00 restore =============================================================================== 0201169c <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 201169c: 9d e3 bf 98 save %sp, -104, %sp CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 20116a0: 92 10 20 ff mov 0xff, %o1 20116a4: 90 10 00 18 mov %i0, %o0 20116a8: 40 00 12 c4 call 20161b8 20116ac: a8 10 00 18 mov %i0, %l4 if ( n > NAME_MAX ) 20116b0: b0 10 20 5b mov 0x5b, %i0 20116b4: 80 a2 20 ff cmp %o0, 0xff 20116b8: 18 80 00 37 bgu 2011794 <_POSIX_Message_queue_Create_support+0xf8><== NEVER TAKEN 20116bc: a4 10 00 08 mov %o0, %l2 20116c0: 05 00 80 8a sethi %hi(0x2022800), %g2 20116c4: c2 00 a3 00 ld [ %g2 + 0x300 ], %g1 ! 2022b00 <_Thread_Dispatch_disable_level> 20116c8: 82 00 60 01 inc %g1 20116cc: c2 20 a3 00 st %g1, [ %g2 + 0x300 ] * but were not compared against any existing implementation for * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { 20116d0: 80 a6 a0 00 cmp %i2, 0 20116d4: 22 80 00 32 be,a 201179c <_POSIX_Message_queue_Create_support+0x100> 20116d8: b4 10 20 10 mov 0x10, %i2 attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 20116dc: e2 06 a0 04 ld [ %i2 + 4 ], %l1 20116e0: 80 a4 60 00 cmp %l1, 0 20116e4: 04 80 00 3d ble 20117d8 <_POSIX_Message_queue_Create_support+0x13c> 20116e8: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 20116ec: f4 06 a0 08 ld [ %i2 + 8 ], %i2 20116f0: 80 a6 a0 00 cmp %i2, 0 20116f4: 04 80 00 39 ble 20117d8 <_POSIX_Message_queue_Create_support+0x13c> 20116f8: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void ) { return (POSIX_Message_queue_Control *) 20116fc: 27 00 80 8b sethi %hi(0x2022c00), %l3 2011700: 7f ff ed 6a call 200cca8 <_Objects_Allocate> 2011704: 90 14 e2 90 or %l3, 0x290, %o0 ! 2022e90 <_POSIX_Message_queue_Information> attr = *attr_ptr; } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 2011708: a0 92 20 00 orcc %o0, 0, %l0 201170c: 02 80 00 3b be 20117f8 <_POSIX_Message_queue_Create_support+0x15c><== NEVER TAKEN 2011710: 84 10 20 01 mov 1, %g2 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; the_mq->named = TRUE; 2011714: 82 10 20 01 mov 1, %g1 if ( !the_mq ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; 2011718: f2 24 20 10 st %i1, [ %l0 + 0x10 ] /* * Make a copy of the user's string for name just in case it was * dynamically constructed. */ name = _Workspace_Allocate(n); 201171c: 90 10 00 12 mov %l2, %o0 } the_mq->process_shared = pshared; the_mq->named = TRUE; the_mq->open_count = 1; the_mq->linked = TRUE; 2011720: c4 2c 20 15 stb %g2, [ %l0 + 0x15 ] rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; the_mq->named = TRUE; the_mq->open_count = 1; 2011724: c4 24 20 18 st %g2, [ %l0 + 0x18 ] /* * Make a copy of the user's string for name just in case it was * dynamically constructed. */ name = _Workspace_Allocate(n); 2011728: 7f ff f7 22 call 200f3b0 <_Workspace_Allocate> 201172c: c2 2c 20 14 stb %g1, [ %l0 + 0x14 ] if (!name) { 2011730: b2 92 20 00 orcc %o0, 0, %i1 2011734: 22 80 00 39 be,a 2011818 <_POSIX_Message_queue_Create_support+0x17c><== NEVER TAKEN 2011738: 90 14 e2 90 or %l3, 0x290, %o0 <== NOT EXECUTED _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOMEM ); } strcpy( name, name_arg ); 201173c: 40 00 10 34 call 201580c 2011740: 92 10 00 14 mov %l4, %o1 */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 2011744: 94 10 00 11 mov %l1, %o2 * Note that thread blocking discipline should be based on the * current scheduling policy. */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 2011748: c0 24 20 5c clr [ %l0 + 0x5c ] if ( ! _CORE_message_queue_Initialize( 201174c: 96 10 00 1a mov %i2, %o3 2011750: 90 04 20 1c add %l0, 0x1c, %o0 2011754: 40 00 03 80 call 2012554 <_CORE_message_queue_Initialize> 2011758: 92 04 20 5c add %l0, 0x5c, %o1 201175c: 80 8a 20 ff btst 0xff, %o0 2011760: 02 80 00 11 be 20117a4 <_POSIX_Message_queue_Create_support+0x108><== NEVER TAKEN 2011764: 82 14 e2 90 or %l3, 0x290, %g1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2011768: c4 04 20 08 ld [ %l0 + 8 ], %g2 201176c: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 2011770: 03 00 00 3f sethi %hi(0xfc00), %g1 2011774: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2011778: 84 08 80 01 and %g2, %g1, %g2 201177c: 85 28 a0 02 sll %g2, 2, %g2 2011780: e0 20 c0 02 st %l0, [ %g3 + %g2 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string */ the_object->name.name_p = name; 2011784: f2 24 20 0c st %i1, [ %l0 + 0xc ] &_POSIX_Message_queue_Information, &the_mq->Object, name ); *message_queue = the_mq; 2011788: e0 26 c0 00 st %l0, [ %i3 ] _Thread_Enable_dispatch(); 201178c: 7f ff f1 30 call 200dc4c <_Thread_Enable_dispatch> 2011790: b0 10 20 00 clr %i0 return 0; } 2011794: 81 c7 e0 08 ret 2011798: 81 e8 00 00 restore rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); 201179c: 10 bf ff d8 b 20116fc <_POSIX_Message_queue_Create_support+0x60> 20117a0: a2 10 20 0a mov 0xa, %l1 RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free ( POSIX_Message_queue_Control *the_mq ) { _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object ); 20117a4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 20117a8: 7f ff ee 3b call 200d094 <_Objects_Free> <== NOT EXECUTED 20117ac: 90 14 e2 90 or %l3, 0x290, %o0 <== NOT EXECUTED attr.mq_maxmsg, attr.mq_msgsize ) ) { _POSIX_Message_queue_Free( the_mq ); _Workspace_Free(name); 20117b0: 7f ff f6 f9 call 200f394 <_Workspace_Free> <== NOT EXECUTED 20117b4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); 20117b8: 7f ff f1 25 call 200dc4c <_Thread_Enable_dispatch> <== NOT EXECUTED 20117bc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 20117c0: 40 00 0a df call 201433c <__errno> <== NOT EXECUTED 20117c4: 01 00 00 00 nop <== NOT EXECUTED 20117c8: 82 10 20 1c mov 0x1c, %g1 ! 1c <== NOT EXECUTED 20117cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20117d0: 81 c7 e0 08 ret <== NOT EXECUTED 20117d4: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ _Thread_Enable_dispatch(); 20117d8: 7f ff f1 1d call 200dc4c <_Thread_Enable_dispatch> 20117dc: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( EINVAL ); 20117e0: 40 00 0a d7 call 201433c <__errno> 20117e4: 01 00 00 00 nop 20117e8: 82 10 20 16 mov 0x16, %g1 ! 16 20117ec: c2 22 00 00 st %g1, [ %o0 ] 20117f0: 81 c7 e0 08 ret 20117f4: 81 e8 00 00 restore attr = *attr_ptr; } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { _Thread_Enable_dispatch(); 20117f8: 7f ff f1 15 call 200dc4c <_Thread_Enable_dispatch> <== NOT EXECUTED 20117fc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENFILE ); 2011800: 40 00 0a cf call 201433c <__errno> <== NOT EXECUTED 2011804: 01 00 00 00 nop <== NOT EXECUTED 2011808: 82 10 20 17 mov 0x17, %g1 ! 17 <== NOT EXECUTED 201180c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2011810: 81 c7 e0 08 ret <== NOT EXECUTED 2011814: 81 e8 00 00 restore <== NOT EXECUTED 2011818: 7f ff ee 1f call 200d094 <_Objects_Free> <== NOT EXECUTED 201181c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED */ name = _Workspace_Allocate(n); if (!name) { _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); 2011820: 7f ff f1 0b call 200dc4c <_Thread_Enable_dispatch> <== NOT EXECUTED 2011824: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 2011828: 40 00 0a c5 call 201433c <__errno> <== NOT EXECUTED 201182c: 01 00 00 00 nop <== NOT EXECUTED 2011830: 82 10 20 0c mov 0xc, %g1 ! c <== NOT EXECUTED 2011834: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2011838: 81 c7 e0 08 ret <== NOT EXECUTED 201183c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02009748 <_POSIX_Message_queue_Delete>: */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq ) { 2009748: 9d e3 bf 98 save %sp, -104, %sp if ( !the_mq->linked && !the_mq->open_count ) { 200974c: c2 0e 20 15 ldub [ %i0 + 0x15 ], %g1 2009750: 80 a0 60 00 cmp %g1, 0 2009754: 12 80 00 16 bne 20097ac <_POSIX_Message_queue_Delete+0x64> 2009758: b2 10 00 18 mov %i0, %i1 200975c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2009760: 80 a0 60 00 cmp %g1, 0 2009764: 12 80 00 12 bne 20097ac <_POSIX_Message_queue_Delete+0x64> 2009768: 01 00 00 00 nop /* the name memory may have been freed by unlink. */ Objects_Control *the_object = &the_mq->Object; if ( the_object->name.name_p ) 200976c: d0 06 20 0c ld [ %i0 + 0xc ], %o0 2009770: 80 a2 20 00 cmp %o0, 0 2009774: 02 80 00 04 be 2009784 <_POSIX_Message_queue_Delete+0x3c> <== ALWAYS TAKEN 2009778: 31 00 80 8b sethi %hi(0x2022c00), %i0 _Workspace_Free( (void *)the_object->name.name_p ); 200977c: 40 00 17 06 call 200f394 <_Workspace_Free> <== NOT EXECUTED 2009780: 01 00 00 00 nop <== NOT EXECUTED _Objects_Close( &_POSIX_Message_queue_Information, the_object ); 2009784: 92 10 00 19 mov %i1, %o1 2009788: 40 00 0d 74 call 200cd58 <_Objects_Close> 200978c: 90 16 22 90 or %i0, 0x290, %o0 _CORE_message_queue_Close( 2009790: 90 06 60 1c add %i1, 0x1c, %o0 2009794: 92 10 20 00 clr %o1 2009798: 94 10 20 05 mov 5, %o2 200979c: 40 00 0a 5c call 200c10c <_CORE_message_queue_Close> 20097a0: b0 16 22 90 or %i0, 0x290, %i0 RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free ( POSIX_Message_queue_Control *the_mq ) { _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object ); 20097a4: 40 00 0e 3c call 200d094 <_Objects_Free> 20097a8: 81 e8 00 00 restore 20097ac: 81 c7 e0 08 ret 20097b0: 81 e8 00 00 restore =============================================================================== 02009b54 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 2009b54: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) 2009b58: 11 00 80 8c sethi %hi(0x2023000), %o0 2009b5c: 94 07 bf f4 add %fp, -12, %o2 2009b60: 90 12 20 0c or %o0, 0xc, %o0 2009b64: 40 00 0d b9 call 200d248 <_Objects_Get> 2009b68: 92 10 00 18 mov %i0, %o1 Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 2009b6c: c2 07 bf f4 ld [ %fp + -12 ], %g1 size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 2009b70: 94 10 00 19 mov %i1, %o2 Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 2009b74: 80 a0 60 00 cmp %g1, 0 2009b78: 02 80 00 08 be 2009b98 <_POSIX_Message_queue_Receive_support+0x44> 2009b7c: 9a 10 00 1d mov %i5, %o5 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 2009b80: 40 00 29 ef call 201433c <__errno> 2009b84: b0 10 3f ff mov -1, %i0 2009b88: 82 10 20 09 mov 9, %g1 2009b8c: c2 22 00 00 st %g1, [ %o0 ] } 2009b90: 81 c7 e0 08 ret 2009b94: 81 e8 00 00 restore the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 2009b98: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 2009b9c: 82 08 a0 03 and %g2, 3, %g1 2009ba0: 80 a0 60 01 cmp %g1, 1 2009ba4: 02 80 00 32 be 2009c6c <_POSIX_Message_queue_Receive_support+0x118> 2009ba8: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 2009bac: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 2009bb0: c2 02 20 68 ld [ %o0 + 0x68 ], %g1 2009bb4: 80 a0 40 1a cmp %g1, %i2 2009bb8: 18 80 00 1c bgu 2009c28 <_POSIX_Message_queue_Receive_support+0xd4> 2009bbc: 80 8f 20 ff btst 0xff, %i4 length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 2009bc0: 12 80 00 16 bne 2009c18 <_POSIX_Message_queue_Receive_support+0xc4><== ALWAYS TAKEN 2009bc4: 98 10 20 00 clr %o4 /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 2009bc8: 82 10 3f ff mov -1, %g1 do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 2009bcc: 90 02 20 1c add %o0, 0x1c, %o0 2009bd0: 92 10 00 18 mov %i0, %o1 2009bd4: 96 07 bf f0 add %fp, -16, %o3 2009bd8: 40 00 09 72 call 200c1a0 <_CORE_message_queue_Seize> 2009bdc: c2 27 bf f0 st %g1, [ %fp + -16 ] &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 2009be0: 40 00 10 1b call 200dc4c <_Thread_Enable_dispatch> 2009be4: 3b 00 80 8a sethi %hi(0x2022800), %i5 *msg_prio = 2009be8: c4 07 63 c4 ld [ %i5 + 0x3c4 ], %g2 ! 2022bc4 <_Thread_Executing> 2009bec: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 2009bf0: c8 00 a0 34 ld [ %g2 + 0x34 ], %g4 do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 2009bf4: 87 38 60 1f sra %g1, 0x1f, %g3 2009bf8: 82 18 c0 01 xor %g3, %g1, %g1 2009bfc: 82 20 40 03 sub %g1, %g3, %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 2009c00: 80 a1 20 00 cmp %g4, 0 2009c04: 12 80 00 11 bne 2009c48 <_POSIX_Message_queue_Receive_support+0xf4> 2009c08: c2 26 c0 00 st %g1, [ %i3 ] return length_out; 2009c0c: f0 07 bf f0 ld [ %fp + -16 ], %i0 2009c10: 81 c7 e0 08 ret 2009c14: 81 e8 00 00 restore length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 2009c18: 83 30 a0 0e srl %g2, 0xe, %g1 2009c1c: 82 18 60 01 xor %g1, 1, %g1 2009c20: 10 bf ff ea b 2009bc8 <_POSIX_Message_queue_Receive_support+0x74> 2009c24: 98 08 60 01 and %g1, 1, %o4 } the_mq = the_mq_fd->Queue; if ( msg_len < the_mq->Message_queue.maximum_message_size ) { _Thread_Enable_dispatch(); 2009c28: 40 00 10 09 call 200dc4c <_Thread_Enable_dispatch> 2009c2c: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( EMSGSIZE ); 2009c30: 40 00 29 c3 call 201433c <__errno> 2009c34: 01 00 00 00 nop 2009c38: 82 10 20 7a mov 0x7a, %g1 ! 7a 2009c3c: c2 22 00 00 st %g1, [ %o0 ] 2009c40: 81 c7 e0 08 ret 2009c44: 81 e8 00 00 restore _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) return length_out; rtems_set_errno_and_return_minus_one( 2009c48: 40 00 29 bd call 201433c <__errno> 2009c4c: b0 10 3f ff mov -1, %i0 2009c50: c2 07 63 c4 ld [ %i5 + 0x3c4 ], %g1 2009c54: a0 10 00 08 mov %o0, %l0 2009c58: 40 00 00 b2 call 2009f20 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 2009c5c: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 2009c60: d0 24 00 00 st %o0, [ %l0 ] 2009c64: 81 c7 e0 08 ret 2009c68: 81 e8 00 00 restore the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { _Thread_Enable_dispatch(); 2009c6c: 40 00 0f f8 call 200dc4c <_Thread_Enable_dispatch> 2009c70: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( EBADF ); 2009c74: 40 00 29 b2 call 201433c <__errno> 2009c78: 01 00 00 00 nop 2009c7c: 82 10 20 09 mov 9, %g1 ! 9 2009c80: c2 22 00 00 st %g1, [ %o0 ] 2009c84: 81 c7 e0 08 ret 2009c88: 81 e8 00 00 restore =============================================================================== 02009ca4 <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, bool wait, Watchdog_Interval timeout ) { 2009ca4: 9d e3 bf 88 save %sp, -120, %sp /* * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) 2009ca8: 80 a6 e0 20 cmp %i3, 0x20 2009cac: 18 80 00 47 bgu 2009dc8 <_POSIX_Message_queue_Send_support+0x124> 2009cb0: 11 00 80 8c sethi %hi(0x2023000), %o0 2009cb4: 92 10 00 18 mov %i0, %o1 2009cb8: 90 12 20 0c or %o0, 0xc, %o0 2009cbc: 40 00 0d 63 call 200d248 <_Objects_Get> 2009cc0: 94 07 bf f4 add %fp, -12, %o2 rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 2009cc4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009cc8: 80 a0 60 00 cmp %g1, 0 2009ccc: 12 80 00 31 bne 2009d90 <_POSIX_Message_queue_Send_support+0xec> 2009cd0: 01 00 00 00 nop case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { 2009cd4: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 2009cd8: 80 88 a0 03 btst 3, %g2 2009cdc: 02 80 00 41 be 2009de0 <_POSIX_Message_queue_Send_support+0x13c> 2009ce0: 80 8f 20 ff btst 0xff, %i4 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 2009ce4: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 2009ce8: 12 80 00 15 bne 2009d3c <_POSIX_Message_queue_Send_support+0x98><== ALWAYS TAKEN 2009cec: 82 10 20 00 clr %g1 do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 2009cf0: c2 23 a0 5c st %g1, [ %sp + 0x5c ] <== NOT EXECUTED 2009cf4: fa 23 a0 60 st %i5, [ %sp + 0x60 ] <== NOT EXECUTED 2009cf8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2009cfc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2009d00: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED 2009d04: 9a 20 00 1b neg %i3, %o5 <== NOT EXECUTED 2009d08: 98 10 20 00 clr %o4 <== NOT EXECUTED 2009d0c: 40 00 09 65 call 200c2a0 <_CORE_message_queue_Submit> <== NOT EXECUTED 2009d10: 90 02 20 1c add %o0, 0x1c, %o0 <== NOT EXECUTED _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout /* no timeout */ ); _Thread_Enable_dispatch(); 2009d14: 40 00 0f ce call 200dc4c <_Thread_Enable_dispatch> <== NOT EXECUTED 2009d18: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED * after it wakes up. The returned status is correct for * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) 2009d1c: 80 a7 60 07 cmp %i5, 7 <== NOT EXECUTED 2009d20: 02 80 00 19 be 2009d84 <_POSIX_Message_queue_Send_support+0xe0><== NOT EXECUTED 2009d24: 03 00 80 8a sethi %hi(0x2022800), %g1 <== NOT EXECUTED msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) 2009d28: 80 a7 60 00 cmp %i5, 0 2009d2c: 12 80 00 1f bne 2009da8 <_POSIX_Message_queue_Send_support+0x104> 2009d30: b0 10 20 00 clr %i0 case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 2009d34: 81 c7 e0 08 ret 2009d38: 81 e8 00 00 restore the_mq = the_mq_fd->Queue; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 2009d3c: 83 30 a0 0e srl %g2, 0xe, %g1 2009d40: 82 18 60 01 xor %g1, 1, %g1 2009d44: 82 08 60 01 and %g1, 1, %g1 do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 2009d48: fa 23 a0 60 st %i5, [ %sp + 0x60 ] 2009d4c: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2009d50: 92 10 00 19 mov %i1, %o1 2009d54: 94 10 00 1a mov %i2, %o2 2009d58: 96 10 00 18 mov %i0, %o3 2009d5c: 9a 20 00 1b neg %i3, %o5 2009d60: 98 10 20 00 clr %o4 2009d64: 40 00 09 4f call 200c2a0 <_CORE_message_queue_Submit> 2009d68: 90 02 20 1c add %o0, 0x1c, %o0 _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout /* no timeout */ ); _Thread_Enable_dispatch(); 2009d6c: 40 00 0f b8 call 200dc4c <_Thread_Enable_dispatch> 2009d70: ba 10 00 08 mov %o0, %i5 * after it wakes up. The returned status is correct for * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) 2009d74: 80 a7 60 07 cmp %i5, 7 2009d78: 12 bf ff ed bne 2009d2c <_POSIX_Message_queue_Send_support+0x88> 2009d7c: 80 a7 60 00 cmp %i5, 0 msg_status = _Thread_Executing->Wait.return_code; 2009d80: 03 00 80 8a sethi %hi(0x2022800), %g1 2009d84: c4 00 63 c4 ld [ %g1 + 0x3c4 ], %g2 ! 2022bc4 <_Thread_Executing> 2009d88: 10 bf ff e8 b 2009d28 <_POSIX_Message_queue_Send_support+0x84> 2009d8c: fa 00 a0 34 ld [ %g2 + 0x34 ], %i5 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 2009d90: 40 00 29 6b call 201433c <__errno> 2009d94: b0 10 3f ff mov -1, %i0 2009d98: 82 10 20 09 mov 9, %g1 2009d9c: c2 22 00 00 st %g1, [ %o0 ] } 2009da0: 81 c7 e0 08 ret 2009da4: 81 e8 00 00 restore msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) return msg_status; rtems_set_errno_and_return_minus_one( 2009da8: 40 00 29 65 call 201433c <__errno> 2009dac: b0 10 3f ff mov -1, %i0 2009db0: a0 10 00 08 mov %o0, %l0 2009db4: 40 00 00 5b call 2009f20 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 2009db8: 90 10 00 1d mov %i5, %o0 2009dbc: d0 24 00 00 st %o0, [ %l0 ] 2009dc0: 81 c7 e0 08 ret 2009dc4: 81 e8 00 00 restore * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) rtems_set_errno_and_return_minus_one( EINVAL ); 2009dc8: 40 00 29 5d call 201433c <__errno> 2009dcc: b0 10 3f ff mov -1, %i0 2009dd0: 82 10 20 16 mov 0x16, %g1 2009dd4: c2 22 00 00 st %g1, [ %o0 ] 2009dd8: 81 c7 e0 08 ret 2009ddc: 81 e8 00 00 restore the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { _Thread_Enable_dispatch(); 2009de0: 40 00 0f 9b call 200dc4c <_Thread_Enable_dispatch> 2009de4: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( EBADF ); 2009de8: 40 00 29 55 call 201433c <__errno> 2009dec: 01 00 00 00 nop 2009df0: 82 10 20 09 mov 9, %g1 ! 9 2009df4: c2 22 00 00 st %g1, [ %o0 ] 2009df8: 81 c7 e0 08 ret 2009dfc: 81 e8 00 00 restore =============================================================================== 02007320 <_POSIX_Mutex_Get>: POSIX_Mutex_Control *_POSIX_Mutex_Get ( pthread_mutex_t *mutex, Objects_Locations *location ) { 2007320: 9d e3 bf 98 save %sp, -104, %sp Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007324: 80 a6 20 00 cmp %i0, 0 2007328: 02 80 00 12 be 2007370 <_POSIX_Mutex_Get+0x50> 200732c: b4 10 00 19 mov %i1, %i2 2007330: f2 06 00 00 ld [ %i0 ], %i1 2007334: 80 a6 7f ff cmp %i1, -1 2007338: 02 80 00 05 be 200734c <_POSIX_Mutex_Get+0x2c> <== NEVER TAKEN 200733c: 90 10 00 18 mov %i0, %o0 return (POSIX_Mutex_Control *) 2007340: 31 00 80 66 sethi %hi(0x2019800), %i0 2007344: 40 00 0c 3b call 200a430 <_Objects_Get> 2007348: 91 ee 21 d0 restore %i0, 0x1d0, %o0 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 200734c: 40 00 00 20 call 20073cc <== NOT EXECUTED 2007350: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007354: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007358: 12 80 00 07 bne 2007374 <_POSIX_Mutex_Get+0x54> <== NOT EXECUTED 200735c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2007360: f2 06 00 00 ld [ %i0 ], %i1 <== NOT EXECUTED return (POSIX_Mutex_Control *) 2007364: 31 00 80 66 sethi %hi(0x2019800), %i0 <== NOT EXECUTED 2007368: 40 00 0c 32 call 200a430 <_Objects_Get> <== NOT EXECUTED 200736c: 91 ee 21 d0 restore %i0, 0x1d0, %o0 <== NOT EXECUTED Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007370: 82 10 20 01 mov 1, %g1 2007374: c2 26 80 00 st %g1, [ %i2 ] return (POSIX_Mutex_Control *) _Objects_Get( &_POSIX_Mutex_Information, *id, location ); } 2007378: 81 c7 e0 08 ret 200737c: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 020072b8 <_POSIX_Mutex_Get_interrupt_disable>: POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable ( pthread_mutex_t *mutex, Objects_Locations *location, ISR_Level *level ) { 20072b8: 9d e3 bf 98 save %sp, -104, %sp 20072bc: a0 10 00 19 mov %i1, %l0 Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 20072c0: 80 a6 20 00 cmp %i0, 0 20072c4: 02 80 00 13 be 2007310 <_POSIX_Mutex_Get_interrupt_disable+0x58><== NEVER TAKEN 20072c8: b6 10 00 1a mov %i2, %i3 20072cc: f2 06 00 00 ld [ %i0 ], %i1 20072d0: 80 a6 7f ff cmp %i1, -1 20072d4: 02 80 00 05 be 20072e8 <_POSIX_Mutex_Get_interrupt_disable+0x30><== NEVER TAKEN 20072d8: b4 10 00 10 mov %l0, %i2 return (POSIX_Mutex_Control *) 20072dc: 31 00 80 66 sethi %hi(0x2019800), %i0 20072e0: 40 00 0c 36 call 200a3b8 <_Objects_Get_isr_disable> 20072e4: 91 ee 21 d0 restore %i0, 0x1d0, %o0 ISR_Level *level ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 20072e8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20072ec: 40 00 00 38 call 20073cc <== NOT EXECUTED 20072f0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20072f4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20072f8: 12 80 00 06 bne 2007310 <_POSIX_Mutex_Get_interrupt_disable+0x58><== NOT EXECUTED 20072fc: b4 10 00 10 mov %l0, %i2 <== NOT EXECUTED 2007300: f2 06 00 00 ld [ %i0 ], %i1 <== NOT EXECUTED return (POSIX_Mutex_Control *) 2007304: 31 00 80 66 sethi %hi(0x2019800), %i0 <== NOT EXECUTED 2007308: 40 00 0c 2c call 200a3b8 <_Objects_Get_isr_disable> <== NOT EXECUTED 200730c: 91 ee 21 d0 restore %i0, 0x1d0, %o0 <== NOT EXECUTED ISR_Level *level ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007310: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2007314: c2 24 00 00 st %g1, [ %l0 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) _Objects_Get_isr_disable( &_POSIX_Mutex_Information, *id, location, level ); } 2007318: 81 c7 e0 08 ret <== NOT EXECUTED 200731c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 0200f0d0 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 200f0d0: 9d e3 bf 98 save %sp, -104, %sp 200f0d4: 03 00 80 7a sethi %hi(0x201e800), %g1 200f0d8: c4 00 62 a0 ld [ %g1 + 0x2a0 ], %g2 ! 201eaa0 <_Thread_Dispatch_disable_level> 200f0dc: 84 00 a0 01 inc %g2 200f0e0: c4 20 62 a0 st %g2, [ %g1 + 0x2a0 ] char *name_p = (char *)name; _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { 200f0e4: 80 a6 60 00 cmp %i1, 0 200f0e8: 12 80 00 2e bne 200f1a0 <_POSIX_Semaphore_Create_support+0xd0> 200f0ec: 80 a6 20 00 cmp %i0, 0 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSYS ); } if ( name ) { 200f0f0: 02 80 00 07 be 200f10c <_POSIX_Semaphore_Create_support+0x3c> 200f0f4: 21 00 80 7b sethi %hi(0x201ec00), %l0 if( strlen(name) > PATH_MAX ) { 200f0f8: 40 00 0f ec call 20130a8 200f0fc: 90 10 00 18 mov %i0, %o0 200f100: 80 a2 20 ff cmp %o0, 0xff 200f104: 18 80 00 2f bgu 200f1c0 <_POSIX_Semaphore_Create_support+0xf0><== NEVER TAKEN 200f108: 21 00 80 7b sethi %hi(0x201ec00), %l0 * _POSIX_Semaphore_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void ) { return (POSIX_Semaphore_Control *) 200f10c: 7f ff eb 88 call 2009f2c <_Objects_Allocate> 200f110: 90 14 21 b0 or %l0, 0x1b0, %o0 ! 201edb0 <_POSIX_Semaphore_Information> } } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 200f114: b2 92 20 00 orcc %o0, 0, %i1 200f118: 02 80 00 32 be 200f1e0 <_POSIX_Semaphore_Create_support+0x110> 200f11c: 80 a6 20 00 cmp %i0, 0 rtems_set_errno_and_return_minus_one( ENOSPC ); } the_semaphore->process_shared = pshared; if ( name ) { 200f120: 02 80 00 1c be 200f190 <_POSIX_Semaphore_Create_support+0xc0> 200f124: c0 26 60 10 clr [ %i1 + 0x10 ] the_semaphore->named = TRUE; the_semaphore->open_count = 1; 200f128: 84 10 20 01 mov 1, %g2 } the_semaphore->process_shared = pshared; if ( name ) { the_semaphore->named = TRUE; 200f12c: 82 10 20 01 mov 1, %g1 the_semaphore->open_count = 1; the_semaphore->linked = TRUE; 200f130: c4 2e 60 15 stb %g2, [ %i1 + 0x15 ] the_semaphore->process_shared = pshared; if ( name ) { the_semaphore->named = TRUE; the_semaphore->open_count = 1; 200f134: c4 26 60 18 st %g2, [ %i1 + 0x18 ] } the_semaphore->process_shared = pshared; if ( name ) { the_semaphore->named = TRUE; 200f138: c2 2e 60 14 stb %g1, [ %i1 + 0x14 ] /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 200f13c: 82 10 3f ff mov -1, %g1 _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 200f140: 94 10 00 1a mov %i2, %o2 200f144: 90 06 60 1c add %i1, 0x1c, %o0 200f148: 92 06 60 5c add %i1, 0x5c, %o1 /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 200f14c: c2 26 60 5c st %g1, [ %i1 + 0x5c ] _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 200f150: 7f ff ea 48 call 2009a70 <_CORE_semaphore_Initialize> 200f154: c0 26 60 60 clr [ %i1 + 0x60 ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200f158: 82 14 21 b0 or %l0, 0x1b0, %g1 200f15c: c4 06 60 08 ld [ %i1 + 8 ], %g2 200f160: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 200f164: 03 00 00 3f sethi %hi(0xfc00), %g1 200f168: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200f16c: 84 08 80 01 and %g2, %g1, %g2 200f170: 85 28 a0 02 sll %g2, 2, %g2 200f174: f2 20 c0 02 st %i1, [ %g3 + %g2 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string */ the_object->name.name_p = name; 200f178: f0 26 60 0c st %i0, [ %i1 + 0xc ] &_POSIX_Semaphore_Information, &the_semaphore->Object, name_p ); *the_sem = the_semaphore; 200f17c: f2 26 c0 00 st %i1, [ %i3 ] _Thread_Enable_dispatch(); 200f180: 7f ff ef 28 call 200ae20 <_Thread_Enable_dispatch> 200f184: b0 10 20 00 clr %i0 return 0; } 200f188: 81 c7 e0 08 ret 200f18c: 81 e8 00 00 restore if ( name ) { the_semaphore->named = TRUE; the_semaphore->open_count = 1; the_semaphore->linked = TRUE; } else { the_semaphore->named = FALSE; 200f190: c0 2e 60 14 clrb [ %i1 + 0x14 ] the_semaphore->open_count = 0; 200f194: c0 26 60 18 clr [ %i1 + 0x18 ] the_semaphore->linked = FALSE; 200f198: 10 bf ff e9 b 200f13c <_POSIX_Semaphore_Create_support+0x6c> 200f19c: c0 2e 60 15 clrb [ %i1 + 0x15 ] _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { _Thread_Enable_dispatch(); 200f1a0: 7f ff ef 20 call 200ae20 <_Thread_Enable_dispatch> 200f1a4: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( ENOSYS ); 200f1a8: 40 00 08 f6 call 2011580 <__errno> 200f1ac: 01 00 00 00 nop 200f1b0: 82 10 20 58 mov 0x58, %g1 ! 58 200f1b4: c2 22 00 00 st %g1, [ %o0 ] 200f1b8: 81 c7 e0 08 ret 200f1bc: 81 e8 00 00 restore } if ( name ) { if( strlen(name) > PATH_MAX ) { _Thread_Enable_dispatch(); 200f1c0: 7f ff ef 18 call 200ae20 <_Thread_Enable_dispatch> <== NOT EXECUTED 200f1c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 200f1c8: 40 00 08 ee call 2011580 <__errno> <== NOT EXECUTED 200f1cc: 01 00 00 00 nop <== NOT EXECUTED 200f1d0: 82 10 20 5b mov 0x5b, %g1 ! 5b <== NOT EXECUTED 200f1d4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200f1d8: 81 c7 e0 08 ret <== NOT EXECUTED 200f1dc: 81 e8 00 00 restore <== NOT EXECUTED } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 200f1e0: 7f ff ef 10 call 200ae20 <_Thread_Enable_dispatch> 200f1e4: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( ENOSPC ); 200f1e8: 40 00 08 e6 call 2011580 <__errno> 200f1ec: 01 00 00 00 nop 200f1f0: 82 10 20 1c mov 0x1c, %g1 ! 1c 200f1f4: c2 22 00 00 st %g1, [ %o0 ] 200f1f8: 81 c7 e0 08 ret 200f1fc: 81 e8 00 00 restore =============================================================================== 0200b844 <_POSIX_Threads_Create_extension>: bool _POSIX_Threads_Create_extension( Thread_Control *executing, Thread_Control *created ) { 200b844: 9d e3 bf 98 save %sp, -104, %sp POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); 200b848: 90 10 20 e4 mov 0xe4, %o0 200b84c: 7f ff f6 7a call 2009234 <_Workspace_Allocate> 200b850: b0 10 20 00 clr %i0 if ( !api ) 200b854: a2 92 20 00 orcc %o0, 0, %l1 200b858: 02 80 00 37 be 200b934 <_POSIX_Threads_Create_extension+0xf0><== NEVER TAKEN 200b85c: 21 00 80 5a sethi %hi(0x2016800), %l0 return false; created->API_Extensions[ THREAD_API_POSIX ] = api; 200b860: e2 26 61 6c st %l1, [ %i1 + 0x16c ] /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; 200b864: 94 10 20 38 mov 0x38, %o2 200b868: a0 14 23 78 or %l0, 0x378, %l0 200b86c: 40 00 0a 9b call 200e2d8 200b870: 92 10 00 10 mov %l0, %o1 api->detachstate = _POSIX_Threads_Default_attributes.detachstate; api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; api->schedparam = _POSIX_Threads_Default_attributes.schedparam; 200b874: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 200b878: c4 04 20 1c ld [ %l0 + 0x1c ], %g2 200b87c: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 200b880: c8 04 20 24 ld [ %l0 + 0x24 ], %g4 200b884: d8 04 20 2c ld [ %l0 + 0x2c ], %o4 200b888: da 04 20 28 ld [ %l0 + 0x28 ], %o5 200b88c: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 200b890: c4 24 60 84 st %g2, [ %l1 + 0x84 ] 200b894: c6 24 60 88 st %g3, [ %l1 + 0x88 ] 200b898: c8 24 60 8c st %g4, [ %l1 + 0x8c ] 200b89c: da 24 60 90 st %o5, [ %l1 + 0x90 ] 200b8a0: d8 24 60 94 st %o4, [ %l1 + 0x94 ] api->schedparam.sched_priority = 200b8a4: c6 06 60 14 ld [ %i1 + 0x14 ], %g3 created->API_Extensions[ THREAD_API_POSIX ] = api; /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 200b8a8: 84 10 20 01 mov 1, %g2 * If the thread is not a posix thread, then all posix signals are blocked * by default. */ /* XXX use signal constants */ api->signals_pending = 0; 200b8ac: c0 24 60 c8 clr [ %l1 + 0xc8 ] if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 200b8b0: c8 06 60 08 ld [ %i1 + 8 ], %g4 created->API_Extensions[ THREAD_API_POSIX ] = api; /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; api->detachstate = _POSIX_Threads_Default_attributes.detachstate; api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 200b8b4: c4 24 60 7c st %g2, [ %l1 + 0x7c ] created->API_Extensions[ THREAD_API_POSIX ] = api; /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 200b8b8: c4 24 60 38 st %g2, [ %l1 + 0x38 ] api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; api->schedparam = _POSIX_Threads_Default_attributes.schedparam; api->schedparam.sched_priority = 200b8bc: 82 10 20 ff mov 0xff, %g1 200b8c0: 84 04 60 dc add %l1, 0xdc, %g2 200b8c4: 82 20 40 03 sub %g1, %g3, %g1 _POSIX_Priority_From_core( created->current_priority ); /* * POSIX 1003.1 1996, 18.2.2.2 */ api->cancelation_requested = 0; 200b8c8: c0 24 60 d4 clr [ %l1 + 0xd4 ] /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; api->detachstate = _POSIX_Threads_Default_attributes.detachstate; api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; api->schedparam = _POSIX_Threads_Default_attributes.schedparam; api->schedparam.sched_priority = 200b8cc: c2 24 60 80 st %g1, [ %l1 + 0x80 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 200b8d0: 86 04 60 d8 add %l1, 0xd8, %g3 /* * POSIX 1003.1 1996, 18.2.2.2 */ api->cancelation_requested = 0; api->cancelability_state = PTHREAD_CANCEL_ENABLE; 200b8d4: c0 24 60 cc clr [ %l1 + 0xcc ] api->cancelability_type = PTHREAD_CANCEL_DEFERRED; 200b8d8: c0 24 60 d0 clr [ %l1 + 0xd0 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 200b8dc: c0 24 60 dc clr [ %l1 + 0xdc ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 200b8e0: c4 24 60 d8 st %g2, [ %l1 + 0xd8 ] * by default. */ /* XXX use signal constants */ api->signals_pending = 0; if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 200b8e4: 83 31 20 18 srl %g4, 0x18, %g1 200b8e8: 82 08 60 07 and %g1, 7, %g1 200b8ec: 80 a0 60 03 cmp %g1, 3 200b8f0: 02 80 00 13 be 200b93c <_POSIX_Threads_Create_extension+0xf8> 200b8f4: c6 24 60 e0 st %g3, [ %l1 + 0xe0 ] _Objects_Get_class( created->Object.id ) == 1 ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; } else { api->signals_blocked = 0xffffffff; 200b8f8: 82 10 3f ff mov -1, %g1 200b8fc: c2 24 60 c4 st %g1, [ %l1 + 0xc4 ] } _Thread_queue_Initialize( 200b900: 90 04 60 3c add %l1, 0x3c, %o0 200b904: 92 10 20 00 clr %o1 200b908: 15 00 00 04 sethi %hi(0x1000), %o2 200b90c: 7f ff f2 f6 call 20084e4 <_Thread_queue_Initialize> 200b910: 96 10 20 00 clr %o3 THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_JOIN_AT_EXIT, 0 ); _Watchdog_Initialize( 200b914: c2 06 60 08 ld [ %i1 + 8 ], %g1 ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 200b918: f2 24 60 c0 st %i1, [ %l1 + 0xc0 ] void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200b91c: c2 24 60 bc st %g1, [ %l1 + 0xbc ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200b920: c0 24 60 a4 clr [ %l1 + 0xa4 ] the_watchdog->routine = routine; 200b924: 03 00 80 2e sethi %hi(0x200b800), %g1 the_watchdog->id = id; the_watchdog->user_data = user_data; 200b928: b0 10 20 01 mov 1, %i0 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 200b92c: 82 10 61 b4 or %g1, 0x1b4, %g1 200b930: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] created->Object.id, created ); return true; } 200b934: 81 c7 e0 08 ret 200b938: 81 e8 00 00 restore * by default. */ /* XXX use signal constants */ api->signals_pending = 0; if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 200b93c: 83 31 20 1b srl %g4, 0x1b, %g1 200b940: 80 a0 60 01 cmp %g1, 1 200b944: 12 bf ff ee bne 200b8fc <_POSIX_Threads_Create_extension+0xb8><== NEVER TAKEN 200b948: 82 10 3f ff mov -1, %g1 _Objects_Get_class( created->Object.id ) == 1 ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; 200b94c: 03 00 80 60 sethi %hi(0x2018000), %g1 200b950: c4 00 63 d4 ld [ %g1 + 0x3d4 ], %g2 ! 20183d4 <_Thread_Executing> 200b954: c6 00 a1 6c ld [ %g2 + 0x16c ], %g3 200b958: c2 00 e0 c4 ld [ %g3 + 0xc4 ], %g1 200b95c: 10 bf ff e9 b 200b900 <_POSIX_Threads_Create_extension+0xbc> 200b960: c2 24 60 c4 st %g1, [ %l1 + 0xc4 ] =============================================================================== 020069b4 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body( void ) { 20069b4: 9d e3 bf 58 save %sp, -168, %sp uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = _POSIX_Threads_User_initialization_threads; 20069b8: 03 00 80 72 sethi %hi(0x201c800), %g1 20069bc: e6 00 62 d0 ld [ %g1 + 0x2d0 ], %l3 ! 201cad0 <_POSIX_Threads_User_initialization_threads> maximum = _POSIX_Threads_Number_of_initialization_threads; 20069c0: 03 00 80 72 sethi %hi(0x201c800), %g1 if ( !user_threads || maximum == 0 ) 20069c4: 80 a4 e0 00 cmp %l3, 0 20069c8: 02 80 00 1c be 2006a38 <_POSIX_Threads_Initialize_user_threads_body+0x84><== NEVER TAKEN 20069cc: e8 00 63 88 ld [ %g1 + 0x388 ], %l4 20069d0: 80 a5 20 00 cmp %l4, 0 20069d4: 02 80 00 19 be 2006a38 <_POSIX_Threads_Initialize_user_threads_body+0x84><== NEVER TAKEN 20069d8: a2 10 20 00 clr %l1 return; 20069dc: a0 10 20 00 clr %l0 20069e0: a4 07 bf bc add %fp, -68, %l2 20069e4: aa 07 bf f4 add %fp, -12, %l5 for ( index=0 ; index < maximum ; index++ ) { /* * There is no way for these calls to fail in this situation. */ (void) pthread_attr_init( &attr ); 20069e8: 40 00 1c ab call 200dc94 20069ec: 90 10 00 12 mov %l2, %o0 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 20069f0: 92 10 20 02 mov 2, %o1 20069f4: 40 00 1c b3 call 200dcc0 20069f8: 90 10 00 12 mov %l2, %o0 (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 20069fc: 82 04 c0 10 add %l3, %l0, %g1 2006a00: d2 00 60 04 ld [ %g1 + 4 ], %o1 2006a04: 40 00 1c c0 call 200dd04 2006a08: 90 10 00 12 mov %l2, %o0 status = pthread_create( 2006a0c: d4 04 c0 10 ld [ %l3 + %l0 ], %o2 2006a10: 90 10 00 15 mov %l5, %o0 2006a14: 92 10 00 12 mov %l2, %o1 2006a18: 7f ff fe fc call 2006608 2006a1c: 96 10 20 00 clr %o3 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 2006a20: 80 a2 20 00 cmp %o0, 0 2006a24: 12 80 00 07 bne 2006a40 <_POSIX_Threads_Initialize_user_threads_body+0x8c> 2006a28: a2 04 60 01 inc %l1 * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 2006a2c: 80 a5 00 11 cmp %l4, %l1 2006a30: 18 bf ff ee bgu 20069e8 <_POSIX_Threads_Initialize_user_threads_body+0x34><== NEVER TAKEN 2006a34: a0 04 20 08 add %l0, 8, %l0 2006a38: 81 c7 e0 08 ret 2006a3c: 81 e8 00 00 restore &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status ); 2006a40: 94 10 00 08 mov %o0, %o2 2006a44: 92 10 20 01 mov 1, %o1 2006a48: 40 00 08 f0 call 2008e08 <_Internal_error_Occurred> 2006a4c: 90 10 20 02 mov 2, %o0 =============================================================================== 0200b9b4 <_POSIX_Threads_Sporadic_budget_TSR>: void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id, void *argument ) { 200b9b4: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200b9b8: f0 06 61 6c ld [ %i1 + 0x16c ], %i0 ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); 200b9bc: 40 00 04 3f call 200cab8 <_Timespec_To_ticks> 200b9c0: 90 06 20 90 add %i0, 0x90, %o0 if ( !ticks ) 200b9c4: 80 a2 20 00 cmp %o0, 0 200b9c8: 22 80 00 02 be,a 200b9d0 <_POSIX_Threads_Sporadic_budget_TSR+0x1c><== NEVER TAKEN 200b9cc: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 200b9d0: c2 06 20 98 ld [ %i0 + 0x98 ], %g1 the_thread->cpu_time_budget = ticks; new_priority = _POSIX_Priority_To_core( api->ss_high_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200b9d4: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 200b9d8: 84 10 20 ff mov 0xff, %g2 ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); if ( !ticks ) ticks = 1; the_thread->cpu_time_budget = ticks; 200b9dc: d0 26 60 78 st %o0, [ %i1 + 0x78 ] 200b9e0: 92 20 80 01 sub %g2, %g1, %o1 new_priority = _POSIX_Priority_To_core( api->ss_high_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200b9e4: 80 a0 e0 00 cmp %g3, 0 200b9e8: 02 80 00 10 be 200ba28 <_POSIX_Threads_Sporadic_budget_TSR+0x74> 200b9ec: d2 26 60 18 st %o1, [ %i1 + 0x18 ] 200b9f0: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 200b9f4: 80 a0 40 09 cmp %g1, %o1 200b9f8: 18 80 00 0d bgu 200ba2c <_POSIX_Threads_Sporadic_budget_TSR+0x78><== ALWAYS TAKEN 200b9fc: 90 10 00 19 mov %i1, %o0 the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 200ba00: 40 00 04 2e call 200cab8 <_Timespec_To_ticks> 200ba04: 90 06 20 88 add %i0, 0x88, %o0 if ( !ticks ) 200ba08: 80 a2 20 00 cmp %o0, 0 200ba0c: 22 80 00 02 be,a 200ba14 <_POSIX_Threads_Sporadic_budget_TSR+0x60><== NEVER TAKEN 200ba10: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200ba14: d0 26 20 a8 st %o0, [ %i0 + 0xa8 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200ba18: b2 06 20 9c add %i0, 0x9c, %i1 200ba1c: 31 00 80 60 sethi %hi(0x2018000), %i0 200ba20: 7f ff f5 32 call 2008ee8 <_Watchdog_Insert> 200ba24: 91 ee 23 f4 restore %i0, 0x3f4, %o0 new_priority = _POSIX_Priority_To_core( api->ss_high_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 200ba28: 90 10 00 19 mov %i1, %o0 200ba2c: 7f ff ee e3 call 20075b8 <_Thread_Change_priority> 200ba30: 94 10 20 01 mov 1, %o2 200ba34: 30 bf ff f3 b,a 200ba00 <_POSIX_Threads_Sporadic_budget_TSR+0x4c> =============================================================================== 0200b964 <_POSIX_Threads_Sporadic_budget_callout>: ) { POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200b964: c4 02 21 6c ld [ %o0 + 0x16c ], %g2 the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200b968: c8 02 20 1c ld [ %o0 + 0x1c ], %g4 RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (255 - priority); 200b96c: c6 00 a0 84 ld [ %g2 + 0x84 ], %g3 * This will prevent the thread from consuming its entire "budget" * while at low priority. */ the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ 200b970: 82 10 3f ff mov -1, %g1 200b974: 84 10 20 ff mov 0xff, %g2 200b978: c2 22 20 78 st %g1, [ %o0 + 0x78 ] 200b97c: 92 20 80 03 sub %g2, %g3, %o1 new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200b980: 80 a1 20 00 cmp %g4, 0 200b984: 02 80 00 06 be 200b99c <_POSIX_Threads_Sporadic_budget_callout+0x38><== ALWAYS TAKEN 200b988: d2 22 20 18 st %o1, [ %o0 + 0x18 ] 200b98c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED 200b990: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED 200b994: 08 80 00 06 bleu 200b9ac <_POSIX_Threads_Sporadic_budget_callout+0x48><== NOT EXECUTED 200b998: 01 00 00 00 nop <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 200b99c: 94 10 20 01 mov 1, %o2 ! 1 200b9a0: 82 13 c0 00 mov %o7, %g1 200b9a4: 7f ff ef 05 call 20075b8 <_Thread_Change_priority> 200b9a8: 9e 10 40 00 mov %g1, %o7 200b9ac: 81 c3 e0 08 retl <== NOT EXECUTED =============================================================================== 0200d0c4 <_POSIX_Threads_cancel_run>: #include void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 200d0c4: 9d e3 bf 98 save %sp, -104, %sp POSIX_Cancel_Handler_control *handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200d0c8: e2 06 21 6c ld [ %i0 + 0x16c ], %l1 handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 200d0cc: 82 10 20 01 mov 1, %g1 while ( !_Chain_Is_empty( handler_stack ) ) { 200d0d0: c4 04 60 d8 ld [ %l1 + 0xd8 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200d0d4: b0 04 60 dc add %l1, 0xdc, %i0 200d0d8: 80 a0 80 18 cmp %g2, %i0 200d0dc: 02 80 00 14 be 200d12c <_POSIX_Threads_cancel_run+0x68> <== ALWAYS TAKEN 200d0e0: c2 24 60 cc st %g1, [ %l1 + 0xcc ] _ISR_Disable( level ); 200d0e4: 7f ff d3 40 call 2001de4 <== NOT EXECUTED 200d0e8: 01 00 00 00 nop <== NOT EXECUTED handler = (POSIX_Cancel_Handler_control *) 200d0ec: e0 06 20 04 ld [ %i0 + 4 ], %l0 <== NOT EXECUTED ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 200d0f0: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED previous = the_node->previous; 200d0f4: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 200d0f8: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200d0fc: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 200d100: 7f ff d3 3d call 2001df4 <== NOT EXECUTED 200d104: 01 00 00 00 nop <== NOT EXECUTED (*handler->routine)( handler->arg ); 200d108: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 200d10c: 9f c0 40 00 call %g1 <== NOT EXECUTED 200d110: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED _Workspace_Free( handler ); 200d114: 7f ff f0 41 call 2009218 <_Workspace_Free> <== NOT EXECUTED 200d118: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; while ( !_Chain_Is_empty( handler_stack ) ) { 200d11c: c2 04 60 d8 ld [ %l1 + 0xd8 ], %g1 <== NOT EXECUTED 200d120: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED 200d124: 12 bf ff f0 bne 200d0e4 <_POSIX_Threads_cancel_run+0x20> <== NOT EXECUTED 200d128: 01 00 00 00 nop <== NOT EXECUTED 200d12c: 81 c7 e0 08 ret 200d130: 81 e8 00 00 restore =============================================================================== 0200e0c8 <_POSIX_Timer_Insert_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 200e0c8: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; (void) _Watchdog_Remove( timer ); 200e0cc: 7f ff f4 a5 call 200b360 <_Watchdog_Remove> 200e0d0: 90 10 00 18 mov %i0, %o0 _ISR_Disable( level ); 200e0d4: 7f ff d2 ab call 2002b80 200e0d8: 01 00 00 00 nop 200e0dc: a0 10 00 08 mov %o0, %l0 /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( timer->state != WATCHDOG_INACTIVE ) { 200e0e0: c2 06 20 08 ld [ %i0 + 8 ], %g1 200e0e4: 80 a0 60 00 cmp %g1, 0 200e0e8: 12 80 00 0f bne 200e124 <_POSIX_Timer_Insert_helper+0x5c> <== NEVER TAKEN 200e0ec: 92 10 00 18 mov %i0, %o1 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 200e0f0: f6 26 20 1c st %i3, [ %i0 + 0x1c ] the_watchdog->id = id; 200e0f4: f4 26 20 20 st %i2, [ %i0 + 0x20 ] the_watchdog->user_data = user_data; 200e0f8: f8 26 20 24 st %i4, [ %i0 + 0x24 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200e0fc: f2 26 20 0c st %i1, [ %i0 + 0xc ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200e100: c0 26 20 08 clr [ %i0 + 8 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200e104: 11 00 80 74 sethi %hi(0x201d000), %o0 200e108: 7f ff f4 2b call 200b1b4 <_Watchdog_Insert> 200e10c: 90 12 21 c4 or %o0, 0x1c4, %o0 ! 201d1c4 <_Watchdog_Ticks_chain> * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); 200e110: b0 10 20 01 mov 1, %i0 200e114: 7f ff d2 9f call 2002b90 200e118: 90 10 00 10 mov %l0, %o0 return true; } 200e11c: 81 c7 e0 08 ret 200e120: 81 e8 00 00 restore /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( timer->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 200e124: 7f ff d2 9b call 2002b90 <== NOT EXECUTED 200e128: b0 10 20 00 clr %i0 <== NOT EXECUTED 200e12c: 81 c7 e0 08 ret <== NOT EXECUTED 200e130: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02007184 <_POSIX_Timer_TSR>: /* * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR(Objects_Id timer, void *data) { 2007184: 9d e3 bf 98 save %sp, -104, %sp bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 2007188: c2 06 60 68 ld [ %i1 + 0x68 ], %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 200718c: c4 06 60 54 ld [ %i1 + 0x54 ], %g2 bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 2007190: 82 00 60 01 inc %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 2007194: 80 a0 a0 00 cmp %g2, 0 2007198: 12 80 00 0e bne 20071d0 <_POSIX_Timer_TSR+0x4c> <== ALWAYS TAKEN 200719c: c2 26 60 68 st %g1, [ %i1 + 0x68 ] 20071a0: c2 06 60 58 ld [ %i1 + 0x58 ], %g1 <== NOT EXECUTED 20071a4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20071a8: 32 80 00 0b bne,a 20071d4 <_POSIX_Timer_TSR+0x50> <== NOT EXECUTED 20071ac: d2 06 60 64 ld [ %i1 + 0x64 ], %o1 <== NOT EXECUTED /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 20071b0: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED 20071b4: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] <== NOT EXECUTED /* * The sending of the signal to the process running the handling function * specified for that signal is simulated */ if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) { 20071b8: d0 06 60 38 ld [ %i1 + 0x38 ], %o0 20071bc: 40 00 1a e3 call 200dd48 20071c0: d2 06 60 44 ld [ %i1 + 0x44 ], %o1 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 20071c4: c0 26 60 68 clr [ %i1 + 0x68 ] 20071c8: 81 c7 e0 08 ret 20071cc: 81 e8 00 00 restore ptimer->overrun = ptimer->overrun + 1; /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 20071d0: d2 06 60 64 ld [ %i1 + 0x64 ], %o1 20071d4: d4 06 60 08 ld [ %i1 + 8 ], %o2 20071d8: 90 06 60 10 add %i1, 0x10, %o0 20071dc: 17 00 80 1c sethi %hi(0x2007000), %o3 20071e0: 98 10 00 19 mov %i1, %o4 20071e4: 40 00 1b b9 call 200e0c8 <_POSIX_Timer_Insert_helper> 20071e8: 96 12 e1 84 or %o3, 0x184, %o3 ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 20071ec: 80 8a 20 ff btst 0xff, %o0 20071f0: 02 bf ff f6 be 20071c8 <_POSIX_Timer_TSR+0x44> <== NEVER TAKEN 20071f4: 01 00 00 00 nop return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 20071f8: 40 00 06 22 call 2008a80 <_TOD_Get> 20071fc: 90 06 60 6c add %i1, 0x6c, %o0 /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 2007200: 82 10 20 03 mov 3, %g1 2007204: 10 bf ff ed b 20071b8 <_POSIX_Timer_TSR+0x34> 2007208: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] =============================================================================== 0200d220 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 200d220: 9d e3 bf 88 save %sp, -120, %sp siginfo_t siginfo_struct; sigset_t saved_signals_blocked; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 200d224: 98 10 20 01 mov 1, %o4 200d228: 96 0e a0 ff and %i2, 0xff, %o3 200d22c: a0 07 bf ec add %fp, -20, %l0 200d230: 90 10 00 18 mov %i0, %o0 200d234: 92 10 00 19 mov %i1, %o1 200d238: 40 00 00 24 call 200d2c8 <_POSIX_signals_Clear_signals> 200d23c: 94 10 00 10 mov %l0, %o2 200d240: 80 8a 20 ff btst 0xff, %o0 200d244: 02 80 00 17 be 200d2a0 <_POSIX_signals_Check_signal+0x80> 200d248: 03 00 80 62 sethi %hi(0x2018800), %g1 #endif /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 200d24c: 85 2e 60 02 sll %i1, 2, %g2 200d250: 9a 10 60 e0 or %g1, 0xe0, %o5 200d254: 83 2e 60 04 sll %i1, 4, %g1 200d258: 84 20 40 02 sub %g1, %g2, %g2 200d25c: 86 03 40 02 add %o5, %g2, %g3 200d260: c8 00 e0 08 ld [ %g3 + 8 ], %g4 200d264: 80 a1 20 01 cmp %g4, 1 200d268: 02 80 00 0e be 200d2a0 <_POSIX_signals_Check_signal+0x80> <== NEVER TAKEN 200d26c: 01 00 00 00 nop return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 200d270: f4 06 20 c4 ld [ %i0 + 0xc4 ], %i2 api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 200d274: c2 00 e0 04 ld [ %g3 + 4 ], %g1 /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 200d278: c4 03 40 02 ld [ %o5 + %g2 ], %g2 /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 200d27c: 82 10 40 1a or %g1, %i2, %g1 /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 200d280: 80 a0 a0 02 cmp %g2, 2 200d284: 02 80 00 09 be 200d2a8 <_POSIX_signals_Check_signal+0x88> 200d288: c2 26 20 c4 st %g1, [ %i0 + 0xc4 ] &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 200d28c: 9f c1 00 00 call %g4 200d290: 90 10 00 19 mov %i1, %o0 } /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 200d294: f4 26 20 c4 st %i2, [ %i0 + 0xc4 ] 200d298: 81 c7 e0 08 ret 200d29c: 91 e8 20 01 restore %g0, 1, %o0 return true; } 200d2a0: 81 c7 e0 08 ret 200d2a4: 91 e8 20 00 restore %g0, 0, %o0 /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 200d2a8: c2 00 e0 08 ld [ %g3 + 8 ], %g1 200d2ac: 90 10 00 19 mov %i1, %o0 200d2b0: 92 10 00 10 mov %l0, %o1 200d2b4: 9f c0 40 00 call %g1 200d2b8: 94 10 20 00 clr %o2 } /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 200d2bc: f4 26 20 c4 st %i2, [ %i0 + 0xc4 ] 200d2c0: 81 c7 e0 08 ret 200d2c4: 91 e8 20 01 restore %g0, 1, %o0 =============================================================================== 0200dab0 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( sigset_t mask ) { 200dab0: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 200dab4: 7f ff d0 cc call 2001de4 200dab8: 01 00 00 00 nop _POSIX_signals_Pending &= ~mask; 200dabc: 05 00 80 62 sethi %hi(0x2018800), %g2 200dac0: c2 00 a2 ac ld [ %g2 + 0x2ac ], %g1 ! 2018aac <_POSIX_signals_Pending> 200dac4: b0 28 40 18 andn %g1, %i0, %i0 if ( !_POSIX_signals_Pending ) 200dac8: 80 a6 20 00 cmp %i0, 0 200dacc: 12 80 00 06 bne 200dae4 <_POSIX_signals_Clear_process_signals+0x34><== NEVER TAKEN 200dad0: f0 20 a2 ac st %i0, [ %g2 + 0x2ac ] _Thread_Do_post_task_switch_extension--; 200dad4: 05 00 80 60 sethi %hi(0x2018000), %g2 200dad8: c2 00 a3 b8 ld [ %g2 + 0x3b8 ], %g1 ! 20183b8 <_Thread_Do_post_task_switch_extension> 200dadc: 82 00 7f ff add %g1, -1, %g1 200dae0: c2 20 a3 b8 st %g1, [ %g2 + 0x3b8 ] _ISR_Enable( level ); 200dae4: 7f ff d0 c4 call 2001df4 200dae8: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 0200d2c8 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, bool is_global, bool check_blocked ) { 200d2c8: 9d e3 bf 98 save %sp, -104, %sp sigset_t signals_blocked; ISR_Level level; bool do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); 200d2cc: 82 10 20 01 mov 1, %g1 /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK * insures that no signals are blocked and all are checked. */ if ( check_blocked ) 200d2d0: 80 8f 20 ff btst 0xff, %i4 sigset_t signals_blocked; ISR_Level level; bool do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); 200d2d4: 84 06 7f ff add %i1, -1, %g2 /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK * insures that no signals are blocked and all are checked. */ if ( check_blocked ) 200d2d8: b8 10 3f ff mov -1, %i4 200d2dc: 02 80 00 04 be 200d2ec <_POSIX_signals_Clear_signals+0x24> 200d2e0: a1 28 40 02 sll %g1, %g2, %l0 signals_blocked = ~api->signals_blocked; 200d2e4: c2 06 20 c4 ld [ %i0 + 0xc4 ], %g1 200d2e8: b8 38 00 01 xnor %g0, %g1, %i4 signals_blocked = SIGNAL_ALL_MASK; /* XXX this is not right for siginfo type signals yet */ /* XXX since they can't be cleared the same way */ _ISR_Disable( level ); 200d2ec: 7f ff d2 be call 2001de4 200d2f0: 01 00 00 00 nop 200d2f4: a2 10 00 08 mov %o0, %l1 if ( is_global ) { 200d2f8: 80 8e e0 ff btst 0xff, %i3 200d2fc: 22 80 00 33 be,a 200d3c8 <_POSIX_signals_Clear_signals+0x100> 200d300: c4 06 20 c8 ld [ %i0 + 0xc8 ], %g2 if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 200d304: 05 00 80 62 sethi %hi(0x2018800), %g2 200d308: c2 00 a2 ac ld [ %g2 + 0x2ac ], %g1 ! 2018aac <_POSIX_signals_Pending> 200d30c: 82 0c 00 01 and %l0, %g1, %g1 200d310: 80 88 40 1c btst %g1, %i4 200d314: 02 80 00 37 be 200d3f0 <_POSIX_signals_Clear_signals+0x128> 200d318: 85 2e 60 02 sll %i1, 2, %g2 if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 200d31c: 87 2e 60 04 sll %i1, 4, %g3 200d320: 03 00 80 62 sethi %hi(0x2018800), %g1 200d324: 86 20 c0 02 sub %g3, %g2, %g3 200d328: 82 10 60 e0 or %g1, 0xe0, %g1 200d32c: c4 00 40 03 ld [ %g1 + %g3 ], %g2 200d330: 80 a0 a0 02 cmp %g2, 2 200d334: 12 80 00 34 bne 200d404 <_POSIX_signals_Clear_signals+0x13c> 200d338: 03 00 80 62 sethi %hi(0x2018800), %g1 psiginfo = (POSIX_signals_Siginfo_node *) 200d33c: 88 10 62 b0 or %g1, 0x2b0, %g4 ! 2018ab0 <_POSIX_signals_Siginfo> */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 200d340: c4 00 c0 04 ld [ %g3 + %g4 ], %g2 200d344: 98 00 c0 04 add %g3, %g4, %o4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200d348: 9a 03 20 04 add %o4, 4, %o5 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 200d34c: 80 a0 80 0d cmp %g2, %o5 200d350: 02 80 00 34 be 200d420 <_POSIX_signals_Clear_signals+0x158><== NEVER TAKEN 200d354: b8 10 20 00 clr %i4 { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 200d358: c2 00 80 00 ld [ %g2 ], %g1 200d35c: b8 10 00 02 mov %g2, %i4 the_chain->first = new_first; 200d360: c2 20 c0 04 st %g1, [ %g3 + %g4 ] _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 200d364: 80 a3 40 01 cmp %o5, %g1 200d368: 02 80 00 2e be 200d420 <_POSIX_signals_Clear_signals+0x158><== ALWAYS TAKEN 200d36c: d8 20 60 04 st %o4, [ %g1 + 4 ] _POSIX_signals_Clear_process_signals( mask ); if ( psiginfo ) { 200d370: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 200d374: 02 80 00 1b be 200d3e0 <_POSIX_signals_Clear_signals+0x118><== NEVER TAKEN 200d378: b0 10 20 01 mov 1, %i0 *info = psiginfo->Info; 200d37c: c2 07 20 08 ld [ %i4 + 8 ], %g1 the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; the_node->previous = old_last_node; 200d380: b0 10 20 01 mov 1, %i0 200d384: c2 26 80 00 st %g1, [ %i2 ] 200d388: c4 07 20 0c ld [ %i4 + 0xc ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200d38c: 03 00 80 62 sethi %hi(0x2018800), %g1 200d390: c4 26 a0 04 st %g2, [ %i2 + 4 ] 200d394: 82 10 62 64 or %g1, 0x264, %g1 200d398: c6 07 20 10 ld [ %i4 + 0x10 ], %g3 200d39c: c2 27 00 00 st %g1, [ %i4 ] old_last_node = the_chain->last; 200d3a0: 82 00 7f fc add %g1, -4, %g1 200d3a4: c4 00 60 08 ld [ %g1 + 8 ], %g2 the_chain->last = the_node; 200d3a8: f8 20 60 08 st %i4, [ %g1 + 8 ] 200d3ac: c6 26 a0 08 st %g3, [ %i2 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200d3b0: c4 27 20 04 st %g2, [ %i4 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 200d3b4: f8 20 80 00 st %i4, [ %g2 ] if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; do_callout = true; } } _ISR_Enable( level ); 200d3b8: 7f ff d2 8f call 2001df4 200d3bc: 90 10 00 11 mov %l1, %o0 return do_callout; } 200d3c0: 81 c7 e0 08 ret 200d3c4: 81 e8 00 00 restore } else _POSIX_signals_Clear_process_signals( mask ); do_callout = true; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 200d3c8: 82 0c 00 02 and %l0, %g2, %g1 200d3cc: 80 88 40 1c btst %g1, %i4 200d3d0: 02 80 00 08 be 200d3f0 <_POSIX_signals_Clear_signals+0x128> 200d3d4: 82 28 80 10 andn %g2, %l0, %g1 api->signals_pending &= ~mask; 200d3d8: c2 26 20 c8 st %g1, [ %i0 + 0xc8 ] 200d3dc: b0 10 20 01 mov 1, %i0 do_callout = true; } } _ISR_Enable( level ); 200d3e0: 7f ff d2 85 call 2001df4 200d3e4: 90 10 00 11 mov %l1, %o0 return do_callout; } 200d3e8: 81 c7 e0 08 ret 200d3ec: 81 e8 00 00 restore _POSIX_signals_Clear_process_signals( mask ); do_callout = true; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; 200d3f0: b0 10 20 00 clr %i0 do_callout = true; } } _ISR_Enable( level ); 200d3f4: 7f ff d2 80 call 2001df4 200d3f8: 90 10 00 11 mov %l1, %o0 return do_callout; } 200d3fc: 81 c7 e0 08 ret 200d400: 81 e8 00 00 restore &psiginfo->Node ); } else do_callout = false; } else _POSIX_signals_Clear_process_signals( mask ); 200d404: 90 10 00 10 mov %l0, %o0 200d408: 40 00 01 aa call 200dab0 <_POSIX_signals_Clear_process_signals> 200d40c: b0 10 20 01 mov 1, %i0 if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; do_callout = true; } } _ISR_Enable( level ); 200d410: 7f ff d2 79 call 2001df4 200d414: 90 10 00 11 mov %l1, %o0 return do_callout; } 200d418: 81 c7 e0 08 ret 200d41c: 81 e8 00 00 restore if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) _POSIX_signals_Clear_process_signals( mask ); 200d420: 40 00 01 a4 call 200dab0 <_POSIX_signals_Clear_process_signals> 200d424: 90 10 00 10 mov %l0, %o0 if ( psiginfo ) { 200d428: 10 bf ff d3 b 200d374 <_POSIX_signals_Clear_signals+0xac> 200d42c: 80 a7 20 00 cmp %i4, 0 =============================================================================== 020063a4 <_POSIX_signals_Get_highest>: #include int _POSIX_signals_Get_highest( sigset_t set ) { 20063a4: 86 10 00 08 mov %o0, %g3 int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) 20063a8: 84 10 20 01 mov 1, %g2 #include int _POSIX_signals_Get_highest( sigset_t set ) { 20063ac: 90 10 20 1b mov 0x1b, %o0 int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) 20063b0: 82 02 3f ff add %o0, -1, %g1 20063b4: 83 28 80 01 sll %g2, %g1, %g1 20063b8: 80 88 40 03 btst %g1, %g3 20063bc: 12 80 00 11 bne 2006400 <_POSIX_signals_Get_highest+0x5c> <== NEVER TAKEN 20063c0: 01 00 00 00 nop sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 20063c4: 90 02 20 01 inc %o0 20063c8: 80 a2 20 20 cmp %o0, 0x20 20063cc: 12 bf ff fa bne 20063b4 <_POSIX_signals_Get_highest+0x10> 20063d0: 82 02 3f ff add %o0, -1, %g1 20063d4: 90 10 20 01 mov 1, %o0 } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) 20063d8: 10 80 00 05 b 20063ec <_POSIX_signals_Get_highest+0x48> 20063dc: 84 10 20 01 mov 1, %g2 return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 20063e0: 80 a2 20 1b cmp %o0, 0x1b 20063e4: 02 80 00 09 be 2006408 <_POSIX_signals_Get_highest+0x64> <== NEVER TAKEN 20063e8: 01 00 00 00 nop if ( set & signo_to_mask( signo ) ) 20063ec: 82 02 3f ff add %o0, -1, %g1 20063f0: 83 28 80 01 sll %g2, %g1, %g1 20063f4: 80 88 40 03 btst %g1, %g3 20063f8: 22 bf ff fa be,a 20063e0 <_POSIX_signals_Get_highest+0x3c> 20063fc: 90 02 20 01 inc %o0 return signo; } return 0; } 2006400: 81 c3 e0 08 retl 2006404: 01 00 00 00 nop 2006408: 81 c3 e0 08 retl <== NOT EXECUTED 200640c: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED =============================================================================== 0200b5e0 <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) { 200b5e0: 9d e3 bf 98 save %sp, -104, %sp POSIX_API_Control *api; int signo; ISR_Level level; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200b5e4: e0 06 21 6c ld [ %i0 + 0x16c ], %l0 if ( !api ) 200b5e8: 80 a4 20 00 cmp %l0, 0 200b5ec: 02 80 00 3c be 200b6dc <_POSIX_signals_Post_switch_extension+0xfc><== NEVER TAKEN 200b5f0: 03 00 80 62 sethi %hi(0x2018800), %g1 200b5f4: a2 10 62 ac or %g1, 0x2ac, %l1 ! 2018aac <_POSIX_signals_Pending> * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { restart: _ISR_Disable( level ); 200b5f8: 7f ff d9 fb call 2001de4 200b5fc: 01 00 00 00 nop 200b600: b0 10 00 08 mov %o0, %i0 if ( !(~api->signals_blocked & 200b604: c2 04 40 00 ld [ %l1 ], %g1 200b608: c4 04 20 c8 ld [ %l0 + 0xc8 ], %g2 200b60c: c6 04 20 c4 ld [ %l0 + 0xc4 ], %g3 200b610: 82 10 40 02 or %g1, %g2, %g1 200b614: 80 a8 40 03 andncc %g1, %g3, %g0 200b618: 02 80 00 2f be 200b6d4 <_POSIX_signals_Post_switch_extension+0xf4> 200b61c: 01 00 00 00 nop (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); break; } _ISR_Enable( level ); 200b620: 7f ff d9 f5 call 2001df4 200b624: b0 10 20 1b mov 0x1b, %i0 ! 1b for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, false ) ) 200b628: 92 10 00 18 mov %i0, %o1 200b62c: 94 10 20 00 clr %o2 200b630: 40 00 06 fc call 200d220 <_POSIX_signals_Check_signal> 200b634: 90 10 00 10 mov %l0, %o0 200b638: 80 8a 20 ff btst 0xff, %o0 200b63c: 12 bf ff ef bne 200b5f8 <_POSIX_signals_Post_switch_extension+0x18><== NEVER TAKEN 200b640: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, true ) ) 200b644: 90 10 00 10 mov %l0, %o0 200b648: 94 10 20 01 mov 1, %o2 200b64c: 40 00 06 f5 call 200d220 <_POSIX_signals_Check_signal> 200b650: b0 06 20 01 inc %i0 200b654: 80 8a 20 ff btst 0xff, %o0 200b658: 12 bf ff e8 bne 200b5f8 <_POSIX_signals_Post_switch_extension+0x18><== NEVER TAKEN 200b65c: 80 a6 20 20 cmp %i0, 0x20 _ISR_Enable( level ); break; } _ISR_Enable( level ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 200b660: 12 bf ff f3 bne 200b62c <_POSIX_signals_Post_switch_extension+0x4c> 200b664: 92 10 00 18 mov %i0, %o1 200b668: b0 10 20 01 mov 1, %i0 /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, false ) ) 200b66c: 92 10 00 18 mov %i0, %o1 200b670: 94 10 20 00 clr %o2 200b674: 40 00 06 eb call 200d220 <_POSIX_signals_Check_signal> 200b678: 90 10 00 10 mov %l0, %o0 200b67c: 80 8a 20 ff btst 0xff, %o0 200b680: 12 bf ff de bne 200b5f8 <_POSIX_signals_Post_switch_extension+0x18> 200b684: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, true ) ) 200b688: 90 10 00 10 mov %l0, %o0 200b68c: 94 10 20 01 mov 1, %o2 200b690: 40 00 06 e4 call 200d220 <_POSIX_signals_Check_signal> 200b694: b0 06 20 01 inc %i0 200b698: 80 8a 20 ff btst 0xff, %o0 200b69c: 12 bf ff d7 bne 200b5f8 <_POSIX_signals_Post_switch_extension+0x18> 200b6a0: 80 a6 20 1b cmp %i0, 0x1b } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 200b6a4: 12 bf ff f3 bne 200b670 <_POSIX_signals_Post_switch_extension+0x90><== ALWAYS TAKEN 200b6a8: 92 10 00 18 mov %i0, %o1 * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { restart: _ISR_Disable( level ); 200b6ac: 7f ff d9 ce call 2001de4 <== NOT EXECUTED 200b6b0: 01 00 00 00 nop <== NOT EXECUTED 200b6b4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED if ( !(~api->signals_blocked & 200b6b8: c2 04 40 00 ld [ %l1 ], %g1 <== NOT EXECUTED 200b6bc: c4 04 20 c8 ld [ %l0 + 0xc8 ], %g2 <== NOT EXECUTED 200b6c0: c6 04 20 c4 ld [ %l0 + 0xc4 ], %g3 <== NOT EXECUTED 200b6c4: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED 200b6c8: 80 a8 40 03 andncc %g1, %g3, %g0 <== NOT EXECUTED 200b6cc: 12 bf ff d5 bne 200b620 <_POSIX_signals_Post_switch_extension+0x40><== NOT EXECUTED 200b6d0: 01 00 00 00 nop <== NOT EXECUTED (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); 200b6d4: 7f ff d9 c8 call 2001df4 200b6d8: 81 e8 00 00 restore 200b6dc: 81 c7 e0 08 ret <== NOT EXECUTED 200b6e0: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 020194d0 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 20194d0: 9d e3 bf 98 save %sp, -104, %sp /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 20194d4: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 20194d8: 07 04 00 20 sethi %hi(0x10008000), %g3 sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; mask = signo_to_mask( signo ); 20194dc: 84 06 7f ff add %i1, -1, %g2 /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 20194e0: 82 09 00 03 and %g4, %g3, %g1 sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; mask = signo_to_mask( signo ); 20194e4: 9a 10 20 01 mov 1, %o5 /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 20194e8: 80 a0 40 03 cmp %g1, %g3 sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; mask = signo_to_mask( signo ); 20194ec: 85 2b 40 02 sll %o5, %g2, %g2 /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 20194f0: 02 80 00 25 be 2019584 <_POSIX_signals_Unblock_thread+0xb4> 20194f4: c6 06 21 6c ld [ %i0 + 0x16c ], %g3 } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 20194f8: c2 00 e0 c4 ld [ %g3 + 0xc4 ], %g1 20194fc: 80 a8 80 01 andncc %g2, %g1, %g0 2019500: 02 80 00 1f be 201957c <_POSIX_signals_Unblock_thread+0xac> 2019504: 03 04 00 00 sethi %hi(0x10000000), %g1 * + Any other combination, do nothing. */ the_thread->do_post_task_switch_extension = true; if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 2019508: 80 89 00 01 btst %g4, %g1 201950c: 02 80 00 11 be 2019550 <_POSIX_signals_Unblock_thread+0x80> 2019510: da 2e 20 75 stb %o5, [ %i0 + 0x75 ] the_thread->Wait.return_code = EINTR; 2019514: 82 10 20 04 mov 4, %g1 #if 0 if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) _Thread_queue_Extract_with_proxy( the_thread ); else #endif if ( _States_Is_delaying(the_thread->current_state) ){ 2019518: 80 89 20 08 btst 8, %g4 201951c: 02 80 00 18 be 201957c <_POSIX_signals_Unblock_thread+0xac><== NEVER TAKEN 2019520: c2 26 20 34 st %g1, [ %i0 + 0x34 ] if ( _Watchdog_Is_active( &the_thread->Timer ) ) 2019524: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 2019528: 80 a0 60 02 cmp %g1, 2 201952c: 02 80 00 36 be 2019604 <_POSIX_signals_Unblock_thread+0x134><== ALWAYS TAKEN 2019530: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2019534: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2019538: 13 04 00 ff sethi %hi(0x1003fc00), %o1 201953c: b0 10 20 00 clr %i0 2019540: 7f ff be d7 call 200909c <_Thread_Clear_state> 2019544: 92 12 63 f8 or %o1, 0x3f8, %o1 2019548: 81 c7 e0 08 ret 201954c: 81 e8 00 00 restore (void) _Watchdog_Remove( &the_thread->Timer ); _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 2019550: 80 a1 20 00 cmp %g4, 0 2019554: 12 80 00 0a bne 201957c <_POSIX_signals_Unblock_thread+0xac><== NEVER TAKEN 2019558: 03 00 80 93 sethi %hi(0x2024c00), %g1 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 201955c: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 2024e00 <_ISR_Nest_level> 2019560: 80 a0 a0 00 cmp %g2, 0 2019564: 02 80 00 06 be 201957c <_POSIX_signals_Unblock_thread+0xac> 2019568: 03 00 80 93 sethi %hi(0x2024c00), %g1 201956c: c4 00 62 24 ld [ %g1 + 0x224 ], %g2 ! 2024e24 <_Thread_Executing> 2019570: 80 a6 00 02 cmp %i0, %g2 2019574: 02 80 00 1c be 20195e4 <_POSIX_signals_Unblock_thread+0x114><== ALWAYS TAKEN 2019578: 03 00 80 93 sethi %hi(0x2024c00), %g1 _ISR_Signals_to_thread_executing = TRUE; } } return false; } 201957c: 81 c7 e0 08 ret 2019580: 91 e8 20 00 restore %g0, 0, %o0 * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 2019584: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2019588: 80 88 80 01 btst %g2, %g1 201958c: 22 80 00 12 be,a 20195d4 <_POSIX_signals_Unblock_thread+0x104> 2019590: c2 00 e0 c4 ld [ %g3 + 0xc4 ], %g1 the_thread->Wait.return_code = EINTR; 2019594: 82 10 20 04 mov 4, %g1 2019598: c2 26 20 34 st %g1, [ %i0 + 0x34 ] the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { 201959c: 80 a6 a0 00 cmp %i2, 0 20195a0: 02 80 00 14 be 20195f0 <_POSIX_signals_Unblock_thread+0x120> 20195a4: c6 06 20 28 ld [ %i0 + 0x28 ], %g3 the_info->si_signo = signo; the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; } else { *the_info = *info; 20195a8: c2 06 80 00 ld [ %i2 ], %g1 20195ac: c2 20 c0 00 st %g1, [ %g3 ] 20195b0: c4 06 a0 04 ld [ %i2 + 4 ], %g2 20195b4: c4 20 e0 04 st %g2, [ %g3 + 4 ] 20195b8: c2 06 a0 08 ld [ %i2 + 8 ], %g1 20195bc: c2 20 e0 08 st %g1, [ %g3 + 8 ] } _Thread_queue_Extract_with_proxy( the_thread ); 20195c0: 90 10 00 18 mov %i0, %o0 20195c4: 7f ff c2 05 call 2009dd8 <_Thread_queue_Extract_with_proxy> 20195c8: b0 10 20 01 mov 1, %i0 20195cc: 81 c7 e0 08 ret 20195d0: 81 e8 00 00 restore * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 20195d4: 80 a8 80 01 andncc %g2, %g1, %g0 20195d8: 12 bf ff f0 bne 2019598 <_POSIX_signals_Unblock_thread+0xc8><== NEVER TAKEN 20195dc: 82 10 20 04 mov 4, %g1 20195e0: 30 bf ff e7 b,a 201957c <_POSIX_signals_Unblock_thread+0xac> (void) _Watchdog_Remove( &the_thread->Timer ); _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _ISR_Signals_to_thread_executing = TRUE; 20195e4: da 28 62 b8 stb %o5, [ %g1 + 0x2b8 ] 20195e8: 81 c7 e0 08 ret 20195ec: 91 e8 20 00 restore %g0, 0, %o0 the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { the_info->si_signo = signo; the_info->si_code = SI_USER; 20195f0: 82 10 20 01 mov 1, %g1 the_thread->Wait.return_code = EINTR; the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { the_info->si_signo = signo; 20195f4: f2 20 c0 00 st %i1, [ %g3 ] the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; 20195f8: c0 20 e0 08 clr [ %g3 + 8 ] the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { the_info->si_signo = signo; the_info->si_code = SI_USER; 20195fc: 10 bf ff f1 b 20195c0 <_POSIX_signals_Unblock_thread+0xf0> 2019600: c2 20 e0 04 st %g1, [ %g3 + 4 ] _Thread_queue_Extract_with_proxy( the_thread ); else #endif if ( _States_Is_delaying(the_thread->current_state) ){ if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 2019604: 7f ff c6 75 call 200afd8 <_Watchdog_Remove> 2019608: 90 06 20 48 add %i0, 0x48, %o0 201960c: 10 bf ff cb b 2019538 <_POSIX_signals_Unblock_thread+0x68> 2019610: 90 10 00 18 mov %i0, %o0 =============================================================================== 02009ff4 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 2009ff4: 9d e3 bf 98 save %sp, -104, %sp Heap_Get_information_status status; if ( !the_heap ) 2009ff8: 80 a6 20 00 cmp %i0, 0 2009ffc: 02 80 00 10 be 200a03c <_Protected_heap_Get_information+0x48><== NEVER TAKEN 200a000: 80 a6 60 00 cmp %i1, 0 return false; if ( !the_info ) 200a004: 02 80 00 0e be 200a03c <_Protected_heap_Get_information+0x48><== NEVER TAKEN 200a008: 23 00 80 79 sethi %hi(0x201e400), %l1 return false; _RTEMS_Lock_allocator(); 200a00c: 7f ff f9 22 call 2008494 <_API_Mutex_Lock> 200a010: d0 04 61 cc ld [ %l1 + 0x1cc ], %o0 ! 201e5cc <_RTEMS_Allocator_Mutex> status = _Heap_Get_information( the_heap, the_info ); 200a014: 90 10 00 18 mov %i0, %o0 200a018: 40 00 13 81 call 200ee1c <_Heap_Get_information> 200a01c: 92 10 00 19 mov %i1, %o1 200a020: a0 10 00 08 mov %o0, %l0 _RTEMS_Unlock_allocator(); 200a024: 7f ff f9 32 call 20084ec <_API_Mutex_Unlock> 200a028: d0 04 61 cc ld [ %l1 + 0x1cc ], %o0 if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 200a02c: 80 a0 00 10 cmp %g0, %l0 200a030: 82 60 3f ff subx %g0, -1, %g1 200a034: 81 c7 e0 08 ret 200a038: 91 e8 00 01 restore %g0, %g1, %o0 return true; return false; } 200a03c: 81 c7 e0 08 ret <== NOT EXECUTED 200a040: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 0200be58 <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 200be58: 9d e3 bf 98 save %sp, -104, %sp /* * Notepads must be the last entry in the structure and they * can be left off if disabled in the configuration. */ to_allocate = sizeof( RTEMS_API_Control ); if ( !rtems_configuration_get_notepads_enabled() ) 200be5c: 21 00 80 60 sethi %hi(0x2018000), %l0 200be60: c6 04 23 ac ld [ %l0 + 0x3ac ], %g3 ! 20183ac <_Configuration_Table> to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); if ( !api ) 200be64: b0 10 20 00 clr %i0 /* * Notepads must be the last entry in the structure and they * can be left off if disabled in the configuration. */ to_allocate = sizeof( RTEMS_API_Control ); if ( !rtems_configuration_get_notepads_enabled() ) 200be68: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1 200be6c: c4 08 60 04 ldub [ %g1 + 4 ], %g2 200be70: 80 a0 00 02 cmp %g0, %g2 200be74: 90 60 20 00 subx %g0, 0, %o0 200be78: 90 0a 20 40 and %o0, 0x40, %o0 to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 200be7c: 7f ff f4 ee call 2009234 <_Workspace_Allocate> 200be80: 90 02 20 20 add %o0, 0x20, %o0 if ( !api ) 200be84: 80 a2 20 00 cmp %o0, 0 200be88: 02 80 00 17 be 200bee4 <_RTEMS_tasks_Create_extension+0x8c><== NEVER TAKEN 200be8c: c2 04 23 ac ld [ %l0 + 0x3ac ], %g1 */ RTEMS_INLINE_ROUTINE void _ASR_Initialize ( ASR_Information *information ) { information->is_enabled = true; 200be90: 84 10 20 01 mov 1, %g2 api->pending_events = EVENT_SETS_NONE_PENDING; _ASR_Initialize( &api->Signal ); created->task_variables = NULL; if ( rtems_configuration_get_notepads_enabled() ) { 200be94: c6 00 60 40 ld [ %g1 + 0x40 ], %g3 200be98: c4 2a 20 08 stb %g2, [ %o0 + 8 ] 200be9c: c2 08 e0 04 ldub [ %g3 + 4 ], %g1 created->API_Extensions[ THREAD_API_RTEMS ] = api; api->pending_events = EVENT_SETS_NONE_PENDING; _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 200bea0: c0 26 61 78 clr [ %i1 + 0x178 ] api = _Workspace_Allocate( to_allocate ); if ( !api ) return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 200bea4: d0 26 61 68 st %o0, [ %i1 + 0x168 ] api->pending_events = EVENT_SETS_NONE_PENDING; 200bea8: c0 22 00 00 clr [ %o0 ] information->handler = NULL; 200beac: c0 22 20 0c clr [ %o0 + 0xc ] information->mode_set = RTEMS_DEFAULT_MODES; 200beb0: c0 22 20 10 clr [ %o0 + 0x10 ] information->signals_posted = 0; 200beb4: c0 22 20 14 clr [ %o0 + 0x14 ] information->signals_pending = 0; 200beb8: c0 22 20 18 clr [ %o0 + 0x18 ] _ASR_Initialize( &api->Signal ); created->task_variables = NULL; if ( rtems_configuration_get_notepads_enabled() ) { 200bebc: 80 a0 60 00 cmp %g1, 0 200bec0: 02 80 00 08 be 200bee0 <_RTEMS_tasks_Create_extension+0x88> 200bec4: c0 22 20 1c clr [ %o0 + 0x1c ] 200bec8: 84 10 20 00 clr %g2 for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 200becc: 82 02 00 02 add %o0, %g2, %g1 200bed0: 84 00 a0 04 add %g2, 4, %g2 api->pending_events = EVENT_SETS_NONE_PENDING; _ASR_Initialize( &api->Signal ); created->task_variables = NULL; if ( rtems_configuration_get_notepads_enabled() ) { for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) 200bed4: 80 a0 a0 40 cmp %g2, 0x40 200bed8: 12 bf ff fd bne 200becc <_RTEMS_tasks_Create_extension+0x74> 200bedc: c0 20 60 20 clr [ %g1 + 0x20 ] 200bee0: b0 10 20 01 mov 1, %i0 api->Notepads[i] = 0; } return true; } 200bee4: 81 c7 e0 08 ret 200bee8: 81 e8 00 00 restore =============================================================================== 02005c34 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 2005c34: 9d e3 bf 90 save %sp, -112, %sp rtems_status_code return_value; rtems_initialization_tasks_table *user_tasks; rtems_api_configuration_table *api_configuration; api_configuration = _Configuration_Table->RTEMS_api_configuration; 2005c38: 03 00 80 60 sethi %hi(0x2018000), %g1 2005c3c: c4 00 63 ac ld [ %g1 + 0x3ac ], %g2 ! 20183ac <_Configuration_Table> 2005c40: c6 00 a0 40 ld [ %g2 + 0x40 ], %g3 /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 2005c44: d0 00 e0 2c ld [ %g3 + 0x2c ], %o0 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) 2005c48: 80 a2 20 00 cmp %o0, 0 2005c4c: 02 80 00 1b be 2005cb8 <_RTEMS_tasks_Initialize_user_tasks_body+0x84><== NEVER TAKEN 2005c50: e4 00 e0 28 ld [ %g3 + 0x28 ], %l2 2005c54: 80 a4 a0 00 cmp %l2, 0 2005c58: 02 80 00 18 be 2005cb8 <_RTEMS_tasks_Initialize_user_tasks_body+0x84><== NEVER TAKEN 2005c5c: a0 10 00 08 mov %o0, %l0 return; 2005c60: a2 10 20 00 clr %l1 2005c64: a6 07 bf f4 add %fp, -12, %l3 for ( index=0 ; index < maximum ; index++ ) { return_value = rtems_task_create( 2005c68: d0 04 00 00 ld [ %l0 ], %o0 2005c6c: d2 04 20 08 ld [ %l0 + 8 ], %o1 2005c70: d4 04 20 04 ld [ %l0 + 4 ], %o2 2005c74: d6 04 20 14 ld [ %l0 + 0x14 ], %o3 2005c78: d8 04 20 0c ld [ %l0 + 0xc ], %o4 2005c7c: 7f ff ff 6c call 2005a2c 2005c80: 9a 10 00 13 mov %l3, %o5 user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 2005c84: 80 a2 20 00 cmp %o0, 0 2005c88: 12 80 00 0f bne 2005cc4 <_RTEMS_tasks_Initialize_user_tasks_body+0x90> 2005c8c: 94 10 00 08 mov %o0, %o2 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); return_value = rtems_task_start( 2005c90: d0 07 bf f4 ld [ %fp + -12 ], %o0 2005c94: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 2005c98: 40 00 00 0f call 2005cd4 2005c9c: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 2005ca0: 80 a2 20 00 cmp %o0, 0 2005ca4: 12 80 00 07 bne 2005cc0 <_RTEMS_tasks_Initialize_user_tasks_body+0x8c> 2005ca8: a2 04 60 01 inc %l1 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 2005cac: 80 a4 80 11 cmp %l2, %l1 2005cb0: 18 bf ff ee bgu 2005c68 <_RTEMS_tasks_Initialize_user_tasks_body+0x34><== NEVER TAKEN 2005cb4: a0 04 20 1c add %l0, 0x1c, %l0 2005cb8: 81 c7 e0 08 ret 2005cbc: 81 e8 00 00 restore user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 2005cc0: 94 10 00 08 mov %o0, %o2 2005cc4: 92 10 20 01 mov 1, %o1 2005cc8: 40 00 03 b7 call 2006ba4 <_Internal_error_Occurred> 2005ccc: 90 10 20 01 mov 1, %o0 =============================================================================== 0200bd88 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 200bd88: 9d e3 bf 90 save %sp, -112, %sp RTEMS_API_Control *api; ASR_Information *asr; rtems_signal_set signal_set; Modes_Control prev_mode; api = executing->API_Extensions[ THREAD_API_RTEMS ]; 200bd8c: f0 06 21 68 ld [ %i0 + 0x168 ], %i0 if ( !api ) 200bd90: 80 a6 20 00 cmp %i0, 0 200bd94: 02 80 00 1f be 200be10 <_RTEMS_tasks_Post_switch_extension+0x88><== NEVER TAKEN 200bd98: 01 00 00 00 nop * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 200bd9c: 7f ff d8 12 call 2001de4 200bda0: 01 00 00 00 nop signal_set = asr->signals_posted; 200bda4: e4 06 20 14 ld [ %i0 + 0x14 ], %l2 asr->signals_posted = 0; 200bda8: c0 26 20 14 clr [ %i0 + 0x14 ] _ISR_Enable( level ); 200bdac: 7f ff d8 12 call 2001df4 200bdb0: 01 00 00 00 nop if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 200bdb4: 80 a4 a0 00 cmp %l2, 0 200bdb8: 32 80 00 04 bne,a 200bdc8 <_RTEMS_tasks_Post_switch_extension+0x40> 200bdbc: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 200bdc0: 81 c7 e0 08 ret 200bdc4: 81 e8 00 00 restore return; asr->nest_level += 1; rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200bdc8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ return; asr->nest_level += 1; 200bdcc: 82 00 60 01 inc %g1 rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200bdd0: a2 07 bf f4 add %fp, -12, %l1 if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ return; asr->nest_level += 1; 200bdd4: c2 26 20 1c st %g1, [ %i0 + 0x1c ] rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200bdd8: 94 10 00 11 mov %l1, %o2 200bddc: 21 00 00 3f sethi %hi(0xfc00), %l0 200bde0: 40 00 05 b3 call 200d4ac 200bde4: 92 14 23 ff or %l0, 0x3ff, %o1 ! ffff (*asr->handler)( signal_set ); 200bde8: c2 06 20 0c ld [ %i0 + 0xc ], %g1 200bdec: 9f c0 40 00 call %g1 200bdf0: 90 10 00 12 mov %l2, %o0 asr->nest_level -= 1; 200bdf4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200bdf8: d0 07 bf f4 ld [ %fp + -12 ], %o0 asr->nest_level += 1; rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); (*asr->handler)( signal_set ); asr->nest_level -= 1; 200bdfc: 82 00 7f ff add %g1, -1, %g1 rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200be00: 92 14 23 ff or %l0, 0x3ff, %o1 asr->nest_level += 1; rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); (*asr->handler)( signal_set ); asr->nest_level -= 1; 200be04: c2 26 20 1c st %g1, [ %i0 + 0x1c ] rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200be08: 40 00 05 a9 call 200d4ac 200be0c: 94 10 00 11 mov %l1, %o2 200be10: 81 c7 e0 08 ret 200be14: 81 e8 00 00 restore =============================================================================== 0200bcb0 <_RTEMS_tasks_Switch_extension>: /* * Per Task Variables */ tvp = executing->task_variables; 200bcb0: c8 02 21 78 ld [ %o0 + 0x178 ], %g4 while (tvp) { 200bcb4: 80 a1 20 00 cmp %g4, 0 200bcb8: 22 80 00 0b be,a 200bce4 <_RTEMS_tasks_Switch_extension+0x34> 200bcbc: d2 02 61 78 ld [ %o1 + 0x178 ], %o1 tvp->tval = *tvp->ptr; 200bcc0: c2 01 20 04 ld [ %g4 + 4 ], %g1 *tvp->ptr = tvp->gval; 200bcc4: c6 01 20 08 ld [ %g4 + 8 ], %g3 * Per Task Variables */ tvp = executing->task_variables; while (tvp) { tvp->tval = *tvp->ptr; 200bcc8: c4 00 40 00 ld [ %g1 ], %g2 200bccc: c4 21 20 0c st %g2, [ %g4 + 0xc ] *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; 200bcd0: c8 01 00 00 ld [ %g4 ], %g4 /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 200bcd4: 80 a1 20 00 cmp %g4, 0 200bcd8: 12 bf ff fa bne 200bcc0 <_RTEMS_tasks_Switch_extension+0x10><== NEVER TAKEN 200bcdc: c6 20 40 00 st %g3, [ %g1 ] tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 200bce0: d2 02 61 78 ld [ %o1 + 0x178 ], %o1 while (tvp) { 200bce4: 80 a2 60 00 cmp %o1, 0 200bce8: 02 80 00 0a be 200bd10 <_RTEMS_tasks_Switch_extension+0x60> 200bcec: 01 00 00 00 nop tvp->gval = *tvp->ptr; 200bcf0: c2 02 60 04 ld [ %o1 + 4 ], %g1 *tvp->ptr = tvp->tval; 200bcf4: c6 02 60 0c ld [ %o1 + 0xc ], %g3 tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { tvp->gval = *tvp->ptr; 200bcf8: c4 00 40 00 ld [ %g1 ], %g2 200bcfc: c4 22 60 08 st %g2, [ %o1 + 8 ] *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; 200bd00: d2 02 40 00 ld [ %o1 ], %o1 *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 200bd04: 80 a2 60 00 cmp %o1, 0 200bd08: 12 bf ff fa bne 200bcf0 <_RTEMS_tasks_Switch_extension+0x40><== NEVER TAKEN 200bd0c: c6 20 40 00 st %g3, [ %g1 ] 200bd10: 81 c3 e0 08 retl =============================================================================== 02006ec0 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 2006ec0: 9d e3 bf 90 save %sp, -112, %sp 2006ec4: 11 00 80 74 sethi %hi(0x201d000), %o0 2006ec8: 92 10 00 18 mov %i0, %o1 2006ecc: 90 12 22 3c or %o0, 0x23c, %o0 2006ed0: 40 00 08 19 call 2008f34 <_Objects_Get> 2006ed4: 94 07 bf f4 add %fp, -12, %o2 /* * When we get here, the Timer is already off the chain so we do not * have to worry about that -- hence no _Watchdog_Remove(). */ the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 2006ed8: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006edc: 80 a0 60 00 cmp %g1, 0 2006ee0: 12 80 00 11 bne 2006f24 <_Rate_monotonic_Timeout+0x64> <== NEVER TAKEN 2006ee4: b0 10 00 08 mov %o0, %i0 case OBJECTS_LOCAL: the_thread = the_period->owner; 2006ee8: d0 02 20 50 ld [ %o0 + 0x50 ], %o0 if ( _States_Is_waiting_for_period( the_thread->current_state ) && 2006eec: 03 00 00 10 sethi %hi(0x4000), %g1 2006ef0: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 2006ef4: 80 88 80 01 btst %g2, %g1 2006ef8: 32 80 00 0d bne,a 2006f2c <_Rate_monotonic_Timeout+0x6c> 2006efc: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 2006f00: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 2006f04: 80 a0 60 01 cmp %g1, 1 2006f08: 02 80 00 12 be 2006f50 <_Rate_monotonic_Timeout+0x90> <== NEVER TAKEN 2006f0c: 82 10 20 04 mov 4, %g1 _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 2006f10: c2 26 20 38 st %g1, [ %i0 + 0x38 ] */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2006f14: 05 00 80 74 sethi %hi(0x201d000), %g2 2006f18: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 201d3b0 <_Thread_Dispatch_disable_level> 2006f1c: 82 00 7f ff add %g1, -1, %g1 2006f20: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 2006f24: 81 c7 e0 08 ret 2006f28: 81 e8 00 00 restore the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_thread = the_period->owner; if ( _States_Is_waiting_for_period( the_thread->current_state ) && 2006f2c: c2 06 20 08 ld [ %i0 + 8 ], %g1 2006f30: 80 a0 80 01 cmp %g2, %g1 2006f34: 32 bf ff f4 bne,a 2006f04 <_Rate_monotonic_Timeout+0x44> <== NEVER TAKEN 2006f38: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2006f3c: 13 04 00 ff sethi %hi(0x1003fc00), %o1 2006f40: 40 00 09 67 call 20094dc <_Thread_Clear_state> 2006f44: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 2006f48: 10 80 00 05 b 2006f5c <_Rate_monotonic_Timeout+0x9c> 2006f4c: 90 10 00 18 mov %i0, %o0 _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 2006f50: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); 2006f54: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 2006f58: c2 26 20 38 st %g1, [ %i0 + 0x38 ] <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); 2006f5c: 7f ff fe 2e call 2006814 <_Rate_monotonic_Initiate_statistics> 2006f60: 01 00 00 00 nop Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2006f64: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006f68: 92 06 20 10 add %i0, 0x10, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2006f6c: c2 26 20 1c st %g1, [ %i0 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006f70: 11 00 80 75 sethi %hi(0x201d400), %o0 2006f74: 40 00 10 0e call 200afac <_Watchdog_Insert> 2006f78: 90 12 20 94 or %o0, 0x94, %o0 ! 201d494 <_Watchdog_Ticks_chain> 2006f7c: 30 bf ff e6 b,a 2006f14 <_Rate_monotonic_Timeout+0x54> =============================================================================== 02006494 <_TOD_Validate>: */ bool _TOD_Validate( rtems_time_of_day *the_tod ) { 2006494: 9d e3 bf 98 save %sp, -104, %sp uint32_t days_in_month; if ((!the_tod) || 2006498: 80 a6 20 00 cmp %i0, 0 200649c: 02 80 00 2f be 2006558 <_TOD_Validate+0xc4> <== NEVER TAKEN 20064a0: 03 00 80 93 sethi %hi(0x2024c00), %g1 20064a4: d2 00 63 00 ld [ %g1 + 0x300 ], %o1 ! 2024f00 <_TOD_Microseconds_per_tick> 20064a8: 11 00 03 d0 sethi %hi(0xf4000), %o0 20064ac: 40 00 46 49 call 2017dd0 <.udiv> 20064b0: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 20064b4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 20064b8: 80 a0 40 08 cmp %g1, %o0 20064bc: 1a 80 00 27 bcc 2006558 <_TOD_Validate+0xc4> 20064c0: 01 00 00 00 nop 20064c4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 20064c8: 80 a0 60 3b cmp %g1, 0x3b 20064cc: 18 80 00 23 bgu 2006558 <_TOD_Validate+0xc4> 20064d0: 01 00 00 00 nop 20064d4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 20064d8: 80 a0 60 3b cmp %g1, 0x3b 20064dc: 18 80 00 1f bgu 2006558 <_TOD_Validate+0xc4> 20064e0: 01 00 00 00 nop 20064e4: c2 06 20 0c ld [ %i0 + 0xc ], %g1 20064e8: 80 a0 60 17 cmp %g1, 0x17 20064ec: 18 80 00 1b bgu 2006558 <_TOD_Validate+0xc4> 20064f0: 01 00 00 00 nop 20064f4: c4 06 20 04 ld [ %i0 + 4 ], %g2 20064f8: 80 a0 a0 00 cmp %g2, 0 20064fc: 02 80 00 17 be 2006558 <_TOD_Validate+0xc4> <== NEVER TAKEN 2006500: 80 a0 a0 0c cmp %g2, 0xc 2006504: 18 80 00 15 bgu 2006558 <_TOD_Validate+0xc4> 2006508: 01 00 00 00 nop 200650c: c2 06 00 00 ld [ %i0 ], %g1 2006510: 80 a0 67 c3 cmp %g1, 0x7c3 2006514: 08 80 00 11 bleu 2006558 <_TOD_Validate+0xc4> 2006518: 01 00 00 00 nop 200651c: f0 06 20 08 ld [ %i0 + 8 ], %i0 2006520: 80 a6 20 00 cmp %i0, 0 2006524: 02 80 00 0d be 2006558 <_TOD_Validate+0xc4> <== NEVER TAKEN 2006528: 80 88 60 03 btst 3, %g1 (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 200652c: 32 80 00 0d bne,a 2006560 <_TOD_Validate+0xcc> 2006530: 85 28 a0 02 sll %g2, 2, %g2 days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 2006534: 84 00 a0 0d add %g2, 0xd, %g2 2006538: 03 00 80 6a sethi %hi(0x201a800), %g1 200653c: 85 28 a0 02 sll %g2, 2, %g2 2006540: 82 10 61 58 or %g1, 0x158, %g1 2006544: c4 00 40 02 ld [ %g1 + %g2 ], %g2 else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 2006548: 80 a0 80 18 cmp %g2, %i0 200654c: 82 60 3f ff subx %g0, -1, %g1 2006550: 81 c7 e0 08 ret 2006554: 91 e8 00 01 restore %g0, %g1, %o0 if ( the_tod->day > days_in_month ) return false; return true; } 2006558: 81 c7 e0 08 ret 200655c: 91 e8 20 00 restore %g0, 0, %o0 return false; if ( (the_tod->year % 4) == 0 ) days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 2006560: 03 00 80 6a sethi %hi(0x201a800), %g1 2006564: 82 10 61 58 or %g1, 0x158, %g1 ! 201a958 <_TOD_Days_per_month> 2006568: 10 bf ff f8 b 2006548 <_TOD_Validate+0xb4> 200656c: c4 00 40 02 ld [ %g1 + %g2 ], %g2 =============================================================================== 020075b8 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 20075b8: 9d e3 bf 98 save %sp, -104, %sp */ /* * Save original state */ original_state = the_thread->current_state; 20075bc: e2 06 20 10 ld [ %i0 + 0x10 ], %l1 /* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread ); 20075c0: 40 00 04 94 call 2008810 <_Thread_Set_transient> 20075c4: 90 10 00 18 mov %i0, %o0 /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 20075c8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 20075cc: a0 10 00 18 mov %i0, %l0 /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 20075d0: 80 a0 40 19 cmp %g1, %i1 20075d4: 02 80 00 04 be 20075e4 <_Thread_Change_priority+0x2c> 20075d8: 92 10 00 19 mov %i1, %o1 _Thread_Set_priority( the_thread, new_priority ); 20075dc: 40 00 04 11 call 2008620 <_Thread_Set_priority> 20075e0: 90 10 00 18 mov %i0, %o0 _ISR_Disable( level ); 20075e4: 7f ff ea 00 call 2001de4 20075e8: 01 00 00 00 nop 20075ec: b0 10 00 08 mov %o0, %i0 /* * If the thread has more than STATES_TRANSIENT set, then it is blocked, * If it is blocked on a thread queue, then we need to requeue it. */ state = the_thread->current_state; 20075f0: f2 04 20 10 ld [ %l0 + 0x10 ], %i1 if ( state != STATES_TRANSIENT ) { 20075f4: 80 a6 60 04 cmp %i1, 4 20075f8: 02 80 00 10 be 2007638 <_Thread_Change_priority+0x80> 20075fc: 80 8c 60 04 btst 4, %l1 /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 2007600: 12 80 00 03 bne 200760c <_Thread_Change_priority+0x54> <== NEVER TAKEN 2007604: 82 0e 7f fb and %i1, -5, %g1 the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 2007608: c2 24 20 10 st %g1, [ %l0 + 0x10 ] _ISR_Enable( level ); 200760c: 7f ff e9 fa call 2001df4 2007610: 90 10 00 18 mov %i0, %o0 if ( _States_Is_waiting_on_thread_queue( state ) ) { 2007614: 03 00 00 ef sethi %hi(0x3bc00), %g1 2007618: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200761c: 80 8e 40 01 btst %i1, %g1 2007620: 32 80 00 04 bne,a 2007630 <_Thread_Change_priority+0x78> 2007624: f0 04 20 44 ld [ %l0 + 0x44 ], %i0 2007628: 81 c7 e0 08 ret 200762c: 81 e8 00 00 restore _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 2007630: 40 00 03 cc call 2008560 <_Thread_queue_Requeue> 2007634: 93 e8 00 10 restore %g0, %l0, %o1 } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 2007638: 12 80 00 14 bne 2007688 <_Thread_Change_priority+0xd0> <== NEVER TAKEN 200763c: 23 00 80 60 sethi %hi(0x2018000), %l1 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 2007640: c6 04 20 90 ld [ %l0 + 0x90 ], %g3 2007644: c4 14 20 96 lduh [ %l0 + 0x96 ], %g2 2007648: c2 10 c0 00 lduh [ %g3 ], %g1 * Interrupts are STILL disabled. * We now know the thread will be in the READY state when we remove * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 200764c: c0 24 20 10 clr [ %l0 + 0x10 ] 2007650: 82 10 40 02 or %g1, %g2, %g1 2007654: c2 30 c0 00 sth %g1, [ %g3 ] _Priority_Major_bit_map |= the_priority_map->ready_major; 2007658: c4 14 63 c8 lduh [ %l1 + 0x3c8 ], %g2 200765c: c2 14 20 94 lduh [ %l0 + 0x94 ], %g1 _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) 2007660: 80 8e a0 ff btst 0xff, %i2 2007664: 84 10 80 01 or %g2, %g1, %g2 2007668: c4 34 63 c8 sth %g2, [ %l1 + 0x3c8 ] 200766c: 02 80 00 49 be 2007790 <_Thread_Change_priority+0x1d8> 2007670: c2 04 20 8c ld [ %l0 + 0x8c ], %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 2007674: c4 00 40 00 ld [ %g1 ], %g2 Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 2007678: c2 24 20 04 st %g1, [ %l0 + 4 ] before_node = after_node->next; after_node->next = the_node; 200767c: e0 20 40 00 st %l0, [ %g1 ] the_node->next = before_node; before_node->previous = the_node; 2007680: e0 20 a0 04 st %l0, [ %g2 + 4 ] Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 2007684: c4 24 00 00 st %g2, [ %l0 ] _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node ); else _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); } _ISR_Flash( level ); 2007688: 7f ff e9 db call 2001df4 200768c: 90 10 00 18 mov %i0, %o0 2007690: 7f ff e9 d5 call 2001de4 2007694: 01 00 00 00 nop RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_highest( void ) { Priority_Bit_map_control minor; Priority_Bit_map_control major; _Bitfield_Find_first_bit( _Priority_Major_bit_map, major ); 2007698: c2 14 63 c8 lduh [ %l1 + 0x3c8 ], %g1 * ready thread. */ RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void ) { _Thread_Heir = (Thread_Control *) 200769c: 05 00 80 60 sethi %hi(0x2018000), %g2 20076a0: 83 28 60 10 sll %g1, 0x10, %g1 20076a4: 87 30 60 10 srl %g1, 0x10, %g3 20076a8: 80 a0 e0 ff cmp %g3, 0xff 20076ac: 08 80 00 28 bleu 200774c <_Thread_Change_priority+0x194> 20076b0: d8 00 a2 64 ld [ %g2 + 0x264 ], %o4 20076b4: 05 00 80 59 sethi %hi(0x2016400), %g2 20076b8: 83 30 60 18 srl %g1, 0x18, %g1 20076bc: 88 10 a1 b0 or %g2, 0x1b0, %g4 20076c0: c2 09 00 01 ldub [ %g4 + %g1 ], %g1 _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 20076c4: 05 00 80 61 sethi %hi(0x2018400), %g2 20076c8: 9b 28 60 10 sll %g1, 0x10, %o5 20076cc: 84 10 a0 40 or %g2, 0x40, %g2 20076d0: 83 33 60 0f srl %o5, 0xf, %g1 20076d4: c6 10 80 01 lduh [ %g2 + %g1 ], %g3 20076d8: 83 28 e0 10 sll %g3, 0x10, %g1 20076dc: 85 30 60 10 srl %g1, 0x10, %g2 20076e0: 80 a0 a0 ff cmp %g2, 0xff 20076e4: 18 80 00 29 bgu 2007788 <_Thread_Change_priority+0x1d0> 20076e8: 83 30 60 18 srl %g1, 0x18, %g1 20076ec: c2 09 00 02 ldub [ %g4 + %g2 ], %g1 20076f0: 82 00 60 08 add %g1, 8, %g1 20076f4: 87 33 60 0c srl %o5, 0xc, %g3 20076f8: 83 28 60 10 sll %g1, 0x10, %g1 20076fc: 83 30 60 10 srl %g1, 0x10, %g1 2007700: 82 00 40 03 add %g1, %g3, %g1 2007704: 85 28 60 04 sll %g1, 4, %g2 2007708: 83 28 60 02 sll %g1, 2, %g1 200770c: 84 20 80 01 sub %g2, %g1, %g2 2007710: c6 03 00 02 ld [ %o4 + %g2 ], %g3 * is also the heir thread, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 2007714: 03 00 80 60 sethi %hi(0x2018000), %g1 2007718: c2 00 63 d4 ld [ %g1 + 0x3d4 ], %g1 ! 20183d4 <_Thread_Executing> * ready thread. */ RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void ) { _Thread_Heir = (Thread_Control *) 200771c: 05 00 80 60 sethi %hi(0x2018000), %g2 * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Thread_Calculate_heir(); if ( !_Thread_Is_executing_also_the_heir() && 2007720: 80 a0 c0 01 cmp %g3, %g1 2007724: 02 80 00 08 be 2007744 <_Thread_Change_priority+0x18c> 2007728: c6 20 a3 a0 st %g3, [ %g2 + 0x3a0 ] 200772c: c2 08 60 76 ldub [ %g1 + 0x76 ], %g1 2007730: 80 a0 60 00 cmp %g1, 0 2007734: 02 80 00 04 be 2007744 <_Thread_Change_priority+0x18c> 2007738: 84 10 20 01 mov 1, %g2 _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; 200773c: 03 00 80 60 sethi %hi(0x2018000), %g1 2007740: c4 28 63 e4 stb %g2, [ %g1 + 0x3e4 ] ! 20183e4 <_Context_Switch_necessary> _ISR_Enable( level ); 2007744: 7f ff e9 ac call 2001df4 2007748: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_highest( void ) { Priority_Bit_map_control minor; Priority_Bit_map_control major; _Bitfield_Find_first_bit( _Priority_Major_bit_map, major ); 200774c: 05 00 80 59 sethi %hi(0x2016400), %g2 2007750: 88 10 a1 b0 or %g2, 0x1b0, %g4 ! 20165b0 <__log2table> 2007754: c2 09 00 03 ldub [ %g4 + %g3 ], %g1 _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 2007758: 05 00 80 61 sethi %hi(0x2018400), %g2 RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_highest( void ) { Priority_Bit_map_control minor; Priority_Bit_map_control major; _Bitfield_Find_first_bit( _Priority_Major_bit_map, major ); 200775c: 82 00 60 08 add %g1, 8, %g1 _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 2007760: 84 10 a0 40 or %g2, 0x40, %g2 2007764: 9b 28 60 10 sll %g1, 0x10, %o5 2007768: 83 33 60 0f srl %o5, 0xf, %g1 200776c: c6 10 80 01 lduh [ %g2 + %g1 ], %g3 2007770: 83 28 e0 10 sll %g3, 0x10, %g1 2007774: 85 30 60 10 srl %g1, 0x10, %g2 2007778: 80 a0 a0 ff cmp %g2, 0xff 200777c: 28 bf ff dd bleu,a 20076f0 <_Thread_Change_priority+0x138> 2007780: c2 09 00 02 ldub [ %g4 + %g2 ], %g1 2007784: 83 30 60 18 srl %g1, 0x18, %g1 2007788: 10 bf ff db b 20076f4 <_Thread_Change_priority+0x13c> 200778c: c2 09 00 01 ldub [ %g4 + %g1 ], %g1 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 2007790: 84 00 60 04 add %g1, 4, %g2 2007794: c4 24 00 00 st %g2, [ %l0 ] old_last_node = the_chain->last; 2007798: c6 00 60 08 ld [ %g1 + 8 ], %g3 the_chain->last = the_node; 200779c: e0 20 60 08 st %l0, [ %g1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 20077a0: c6 24 20 04 st %g3, [ %l0 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 20077a4: 10 bf ff b9 b 2007688 <_Thread_Change_priority+0xd0> 20077a8: e0 20 c0 00 st %l0, [ %g3 ] =============================================================================== 020077ac <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 20077ac: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; States_Control current_state; _ISR_Disable( level ); 20077b0: 7f ff e9 8d call 2001de4 20077b4: a0 10 00 19 mov %i1, %l0 20077b8: a2 10 00 08 mov %o0, %l1 current_state = the_thread->current_state; 20077bc: f2 06 20 10 ld [ %i0 + 0x10 ], %i1 if ( current_state & state ) { 20077c0: 80 8c 00 19 btst %l0, %i1 20077c4: 02 80 00 05 be 20077d8 <_Thread_Clear_state+0x2c> 20077c8: 82 2e 40 10 andn %i1, %l0, %g1 current_state = the_thread->current_state = _States_Clear( state, current_state ); if ( _States_Is_ready( current_state ) ) { 20077cc: 80 a0 60 00 cmp %g1, 0 20077d0: 02 80 00 04 be 20077e0 <_Thread_Clear_state+0x34> 20077d4: c2 26 20 10 st %g1, [ %i0 + 0x10 ] the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 20077d8: 7f ff e9 87 call 2001df4 20077dc: 91 e8 00 11 restore %g0, %l1, %o0 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 20077e0: c8 06 20 90 ld [ %i0 + 0x90 ], %g4 20077e4: c4 16 20 96 lduh [ %i0 + 0x96 ], %g2 20077e8: c2 11 00 00 lduh [ %g4 ], %g1 if ( _States_Is_ready( current_state ) ) { _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 20077ec: c6 06 20 8c ld [ %i0 + 0x8c ], %g3 20077f0: 82 10 40 02 or %g1, %g2, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 20077f4: 1b 00 80 60 sethi %hi(0x2018000), %o5 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 20077f8: c2 31 00 00 sth %g1, [ %g4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 20077fc: 82 00 e0 04 add %g3, 4, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 2007800: d8 16 20 94 lduh [ %i0 + 0x94 ], %o4 2007804: c2 26 00 00 st %g1, [ %i0 ] 2007808: c4 13 63 c8 lduh [ %o5 + 0x3c8 ], %g2 old_last_node = the_chain->last; 200780c: c8 00 e0 08 ld [ %g3 + 8 ], %g4 the_chain->last = the_node; 2007810: f0 20 e0 08 st %i0, [ %g3 + 8 ] 2007814: 84 10 80 0c or %g2, %o4, %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 2007818: c8 26 20 04 st %g4, [ %i0 + 4 ] 200781c: c4 33 63 c8 sth %g2, [ %o5 + 0x3c8 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 2007820: f0 21 00 00 st %i0, [ %g4 ] _ISR_Flash( level ); 2007824: 7f ff e9 74 call 2001df4 2007828: 01 00 00 00 nop 200782c: 7f ff e9 6e call 2001de4 2007830: 01 00 00 00 nop * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 2007834: 09 00 80 60 sethi %hi(0x2018000), %g4 2007838: c4 01 23 a0 ld [ %g4 + 0x3a0 ], %g2 ! 20183a0 <_Thread_Heir> 200783c: c6 06 20 14 ld [ %i0 + 0x14 ], %g3 2007840: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 2007844: 80 a0 c0 01 cmp %g3, %g1 2007848: 1a bf ff e4 bcc 20077d8 <_Thread_Clear_state+0x2c> 200784c: 03 00 80 60 sethi %hi(0x2018000), %g1 _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 2007850: c4 00 63 d4 ld [ %g1 + 0x3d4 ], %g2 ! 20183d4 <_Thread_Executing> * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; 2007854: f0 21 23 a0 st %i0, [ %g4 + 0x3a0 ] if ( _Thread_Executing->is_preemptible || 2007858: c2 08 a0 76 ldub [ %g2 + 0x76 ], %g1 200785c: 80 a0 60 00 cmp %g1, 0 2007860: 12 80 00 05 bne 2007874 <_Thread_Clear_state+0xc8> 2007864: 84 10 20 01 mov 1, %g2 2007868: 80 a0 e0 00 cmp %g3, 0 200786c: 12 bf ff db bne 20077d8 <_Thread_Clear_state+0x2c> <== ALWAYS TAKEN 2007870: 01 00 00 00 nop the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 2007874: 03 00 80 60 sethi %hi(0x2018000), %g1 2007878: c4 28 63 e4 stb %g2, [ %g1 + 0x3e4 ] ! 20183e4 <_Context_Switch_necessary> 200787c: 30 bf ff d7 b,a 20077d8 <_Thread_Clear_state+0x2c> =============================================================================== 02007968 <_Thread_Create_idle>: * * _Thread_Create_idle */ void _Thread_Create_idle( void ) { 2007968: 9d e3 bf 78 save %sp, -136, %sp * This routine allocates an internal thread. */ RTEMS_INLINE_ROUTINE Thread_Control *_Thread_Internal_allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_Thread_Internal_information ); 200796c: 35 00 80 61 sethi %hi(0x2018400), %i2 2007970: 7f ff fc bd call 2006c64 <_Objects_Allocate> 2007974: 90 16 a0 70 or %i2, 0x70, %o0 ! 2018470 <_Thread_Internal_information> rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007978: 37 00 80 60 sethi %hi(0x2018000), %i3 200797c: c2 06 e3 10 ld [ %i3 + 0x310 ], %g1 ! 2018310 <_Thread_Dispatch_disable_level> /* * The entire workspace is zeroed during its initialization. Thus, all * fields not explicitly assigned were explicitly zeroed by * _Workspace_Initialization. */ _Thread_Idle = _Thread_Internal_allocate(); 2007980: 39 00 80 61 sethi %hi(0x2018400), %i4 2007984: 82 00 60 01 inc %g1 2007988: d0 27 20 bc st %o0, [ %i4 + 0xbc ] 200798c: c2 26 e3 10 st %g1, [ %i3 + 0x310 ] * that when _Thread_Initialize unnests dispatch that we do not * do anything stupid. */ _Thread_Disable_dispatch(); _Thread_Initialize( 2007990: 33 00 80 60 sethi %hi(0x2018000), %i1 2007994: c2 06 63 ac ld [ %i1 + 0x3ac ], %g1 ! 20183ac <_Configuration_Table> 2007998: 05 00 80 5d sethi %hi(0x2017400), %g2 200799c: c6 00 60 18 ld [ %g1 + 0x18 ], %g3 20079a0: d6 00 a0 e0 ld [ %g2 + 0xe0 ], %o3 20079a4: 03 00 80 59 sethi %hi(0x2016400), %g1 20079a8: 82 10 63 48 or %g1, 0x348, %g1 ! 2016748 <_Status_Object_name_errors_to_status+0x14> 20079ac: c2 27 bf f4 st %g1, [ %fp + -12 ] 20079b0: 80 a2 c0 03 cmp %o3, %g3 20079b4: 1a 80 00 03 bcc 20079c0 <_Thread_Create_idle+0x58> <== ALWAYS TAKEN 20079b8: d2 07 20 bc ld [ %i4 + 0xbc ], %o1 20079bc: 96 10 00 03 mov %g3, %o3 <== NOT EXECUTED 20079c0: 03 00 80 5d sethi %hi(0x2017400), %g1 20079c4: da 08 60 e4 ldub [ %g1 + 0xe4 ], %o5 ! 20174e4 20079c8: 84 07 bf f4 add %fp, -12, %g2 20079cc: 82 10 20 01 mov 1, %g1 20079d0: c0 23 a0 60 clr [ %sp + 0x60 ] 20079d4: c0 23 a0 64 clr [ %sp + 0x64 ] 20079d8: c0 23 a0 68 clr [ %sp + 0x68 ] 20079dc: 90 16 a0 70 or %i2, 0x70, %o0 20079e0: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 20079e4: c4 23 a0 6c st %g2, [ %sp + 0x6c ] 20079e8: 94 10 20 00 clr %o2 20079ec: 40 00 00 c3 call 2007cf8 <_Thread_Initialize> 20079f0: 98 10 20 00 clr %o4 * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = _Thread_Executing = _Thread_Idle; _Thread_Start( 20079f4: c4 06 63 ac ld [ %i1 + 0x3ac ], %g2 */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 20079f8: c2 06 e3 10 ld [ %i3 + 0x310 ], %g1 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 20079fc: c6 07 20 bc ld [ %i4 + 0xbc ], %g3 2007a00: 82 00 7f ff add %g1, -1, %g1 _Thread_Executing = _Thread_Idle; _Thread_Start( 2007a04: f4 00 a0 14 ld [ %g2 + 0x14 ], %i2 2007a08: c2 26 e3 10 st %g1, [ %i3 + 0x310 ] /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 2007a0c: 05 00 80 60 sethi %hi(0x2018000), %g2 2007a10: 03 00 80 60 sethi %hi(0x2018000), %g1 _Thread_Executing = _Thread_Idle; _Thread_Start( 2007a14: b0 10 00 03 mov %g3, %i0 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 2007a18: c6 20 a3 d4 st %g3, [ %g2 + 0x3d4 ] 2007a1c: c6 20 63 a0 st %g3, [ %g1 + 0x3a0 ] _Thread_Executing = _Thread_Idle; _Thread_Start( 2007a20: b2 10 20 00 clr %i1 2007a24: b6 10 20 00 clr %i3 2007a28: 40 00 03 e0 call 20089a8 <_Thread_Start> 2007a2c: 99 e8 20 00 restore %g0, 0, %o4 =============================================================================== 02007a34 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 2007a34: 9d e3 bf 90 save %sp, -112, %sp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 2007a38: 90 10 00 18 mov %i0, %o0 2007a3c: 40 00 00 83 call 2007c48 <_Thread_Get> 2007a40: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 2007a44: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007a48: 80 a0 60 00 cmp %g1, 0 2007a4c: 12 80 00 08 bne 2007a6c <_Thread_Delay_ended+0x38> <== NEVER TAKEN 2007a50: 13 04 00 ff sethi %hi(0x1003fc00), %o1 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2007a54: 7f ff ff 56 call 20077ac <_Thread_Clear_state> 2007a58: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2007a5c: 05 00 80 60 sethi %hi(0x2018000), %g2 2007a60: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2018310 <_Thread_Dispatch_disable_level> 2007a64: 82 00 7f ff add %g1, -1, %g1 2007a68: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] 2007a6c: 81 c7 e0 08 ret 2007a70: 81 e8 00 00 restore =============================================================================== 02007a74 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 2007a74: 9d e3 bf 88 save %sp, -120, %sp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 2007a78: 03 00 80 60 sethi %hi(0x2018000), %g1 2007a7c: e2 00 63 d4 ld [ %g1 + 0x3d4 ], %l1 ! 20183d4 <_Thread_Executing> _ISR_Disable( level ); 2007a80: 7f ff e8 d9 call 2001de4 2007a84: ae 10 63 d4 or %g1, 0x3d4, %l7 while ( _Context_Switch_necessary == TRUE ) { 2007a88: 05 00 80 60 sethi %hi(0x2018000), %g2 2007a8c: c2 08 a3 e4 ldub [ %g2 + 0x3e4 ], %g1 ! 20183e4 <_Context_Switch_necessary> 2007a90: aa 10 a3 e4 or %g2, 0x3e4, %l5 2007a94: 80 a0 60 00 cmp %g1, 0 2007a98: 03 00 80 60 sethi %hi(0x2018000), %g1 2007a9c: 02 80 00 4d be 2007bd0 <_Thread_Dispatch+0x15c> 2007aa0: b2 10 63 10 or %g1, 0x310, %i1 ! 2018310 <_Thread_Dispatch_disable_level> 2007aa4: 03 00 80 60 sethi %hi(0x2018000), %g1 2007aa8: 05 00 80 60 sethi %hi(0x2018000), %g2 2007aac: b4 10 63 a0 or %g1, 0x3a0, %i2 2007ab0: 03 00 80 60 sethi %hi(0x2018000), %g1 2007ab4: a4 10 a3 dc or %g2, 0x3dc, %l2 2007ab8: b6 10 63 9c or %g1, 0x39c, %i3 #if __RTEMS_ADA__ executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 2007abc: 05 00 80 60 sethi %hi(0x2018000), %g2 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 2007ac0: 03 00 80 60 sethi %hi(0x2018000), %g1 2007ac4: b0 10 a2 68 or %g2, 0x268, %i0 2007ac8: ac 10 63 98 or %g1, 0x398, %l6 2007acc: a8 07 bf f0 add %fp, -16, %l4 2007ad0: a6 07 bf e8 add %fp, -24, %l3 executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { heir = _Thread_Heir; _Thread_Dispatch_disable_level = 1; 2007ad4: b8 10 20 01 mov 1, %i4 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 2007ad8: 10 80 00 34 b 2007ba8 <_Thread_Dispatch+0x134> 2007adc: ba 10 00 12 mov %l2, %i5 executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) heir->cpu_time_budget = _Thread_Ticks_per_timeslice; _ISR_Enable( level ); 2007ae0: 7f ff e8 c5 call 2001df4 2007ae4: 01 00 00 00 nop #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); 2007ae8: 40 00 11 ca call 200c210 <_TOD_Get_uptime> 2007aec: 90 10 00 14 mov %l4, %o0 _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 2007af0: 90 10 00 1d mov %i5, %o0 2007af4: 92 10 00 14 mov %l4, %o1 2007af8: 40 00 04 2d call 2008bac <_Timespec_Subtract> 2007afc: 94 10 00 13 mov %l3, %o2 _Timespec_Add_to( &executing->cpu_time_used, &ran ); 2007b00: 92 10 00 13 mov %l3, %o1 2007b04: 40 00 04 10 call 2008b44 <_Timespec_Add_to> 2007b08: 90 04 60 84 add %l1, 0x84, %o0 _Thread_Time_of_last_context_switch = uptime; 2007b0c: c2 07 bf f0 ld [ %fp + -16 ], %g1 2007b10: c4 07 bf f4 ld [ %fp + -12 ], %g2 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 2007b14: c6 06 c0 00 ld [ %i3 ], %g3 { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); _Timespec_Add_to( &executing->cpu_time_used, &ran ); _Thread_Time_of_last_context_switch = uptime; 2007b18: c2 24 80 00 st %g1, [ %l2 ] 2007b1c: c4 24 a0 04 st %g2, [ %l2 + 4 ] if ( _Thread_libc_reent ) { executing->libc_reent = *_Thread_libc_reent; *_Thread_libc_reent = heir->libc_reent; } _User_extensions_Thread_switch( executing, heir ); 2007b20: 90 10 00 11 mov %l1, %o0 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 2007b24: 80 a0 e0 00 cmp %g3, 0 2007b28: 02 80 00 06 be 2007b40 <_Thread_Dispatch+0xcc> <== NEVER TAKEN 2007b2c: 92 10 00 10 mov %l0, %o1 executing->libc_reent = *_Thread_libc_reent; 2007b30: c2 00 c0 00 ld [ %g3 ], %g1 2007b34: c2 24 61 64 st %g1, [ %l1 + 0x164 ] *_Thread_libc_reent = heir->libc_reent; 2007b38: c4 04 21 64 ld [ %l0 + 0x164 ], %g2 2007b3c: c4 20 c0 00 st %g2, [ %g3 ] } _User_extensions_Thread_switch( executing, heir ); 2007b40: 40 00 04 d8 call 2008ea0 <_User_extensions_Thread_switch> 2007b44: 01 00 00 00 nop if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 2007b48: 92 04 20 d8 add %l0, 0xd8, %o1 2007b4c: 40 00 06 2b call 20093f8 <_CPU_Context_switch> 2007b50: 90 04 60 d8 add %l1, 0xd8, %o0 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 2007b54: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2007b58: 80 a0 60 00 cmp %g1, 0 2007b5c: 02 80 00 0d be 2007b90 <_Thread_Dispatch+0x11c> 2007b60: 01 00 00 00 nop 2007b64: d0 05 80 00 ld [ %l6 ], %o0 2007b68: 80 a4 40 08 cmp %l1, %o0 2007b6c: 02 80 00 09 be 2007b90 <_Thread_Dispatch+0x11c> 2007b70: 80 a2 20 00 cmp %o0, 0 !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 2007b74: 02 80 00 04 be 2007b84 <_Thread_Dispatch+0x110> 2007b78: 01 00 00 00 nop _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 2007b7c: 40 00 05 e5 call 2009310 <_CPU_Context_save_fp> 2007b80: 90 02 21 60 add %o0, 0x160, %o0 _Context_Restore_fp( &executing->fp_context ); 2007b84: 40 00 06 00 call 2009384 <_CPU_Context_restore_fp> 2007b88: 90 04 61 60 add %l1, 0x160, %o0 _Thread_Allocated_fp = executing; 2007b8c: e2 25 80 00 st %l1, [ %l6 ] #endif #endif executing = _Thread_Executing; _ISR_Disable( level ); 2007b90: 7f ff e8 95 call 2001de4 2007b94: e2 05 c0 00 ld [ %l7 ], %l1 Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { 2007b98: c2 0d 40 00 ldub [ %l5 ], %g1 2007b9c: 80 a0 60 00 cmp %g1, 0 2007ba0: 02 80 00 0c be 2007bd0 <_Thread_Dispatch+0x15c> 2007ba4: 03 00 80 60 sethi %hi(0x2018000), %g1 heir = _Thread_Heir; 2007ba8: e0 06 80 00 ld [ %i2 ], %l0 _Thread_Dispatch_disable_level = 1; 2007bac: f8 26 40 00 st %i4, [ %i1 ] _Thread_Executing = heir; #if __RTEMS_ADA__ executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 2007bb0: c2 04 20 7c ld [ %l0 + 0x7c ], %g1 executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { heir = _Thread_Heir; _Thread_Dispatch_disable_level = 1; _Context_Switch_necessary = FALSE; 2007bb4: c0 2d 40 00 clrb [ %l5 ] _Thread_Executing = heir; #if __RTEMS_ADA__ executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 2007bb8: 80 a0 60 01 cmp %g1, 1 2007bbc: 12 bf ff c9 bne 2007ae0 <_Thread_Dispatch+0x6c> 2007bc0: e0 25 c0 00 st %l0, [ %l7 ] heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 2007bc4: c2 06 00 00 ld [ %i0 ], %g1 2007bc8: 10 bf ff c6 b 2007ae0 <_Thread_Dispatch+0x6c> 2007bcc: c2 24 20 78 st %g1, [ %l0 + 0x78 ] executing = _Thread_Executing; _ISR_Disable( level ); } _Thread_Dispatch_disable_level = 0; 2007bd0: c0 20 63 10 clr [ %g1 + 0x310 ] _ISR_Enable( level ); 2007bd4: 7f ff e8 88 call 2001df4 2007bd8: 01 00 00 00 nop if ( _Thread_Do_post_task_switch_extension || 2007bdc: 03 00 80 60 sethi %hi(0x2018000), %g1 2007be0: c4 00 63 b8 ld [ %g1 + 0x3b8 ], %g2 ! 20183b8 <_Thread_Do_post_task_switch_extension> 2007be4: 80 a0 a0 00 cmp %g2, 0 2007be8: 12 80 00 06 bne 2007c00 <_Thread_Dispatch+0x18c> 2007bec: 01 00 00 00 nop 2007bf0: c2 0c 60 75 ldub [ %l1 + 0x75 ], %g1 2007bf4: 80 a0 60 00 cmp %g1, 0 2007bf8: 02 80 00 04 be 2007c08 <_Thread_Dispatch+0x194> 2007bfc: 01 00 00 00 nop executing->do_post_task_switch_extension ) { executing->do_post_task_switch_extension = false; _API_extensions_Run_postswitch(); 2007c00: 7f ff f9 96 call 2006258 <_API_extensions_Run_postswitch> 2007c04: c0 2c 60 75 clrb [ %l1 + 0x75 ] 2007c08: 81 c7 e0 08 ret 2007c0c: 81 e8 00 00 restore =============================================================================== 0200d808 <_Thread_Evaluate_mode>: bool _Thread_Evaluate_mode( void ) { Thread_Control *executing; executing = _Thread_Executing; 200d808: 03 00 80 60 sethi %hi(0x2018000), %g1 200d80c: c6 00 63 d4 ld [ %g1 + 0x3d4 ], %g3 ! 20183d4 <_Thread_Executing> if ( !_States_Is_ready( executing->current_state ) || 200d810: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2 200d814: 80 a0 a0 00 cmp %g2, 0 200d818: 12 80 00 0b bne 200d844 <_Thread_Evaluate_mode+0x3c> <== NEVER TAKEN 200d81c: 84 10 20 01 mov 1, %g2 200d820: 03 00 80 60 sethi %hi(0x2018000), %g1 200d824: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20183a0 <_Thread_Heir> 200d828: 80 a0 c0 02 cmp %g3, %g2 200d82c: 02 80 00 0b be 200d858 <_Thread_Evaluate_mode+0x50> 200d830: 01 00 00 00 nop 200d834: c2 08 e0 76 ldub [ %g3 + 0x76 ], %g1 200d838: 80 a0 60 00 cmp %g1, 0 200d83c: 02 80 00 07 be 200d858 <_Thread_Evaluate_mode+0x50> <== NEVER TAKEN 200d840: 84 10 20 01 mov 1, %g2 ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 200d844: 03 00 80 60 sethi %hi(0x2018000), %g1 200d848: 90 10 20 01 mov 1, %o0 200d84c: c4 28 63 e4 stb %g2, [ %g1 + 0x3e4 ] 200d850: 81 c3 e0 08 retl 200d854: 01 00 00 00 nop return TRUE; } return FALSE; } 200d858: 81 c3 e0 08 retl 200d85c: 90 10 20 00 clr %o0 ! 0 =============================================================================== 02007c48 <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 2007c48: 86 10 00 08 mov %o0, %g3 uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2007c4c: 80 a2 20 00 cmp %o0, 0 2007c50: 02 80 00 1d be 2007cc4 <_Thread_Get+0x7c> 2007c54: 94 10 00 09 mov %o1, %o2 */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2007c58: 83 32 20 18 srl %o0, 0x18, %g1 2007c5c: 82 08 60 07 and %g1, 7, %g1 */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 2007c60: 84 00 7f ff add %g1, -1, %g2 2007c64: 80 a0 a0 03 cmp %g2, 3 2007c68: 38 80 00 14 bgu,a 2007cb8 <_Thread_Get+0x70> 2007c6c: 82 10 20 01 mov 1, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007c70: 89 32 20 1b srl %o0, 0x1b, %g4 2007c74: 80 a1 20 01 cmp %g4, 1 2007c78: 12 80 00 0f bne 2007cb4 <_Thread_Get+0x6c> 2007c7c: 85 28 60 02 sll %g1, 2, %g2 *location = OBJECTS_ERROR; goto done; } api_information = _Objects_Information_table[ the_api ]; 2007c80: 03 00 80 60 sethi %hi(0x2018000), %g1 2007c84: 82 10 62 70 or %g1, 0x270, %g1 ! 2018270 <_Objects_Information_table> 2007c88: c2 00 40 02 ld [ %g1 + %g2 ], %g1 if ( !api_information ) { 2007c8c: 80 a0 60 00 cmp %g1, 0 2007c90: 22 80 00 17 be,a 2007cec <_Thread_Get+0xa4> 2007c94: c8 22 80 00 st %g4, [ %o2 ] *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 2007c98: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2007c9c: 80 a2 20 00 cmp %o0, 0 2007ca0: 02 80 00 11 be 2007ce4 <_Thread_Get+0x9c> <== NEVER TAKEN 2007ca4: 92 10 00 03 mov %g3, %o1 *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007ca8: 82 13 c0 00 mov %o7, %g1 2007cac: 7f ff fd 56 call 2007204 <_Objects_Get> 2007cb0: 9e 10 40 00 mov %g1, %o7 goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; 2007cb4: 82 10 20 01 mov 1, %g1 2007cb8: 90 10 20 00 clr %o0 2007cbc: 81 c3 e0 08 retl 2007cc0: c2 22 80 00 st %g1, [ %o2 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007cc4: 03 00 80 60 sethi %hi(0x2018000), %g1 2007cc8: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 2018310 <_Thread_Dispatch_disable_level> 2007ccc: 84 00 a0 01 inc %g2 2007cd0: c4 20 63 10 st %g2, [ %g1 + 0x310 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 2007cd4: 03 00 80 60 sethi %hi(0x2018000), %g1 Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; 2007cd8: c0 22 40 00 clr [ %o1 ] tp = _Thread_Executing; 2007cdc: 81 c3 e0 08 retl 2007ce0: d0 00 63 d4 ld [ %g1 + 0x3d4 ], %o0 goto done; } information = api_information[ the_class ]; if ( !information ) { *location = OBJECTS_ERROR; 2007ce4: 81 c3 e0 08 retl <== NOT EXECUTED 2007ce8: c8 22 80 00 st %g4, [ %o2 ] <== NOT EXECUTED goto done; } api_information = _Objects_Information_table[ the_api ]; if ( !api_information ) { *location = OBJECTS_ERROR; 2007cec: 81 c3 e0 08 retl 2007cf0: 90 10 20 00 clr %o0 =============================================================================== 0200d860 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 200d860: 9d e3 bf 98 save %sp, -104, %sp #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 200d864: 03 00 80 60 sethi %hi(0x2018000), %g1 200d868: e0 00 63 d4 ld [ %g1 + 0x3d4 ], %l0 ! 20183d4 <_Thread_Executing> /* * Some CPUs need to tinker with the call frame or registers when the * thread actually begins to execute for the first time. This is a * hook point where the port gets a shot at doing whatever it requires. */ _Context_Initialization_at_thread_begin(); 200d86c: 3f 00 80 36 sethi %hi(0x200d800), %i7 200d870: be 17 e0 60 or %i7, 0x60, %i7 ! 200d860 <_Thread_Handler> /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 200d874: d0 04 20 b8 ld [ %l0 + 0xb8 ], %o0 _ISR_Set_level(level); 200d878: 7f ff d1 5f call 2001df4 200d87c: 91 2a 20 08 sll %o0, 8, %o0 #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 200d880: 07 00 80 60 sethi %hi(0x2018000), %g3 doneConstructors = 1; 200d884: 82 10 20 01 mov 1, %g1 level = executing->Start.isr_level; _ISR_Set_level(level); #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 200d888: e4 08 e0 20 ldub [ %g3 + 0x20 ], %l2 doneConstructors = 1; 200d88c: c2 28 e0 20 stb %g1, [ %g3 + 0x20 ] #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && !_Thread_Is_allocated_fp( executing ) ) { 200d890: c4 04 21 60 ld [ %l0 + 0x160 ], %g2 200d894: 80 a0 a0 00 cmp %g2, 0 200d898: 02 80 00 0b be 200d8c4 <_Thread_Handler+0x64> 200d89c: 23 00 80 60 sethi %hi(0x2018000), %l1 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 200d8a0: d0 04 63 98 ld [ %l1 + 0x398 ], %o0 ! 2018398 <_Thread_Allocated_fp> 200d8a4: 80 a4 00 08 cmp %l0, %o0 200d8a8: 02 80 00 07 be 200d8c4 <_Thread_Handler+0x64> 200d8ac: 80 a2 20 00 cmp %o0, 0 if ( _Thread_Allocated_fp != NULL ) 200d8b0: 22 80 00 05 be,a 200d8c4 <_Thread_Handler+0x64> 200d8b4: e0 24 63 98 st %l0, [ %l1 + 0x398 ] _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 200d8b8: 7f ff ee 96 call 2009310 <_CPU_Context_save_fp> 200d8bc: 90 02 21 60 add %o0, 0x160, %o0 _Thread_Allocated_fp = executing; 200d8c0: e0 24 63 98 st %l0, [ %l1 + 0x398 ] * Take care that 'begin' extensions get to complete before * 'switch' extensions can run. This means must keep dispatch * disabled until all 'begin' extensions complete. */ _User_extensions_Thread_begin( executing ); 200d8c4: 7f ff ec f7 call 2008ca0 <_User_extensions_Thread_begin> 200d8c8: 90 10 00 10 mov %l0, %o0 /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 200d8cc: 7f ff e8 d1 call 2007c10 <_Thread_Enable_dispatch> 200d8d0: 01 00 00 00 nop /* * _init could be a weak symbol and we SHOULD test it but it isn't * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (!doneCons) /* && (volatile void *)_init) */ 200d8d4: 83 2c a0 18 sll %l2, 0x18, %g1 200d8d8: 80 a0 60 00 cmp %g1, 0 200d8dc: 02 80 00 1e be 200d954 <_Thread_Handler+0xf4> 200d8e0: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200d8e4: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 200d8e8: 80 a0 60 01 cmp %g1, 1 200d8ec: 22 80 00 21 be,a 200d970 <_Thread_Handler+0x110> 200d8f0: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 200d8f4: 80 a0 60 01 cmp %g1, 1 200d8f8: 1a 80 00 0c bcc 200d928 <_Thread_Handler+0xc8> <== NEVER TAKEN 200d8fc: 80 a0 60 02 cmp %g1, 2 case THREAD_START_NUMERIC: executing->Wait.return_argument = 200d900: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 200d904: 9f c0 40 00 call %g1 200d908: d0 04 20 a8 ld [ %l0 + 0xa8 ], %o0 200d90c: d0 24 20 28 st %o0, [ %l0 + 0x28 ] * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 200d910: 7f ff ec f8 call 2008cf0 <_User_extensions_Thread_exitted> 200d914: 90 10 00 10 mov %l0, %o0 _Internal_error_Occurred( 200d918: 90 10 20 00 clr %o0 200d91c: 92 10 20 01 mov 1, %o1 200d920: 7f ff e4 a1 call 2006ba4 <_Internal_error_Occurred> 200d924: 94 10 20 06 mov 6, %o2 #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200d928: 22 80 00 16 be,a 200d980 <_Thread_Handler+0x120> <== NOT EXECUTED 200d92c: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED 200d930: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 200d934: 12 bf ff f7 bne 200d910 <_Thread_Handler+0xb0> <== NOT EXECUTED 200d938: 01 00 00 00 nop <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 200d93c: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED 200d940: d0 04 20 a8 ld [ %l0 + 0xa8 ], %o0 <== NOT EXECUTED 200d944: 9f c0 40 00 call %g1 <== NOT EXECUTED 200d948: d2 04 20 a4 ld [ %l0 + 0xa4 ], %o1 <== NOT EXECUTED 200d94c: 10 bf ff f1 b 200d910 <_Thread_Handler+0xb0> <== NOT EXECUTED 200d950: d0 24 20 28 st %o0, [ %l0 + 0x28 ] <== NOT EXECUTED * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (!doneCons) /* && (volatile void *)_init) */ { _init (); 200d954: 40 00 26 ab call 2017400 <_init> 200d958: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200d95c: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 200d960: 80 a0 60 01 cmp %g1, 1 200d964: 12 bf ff e5 bne 200d8f8 <_Thread_Handler+0x98> 200d968: 01 00 00 00 nop (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 200d96c: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 200d970: 9f c0 40 00 call %g1 200d974: d0 04 20 a4 ld [ %l0 + 0xa4 ], %o0 200d978: 10 bf ff e6 b 200d910 <_Thread_Handler+0xb0> 200d97c: d0 24 20 28 st %o0, [ %l0 + 0x28 ] (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 200d980: d0 04 20 a4 ld [ %l0 + 0xa4 ], %o0 <== NOT EXECUTED 200d984: 9f c0 40 00 call %g1 <== NOT EXECUTED 200d988: d2 04 20 a8 ld [ %l0 + 0xa8 ], %o1 <== NOT EXECUTED 200d98c: 10 bf ff e1 b 200d910 <_Thread_Handler+0xb0> <== NOT EXECUTED 200d990: d0 24 20 28 st %o0, [ %l0 + 0x28 ] <== NOT EXECUTED =============================================================================== 02007cf8 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 2007cf8: 9d e3 bf 98 save %sp, -104, %sp 2007cfc: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 2007d00: 80 a6 a0 00 cmp %i2, 0 Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 2007d04: e4 00 40 00 ld [ %g1 ], %l2 2007d08: e6 07 a0 60 ld [ %fp + 0x60 ], %l3 /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 2007d0c: 02 80 00 69 be 2007eb0 <_Thread_Initialize+0x1b8> <== ALWAYS TAKEN 2007d10: e2 0f a0 5f ldub [ %fp + 0x5f ], %l1 stack = the_thread->Start.stack; the_thread->Start.core_allocated_stack = TRUE; } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 2007d14: c0 2e 60 c0 clrb [ %i1 + 0xc0 ] <== NOT EXECUTED 2007d18: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 2007d1c: f4 26 60 c8 st %i2, [ %i1 + 0xc8 ] the_stack->size = size; 2007d20: d0 26 60 c4 st %o0, [ %i1 + 0xc4 ] /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 2007d24: 80 8f 20 ff btst 0xff, %i4 fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) { _Thread_Stack_Free( the_thread ); return FALSE; 2007d28: b4 10 20 00 clr %i2 /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 2007d2c: 12 80 00 43 bne 2007e38 <_Thread_Initialize+0x140> 2007d30: 82 10 20 00 clr %g1 /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 2007d34: 37 00 80 60 sethi %hi(0x2018000), %i3 2007d38: d0 06 e3 b4 ld [ %i3 + 0x3b4 ], %o0 ! 20183b4 <_Thread_Maximum_extensions> } else fp_area = NULL; the_thread->fp_context = fp_area; the_thread->Start.fp_context = fp_area; 2007d3c: c2 26 60 cc st %g1, [ %i1 + 0xcc ] fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 2007d40: c2 26 61 60 st %g1, [ %i1 + 0x160 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2007d44: c0 26 60 50 clr [ %i1 + 0x50 ] the_watchdog->routine = routine; 2007d48: c0 26 60 64 clr [ %i1 + 0x64 ] the_watchdog->id = id; 2007d4c: c0 26 60 68 clr [ %i1 + 0x68 ] the_watchdog->user_data = user_data; 2007d50: c0 26 60 6c clr [ %i1 + 0x6c ] /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 2007d54: c0 26 61 64 clr [ %i1 + 0x164 ] /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 2007d58: 80 a2 20 00 cmp %o0, 0 2007d5c: 12 80 00 41 bne 2007e60 <_Thread_Initialize+0x168> 2007d60: b8 16 e3 b4 or %i3, 0x3b4, %i4 return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 2007d64: c0 26 61 74 clr [ %i1 + 0x174 ] 2007d68: a0 10 20 00 clr %l0 * General initialization */ the_thread->Start.is_preemptible = is_preemptible; the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 2007d6c: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 2007d70: e2 2e 60 ac stb %l1, [ %i1 + 0xac ] the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 2007d74: c2 26 60 b4 st %g1, [ %i1 + 0xb4 ] switch ( budget_algorithm ) { 2007d78: 80 a4 e0 02 cmp %l3, 2 2007d7c: 12 80 00 05 bne 2007d90 <_Thread_Initialize+0x98> <== ALWAYS TAKEN 2007d80: e6 26 60 b0 st %l3, [ %i1 + 0xb0 ] case THREAD_CPU_BUDGET_ALGORITHM_NONE: case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: break; case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 2007d84: 03 00 80 60 sethi %hi(0x2018000), %g1 <== NOT EXECUTED 2007d88: c4 00 62 68 ld [ %g1 + 0x268 ], %g2 ! 2018268 <_Thread_Ticks_per_timeslice><== NOT EXECUTED 2007d8c: c4 26 60 78 st %g2, [ %i1 + 0x78 ] <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 2007d90: c2 07 a0 68 ld [ %fp + 0x68 ], %g1 the_thread->Wait.queue = NULL; the_thread->resource_count = 0; the_thread->suspend_count = 0; the_thread->real_priority = priority; the_thread->Start.initial_priority = priority; _Thread_Set_priority( the_thread, priority ); 2007d94: 92 10 00 1d mov %i5, %o1 break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 2007d98: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->current_state = STATES_DORMANT; 2007d9c: 82 10 20 01 mov 1, %g1 the_thread->Wait.queue = NULL; the_thread->resource_count = 0; the_thread->suspend_count = 0; the_thread->real_priority = priority; the_thread->Start.initial_priority = priority; _Thread_Set_priority( the_thread, priority ); 2007da0: 90 10 00 19 mov %i1, %o0 break; } the_thread->Start.isr_level = isr_level; the_thread->current_state = STATES_DORMANT; 2007da4: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_thread->Wait.queue = NULL; 2007da8: c0 26 60 44 clr [ %i1 + 0x44 ] the_thread->resource_count = 0; 2007dac: c0 26 60 1c clr [ %i1 + 0x1c ] the_thread->suspend_count = 0; 2007db0: c0 26 60 70 clr [ %i1 + 0x70 ] the_thread->real_priority = priority; 2007db4: fa 26 60 18 st %i5, [ %i1 + 0x18 ] the_thread->Start.initial_priority = priority; _Thread_Set_priority( the_thread, priority ); 2007db8: 40 00 02 1a call 2008620 <_Thread_Set_priority> 2007dbc: fa 26 60 bc st %i5, [ %i1 + 0xbc ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2007dc0: c4 06 60 08 ld [ %i1 + 8 ], %g2 2007dc4: c6 06 20 1c ld [ %i0 + 0x1c ], %g3 2007dc8: 03 00 00 3f sethi %hi(0xfc00), %g1 2007dcc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2007dd0: 84 08 80 01 and %g2, %g1, %g2 2007dd4: 85 28 a0 02 sll %g2, 2, %g2 information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 2007dd8: e4 26 60 0c st %l2, [ %i1 + 0xc ] /* * Initialize the CPU usage statistics */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS the_thread->cpu_time_used.tv_sec = 0; 2007ddc: c0 26 60 84 clr [ %i1 + 0x84 ] the_thread->cpu_time_used.tv_nsec = 0; 2007de0: c0 26 60 88 clr [ %i1 + 0x88 ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2007de4: f2 20 c0 02 st %i1, [ %g3 + %g2 ] * enabled when we get here. We want to be able to run the * user extensions with dispatching enabled. The Allocator * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); 2007de8: 90 10 00 19 mov %i1, %o0 2007dec: 40 00 03 e9 call 2008d90 <_User_extensions_Thread_create> 2007df0: b0 10 20 01 mov 1, %i0 if ( !extension_status ) { 2007df4: 80 8a 20 ff btst 0xff, %o0 2007df8: 12 80 00 0e bne 2007e30 <_Thread_Initialize+0x138> <== ALWAYS TAKEN 2007dfc: 80 a4 20 00 cmp %l0, 0 if ( extensions_area ) 2007e00: 02 80 00 05 be 2007e14 <_Thread_Initialize+0x11c> <== NOT EXECUTED 2007e04: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); 2007e08: 40 00 05 04 call 2009218 <_Workspace_Free> <== NOT EXECUTED 2007e0c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2007e10: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 2007e14: 02 80 00 05 be 2007e28 <_Thread_Initialize+0x130> <== NOT EXECUTED 2007e18: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 2007e1c: 40 00 04 ff call 2009218 <_Workspace_Free> <== NOT EXECUTED 2007e20: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 2007e24: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2007e28: 40 00 02 ba call 2008910 <_Thread_Stack_Free> <== NOT EXECUTED 2007e2c: b0 10 20 00 clr %i0 <== NOT EXECUTED return FALSE; } return TRUE; } 2007e30: 81 c7 e0 08 ret 2007e34: 81 e8 00 00 restore */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 2007e38: 40 00 04 ff call 2009234 <_Workspace_Allocate> 2007e3c: 90 10 20 88 mov 0x88, %o0 if ( !fp_area ) { 2007e40: b4 92 20 00 orcc %o0, 0, %i2 2007e44: 12 bf ff bc bne 2007d34 <_Thread_Initialize+0x3c> <== ALWAYS TAKEN 2007e48: 82 10 00 1a mov %i2, %g1 _Thread_Stack_Free( the_thread ); 2007e4c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2007e50: 40 00 02 b0 call 2008910 <_Thread_Stack_Free> <== NOT EXECUTED 2007e54: b0 10 20 00 clr %i0 <== NOT EXECUTED 2007e58: 81 c7 e0 08 ret <== NOT EXECUTED 2007e5c: 81 e8 00 00 restore <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 2007e60: 90 02 20 01 inc %o0 2007e64: 40 00 04 f4 call 2009234 <_Workspace_Allocate> 2007e68: 91 2a 20 02 sll %o0, 2, %o0 (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 2007e6c: a0 92 20 00 orcc %o0, 0, %l0 2007e70: 02 80 00 1b be 2007edc <_Thread_Initialize+0x1e4> <== NEVER TAKEN 2007e74: c2 06 e3 b4 ld [ %i3 + 0x3b4 ], %g1 * call. */ if ( the_thread->extensions ) { uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2007e78: 80 a0 7f ff cmp %g1, -1 2007e7c: 02 bf ff bc be 2007d6c <_Thread_Initialize+0x74> <== NEVER TAKEN 2007e80: e0 26 61 74 st %l0, [ %i1 + 0x174 ] 2007e84: 86 10 20 00 clr %g3 2007e88: 88 10 00 10 mov %l0, %g4 2007e8c: c4 07 00 00 ld [ %i4 ], %g2 the_thread->extensions[i] = NULL; 2007e90: 83 28 e0 02 sll %g3, 2, %g1 * call. */ if ( the_thread->extensions ) { uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2007e94: 86 00 e0 01 inc %g3 2007e98: 84 00 a0 01 inc %g2 2007e9c: 80 a0 80 03 cmp %g2, %g3 2007ea0: 18 bf ff fb bgu 2007e8c <_Thread_Initialize+0x194> 2007ea4: c0 21 00 01 clr [ %g4 + %g1 ] * General initialization */ the_thread->Start.is_preemptible = is_preemptible; the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 2007ea8: 10 bf ff b2 b 2007d70 <_Thread_Initialize+0x78> 2007eac: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 */ if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 2007eb0: 90 10 00 19 mov %i1, %o0 2007eb4: 40 00 02 7b call 20088a0 <_Thread_Stack_Allocate> 2007eb8: 92 10 00 1b mov %i3, %o1 if ( !actual_stack_size || actual_stack_size < stack_size ) 2007ebc: 80 a2 20 00 cmp %o0, 0 2007ec0: 02 80 00 0e be 2007ef8 <_Thread_Initialize+0x200> 2007ec4: 80 a6 c0 08 cmp %i3, %o0 2007ec8: 18 80 00 0c bgu 2007ef8 <_Thread_Initialize+0x200> <== NEVER TAKEN 2007ecc: 82 10 20 01 mov 1, %g1 return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 2007ed0: f4 06 60 d0 ld [ %i1 + 0xd0 ], %i2 the_thread->Start.core_allocated_stack = TRUE; 2007ed4: 10 bf ff 92 b 2007d1c <_Thread_Initialize+0x24> 2007ed8: c2 2e 60 c0 stb %g1, [ %i1 + 0xc0 ] (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2007edc: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 2007ee0: 02 80 00 04 be 2007ef0 <_Thread_Initialize+0x1f8> <== NOT EXECUTED 2007ee4: 01 00 00 00 nop <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 2007ee8: 40 00 04 cc call 2009218 <_Workspace_Free> <== NOT EXECUTED 2007eec: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 2007ef0: 40 00 02 88 call 2008910 <_Thread_Stack_Free> <== NOT EXECUTED 2007ef4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2007ef8: 81 c7 e0 08 ret 2007efc: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 0200d75c <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 200d75c: 9d e3 bf 98 save %sp, -104, %sp the_thread->resource_count = 0; the_thread->suspend_count = 0; the_thread->is_preemptible = the_thread->Start.is_preemptible; the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout; 200d760: c4 1e 20 b0 ldd [ %i0 + 0xb0 ], %g2 Thread_Entry_numeric_type numeric_argument ) { the_thread->resource_count = 0; the_thread->suspend_count = 0; the_thread->is_preemptible = the_thread->Start.is_preemptible; 200d764: c2 0e 20 ac ldub [ %i0 + 0xac ], %g1 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 200d768: c4 26 20 7c st %g2, [ %i0 + 0x7c ] Thread_Entry_numeric_type numeric_argument ) { the_thread->resource_count = 0; the_thread->suspend_count = 0; the_thread->is_preemptible = the_thread->Start.is_preemptible; 200d76c: c2 2e 20 76 stb %g1, [ %i0 + 0x76 ] the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout; 200d770: c6 26 20 80 st %g3, [ %i0 + 0x80 ] the_thread->Start.pointer_argument = pointer_argument; 200d774: f2 26 20 a4 st %i1, [ %i0 + 0xa4 ] the_thread->Start.numeric_argument = numeric_argument; 200d778: f4 26 20 a8 st %i2, [ %i0 + 0xa8 ] Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { the_thread->resource_count = 0; 200d77c: c0 26 20 1c clr [ %i0 + 0x1c ] the_thread->suspend_count = 0; 200d780: c0 26 20 70 clr [ %i0 + 0x70 ] the_thread->budget_callout = the_thread->Start.budget_callout; the_thread->Start.pointer_argument = pointer_argument; the_thread->Start.numeric_argument = numeric_argument; if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 200d784: 7f ff ee 2d call 2009038 <_Thread_queue_Extract_with_proxy> 200d788: 90 10 00 18 mov %i0, %o0 200d78c: 80 8a 20 ff btst 0xff, %o0 200d790: 32 80 00 07 bne,a 200d7ac <_Thread_Reset+0x50> 200d794: f2 06 20 bc ld [ %i0 + 0xbc ], %i1 if ( _Watchdog_Is_active( &the_thread->Timer ) ) 200d798: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 200d79c: 80 a0 60 02 cmp %g1, 2 200d7a0: 02 80 00 0c be 200d7d0 <_Thread_Reset+0x74> <== NEVER TAKEN 200d7a4: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 200d7a8: f2 06 20 bc ld [ %i0 + 0xbc ], %i1 200d7ac: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 200d7b0: 80 a0 40 19 cmp %g1, %i1 200d7b4: 02 80 00 05 be 200d7c8 <_Thread_Reset+0x6c> 200d7b8: 01 00 00 00 nop the_thread->real_priority = the_thread->Start.initial_priority; 200d7bc: f2 26 20 18 st %i1, [ %i0 + 0x18 ] _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 200d7c0: 7f ff ee a5 call 2009254 <_Thread_Set_priority> 200d7c4: 81 e8 00 00 restore 200d7c8: 81 c7 e0 08 ret 200d7cc: 81 e8 00 00 restore the_thread->Start.numeric_argument = numeric_argument; if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 200d7d0: 7f ff f1 53 call 2009d1c <_Watchdog_Remove> <== NOT EXECUTED 200d7d4: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 200d7d8: 10 bf ff f5 b 200d7ac <_Thread_Reset+0x50> <== NOT EXECUTED 200d7dc: f2 06 20 bc ld [ %i0 + 0xbc ], %i1 <== NOT EXECUTED =============================================================================== 0200ca10 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 200ca10: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 200ca14: 03 00 80 60 sethi %hi(0x2018000), %g1 200ca18: e0 00 63 d4 ld [ %g1 + 0x3d4 ], %l0 ! 20183d4 <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 200ca1c: 7f ff d4 f2 call 2001de4 200ca20: e2 04 20 8c ld [ %l0 + 0x8c ], %l1 200ca24: b0 10 00 08 mov %o0, %i0 if ( _Chain_Has_only_one_node( ready ) ) { 200ca28: c4 04 40 00 ld [ %l1 ], %g2 200ca2c: c2 04 60 08 ld [ %l1 + 8 ], %g1 200ca30: 80 a0 80 01 cmp %g2, %g1 200ca34: 02 80 00 18 be 200ca94 <_Thread_Reset_timeslice+0x84> 200ca38: 82 04 60 04 add %l1, 4, %g1 ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 200ca3c: c6 04 00 00 ld [ %l0 ], %g3 previous = the_node->previous; 200ca40: c4 04 20 04 ld [ %l0 + 4 ], %g2 next->previous = previous; previous->next = next; 200ca44: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200ca48: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200ca4c: c4 20 e0 04 st %g2, [ %g3 + 4 ] ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; 200ca50: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 200ca54: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200ca58: c2 24 20 04 st %g1, [ %l0 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 200ca5c: e0 20 40 00 st %l0, [ %g1 ] return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 200ca60: 7f ff d4 e5 call 2001df4 200ca64: 01 00 00 00 nop 200ca68: 7f ff d4 df call 2001de4 200ca6c: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 200ca70: 07 00 80 60 sethi %hi(0x2018000), %g3 200ca74: c2 00 e3 a0 ld [ %g3 + 0x3a0 ], %g1 ! 20183a0 <_Thread_Heir> 200ca78: 80 a4 00 01 cmp %l0, %g1 200ca7c: 02 80 00 08 be 200ca9c <_Thread_Reset_timeslice+0x8c> <== ALWAYS TAKEN 200ca80: 84 10 20 01 mov 1, %g2 _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; 200ca84: 03 00 80 60 sethi %hi(0x2018000), %g1 <== NOT EXECUTED 200ca88: c4 28 63 e4 stb %g2, [ %g1 + 0x3e4 ] ! 20183e4 <_Context_Switch_necessary><== NOT EXECUTED _ISR_Enable( level ); 200ca8c: 7f ff d4 da call 2001df4 <== NOT EXECUTED 200ca90: 81 e8 00 00 restore <== NOT EXECUTED executing = _Thread_Executing; ready = executing->ready; _ISR_Disable( level ); if ( _Chain_Has_only_one_node( ready ) ) { _ISR_Enable( level ); 200ca94: 7f ff d4 d8 call 2001df4 200ca98: 81 e8 00 00 restore _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; 200ca9c: c2 04 40 00 ld [ %l1 ], %g1 200caa0: c2 20 e3 a0 st %g1, [ %g3 + 0x3a0 ] _Context_Switch_necessary = TRUE; 200caa4: 03 00 80 60 sethi %hi(0x2018000), %g1 200caa8: c4 28 63 e4 stb %g2, [ %g1 + 0x3e4 ] ! 20183e4 <_Context_Switch_necessary> _ISR_Enable( level ); 200caac: 7f ff d4 d2 call 2001df4 200cab0: 81 e8 00 00 restore =============================================================================== 02009f68 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 2009f68: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; States_Control current_state; _ISR_Disable( level ); 2009f6c: 7f ff e2 bb call 2002a58 2009f70: 01 00 00 00 nop 2009f74: a0 10 00 08 mov %o0, %l0 if ( force == TRUE ) 2009f78: 80 8e 60 ff btst 0xff, %i1 2009f7c: 22 80 00 0d be,a 2009fb0 <_Thread_Resume+0x48> <== NEVER TAKEN 2009f80: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED the_thread->suspend_count = 0; 2009f84: c0 26 20 70 clr [ %i0 + 0x70 ] if ( the_thread->suspend_count > 0 ) { _ISR_Enable( level ); return; } current_state = the_thread->current_state; 2009f88: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 if ( current_state & STATES_SUSPENDED ) { 2009f8c: 80 88 60 02 btst 2, %g1 2009f90: 02 80 00 06 be 2009fa8 <_Thread_Resume+0x40> <== NEVER TAKEN 2009f94: 01 00 00 00 nop RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 2009f98: 82 08 7f fd and %g1, -3, %g1 current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 2009f9c: 80 a0 60 00 cmp %g1, 0 2009fa0: 02 80 00 0a be 2009fc8 <_Thread_Resume+0x60> 2009fa4: c2 26 20 10 st %g1, [ %i0 + 0x10 ] _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 2009fa8: 7f ff e2 b0 call 2002a68 2009fac: 91 e8 00 10 restore %g0, %l0, %o0 _ISR_Disable( level ); if ( force == TRUE ) the_thread->suspend_count = 0; else the_thread->suspend_count--; 2009fb0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 2009fb4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2009fb8: 02 bf ff f4 be 2009f88 <_Thread_Resume+0x20> <== NOT EXECUTED 2009fbc: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED _ISR_Enable( level ); 2009fc0: 7f ff e2 aa call 2002a68 <== NOT EXECUTED 2009fc4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 2009fc8: c8 06 20 90 ld [ %i0 + 0x90 ], %g4 2009fcc: c4 16 20 96 lduh [ %i0 + 0x96 ], %g2 2009fd0: c2 11 00 00 lduh [ %g4 ], %g1 if ( _States_Is_ready( current_state ) ) { _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 2009fd4: c6 06 20 8c ld [ %i0 + 0x8c ], %g3 2009fd8: 82 10 40 02 or %g1, %g2, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 2009fdc: 1b 00 80 93 sethi %hi(0x2024c00), %o5 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 2009fe0: c2 31 00 00 sth %g1, [ %g4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 2009fe4: 82 00 e0 04 add %g3, 4, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 2009fe8: d8 16 20 94 lduh [ %i0 + 0x94 ], %o4 2009fec: c2 26 00 00 st %g1, [ %i0 ] 2009ff0: c4 13 62 18 lduh [ %o5 + 0x218 ], %g2 old_last_node = the_chain->last; 2009ff4: c8 00 e0 08 ld [ %g3 + 8 ], %g4 the_chain->last = the_node; 2009ff8: f0 20 e0 08 st %i0, [ %g3 + 8 ] 2009ffc: 84 10 80 0c or %g2, %o4, %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 200a000: c8 26 20 04 st %g4, [ %i0 + 4 ] 200a004: c4 33 62 18 sth %g2, [ %o5 + 0x218 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 200a008: f0 21 00 00 st %i0, [ %g4 ] _ISR_Flash( level ); 200a00c: 7f ff e2 97 call 2002a68 200a010: 90 10 00 10 mov %l0, %o0 200a014: 7f ff e2 91 call 2002a58 200a018: 01 00 00 00 nop if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 200a01c: 09 00 80 93 sethi %hi(0x2024c00), %g4 200a020: c4 01 21 f0 ld [ %g4 + 0x1f0 ], %g2 ! 2024df0 <_Thread_Heir> 200a024: c6 06 20 14 ld [ %i0 + 0x14 ], %g3 200a028: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 200a02c: 80 a0 c0 01 cmp %g3, %g1 200a030: 1a bf ff de bcc 2009fa8 <_Thread_Resume+0x40> 200a034: 01 00 00 00 nop _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200a038: 03 00 80 93 sethi %hi(0x2024c00), %g1 200a03c: c4 00 62 24 ld [ %g1 + 0x224 ], %g2 ! 2024e24 <_Thread_Executing> _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); _ISR_Flash( level ); if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; 200a040: f0 21 21 f0 st %i0, [ %g4 + 0x1f0 ] if ( _Thread_Executing->is_preemptible || 200a044: c2 08 a0 76 ldub [ %g2 + 0x76 ], %g1 200a048: 80 a0 60 00 cmp %g1, 0 200a04c: 02 80 00 06 be 200a064 <_Thread_Resume+0xfc> 200a050: 80 a0 e0 00 cmp %g3, 0 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 200a054: 84 10 20 01 mov 1, %g2 200a058: 03 00 80 93 sethi %hi(0x2024c00), %g1 200a05c: c4 28 62 34 stb %g2, [ %g1 + 0x234 ] ! 2024e34 <_Context_Switch_necessary> 200a060: 30 bf ff d2 b,a 2009fa8 <_Thread_Resume+0x40> _ISR_Flash( level ); if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200a064: 12 bf ff d1 bne 2009fa8 <_Thread_Resume+0x40> <== ALWAYS TAKEN 200a068: 84 10 20 01 mov 1, %g2 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 200a06c: 10 bf ff fc b 200a05c <_Thread_Resume+0xf4> <== NOT EXECUTED 200a070: 03 00 80 93 sethi %hi(0x2024c00), %g1 <== NOT EXECUTED =============================================================================== 020088a0 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 20088a0: 9d e3 bf 98 save %sp, -104, %sp 20088a4: 03 00 80 5d sethi %hi(0x2017400), %g1 20088a8: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 ! 20174e0 20088ac: 80 a6 40 01 cmp %i1, %g1 20088b0: 2a 80 00 02 bcs,a 20088b8 <_Thread_Stack_Allocate+0x18> 20088b4: b2 10 00 01 mov %g1, %i1 * Call ONLY the CPU table stack allocate hook, _or_ the * the RTEMS workspace allocate. This is so the stack free * routine can call the correct deallocation routine. */ if ( _Configuration_Table->stack_allocate_hook ) { 20088b8: 03 00 80 60 sethi %hi(0x2018000), %g1 20088bc: c4 00 63 ac ld [ %g1 + 0x3ac ], %g2 ! 20183ac <_Configuration_Table> 20088c0: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1 20088c4: 80 a0 60 00 cmp %g1, 0 20088c8: 22 80 00 0a be,a 20088f0 <_Thread_Stack_Allocate+0x50> <== ALWAYS TAKEN 20088cc: b2 06 60 10 add %i1, 0x10, %i1 stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size ); 20088d0: 9f c0 40 00 call %g1 <== NOT EXECUTED 20088d4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 20088d8: d0 26 20 d0 st %o0, [ %i0 + 0xd0 ] <== NOT EXECUTED the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 20088dc: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 20088e0: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 20088e4: b0 0e 40 18 and %i1, %i0, %i0 <== NOT EXECUTED 20088e8: 81 c7 e0 08 ret <== NOT EXECUTED 20088ec: 81 e8 00 00 restore <== NOT EXECUTED * get and keep the stack adjust factor, the stack alignment, and * the context initialization sequence in sync. */ the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); 20088f0: 40 00 02 51 call 2009234 <_Workspace_Allocate> 20088f4: 90 10 00 19 mov %i1, %o0 } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 20088f8: d0 26 20 d0 st %o0, [ %i0 + 0xd0 ] the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 20088fc: 80 a0 00 08 cmp %g0, %o0 2008900: b0 60 20 00 subx %g0, 0, %i0 the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 2008904: b0 0e 40 18 and %i1, %i0, %i0 2008908: 81 c7 e0 08 ret 200890c: 81 e8 00 00 restore =============================================================================== 02008910 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 2008910: 9d e3 bf 98 save %sp, -104, %sp /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 2008914: c2 0e 20 c0 ldub [ %i0 + 0xc0 ], %g1 2008918: 80 a0 60 00 cmp %g1, 0 200891c: 02 80 00 09 be 2008940 <_Thread_Stack_Free+0x30> <== NEVER TAKEN 2008920: 03 00 80 60 sethi %hi(0x2018000), %g1 * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( _Configuration_Table->stack_free_hook ) 2008924: c4 00 63 ac ld [ %g1 + 0x3ac ], %g2 ! 20183ac <_Configuration_Table> 2008928: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1 200892c: 80 a0 60 00 cmp %g1, 0 2008930: 22 80 00 06 be,a 2008948 <_Thread_Stack_Free+0x38> <== ALWAYS TAKEN 2008934: f0 06 20 c8 ld [ %i0 + 0xc8 ], %i0 (*_Configuration_Table->stack_free_hook)( 2008938: 9f c0 40 00 call %g1 <== NOT EXECUTED 200893c: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0 <== NOT EXECUTED 2008940: 81 c7 e0 08 ret <== NOT EXECUTED 2008944: 81 e8 00 00 restore <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 2008948: 40 00 02 34 call 2009218 <_Workspace_Free> 200894c: 81 e8 00 00 restore =============================================================================== 020089f4 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 20089f4: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; 20089f8: 03 00 80 60 sethi %hi(0x2018000), %g1 20089fc: e0 00 63 d4 ld [ %g1 + 0x3d4 ], %l0 ! 20183d4 <_Thread_Executing> /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 2008a00: c4 0c 20 76 ldub [ %l0 + 0x76 ], %g2 2008a04: 80 a0 a0 00 cmp %g2, 0 2008a08: 02 80 00 23 be 2008a94 <_Thread_Tickle_timeslice+0xa0> 2008a0c: 01 00 00 00 nop return; if ( !_States_Is_ready( executing->current_state ) ) 2008a10: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2008a14: 80 a0 60 00 cmp %g1, 0 2008a18: 12 80 00 1f bne 2008a94 <_Thread_Tickle_timeslice+0xa0> 2008a1c: 01 00 00 00 nop /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 2008a20: c2 04 20 7c ld [ %l0 + 0x7c ], %g1 2008a24: 80 a0 60 01 cmp %g1, 1 2008a28: 0a 80 00 07 bcs 2008a44 <_Thread_Tickle_timeslice+0x50> 2008a2c: 80 a0 60 02 cmp %g1, 2 2008a30: 28 80 00 10 bleu,a 2008a70 <_Thread_Tickle_timeslice+0x7c> 2008a34: c2 04 20 78 ld [ %l0 + 0x78 ], %g1 2008a38: 80 a0 60 03 cmp %g1, 3 2008a3c: 22 80 00 04 be,a 2008a4c <_Thread_Tickle_timeslice+0x58> <== ALWAYS TAKEN 2008a40: c2 04 20 78 ld [ %l0 + 0x78 ], %g1 2008a44: 81 c7 e0 08 ret 2008a48: 81 e8 00 00 restore executing->cpu_time_budget = _Thread_Ticks_per_timeslice; } break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 2008a4c: 82 00 7f ff add %g1, -1, %g1 2008a50: 80 a0 60 00 cmp %g1, 0 2008a54: 12 bf ff fc bne 2008a44 <_Thread_Tickle_timeslice+0x50> 2008a58: c2 24 20 78 st %g1, [ %l0 + 0x78 ] (*executing->budget_callout)( executing ); 2008a5c: c2 04 20 80 ld [ %l0 + 0x80 ], %g1 2008a60: 9f c0 40 00 call %g1 2008a64: 90 10 00 10 mov %l0, %o0 2008a68: 81 c7 e0 08 ret 2008a6c: 81 e8 00 00 restore case THREAD_CPU_BUDGET_ALGORITHM_NONE: break; case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: if ( (int)(--executing->cpu_time_budget) <= 0 ) { 2008a70: 82 00 7f ff add %g1, -1, %g1 2008a74: 80 a0 60 00 cmp %g1, 0 2008a78: 14 bf ff f3 bg 2008a44 <_Thread_Tickle_timeslice+0x50> 2008a7c: c2 24 20 78 st %g1, [ %l0 + 0x78 ] _Thread_Reset_timeslice(); 2008a80: 40 00 0f e4 call 200ca10 <_Thread_Reset_timeslice> 2008a84: 01 00 00 00 nop executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 2008a88: 03 00 80 60 sethi %hi(0x2018000), %g1 2008a8c: c4 00 62 68 ld [ %g1 + 0x268 ], %g2 ! 2018268 <_Thread_Ticks_per_timeslice> 2008a90: c4 24 20 78 st %g2, [ %l0 + 0x78 ] 2008a94: 81 c7 e0 08 ret 2008a98: 81 e8 00 00 restore =============================================================================== 02008a9c <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 2008a9c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 2008aa0: 03 00 80 60 sethi %hi(0x2018000), %g1 2008aa4: e0 00 63 d4 ld [ %g1 + 0x3d4 ], %l0 ! 20183d4 <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 2008aa8: 7f ff e4 cf call 2001de4 2008aac: e2 04 20 8c ld [ %l0 + 0x8c ], %l1 2008ab0: b0 10 00 08 mov %o0, %i0 if ( !_Chain_Has_only_one_node( ready ) ) { 2008ab4: c4 04 40 00 ld [ %l1 ], %g2 2008ab8: c2 04 60 08 ld [ %l1 + 8 ], %g1 2008abc: 80 a0 80 01 cmp %g2, %g1 2008ac0: 02 80 00 19 be 2008b24 <_Thread_Yield_processor+0x88> 2008ac4: 82 04 60 04 add %l1, 4, %g1 ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 2008ac8: c6 04 00 00 ld [ %l0 ], %g3 previous = the_node->previous; 2008acc: c4 04 20 04 ld [ %l0 + 4 ], %g2 next->previous = previous; previous->next = next; 2008ad0: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 2008ad4: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 2008ad8: c4 20 e0 04 st %g2, [ %g3 + 4 ] ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; 2008adc: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 2008ae0: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 2008ae4: c2 24 20 04 st %g1, [ %l0 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 2008ae8: e0 20 40 00 st %l0, [ %g1 ] _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 2008aec: 7f ff e4 c2 call 2001df4 2008af0: 01 00 00 00 nop 2008af4: 7f ff e4 bc call 2001de4 2008af8: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 2008afc: 07 00 80 60 sethi %hi(0x2018000), %g3 2008b00: c2 00 e3 a0 ld [ %g3 + 0x3a0 ], %g1 ! 20183a0 <_Thread_Heir> 2008b04: 80 a4 00 01 cmp %l0, %g1 2008b08: 22 80 00 0d be,a 2008b3c <_Thread_Yield_processor+0xa0> <== ALWAYS TAKEN 2008b0c: c2 04 40 00 ld [ %l1 ], %g1 _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) _Context_Switch_necessary = TRUE; 2008b10: 84 10 20 01 mov 1, %g2 2008b14: 03 00 80 60 sethi %hi(0x2018000), %g1 2008b18: c4 28 63 e4 stb %g2, [ %g1 + 0x3e4 ] ! 20183e4 <_Context_Switch_necessary> _ISR_Enable( level ); 2008b1c: 7f ff e4 b6 call 2001df4 2008b20: 81 e8 00 00 restore if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 2008b24: 03 00 80 60 sethi %hi(0x2018000), %g1 2008b28: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20183a0 <_Thread_Heir> 2008b2c: 80 a4 00 02 cmp %l0, %g2 2008b30: 12 bf ff f9 bne 2008b14 <_Thread_Yield_processor+0x78> <== NEVER TAKEN 2008b34: 84 10 20 01 mov 1, %g2 2008b38: 30 bf ff f9 b,a 2008b1c <_Thread_Yield_processor+0x80> _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; 2008b3c: 10 bf ff f5 b 2008b10 <_Thread_Yield_processor+0x74> 2008b40: c2 20 e3 a0 st %g1, [ %g3 + 0x3a0 ] =============================================================================== 02008220 <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 2008220: 9d e3 bf 98 save %sp, -104, %sp Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 2008224: e4 06 60 14 ld [ %i1 + 0x14 ], %l2 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2008228: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 200822c: 84 06 60 38 add %i1, 0x38, %g2 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2008230: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; 2008234: c0 26 60 3c clr [ %i1 + 0x3c ] the_chain->last = _Chain_Head(the_chain); 2008238: c4 26 60 40 st %g2, [ %i1 + 0x40 ] Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 200823c: ac 10 00 18 mov %i0, %l6 priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 2008240: 80 8c a0 20 btst 0x20, %l2 RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number ( Priority_Control the_priority ) { return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER); 2008244: 83 34 a0 06 srl %l2, 6, %g1 2008248: 12 80 00 30 bne 2008308 <_Thread_queue_Enqueue_priority+0xe8> 200824c: ea 06 20 38 ld [ %i0 + 0x38 ], %l5 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2008250: 85 28 60 04 sll %g1, 4, %g2 2008254: 83 28 60 02 sll %g1, 2, %g1 2008258: 82 20 80 01 sub %g2, %g1, %g1 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 200825c: b0 10 00 01 mov %g1, %i0 2008260: 82 05 80 01 add %l6, %g1, %g1 2008264: a6 00 60 04 add %g1, 4, %l3 if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 2008268: 7f ff e6 df call 2001de4 200826c: 01 00 00 00 nop 2008270: a8 10 00 08 mov %o0, %l4 search_thread = (Thread_Control *) header->first; 2008274: e0 05 80 18 ld [ %l6 + %i0 ], %l0 while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 2008278: 80 a4 00 13 cmp %l0, %l3 200827c: 32 80 00 18 bne,a 20082dc <_Thread_queue_Enqueue_priority+0xbc> 2008280: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 2008284: 10 80 00 81 b 2008488 <_Thread_queue_Enqueue_priority+0x268> 2008288: a2 10 3f ff mov -1, %l1 if ( priority <= search_priority ) break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 200828c: 80 a4 00 13 cmp %l0, %l3 2008290: 02 80 00 17 be 20082ec <_Thread_queue_Enqueue_priority+0xcc> 2008294: 90 10 00 14 mov %l4, %o0 break; search_priority = search_thread->current_priority; 2008298: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 200829c: 80 a4 80 11 cmp %l2, %l1 20082a0: 28 80 00 14 bleu,a 20082f0 <_Thread_queue_Enqueue_priority+0xd0> 20082a4: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0 break; #endif _ISR_Flash( level ); 20082a8: 7f ff e6 d3 call 2001df4 20082ac: 90 10 00 14 mov %l4, %o0 20082b0: 7f ff e6 cd call 2001de4 20082b4: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 20082b8: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 20082bc: 80 8d 40 01 btst %l5, %g1 20082c0: 02 80 00 6b be 200846c <_Thread_queue_Enqueue_priority+0x24c><== NEVER TAKEN 20082c4: 01 00 00 00 nop _ISR_Enable( level ); goto restart_forward_search; } search_thread = 20082c8: e0 04 00 00 ld [ %l0 ], %l0 restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 20082cc: 80 a4 00 13 cmp %l0, %l3 20082d0: 02 80 00 07 be 20082ec <_Thread_queue_Enqueue_priority+0xcc> 20082d4: 90 10 00 14 mov %l4, %o0 search_priority = search_thread->current_priority; 20082d8: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 20082dc: 80 a4 80 11 cmp %l2, %l1 20082e0: 38 bf ff eb bgu,a 200828c <_Thread_queue_Enqueue_priority+0x6c> 20082e4: e0 04 00 00 ld [ %l0 ], %l0 restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 20082e8: 90 10 00 14 mov %l4, %o0 } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 20082ec: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0 20082f0: 80 a6 20 01 cmp %i0, 1 20082f4: 02 80 00 47 be 2008410 <_Thread_queue_Enqueue_priority+0x1f0><== ALWAYS TAKEN 20082f8: 80 a4 80 11 cmp %l2, %l1 * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 20082fc: d0 26 80 00 st %o0, [ %i2 ] <== NOT EXECUTED return the_thread_queue->sync_state; } 2008300: 81 c7 e0 08 ret <== NOT EXECUTED 2008304: 81 e8 00 00 restore <== NOT EXECUTED the_node->previous = previous_node; previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 2008308: 85 28 60 04 sll %g1, 4, %g2 200830c: 83 28 60 02 sll %g1, 2, %g1 2008310: 82 20 80 01 sub %g2, %g1, %g1 2008314: 05 00 80 5d sethi %hi(0x2017400), %g2 2008318: a6 06 00 01 add %i0, %g1, %l3 200831c: ae 10 a0 e4 or %g2, 0xe4, %l7 restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 2008320: b0 10 00 13 mov %l3, %i0 the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 2008324: c2 0d c0 00 ldub [ %l7 ], %g1 _ISR_Disable( level ); 2008328: 7f ff e6 af call 2001de4 200832c: a2 00 60 01 add %g1, 1, %l1 2008330: a8 10 00 08 mov %o0, %l4 search_thread = (Thread_Control *) header->last; 2008334: e0 06 20 08 ld [ %i0 + 8 ], %l0 while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 2008338: 80 a4 c0 10 cmp %l3, %l0 200833c: 22 80 00 25 be,a 20083d0 <_Thread_queue_Enqueue_priority+0x1b0> 2008340: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0 search_priority = search_thread->current_priority; 2008344: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority >= search_priority ) 2008348: 80 a4 80 11 cmp %l2, %l1 200834c: 3a 80 00 21 bcc,a 20083d0 <_Thread_queue_Enqueue_priority+0x1b0> 2008350: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 2008354: e0 04 20 04 ld [ %l0 + 4 ], %l0 if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 2008358: 80 a4 c0 10 cmp %l3, %l0 200835c: 32 80 00 19 bne,a 20083c0 <_Thread_queue_Enqueue_priority+0x1a0> 2008360: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 2008364: 10 80 00 1b b 20083d0 <_Thread_queue_Enqueue_priority+0x1b0> 2008368: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0 break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 200836c: 7f ff e6 a2 call 2001df4 2008370: 90 10 00 14 mov %l4, %o0 2008374: 7f ff e6 9c call 2001de4 2008378: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 200837c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2008380: 80 8d 40 01 btst %l5, %g1 2008384: 02 80 00 3d be 2008478 <_Thread_queue_Enqueue_priority+0x258><== NEVER TAKEN 2008388: 01 00 00 00 nop _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 200838c: e0 04 20 04 ld [ %l0 + 4 ], %l0 restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 2008390: 80 a4 00 13 cmp %l0, %l3 2008394: 22 80 00 0f be,a 20083d0 <_Thread_queue_Enqueue_priority+0x1b0> 2008398: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0 search_priority = search_thread->current_priority; 200839c: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority >= search_priority ) 20083a0: 80 a4 80 11 cmp %l2, %l1 20083a4: 3a 80 00 0b bcc,a 20083d0 <_Thread_queue_Enqueue_priority+0x1b0><== ALWAYS TAKEN 20083a8: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 20083ac: e0 04 20 04 ld [ %l0 + 4 ], %l0 <== NOT EXECUTED if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 20083b0: 80 a4 00 13 cmp %l0, %l3 <== NOT EXECUTED 20083b4: 22 80 00 07 be,a 20083d0 <_Thread_queue_Enqueue_priority+0x1b0><== NOT EXECUTED 20083b8: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0 <== NOT EXECUTED break; search_priority = search_thread->current_priority; 20083bc: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED if ( priority >= search_priority ) 20083c0: 80 a4 80 11 cmp %l2, %l1 20083c4: 0a bf ff ea bcs 200836c <_Thread_queue_Enqueue_priority+0x14c> 20083c8: 01 00 00 00 nop } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 20083cc: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0 20083d0: 80 a6 20 01 cmp %i0, 1 20083d4: 12 bf ff ca bne 20082fc <_Thread_queue_Enqueue_priority+0xdc><== NEVER TAKEN 20083d8: 90 10 00 14 mov %l4, %o0 THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( priority == search_priority ) 20083dc: 80 a4 80 11 cmp %l2, %l1 20083e0: 02 80 00 18 be 2008440 <_Thread_queue_Enqueue_priority+0x220> 20083e4: c0 25 a0 30 clr [ %l6 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 20083e8: c2 04 00 00 ld [ %l0 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 20083ec: e0 26 60 04 st %l0, [ %i1 + 4 ] search_node = (Chain_Node *) search_thread; next_node = search_node->next; the_node = (Chain_Node *) the_thread; the_node->next = next_node; 20083f0: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = search_node; search_node->next = the_node; next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; 20083f4: ec 26 60 44 st %l6, [ %i1 + 0x44 ] the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; search_node->next = the_node; next_node->previous = the_node; 20083f8: f2 20 60 04 st %i1, [ %g1 + 4 ] next_node = search_node->next; the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; search_node->next = the_node; 20083fc: f2 24 00 00 st %i1, [ %l0 ] next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2008400: 7f ff e6 7d call 2001df4 2008404: 01 00 00 00 nop 2008408: 81 c7 e0 08 ret 200840c: 81 e8 00 00 restore THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( priority == search_priority ) 2008410: 02 80 00 0c be 2008440 <_Thread_queue_Enqueue_priority+0x220> 2008414: c0 25 a0 30 clr [ %l6 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 2008418: c2 04 20 04 ld [ %l0 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 200841c: e0 26 40 00 st %l0, [ %i1 ] the_node->previous = previous_node; 2008420: c2 26 60 04 st %g1, [ %i1 + 4 ] previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; 2008424: ec 26 60 44 st %l6, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 2008428: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 200842c: f2 24 20 04 st %i1, [ %l0 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2008430: 7f ff e6 71 call 2001df4 2008434: 90 10 00 14 mov %l4, %o0 2008438: 81 c7 e0 08 ret 200843c: 81 e8 00 00 restore 2008440: 82 04 20 3c add %l0, 0x3c, %g1 _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 2008444: c4 00 60 04 ld [ %g1 + 4 ], %g2 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 2008448: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = previous_node; 200844c: c4 26 60 04 st %g2, [ %i1 + 4 ] previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; 2008450: ec 26 60 44 st %l6, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 2008454: f2 20 80 00 st %i1, [ %g2 ] search_node->previous = the_node; 2008458: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 200845c: 7f ff e6 66 call 2001df4 2008460: b0 10 20 01 mov 1, %i0 2008464: 81 c7 e0 08 ret 2008468: 81 e8 00 00 restore if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 200846c: 7f ff e6 62 call 2001df4 <== NOT EXECUTED 2008470: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 2008474: 30 bf ff 7d b,a 2008268 <_Thread_queue_Enqueue_priority+0x48><== NOT EXECUTED if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 2008478: 7f ff e6 5f call 2001df4 <== NOT EXECUTED 200847c: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 2008480: 10 bf ff aa b 2008328 <_Thread_queue_Enqueue_priority+0x108><== NOT EXECUTED 2008484: c2 0d c0 00 ldub [ %l7 ], %g1 <== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 2008488: 10 bf ff 9a b 20082f0 <_Thread_queue_Enqueue_priority+0xd0> 200848c: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0 =============================================================================== 0200d994 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200d994: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 200d998: 7f ff d1 13 call 2001de4 200d99c: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200d9a0: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200d9a4: 03 00 00 ef sethi %hi(0x3bc00), %g1 200d9a8: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200d9ac: 80 88 80 01 btst %g2, %g1 200d9b0: 02 80 00 19 be 200da14 <_Thread_queue_Extract_fifo+0x80> <== NEVER TAKEN 200d9b4: 01 00 00 00 nop ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 200d9b8: c2 06 40 00 ld [ %i1 ], %g1 previous = the_node->previous; 200d9bc: c4 06 60 04 ld [ %i1 + 4 ], %g2 _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 200d9c0: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 next->previous = previous; previous->next = next; 200d9c4: c2 20 80 00 st %g1, [ %g2 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200d9c8: c4 20 60 04 st %g2, [ %g1 + 4 ] 200d9cc: 80 a0 e0 02 cmp %g3, 2 200d9d0: 02 80 00 07 be 200d9ec <_Thread_queue_Extract_fifo+0x58> 200d9d4: c0 26 60 44 clr [ %i1 + 0x44 ] _ISR_Enable( level ); 200d9d8: 7f ff d1 07 call 2001df4 200d9dc: 33 04 00 ff sethi %hi(0x1003fc00), %i1 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 200d9e0: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200d9e4: 7f ff e7 72 call 20077ac <_Thread_Clear_state> 200d9e8: 81 e8 00 00 restore 200d9ec: 82 10 20 03 mov 3, %g1 200d9f0: c2 26 60 50 st %g1, [ %i1 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200d9f4: 7f ff d1 00 call 2001df4 200d9f8: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 200d9fc: 7f ff ed a6 call 2009094 <_Watchdog_Remove> 200da00: 90 06 60 48 add %i1, 0x48, %o0 200da04: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200da08: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200da0c: 7f ff e7 68 call 20077ac <_Thread_Clear_state> 200da10: 81 e8 00 00 restore ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 200da14: 7f ff d0 f8 call 2001df4 <== NOT EXECUTED 200da18: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED =============================================================================== 0200c798 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, bool requeuing ) { 200c798: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *new_first_node; Chain_Node *new_second_node; Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); 200c79c: 7f ff d5 92 call 2001de4 200c7a0: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200c7a4: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200c7a8: 03 00 00 ef sethi %hi(0x3bc00), %g1 200c7ac: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200c7b0: 80 88 80 01 btst %g2, %g1 200c7b4: 02 80 00 23 be 200c840 <_Thread_queue_Extract_priority_helper+0xa8><== NEVER TAKEN 200c7b8: 82 06 60 3c add %i1, 0x3c, %g1 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 200c7bc: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 200c7c0: c4 06 40 00 ld [ %i1 ], %g2 previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 200c7c4: 80 a0 c0 01 cmp %g3, %g1 200c7c8: 02 80 00 2a be 200c870 <_Thread_queue_Extract_priority_helper+0xd8> 200c7cc: c2 06 60 04 ld [ %i1 + 4 ], %g1 new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 200c7d0: da 06 60 40 ld [ %i1 + 0x40 ], %o5 new_second_node = new_first_node->next; 200c7d4: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 200c7d8: c6 20 a0 04 st %g3, [ %g2 + 4 ] new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; new_second_node = new_first_node->next; previous_node->next = new_first_node; 200c7dc: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 200c7e0: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 200c7e4: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 200c7e8: c4 06 60 38 ld [ %i1 + 0x38 ], %g2 200c7ec: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 200c7f0: 80 a0 80 01 cmp %g2, %g1 200c7f4: 02 80 00 07 be 200c810 <_Thread_queue_Extract_priority_helper+0x78> 200c7f8: 82 00 e0 38 add %g3, 0x38, %g1 /* > two threads on 2-n */ new_second_node->previous = 200c7fc: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 200c800: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] new_first_thread->Wait.Block2n.last = last_node; 200c804: da 20 e0 40 st %o5, [ %g3 + 0x40 ] last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 200c808: 82 00 e0 3c add %g3, 0x3c, %g1 200c80c: c2 23 40 00 st %g1, [ %o5 ] /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 200c810: 80 8e a0 ff btst 0xff, %i2 200c814: 12 80 00 0d bne 200c848 <_Thread_queue_Extract_priority_helper+0xb0> 200c818: 01 00 00 00 nop _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 200c81c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 200c820: 80 a0 60 02 cmp %g1, 2 200c824: 02 80 00 0b be 200c850 <_Thread_queue_Extract_priority_helper+0xb8> 200c828: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 200c82c: 7f ff d5 72 call 2001df4 200c830: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200c834: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200c838: 7f ff eb dd call 20077ac <_Thread_Clear_state> 200c83c: 81 e8 00 00 restore Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 200c840: 7f ff d5 6d call 2001df4 <== NOT EXECUTED 200c844: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { _ISR_Enable( level ); 200c848: 7f ff d5 6b call 2001df4 200c84c: 91 e8 00 08 restore %g0, %o0, %o0 200c850: c2 26 20 50 st %g1, [ %i0 + 0x50 ] if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200c854: 7f ff d5 68 call 2001df4 200c858: 33 04 00 ff sethi %hi(0x1003fc00), %i1 (void) _Watchdog_Remove( &the_thread->Timer ); 200c85c: 7f ff f2 0e call 2009094 <_Watchdog_Remove> 200c860: 90 06 20 48 add %i0, 0x48, %o0 200c864: b2 16 63 f8 or %i1, 0x3f8, %i1 200c868: 7f ff eb d1 call 20077ac <_Thread_Clear_state> 200c86c: 81 e8 00 00 restore new_first_thread->Wait.Block2n.last = last_node; last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; next_node->previous = previous_node; 200c870: c2 20 a0 04 st %g1, [ %g2 + 4 ] new_first_thread->Wait.Block2n.last = last_node; last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; 200c874: 10 bf ff e7 b 200c810 <_Thread_queue_Extract_priority_helper+0x78> 200c878: c4 20 40 00 st %g2, [ %g1 ] =============================================================================== 0200c87c <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 200c87c: 92 10 00 08 mov %o0, %o1 Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 200c880: d0 02 20 44 ld [ %o0 + 0x44 ], %o0 * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && 200c884: c6 02 20 30 ld [ %o0 + 0x30 ], %g3 200c888: 80 a0 e0 00 cmp %g3, 0 200c88c: 02 80 00 06 be 200c8a4 <_Thread_queue_Process_timeout+0x28> 200c890: 03 00 80 60 sethi %hi(0x2018000), %g1 200c894: c4 00 63 d4 ld [ %g1 + 0x3d4 ], %g2 ! 20183d4 <_Thread_Executing> 200c898: 80 a2 40 02 cmp %o1, %g2 200c89c: 02 80 00 07 be 200c8b8 <_Thread_queue_Process_timeout+0x3c><== ALWAYS TAKEN 200c8a0: 80 a0 e0 03 cmp %g3, 3 if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 200c8a4: c2 02 20 3c ld [ %o0 + 0x3c ], %g1 200c8a8: c2 22 60 34 st %g1, [ %o1 + 0x34 ] _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 200c8ac: 82 13 c0 00 mov %o7, %g1 200c8b0: 7f ff ff af call 200c76c <_Thread_queue_Extract> 200c8b4: 9e 10 40 00 mov %g1, %o7 * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 200c8b8: 02 80 00 06 be 200c8d0 <_Thread_queue_Process_timeout+0x54><== NEVER TAKEN 200c8bc: 84 10 20 02 mov 2, %g2 the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 200c8c0: c2 02 20 3c ld [ %o0 + 0x3c ], %g1 200c8c4: c2 22 60 34 st %g1, [ %o1 + 0x34 ] the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 200c8c8: 81 c3 e0 08 retl 200c8cc: c4 22 20 30 st %g2, [ %o0 + 0x30 ] 200c8d0: 81 c3 e0 08 retl <== NOT EXECUTED =============================================================================== 02008560 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 2008560: 9d e3 bf 90 save %sp, -112, %sp /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 2008564: 80 a6 20 00 cmp %i0, 0 2008568: 02 80 00 13 be 20085b4 <_Thread_queue_Requeue+0x54> <== NEVER TAKEN 200856c: 01 00 00 00 nop /* * If queueing by FIFO, there is nothing to do. This only applies to * priority blocking discipline. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 2008570: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 2008574: 80 a4 20 01 cmp %l0, 1 2008578: 02 80 00 04 be 2008588 <_Thread_queue_Requeue+0x28> <== ALWAYS TAKEN 200857c: 01 00 00 00 nop 2008580: 81 c7 e0 08 ret <== NOT EXECUTED 2008584: 81 e8 00 00 restore <== NOT EXECUTED Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 2008588: 7f ff e6 17 call 2001de4 200858c: 01 00 00 00 nop 2008590: a2 10 00 08 mov %o0, %l1 if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 2008594: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 2008598: 03 00 00 ef sethi %hi(0x3bc00), %g1 200859c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 20085a0: 80 88 80 01 btst %g2, %g1 20085a4: 12 80 00 06 bne 20085bc <_Thread_queue_Requeue+0x5c> <== ALWAYS TAKEN 20085a8: 90 10 00 18 mov %i0, %o0 _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); 20085ac: 7f ff e6 12 call 2001df4 20085b0: 90 10 00 11 mov %l1, %o0 20085b4: 81 c7 e0 08 ret 20085b8: 81 e8 00 00 restore ISR_Level level_ignored; _ISR_Disable( level ); if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 20085bc: 92 10 00 19 mov %i1, %o1 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 20085c0: e0 26 20 30 st %l0, [ %i0 + 0x30 ] 20085c4: 40 00 10 75 call 200c798 <_Thread_queue_Extract_priority_helper> 20085c8: 94 10 20 01 mov 1, %o2 (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 20085cc: 90 10 00 18 mov %i0, %o0 20085d0: 92 10 00 19 mov %i1, %o1 20085d4: 7f ff ff 13 call 2008220 <_Thread_queue_Enqueue_priority> 20085d8: 94 07 bf f4 add %fp, -12, %o2 20085dc: 30 bf ff f4 b,a 20085ac <_Thread_queue_Requeue+0x4c> =============================================================================== 020085e0 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 20085e0: 9d e3 bf 90 save %sp, -112, %sp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 20085e4: 90 10 00 18 mov %i0, %o0 20085e8: 7f ff fd 98 call 2007c48 <_Thread_Get> 20085ec: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 20085f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20085f4: 80 a0 60 00 cmp %g1, 0 20085f8: 12 80 00 08 bne 2008618 <_Thread_queue_Timeout+0x38> <== NEVER TAKEN 20085fc: 01 00 00 00 nop #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 2008600: 40 00 10 9f call 200c87c <_Thread_queue_Process_timeout> 2008604: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2008608: 05 00 80 60 sethi %hi(0x2018000), %g2 200860c: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2018310 <_Thread_Dispatch_disable_level> 2008610: 82 00 7f ff add %g1, -1, %g1 2008614: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] 2008618: 81 c7 e0 08 ret 200861c: 81 e8 00 00 restore =============================================================================== 02011c4c <_Timer_Server_body>: * @param[in] ignored is the the task argument that is ignored */ Thread _Timer_Server_body( uint32_t ignored ) { 2011c4c: 9d e3 bf 88 save %sp, -120, %sp 2011c50: 05 00 80 c8 sethi %hi(0x2032000), %g2 /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 2011c54: 19 00 80 c8 sethi %hi(0x2032000), %o4 2011c58: c6 03 23 e4 ld [ %o4 + 0x3e4 ], %g3 ! 20323e4 <_Watchdog_Ticks_since_boot> 2011c5c: c2 00 a2 90 ld [ %g2 + 0x290 ], %g1 _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2011c60: 17 00 80 c8 sethi %hi(0x2032000), %o3 2011c64: c8 02 e3 24 ld [ %o3 + 0x324 ], %g4 ! 2032324 <_TOD_Now> 2011c68: 82 00 60 01 inc %g1 /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 2011c6c: 1b 00 80 c8 sethi %hi(0x2032000), %o5 2011c70: c2 20 a2 90 st %g1, [ %g2 + 0x290 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2011c74: a2 07 bf ec add %fp, -20, %l1 _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2011c78: 03 00 80 c8 sethi %hi(0x2032000), %g1 2011c7c: a4 07 bf f0 add %fp, -16, %l2 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2011c80: c0 27 bf f0 clr [ %fp + -16 ] /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 2011c84: c6 23 61 94 st %g3, [ %o5 + 0x194 ] _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2011c88: c8 20 61 90 st %g4, [ %g1 + 0x190 ] the_chain->last = _Chain_Head(the_chain); 2011c8c: e2 27 bf f4 st %l1, [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2011c90: e4 27 bf ec st %l2, [ %fp + -20 ] /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 2011c94: b0 13 23 e4 or %o4, 0x3e4, %i0 2011c98: ac 13 61 94 or %o5, 0x194, %l6 _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2011c9c: ae 10 61 90 or %g1, 0x190, %l7 2011ca0: b6 12 e3 24 or %o3, 0x324, %i3 2011ca4: a6 10 a2 90 or %g2, 0x290, %l3 /* * Insert the timers that were inserted before we got to run. * This should be done with dispatching disabled. */ _Thread_Disable_dispatch(); _Timer_Server_process_insertions(); 2011ca8: 7f ff ff c3 call 2011bb4 <_Timer_Server_process_insertions> 2011cac: 01 00 00 00 nop _Thread_Enable_dispatch(); 2011cb0: 40 00 0c 15 call 2014d04 <_Thread_Enable_dispatch> 2011cb4: 01 00 00 00 nop 2011cb8: 03 00 80 c8 sethi %hi(0x2032000), %g1 2011cbc: b8 10 61 88 or %g1, 0x188, %i4 ! 2032188 <_Timer_Ticks_chain+0x4> 2011cc0: 03 00 80 cb sethi %hi(0x2032c00), %g1 2011cc4: 05 00 80 c8 sethi %hi(0x2032000), %g2 2011cc8: a8 10 60 40 or %g1, 0x40, %l4 2011ccc: ba 10 a1 9c or %g2, 0x19c, %i5 2011cd0: 03 00 80 c8 sethi %hi(0x2032000), %g1 2011cd4: b4 07 3f fc add %i4, -4, %i2 2011cd8: b2 07 7f fc add %i5, -4, %i1 2011cdc: aa 10 61 b0 or %g1, 0x1b0, %l5 2011ce0: c2 04 c0 00 ld [ %l3 ], %g1 2011ce4: 82 00 60 01 inc %g1 2011ce8: c2 24 c0 00 st %g1, [ %l3 ] /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 2011cec: d0 05 00 00 ld [ %l4 ], %o0 2011cf0: 40 00 0f 09 call 2015914 <_Thread_Set_state> 2011cf4: 92 10 20 08 mov 8, %o1 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2011cf8: c2 06 80 00 ld [ %i2 ], %g1 _Timer_Server_reset_ticks_timer(); 2011cfc: 80 a0 40 1c cmp %g1, %i4 2011d00: 02 80 00 0a be 2011d28 <_Timer_Server_body+0xdc> 2011d04: 05 00 80 cb sethi %hi(0x2032c00), %g2 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2011d08: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 2011d0c: 84 10 a0 40 or %g2, 0x40, %g2 2011d10: d2 00 80 00 ld [ %g2 ], %o1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2011d14: 11 00 80 c8 sethi %hi(0x2032000), %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2011d18: c2 22 60 54 st %g1, [ %o1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2011d1c: 90 12 23 74 or %o0, 0x374, %o0 2011d20: 40 00 12 18 call 2016580 <_Watchdog_Insert> 2011d24: 92 02 60 48 add %o1, 0x48, %o1 2011d28: c2 06 40 00 ld [ %i1 ], %g1 _Timer_Server_reset_seconds_timer(); 2011d2c: 80 a0 40 1d cmp %g1, %i5 2011d30: 02 80 00 08 be 2011d50 <_Timer_Server_body+0x104> 2011d34: 01 00 00 00 nop Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2011d38: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2011d3c: 11 00 80 c8 sethi %hi(0x2032000), %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2011d40: c2 25 60 0c st %g1, [ %l5 + 0xc ] _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2011d44: 90 12 23 68 or %o0, 0x368, %o0 2011d48: 40 00 12 0e call 2016580 <_Watchdog_Insert> 2011d4c: 92 10 00 15 mov %l5, %o1 _Thread_Enable_dispatch(); 2011d50: 40 00 0b ed call 2014d04 <_Thread_Enable_dispatch> 2011d54: 01 00 00 00 nop 2011d58: c2 04 c0 00 ld [ %l3 ], %g1 2011d5c: 82 00 60 01 inc %g1 2011d60: c2 24 c0 00 st %g1, [ %l3 ] /* * At this point, at least one of the timers this task relies * upon has fired. Stop them both while we process any outstanding * timers. Before we block, we will restart them. */ _Timer_Server_stop_ticks_timer(); 2011d64: d0 05 00 00 ld [ %l4 ], %o0 2011d68: 40 00 12 71 call 201672c <_Watchdog_Remove> 2011d6c: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_stop_seconds_timer(); 2011d70: 11 00 80 c8 sethi %hi(0x2032000), %o0 2011d74: 40 00 12 6e call 201672c <_Watchdog_Remove> 2011d78: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 20321b0 <_Timer_Seconds_timer> ) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 2011d7c: c6 06 00 00 ld [ %i0 ], %g3 if ( snapshot >= _Timer_Server_ticks_last_time ) 2011d80: c4 05 80 00 ld [ %l6 ], %g2 ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 2011d84: 82 38 00 02 xnor %g0, %g2, %g1 { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; if ( snapshot >= _Timer_Server_ticks_last_time ) 2011d88: 80 a0 c0 02 cmp %g3, %g2 2011d8c: 0a 80 00 03 bcs 2011d98 <_Timer_Server_body+0x14c> <== NEVER TAKEN 2011d90: 92 00 40 03 add %g1, %g3, %o1 ticks = snapshot - _Timer_Server_ticks_last_time; 2011d94: 92 20 c0 02 sub %g3, %g2, %o1 else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; _Timer_Server_ticks_last_time = snapshot; _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire ); 2011d98: 94 10 00 11 mov %l1, %o2 if ( snapshot >= _Timer_Server_ticks_last_time ) ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; _Timer_Server_ticks_last_time = snapshot; 2011d9c: c6 25 80 00 st %g3, [ %l6 ] _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire ); 2011da0: 11 00 80 c8 sethi %hi(0x2032000), %o0 2011da4: 40 00 11 c3 call 20164b0 <_Watchdog_Adjust_to_chain> 2011da8: 90 12 21 84 or %o0, 0x184, %o0 ! 2032184 <_Timer_Ticks_chain> * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the _Timer_Seconds_chain to indicate this. */ snapshot = _TOD_Seconds_since_epoch; if ( snapshot > _Timer_Server_seconds_last_time ) { 2011dac: d4 05 c0 00 ld [ %l7 ], %o2 /* * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the _Timer_Seconds_chain to indicate this. */ snapshot = _TOD_Seconds_since_epoch; 2011db0: e0 06 c0 00 ld [ %i3 ], %l0 if ( snapshot > _Timer_Server_seconds_last_time ) { 2011db4: 80 a4 00 0a cmp %l0, %o2 2011db8: 18 80 00 1b bgu 2011e24 <_Timer_Server_body+0x1d8> 2011dbc: 92 24 00 0a sub %l0, %o2, %o1 * TOD has been set forward. */ ticks = snapshot - _Timer_Server_seconds_last_time; _Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire ); } else if ( snapshot < _Timer_Server_seconds_last_time ) { 2011dc0: 0a 80 00 1e bcs 2011e38 <_Timer_Server_body+0x1ec> 2011dc4: 94 22 80 10 sub %o2, %l0, %o2 _Timer_Server_process_seconds_chain( &to_fire ); /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 2011dc8: 7f ff ff 7b call 2011bb4 <_Timer_Server_process_insertions> 2011dcc: e0 25 c0 00 st %l0, [ %l7 ] /* * Enable dispatching to process the set that are ready "to fire." */ _Thread_Enable_dispatch(); 2011dd0: 40 00 0b cd call 2014d04 <_Thread_Enable_dispatch> 2011dd4: 01 00 00 00 nop 2011dd8: 30 80 00 0a b,a 2011e00 <_Timer_Server_body+0x1b4> if ( watch == NULL ) { _ISR_Enable( level ); break; } watch->state = WATCHDOG_INACTIVE; 2011ddc: c0 24 20 08 clr [ %l0 + 8 ] Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; 2011de0: c2 27 bf ec st %g1, [ %fp + -20 ] new_first->previous = _Chain_Head(the_chain); 2011de4: e2 20 60 04 st %l1, [ %g1 + 4 ] _ISR_Enable( level ); 2011de8: 7f ff e5 27 call 200b284 2011dec: 01 00 00 00 nop (*watch->routine)( watch->id, watch->user_data ); 2011df0: d2 04 20 24 ld [ %l0 + 0x24 ], %o1 2011df4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 2011df8: 9f c0 40 00 call %g1 2011dfc: d0 04 20 20 ld [ %l0 + 0x20 ], %o0 */ while (1) { Watchdog_Control *watch; ISR_Level level; _ISR_Disable( level ); 2011e00: 7f ff e5 1d call 200b274 2011e04: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2011e08: e0 07 bf ec ld [ %fp + -20 ], %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 2011e0c: 80 a4 80 10 cmp %l2, %l0 2011e10: 32 bf ff f3 bne,a 2011ddc <_Timer_Server_body+0x190> 2011e14: c2 04 00 00 ld [ %l0 ], %g1 watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire ); if ( watch == NULL ) { _ISR_Enable( level ); 2011e18: 7f ff e5 1b call 200b284 2011e1c: 01 00 00 00 nop 2011e20: 30 bf ff b0 b,a 2011ce0 <_Timer_Server_body+0x94> /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ ticks = snapshot - _Timer_Server_seconds_last_time; _Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire ); 2011e24: 11 00 80 c8 sethi %hi(0x2032000), %o0 2011e28: 94 10 00 11 mov %l1, %o2 2011e2c: 40 00 11 a1 call 20164b0 <_Watchdog_Adjust_to_chain> 2011e30: 90 12 21 98 or %o0, 0x198, %o0 2011e34: 30 bf ff e5 b,a 2011dc8 <_Timer_Server_body+0x17c> /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ ticks = _Timer_Server_seconds_last_time - snapshot; _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks ); 2011e38: 11 00 80 c8 sethi %hi(0x2032000), %o0 2011e3c: 92 10 20 01 mov 1, %o1 2011e40: 40 00 11 6c call 20163f0 <_Watchdog_Adjust> 2011e44: 90 12 21 98 or %o0, 0x198, %o0 2011e48: 30 bf ff e0 b,a 2011dc8 <_Timer_Server_body+0x17c> =============================================================================== 02011bb4 <_Timer_Server_process_insertions>: * onto one of the Timer Server chains. * * @note It is only to be called from the Timer Server task. */ static void _Timer_Server_process_insertions(void) { 2011bb4: 9d e3 bf 98 save %sp, -104, %sp 2011bb8: 03 00 80 c8 sethi %hi(0x2032000), %g1 break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker ); 2011bbc: 05 00 80 c8 sethi %hi(0x2032000), %g2 static void _Timer_Server_process_insertions(void) { Timer_Control *the_timer; while ( 1 ) { the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted ); 2011bc0: a0 10 61 a4 or %g1, 0x1a4, %l0 if ( the_timer == NULL ) break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 2011bc4: 03 00 80 c8 sethi %hi(0x2032000), %g1 } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker ); 2011bc8: a4 10 a1 98 or %g2, 0x198, %l2 the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted ); if ( the_timer == NULL ) break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 2011bcc: a2 10 61 84 or %g1, 0x184, %l1 static void _Timer_Server_process_insertions(void) { Timer_Control *the_timer; while ( 1 ) { the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted ); 2011bd0: 40 00 02 ca call 20126f8 <_Chain_Get> 2011bd4: 90 10 00 10 mov %l0, %o0 if ( the_timer == NULL ) 2011bd8: 80 a2 20 00 cmp %o0, 0 2011bdc: 02 80 00 0f be 2011c18 <_Timer_Server_process_insertions+0x64> 2011be0: 01 00 00 00 nop break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 2011be4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 2011be8: 80 a0 60 01 cmp %g1, 1 2011bec: 02 80 00 12 be 2011c34 <_Timer_Server_process_insertions+0x80> 2011bf0: 80 a0 60 03 cmp %g1, 3 _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 2011bf4: 02 80 00 0b be 2011c20 <_Timer_Server_process_insertions+0x6c><== ALWAYS TAKEN 2011bf8: 92 02 20 10 add %o0, 0x10, %o1 } /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 2011bfc: 7f ff ff ee call 2011bb4 <_Timer_Server_process_insertions><== NOT EXECUTED 2011c00: 01 00 00 00 nop <== NOT EXECUTED static void _Timer_Server_process_insertions(void) { Timer_Control *the_timer; while ( 1 ) { the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted ); 2011c04: 40 00 02 bd call 20126f8 <_Chain_Get> 2011c08: 90 10 00 10 mov %l0, %o0 if ( the_timer == NULL ) 2011c0c: 80 a2 20 00 cmp %o0, 0 2011c10: 32 bf ff f6 bne,a 2011be8 <_Timer_Server_process_insertions+0x34><== NEVER TAKEN 2011c14: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 <== NOT EXECUTED 2011c18: 81 c7 e0 08 ret 2011c1c: 81 e8 00 00 restore break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker ); 2011c20: 40 00 12 58 call 2016580 <_Watchdog_Insert> 2011c24: 90 10 00 12 mov %l2, %o0 } /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 2011c28: 7f ff ff e3 call 2011bb4 <_Timer_Server_process_insertions> 2011c2c: 01 00 00 00 nop 2011c30: 30 bf ff f5 b,a 2011c04 <_Timer_Server_process_insertions+0x50> the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted ); if ( the_timer == NULL ) break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 2011c34: 92 02 20 10 add %o0, 0x10, %o1 2011c38: 40 00 12 52 call 2016580 <_Watchdog_Insert> 2011c3c: 90 10 00 11 mov %l1, %o0 } /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 2011c40: 7f ff ff dd call 2011bb4 <_Timer_Server_process_insertions> 2011c44: 01 00 00 00 nop 2011c48: 30 bf ff ef b,a 2011c04 <_Timer_Server_process_insertions+0x50> =============================================================================== 0200a798 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 200a798: 9d e3 bf 98 save %sp, -104, %sp * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 200a79c: c2 06 40 00 ld [ %i1 ], %g1 right += rhs->tv_nsec; 200a7a0: de 06 60 04 ld [ %i1 + 4 ], %o7 * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 200a7a4: 91 38 60 1f sra %g1, 0x1f, %o0 200a7a8: 92 10 00 01 mov %g1, %o1 200a7ac: 83 30 60 1d srl %g1, 0x1d, %g1 200a7b0: 87 2a 60 03 sll %o1, 3, %g3 200a7b4: 85 2a 20 03 sll %o0, 3, %g2 200a7b8: 84 10 40 02 or %g1, %g2, %g2 200a7bc: 83 30 e0 1b srl %g3, 0x1b, %g1 200a7c0: 99 28 a0 05 sll %g2, 5, %o4 200a7c4: 9b 28 e0 05 sll %g3, 5, %o5 200a7c8: 98 10 40 0c or %g1, %o4, %o4 200a7cc: 9a a3 40 03 subcc %o5, %g3, %o5 200a7d0: 83 33 60 1a srl %o5, 0x1a, %g1 200a7d4: 98 63 00 02 subx %o4, %g2, %o4 200a7d8: 97 2b 60 06 sll %o5, 6, %o3 200a7dc: 95 2b 20 06 sll %o4, 6, %o2 200a7e0: 96 a2 c0 0d subcc %o3, %o5, %o3 200a7e4: 94 10 40 0a or %g1, %o2, %o2 200a7e8: 94 62 80 0c subx %o2, %o4, %o2 200a7ec: 96 82 c0 09 addcc %o3, %o1, %o3 200a7f0: 94 42 80 08 addx %o2, %o0, %o2 200a7f4: 83 32 e0 1e srl %o3, 0x1e, %g1 200a7f8: 85 2a a0 02 sll %o2, 2, %g2 200a7fc: 84 10 40 02 or %g1, %g2, %g2 200a800: 87 2a e0 02 sll %o3, 2, %g3 200a804: 96 82 c0 03 addcc %o3, %g3, %o3 200a808: 94 42 80 02 addx %o2, %g2, %o2 200a80c: 83 32 e0 1e srl %o3, 0x1e, %g1 200a810: 85 2a a0 02 sll %o2, 2, %g2 200a814: 84 10 40 02 or %g1, %g2, %g2 200a818: 87 2a e0 02 sll %o3, 2, %g3 200a81c: 96 82 c0 03 addcc %o3, %g3, %o3 200a820: 94 42 80 02 addx %o2, %g2, %o2 200a824: 83 32 e0 1e srl %o3, 0x1e, %g1 200a828: 85 2a a0 02 sll %o2, 2, %g2 200a82c: 84 10 40 02 or %g1, %g2, %g2 200a830: 87 2a e0 02 sll %o3, 2, %g3 200a834: 96 82 c0 03 addcc %o3, %g3, %o3 200a838: 94 42 80 02 addx %o2, %g2, %o2 200a83c: 85 32 e0 17 srl %o3, 0x17, %g2 200a840: 83 2a a0 09 sll %o2, 9, %g1 200a844: 9b 2a e0 09 sll %o3, 9, %o5 200a848: 98 10 80 01 or %g2, %g1, %o4 right += rhs->tv_nsec; 200a84c: 96 83 40 0f addcc %o5, %o7, %o3 200a850: 85 3b e0 1f sra %o7, 0x1f, %g2 /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; 200a854: e4 06 20 04 ld [ %i0 + 4 ], %l2 right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec; 200a858: 94 43 00 02 addx %o4, %g2, %o2 if ( right == 0 ) { 200a85c: 80 92 80 0b orcc %o2, %o3, %g0 200a860: 02 80 00 5d be 200a9d4 <_Timespec_Divide+0x23c> <== NEVER TAKEN 200a864: d0 06 00 00 ld [ %i0 ], %o0 /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 200a868: 92 10 00 08 mov %o0, %o1 200a86c: 83 32 60 1d srl %o1, 0x1d, %g1 200a870: 9b 2a 60 03 sll %o1, 3, %o5 200a874: 91 3a 20 1f sra %o0, 0x1f, %o0 200a878: 99 2a 20 03 sll %o0, 3, %o4 200a87c: 98 10 40 0c or %g1, %o4, %o4 200a880: 83 33 60 1b srl %o5, 0x1b, %g1 200a884: 85 2b 20 05 sll %o4, 5, %g2 200a888: 87 2b 60 05 sll %o5, 5, %g3 200a88c: 84 10 40 02 or %g1, %g2, %g2 200a890: 86 a0 c0 0d subcc %g3, %o5, %g3 200a894: 83 30 e0 1a srl %g3, 0x1a, %g1 200a898: 84 60 80 0c subx %g2, %o4, %g2 200a89c: 9b 28 e0 06 sll %g3, 6, %o5 200a8a0: 99 28 a0 06 sll %g2, 6, %o4 200a8a4: 9a a3 40 03 subcc %o5, %g3, %o5 200a8a8: 98 10 40 0c or %g1, %o4, %o4 200a8ac: 98 63 00 02 subx %o4, %g2, %o4 200a8b0: 9a 83 40 09 addcc %o5, %o1, %o5 200a8b4: 83 33 60 1e srl %o5, 0x1e, %g1 200a8b8: 98 43 00 08 addx %o4, %o0, %o4 200a8bc: 87 2b 60 02 sll %o5, 2, %g3 200a8c0: 85 2b 20 02 sll %o4, 2, %g2 200a8c4: 9a 83 40 03 addcc %o5, %g3, %o5 200a8c8: 84 10 40 02 or %g1, %g2, %g2 200a8cc: 83 33 60 1e srl %o5, 0x1e, %g1 200a8d0: 98 43 00 02 addx %o4, %g2, %o4 200a8d4: 87 2b 60 02 sll %o5, 2, %g3 200a8d8: 85 2b 20 02 sll %o4, 2, %g2 200a8dc: 9a 83 40 03 addcc %o5, %g3, %o5 200a8e0: 84 10 40 02 or %g1, %g2, %g2 200a8e4: 83 33 60 1e srl %o5, 0x1e, %g1 200a8e8: 98 43 00 02 addx %o4, %g2, %o4 200a8ec: 87 2b 60 02 sll %o5, 2, %g3 200a8f0: 85 2b 20 02 sll %o4, 2, %g2 200a8f4: 9a 83 40 03 addcc %o5, %g3, %o5 200a8f8: 84 10 40 02 or %g1, %g2, %g2 200a8fc: 98 43 00 02 addx %o4, %g2, %o4 200a900: 83 2b 20 09 sll %o4, 9, %g1 200a904: 89 33 60 17 srl %o5, 0x17, %g4 * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 200a908: a6 10 00 12 mov %l2, %l3 /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 200a90c: a0 11 00 01 or %g4, %g1, %l0 200a910: a3 2b 60 09 sll %o5, 9, %l1 * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 200a914: a2 84 40 13 addcc %l1, %l3, %l1 200a918: 83 34 60 1e srl %l1, 0x1e, %g1 200a91c: 87 2c 60 02 sll %l1, 2, %g3 200a920: a5 3c a0 1f sra %l2, 0x1f, %l2 200a924: a0 44 00 12 addx %l0, %l2, %l0 200a928: 85 2c 20 02 sll %l0, 2, %g2 200a92c: 84 10 40 02 or %g1, %g2, %g2 200a930: 83 30 e0 1b srl %g3, 0x1b, %g1 200a934: 99 28 a0 05 sll %g2, 5, %o4 200a938: 9b 28 e0 05 sll %g3, 5, %o5 200a93c: 98 10 40 0c or %g1, %o4, %o4 200a940: 9a a3 40 03 subcc %o5, %g3, %o5 200a944: 98 63 00 02 subx %o4, %g2, %o4 200a948: 9a 83 40 11 addcc %o5, %l1, %o5 200a94c: 83 33 60 1e srl %o5, 0x1e, %g1 200a950: 98 43 00 10 addx %o4, %l0, %o4 200a954: 87 2b 60 02 sll %o5, 2, %g3 200a958: 85 2b 20 02 sll %o4, 2, %g2 200a95c: 9a 83 40 03 addcc %o5, %g3, %o5 200a960: 84 10 40 02 or %g1, %g2, %g2 200a964: 83 33 60 1e srl %o5, 0x1e, %g1 200a968: 87 2b 60 02 sll %o5, 2, %g3 200a96c: 98 43 00 02 addx %o4, %g2, %o4 200a970: 9a 83 40 03 addcc %o5, %g3, %o5 200a974: 85 2b 20 02 sll %o4, 2, %g2 200a978: 84 10 40 02 or %g1, %g2, %g2 200a97c: 83 33 60 1b srl %o5, 0x1b, %g1 200a980: 98 43 00 02 addx %o4, %g2, %o4 200a984: 99 2b 20 05 sll %o4, 5, %o4 200a988: 98 10 40 0c or %g1, %o4, %o4 200a98c: 93 2b 60 05 sll %o5, 5, %o1 200a990: 40 00 36 68 call 2018330 <__udivdi3> 200a994: 90 10 00 0c mov %o4, %o0 *ival_percentage = answer / 1000; 200a998: 94 10 20 00 clr %o2 * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 200a99c: a0 10 00 08 mov %o0, %l0 200a9a0: a2 10 00 09 mov %o1, %l1 *ival_percentage = answer / 1000; 200a9a4: 96 10 23 e8 mov 0x3e8, %o3 200a9a8: 40 00 36 62 call 2018330 <__udivdi3> 200a9ac: 90 10 00 10 mov %l0, %o0 *fval_percentage = answer % 1000; 200a9b0: 90 10 00 10 mov %l0, %o0 * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 200a9b4: d2 26 80 00 st %o1, [ %i2 ] *fval_percentage = answer % 1000; 200a9b8: 94 10 20 00 clr %o2 200a9bc: 92 10 00 11 mov %l1, %o1 200a9c0: 40 00 37 38 call 20186a0 <__umoddi3> 200a9c4: 96 10 23 e8 mov 0x3e8, %o3 200a9c8: d2 26 c0 00 st %o1, [ %i3 ] 200a9cc: 81 c7 e0 08 ret 200a9d0: 81 e8 00 00 restore left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec; if ( right == 0 ) { *ival_percentage = 0; 200a9d4: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED *fval_percentage = 0; 200a9d8: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 200a9dc: 81 c7 e0 08 ret <== NOT EXECUTED 200a9e0: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02008d3c <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 2008d3c: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 2008d40: 03 00 80 61 sethi %hi(0x2018400), %g1 2008d44: 82 10 61 48 or %g1, 0x148, %g1 ! 2018548 <_User_extensions_List> 2008d48: e0 00 60 08 ld [ %g1 + 8 ], %l0 !_Chain_Is_head( &_User_extensions_List, the_node ) ; 2008d4c: 80 a4 00 01 cmp %l0, %g1 2008d50: 02 80 00 0e be 2008d88 <_User_extensions_Fatal+0x4c> <== NEVER TAKEN 2008d54: a2 10 00 01 mov %g1, %l1 the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 2008d58: b2 0e 60 ff and %i1, 0xff, %i1 !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 2008d5c: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 2008d60: 80 a0 60 00 cmp %g1, 0 2008d64: 02 80 00 05 be 2008d78 <_User_extensions_Fatal+0x3c> 2008d68: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 2008d6c: 92 10 00 19 mov %i1, %o1 2008d70: 9f c0 40 00 call %g1 2008d74: 94 10 00 1a mov %i2, %o2 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 2008d78: e0 04 20 04 ld [ %l0 + 4 ], %l0 { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 2008d7c: 80 a4 00 11 cmp %l0, %l1 2008d80: 32 bf ff f8 bne,a 2008d60 <_User_extensions_Fatal+0x24> 2008d84: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 2008d88: 81 c7 e0 08 ret 2008d8c: 81 e8 00 00 restore =============================================================================== 02008c04 <_User_extensions_Handler_initialization>: void _User_extensions_Handler_initialization ( uint32_t number_of_extensions, User_extensions_Table *initial_extensions ) { 2008c04: 9d e3 bf 98 save %sp, -104, %sp */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2008c08: 07 00 80 61 sethi %hi(0x2018400), %g3 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2008c0c: 09 00 80 60 sethi %hi(0x2018000), %g4 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2008c10: 84 10 e1 48 or %g3, 0x148, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2008c14: 82 11 23 14 or %g4, 0x314, %g1 2008c18: c4 20 a0 08 st %g2, [ %g2 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2008c1c: c0 20 a0 04 clr [ %g2 + 4 ] the_chain->last = _Chain_Head(the_chain); 2008c20: c2 20 60 08 st %g1, [ %g1 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2008c24: c0 20 60 04 clr [ %g1 + 4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2008c28: 84 00 a0 04 add %g2, 4, %g2 2008c2c: 82 00 60 04 add %g1, 4, %g1 2008c30: c4 20 e1 48 st %g2, [ %g3 + 0x148 ] uint32_t i; _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 2008c34: 80 a6 60 00 cmp %i1, 0 2008c38: 02 80 00 18 be 2008c98 <_User_extensions_Handler_initialization+0x94> 2008c3c: c2 21 23 14 st %g1, [ %g4 + 0x314 ] extension = (User_extensions_Control *) 2008c40: 83 2e 20 02 sll %i0, 2, %g1 2008c44: a1 2e 20 04 sll %i0, 4, %l0 2008c48: a0 24 00 01 sub %l0, %g1, %l0 2008c4c: a0 04 00 18 add %l0, %i0, %l0 2008c50: a1 2c 20 02 sll %l0, 2, %l0 2008c54: 40 00 01 7f call 2009250 <_Workspace_Allocate_or_fatal_error> 2008c58: 90 10 00 10 mov %l0, %o0 _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 2008c5c: 94 10 00 10 mov %l0, %o2 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { extension = (User_extensions_Control *) 2008c60: a2 10 00 08 mov %o0, %l1 _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 2008c64: 40 00 15 d6 call 200e3bc 2008c68: 92 10 20 00 clr %o1 extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 2008c6c: 80 a6 20 00 cmp %i0, 0 2008c70: 02 80 00 0a be 2008c98 <_User_extensions_Handler_initialization+0x94><== NEVER TAKEN 2008c74: a0 10 20 00 clr %l0 _User_extensions_Add_set (extension, &initial_extensions[i]); 2008c78: 90 10 00 11 mov %l1, %o0 2008c7c: 40 00 0f bb call 200cb68 <_User_extensions_Add_set> 2008c80: 92 10 00 19 mov %i1, %o1 extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 2008c84: a0 04 20 01 inc %l0 _User_extensions_Add_set (extension, &initial_extensions[i]); extension++; 2008c88: a2 04 60 34 add %l1, 0x34, %l1 extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 2008c8c: 80 a6 00 10 cmp %i0, %l0 2008c90: 18 bf ff fa bgu 2008c78 <_User_extensions_Handler_initialization+0x74> 2008c94: b2 06 60 20 add %i1, 0x20, %i1 2008c98: 81 c7 e0 08 ret 2008c9c: 81 e8 00 00 restore =============================================================================== 0200ae00 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 200ae00: 9d e3 bf 98 save %sp, -104, %sp _Chain_Extract( &the_extension->Node ); 200ae04: 40 00 0d 1e call 200e27c <_Chain_Extract> 200ae08: 90 10 00 18 mov %i0, %o0 /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 200ae0c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 200ae10: 80 a0 60 00 cmp %g1, 0 200ae14: 02 80 00 04 be 200ae24 <_User_extensions_Remove_set+0x24> <== ALWAYS TAKEN 200ae18: 01 00 00 00 nop _Chain_Extract( &the_extension->Switch.Node ); 200ae1c: 40 00 0d 18 call 200e27c <_Chain_Extract> <== NOT EXECUTED 200ae20: 91 ee 20 08 restore %i0, 8, %o0 <== NOT EXECUTED 200ae24: 81 c7 e0 08 ret 200ae28: 81 e8 00 00 restore =============================================================================== 02008ca0 <_User_extensions_Thread_begin>: */ void _User_extensions_Thread_begin ( Thread_Control *executing ) { 2008ca0: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 2008ca4: 03 00 80 61 sethi %hi(0x2018400), %g1 2008ca8: e0 00 61 48 ld [ %g1 + 0x148 ], %l0 ! 2018548 <_User_extensions_List> 2008cac: 82 10 61 48 or %g1, 0x148, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2008cb0: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 2008cb4: 80 a4 00 11 cmp %l0, %l1 2008cb8: 02 80 00 0c be 2008ce8 <_User_extensions_Thread_begin+0x48><== NEVER TAKEN 2008cbc: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) 2008cc0: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 2008cc4: 80 a0 60 00 cmp %g1, 0 2008cc8: 02 80 00 04 be 2008cd8 <_User_extensions_Thread_begin+0x38> 2008ccc: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.thread_begin)( executing ); 2008cd0: 9f c0 40 00 call %g1 2008cd4: 01 00 00 00 nop Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 2008cd8: e0 04 00 00 ld [ %l0 ], %l0 { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 2008cdc: 80 a4 00 11 cmp %l0, %l1 2008ce0: 32 bf ff f9 bne,a 2008cc4 <_User_extensions_Thread_begin+0x24> 2008ce4: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 2008ce8: 81 c7 e0 08 ret 2008cec: 81 e8 00 00 restore =============================================================================== 02008d90 <_User_extensions_Thread_create>: */ bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 2008d90: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; 2008d94: 03 00 80 61 sethi %hi(0x2018400), %g1 2008d98: e0 00 61 48 ld [ %g1 + 0x148 ], %l0 ! 2018548 <_User_extensions_List> 2008d9c: 82 10 61 48 or %g1, 0x148, %g1 2008da0: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 2008da4: 80 a4 00 11 cmp %l0, %l1 2008da8: 02 80 00 10 be 2008de8 <_User_extensions_Thread_create+0x58><== NEVER TAKEN 2008dac: 03 00 80 60 sethi %hi(0x2018000), %g1 the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { status = (*the_extension->Callouts.thread_create)( 2008db0: a4 10 63 d4 or %g1, 0x3d4, %l2 ! 20183d4 <_Thread_Executing> !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 2008db4: c2 04 20 14 ld [ %l0 + 0x14 ], %g1 2008db8: 80 a0 60 00 cmp %g1, 0 2008dbc: 02 80 00 07 be 2008dd8 <_User_extensions_Thread_create+0x48> 2008dc0: 92 10 00 18 mov %i0, %o1 status = (*the_extension->Callouts.thread_create)( 2008dc4: 9f c0 40 00 call %g1 2008dc8: d0 04 80 00 ld [ %l2 ], %o0 _Thread_Executing, the_thread ); if ( !status ) 2008dcc: 80 8a 20 ff btst 0xff, %o0 2008dd0: 02 80 00 08 be 2008df0 <_User_extensions_Thread_create+0x60><== NEVER TAKEN 2008dd4: 01 00 00 00 nop User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 2008dd8: e0 04 00 00 ld [ %l0 ], %l0 Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 2008ddc: 80 a4 00 11 cmp %l0, %l1 2008de0: 32 bf ff f6 bne,a 2008db8 <_User_extensions_Thread_create+0x28> 2008de4: c2 04 20 14 ld [ %l0 + 0x14 ], %g1 return FALSE; } } return TRUE; } 2008de8: 81 c7 e0 08 ret 2008dec: 91 e8 20 01 restore %g0, 1, %o0 if ( the_extension->Callouts.thread_create != NULL ) { status = (*the_extension->Callouts.thread_create)( _Thread_Executing, the_thread ); if ( !status ) 2008df0: 81 c7 e0 08 ret <== NOT EXECUTED 2008df4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 02008df8 <_User_extensions_Thread_delete>: */ void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 2008df8: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 2008dfc: 03 00 80 61 sethi %hi(0x2018400), %g1 2008e00: 82 10 61 48 or %g1, 0x148, %g1 ! 2018548 <_User_extensions_List> 2008e04: e0 00 60 08 ld [ %g1 + 8 ], %l0 !_Chain_Is_head( &_User_extensions_List, the_node ) ; 2008e08: 80 a4 00 01 cmp %l0, %g1 2008e0c: 02 80 00 0e be 2008e44 <_User_extensions_Thread_delete+0x4c><== NEVER TAKEN 2008e10: a4 10 00 01 mov %g1, %l2 the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_delete != NULL ) (*the_extension->Callouts.thread_delete)( 2008e14: 03 00 80 60 sethi %hi(0x2018000), %g1 2008e18: a2 10 63 d4 or %g1, 0x3d4, %l1 ! 20183d4 <_Thread_Executing> !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_delete != NULL ) 2008e1c: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 2008e20: 80 a0 60 00 cmp %g1, 0 2008e24: 02 80 00 04 be 2008e34 <_User_extensions_Thread_delete+0x3c> 2008e28: 92 10 00 18 mov %i0, %o1 (*the_extension->Callouts.thread_delete)( 2008e2c: 9f c0 40 00 call %g1 2008e30: d0 04 40 00 ld [ %l1 ], %o0 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 2008e34: e0 04 20 04 ld [ %l0 + 4 ], %l0 { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 2008e38: 80 a4 00 12 cmp %l0, %l2 2008e3c: 32 bf ff f9 bne,a 2008e20 <_User_extensions_Thread_delete+0x28> 2008e40: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 2008e44: 81 c7 e0 08 ret 2008e48: 81 e8 00 00 restore =============================================================================== 02008cf0 <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 2008cf0: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 2008cf4: 03 00 80 61 sethi %hi(0x2018400), %g1 2008cf8: 82 10 61 48 or %g1, 0x148, %g1 ! 2018548 <_User_extensions_List> 2008cfc: e0 00 60 08 ld [ %g1 + 8 ], %l0 !_Chain_Is_head( &_User_extensions_List, the_node ) ; 2008d00: 80 a4 00 01 cmp %l0, %g1 2008d04: 02 80 00 0c be 2008d34 <_User_extensions_Thread_exitted+0x44><== NEVER TAKEN 2008d08: a2 10 00 01 mov %g1, %l1 the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 2008d0c: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 2008d10: 80 a0 60 00 cmp %g1, 0 2008d14: 02 80 00 04 be 2008d24 <_User_extensions_Thread_exitted+0x34> 2008d18: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.thread_exitted)( executing ); 2008d1c: 9f c0 40 00 call %g1 2008d20: 01 00 00 00 nop Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 2008d24: e0 04 20 04 ld [ %l0 + 4 ], %l0 { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 2008d28: 80 a4 00 11 cmp %l0, %l1 2008d2c: 32 bf ff f9 bne,a 2008d10 <_User_extensions_Thread_exitted+0x20> 2008d30: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 2008d34: 81 c7 e0 08 ret 2008d38: 81 e8 00 00 restore =============================================================================== 02009a80 <_User_extensions_Thread_restart>: */ void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 2009a80: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 2009a84: 03 00 80 70 sethi %hi(0x201c000), %g1 2009a88: e0 00 60 48 ld [ %g1 + 0x48 ], %l0 ! 201c048 <_User_extensions_List> 2009a8c: 82 10 60 48 or %g1, 0x48, %g1 2009a90: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 2009a94: 80 a4 00 11 cmp %l0, %l1 2009a98: 02 80 00 0d be 2009acc <_User_extensions_Thread_restart+0x4c><== NEVER TAKEN 2009a9c: 03 00 80 6f sethi %hi(0x201bc00), %g1 the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_restart != NULL ) (*the_extension->Callouts.thread_restart)( 2009aa0: a4 10 62 d4 or %g1, 0x2d4, %l2 ! 201bed4 <_Thread_Executing> !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_restart != NULL ) 2009aa4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 2009aa8: 80 a0 60 00 cmp %g1, 0 2009aac: 02 80 00 04 be 2009abc <_User_extensions_Thread_restart+0x3c> 2009ab0: 92 10 00 18 mov %i0, %o1 (*the_extension->Callouts.thread_restart)( 2009ab4: 9f c0 40 00 call %g1 2009ab8: d0 04 80 00 ld [ %l2 ], %o0 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 2009abc: e0 04 00 00 ld [ %l0 ], %l0 { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 2009ac0: 80 a4 00 11 cmp %l0, %l1 2009ac4: 32 bf ff f9 bne,a 2009aa8 <_User_extensions_Thread_restart+0x28> 2009ac8: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 2009acc: 81 c7 e0 08 ret 2009ad0: 81 e8 00 00 restore =============================================================================== 02008e4c <_User_extensions_Thread_start>: */ void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 2008e4c: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 2008e50: 03 00 80 61 sethi %hi(0x2018400), %g1 2008e54: e0 00 61 48 ld [ %g1 + 0x148 ], %l0 ! 2018548 <_User_extensions_List> 2008e58: 82 10 61 48 or %g1, 0x148, %g1 2008e5c: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 2008e60: 80 a4 00 11 cmp %l0, %l1 2008e64: 02 80 00 0d be 2008e98 <_User_extensions_Thread_start+0x4c><== NEVER TAKEN 2008e68: 03 00 80 60 sethi %hi(0x2018000), %g1 the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_start != NULL ) (*the_extension->Callouts.thread_start)( 2008e6c: a4 10 63 d4 or %g1, 0x3d4, %l2 ! 20183d4 <_Thread_Executing> !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_start != NULL ) 2008e70: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 2008e74: 80 a0 60 00 cmp %g1, 0 2008e78: 02 80 00 04 be 2008e88 <_User_extensions_Thread_start+0x3c> 2008e7c: 92 10 00 18 mov %i0, %o1 (*the_extension->Callouts.thread_start)( 2008e80: 9f c0 40 00 call %g1 2008e84: d0 04 80 00 ld [ %l2 ], %o0 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 2008e88: e0 04 00 00 ld [ %l0 ], %l0 { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 2008e8c: 80 a4 00 11 cmp %l0, %l1 2008e90: 32 bf ff f9 bne,a 2008e74 <_User_extensions_Thread_start+0x28> 2008e94: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 2008e98: 81 c7 e0 08 ret 2008e9c: 81 e8 00 00 restore =============================================================================== 02008ea0 <_User_extensions_Thread_switch>: */ void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 2008ea0: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; 2008ea4: 03 00 80 60 sethi %hi(0x2018000), %g1 2008ea8: e0 00 63 14 ld [ %g1 + 0x314 ], %l0 ! 2018314 <_User_extensions_Switches_list> 2008eac: 82 10 63 14 or %g1, 0x314, %g1 2008eb0: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; 2008eb4: 80 a4 00 11 cmp %l0, %l1 2008eb8: 02 80 00 0a be 2008ee0 <_User_extensions_Thread_switch+0x40><== NEVER TAKEN 2008ebc: 01 00 00 00 nop the_node = the_node->next ) { the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); 2008ec0: c2 04 20 08 ld [ %l0 + 8 ], %g1 2008ec4: 90 10 00 18 mov %i0, %o0 2008ec8: 9f c0 40 00 call %g1 2008ecc: 92 10 00 19 mov %i1, %o1 Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { 2008ed0: e0 04 00 00 ld [ %l0 ], %l0 { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; 2008ed4: 80 a4 00 11 cmp %l0, %l1 2008ed8: 32 bf ff fb bne,a 2008ec4 <_User_extensions_Thread_switch+0x24> 2008edc: c2 04 20 08 ld [ %l0 + 8 ], %g1 2008ee0: 81 c7 e0 08 ret 2008ee4: 81 e8 00 00 restore =============================================================================== 0200ad6c <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 200ad6c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 200ad70: 7f ff df 3a call 2002a58 200ad74: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 200ad78: c4 06 00 00 ld [ %i0 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200ad7c: a0 06 20 04 add %i0, 4, %l0 * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 200ad80: 80 a0 80 10 cmp %g2, %l0 200ad84: 02 80 00 1f be 200ae00 <_Watchdog_Adjust+0x94> 200ad88: 80 a6 60 00 cmp %i1, 0 switch ( direction ) { 200ad8c: 12 80 00 1f bne 200ae08 <_Watchdog_Adjust+0x9c> 200ad90: 80 a6 60 01 cmp %i1, 1 case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 200ad94: 80 a6 a0 00 cmp %i2, 0 200ad98: 02 80 00 1a be 200ae00 <_Watchdog_Adjust+0x94> <== NEVER TAKEN 200ad9c: 01 00 00 00 nop if ( units < _Watchdog_First( header )->delta_interval ) { 200ada0: f2 00 a0 10 ld [ %g2 + 0x10 ], %i1 200ada4: 80 a6 80 19 cmp %i2, %i1 200ada8: 1a 80 00 0b bcc 200add4 <_Watchdog_Adjust+0x68> <== ALWAYS TAKEN 200adac: a2 10 20 01 mov 1, %l1 _Watchdog_First( header )->delta_interval -= units; 200adb0: 10 80 00 1d b 200ae24 <_Watchdog_Adjust+0xb8> <== NOT EXECUTED 200adb4: 82 26 40 1a sub %i1, %i2, %g1 <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 200adb8: b4 a6 80 19 subcc %i2, %i1, %i2 200adbc: 02 80 00 11 be 200ae00 <_Watchdog_Adjust+0x94> <== NEVER TAKEN 200adc0: 01 00 00 00 nop if ( units < _Watchdog_First( header )->delta_interval ) { 200adc4: f2 00 a0 10 ld [ %g2 + 0x10 ], %i1 200adc8: 80 a6 40 1a cmp %i1, %i2 200adcc: 18 80 00 16 bgu 200ae24 <_Watchdog_Adjust+0xb8> 200add0: 82 26 40 1a sub %i1, %i2, %g1 _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 200add4: e2 20 a0 10 st %l1, [ %g2 + 0x10 ] _ISR_Enable( level ); 200add8: 7f ff df 24 call 2002a68 200addc: 01 00 00 00 nop _Watchdog_Tickle( header ); 200ade0: 40 00 00 b4 call 200b0b0 <_Watchdog_Tickle> 200ade4: 90 10 00 18 mov %i0, %o0 _ISR_Disable( level ); 200ade8: 7f ff df 1c call 2002a58 200adec: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 200adf0: c2 06 00 00 ld [ %i0 ], %g1 if ( _Chain_Is_empty( header ) ) 200adf4: 80 a4 00 01 cmp %l0, %g1 200adf8: 12 bf ff f0 bne 200adb8 <_Watchdog_Adjust+0x4c> 200adfc: 84 10 00 01 mov %g1, %g2 } break; } } _ISR_Enable( level ); 200ae00: 7f ff df 1a call 2002a68 200ae04: 91 e8 00 08 restore %g0, %o0, %o0 * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 200ae08: 12 bf ff fe bne 200ae00 <_Watchdog_Adjust+0x94> <== NEVER TAKEN 200ae0c: 01 00 00 00 nop case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 200ae10: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 200ae14: 82 00 40 1a add %g1, %i2, %g1 200ae18: c2 20 a0 10 st %g1, [ %g2 + 0x10 ] } break; } } _ISR_Enable( level ); 200ae1c: 7f ff df 13 call 2002a68 200ae20: 91 e8 00 08 restore %g0, %o0, %o0 _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 200ae24: 10 bf ff f7 b 200ae00 <_Watchdog_Adjust+0x94> 200ae28: c2 20 a0 10 st %g1, [ %g2 + 0x10 ] =============================================================================== 020164b0 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 20164b0: 9d e3 bf 98 save %sp, -104, %sp Watchdog_Interval units = units_arg; ISR_Level level; Chain_Node *node; if ( !units ) { 20164b4: a2 96 60 00 orcc %i1, 0, %l1 20164b8: 12 80 00 04 bne 20164c8 <_Watchdog_Adjust_to_chain+0x18> 20164bc: 01 00 00 00 nop 20164c0: 81 c7 e0 08 ret 20164c4: 81 e8 00 00 restore return; } _ISR_Disable( level ); 20164c8: 7f ff d3 6b call 200b274 20164cc: 01 00 00 00 nop 20164d0: a6 10 00 08 mov %o0, %l3 20164d4: c4 06 00 00 ld [ %i0 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 20164d8: a0 06 20 04 add %i0, 4, %l0 if ( !_Chain_Is_empty( header ) ) { 20164dc: 80 a0 80 10 cmp %g2, %l0 20164e0: 02 80 00 25 be 2016574 <_Watchdog_Adjust_to_chain+0xc4> 20164e4: a4 06 a0 04 add %i2, 4, %l2 20164e8: f2 00 a0 10 ld [ %g2 + 0x10 ], %i1 while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 20164ec: 80 a6 40 11 cmp %i1, %l1 20164f0: 18 80 00 20 bgu 2016570 <_Watchdog_Adjust_to_chain+0xc0> 20164f4: 82 26 40 11 sub %i1, %l1, %g1 _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 0; 20164f8: 10 80 00 15 b 201654c <_Watchdog_Adjust_to_chain+0x9c> 20164fc: c0 20 a0 10 clr [ %g2 + 0x10 ] Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; 2016500: c2 26 00 00 st %g1, [ %i0 ] new_first->previous = _Chain_Head(the_chain); 2016504: f0 20 60 04 st %i0, [ %g1 + 4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 2016508: e4 20 80 00 st %l2, [ %g2 ] old_last_node = the_chain->last; 201650c: c2 06 a0 08 ld [ %i2 + 8 ], %g1 the_chain->last = the_node; 2016510: c4 26 a0 08 st %g2, [ %i2 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 2016514: c2 20 a0 04 st %g1, [ %g2 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 2016518: c4 20 40 00 st %g2, [ %g1 ] do { node = _Chain_Get_unprotected( header ); _Chain_Append_unprotected( to_fire, node ); _ISR_Flash( level ); 201651c: 7f ff d3 5a call 200b284 2016520: 90 10 00 13 mov %l3, %o0 2016524: 7f ff d3 54 call 200b274 2016528: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 201652c: c4 06 00 00 ld [ %i0 ], %g2 } while ( !_Chain_Is_empty( header ) && _Watchdog_First( header )->delta_interval == 0 ); 2016530: 80 a4 00 02 cmp %l0, %g2 2016534: 02 80 00 10 be 2016574 <_Watchdog_Adjust_to_chain+0xc4> 2016538: 01 00 00 00 nop 201653c: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 2016540: 80 a0 60 00 cmp %g1, 0 2016544: 32 80 00 07 bne,a 2016560 <_Watchdog_Adjust_to_chain+0xb0> 2016548: a2 a4 40 19 subcc %l1, %i1, %l1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 201654c: 80 a4 00 02 cmp %l0, %g2 2016550: 32 bf ff ec bne,a 2016500 <_Watchdog_Adjust_to_chain+0x50><== ALWAYS TAKEN 2016554: c2 00 80 00 ld [ %g2 ], %g1 2016558: 10 bf ff ec b 2016508 <_Watchdog_Adjust_to_chain+0x58> <== NOT EXECUTED 201655c: 84 10 20 00 clr %g2 <== NOT EXECUTED return; } _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { 2016560: 02 80 00 05 be 2016574 <_Watchdog_Adjust_to_chain+0xc4> <== ALWAYS TAKEN 2016564: 01 00 00 00 nop 2016568: 10 bf ff e1 b 20164ec <_Watchdog_Adjust_to_chain+0x3c> <== NOT EXECUTED 201656c: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 2016570: c2 20 a0 10 st %g1, [ %g2 + 0x10 ] break; } } } _ISR_Enable( level ); 2016574: 7f ff d3 44 call 200b284 2016578: 91 e8 00 13 restore %g0, %l3, %o0 =============================================================================== 02008ee8 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 2008ee8: 9d e3 bf 98 save %sp, -104, %sp Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 2008eec: 03 00 80 60 sethi %hi(0x2018000), %g1 void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 2008ef0: ac 10 00 18 mov %i0, %l6 Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 2008ef4: e6 00 63 b0 ld [ %g1 + 0x3b0 ], %l3 _ISR_Disable( level ); 2008ef8: 7f ff e3 bb call 2001de4 2008efc: 01 00 00 00 nop 2008f00: b0 10 00 08 mov %o0, %i0 /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { 2008f04: c2 06 60 08 ld [ %i1 + 8 ], %g1 2008f08: 80 a0 60 00 cmp %g1, 0 2008f0c: 12 80 00 4a bne 2009034 <_Watchdog_Insert+0x14c> <== NEVER TAKEN 2008f10: 01 00 00 00 nop _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 2008f14: 2b 00 80 61 sethi %hi(0x2018400), %l5 2008f18: c2 05 60 60 ld [ %l5 + 0x60 ], %g1 ! 2018460 <_Watchdog_Sync_count> if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 2008f1c: 84 10 20 01 mov 1, %g2 _Watchdog_Sync_count++; 2008f20: 82 00 60 01 inc %g1 2008f24: 2f 00 80 60 sethi %hi(0x2018000), %l7 if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 2008f28: c4 26 60 08 st %g2, [ %i1 + 8 ] 2008f2c: a8 15 e3 d0 or %l7, 0x3d0, %l4 _Watchdog_Sync_count++; 2008f30: c2 25 60 60 st %g1, [ %l5 + 0x60 ] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 2008f34: ba 10 00 14 mov %l4, %i5 the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 2008f38: e4 06 60 0c ld [ %i1 + 0xc ], %l2 * cache *header!! * * Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc) * */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; 2008f3c: e2 05 80 00 ld [ %l6 ], %l1 ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 2008f40: 80 a4 a0 00 cmp %l2, 0 2008f44: 02 80 00 2b be 2008ff0 <_Watchdog_Insert+0x108> <== NEVER TAKEN 2008f48: 03 00 80 61 sethi %hi(0x2018400), %g1 2008f4c: c2 04 40 00 ld [ %l1 ], %g1 2008f50: 80 a0 60 00 cmp %g1, 0 2008f54: 02 80 00 27 be 2008ff0 <_Watchdog_Insert+0x108> 2008f58: 03 00 80 61 sethi %hi(0x2018400), %g1 break; if ( delta_interval < after->delta_interval ) { 2008f5c: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 2008f60: 80 a4 80 10 cmp %l2, %l0 2008f64: 1a 80 00 13 bcc 2008fb0 <_Watchdog_Insert+0xc8> 2008f68: 82 24 00 12 sub %l0, %l2, %g1 after->delta_interval -= delta_interval; 2008f6c: 10 80 00 20 b 2008fec <_Watchdog_Insert+0x104> 2008f70: c2 24 60 10 st %g1, [ %l1 + 0x10 ] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 2008f74: c2 05 00 00 ld [ %l4 ], %g1 2008f78: 80 a4 c0 01 cmp %l3, %g1 2008f7c: 0a 80 00 30 bcs 200903c <_Watchdog_Insert+0x154> 2008f80: 01 00 00 00 nop */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 2008f84: a4 a4 80 10 subcc %l2, %l0, %l2 2008f88: 02 80 00 19 be 2008fec <_Watchdog_Insert+0x104> 2008f8c: e2 04 40 00 ld [ %l1 ], %l1 2008f90: c2 04 40 00 ld [ %l1 ], %g1 2008f94: 80 a0 60 00 cmp %g1, 0 2008f98: 02 80 00 16 be 2008ff0 <_Watchdog_Insert+0x108> 2008f9c: 03 00 80 61 sethi %hi(0x2018400), %g1 break; if ( delta_interval < after->delta_interval ) { 2008fa0: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 2008fa4: 80 a4 00 12 cmp %l0, %l2 2008fa8: 18 80 00 10 bgu 2008fe8 <_Watchdog_Insert+0x100> 2008fac: 82 24 00 12 sub %l0, %l2, %g1 * used around this flash point allowed interrupts to execute * which violated the design assumptions. The critical section * mechanism used here WAS redesigned to address this. */ _ISR_Flash( level ); 2008fb0: 7f ff e3 91 call 2001df4 2008fb4: 90 10 00 18 mov %i0, %o0 2008fb8: 7f ff e3 8b call 2001de4 2008fbc: 01 00 00 00 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 2008fc0: c2 06 60 08 ld [ %i1 + 8 ], %g1 2008fc4: 80 a0 60 01 cmp %g1, 1 2008fc8: 02 bf ff eb be 2008f74 <_Watchdog_Insert+0x8c> <== ALWAYS TAKEN 2008fcc: 01 00 00 00 nop _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 2008fd0: e6 25 e3 d0 st %l3, [ %l7 + 0x3d0 ] <== NOT EXECUTED _Watchdog_Sync_count--; 2008fd4: c2 05 60 60 ld [ %l5 + 0x60 ], %g1 <== NOT EXECUTED 2008fd8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008fdc: c2 25 60 60 st %g1, [ %l5 + 0x60 ] <== NOT EXECUTED _ISR_Enable( level ); 2008fe0: 7f ff e3 85 call 2001df4 <== NOT EXECUTED 2008fe4: 81 e8 00 00 restore <== NOT EXECUTED if ( delta_interval == 0 || !_Watchdog_Next( after ) ) break; if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; 2008fe8: c2 24 60 10 st %g1, [ %l1 + 0x10 ] the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; 2008fec: 03 00 80 61 sethi %hi(0x2018400), %g1 2008ff0: c6 00 60 64 ld [ %g1 + 0x64 ], %g3 ! 2018464 <_Watchdog_Ticks_since_boot> _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 2008ff4: c4 04 60 04 ld [ %l1 + 4 ], %g2 the_watchdog->start_time = _Watchdog_Ticks_since_boot; 2008ff8: c6 26 60 14 st %g3, [ %i1 + 0x14 ] } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 2008ffc: e4 26 60 10 st %l2, [ %i1 + 0x10 ] RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 2009000: 82 10 20 02 mov 2, %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 2009004: c8 00 80 00 ld [ %g2 ], %g4 _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 2009008: e6 25 e3 d0 st %l3, [ %l7 + 0x3d0 ] 200900c: c2 26 60 08 st %g1, [ %i1 + 8 ] _Watchdog_Sync_count--; 2009010: c2 05 60 60 ld [ %l5 + 0x60 ], %g1 after_node->next = the_node; 2009014: f2 20 80 00 st %i1, [ %g2 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 2009018: c4 26 60 04 st %g2, [ %i1 + 4 ] 200901c: 82 00 7f ff add %g1, -1, %g1 before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; before_node->previous = the_node; 2009020: f2 21 20 04 st %i1, [ %g4 + 4 ] Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 2009024: c8 26 40 00 st %g4, [ %i1 ] 2009028: c2 25 60 60 st %g1, [ %l5 + 0x60 ] _ISR_Enable( level ); 200902c: 7f ff e3 72 call 2001df4 2009030: 81 e8 00 00 restore * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 2009034: 7f ff e3 70 call 2001df4 <== NOT EXECUTED 2009038: 81 e8 00 00 restore <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { _Watchdog_Sync_level = insert_isr_nest_level; 200903c: e6 27 40 00 st %l3, [ %i5 ] the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 2009040: 10 bf ff bf b 2008f3c <_Watchdog_Insert+0x54> 2009044: e4 06 60 0c ld [ %i1 + 0xc ], %l2 =============================================================================== 02009094 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 2009094: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 2009098: 7f ff e3 53 call 2001de4 200909c: a0 10 00 18 mov %i0, %l0 previous_state = the_watchdog->state; 20090a0: f0 06 20 08 ld [ %i0 + 8 ], %i0 switch ( previous_state ) { 20090a4: 80 a6 20 01 cmp %i0, 1 20090a8: 02 80 00 2a be 2009150 <_Watchdog_Remove+0xbc> <== NEVER TAKEN 20090ac: 03 00 80 61 sethi %hi(0x2018400), %g1 20090b0: 1a 80 00 09 bcc 20090d4 <_Watchdog_Remove+0x40> 20090b4: 80 a6 20 03 cmp %i0, 3 _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 20090b8: 03 00 80 61 sethi %hi(0x2018400), %g1 20090bc: c4 00 60 64 ld [ %g1 + 0x64 ], %g2 ! 2018464 <_Watchdog_Ticks_since_boot> 20090c0: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 20090c4: 7f ff e3 4c call 2001df4 20090c8: 01 00 00 00 nop return( previous_state ); } 20090cc: 81 c7 e0 08 ret 20090d0: 81 e8 00 00 restore Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 20090d4: 18 bf ff fa bgu 20090bc <_Watchdog_Remove+0x28> <== NEVER TAKEN 20090d8: 03 00 80 61 sethi %hi(0x2018400), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 20090dc: c8 04 00 00 ld [ %l0 ], %g4 break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 20090e0: c0 24 20 08 clr [ %l0 + 8 ] next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 20090e4: c2 01 00 00 ld [ %g4 ], %g1 20090e8: 80 a0 60 00 cmp %g1, 0 20090ec: 02 80 00 07 be 2009108 <_Watchdog_Remove+0x74> 20090f0: 03 00 80 61 sethi %hi(0x2018400), %g1 next_watchdog->delta_interval += the_watchdog->delta_interval; 20090f4: c2 01 20 10 ld [ %g4 + 0x10 ], %g1 20090f8: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 20090fc: 82 00 40 02 add %g1, %g2, %g1 2009100: c2 21 20 10 st %g1, [ %g4 + 0x10 ] if ( _Watchdog_Sync_count ) 2009104: 03 00 80 61 sethi %hi(0x2018400), %g1 2009108: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 ! 2018460 <_Watchdog_Sync_count> 200910c: 80 a0 a0 00 cmp %g2, 0 2009110: 22 80 00 07 be,a 200912c <_Watchdog_Remove+0x98> <== ALWAYS TAKEN 2009114: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Watchdog_Sync_level = _ISR_Nest_level; 2009118: 03 00 80 60 sethi %hi(0x2018000), %g1 <== NOT EXECUTED 200911c: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 ! 20183b0 <_ISR_Nest_level><== NOT EXECUTED 2009120: 05 00 80 60 sethi %hi(0x2018000), %g2 <== NOT EXECUTED 2009124: c6 20 a3 d0 st %g3, [ %g2 + 0x3d0 ] ! 20183d0 <_Watchdog_Sync_level><== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 2009128: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 200912c: c8 20 40 00 st %g4, [ %g1 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 2009130: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 2009134: 03 00 80 61 sethi %hi(0x2018400), %g1 2009138: c4 00 60 64 ld [ %g1 + 0x64 ], %g2 ! 2018464 <_Watchdog_Ticks_since_boot> 200913c: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 2009140: 7f ff e3 2d call 2001df4 2009144: 01 00 00 00 nop return( previous_state ); } 2009148: 81 c7 e0 08 ret 200914c: 81 e8 00 00 restore _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 2009150: c4 00 60 64 ld [ %g1 + 0x64 ], %g2 <== NOT EXECUTED /* * It is not actually on the chain so just change the state and * the Insert operation we interrupted will be aborted. */ the_watchdog->state = WATCHDOG_INACTIVE; 2009154: c0 24 20 08 clr [ %l0 + 8 ] <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 2009158: c4 24 20 18 st %g2, [ %l0 + 0x18 ] <== NOT EXECUTED _ISR_Enable( level ); 200915c: 7f ff e3 26 call 2001df4 <== NOT EXECUTED 2009160: 01 00 00 00 nop <== NOT EXECUTED return( previous_state ); } 2009164: 81 c7 e0 08 ret <== NOT EXECUTED 2009168: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 0200916c <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 200916c: 9d e3 bf 98 save %sp, -104, %sp * See the comment in watchdoginsert.c and watchdogadjust.c * about why it's safe not to declare header a pointer to * volatile data - till, 2003/7 */ _ISR_Disable( level ); 2009170: 7f ff e3 1d call 2001de4 2009174: a4 10 00 18 mov %i0, %l2 2009178: b0 10 00 08 mov %o0, %i0 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 200917c: c4 04 80 00 ld [ %l2 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2009180: a6 04 a0 04 add %l2, 4, %l3 if ( _Chain_Is_empty( header ) ) 2009184: 80 a0 80 13 cmp %g2, %l3 2009188: 02 80 00 0a be 20091b0 <_Watchdog_Tickle+0x44> 200918c: 01 00 00 00 nop * to be inserted has already had its delta_interval adjusted to 0, and * so is added to the head of the chain with a delta_interval of 0. * * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc) */ if (the_watchdog->delta_interval != 0) { 2009190: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 2009194: 80 a0 60 00 cmp %g1, 0 2009198: 02 80 00 16 be 20091f0 <_Watchdog_Tickle+0x84> <== NEVER TAKEN 200919c: a2 10 00 02 mov %g2, %l1 the_watchdog->delta_interval--; 20091a0: 82 00 7f ff add %g1, -1, %g1 if ( the_watchdog->delta_interval != 0 ) 20091a4: 80 a0 60 00 cmp %g1, 0 20091a8: 02 80 00 12 be 20091f0 <_Watchdog_Tickle+0x84> 20091ac: c2 20 a0 10 st %g1, [ %g2 + 0x10 ] the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 20091b0: 7f ff e3 11 call 2001df4 20091b4: 81 e8 00 00 restore _ISR_Enable( level ); switch( watchdog_state ) { case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 20091b8: c2 04 60 1c ld [ %l1 + 0x1c ], %g1 20091bc: 9f c0 40 00 call %g1 20091c0: d0 04 60 20 ld [ %l1 + 0x20 ], %o0 case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 20091c4: 7f ff e3 08 call 2001de4 20091c8: 01 00 00 00 nop 20091cc: b0 10 00 08 mov %o0, %i0 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) header->first ); 20091d0: c2 04 80 00 ld [ %l2 ], %g1 the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 20091d4: 80 a4 c0 01 cmp %l3, %g1 20091d8: 02 bf ff f6 be 20091b0 <_Watchdog_Tickle+0x44> 20091dc: a2 10 00 01 mov %g1, %l1 20091e0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 20091e4: 80 a0 60 00 cmp %g1, 0 20091e8: 12 bf ff f2 bne 20091b0 <_Watchdog_Tickle+0x44> 20091ec: 01 00 00 00 nop if ( the_watchdog->delta_interval != 0 ) goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 20091f0: 7f ff ff a9 call 2009094 <_Watchdog_Remove> 20091f4: 90 10 00 11 mov %l1, %o0 20091f8: a0 10 00 08 mov %o0, %l0 _ISR_Enable( level ); 20091fc: 7f ff e2 fe call 2001df4 2009200: 90 10 00 18 mov %i0, %o0 switch( watchdog_state ) { 2009204: 80 a4 20 02 cmp %l0, 2 2009208: 12 bf ff ef bne 20091c4 <_Watchdog_Tickle+0x58> <== NEVER TAKEN 200920c: 01 00 00 00 nop case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 2009210: 10 bf ff ea b 20091b8 <_Watchdog_Tickle+0x4c> 2009214: d2 04 60 24 ld [ %l1 + 0x24 ], %o1 =============================================================================== 02009284 <_Workspace_Handler_initialization>: */ void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 2009284: 9d e3 bf 98 save %sp, -104, %sp uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 2009288: 80 a6 20 00 cmp %i0, 0 200928c: 02 80 00 15 be 20092e0 <_Workspace_Handler_initialization+0x5c> 2009290: 80 8e 20 07 btst 7, %i0 2009294: 12 80 00 14 bne 20092e4 <_Workspace_Handler_initialization+0x60><== NEVER TAKEN 2009298: 90 10 20 00 clr %o0 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) 200929c: 03 00 80 60 sethi %hi(0x2018000), %g1 20092a0: c4 00 63 ac ld [ %g1 + 0x3ac ], %g2 ! 20183ac <_Configuration_Table> 20092a4: c6 08 a0 28 ldub [ %g2 + 0x28 ], %g3 20092a8: 80 a0 e0 00 cmp %g3, 0 20092ac: 32 80 00 11 bne,a 20092f0 <_Workspace_Handler_initialization+0x6c><== NEVER TAKEN 20092b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED memset( starting_address, 0, size ); memory_available = _Heap_Initialize( 20092b4: 92 10 00 18 mov %i0, %o1 20092b8: 94 10 00 19 mov %i1, %o2 20092bc: 11 00 80 60 sethi %hi(0x2018000), %o0 20092c0: 96 10 20 08 mov 8, %o3 20092c4: 7f ff f5 ab call 2006970 <_Heap_Initialize> 20092c8: 90 12 23 34 or %o0, 0x334, %o0 starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 20092cc: 80 a2 20 00 cmp %o0, 0 20092d0: 02 80 00 0d be 2009304 <_Workspace_Handler_initialization+0x80><== NEVER TAKEN 20092d4: 92 10 20 01 mov 1, %o1 20092d8: 81 c7 e0 08 ret 20092dc: 81 e8 00 00 restore ) { uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) _Internal_error_Occurred( 20092e0: 90 10 20 00 clr %o0 20092e4: 92 10 20 01 mov 1, %o1 20092e8: 7f ff f6 2f call 2006ba4 <_Internal_error_Occurred> 20092ec: 94 10 20 02 mov 2, %o2 TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) memset( starting_address, 0, size ); 20092f0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20092f4: 40 00 14 32 call 200e3bc <== NOT EXECUTED 20092f8: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED memory_available = _Heap_Initialize( 20092fc: 10 bf ff ef b 20092b8 <_Workspace_Handler_initialization+0x34><== NOT EXECUTED 2009300: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 2009304: 7f ff f6 28 call 2006ba4 <_Internal_error_Occurred> <== NOT EXECUTED 2009308: 94 10 20 03 mov 3, %o2 <== NOT EXECUTED =============================================================================== 0200549c : int adjtime( struct timeval *delta, struct timeval *olddelta ) { 200549c: 9d e3 bf 90 save %sp, -112, %sp long adjustment; /* * Simple validations */ if ( !delta ) 20054a0: a2 96 20 00 orcc %i0, 0, %l1 20054a4: 02 80 00 68 be 2005644 20054a8: 03 00 03 d0 sethi %hi(0xf4000), %g1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) 20054ac: d8 04 60 04 ld [ %l1 + 4 ], %o4 20054b0: 82 10 62 3f or %g1, 0x23f, %g1 20054b4: 80 a3 00 01 cmp %o4, %g1 20054b8: 18 80 00 63 bgu 2005644 20054bc: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( olddelta ) { 20054c0: 22 80 00 06 be,a 20054d8 20054c4: c6 04 40 00 ld [ %l1 ], %g3 olddelta->tv_sec = 0; olddelta->tv_usec = 0; 20054c8: c0 26 60 04 clr [ %i1 + 4 ] 20054cc: d8 04 60 04 ld [ %l1 + 4 ], %o4 if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( olddelta ) { olddelta->tv_sec = 0; 20054d0: c0 26 40 00 clr [ %i1 ] olddelta->tv_usec = 0; } /* convert delta to microseconds */ adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND); 20054d4: c6 04 40 00 ld [ %l1 ], %g3 adjustment += delta->tv_usec; /* too small to account for */ if ( adjustment < _TOD_Microseconds_per_tick ) 20054d8: 03 00 80 69 sethi %hi(0x201a400), %g1 20054dc: da 00 61 e0 ld [ %g1 + 0x1e0 ], %o5 ! 201a5e0 <_TOD_Microseconds_per_tick> olddelta->tv_sec = 0; olddelta->tv_usec = 0; } /* convert delta to microseconds */ adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND); 20054e0: 89 28 e0 03 sll %g3, 3, %g4 20054e4: 85 28 e0 08 sll %g3, 8, %g2 20054e8: 84 20 80 04 sub %g2, %g4, %g2 20054ec: 83 28 a0 06 sll %g2, 6, %g1 20054f0: 82 20 40 02 sub %g1, %g2, %g1 20054f4: 82 00 40 03 add %g1, %g3, %g1 20054f8: 83 28 60 06 sll %g1, 6, %g1 adjustment += delta->tv_usec; /* too small to account for */ if ( adjustment < _TOD_Microseconds_per_tick ) 20054fc: 82 03 00 01 add %o4, %g1, %g1 2005500: 80 a0 40 0d cmp %g1, %o5 2005504: 1a 80 00 04 bcc 2005514 2005508: 05 00 80 69 sethi %hi(0x201a400), %g2 /* set the user's output */ if ( olddelta ) *olddelta = *delta; return 0; } 200550c: 81 c7 e0 08 ret 2005510: 91 e8 20 00 restore %g0, 0, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005514: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 2005518: 82 00 60 01 inc %g1 200551c: c2 20 a0 40 st %g1, [ %g2 + 0x40 ] * This prevents context switches while we are adjusting the TOD */ _Thread_Disable_dispatch(); _TOD_Get( &ts ); 2005520: a4 07 bf f0 add %fp, -16, %l2 2005524: 40 00 07 23 call 20071b0 <_TOD_Get> 2005528: 90 10 00 12 mov %l2, %o0 ts.tv_sec += delta->tv_sec; ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 200552c: c4 04 60 04 ld [ %l1 + 4 ], %g2 _Thread_Disable_dispatch(); _TOD_Get( &ts ); ts.tv_sec += delta->tv_sec; 2005530: c6 04 40 00 ld [ %l1 ], %g3 2005534: c2 07 bf f0 ld [ %fp + -16 ], %g1 ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 2005538: da 07 bf f4 ld [ %fp + -12 ], %o5 _Thread_Disable_dispatch(); _TOD_Get( &ts ); ts.tv_sec += delta->tv_sec; 200553c: b0 00 c0 01 add %g3, %g1, %i0 ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 2005540: 89 28 a0 02 sll %g2, 2, %g4 2005544: 83 28 a0 07 sll %g2, 7, %g1 _Thread_Disable_dispatch(); _TOD_Get( &ts ); ts.tv_sec += delta->tv_sec; 2005548: f0 27 bf f0 st %i0, [ %fp + -16 ] ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 200554c: 82 20 40 04 sub %g1, %g4, %g1 2005550: 82 00 40 02 add %g1, %g2, %g1 2005554: 83 28 60 03 sll %g1, 3, %g1 2005558: 9a 00 40 0d add %g1, %o5, %o5 /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 200555c: 13 0e e6 b2 sethi %hi(0x3b9ac800), %o1 2005560: 82 12 61 ff or %o1, 0x1ff, %g1 ! 3b9ac9ff 2005564: 80 a3 40 01 cmp %o5, %g1 2005568: 08 80 00 1b bleu 20055d4 200556c: da 27 bf f4 st %o5, [ %fp + -12 ] int adjtime( struct timeval *delta, struct timeval *olddelta ) { 2005570: 92 12 62 00 or %o1, 0x200, %o1 ts.tv_sec += delta->tv_sec; ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 2005574: 21 31 19 4d sethi %hi(0xc4653400), %l0 2005578: a0 14 22 00 or %l0, 0x200, %l0 ! c4653600 200557c: a0 03 40 10 add %o5, %l0, %l0 int adjtime( struct timeval *delta, struct timeval *olddelta ) { 2005580: 40 00 43 7e call 2016378 <.udiv> 2005584: 90 10 00 10 mov %l0, %o0 2005588: 82 06 20 01 add %i0, 1, %g1 200558c: 87 2a 20 03 sll %o0, 3, %g3 2005590: 82 00 40 08 add %g1, %o0, %g1 2005594: 85 2a 20 08 sll %o0, 8, %g2 2005598: 84 20 80 03 sub %g2, %g3, %g2 200559c: c2 27 bf f0 st %g1, [ %fp + -16 ] 20055a0: 83 28 a0 06 sll %g2, 6, %g1 20055a4: 82 20 40 02 sub %g1, %g2, %g1 20055a8: 82 00 40 08 add %g1, %o0, %g1 20055ac: 85 28 60 02 sll %g1, 2, %g2 20055b0: 82 00 40 02 add %g1, %g2, %g1 20055b4: 87 28 60 02 sll %g1, 2, %g3 20055b8: 82 00 40 03 add %g1, %g3, %g1 20055bc: 85 28 60 02 sll %g1, 2, %g2 20055c0: 82 00 40 02 add %g1, %g2, %g1 20055c4: 83 28 60 09 sll %g1, 9, %g1 20055c8: a0 24 00 01 sub %l0, %g1, %l0 20055cc: e0 27 bf f4 st %l0, [ %fp + -12 ] 20055d0: 9a 10 00 10 mov %l0, %o5 ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 20055d4: 03 31 19 4d sethi %hi(0xc4653400), %g1 20055d8: 82 10 62 00 or %g1, 0x200, %g1 ! c4653600 20055dc: 80 a3 40 01 cmp %o5, %g1 20055e0: 18 80 00 0c bgu 2005610 <== NEVER TAKEN 20055e4: a0 10 00 0d mov %o5, %l0 20055e8: c4 07 bf f0 ld [ %fp + -16 ], %g2 20055ec: 86 10 00 01 mov %g1, %g3 ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; 20055f0: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 20055f4: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 20055f8: a0 04 00 01 add %l0, %g1, %l0 ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 20055fc: 80 a4 00 03 cmp %l0, %g3 2005600: 08 bf ff fe bleu 20055f8 2005604: 84 00 bf ff add %g2, -1, %g2 2005608: c4 27 bf f0 st %g2, [ %fp + -16 ] 200560c: e0 27 bf f4 st %l0, [ %fp + -12 ] ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; ts.tv_sec--; } _TOD_Set( &ts ); 2005610: 40 00 07 10 call 2007250 <_TOD_Set> 2005614: 90 10 00 12 mov %l2, %o0 _Thread_Enable_dispatch(); 2005618: 40 00 0b d2 call 2008560 <_Thread_Enable_dispatch> 200561c: 01 00 00 00 nop /* set the user's output */ if ( olddelta ) 2005620: 80 a6 60 00 cmp %i1, 0 2005624: 02 bf ff ba be 200550c <== NEVER TAKEN 2005628: 01 00 00 00 nop *olddelta = *delta; 200562c: c4 04 40 00 ld [ %l1 ], %g2 2005630: c4 26 40 00 st %g2, [ %i1 ] 2005634: c2 04 60 04 ld [ %l1 + 4 ], %g1 2005638: c2 26 60 04 st %g1, [ %i1 + 4 ] 200563c: 81 c7 e0 08 ret 2005640: 91 e8 20 00 restore %g0, 0, %o0 */ if ( !delta ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) rtems_set_errno_and_return_minus_one( EINVAL ); 2005644: 40 00 23 be call 200e53c <__errno> 2005648: b0 10 3f ff mov -1, %i0 200564c: 82 10 20 16 mov 0x16, %g1 2005650: c2 22 00 00 st %g1, [ %o0 ] 2005654: 81 c7 e0 08 ret 2005658: 81 e8 00 00 restore =============================================================================== 020072cc : } unsigned int alarm( unsigned int seconds ) { 20072cc: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 20072d0: 03 00 80 65 sethi %hi(0x2019400), %g1 20072d4: a2 10 62 8c or %g1, 0x28c, %l1 ! 201968c <_POSIX_signals_Alarm_timer> 20072d8: c4 04 60 1c ld [ %l1 + 0x1c ], %g2 20072dc: 80 a0 a0 00 cmp %g2, 0 20072e0: 02 80 00 23 be 200736c 20072e4: a4 10 00 18 mov %i0, %l2 _Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 20072e8: 40 00 14 df call 200c664 <_Watchdog_Remove> 20072ec: 90 10 00 11 mov %l1, %o0 20072f0: 90 02 3f fe add %o0, -2, %o0 20072f4: 80 a2 20 01 cmp %o0, 1 20072f8: 08 80 00 09 bleu 200731c <== ALWAYS TAKEN 20072fc: b0 10 20 00 clr %i0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2007300: e4 24 60 0c st %l2, [ %l1 + 0xc ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2007304: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2007308: 11 00 80 66 sethi %hi(0x2019800), %o0 <== NOT EXECUTED 200730c: 40 00 14 6b call 200c4b8 <_Watchdog_Insert> <== NOT EXECUTED 2007310: 90 12 20 c8 or %o0, 0xc8, %o0 ! 20198c8 <_Watchdog_Seconds_chain><== NOT EXECUTED } _Watchdog_Insert_seconds( the_timer, seconds ); return remaining; } 2007314: 81 c7 e0 08 ret <== NOT EXECUTED 2007318: 81 e8 00 00 restore <== NOT EXECUTED * The stop_time and start_time fields are snapshots of ticks since * boot. Since alarm() is dealing in seconds, we must account for * this. */ remaining = the_timer->initial - 200731c: c4 04 60 14 ld [ %l1 + 0x14 ], %g2 2007320: 03 00 80 66 sethi %hi(0x2019800), %g1 2007324: e0 04 60 18 ld [ %l1 + 0x18 ], %l0 2007328: d2 00 61 90 ld [ %g1 + 0x190 ], %o1 200732c: a0 24 00 02 sub %l0, %g2, %l0 2007330: 11 00 03 d0 sethi %hi(0xf4000), %o0 2007334: 40 00 37 2b call 2014fe0 <.udiv> 2007338: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 200733c: 92 10 00 08 mov %o0, %o1 2007340: 40 00 37 28 call 2014fe0 <.udiv> 2007344: 90 10 00 10 mov %l0, %o0 2007348: c2 04 60 0c ld [ %l1 + 0xc ], %g1 200734c: 92 10 00 11 mov %l1, %o1 2007350: b0 20 40 08 sub %g1, %o0, %i0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2007354: e4 24 60 0c st %l2, [ %l1 + 0xc ] _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2007358: 11 00 80 66 sethi %hi(0x2019800), %o0 200735c: 40 00 14 57 call 200c4b8 <_Watchdog_Insert> 2007360: 90 12 20 c8 or %o0, 0xc8, %o0 ! 20198c8 <_Watchdog_Seconds_chain> } _Watchdog_Insert_seconds( the_timer, seconds ); return remaining; } 2007364: 81 c7 e0 08 ret 2007368: 81 e8 00 00 restore Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 200736c: 03 00 80 1c sethi %hi(0x2007000), %g1 2007370: 82 10 63 a4 or %g1, 0x3a4, %g1 ! 20073a4 <_POSIX_signals_Alarm_TSR> the_watchdog->id = id; the_watchdog->user_data = user_data; 2007374: b0 10 20 00 clr %i0 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2007378: c0 24 60 08 clr [ %l1 + 8 ] the_watchdog->routine = routine; the_watchdog->id = id; 200737c: c0 24 60 20 clr [ %l1 + 0x20 ] the_watchdog->user_data = user_data; 2007380: c0 24 60 24 clr [ %l1 + 0x24 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2007384: c2 24 60 1c st %g1, [ %l1 + 0x1c ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2007388: e4 24 60 0c st %l2, [ %l1 + 0xc ] _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 200738c: 92 10 00 11 mov %l1, %o1 2007390: 11 00 80 66 sethi %hi(0x2019800), %o0 2007394: 40 00 14 49 call 200c4b8 <_Watchdog_Insert> 2007398: 90 12 20 c8 or %o0, 0xc8, %o0 ! 20198c8 <_Watchdog_Seconds_chain> 200739c: 81 c7 e0 08 ret 20073a0: 81 e8 00 00 restore =============================================================================== 02006378 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 2006378: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 200637c: 90 96 60 00 orcc %i1, 0, %o0 2006380: 02 80 00 1e be 20063f8 2006384: 80 a6 20 01 cmp %i0, 1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) 2006388: 02 80 00 18 be 20063e8 200638c: 80 a6 20 04 cmp %i0, 4 _TOD_Get(tp); #ifdef CLOCK_MONOTONIC else if ( clock_id == CLOCK_MONOTONIC ) 2006390: 02 80 00 0c be 20063c0 <== NEVER TAKEN 2006394: 80 a6 20 02 cmp %i0, 2 _TOD_Get_uptime(tp); #endif #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 2006398: 02 80 00 0a be 20063c0 200639c: 80 a6 20 03 cmp %i0, 3 _TOD_Get_uptime(tp); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 20063a0: 02 80 00 0c be 20063d0 20063a4: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 20063a8: 40 00 25 90 call 200f9e8 <__errno> 20063ac: b0 10 3f ff mov -1, %i0 ! ffffffff 20063b0: 82 10 20 16 mov 0x16, %g1 20063b4: c2 22 00 00 st %g1, [ %o0 ] return 0; } 20063b8: 81 c7 e0 08 ret 20063bc: 81 e8 00 00 restore else if ( clock_id == CLOCK_MONOTONIC ) _TOD_Get_uptime(tp); #endif #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) _TOD_Get_uptime(tp); 20063c0: 40 00 09 93 call 2008a0c <_TOD_Get_uptime> 20063c4: b0 10 20 00 clr %i0 20063c8: 81 c7 e0 08 ret 20063cc: 81 e8 00 00 restore #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); 20063d0: 40 00 25 86 call 200f9e8 <__errno> 20063d4: b0 10 3f ff mov -1, %i0 20063d8: 82 10 20 58 mov 0x58, %g1 20063dc: c2 22 00 00 st %g1, [ %o0 ] 20063e0: 81 c7 e0 08 ret 20063e4: 81 e8 00 00 restore { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) _TOD_Get(tp); 20063e8: 40 00 09 70 call 20089a8 <_TOD_Get> 20063ec: b0 10 20 00 clr %i0 20063f0: 81 c7 e0 08 ret 20063f4: 81 e8 00 00 restore clockid_t clock_id, struct timespec *tp ) { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); 20063f8: 40 00 25 7c call 200f9e8 <__errno> 20063fc: b0 10 3f ff mov -1, %i0 2006400: 82 10 20 16 mov 0x16, %g1 2006404: c2 22 00 00 st %g1, [ %o0 ] 2006408: 81 c7 e0 08 ret 200640c: 81 e8 00 00 restore =============================================================================== 02006410 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 2006410: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 2006414: 90 96 60 00 orcc %i1, 0, %o0 2006418: 02 80 00 23 be 20064a4 <== NEVER TAKEN 200641c: 80 a6 20 01 cmp %i0, 1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 2006420: 02 80 00 12 be 2006468 2006424: 80 a6 20 02 cmp %i0, 2 _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 2006428: 02 80 00 0a be 2006450 200642c: 80 a6 20 03 cmp %i0, 3 rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 2006430: 02 80 00 08 be 2006450 2006434: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 2006438: 40 00 25 6c call 200f9e8 <__errno> 200643c: b0 10 3f ff mov -1, %i0 ! ffffffff 2006440: 82 10 20 16 mov 0x16, %g1 2006444: c2 22 00 00 st %g1, [ %o0 ] return 0; } 2006448: 81 c7 e0 08 ret 200644c: 81 e8 00 00 restore else if ( clock_id == CLOCK_PROCESS_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); 2006450: 40 00 25 66 call 200f9e8 <__errno> 2006454: b0 10 3f ff mov -1, %i0 2006458: 82 10 20 58 mov 0x58, %g1 200645c: c2 22 00 00 st %g1, [ %o0 ] 2006460: 81 c7 e0 08 ret 2006464: 81 e8 00 00 restore { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 2006468: c4 02 00 00 ld [ %o0 ], %g2 200646c: 03 08 76 b9 sethi %hi(0x21dae400), %g1 2006470: 82 10 60 ff or %g1, 0xff, %g1 ! 21dae4ff 2006474: 80 a0 80 01 cmp %g2, %g1 2006478: 08 80 00 0b bleu 20064a4 200647c: 05 00 80 71 sethi %hi(0x201c400), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006480: c2 00 a2 80 ld [ %g2 + 0x280 ], %g1 ! 201c680 <_Thread_Dispatch_disable_level> 2006484: 82 00 60 01 inc %g1 2006488: c2 20 a2 80 st %g1, [ %g2 + 0x280 ] rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 200648c: 40 00 09 88 call 2008aac <_TOD_Set> 2006490: b0 10 20 00 clr %i0 _Thread_Enable_dispatch(); 2006494: 40 00 0e 4a call 2009dbc <_Thread_Enable_dispatch> 2006498: 01 00 00 00 nop 200649c: 81 c7 e0 08 ret 20064a0: 81 e8 00 00 restore if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) rtems_set_errno_and_return_minus_one( EINVAL ); 20064a4: 40 00 25 51 call 200f9e8 <__errno> 20064a8: b0 10 3f ff mov -1, %i0 20064ac: 82 10 20 16 mov 0x16, %g1 20064b0: c2 22 00 00 st %g1, [ %o0 ] 20064b4: 81 c7 e0 08 ret 20064b8: 81 e8 00 00 restore =============================================================================== 02019120 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 2019120: 9d e3 bf 88 save %sp, -120, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 2019124: 7f ff fe be call 2018c1c 2019128: 01 00 00 00 nop 201912c: 80 a2 00 18 cmp %o0, %i0 2019130: 12 80 00 c6 bne 2019448 <== NEVER TAKEN 2019134: 80 a6 60 00 cmp %i1, 0 /* * Validate the signal passed. */ if ( !sig ) 2019138: 02 80 00 ca be 2019460 <== NEVER TAKEN 201913c: 86 06 7f ff add %i1, -1, %g3 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 2019140: 80 a0 e0 1f cmp %g3, 0x1f 2019144: 18 80 00 c7 bgu 2019460 <== NEVER TAKEN 2019148: 03 00 80 94 sethi %hi(0x2025000), %g1 /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 201914c: a1 2e 60 02 sll %i1, 2, %l0 2019150: a4 10 63 78 or %g1, 0x378, %l2 2019154: a3 2e 60 04 sll %i1, 4, %l1 2019158: 82 24 40 10 sub %l1, %l0, %g1 201915c: 82 04 80 01 add %l2, %g1, %g1 2019160: c4 00 60 08 ld [ %g1 + 8 ], %g2 2019164: 80 a0 a0 01 cmp %g2, 1 2019168: 02 80 00 95 be 20193bc 201916c: 90 10 20 00 clr %o0 * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) 2019170: 80 a6 60 08 cmp %i1, 8 2019174: 02 80 00 94 be 20193c4 2019178: 80 a6 60 04 cmp %i1, 4 201917c: 02 80 00 92 be 20193c4 2019180: 80 a6 60 0b cmp %i1, 0xb 2019184: 02 80 00 90 be 20193c4 2019188: 82 10 20 01 mov 1, %g1 /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 201918c: f2 27 bf ec st %i1, [ %fp + -20 ] siginfo->si_code = SI_USER; 2019190: c2 27 bf f0 st %g1, [ %fp + -16 ] if ( !value ) { 2019194: 80 a6 a0 00 cmp %i2, 0 2019198: 02 80 00 a3 be 2019424 201919c: b1 28 40 03 sll %g1, %g3, %i0 siginfo->si_value.sival_int = 0; } else { siginfo->si_value = *value; 20191a0: c2 06 80 00 ld [ %i2 ], %g1 20191a4: c2 27 bf f4 st %g1, [ %fp + -12 ] 20191a8: 05 00 80 93 sethi %hi(0x2024c00), %g2 20191ac: c2 00 a1 60 ld [ %g2 + 0x160 ], %g1 ! 2024d60 <_Thread_Dispatch_disable_level> 20191b0: 82 00 60 01 inc %g1 20191b4: c2 20 a1 60 st %g1, [ %g2 + 0x160 ] /* * Is the currently executing thread interested? If so then it will * get it an execute it as soon as the dispatcher executes. */ the_thread = _Thread_Executing; 20191b8: 03 00 80 93 sethi %hi(0x2024c00), %g1 20191bc: c8 00 62 24 ld [ %g1 + 0x224 ], %g4 ! 2024e24 <_Thread_Executing> api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 20191c0: c4 01 21 6c ld [ %g4 + 0x16c ], %g2 20191c4: c2 00 a0 c4 ld [ %g2 + 0xc4 ], %g1 20191c8: 80 ae 00 01 andncc %i0, %g1, %g0 20191cc: 12 80 00 69 bne 2019370 20191d0: 03 00 80 95 sethi %hi(0x2025400), %g1 goto process_it; 20191d4: 98 10 61 04 or %g1, 0x104, %o4 ! 2025504 <_POSIX_signals_Wait_queue> */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 20191d8: 96 03 20 30 add %o4, 0x30, %o3 index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; 20191dc: c4 03 00 00 ld [ %o4 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 20191e0: 9a 03 20 04 add %o4, 4, %o5 !_Chain_Is_tail( the_chain, the_node ) ; 20191e4: 80 a0 80 0d cmp %g2, %o5 20191e8: 22 80 00 1a be,a 2019250 20191ec: 98 03 20 0c add %o4, 0xc, %o4 the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ((the_thread->Wait.option & mask) || (~api->signals_blocked & mask)) { 20191f0: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 20191f4: 88 10 00 02 mov %g2, %g4 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ((the_thread->Wait.option & mask) || (~api->signals_blocked & mask)) { 20191f8: 80 8e 00 01 btst %i0, %g1 20191fc: 12 80 00 5d bne 2019370 <== ALWAYS TAKEN 2019200: c2 00 a1 6c ld [ %g2 + 0x16c ], %g1 2019204: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 <== NOT EXECUTED 2019208: 80 ae 00 01 andncc %i0, %g1, %g0 <== NOT EXECUTED 201920c: 22 80 00 0d be,a 2019240 <== NOT EXECUTED 2019210: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = true; 2019214: 10 80 00 58 b 2019374 <== NOT EXECUTED 2019218: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 201921c: c6 00 a1 6c ld [ %g2 + 0x16c ], %g3 <== NOT EXECUTED if ((the_thread->Wait.option & mask) || (~api->signals_blocked & mask)) { 2019220: 80 8e 00 01 btst %i0, %g1 <== NOT EXECUTED 2019224: 12 80 00 53 bne 2019370 <== NOT EXECUTED 2019228: 88 10 00 02 mov %g2, %g4 <== NOT EXECUTED 201922c: c2 00 e0 c4 ld [ %g3 + 0xc4 ], %g1 <== NOT EXECUTED 2019230: 80 ae 00 01 andncc %i0, %g1, %g0 <== NOT EXECUTED 2019234: 12 80 00 50 bne 2019374 <== NOT EXECUTED 2019238: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 201923c: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 2019240: 80 a0 80 0d cmp %g2, %o5 <== NOT EXECUTED 2019244: 32 bf ff f6 bne,a 201921c <== NOT EXECUTED 2019248: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 <== NOT EXECUTED 201924c: 98 03 20 0c add %o4, 0xc, %o4 <== NOT EXECUTED */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 2019250: 80 a3 00 0b cmp %o4, %o3 2019254: 12 bf ff e2 bne 20191dc 2019258: 03 00 80 70 sethi %hi(0x201c000), %g1 * * + rtems internal threads do not receive signals. */ interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 201925c: c4 08 61 84 ldub [ %g1 + 0x184 ], %g2 ! 201c184 2019260: 90 10 20 00 clr %o0 2019264: 03 00 80 93 sethi %hi(0x2024c00), %g1 2019268: 84 00 a0 01 inc %g2 201926c: 94 10 60 c8 or %g1, 0xc8, %o2 * Now we know both threads are blocked. * If the interested thread is interruptible, then just use it. */ /* XXX need a new states macro */ if ( interested_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) 2019270: 35 04 00 00 sethi %hi(0x10000000), %i2 2019274: 9e 02 a0 0c add %o2, 0xc, %o7 the_api++ ) { /* * Thie can occur when no one is interested and ITRON is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 2019278: c2 02 80 00 ld [ %o2 ], %g1 201927c: 80 a0 60 00 cmp %g1, 0 2019280: 22 80 00 35 be,a 2019354 2019284: 9a 10 00 02 mov %g2, %o5 continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 2019288: c2 00 60 04 ld [ %g1 + 4 ], %g1 /* * This cannot happen in the current (as of Dec 2007) implementation * of initialization but at some point, the object information * structure for a particular manager may not be installed. */ if ( !the_info ) 201928c: 80 a0 60 00 cmp %g1, 0 2019290: 22 80 00 31 be,a 2019354 <== NEVER TAKEN 2019294: 9a 10 00 02 mov %g2, %o5 <== NOT EXECUTED continue; maximum = the_info->maximum; 2019298: d8 10 60 10 lduh [ %g1 + 0x10 ], %o4 object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 201929c: 80 a3 20 00 cmp %o4, 0 20192a0: 02 80 00 5f be 201941c 20192a4: d6 00 60 1c ld [ %g1 + 0x1c ], %o3 20192a8: 88 10 20 01 mov 1, %g4 the_thread = (Thread_Control *) object_table[ index ]; 20192ac: 83 29 20 02 sll %g4, 2, %g1 20192b0: c6 02 c0 01 ld [ %o3 + %g1 ], %g3 if ( !the_thread ) 20192b4: 80 a0 e0 00 cmp %g3, 0 20192b8: 02 80 00 23 be 2019344 <== NEVER TAKEN 20192bc: 9a 10 00 02 mov %g2, %o5 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 20192c0: da 00 e0 14 ld [ %g3 + 0x14 ], %o5 20192c4: 80 a3 40 02 cmp %o5, %g2 20192c8: 38 80 00 1f bgu,a 2019344 <== NEVER TAKEN 20192cc: 9a 10 00 02 mov %g2, %o5 <== NOT EXECUTED /* * If this thread is not interested, then go on to the next thread. */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 20192d0: c2 00 e1 6c ld [ %g3 + 0x16c ], %g1 if ( !api || !_POSIX_signals_Is_interested( api, mask ) ) 20192d4: 80 a0 60 00 cmp %g1, 0 20192d8: 22 80 00 1b be,a 2019344 <== NEVER TAKEN 20192dc: 9a 10 00 02 mov %g2, %o5 <== NOT EXECUTED 20192e0: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 20192e4: 80 ae 00 01 andncc %i0, %g1, %g0 20192e8: 22 80 00 17 be,a 2019344 20192ec: 9a 10 00 02 mov %g2, %o5 * Now we know the thread under connsideration is interested. * If the thread under consideration is of higher priority, then * it becomes the interested thread. */ if ( the_thread->current_priority < interested_priority ) { 20192f0: 80 a3 40 02 cmp %o5, %g2 20192f4: 2a 80 00 0b bcs,a 2019320 <== ALWAYS TAKEN 20192f8: 88 01 20 01 inc %g4 * Now the thread and the interested thread have the same priority. * If the interested thread is ready, then we don't need to send it * to a blocked thread. */ if ( _States_Is_ready( interested_thread->current_state ) ) 20192fc: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 <== NOT EXECUTED 2019300: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2019304: 22 80 00 10 be,a 2019344 <== NOT EXECUTED 2019308: 9a 10 00 02 mov %g2, %o5 <== NOT EXECUTED * Now the interested thread is blocked. * If the thread we are considering is not, the it becomes the * interested thread. */ if ( _States_Is_ready( the_thread->current_state ) ) { 201930c: d2 00 e0 10 ld [ %g3 + 0x10 ], %o1 <== NOT EXECUTED 2019310: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED 2019314: 12 80 00 46 bne 201942c <== NOT EXECUTED 2019318: 80 88 40 1a btst %g1, %i2 <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 201931c: 88 01 20 01 inc %g4 <== NOT EXECUTED 2019320: 80 a3 00 04 cmp %o4, %g4 2019324: 0a 80 00 0c bcs 2019354 <== NEVER TAKEN 2019328: 90 10 00 03 mov %g3, %o0 the_thread = (Thread_Control *) object_table[ index ]; 201932c: 83 29 20 02 sll %g4, 2, %g1 2019330: c6 02 c0 01 ld [ %o3 + %g1 ], %g3 if ( !the_thread ) 2019334: 80 a0 e0 00 cmp %g3, 0 2019338: 12 bf ff e2 bne 20192c0 201933c: 84 10 00 0d mov %o5, %g2 * If the thread under consideration is interruptible by a signal, * then it becomes the interested thread. */ /* XXX need a new states macro */ if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 2019340: 9a 10 00 02 mov %g2, %o5 continue; maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 2019344: 88 01 20 01 inc %g4 2019348: 80 a3 00 04 cmp %o4, %g4 201934c: 1a bf ff f9 bcc 2019330 2019350: 83 29 20 02 sll %g4, 2, %g1 2019354: 94 02 a0 04 add %o2, 4, %o2 interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; 2019358: 80 a2 80 0f cmp %o2, %o7 201935c: 12 bf ff c7 bne 2019278 2019360: 84 10 00 0d mov %o5, %g2 interested_priority = the_thread->current_priority; } } } if ( interested_thread ) { 2019364: 80 a2 20 00 cmp %o0, 0 2019368: 02 80 00 0b be 2019394 201936c: 88 10 00 08 mov %o0, %g4 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = true; 2019370: 82 10 20 01 mov 1, %g1 /* * Returns TRUE if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 2019374: 90 10 00 04 mov %g4, %o0 2019378: 92 10 00 19 mov %i1, %o1 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = true; 201937c: c2 29 20 75 stb %g1, [ %g4 + 0x75 ] /* * Returns TRUE if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 2019380: 40 00 00 54 call 20194d0 <_POSIX_signals_Unblock_thread> 2019384: 94 07 bf ec add %fp, -20, %o2 2019388: 80 8a 20 ff btst 0xff, %o0 201938c: 12 80 00 09 bne 20193b0 2019390: 01 00 00 00 nop /* * We may have woken up a thread but we definitely need to post the * signal to the process wide information set. */ _POSIX_signals_Set_process_signals( mask ); 2019394: 40 00 00 3f call 2019490 <_POSIX_signals_Set_process_signals> 2019398: 90 10 00 18 mov %i0, %o0 if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 201939c: b4 24 40 10 sub %l1, %l0, %i2 20193a0: c2 04 80 1a ld [ %l2 + %i2 ], %g1 20193a4: 80 a0 60 02 cmp %g1, 2 20193a8: 02 80 00 0d be 20193dc 20193ac: 11 00 80 95 sethi %hi(0x2025400), %o0 psiginfo->Info = *siginfo; _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); 20193b0: 7f ff c0 54 call 2009500 <_Thread_Enable_dispatch> 20193b4: 01 00 00 00 nop 20193b8: 90 10 20 00 clr %o0 ! 0 return 0; } 20193bc: 81 c7 e0 08 ret 20193c0: 91 e8 00 08 restore %g0, %o0, %o0 * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) return pthread_kill( pthread_self(), sig ); 20193c4: 40 00 00 d0 call 2019704 20193c8: 01 00 00 00 nop 20193cc: 40 00 00 92 call 2019614 20193d0: 92 10 00 19 mov %i1, %o1 _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); return 0; } 20193d4: 81 c7 e0 08 ret 20193d8: 91 e8 00 08 restore %g0, %o0, %o0 _POSIX_signals_Set_process_signals( mask ); if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) 20193dc: 7f ff d3 0b call 200e008 <_Chain_Get> 20193e0: 90 12 20 f8 or %o0, 0xf8, %o0 _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 20193e4: 80 a2 20 00 cmp %o0, 0 20193e8: 02 80 00 24 be 2019478 <== NEVER TAKEN 20193ec: c2 07 bf ec ld [ %fp + -20 ], %g1 rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 20193f0: 92 10 00 08 mov %o0, %o1 _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; 20193f4: c2 22 20 08 st %g1, [ %o0 + 8 ] 20193f8: c4 07 bf f0 ld [ %fp + -16 ], %g2 20193fc: c4 22 20 0c st %g2, [ %o0 + 0xc ] 2019400: c2 07 bf f4 ld [ %fp + -12 ], %g1 2019404: c2 22 20 10 st %g1, [ %o0 + 0x10 ] _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 2019408: 11 00 80 95 sethi %hi(0x2025400), %o0 201940c: 90 12 21 48 or %o0, 0x148, %o0 ! 2025548 <_POSIX_signals_Siginfo> 2019410: 7f ff b9 a1 call 2007a94 <_Chain_Append> 2019414: 90 02 00 1a add %o0, %i2, %o0 2019418: 30 bf ff e6 b,a 20193b0 continue; maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 201941c: 10 bf ff ce b 2019354 2019420: 9a 10 00 02 mov %g2, %o5 siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { siginfo->si_value.sival_int = 0; 2019424: 10 bf ff 61 b 20191a8 2019428: c0 27 bf f4 clr [ %fp + -12 ] * Now we know both threads are blocked. * If the interested thread is interruptible, then just use it. */ /* XXX need a new states macro */ if ( interested_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) 201942c: 32 bf ff c6 bne,a 2019344 <== NOT EXECUTED 2019430: 9a 10 00 02 mov %g2, %o5 <== NOT EXECUTED * If the thread under consideration is interruptible by a signal, * then it becomes the interested thread. */ /* XXX need a new states macro */ if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 2019434: 80 8a 40 1a btst %o1, %i2 <== NOT EXECUTED 2019438: 32 bf ff ba bne,a 2019320 <== NOT EXECUTED 201943c: 88 01 20 01 inc %g4 <== NOT EXECUTED 2019440: 10 bf ff c1 b 2019344 <== NOT EXECUTED 2019444: 9a 10 00 02 mov %g2, %o5 <== NOT EXECUTED /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) rtems_set_errno_and_return_minus_one( ESRCH ); 2019448: 7f ff d8 ee call 200f800 <__errno> <== NOT EXECUTED 201944c: 01 00 00 00 nop <== NOT EXECUTED 2019450: 82 10 20 03 mov 3, %g1 ! 3 <== NOT EXECUTED 2019454: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2019458: 10 bf ff d9 b 20193bc <== NOT EXECUTED 201945c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 2019460: 7f ff d8 e8 call 200f800 <__errno> <== NOT EXECUTED 2019464: 01 00 00 00 nop <== NOT EXECUTED 2019468: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 201946c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2019470: 10 bf ff d3 b 20193bc <== NOT EXECUTED 2019474: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { rtems_set_errno_and_return_minus_one( EAGAIN ); 2019478: 7f ff d8 e2 call 200f800 <__errno> <== NOT EXECUTED 201947c: 01 00 00 00 nop <== NOT EXECUTED 2019480: 82 10 20 0b mov 0xb, %g1 ! b <== NOT EXECUTED 2019484: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2019488: 10 bf ff cd b 20193bc <== NOT EXECUTED 201948c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED =============================================================================== 02009948 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 2009948: 9d e3 bf 88 save %sp, -120, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200994c: 05 00 80 8a sethi %hi(0x2022800), %g2 2009950: c2 00 a3 00 ld [ %g2 + 0x300 ], %g1 ! 2022b00 <_Thread_Dispatch_disable_level> Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); 2009954: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 2009958: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 200995c: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 2009960: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 2009964: 82 00 60 01 inc %g1 int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 2009968: a0 10 00 18 mov %i0, %l0 200996c: c2 20 a3 00 st %g1, [ %g2 + 0x300 ] POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 2009970: b6 8e 62 00 andcc %i1, 0x200, %i3 2009974: 12 80 00 37 bne 2009a50 2009978: 39 00 80 8c sethi %hi(0x2023000), %i4 200997c: b4 10 20 00 clr %i2 */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd * _POSIX_Message_queue_Allocate_fd( void ) { return (POSIX_Message_queue_Control_fd *) 2009980: 40 00 0c ca call 200cca8 <_Objects_Allocate> 2009984: 90 17 20 0c or %i4, 0xc, %o0 attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 2009988: b0 92 20 00 orcc %o0, 0, %i0 200998c: 02 80 00 39 be 2009a70 <== NEVER TAKEN 2009990: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq_fd->oflag = oflag; 2009994: f2 26 20 14 st %i1, [ %i0 + 0x14 ] status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 2009998: 90 10 00 10 mov %l0, %o0 200999c: 40 00 1f a9 call 2011840 <_POSIX_Message_queue_Name_to_id> 20099a0: 92 07 bf f0 add %fp, -16, %o1 * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "message queue does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 20099a4: ba 92 20 00 orcc %o0, 0, %i5 20099a8: 02 80 00 0f be 20099e4 20099ac: 82 0e 6a 00 and %i1, 0xa00, %g1 /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 20099b0: 80 a7 60 02 cmp %i5, 2 20099b4: 02 80 00 42 be 2009abc 20099b8: 80 a6 e0 00 cmp %i3, 0 RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd ( POSIX_Message_queue_Control_fd *the_mq_fd ) { _Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object ); 20099bc: 92 10 00 18 mov %i0, %o1 20099c0: 40 00 0d b5 call 200d094 <_Objects_Free> 20099c4: 90 17 20 0c or %i4, 0xc, %o0 _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 20099c8: 40 00 10 a1 call 200dc4c <_Thread_Enable_dispatch> 20099cc: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 20099d0: 40 00 2a 5b call 201433c <__errno> 20099d4: 01 00 00 00 nop 20099d8: fa 22 00 00 st %i5, [ %o0 ] 20099dc: 81 c7 e0 08 ret 20099e0: 81 e8 00 00 restore /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 20099e4: 80 a0 6a 00 cmp %g1, 0xa00 20099e8: 02 80 00 2a be 2009a90 20099ec: d2 07 bf f0 ld [ %fp + -16 ], %o1 RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control *) 20099f0: 94 07 bf e8 add %fp, -24, %o2 20099f4: 11 00 80 8b sethi %hi(0x2022c00), %o0 20099f8: 40 00 0e 14 call 200d248 <_Objects_Get> 20099fc: 90 12 22 90 or %o0, 0x290, %o0 ! 2022e90 <_POSIX_Message_queue_Information> * In this case we need to do an ID->pointer conversion to * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); the_mq->open_count += 1; 2009a00: c2 02 20 18 ld [ %o0 + 0x18 ], %g1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2009a04: 86 17 20 0c or %i4, 0xc, %g3 2009a08: 82 00 60 01 inc %g1 2009a0c: c8 00 e0 1c ld [ %g3 + 0x1c ], %g4 2009a10: c2 22 20 18 st %g1, [ %o0 + 0x18 ] 2009a14: c4 06 20 08 ld [ %i0 + 8 ], %g2 /* * In this case we need to do an ID->pointer conversion to * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); 2009a18: d0 27 bf ec st %o0, [ %fp + -20 ] 2009a1c: 03 00 00 3f sethi %hi(0xfc00), %g1 2009a20: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2009a24: 84 08 80 01 and %g2, %g1, %g2 2009a28: 85 28 a0 02 sll %g2, 2, %g2 2009a2c: f0 21 00 02 st %i0, [ %g4 + %g2 ] the_mq->open_count += 1; the_mq_fd->Queue = the_mq; 2009a30: d0 26 20 10 st %o0, [ %i0 + 0x10 ] _Objects_Open_string( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 2009a34: 40 00 10 86 call 200dc4c <_Thread_Enable_dispatch> 2009a38: c0 26 20 0c clr [ %i0 + 0xc ] _Thread_Enable_dispatch(); 2009a3c: 40 00 10 84 call 200dc4c <_Thread_Enable_dispatch> 2009a40: 01 00 00 00 nop return (mqd_t)the_mq_fd->Object.id; 2009a44: f0 06 20 08 ld [ %i0 + 8 ], %i0 2009a48: 81 c7 e0 08 ret 2009a4c: 81 e8 00 00 restore _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); 2009a50: 82 07 a0 54 add %fp, 0x54, %g1 2009a54: f4 07 a0 50 ld [ %fp + 0x50 ], %i2 2009a58: c2 27 bf f4 st %g1, [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd * _POSIX_Message_queue_Allocate_fd( void ) { return (POSIX_Message_queue_Control_fd *) 2009a5c: 40 00 0c 93 call 200cca8 <_Objects_Allocate> 2009a60: 90 17 20 0c or %i4, 0xc, %o0 va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 2009a64: b0 92 20 00 orcc %o0, 0, %i0 2009a68: 32 bf ff cc bne,a 2009998 2009a6c: f2 26 20 14 st %i1, [ %i0 + 0x14 ] _Thread_Enable_dispatch(); 2009a70: 40 00 10 77 call 200dc4c <_Thread_Enable_dispatch> 2009a74: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( ENFILE ); 2009a78: 40 00 2a 31 call 201433c <__errno> 2009a7c: 01 00 00 00 nop 2009a80: 82 10 20 17 mov 0x17, %g1 ! 17 2009a84: c2 22 00 00 st %g1, [ %o0 ] 2009a88: 81 c7 e0 08 ret 2009a8c: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd ( POSIX_Message_queue_Control_fd *the_mq_fd ) { _Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object ); 2009a90: 92 10 00 18 mov %i0, %o1 2009a94: 40 00 0d 80 call 200d094 <_Objects_Free> 2009a98: 90 17 20 0c or %i4, 0xc, %o0 * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 2009a9c: 40 00 10 6c call 200dc4c <_Thread_Enable_dispatch> 2009aa0: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 2009aa4: 40 00 2a 26 call 201433c <__errno> 2009aa8: 01 00 00 00 nop 2009aac: 82 10 20 11 mov 0x11, %g1 ! 11 2009ab0: c2 22 00 00 st %g1, [ %o0 ] 2009ab4: 81 c7 e0 08 ret 2009ab8: 81 e8 00 00 restore /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 2009abc: 02 bf ff c1 be 20099c0 2009ac0: 92 10 00 18 mov %i0, %o1 /* * At this point, the message queue does not exist and everything has been * checked. We should go ahead and create a message queue. */ status = _POSIX_Message_queue_Create_support( 2009ac4: 90 10 00 10 mov %l0, %o0 2009ac8: 94 10 00 1a mov %i2, %o2 2009acc: 92 10 20 01 mov 1, %o1 2009ad0: 40 00 1e f3 call 201169c <_POSIX_Message_queue_Create_support> 2009ad4: 96 07 bf ec add %fp, -20, %o3 /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 2009ad8: 80 a2 3f ff cmp %o0, -1 2009adc: 12 80 00 0a bne 2009b04 2009ae0: 82 17 20 0c or %i4, 0xc, %g1 _Thread_Enable_dispatch(); 2009ae4: 40 00 10 5a call 200dc4c <_Thread_Enable_dispatch> 2009ae8: 01 00 00 00 nop 2009aec: 92 10 00 18 mov %i0, %o1 2009af0: 90 17 20 0c or %i4, 0xc, %o0 2009af4: 40 00 0d 68 call 200d094 <_Objects_Free> 2009af8: b0 10 3f ff mov -1, %i0 2009afc: 81 c7 e0 08 ret 2009b00: 81 e8 00 00 restore 2009b04: c4 06 20 08 ld [ %i0 + 8 ], %g2 2009b08: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 2009b0c: 03 00 00 3f sethi %hi(0xfc00), %g1 2009b10: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2009b14: 84 08 80 01 and %g2, %g1, %g2 _POSIX_Message_queue_Free_fd( the_mq_fd ); return (mqd_t) -1; } the_mq_fd->Queue = the_mq; 2009b18: c2 07 bf ec ld [ %fp + -20 ], %g1 2009b1c: 85 28 a0 02 sll %g2, 2, %g2 2009b20: f0 20 c0 02 st %i0, [ %g3 + %g2 ] 2009b24: c2 26 20 10 st %g1, [ %i0 + 0x10 ] &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 2009b28: 40 00 10 49 call 200dc4c <_Thread_Enable_dispatch> 2009b2c: c0 26 20 0c clr [ %i0 + 0xc ] return (mqd_t) the_mq_fd->Object.id; 2009b30: f0 06 20 08 ld [ %i0 + 8 ], %i0 } 2009b34: 81 c7 e0 08 ret 2009b38: 81 e8 00 00 restore =============================================================================== 02009ea0 : char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 2009ea0: 9d e3 bf 90 save %sp, -112, %sp * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 2009ea4: 90 10 00 1c mov %i4, %o0 2009ea8: 40 00 00 4c call 2009fd8 <_POSIX_Absolute_timeout_to_ticks> 2009eac: 92 07 bf f4 add %fp, -12, %o1 2009eb0: 80 a2 20 02 cmp %o0, 2 2009eb4: 18 80 00 03 bgu 2009ec0 <== ALWAYS TAKEN 2009eb8: 98 10 20 01 mov 1, %o4 2009ebc: 98 10 20 00 clr %o4 <== NOT EXECUTED default: /* only to silence warnings */ do_wait = TRUE; break; } return _POSIX_Message_queue_Receive_support( 2009ec0: da 07 bf f4 ld [ %fp + -12 ], %o5 2009ec4: 90 10 00 18 mov %i0, %o0 2009ec8: 92 10 00 19 mov %i1, %o1 2009ecc: 94 10 00 1a mov %i2, %o2 2009ed0: 7f ff ff 21 call 2009b54 <_POSIX_Message_queue_Receive_support> 2009ed4: 96 10 00 1b mov %i3, %o3 msg_len, msg_prio, do_wait, ticks ); } 2009ed8: 81 c7 e0 08 ret 2009edc: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 02009ee0 : const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 2009ee0: 9d e3 bf 90 save %sp, -112, %sp * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 2009ee4: 90 10 00 1c mov %i4, %o0 2009ee8: 40 00 00 3c call 2009fd8 <_POSIX_Absolute_timeout_to_ticks> 2009eec: 92 07 bf f4 add %fp, -12, %o1 2009ef0: 80 a2 20 02 cmp %o0, 2 2009ef4: 18 80 00 03 bgu 2009f00 <== ALWAYS TAKEN 2009ef8: 98 10 20 01 mov 1, %o4 2009efc: 98 10 20 00 clr %o4 <== NOT EXECUTED default: /* only to silence warnings */ do_wait = TRUE; break; } return _POSIX_Message_queue_Send_support( 2009f00: da 07 bf f4 ld [ %fp + -12 ], %o5 2009f04: 90 10 00 18 mov %i0, %o0 2009f08: 92 10 00 19 mov %i1, %o1 2009f0c: 94 10 00 1a mov %i2, %o2 2009f10: 7f ff ff 65 call 2009ca4 <_POSIX_Message_queue_Send_support> 2009f14: 96 10 00 1b mov %i3, %o3 msg_len, msg_prio, do_wait, ticks ); } 2009f18: 81 c7 e0 08 ret 2009f1c: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 02009f34 : */ int mq_unlink( const char *name ) { 2009f34: 9d e3 bf 90 save %sp, -112, %sp 2009f38: 03 00 80 8a sethi %hi(0x2022800), %g1 2009f3c: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 2022b00 <_Thread_Dispatch_disable_level> 2009f40: 90 10 00 18 mov %i0, %o0 2009f44: 84 00 a0 01 inc %g2 2009f48: c4 20 63 00 st %g2, [ %g1 + 0x300 ] register POSIX_Message_queue_Control *the_mq; Objects_Id the_mq_id; _Thread_Disable_dispatch(); status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 2009f4c: 40 00 1e 3d call 2011840 <_POSIX_Message_queue_Name_to_id> 2009f50: 92 07 bf f4 add %fp, -12, %o1 if ( status != 0 ) { 2009f54: b0 92 20 00 orcc %o0, 0, %i0 2009f58: 12 80 00 19 bne 2009fbc 2009f5c: 11 00 80 8b sethi %hi(0x2022c00), %o0 RTEMS_INLINE_ROUTINE Objects_Control *_Objects_Get_local_object( Objects_Information *information, uint16_t index ) { if ( index > information->maximum ) 2009f60: c6 07 bf f4 ld [ %fp + -12 ], %g3 2009f64: 88 12 22 90 or %o0, 0x290, %g4 2009f68: c2 11 20 10 lduh [ %g4 + 0x10 ], %g1 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( status ); } the_mq = (POSIX_Message_queue_Control *) _Objects_Get_local_object( 2009f6c: 05 00 00 3f sethi %hi(0xfc00), %g2 2009f70: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2009f74: 86 08 c0 02 and %g3, %g2, %g3 2009f78: 80 a0 c0 01 cmp %g3, %g1 2009f7c: 18 80 00 05 bgu 2009f90 <== NEVER TAKEN 2009f80: b0 10 20 00 clr %i0 2009f84: c4 01 20 1c ld [ %g4 + 0x1c ], %g2 2009f88: 83 28 e0 02 sll %g3, 2, %g1 2009f8c: f0 00 80 01 ld [ %g2 + %g1 ], %i0 RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Namespace_remove ( POSIX_Message_queue_Control *the_mq ) { _Objects_Namespace_remove( 2009f90: 92 10 00 18 mov %i0, %o1 &_POSIX_Message_queue_Information, _Objects_Get_index( the_mq_id ) ); the_mq->linked = FALSE; 2009f94: c0 2e 20 15 clrb [ %i0 + 0x15 ] 2009f98: 40 00 0c fe call 200d390 <_Objects_Namespace_remove> 2009f9c: 90 12 22 90 or %o0, 0x290, %o0 _POSIX_Message_queue_Namespace_remove( the_mq ); _POSIX_Message_queue_Delete( the_mq ); 2009fa0: 90 10 00 18 mov %i0, %o0 2009fa4: 7f ff fd e9 call 2009748 <_POSIX_Message_queue_Delete> 2009fa8: b0 10 20 00 clr %i0 _Thread_Enable_dispatch(); 2009fac: 40 00 0f 28 call 200dc4c <_Thread_Enable_dispatch> 2009fb0: 01 00 00 00 nop return 0; } 2009fb4: 81 c7 e0 08 ret 2009fb8: 81 e8 00 00 restore _Thread_Disable_dispatch(); status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); if ( status != 0 ) { _Thread_Enable_dispatch(); 2009fbc: 40 00 0f 24 call 200dc4c <_Thread_Enable_dispatch> 2009fc0: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( status ); 2009fc4: 40 00 28 de call 201433c <__errno> 2009fc8: 01 00 00 00 nop 2009fcc: f0 22 00 00 st %i0, [ %o0 ] 2009fd0: 81 c7 e0 08 ret 2009fd4: 91 e8 3f ff restore %g0, -1, %o0 =============================================================================== 0200b9b8 : int nanosleep( const struct timespec *rqtp, struct timespec *rmtp ) { 200b9b8: 9d e3 bf 98 save %sp, -104, %sp Watchdog_Interval ticks; if ( !_Timespec_Is_valid( rqtp ) ) 200b9bc: 40 00 05 ce call 200d0f4 <_Timespec_Is_valid> 200b9c0: 90 10 00 18 mov %i0, %o0 200b9c4: 80 8a 20 ff btst 0xff, %o0 200b9c8: 02 80 00 43 be 200bad4 200b9cc: 01 00 00 00 nop * Return EINVAL if the delay interval is negative. * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 ) 200b9d0: c2 06 00 00 ld [ %i0 ], %g1 200b9d4: 80 a0 60 00 cmp %g1, 0 200b9d8: 06 80 00 3f bl 200bad4 <== NEVER TAKEN 200b9dc: 01 00 00 00 nop 200b9e0: c2 06 20 04 ld [ %i0 + 4 ], %g1 200b9e4: 80 a0 60 00 cmp %g1, 0 200b9e8: 06 80 00 3b bl 200bad4 <== NEVER TAKEN 200b9ec: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); ticks = _Timespec_To_ticks( rqtp ); 200b9f0: 40 00 05 d3 call 200d13c <_Timespec_To_ticks> 200b9f4: 90 10 00 18 mov %i0, %o0 * A nanosleep for zero time is implemented as a yield. * This behavior is also beyond the POSIX specification but is * consistent with the RTEMS API and yields desirable behavior. */ if ( !ticks ) { 200b9f8: b0 92 20 00 orcc %o0, 0, %i0 200b9fc: 12 80 00 10 bne 200ba3c 200ba00: 05 00 80 63 sethi %hi(0x2018c00), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200ba04: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 ! 2018c90 <_Thread_Dispatch_disable_level> 200ba08: 82 00 60 01 inc %g1 200ba0c: c2 20 a0 90 st %g1, [ %g2 + 0x90 ] _Thread_Disable_dispatch(); _Thread_Yield_processor(); 200ba10: 7f ff f5 33 call 2008edc <_Thread_Yield_processor> 200ba14: 01 00 00 00 nop _Thread_Enable_dispatch(); 200ba18: 7f ff f1 8e call 2008050 <_Thread_Enable_dispatch> 200ba1c: 01 00 00 00 nop if ( rmtp ) { 200ba20: 80 a6 60 00 cmp %i1, 0 200ba24: 02 80 00 2a be 200bacc <== NEVER TAKEN 200ba28: 01 00 00 00 nop rmtp->tv_sec = 0; rmtp->tv_nsec = 0; 200ba2c: c0 26 60 04 clr [ %i1 + 4 ] if ( !ticks ) { _Thread_Disable_dispatch(); _Thread_Yield_processor(); _Thread_Enable_dispatch(); if ( rmtp ) { rmtp->tv_sec = 0; 200ba30: c0 26 40 00 clr [ %i1 ] 200ba34: 81 c7 e0 08 ret 200ba38: 81 e8 00 00 restore 200ba3c: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 200ba40: 82 00 60 01 inc %g1 200ba44: c2 20 a0 90 st %g1, [ %g2 + 0x90 ] /* * Block for the desired amount of time */ _Thread_Disable_dispatch(); _Thread_Set_state( 200ba48: 21 00 80 63 sethi %hi(0x2018c00), %l0 200ba4c: d0 04 21 54 ld [ %l0 + 0x154 ], %o0 ! 2018d54 <_Thread_Executing> 200ba50: 13 04 00 00 sethi %hi(0x10000000), %o1 200ba54: 7f ff f4 1d call 2008ac8 <_Thread_Set_state> 200ba58: 92 12 60 08 or %o1, 8, %o1 ! 10000008 _Thread_Executing, STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Watchdog_Initialize( 200ba5c: c4 04 21 54 ld [ %l0 + 0x154 ], %g2 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200ba60: 11 00 80 63 sethi %hi(0x2018c00), %o0 200ba64: c2 00 a0 08 ld [ %g2 + 8 ], %g1 200ba68: 90 12 21 74 or %o0, 0x174, %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200ba6c: c2 20 a0 68 st %g1, [ %g2 + 0x68 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200ba70: 92 00 a0 48 add %g2, 0x48, %o1 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 200ba74: 03 00 80 1f sethi %hi(0x2007c00), %g1 200ba78: 82 10 62 74 or %g1, 0x274, %g1 ! 2007e74 <_Thread_Delay_ended> Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200ba7c: c0 20 a0 50 clr [ %g2 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 200ba80: c0 20 a0 6c clr [ %g2 + 0x6c ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200ba84: f0 20 a0 54 st %i0, [ %g2 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200ba88: 7f ff f6 58 call 20093e8 <_Watchdog_Insert> 200ba8c: c2 20 a0 64 st %g1, [ %g2 + 0x64 ] _Thread_Delay_ended, _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); _Thread_Enable_dispatch(); 200ba90: 7f ff f1 70 call 2008050 <_Thread_Enable_dispatch> 200ba94: 01 00 00 00 nop /* calculate time remaining */ if ( rmtp ) { 200ba98: 80 a6 60 00 cmp %i1, 0 200ba9c: 02 80 00 0c be 200bacc <== NEVER TAKEN 200baa0: c2 04 21 54 ld [ %l0 + 0x154 ], %g1 ticks -= _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; _Timespec_From_ticks( ticks, rmtp ); 200baa4: 92 10 00 19 mov %i1, %o1 _Thread_Enable_dispatch(); /* calculate time remaining */ if ( rmtp ) { ticks -= 200baa8: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 200baac: e0 00 60 5c ld [ %g1 + 0x5c ], %l0 200bab0: a0 24 00 02 sub %l0, %g2, %l0 200bab4: a0 04 00 18 add %l0, %i0, %l0 _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; _Timespec_From_ticks( ticks, rmtp ); 200bab8: 40 00 05 7a call 200d0a0 <_Timespec_From_ticks> 200babc: 90 10 00 10 mov %l0, %o0 /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) 200bac0: 80 a4 20 00 cmp %l0, 0 200bac4: 12 80 00 0a bne 200baec 200bac8: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINTR ); } return 0; } 200bacc: 81 c7 e0 08 ret 200bad0: 91 e8 20 00 restore %g0, 0, %o0 * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 ) rtems_set_errno_and_return_minus_one( EINVAL ); 200bad4: 40 00 09 b8 call 200e1b4 <__errno> 200bad8: b0 10 3f ff mov -1, %i0 200badc: 82 10 20 16 mov 0x16, %g1 200bae0: c2 22 00 00 st %g1, [ %o0 ] 200bae4: 81 c7 e0 08 ret 200bae8: 81 e8 00 00 restore /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) rtems_set_errno_and_return_minus_one( EINTR ); 200baec: 40 00 09 b2 call 200e1b4 <__errno> 200baf0: b0 10 3f ff mov -1, %i0 200baf4: 82 10 20 04 mov 4, %g1 200baf8: c2 22 00 00 st %g1, [ %o0 ] 200bafc: 81 c7 e0 08 ret 200bb00: 81 e8 00 00 restore =============================================================================== 0200598c : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 200598c: 9d e3 bf 88 save %sp, -120, %sp const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 2005990: 80 a6 20 00 cmp %i0, 0 2005994: 02 80 00 2a be 2005a3c 2005998: a0 10 00 19 mov %i1, %l0 return EINVAL; if ( count == 0 ) 200599c: 80 a6 a0 00 cmp %i2, 0 20059a0: 02 80 00 27 be 2005a3c 20059a4: 80 a6 60 00 cmp %i1, 0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 20059a8: 22 80 00 2b be,a 2005a54 20059ac: a0 07 bf e8 add %fp, -24, %l0 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 20059b0: c2 04 00 00 ld [ %l0 ], %g1 20059b4: 80 a0 60 00 cmp %g1, 0 20059b8: 02 80 00 21 be 2005a3c 20059bc: 01 00 00 00 nop return EINVAL; switch ( the_attr->process_shared ) { 20059c0: c2 04 20 04 ld [ %l0 + 4 ], %g1 20059c4: 80 a0 60 00 cmp %g1, 0 20059c8: 12 80 00 1d bne 2005a3c <== NEVER TAKEN 20059cc: 05 00 80 66 sethi %hi(0x2019800), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20059d0: c2 00 a3 70 ld [ %g2 + 0x370 ], %g1 ! 2019b70 <_Thread_Dispatch_disable_level> /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; the_attributes.maximum_count = count; 20059d4: f4 27 bf f4 st %i2, [ %fp + -12 ] 20059d8: 82 00 60 01 inc %g1 } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 20059dc: c0 27 bf f0 clr [ %fp + -16 ] 20059e0: c2 20 a3 70 st %g1, [ %g2 + 0x370 ] * This function allocates a barrier control block from * the inactive chain of free barrier control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void ) { return (POSIX_Barrier_Control *) 20059e4: 35 00 80 67 sethi %hi(0x2019c00), %i2 20059e8: 40 00 09 4c call 2007f18 <_Objects_Allocate> 20059ec: 90 16 a3 80 or %i2, 0x380, %o0 ! 2019f80 <_POSIX_Barrier_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 20059f0: a0 92 20 00 orcc %o0, 0, %l0 20059f4: 02 80 00 14 be 2005a44 20059f8: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 20059fc: 40 00 06 f9 call 20075e0 <_CORE_barrier_Initialize> 2005a00: 92 07 bf f0 add %fp, -16, %o1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2005a04: c4 04 20 08 ld [ %l0 + 8 ], %g2 2005a08: 82 16 a3 80 or %i2, 0x380, %g1 2005a0c: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 2005a10: 03 00 00 3f sethi %hi(0xfc00), %g1 2005a14: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005a18: 82 08 80 01 and %g2, %g1, %g1 2005a1c: 83 28 60 02 sll %g1, 2, %g1 2005a20: e0 20 c0 01 st %l0, [ %g3 + %g1 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == FALSE */ the_object->name.name_u32 = name; 2005a24: c0 24 20 0c clr [ %l0 + 0xc ] ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 2005a28: c4 26 00 00 st %g2, [ %i0 ] _Thread_Enable_dispatch(); 2005a2c: 40 00 0c f8 call 2008e0c <_Thread_Enable_dispatch> 2005a30: b0 10 20 00 clr %i0 2005a34: 81 c7 e0 08 ret 2005a38: 81 e8 00 00 restore return 0; } 2005a3c: 81 c7 e0 08 ret 2005a40: 91 e8 20 16 restore %g0, 0x16, %o0 _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 2005a44: 40 00 0c f2 call 2008e0c <_Thread_Enable_dispatch> 2005a48: b0 10 20 0b mov 0xb, %i0 2005a4c: 81 c7 e0 08 ret 2005a50: 81 e8 00 00 restore * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 2005a54: 7f ff ff 98 call 20058b4 2005a58: 90 10 00 10 mov %l0, %o0 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 2005a5c: 10 bf ff d6 b 20059b4 2005a60: c2 04 00 00 ld [ %l0 ], %g1 =============================================================================== 02004fd4 : */ int pthread_cancel( pthread_t thread ) { 2004fd4: 9d e3 bf 90 save %sp, -112, %sp /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 2004fd8: 03 00 80 59 sethi %hi(0x2016400), %g1 2004fdc: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 20165d0 <_ISR_Nest_level> */ int pthread_cancel( pthread_t thread ) { 2004fe0: 90 10 00 18 mov %i0, %o0 /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 2004fe4: 80 a0 a0 00 cmp %g2, 0 2004fe8: 12 80 00 15 bne 200503c <== NEVER TAKEN 2004fec: b0 10 20 47 mov 0x47, %i0 return EPROTO; the_thread = _Thread_Get( thread, &location ); 2004ff0: 40 00 0d 86 call 2008608 <_Thread_Get> 2004ff4: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 2004ff8: c2 07 bf f4 ld [ %fp + -12 ], %g1 */ if ( _ISR_Is_in_progress() ) return EPROTO; the_thread = _Thread_Get( thread, &location ); 2004ffc: a0 10 00 08 mov %o0, %l0 switch ( location ) { 2005000: 80 a0 60 00 cmp %g1, 0 2005004: 12 80 00 0e bne 200503c <== NEVER TAKEN 2005008: b0 10 20 16 mov 0x16, %i0 case OBJECTS_LOCAL: thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200500c: c6 02 21 6c ld [ %o0 + 0x16c ], %g3 thread_support->cancelation_requested = 1; 2005010: 82 10 20 01 mov 1, %g1 if (thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2005014: c4 00 e0 cc ld [ %g3 + 0xcc ], %g2 2005018: 80 a0 a0 00 cmp %g2, 0 200501c: 12 80 00 06 bne 2005034 <== NEVER TAKEN 2005020: c2 20 e0 d4 st %g1, [ %g3 + 0xd4 ] 2005024: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 2005028: 80 a0 60 01 cmp %g1, 1 200502c: 02 80 00 06 be 2005044 2005030: 01 00 00 00 nop thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS) cancel = true; _Thread_Enable_dispatch(); 2005034: 40 00 0d 67 call 20085d0 <_Thread_Enable_dispatch> 2005038: b0 10 20 00 clr %i0 ! 0 case OBJECTS_ERROR: break; } return EINVAL; } 200503c: 81 c7 e0 08 ret 2005040: 81 e8 00 00 restore if (thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS) cancel = true; _Thread_Enable_dispatch(); 2005044: 40 00 0d 63 call 20085d0 <_Thread_Enable_dispatch> 2005048: b0 10 20 00 clr %i0 if ( cancel ) _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 200504c: 90 10 00 10 mov %l0, %o0 2005050: 40 00 00 cc call 2005380 <_POSIX_Thread_Exit> 2005054: 92 10 3f ff mov -1, %o1 2005058: 81 c7 e0 08 ret 200505c: 81 e8 00 00 restore =============================================================================== 0200550c : */ void pthread_cleanup_pop( int execute ) { 200550c: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005510: 09 00 80 5c sethi %hi(0x2017000), %g4 POSIX_Cancel_Handler_control tmp_handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2005514: 05 00 80 5c sethi %hi(0x2017000), %g2 2005518: c2 01 22 f0 ld [ %g4 + 0x2f0 ], %g1 200551c: c6 00 a3 b4 ld [ %g2 + 0x3b4 ], %g3 2005520: 82 00 60 01 inc %g1 2005524: e0 00 e1 6c ld [ %g3 + 0x16c ], %l0 2005528: c2 21 22 f0 st %g1, [ %g4 + 0x2f0 ] */ void pthread_cleanup_pop( int execute ) { 200552c: a4 10 00 18 mov %i0, %l2 * ensure that we do not get prempted and deleted while we are holding * memory that needs to be freed. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 2005530: 7f ff f3 bb call 200241c 2005534: 01 00 00 00 nop 2005538: b0 10 00 08 mov %o0, %i0 if ( _Chain_Is_empty( handler_stack ) ) { 200553c: c2 04 20 d8 ld [ %l0 + 0xd8 ], %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2005540: a0 04 20 dc add %l0, 0xdc, %l0 2005544: 80 a0 40 10 cmp %g1, %l0 2005548: 02 80 00 18 be 20055a8 200554c: 01 00 00 00 nop _Thread_Enable_dispatch(); _ISR_Enable( level ); return; } handler = (POSIX_Cancel_Handler_control *) 2005550: e0 04 20 04 ld [ %l0 + 4 ], %l0 ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 2005554: c4 04 00 00 ld [ %l0 ], %g2 previous = the_node->previous; 2005558: c2 04 20 04 ld [ %l0 + 4 ], %g1 next->previous = previous; previous->next = next; 200555c: c4 20 40 00 st %g2, [ %g1 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 2005560: c2 20 a0 04 st %g1, [ %g2 + 4 ] _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 2005564: 7f ff f3 b2 call 200242c 2005568: 01 00 00 00 nop tmp_handler = *handler; _Workspace_Free( handler ); 200556c: 90 10 00 10 mov %l0, %o0 _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); tmp_handler = *handler; 2005570: e2 04 20 0c ld [ %l0 + 0xc ], %l1 _Workspace_Free( handler ); 2005574: 40 00 14 0e call 200a5ac <_Workspace_Free> 2005578: e0 04 20 08 ld [ %l0 + 8 ], %l0 _Thread_Enable_dispatch(); 200557c: 40 00 0e 5e call 2008ef4 <_Thread_Enable_dispatch> 2005580: 01 00 00 00 nop if ( execute ) 2005584: 80 a4 a0 00 cmp %l2, 0 2005588: 12 80 00 04 bne 2005598 <== ALWAYS TAKEN 200558c: 01 00 00 00 nop 2005590: 81 c7 e0 08 ret <== NOT EXECUTED 2005594: 81 e8 00 00 restore <== NOT EXECUTED (*tmp_handler.routine)( tmp_handler.arg ); 2005598: 9f c4 00 00 call %l0 200559c: 90 10 00 11 mov %l1, %o0 20055a0: 81 c7 e0 08 ret 20055a4: 81 e8 00 00 restore _Thread_Disable_dispatch(); _ISR_Disable( level ); if ( _Chain_Is_empty( handler_stack ) ) { _Thread_Enable_dispatch(); 20055a8: 40 00 0e 53 call 2008ef4 <_Thread_Enable_dispatch> 20055ac: 01 00 00 00 nop _ISR_Enable( level ); 20055b0: 7f ff f3 9f call 200242c 20055b4: 81 e8 00 00 restore =============================================================================== 020055bc : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 20055bc: 9d e3 bf 98 save %sp, -104, %sp /* * The POSIX standard does not address what to do when the routine * is NULL. It also does not address what happens when we cannot * allocate memory or anything else bad happens. */ if ( !routine ) 20055c0: 80 a6 20 00 cmp %i0, 0 20055c4: 02 80 00 12 be 200560c 20055c8: 05 00 80 5c sethi %hi(0x2017000), %g2 20055cc: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 20172f0 <_Thread_Dispatch_disable_level> 20055d0: 82 00 60 01 inc %g1 20055d4: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 20055d8: 40 00 13 fc call 200a5c8 <_Workspace_Allocate> 20055dc: 90 10 20 10 mov 0x10, %o0 if ( handler ) { 20055e0: 92 92 20 00 orcc %o0, 0, %o1 20055e4: 02 80 00 08 be 2005604 <== NEVER TAKEN 20055e8: 03 00 80 5c sethi %hi(0x2017000), %g1 thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; handler_stack = &thread_support->Cancellation_Handlers; 20055ec: c4 00 63 b4 ld [ %g1 + 0x3b4 ], %g2 ! 20173b4 <_Thread_Executing> handler->routine = routine; 20055f0: f0 22 60 08 st %i0, [ %o1 + 8 ] handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); if ( handler ) { thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; handler_stack = &thread_support->Cancellation_Handlers; 20055f4: d0 00 a1 6c ld [ %g2 + 0x16c ], %o0 handler->routine = routine; handler->arg = arg; 20055f8: f2 22 60 0c st %i1, [ %o1 + 0xc ] _Chain_Append( handler_stack, &handler->Node ); 20055fc: 40 00 08 57 call 2007758 <_Chain_Append> 2005600: 90 02 20 d8 add %o0, 0xd8, %o0 } _Thread_Enable_dispatch(); 2005604: 40 00 0e 3c call 2008ef4 <_Thread_Enable_dispatch> 2005608: 81 e8 00 00 restore 200560c: 81 c7 e0 08 ret 2005610: 81 e8 00 00 restore =============================================================================== 02006264 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 2006264: 9d e3 bf 98 save %sp, -104, %sp POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 2006268: 03 00 80 56 sethi %hi(0x2015800), %g1 200626c: 80 a6 60 00 cmp %i1, 0 2006270: 02 80 00 03 be 200627c 2006274: a0 10 61 6c or %g1, 0x16c, %l0 2006278: a0 10 00 19 mov %i1, %l0 /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 200627c: c2 04 20 04 ld [ %l0 + 4 ], %g1 2006280: 80 a0 60 01 cmp %g1, 1 2006284: 02 80 00 06 be 200629c <== NEVER TAKEN 2006288: 01 00 00 00 nop return EINVAL; if ( !the_attr->is_initialized ) 200628c: c2 04 00 00 ld [ %l0 ], %g1 2006290: 80 a0 60 00 cmp %g1, 0 2006294: 12 80 00 04 bne 20062a4 2006298: 05 00 80 5d sethi %hi(0x2017400), %g2 *cond = the_cond->Object.id; _Thread_Enable_dispatch(); return 0; } 200629c: 81 c7 e0 08 ret 20062a0: 91 e8 20 16 restore %g0, 0x16, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20062a4: c2 00 a1 b0 ld [ %g2 + 0x1b0 ], %g1 20062a8: 82 00 60 01 inc %g1 20062ac: c2 20 a1 b0 st %g1, [ %g2 + 0x1b0 ] */ RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) 20062b0: 23 00 80 5e sethi %hi(0x2017800), %l1 20062b4: 40 00 0a c7 call 2008dd0 <_Objects_Allocate> 20062b8: 90 14 62 44 or %l1, 0x244, %o0 ! 2017a44 <_POSIX_Condition_variables_Information> _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 20062bc: b2 92 20 00 orcc %o0, 0, %i1 20062c0: 02 80 00 17 be 200631c 20062c4: 90 06 60 18 add %i1, 0x18, %o0 _Thread_Enable_dispatch(); return ENOMEM; } the_cond->process_shared = the_attr->process_shared; 20062c8: c2 04 20 04 ld [ %l0 + 4 ], %g1 20062cc: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 20062d0: 92 10 20 00 clr %o1 20062d4: 94 10 28 00 mov 0x800, %o2 20062d8: 96 10 20 74 mov 0x74, %o3 20062dc: 40 00 10 cf call 200a618 <_Thread_queue_Initialize> 20062e0: c0 26 60 14 clr [ %i1 + 0x14 ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 20062e4: c4 06 60 08 ld [ %i1 + 8 ], %g2 20062e8: 82 14 62 44 or %l1, 0x244, %g1 20062ec: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 20062f0: 03 00 00 3f sethi %hi(0xfc00), %g1 20062f4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20062f8: 82 08 80 01 and %g2, %g1, %g1 20062fc: 83 28 60 02 sll %g1, 2, %g1 2006300: f2 20 c0 01 st %i1, [ %g3 + %g1 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == FALSE */ the_object->name.name_u32 = name; 2006304: c0 26 60 0c clr [ %i1 + 0xc ] &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 2006308: c4 26 00 00 st %g2, [ %i0 ] _Thread_Enable_dispatch(); 200630c: 40 00 0e 6e call 2009cc4 <_Thread_Enable_dispatch> 2006310: b0 10 20 00 clr %i0 2006314: 81 c7 e0 08 ret 2006318: 81 e8 00 00 restore _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { _Thread_Enable_dispatch(); 200631c: 40 00 0e 6a call 2009cc4 <_Thread_Enable_dispatch> 2006320: b0 10 20 0c mov 0xc, %i0 2006324: 81 c7 e0 08 ret 2006328: 81 e8 00 00 restore =============================================================================== 020060d8 : int pthread_condattr_destroy( pthread_condattr_t *attr ) { if ( !attr || attr->is_initialized == FALSE ) 20060d8: 80 a2 20 00 cmp %o0, 0 20060dc: 02 80 00 09 be 2006100 20060e0: 01 00 00 00 nop 20060e4: c2 02 00 00 ld [ %o0 ], %g1 20060e8: 80 a0 60 00 cmp %g1, 0 20060ec: 02 80 00 05 be 2006100 <== NEVER TAKEN 20060f0: 01 00 00 00 nop return EINVAL; attr->is_initialized = FALSE; 20060f4: c0 22 00 00 clr [ %o0 ] 20060f8: 81 c3 e0 08 retl 20060fc: 90 10 20 00 clr %o0 return 0; } 2006100: 81 c3 e0 08 retl 2006104: 90 10 20 16 mov 0x16, %o0 =============================================================================== 02006608 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 2006608: 9d e3 bf 60 save %sp, -160, %sp 200660c: aa 10 00 18 mov %i0, %l5 POSIX_API_Control *api; int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; if ( !start_routine ) 2006610: 80 a6 a0 00 cmp %i2, 0 2006614: 02 80 00 6f be 20067d0 2006618: b0 10 20 0e mov 0xe, %i0 return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 200661c: 03 00 80 6a sethi %hi(0x201a800), %g1 2006620: 80 a6 60 00 cmp %i1, 0 2006624: 02 80 00 03 be 2006630 2006628: a2 10 60 18 or %g1, 0x18, %l1 200662c: a2 10 00 19 mov %i1, %l1 if ( !the_attr->is_initialized ) 2006630: c2 04 40 00 ld [ %l1 ], %g1 2006634: 80 a0 60 00 cmp %g1, 0 2006638: 22 80 00 66 be,a 20067d0 200663c: b0 10 20 16 mov 0x16, %i0 * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) ) 2006640: c2 04 60 04 ld [ %l1 + 4 ], %g1 2006644: 80 a0 60 00 cmp %g1, 0 2006648: 02 80 00 07 be 2006664 200664c: 03 00 80 6e sethi %hi(0x201b800), %g1 2006650: c4 04 60 08 ld [ %l1 + 8 ], %g2 2006654: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 2006658: 80 a0 80 03 cmp %g2, %g3 200665c: 2a 80 00 5d bcs,a 20067d0 <== ALWAYS TAKEN 2006660: b0 10 20 16 mov 0x16, %i0 * inherits scheduling attributes from the creating thread. If it is * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { 2006664: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 2006668: 80 a0 60 01 cmp %g1, 1 200666c: 02 80 00 5b be 20067d8 2006670: 80 a0 60 02 cmp %g1, 2 2006674: 22 80 00 04 be,a 2006684 2006678: c4 04 60 18 ld [ %l1 + 0x18 ], %g2 *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 200667c: 81 c7 e0 08 ret 2006680: 91 e8 20 16 restore %g0, 0x16, %o0 schedpolicy = api->schedpolicy; schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 2006684: f2 04 60 14 ld [ %l1 + 0x14 ], %i1 schedparam = the_attr->schedparam; 2006688: c4 27 bf e0 st %g2, [ %fp + -32 ] 200668c: c2 04 60 1c ld [ %l1 + 0x1c ], %g1 2006690: c2 27 bf e4 st %g1, [ %fp + -28 ] 2006694: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 2006698: c4 27 bf e8 st %g2, [ %fp + -24 ] 200669c: c2 04 60 24 ld [ %l1 + 0x24 ], %g1 20066a0: c2 27 bf ec st %g1, [ %fp + -20 ] 20066a4: c4 04 60 28 ld [ %l1 + 0x28 ], %g2 20066a8: c4 27 bf f0 st %g2, [ %fp + -16 ] 20066ac: c2 04 60 2c ld [ %l1 + 0x2c ], %g1 20066b0: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 20066b4: c2 04 60 0c ld [ %l1 + 0xc ], %g1 20066b8: 80 a0 60 00 cmp %g1, 0 20066bc: 12 80 00 45 bne 20067d0 20066c0: b0 10 20 86 mov 0x86, %i0 /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 20066c4: e8 07 bf e0 ld [ %fp + -32 ], %l4 20066c8: 82 05 3f ff add %l4, -1, %g1 20066cc: 80 a0 60 fd cmp %g1, 0xfd 20066d0: 18 bf ff eb bgu 200667c <== NEVER TAKEN 20066d4: 80 a6 60 01 cmp %i1, 1 */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 20066d8: 02 80 00 54 be 2006828 20066dc: a6 10 20 00 clr %l3 20066e0: 04 80 00 7c ble 20068d0 20066e4: 80 a6 60 02 cmp %i1, 2 20066e8: 02 80 00 4d be 200681c <== NEVER TAKEN 20066ec: 80 a6 60 03 cmp %i1, 3 20066f0: 32 80 00 38 bne,a 20067d0 <== NEVER TAKEN 20066f4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED case SCHED_SPORADIC: budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; budget_callout = _POSIX_Threads_Sporadic_budget_callout; if ( _Timespec_To_ticks( &schedparam.ss_replenish_period ) < 20066f8: 40 00 11 eb call 200aea4 <_Timespec_To_ticks> 20066fc: 90 07 bf e8 add %fp, -24, %o0 2006700: a0 10 00 08 mov %o0, %l0 2006704: 40 00 11 e8 call 200aea4 <_Timespec_To_ticks> 2006708: 90 07 bf f0 add %fp, -16, %o0 200670c: 80 a4 00 08 cmp %l0, %o0 2006710: 0a 80 00 30 bcs 20067d0 2006714: b0 10 20 16 mov 0x16, %i0 _Timespec_To_ticks( &schedparam.ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( schedparam.ss_low_priority ) ) 2006718: c2 07 bf e4 ld [ %fp + -28 ], %g1 200671c: 82 00 7f ff add %g1, -1, %g1 2006720: 80 a0 60 fd cmp %g1, 0xfd 2006724: 18 80 00 2b bgu 20067d0 2006728: a6 10 20 03 mov 3, %l3 200672c: 03 00 80 1b sethi %hi(0x2006c00), %g1 2006730: a0 10 60 90 or %g1, 0x90, %l0 ! 2006c90 <_POSIX_Threads_Sporadic_budget_callout> #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 2006734: 2d 00 80 71 sethi %hi(0x201c400), %l6 2006738: d0 05 a3 3c ld [ %l6 + 0x33c ], %o0 ! 201c73c <_RTEMS_Allocator_Mutex> 200673c: 40 00 07 56 call 2008494 <_API_Mutex_Lock> 2006740: 31 00 80 72 sethi %hi(0x201c800), %i0 * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 2006744: 40 00 09 e1 call 2008ec8 <_Objects_Allocate> 2006748: 90 16 21 10 or %i0, 0x110, %o0 ! 201c910 <_POSIX_Threads_Information> * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 200674c: a4 92 20 00 orcc %o0, 0, %l2 2006750: 02 80 00 1d be 20067c4 2006754: 03 00 80 6e sethi %hi(0x201b800), %g1 /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 2006758: c6 04 60 08 ld [ %l1 + 8 ], %g3 200675c: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 2006760: c0 27 bf dc clr [ %fp + -36 ] 2006764: 97 28 a0 01 sll %g2, 1, %o3 2006768: 80 a2 c0 03 cmp %o3, %g3 200676c: 1a 80 00 03 bcc 2006778 2006770: d4 04 60 04 ld [ %l1 + 4 ], %o2 2006774: 96 10 00 03 mov %g3, %o3 2006778: 82 07 bf dc add %fp, -36, %g1 200677c: e6 23 a0 60 st %l3, [ %sp + 0x60 ] 2006780: e0 23 a0 64 st %l0, [ %sp + 0x64 ] 2006784: c0 23 a0 68 clr [ %sp + 0x68 ] 2006788: 9a 10 20 ff mov 0xff, %o5 200678c: a6 10 20 01 mov 1, %l3 2006790: 9a 23 40 14 sub %o5, %l4, %o5 2006794: e6 23 a0 5c st %l3, [ %sp + 0x5c ] 2006798: c2 23 a0 6c st %g1, [ %sp + 0x6c ] 200679c: 90 16 21 10 or %i0, 0x110, %o0 20067a0: 92 10 00 12 mov %l2, %o1 20067a4: 40 00 0d d6 call 2009efc <_Thread_Initialize> 20067a8: 98 10 20 01 mov 1, %o4 budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 20067ac: 80 8a 20 ff btst 0xff, %o0 20067b0: 12 80 00 20 bne 2006830 20067b4: 11 00 80 72 sethi %hi(0x201c800), %o0 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 20067b8: 92 10 00 12 mov %l2, %o1 20067bc: 40 00 0a be call 20092b4 <_Objects_Free> 20067c0: 90 12 21 10 or %o0, 0x110, %o0 _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 20067c4: d0 05 a3 3c ld [ %l6 + 0x33c ], %o0 20067c8: 40 00 07 49 call 20084ec <_API_Mutex_Unlock> 20067cc: b0 10 20 0b mov 0xb, %i0 20067d0: 81 c7 e0 08 ret 20067d4: 81 e8 00 00 restore * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 20067d8: 03 00 80 71 sethi %hi(0x201c400), %g1 20067dc: c4 00 63 44 ld [ %g1 + 0x344 ], %g2 ! 201c744 <_Thread_Executing> 20067e0: c6 00 a1 6c ld [ %g2 + 0x16c ], %g3 schedpolicy = api->schedpolicy; schedparam = api->schedparam; 20067e4: c8 00 e0 80 ld [ %g3 + 0x80 ], %g4 */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; schedpolicy = api->schedpolicy; 20067e8: f2 00 e0 7c ld [ %g3 + 0x7c ], %i1 schedparam = api->schedparam; 20067ec: c8 27 bf e0 st %g4, [ %fp + -32 ] 20067f0: c2 00 e0 84 ld [ %g3 + 0x84 ], %g1 20067f4: c2 27 bf e4 st %g1, [ %fp + -28 ] 20067f8: c4 00 e0 88 ld [ %g3 + 0x88 ], %g2 20067fc: c4 27 bf e8 st %g2, [ %fp + -24 ] 2006800: c2 00 e0 8c ld [ %g3 + 0x8c ], %g1 2006804: c2 27 bf ec st %g1, [ %fp + -20 ] 2006808: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 200680c: c4 27 bf f0 st %g2, [ %fp + -16 ] 2006810: c2 00 e0 94 ld [ %g3 + 0x94 ], %g1 2006814: 10 bf ff a8 b 20066b4 2006818: c2 27 bf f4 st %g1, [ %fp + -12 ] */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 200681c: a6 10 20 02 mov 2, %l3 <== NOT EXECUTED 2006820: 10 bf ff c5 b 2006734 <== NOT EXECUTED 2006824: a0 10 20 00 clr %l0 <== NOT EXECUTED 2006828: 10 bf ff c3 b 2006734 200682c: a0 10 20 00 clr %l0 /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 2006830: e0 04 a1 6c ld [ %l2 + 0x16c ], %l0 api->Attributes = *the_attr; 2006834: 92 10 00 11 mov %l1, %o1 2006838: 94 10 20 38 mov 0x38, %o2 200683c: 40 00 26 83 call 2010248 2006840: 90 10 00 10 mov %l0, %o0 api->detachstate = the_attr->detachstate; 2006844: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 api->schedpolicy = schedpolicy; 2006848: f2 24 20 7c st %i1, [ %l0 + 0x7c ] api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; 200684c: c2 24 20 38 st %g1, [ %l0 + 0x38 ] api->schedpolicy = schedpolicy; api->schedparam = schedparam; 2006850: c2 07 bf e0 ld [ %fp + -32 ], %g1 * first run. * * NOTE: Since the thread starts with all unblocked, this is necessary. */ the_thread->do_post_task_switch_extension = true; 2006854: e6 2c a0 75 stb %l3, [ %l2 + 0x75 ] api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 2006858: c2 24 20 80 st %g1, [ %l0 + 0x80 ] 200685c: c2 07 bf e4 ld [ %fp + -28 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 2006860: 94 10 00 1a mov %i2, %o2 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 2006864: c2 24 20 84 st %g1, [ %l0 + 0x84 ] 2006868: c2 07 bf e8 ld [ %fp + -24 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 200686c: 96 10 00 1b mov %i3, %o3 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 2006870: c2 24 20 88 st %g1, [ %l0 + 0x88 ] 2006874: c2 07 bf ec ld [ %fp + -20 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 2006878: 90 10 00 12 mov %l2, %o0 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 200687c: c2 24 20 8c st %g1, [ %l0 + 0x8c ] 2006880: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 2006884: 92 10 20 01 mov 1, %o1 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 2006888: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 200688c: c2 07 bf f4 ld [ %fp + -12 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 2006890: 98 10 20 00 clr %o4 2006894: 40 00 10 c6 call 200abac <_Thread_Start> 2006898: c2 24 20 94 st %g1, [ %l0 + 0x94 ] start_routine, arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { 200689c: 80 a6 60 03 cmp %i1, 3 20068a0: 02 80 00 19 be 2006904 20068a4: a2 10 00 08 mov %o0, %l1 * * NOTE: This can only happen if someone slips in and touches the * thread while we are creating it. */ if ( !status ) { 20068a8: 80 8c 60 ff btst 0xff, %l1 20068ac: 12 80 00 0f bne 20068e8 <== ALWAYS TAKEN 20068b0: 90 16 21 10 or %i0, 0x110, %o0 20068b4: 40 00 0a 80 call 20092b4 <_Objects_Free> <== NOT EXECUTED 20068b8: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 20068bc: d0 05 a3 3c ld [ %l6 + 0x33c ], %o0 <== NOT EXECUTED 20068c0: 40 00 07 0b call 20084ec <_API_Mutex_Unlock> <== NOT EXECUTED 20068c4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED 20068c8: 81 c7 e0 08 ret <== NOT EXECUTED 20068cc: 81 e8 00 00 restore <== NOT EXECUTED */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 20068d0: 80 a6 60 00 cmp %i1, 0 20068d4: a6 10 20 01 mov 1, %l3 20068d8: 02 bf ff 97 be 2006734 20068dc: a0 10 20 00 clr %l0 */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; 20068e0: 81 c7 e0 08 ret 20068e4: 91 e8 20 16 restore %g0, 0x16, %o0 /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 20068e8: c2 04 a0 08 ld [ %l2 + 8 ], %g1 _RTEMS_Unlock_allocator(); 20068ec: d0 05 a3 3c ld [ %l6 + 0x33c ], %o0 /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 20068f0: c2 25 40 00 st %g1, [ %l5 ] _RTEMS_Unlock_allocator(); 20068f4: 40 00 06 fe call 20084ec <_API_Mutex_Unlock> 20068f8: b0 10 20 00 clr %i0 20068fc: 81 c7 e0 08 ret 2006900: 81 e8 00 00 restore arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 2006904: 40 00 11 68 call 200aea4 <_Timespec_To_ticks> 2006908: 90 04 20 88 add %l0, 0x88, %o0 200690c: 92 04 20 9c add %l0, 0x9c, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2006910: d0 24 20 a8 st %o0, [ %l0 + 0xa8 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006914: 11 00 80 71 sethi %hi(0x201c400), %o0 2006918: 40 00 12 78 call 200b2f8 <_Watchdog_Insert> 200691c: 90 12 23 64 or %o0, 0x364, %o0 ! 201c764 <_Watchdog_Ticks_chain> * * NOTE: This can only happen if someone slips in and touches the * thread while we are creating it. */ if ( !status ) { 2006920: 10 bf ff e3 b 20068ac 2006924: 80 8c 60 ff btst 0xff, %l1 =============================================================================== 02005558 : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 2005558: 9d e3 bf 98 save %sp, -104, %sp 200555c: 05 00 80 59 sethi %hi(0x2016400), %g2 2005560: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 ! 2016500 <_Thread_Dispatch_disable_level> 2005564: 82 00 60 01 inc %g1 2005568: c2 20 a1 00 st %g1, [ %g2 + 0x100 ] * _POSIX_Keys_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void ) { return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information ); 200556c: 29 00 80 5a sethi %hi(0x2016800), %l4 2005570: 40 00 09 d4 call 2007cc0 <_Objects_Allocate> 2005574: 90 15 21 54 or %l4, 0x154, %o0 ! 2016954 <_POSIX_Keys_Information> _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 2005578: a4 92 20 00 orcc %o0, 0, %l2 200557c: 02 80 00 2b be 2005628 2005580: 03 00 80 59 sethi %hi(0x2016400), %g1 _Thread_Enable_dispatch(); return EAGAIN; } the_key->destructor = destructor; 2005584: f2 24 a0 14 st %i1, [ %l2 + 0x14 ] 2005588: a2 10 00 12 mov %l2, %l1 200558c: a6 10 60 60 or %g1, 0x60, %l3 2005590: b2 10 20 01 mov 1, %i1 for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] ) { 2005594: 83 2e 60 02 sll %i1, 2, %g1 2005598: c2 04 c0 01 ld [ %l3 + %g1 ], %g1 200559c: 80 a0 60 00 cmp %g1, 0 20055a0: 22 80 00 0e be,a 20055d8 20055a4: c0 24 60 1c clr [ %l1 + 0x1c ] INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY ); #endif bytes_to_allocate = sizeof( void * ) * 20055a8: c4 00 60 04 ld [ %g1 + 4 ], %g2 20055ac: c2 10 a0 10 lduh [ %g2 + 0x10 ], %g1 20055b0: 82 00 60 01 inc %g1 20055b4: a1 28 60 02 sll %g1, 2, %l0 (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); 20055b8: 40 00 13 64 call 200a348 <_Workspace_Allocate> 20055bc: 90 10 00 10 mov %l0, %o0 if ( !table ) { 20055c0: 82 92 20 00 orcc %o0, 0, %g1 20055c4: 02 80 00 1d be 2005638 20055c8: 94 10 00 10 mov %l0, %o2 _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return ENOMEM; } the_key->Values[ the_api ] = table; 20055cc: c2 24 60 1c st %g1, [ %l1 + 0x1c ] memset( table, '\0', bytes_to_allocate ); 20055d0: 40 00 27 74 call 200f3a0 20055d4: 92 10 20 00 clr %o1 * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 20055d8: b2 06 60 01 inc %i1 * APIs are optional. Thus there may be no ITRON tasks to have keys * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; 20055dc: 80 a6 60 05 cmp %i1, 5 20055e0: 12 bf ff ed bne 2005594 20055e4: a2 04 60 04 add %l1, 4, %l1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 20055e8: c4 04 a0 08 ld [ %l2 + 8 ], %g2 20055ec: 82 15 21 54 or %l4, 0x154, %g1 20055f0: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 20055f4: 03 00 00 3f sethi %hi(0xfc00), %g1 20055f8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20055fc: 82 08 80 01 and %g2, %g1, %g1 2005600: 83 28 60 02 sll %g1, 2, %g1 2005604: e4 20 c0 01 st %l2, [ %g3 + %g1 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == FALSE */ the_object->name.name_u32 = name; 2005608: c0 24 a0 0c clr [ %l2 + 0xc ] } } the_key->is_active = TRUE; 200560c: 82 10 20 01 mov 1, %g1 _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 2005610: c4 26 00 00 st %g2, [ %i0 ] } } the_key->is_active = TRUE; 2005614: c2 2c a0 10 stb %g1, [ %l2 + 0x10 ] _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; _Thread_Enable_dispatch(); 2005618: 40 00 0d 67 call 2008bb4 <_Thread_Enable_dispatch> 200561c: b0 10 20 00 clr %i0 return 0; } 2005620: 81 c7 e0 08 ret 2005624: 81 e8 00 00 restore _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { _Thread_Enable_dispatch(); 2005628: 40 00 0d 63 call 2008bb4 <_Thread_Enable_dispatch> 200562c: b0 10 20 0b mov 0xb, %i0 2005630: 81 c7 e0 08 ret 2005634: 81 e8 00 00 restore bytes_to_allocate = sizeof( void * ) * (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { for ( --the_api; the_api >= 1; 2005638: a0 86 7f ff addcc %i1, -1, %l0 200563c: 02 80 00 0a be 2005664 <== ALWAYS TAKEN 2005640: 82 06 60 05 add %i1, 5, %g1 2005644: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 2005648: b2 04 80 01 add %l2, %g1, %i1 <== NOT EXECUTED the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); 200564c: d0 06 40 00 ld [ %i1 ], %o0 <== NOT EXECUTED 2005650: 40 00 13 37 call 200a32c <_Workspace_Free> <== NOT EXECUTED 2005654: b2 06 7f fc add %i1, -4, %i1 <== NOT EXECUTED bytes_to_allocate = sizeof( void * ) * (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { for ( --the_api; the_api >= 1; 2005658: a0 84 3f ff addcc %l0, -1, %l0 <== NOT EXECUTED 200565c: 32 bf ff fd bne,a 2005650 <== NOT EXECUTED 2005660: d0 06 40 00 ld [ %i1 ], %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 2005664: 90 15 21 54 or %l4, 0x154, %o0 2005668: 92 10 00 12 mov %l2, %o1 200566c: 40 00 0a 90 call 20080ac <_Objects_Free> 2005670: b0 10 20 0c mov 0xc, %i0 the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 2005674: 40 00 0d 50 call 2008bb4 <_Thread_Enable_dispatch> 2005678: 01 00 00 00 nop 200567c: 81 c7 e0 08 ret 2005680: 81 e8 00 00 restore =============================================================================== 02005684 : */ int pthread_key_delete( pthread_key_t key ) { 2005684: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Keys_Control *) 2005688: 23 00 80 5a sethi %hi(0x2016800), %l1 200568c: 92 10 00 18 mov %i0, %o1 2005690: 94 07 bf f4 add %fp, -12, %o2 2005694: 40 00 0a f3 call 2008260 <_Objects_Get> 2005698: 90 14 61 54 or %l1, 0x154, %o0 register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 200569c: c2 07 bf f4 ld [ %fp + -12 ], %g1 20056a0: a0 10 00 08 mov %o0, %l0 20056a4: 80 a0 60 00 cmp %g1, 0 20056a8: 12 80 00 23 bne 2005734 20056ac: b0 10 20 16 mov 0x16, %i0 case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); 20056b0: 90 14 61 54 or %l1, 0x154, %o0 20056b4: 40 00 09 af call 2007d70 <_Objects_Close> 20056b8: 92 10 00 10 mov %l0, %o1 the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 20056bc: d0 04 20 1c ld [ %l0 + 0x1c ], %o0 20056c0: 80 a2 20 00 cmp %o0, 0 20056c4: 02 80 00 04 be 20056d4 <== NEVER TAKEN 20056c8: c0 2c 20 10 clrb [ %l0 + 0x10 ] _Workspace_Free( the_key->Values[ the_api ] ); 20056cc: 40 00 13 18 call 200a32c <_Workspace_Free> 20056d0: 01 00 00 00 nop the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 20056d4: d0 04 20 20 ld [ %l0 + 0x20 ], %o0 20056d8: 80 a2 20 00 cmp %o0, 0 20056dc: 22 80 00 05 be,a 20056f0 <== NEVER TAKEN 20056e0: d0 04 20 24 ld [ %l0 + 0x24 ], %o0 <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 20056e4: 40 00 13 12 call 200a32c <_Workspace_Free> 20056e8: 01 00 00 00 nop the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 20056ec: d0 04 20 24 ld [ %l0 + 0x24 ], %o0 20056f0: 80 a2 20 00 cmp %o0, 0 20056f4: 22 80 00 05 be,a 2005708 <== NEVER TAKEN 20056f8: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 20056fc: 40 00 13 0c call 200a32c <_Workspace_Free> 2005700: 01 00 00 00 nop the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 2005704: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 2005708: 80 a2 20 00 cmp %o0, 0 200570c: 22 80 00 05 be,a 2005720 <== ALWAYS TAKEN 2005710: 90 14 61 54 or %l1, 0x154, %o0 _Workspace_Free( the_key->Values[ the_api ] ); 2005714: 40 00 13 06 call 200a32c <_Workspace_Free> <== NOT EXECUTED 2005718: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 200571c: 90 14 61 54 or %l1, 0x154, %o0 <== NOT EXECUTED 2005720: 92 10 00 10 mov %l0, %o1 2005724: 40 00 0a 62 call 20080ac <_Objects_Free> 2005728: b0 10 20 00 clr %i0 * NOTE: The destructor is not called and it is the responsibility * of the application to free the memory. */ _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 200572c: 40 00 0d 22 call 2008bb4 <_Thread_Enable_dispatch> 2005730: 01 00 00 00 nop case OBJECTS_ERROR: break; } return EINVAL; } 2005734: 81 c7 e0 08 ret 2005738: 81 e8 00 00 restore =============================================================================== 02019614 : int pthread_kill( pthread_t thread, int sig ) { 2019614: 9d e3 bf 90 save %sp, -112, %sp POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 2019618: 80 a6 60 00 cmp %i1, 0 201961c: 02 80 00 2e be 20196d4 <== NEVER TAKEN 2019620: 90 10 00 18 mov %i0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 2019624: a0 06 7f ff add %i1, -1, %l0 2019628: 80 a4 20 1f cmp %l0, 0x1f 201962c: 18 80 00 2a bgu 20196d4 2019630: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); the_thread = _Thread_Get( thread, &location ); 2019634: 7f ff bf d7 call 2009590 <_Thread_Get> 2019638: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 201963c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2019640: 80 a0 60 00 cmp %g1, 0 2019644: 12 80 00 2a bne 20196ec <== NEVER TAKEN 2019648: b0 10 00 08 mov %o0, %i0 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 201964c: 87 2e 60 02 sll %i1, 2, %g3 2019650: 85 2e 60 04 sll %i1, 4, %g2 2019654: 03 00 80 94 sethi %hi(0x2025000), %g1 2019658: 84 20 80 03 sub %g2, %g3, %g2 201965c: 82 10 63 78 or %g1, 0x378, %g1 2019660: 82 00 40 02 add %g1, %g2, %g1 2019664: c6 00 60 08 ld [ %g1 + 8 ], %g3 2019668: 80 a0 e0 01 cmp %g3, 1 201966c: 02 80 00 14 be 20196bc <== NEVER TAKEN 2019670: c8 02 21 6c ld [ %o0 + 0x16c ], %g4 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 2019674: c4 01 20 c8 ld [ %g4 + 0xc8 ], %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 2019678: 92 10 00 19 mov %i1, %o1 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 201967c: b2 10 20 01 mov 1, %i1 2019680: 83 2e 40 10 sll %i1, %l0, %g1 2019684: 84 10 80 01 or %g2, %g1, %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 2019688: 94 10 20 00 clr %o2 201968c: 7f ff ff 91 call 20194d0 <_POSIX_signals_Unblock_thread> 2019690: c4 21 20 c8 st %g2, [ %g4 + 0xc8 ] the_thread->do_post_task_switch_extension = true; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 2019694: 03 00 80 93 sethi %hi(0x2024c00), %g1 2019698: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 2024e00 <_ISR_Nest_level> 201969c: 80 a0 a0 00 cmp %g2, 0 20196a0: 02 80 00 07 be 20196bc 20196a4: f2 2e 20 75 stb %i1, [ %i0 + 0x75 ] 20196a8: 03 00 80 93 sethi %hi(0x2024c00), %g1 20196ac: c4 00 62 24 ld [ %g1 + 0x224 ], %g2 ! 2024e24 <_Thread_Executing> 20196b0: 80 a6 00 02 cmp %i0, %g2 20196b4: 02 80 00 06 be 20196cc <== NEVER TAKEN 20196b8: 03 00 80 93 sethi %hi(0x2024c00), %g1 _ISR_Signals_to_thread_executing = TRUE; } _Thread_Enable_dispatch(); 20196bc: 7f ff bf 91 call 2009500 <_Thread_Enable_dispatch> 20196c0: b0 10 20 00 clr %i0 20196c4: 81 c7 e0 08 ret 20196c8: 81 e8 00 00 restore (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); the_thread->do_post_task_switch_extension = true; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _ISR_Signals_to_thread_executing = TRUE; 20196cc: 10 bf ff fc b 20196bc <== NOT EXECUTED 20196d0: f2 28 62 b8 stb %i1, [ %g1 + 0x2b8 ] <== NOT EXECUTED if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 20196d4: 7f ff d8 4b call 200f800 <__errno> 20196d8: b0 10 3f ff mov -1, %i0 20196dc: 82 10 20 16 mov 0x16, %g1 20196e0: c2 22 00 00 st %g1, [ %o0 ] 20196e4: 81 c7 e0 08 ret 20196e8: 81 e8 00 00 restore #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 20196ec: 7f ff d8 45 call 200f800 <__errno> <== NOT EXECUTED 20196f0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20196f4: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 20196f8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 20196fc: 81 c7 e0 08 ret <== NOT EXECUTED 2019700: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 020073cc : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 20073cc: 9d e3 bf 98 save %sp, -104, %sp #if 0 register POSIX_Mutex_Control *mutex_in_use; Objects_Locations location; #endif if ( attr ) the_attr = attr; 20073d0: 03 00 80 5e sethi %hi(0x2017800), %g1 20073d4: 80 a6 60 00 cmp %i1, 0 20073d8: 02 80 00 03 be 20073e4 20073dc: a0 10 61 6c or %g1, 0x16c, %l0 20073e0: a0 10 00 19 mov %i1, %l0 else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 20073e4: 80 a6 20 00 cmp %i0, 0 20073e8: 02 80 00 17 be 2007444 20073ec: 01 00 00 00 nop break; } } #endif if ( !the_attr->is_initialized ) 20073f0: c2 04 00 00 ld [ %l0 ], %g1 20073f4: 80 a0 60 00 cmp %g1, 0 20073f8: 02 80 00 13 be 2007444 20073fc: 01 00 00 00 nop /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 2007400: c2 04 20 04 ld [ %l0 + 4 ], %g1 2007404: 80 a0 60 00 cmp %g1, 0 2007408: 12 80 00 4d bne 200753c <== NEVER TAKEN 200740c: 11 00 80 5e sethi %hi(0x2017800), %o0 /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 2007410: c2 04 20 0c ld [ %l0 + 0xc ], %g1 2007414: 80 a0 60 01 cmp %g1, 1 2007418: 02 80 00 37 be 20074f4 200741c: 80 a0 60 02 cmp %g1, 2 2007420: 02 80 00 3c be 2007510 2007424: 80 a0 60 00 cmp %g1, 0 2007428: 12 80 00 07 bne 2007444 200742c: a2 10 20 00 clr %l1 break; default: return EINVAL; } if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 2007430: c2 04 20 08 ld [ %l0 + 8 ], %g1 2007434: 82 00 7f ff add %g1, -1, %g1 2007438: 80 a0 60 fd cmp %g1, 0xfd 200743c: 08 80 00 04 bleu 200744c <== ALWAYS TAKEN 2007440: 05 00 80 65 sethi %hi(0x2019400), %g2 *mutex = the_mutex->Object.id; _Thread_Enable_dispatch(); return 0; } 2007444: 81 c7 e0 08 ret 2007448: 91 e8 20 16 restore %g0, 0x16, %o0 200744c: c2 00 a2 00 ld [ %g2 + 0x200 ], %g1 2007450: 82 00 60 01 inc %g1 2007454: c2 20 a2 00 st %g1, [ %g2 + 0x200 ] * _POSIX_Mutex_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void ) { return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information ); 2007458: 25 00 80 66 sethi %hi(0x2019800), %l2 200745c: 40 00 0a 8d call 2009e90 <_Objects_Allocate> 2007460: 90 14 a1 d0 or %l2, 0x1d0, %o0 ! 20199d0 <_POSIX_Mutex_Information> _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 2007464: b2 92 20 00 orcc %o0, 0, %i1 2007468: 02 80 00 31 be 200752c 200746c: 01 00 00 00 nop _Thread_Enable_dispatch(); return EAGAIN; } the_mutex->process_shared = the_attr->process_shared; 2007470: c2 04 20 04 ld [ %l0 + 4 ], %g1 2007474: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_mutex_attr = &the_mutex->Mutex.Attributes; if ( the_attr->recursive ) 2007478: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 200747c: 80 a0 a0 00 cmp %g2, 0 2007480: 32 80 00 04 bne,a 2007490 <== NEVER TAKEN 2007484: c0 26 60 54 clr [ %i1 + 0x54 ] <== NOT EXECUTED the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; 2007488: 82 10 20 01 mov 1, %g1 200748c: c2 26 60 54 st %g1, [ %i1 + 0x54 ] the_mutex_attr->only_owner_release = TRUE; the_mutex_attr->priority_ceiling = 2007490: c6 04 20 08 ld [ %l0 + 8 ], %g3 if ( the_attr->recursive ) the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; the_mutex_attr->only_owner_release = TRUE; 2007494: 84 10 20 01 mov 1, %g2 the_mutex_attr->priority_ceiling = 2007498: 82 10 20 ff mov 0xff, %g1 200749c: 82 20 40 03 sub %g1, %g3, %g1 /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 20074a0: 92 06 60 54 add %i1, 0x54, %o1 20074a4: 94 10 20 01 mov 1, %o2 if ( the_attr->recursive ) the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; the_mutex_attr->only_owner_release = TRUE; 20074a8: c4 2e 60 58 stb %g2, [ %i1 + 0x58 ] the_mutex_attr->priority_ceiling = 20074ac: c2 26 60 60 st %g1, [ %i1 + 0x60 ] _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 20074b0: e2 26 60 5c st %l1, [ %i1 + 0x5c ] /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 20074b4: 40 00 08 35 call 2009588 <_CORE_mutex_Initialize> 20074b8: 90 06 60 14 add %i1, 0x14, %o0 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 20074bc: c4 06 60 08 ld [ %i1 + 8 ], %g2 20074c0: 82 14 a1 d0 or %l2, 0x1d0, %g1 20074c4: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 20074c8: 03 00 00 3f sethi %hi(0xfc00), %g1 20074cc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20074d0: 82 08 80 01 and %g2, %g1, %g1 20074d4: 83 28 60 02 sll %g1, 2, %g1 20074d8: f2 20 c0 01 st %i1, [ %g3 + %g1 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == FALSE */ the_object->name.name_u32 = name; 20074dc: c0 26 60 0c clr [ %i1 + 0xc ] CORE_MUTEX_UNLOCKED ); _Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 ); *mutex = the_mutex->Object.id; 20074e0: c4 26 00 00 st %g2, [ %i0 ] _Thread_Enable_dispatch(); 20074e4: 40 00 0e 28 call 200ad84 <_Thread_Enable_dispatch> 20074e8: b0 10 20 00 clr %i0 20074ec: 81 c7 e0 08 ret 20074f0: 81 e8 00 00 restore break; default: return EINVAL; } if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 20074f4: c2 04 20 08 ld [ %l0 + 8 ], %g1 20074f8: 82 00 7f ff add %g1, -1, %g1 20074fc: 80 a0 60 fd cmp %g1, 0xfd 2007500: 18 bf ff d1 bgu 2007444 2007504: a2 10 20 02 mov 2, %l1 2007508: 10 bf ff d1 b 200744c 200750c: 05 00 80 65 sethi %hi(0x2019400), %g2 2007510: c2 04 20 08 ld [ %l0 + 8 ], %g1 2007514: 82 00 7f ff add %g1, -1, %g1 2007518: 80 a0 60 fd cmp %g1, 0xfd 200751c: 18 bf ff ca bgu 2007444 <== NEVER TAKEN 2007520: a2 10 20 03 mov 3, %l1 2007524: 10 bf ff ca b 200744c 2007528: 05 00 80 65 sethi %hi(0x2019400), %g2 _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { _Thread_Enable_dispatch(); 200752c: 40 00 0e 16 call 200ad84 <_Thread_Enable_dispatch> 2007530: b0 10 20 0b mov 0xb, %i0 2007534: 81 c7 e0 08 ret 2007538: 81 e8 00 00 restore /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 200753c: 15 00 80 5e sethi %hi(0x2017800), %o2 <== NOT EXECUTED 2007540: 17 00 80 5e sethi %hi(0x2017800), %o3 <== NOT EXECUTED 2007544: 90 12 21 80 or %o0, 0x180, %o0 <== NOT EXECUTED 2007548: 94 12 a2 08 or %o2, 0x208, %o2 <== NOT EXECUTED 200754c: 96 12 e1 d0 or %o3, 0x1d0, %o3 <== NOT EXECUTED 2007550: 7f ff f2 93 call 2003f9c <__assert_func> <== NOT EXECUTED 2007554: 92 10 20 68 mov 0x68, %o1 <== NOT EXECUTED =============================================================================== 020075cc : int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { 20075cc: 9d e3 bf 90 save %sp, -112, %sp register POSIX_Mutex_Control *the_mutex; Objects_Locations location; Priority_Control the_priority; int status; if ( !old_ceiling ) 20075d0: 80 a6 a0 00 cmp %i2, 0 20075d4: 02 80 00 06 be 20075ec 20075d8: a0 10 00 18 mov %i0, %l0 return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 20075dc: 82 06 7f ff add %i1, -1, %g1 20075e0: 80 a0 60 fd cmp %g1, 0xfd 20075e4: 08 80 00 04 bleu 20075f4 20075e8: 01 00 00 00 nop case OBJECTS_ERROR: break; } return EINVAL; } 20075ec: 81 c7 e0 08 ret 20075f0: 91 e8 20 16 restore %g0, 0x16, %o0 /* * Must acquire the mutex before we can change it's ceiling */ status = pthread_mutex_lock( mutex ); 20075f4: 7f ff ff da call 200755c 20075f8: 90 10 00 18 mov %i0, %o0 if ( status ) 20075fc: b0 92 20 00 orcc %o0, 0, %i0 2007600: 12 80 00 14 bne 2007650 2007604: 90 10 00 10 mov %l0, %o0 return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 2007608: 7f ff ff 46 call 2007320 <_POSIX_Mutex_Get> 200760c: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 2007610: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007614: 80 a0 60 00 cmp %g1, 0 2007618: 32 80 00 0e bne,a 2007650 <== NEVER TAKEN 200761c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 2007620: c2 02 20 60 ld [ %o0 + 0x60 ], %g1 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( 2007624: d2 02 20 08 ld [ %o0 + 8 ], %o1 the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 2007628: 84 10 20 ff mov 0xff, %g2 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 200762c: 86 20 80 19 sub %g2, %i1, %g3 the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 2007630: 84 20 80 01 sub %g2, %g1, %g2 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 2007634: c6 22 20 60 st %g3, [ %o0 + 0x60 ] the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 2007638: c4 26 80 00 st %g2, [ %i2 ] the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( 200763c: 94 10 20 00 clr %o2 2007640: 40 00 08 5d call 20097b4 <_CORE_mutex_Surrender> 2007644: 90 02 20 14 add %o0, 0x14, %o0 &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 2007648: 40 00 0d cf call 200ad84 <_Thread_Enable_dispatch> 200764c: 01 00 00 00 nop 2007650: 81 c7 e0 08 ret 2007654: 81 e8 00 00 restore =============================================================================== 02007658 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 2007658: 9d e3 bf 90 save %sp, -112, %sp * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 200765c: 90 10 00 19 mov %i1, %o0 2007660: 40 00 00 2f call 200771c <_POSIX_Absolute_timeout_to_ticks> 2007664: 92 07 bf f4 add %fp, -12, %o1 switch ( status ) { 2007668: 80 a2 20 02 cmp %o0, 2 200766c: 08 80 00 05 bleu 2007680 <== NEVER TAKEN 2007670: d4 07 bf f4 ld [ %fp + -12 ], %o2 2007674: 80 a2 20 03 cmp %o0, 3 2007678: 02 80 00 07 be 2007694 <== ALWAYS TAKEN 200767c: 90 10 00 18 mov %i0, %o0 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 2007680: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2007684: 7f ff ff bc call 2007574 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED 2007688: 92 10 20 00 clr %o1 <== NOT EXECUTED break; } } return lock_status; } 200768c: 81 c7 e0 08 ret <== NOT EXECUTED 2007690: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 2007694: 7f ff ff b8 call 2007574 <_POSIX_Mutex_Lock_support> 2007698: 92 10 20 01 mov 1, %o1 break; } } return lock_status; } 200769c: 81 c7 e0 08 ret 20076a0: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 02007204 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { if ( !attr || !attr->is_initialized ) 2007204: 80 a2 20 00 cmp %o0, 0 2007208: 02 80 00 08 be 2007228 200720c: 01 00 00 00 nop 2007210: c2 02 00 00 ld [ %o0 ], %g1 2007214: 80 a0 60 00 cmp %g1, 0 2007218: 02 80 00 04 be 2007228 200721c: 80 a2 60 01 cmp %o1, 1 return EINVAL; switch ( pshared ) { 2007220: 28 80 00 04 bleu,a 2007230 <== ALWAYS TAKEN 2007224: d2 22 20 04 st %o1, [ %o0 + 4 ] return 0; default: return EINVAL; } } 2007228: 81 c3 e0 08 retl 200722c: 90 10 20 16 mov 0x16, %o0 return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 2007230: 81 c3 e0 08 retl 2007234: 90 10 20 00 clr %o0 =============================================================================== 02006d64 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 2006d64: 9d e3 bf 90 save %sp, -112, %sp if ( !once_control || !init_routine ) 2006d68: a0 96 20 00 orcc %i0, 0, %l0 2006d6c: 02 80 00 0a be 2006d94 2006d70: 80 a6 60 00 cmp %i1, 0 2006d74: 02 80 00 08 be 2006d94 2006d78: 01 00 00 00 nop return EINVAL; if ( !once_control->init_executed ) { 2006d7c: c2 04 20 04 ld [ %l0 + 4 ], %g1 2006d80: 80 a0 60 00 cmp %g1, 0 2006d84: 02 80 00 06 be 2006d9c 2006d88: b0 10 20 00 clr %i0 (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 2006d8c: 81 c7 e0 08 ret 2006d90: 81 e8 00 00 restore int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) 2006d94: 81 c7 e0 08 ret 2006d98: 91 e8 20 16 restore %g0, 0x16, %o0 return EINVAL; if ( !once_control->init_executed ) { rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 2006d9c: b0 07 bf f4 add %fp, -12, %i0 2006da0: 90 10 21 00 mov 0x100, %o0 2006da4: 92 10 21 00 mov 0x100, %o1 2006da8: 40 00 03 ba call 2007c90 2006dac: 94 10 00 18 mov %i0, %o2 if ( !once_control->init_executed ) { 2006db0: c2 04 20 04 ld [ %l0 + 4 ], %g1 2006db4: 80 a0 60 00 cmp %g1, 0 2006db8: 02 80 00 09 be 2006ddc <== ALWAYS TAKEN 2006dbc: 82 10 20 01 mov 1, %g1 once_control->is_initialized = TRUE; once_control->init_executed = TRUE; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 2006dc0: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED 2006dc4: 94 10 00 18 mov %i0, %o2 2006dc8: 92 10 21 00 mov 0x100, %o1 2006dcc: 40 00 03 b1 call 2007c90 2006dd0: b0 10 20 00 clr %i0 } return 0; } 2006dd4: 81 c7 e0 08 ret 2006dd8: 81 e8 00 00 restore if ( !once_control->init_executed ) { rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); if ( !once_control->init_executed ) { once_control->is_initialized = TRUE; once_control->init_executed = TRUE; 2006ddc: c2 24 20 04 st %g1, [ %l0 + 4 ] (*init_routine)(); 2006de0: 9f c6 40 00 call %i1 2006de4: c2 24 00 00 st %g1, [ %l0 ] } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 2006de8: 10 bf ff f7 b 2006dc4 2006dec: d0 07 bf f4 ld [ %fp + -12 ], %o0 =============================================================================== 02006068 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 2006068: 9d e3 bf 88 save %sp, -120, %sp const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 200606c: 80 a6 20 00 cmp %i0, 0 2006070: 02 80 00 26 be 2006108 2006074: a0 10 00 19 mov %i1, %l0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 2006078: 80 a6 60 00 cmp %i1, 0 200607c: 22 80 00 29 be,a 2006120 <== NEVER TAKEN 2006080: a0 07 bf ec add %fp, -20, %l0 <== NOT EXECUTED } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 2006084: c2 04 00 00 ld [ %l0 ], %g1 2006088: 80 a0 60 00 cmp %g1, 0 200608c: 02 80 00 1f be 2006108 <== NEVER TAKEN 2006090: 01 00 00 00 nop return EINVAL; switch ( the_attr->process_shared ) { 2006094: c2 04 20 04 ld [ %l0 + 4 ], %g1 2006098: 80 a0 60 00 cmp %g1, 0 200609c: 12 80 00 1b bne 2006108 <== NEVER TAKEN 20060a0: 05 00 80 6b sethi %hi(0x201ac00), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20060a4: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 201adf0 <_Thread_Dispatch_disable_level> 20060a8: 82 00 60 01 inc %g1 20060ac: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] * This function allocates a RWLock control block from * the inactive chain of free RWLock control blocks. */ RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void ) { return (POSIX_RWLock_Control *) 20060b0: 33 00 80 6c sethi %hi(0x201b000), %i1 20060b4: 40 00 0b 03 call 2008cc0 <_Objects_Allocate> 20060b8: 90 16 60 40 or %i1, 0x40, %o0 ! 201b040 <_POSIX_RWLock_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 20060bc: a0 92 20 00 orcc %o0, 0, %l0 20060c0: 02 80 00 14 be 2006110 20060c4: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 20060c8: 40 00 09 03 call 20084d4 <_CORE_RWLock_Initialize> 20060cc: 92 07 bf f4 add %fp, -12, %o1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 20060d0: c4 04 20 08 ld [ %l0 + 8 ], %g2 20060d4: 82 16 60 40 or %i1, 0x40, %g1 20060d8: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 20060dc: 03 00 00 3f sethi %hi(0xfc00), %g1 20060e0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20060e4: 82 08 80 01 and %g2, %g1, %g1 20060e8: 83 28 60 02 sll %g1, 2, %g1 20060ec: e0 20 c0 01 st %l0, [ %g3 + %g1 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == FALSE */ the_object->name.name_u32 = name; 20060f0: c0 24 20 0c clr [ %l0 + 0xc ] &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 20060f4: c4 26 00 00 st %g2, [ %i0 ] _Thread_Enable_dispatch(); 20060f8: 40 00 0e af call 2009bb4 <_Thread_Enable_dispatch> 20060fc: b0 10 20 00 clr %i0 2006100: 81 c7 e0 08 ret 2006104: 81 e8 00 00 restore return 0; } 2006108: 81 c7 e0 08 ret 200610c: 91 e8 20 16 restore %g0, 0x16, %o0 _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { _Thread_Enable_dispatch(); 2006110: 40 00 0e a9 call 2009bb4 <_Thread_Enable_dispatch> 2006114: b0 10 20 0b mov 0xb, %i0 2006118: 81 c7 e0 08 ret 200611c: 81 e8 00 00 restore * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 2006120: 40 00 02 b5 call 2006bf4 <== NOT EXECUTED 2006124: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 2006128: 10 bf ff d8 b 2006088 <== NOT EXECUTED 200612c: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED =============================================================================== 020061a0 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 20061a0: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations location; Watchdog_Interval ticks; bool do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 20061a4: 80 a6 20 00 cmp %i0, 0 20061a8: 02 80 00 11 be 20061ec 20061ac: 90 10 00 19 mov %i1, %o0 * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 20061b0: 92 07 bf f0 add %fp, -16, %o1 20061b4: 40 00 1e 08 call 200d9d4 <_POSIX_Absolute_timeout_to_ticks> 20061b8: a0 10 20 00 clr %l0 switch (status) { 20061bc: 80 a2 20 02 cmp %o0, 2 20061c0: 18 80 00 0e bgu 20061f8 20061c4: b2 10 00 08 mov %o0, %i1 20061c8: d2 06 00 00 ld [ %i0 ], %o1 20061cc: 11 00 80 6c sethi %hi(0x201b000), %o0 20061d0: 94 07 bf f4 add %fp, -12, %o2 20061d4: 40 00 0c 23 call 2009260 <_Objects_Get> 20061d8: 90 12 20 40 or %o0, 0x40, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20061dc: c2 07 bf f4 ld [ %fp + -12 ], %g1 20061e0: 80 a0 60 00 cmp %g1, 0 20061e4: 22 80 00 11 be,a 2006228 <== NEVER TAKEN 20061e8: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 20061ec: 90 10 20 16 mov 0x16, %o0 case OBJECTS_ERROR: break; } return EINVAL; } 20061f0: 81 c7 e0 08 ret 20061f4: 91 e8 00 08 restore %g0, %o0, %o0 * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); switch (status) { 20061f8: 80 a2 20 03 cmp %o0, 3 20061fc: 12 bf ff f4 bne 20061cc <== NEVER TAKEN 2006200: d2 06 00 00 ld [ %i0 ], %o1 2006204: 11 00 80 6c sethi %hi(0x201b000), %o0 2006208: 94 07 bf f4 add %fp, -12, %o2 200620c: 40 00 0c 15 call 2009260 <_Objects_Get> 2006210: 90 12 20 40 or %o0, 0x40, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2006214: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006218: 80 a0 60 00 cmp %g1, 0 200621c: 12 bf ff f4 bne 20061ec 2006220: a0 10 20 01 mov 1, %l0 case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 2006224: d2 06 00 00 ld [ %i0 ], %o1 2006228: d6 07 bf f0 ld [ %fp + -16 ], %o3 200622c: a0 0c 20 ff and %l0, 0xff, %l0 2006230: 90 02 20 10 add %o0, 0x10, %o0 2006234: 94 10 00 10 mov %l0, %o2 2006238: 40 00 08 b2 call 2008500 <_CORE_RWLock_Obtain_for_reading> 200623c: 98 10 20 00 clr %o4 do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 2006240: 40 00 0e 5d call 2009bb4 <_Thread_Enable_dispatch> 2006244: 01 00 00 00 nop 2006248: 03 00 80 6b sethi %hi(0x201ac00), %g1 if ( !do_wait && 200624c: 80 a4 20 00 cmp %l0, 0 2006250: 12 80 00 0f bne 200628c <== ALWAYS TAKEN 2006254: 86 10 62 b4 or %g1, 0x2b4, %g3 2006258: 03 00 80 6b sethi %hi(0x201ac00), %g1 <== NOT EXECUTED 200625c: c4 00 62 b4 ld [ %g1 + 0x2b4 ], %g2 ! 201aeb4 <_Thread_Executing><== NOT EXECUTED 2006260: 86 10 62 b4 or %g1, 0x2b4, %g3 <== NOT EXECUTED 2006264: c2 00 a0 34 ld [ %g2 + 0x34 ], %g1 <== NOT EXECUTED 2006268: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200626c: 32 80 00 09 bne,a 2006290 <== NOT EXECUTED 2006270: c2 00 c0 00 ld [ %g3 ], %g1 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 2006274: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2006278: 02 bf ff de be 20061f0 <== NOT EXECUTED 200627c: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 2006280: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED 2006284: 08 bf ff db bleu 20061f0 <== NOT EXECUTED 2006288: 90 10 20 74 mov 0x74, %o0 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 200628c: c2 00 c0 00 ld [ %g3 ], %g1 2006290: 40 00 00 44 call 20063a0 <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006294: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 case OBJECTS_ERROR: break; } return EINVAL; } 2006298: 81 c7 e0 08 ret 200629c: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 020062a0 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 20062a0: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations location; Watchdog_Interval ticks; bool do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 20062a4: 80 a6 20 00 cmp %i0, 0 20062a8: 02 80 00 11 be 20062ec 20062ac: 90 10 00 19 mov %i1, %o0 * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 20062b0: 92 07 bf f0 add %fp, -16, %o1 20062b4: 40 00 1d c8 call 200d9d4 <_POSIX_Absolute_timeout_to_ticks> 20062b8: a0 10 20 00 clr %l0 switch (status) { 20062bc: 80 a2 20 02 cmp %o0, 2 20062c0: 18 80 00 0e bgu 20062f8 20062c4: b2 10 00 08 mov %o0, %i1 20062c8: d2 06 00 00 ld [ %i0 ], %o1 20062cc: 11 00 80 6c sethi %hi(0x201b000), %o0 20062d0: 94 07 bf f4 add %fp, -12, %o2 20062d4: 40 00 0b e3 call 2009260 <_Objects_Get> 20062d8: 90 12 20 40 or %o0, 0x40, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20062dc: c2 07 bf f4 ld [ %fp + -12 ], %g1 20062e0: 80 a0 60 00 cmp %g1, 0 20062e4: 22 80 00 11 be,a 2006328 <== NEVER TAKEN 20062e8: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 20062ec: 90 10 20 16 mov 0x16, %o0 case OBJECTS_ERROR: break; } return EINVAL; } 20062f0: 81 c7 e0 08 ret 20062f4: 91 e8 00 08 restore %g0, %o0, %o0 * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); switch (status) { 20062f8: 80 a2 20 03 cmp %o0, 3 20062fc: 12 bf ff f4 bne 20062cc <== NEVER TAKEN 2006300: d2 06 00 00 ld [ %i0 ], %o1 2006304: 11 00 80 6c sethi %hi(0x201b000), %o0 2006308: 94 07 bf f4 add %fp, -12, %o2 200630c: 40 00 0b d5 call 2009260 <_Objects_Get> 2006310: 90 12 20 40 or %o0, 0x40, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2006314: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006318: 80 a0 60 00 cmp %g1, 0 200631c: 12 bf ff f4 bne 20062ec 2006320: a0 10 20 01 mov 1, %l0 case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 2006324: d2 06 00 00 ld [ %i0 ], %o1 2006328: d6 07 bf f0 ld [ %fp + -16 ], %o3 200632c: a0 0c 20 ff and %l0, 0xff, %l0 2006330: 90 02 20 10 add %o0, 0x10, %o0 2006334: 94 10 00 10 mov %l0, %o2 2006338: 40 00 08 a7 call 20085d4 <_CORE_RWLock_Obtain_for_writing> 200633c: 98 10 20 00 clr %o4 do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 2006340: 40 00 0e 1d call 2009bb4 <_Thread_Enable_dispatch> 2006344: 01 00 00 00 nop 2006348: 03 00 80 6b sethi %hi(0x201ac00), %g1 if ( !do_wait && 200634c: 80 a4 20 00 cmp %l0, 0 2006350: 12 80 00 0f bne 200638c <== ALWAYS TAKEN 2006354: 86 10 62 b4 or %g1, 0x2b4, %g3 2006358: 03 00 80 6b sethi %hi(0x201ac00), %g1 <== NOT EXECUTED 200635c: c4 00 62 b4 ld [ %g1 + 0x2b4 ], %g2 ! 201aeb4 <_Thread_Executing><== NOT EXECUTED 2006360: 86 10 62 b4 or %g1, 0x2b4, %g3 <== NOT EXECUTED 2006364: c2 00 a0 34 ld [ %g2 + 0x34 ], %g1 <== NOT EXECUTED 2006368: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200636c: 32 80 00 09 bne,a 2006390 <== NOT EXECUTED 2006370: c2 00 c0 00 ld [ %g3 ], %g1 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 2006374: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2006378: 02 bf ff de be 20062f0 <== NOT EXECUTED 200637c: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 2006380: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED 2006384: 08 bf ff db bleu 20062f0 <== NOT EXECUTED 2006388: 90 10 20 74 mov 0x74, %o0 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 200638c: c2 00 c0 00 ld [ %g3 ], %g1 2006390: 40 00 00 04 call 20063a0 <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006394: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 case OBJECTS_ERROR: break; } return EINVAL; } 2006398: 81 c7 e0 08 ret 200639c: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 02006c18 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { if ( !attr ) 2006c18: 80 a2 20 00 cmp %o0, 0 2006c1c: 02 80 00 08 be 2006c3c 2006c20: 01 00 00 00 nop return EINVAL; if ( !attr->is_initialized ) 2006c24: c2 02 00 00 ld [ %o0 ], %g1 2006c28: 80 a0 60 00 cmp %g1, 0 2006c2c: 02 80 00 04 be 2006c3c 2006c30: 80 a2 60 01 cmp %o1, 1 return EINVAL; switch ( pshared ) { 2006c34: 28 80 00 04 bleu,a 2006c44 <== ALWAYS TAKEN 2006c38: d2 22 20 04 st %o1, [ %o0 + 4 ] return 0; default: return EINVAL; } } 2006c3c: 81 c3 e0 08 retl 2006c40: 90 10 20 16 mov 0x16, %o0 return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 2006c44: 81 c3 e0 08 retl 2006c48: 90 10 20 00 clr %o0 =============================================================================== 020057b0 : int pthread_setcancelstate( int state, int *oldstate ) { 20057b0: 9d e3 bf 98 save %sp, -104, %sp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 20057b4: 03 00 80 59 sethi %hi(0x2016400), %g1 20057b8: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 20165d0 <_ISR_Nest_level> int pthread_setcancelstate( int state, int *oldstate ) { 20057bc: 88 10 00 18 mov %i0, %g4 * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 20057c0: 80 a0 a0 00 cmp %g2, 0 20057c4: 12 80 00 1a bne 200582c <== NEVER TAKEN 20057c8: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldstate ) 20057cc: 80 a6 60 00 cmp %i1, 0 20057d0: 02 80 00 04 be 20057e0 <== NEVER TAKEN 20057d4: 80 a1 20 01 cmp %g4, 1 return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 20057d8: 08 80 00 04 bleu 20057e8 <== ALWAYS TAKEN 20057dc: 07 00 80 59 sethi %hi(0x2016400), %g3 _Thread_Enable_dispatch(); if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 20057e0: 81 c7 e0 08 ret <== NOT EXECUTED 20057e4: 91 e8 20 16 restore %g0, 0x16, %o0 <== NOT EXECUTED return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 20057e8: 31 00 80 59 sethi %hi(0x2016400), %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20057ec: c2 00 e1 30 ld [ %g3 + 0x130 ], %g1 20057f0: c4 06 21 f4 ld [ %i0 + 0x1f4 ], %g2 20057f4: 82 00 60 01 inc %g1 20057f8: c4 00 a1 6c ld [ %g2 + 0x16c ], %g2 20057fc: c2 20 e1 30 st %g1, [ %g3 + 0x130 ] _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 2005800: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2005804: 80 a1 20 00 cmp %g4, 0 return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 2005808: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 200580c: 12 80 00 06 bne 2005824 <== NEVER TAKEN 2005810: c8 20 a0 cc st %g4, [ %g2 + 0xcc ] 2005814: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 2005818: 80 a0 60 01 cmp %g1, 1 200581c: 22 80 00 06 be,a 2005834 <== NEVER TAKEN 2005820: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 2005824: 40 00 0b 6b call 20085d0 <_Thread_Enable_dispatch> 2005828: b0 10 20 00 clr %i0 200582c: 81 c7 e0 08 ret 2005830: 81 e8 00 00 restore _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2005834: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2005838: 02 bf ff fb be 2005824 <== NOT EXECUTED 200583c: 01 00 00 00 nop <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 2005840: 40 00 0b 64 call 20085d0 <_Thread_Enable_dispatch> <== NOT EXECUTED 2005844: 01 00 00 00 nop <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 2005848: d0 06 21 f4 ld [ %i0 + 0x1f4 ], %o0 <== NOT EXECUTED 200584c: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED 2005850: 7f ff fe cc call 2005380 <_POSIX_Thread_Exit> <== NOT EXECUTED 2005854: b0 10 20 00 clr %i0 <== NOT EXECUTED 2005858: 81 c7 e0 08 ret <== NOT EXECUTED 200585c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02005860 : int pthread_setcanceltype( int type, int *oldtype ) { 2005860: 9d e3 bf 98 save %sp, -104, %sp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 2005864: 03 00 80 59 sethi %hi(0x2016400), %g1 2005868: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 20165d0 <_ISR_Nest_level> int pthread_setcanceltype( int type, int *oldtype ) { 200586c: 88 10 00 18 mov %i0, %g4 * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 2005870: 80 a0 a0 00 cmp %g2, 0 2005874: 12 80 00 1a bne 20058dc <== NEVER TAKEN 2005878: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldtype ) 200587c: 80 a6 60 00 cmp %i1, 0 2005880: 02 80 00 04 be 2005890 <== NEVER TAKEN 2005884: 80 a1 20 01 cmp %g4, 1 return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 2005888: 08 80 00 04 bleu 2005898 <== ALWAYS TAKEN 200588c: 07 00 80 59 sethi %hi(0x2016400), %g3 _Thread_Enable_dispatch(); if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 2005890: 81 c7 e0 08 ret <== NOT EXECUTED 2005894: 91 e8 20 16 restore %g0, 0x16, %o0 <== NOT EXECUTED return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2005898: 31 00 80 59 sethi %hi(0x2016400), %i0 200589c: c2 00 e1 30 ld [ %g3 + 0x130 ], %g1 20058a0: c4 06 21 f4 ld [ %i0 + 0x1f4 ], %g2 20058a4: 82 00 60 01 inc %g1 20058a8: c2 20 e1 30 st %g1, [ %g3 + 0x130 ] 20058ac: c6 00 a1 6c ld [ %g2 + 0x16c ], %g3 _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 20058b0: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 20058b4: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_type = type; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 20058b8: c4 00 e0 cc ld [ %g3 + 0xcc ], %g2 20058bc: 80 a0 a0 00 cmp %g2, 0 20058c0: 12 80 00 05 bne 20058d4 <== NEVER TAKEN 20058c4: c8 20 e0 d0 st %g4, [ %g3 + 0xd0 ] 20058c8: 80 a1 20 01 cmp %g4, 1 20058cc: 22 80 00 06 be,a 20058e4 20058d0: c2 00 e0 d4 ld [ %g3 + 0xd4 ], %g1 thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 20058d4: 40 00 0b 3f call 20085d0 <_Thread_Enable_dispatch> 20058d8: b0 10 20 00 clr %i0 20058dc: 81 c7 e0 08 ret 20058e0: 81 e8 00 00 restore _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; thread_support->cancelability_type = type; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 20058e4: 80 a0 60 00 cmp %g1, 0 20058e8: 02 bf ff fb be 20058d4 <== ALWAYS TAKEN 20058ec: 01 00 00 00 nop thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 20058f0: 40 00 0b 38 call 20085d0 <_Thread_Enable_dispatch> <== NOT EXECUTED 20058f4: 01 00 00 00 nop <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 20058f8: d0 06 21 f4 ld [ %i0 + 0x1f4 ], %o0 <== NOT EXECUTED 20058fc: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED 2005900: 7f ff fe a0 call 2005380 <_POSIX_Thread_Exit> <== NOT EXECUTED 2005904: b0 10 20 00 clr %i0 <== NOT EXECUTED 2005908: 81 c7 e0 08 ret <== NOT EXECUTED 200590c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02007f90 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 2007f90: 9d e3 bf 90 save %sp, -112, %sp /* * Check all the parameters */ if ( !param ) 2007f94: 80 a6 a0 00 cmp %i2, 0 2007f98: 22 80 00 41 be,a 200809c 2007f9c: b0 10 20 16 mov 0x16, %i0 return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 2007fa0: c2 06 80 00 ld [ %i2 ], %g1 2007fa4: 82 00 7f ff add %g1, -1, %g1 2007fa8: 80 a0 60 fd cmp %g1, 0xfd 2007fac: 18 80 00 0a bgu 2007fd4 <== NEVER TAKEN 2007fb0: 80 a6 60 01 cmp %i1, 1 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 2007fb4: 02 80 00 0a be 2007fdc 2007fb8: a4 10 20 00 clr %l2 2007fbc: 04 80 00 4d ble 20080f0 2007fc0: 80 a6 60 02 cmp %i1, 2 2007fc4: 02 80 00 48 be 20080e4 2007fc8: 80 a6 60 03 cmp %i1, 3 2007fcc: 02 80 00 36 be 20080a4 <== ALWAYS TAKEN 2007fd0: 01 00 00 00 nop case OBJECTS_ERROR: break; } return ESRCH; } 2007fd4: 81 c7 e0 08 ret 2007fd8: 91 e8 20 16 restore %g0, 0x16, %o0 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 2007fdc: a6 10 20 00 clr %l3 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 2007fe0: 92 10 00 18 mov %i0, %o1 2007fe4: 11 00 80 66 sethi %hi(0x2019800), %o0 2007fe8: 94 07 bf f4 add %fp, -12, %o2 2007fec: 40 00 09 11 call 200a430 <_Objects_Get> 2007ff0: 90 12 20 90 or %o0, 0x90, %o0 /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2007ff4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007ff8: a2 10 00 08 mov %o0, %l1 2007ffc: 80 a0 60 00 cmp %g1, 0 2008000: 12 80 00 27 bne 200809c 2008004: b0 10 20 03 mov 3, %i0 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 2008008: e0 02 21 6c ld [ %o0 + 0x16c ], %l0 if ( api->schedpolicy == SCHED_SPORADIC ) 200800c: c2 04 20 7c ld [ %l0 + 0x7c ], %g1 2008010: 80 a0 60 03 cmp %g1, 3 2008014: 02 80 00 46 be 200812c 2008018: 01 00 00 00 nop (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; 200801c: f2 24 20 7c st %i1, [ %l0 + 0x7c ] api->schedparam = *param; 2008020: c6 06 80 00 ld [ %i2 ], %g3 the_thread->budget_algorithm = budget_algorithm; 2008024: e4 24 60 7c st %l2, [ %l1 + 0x7c ] if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; 2008028: c6 24 20 80 st %g3, [ %l0 + 0x80 ] 200802c: c2 06 a0 04 ld [ %i2 + 4 ], %g1 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; 2008030: e6 24 60 80 st %l3, [ %l1 + 0x80 ] if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; 2008034: c2 24 20 84 st %g1, [ %l0 + 0x84 ] 2008038: c4 06 a0 08 ld [ %i2 + 8 ], %g2 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 200803c: 80 a6 60 00 cmp %i1, 0 if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; 2008040: c4 24 20 88 st %g2, [ %l0 + 0x88 ] 2008044: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 2008048: c2 24 20 8c st %g1, [ %l0 + 0x8c ] 200804c: c4 06 a0 10 ld [ %i2 + 0x10 ], %g2 2008050: c4 24 20 90 st %g2, [ %l0 + 0x90 ] 2008054: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 2008058: 06 80 00 0f bl 2008094 <== NEVER TAKEN 200805c: c2 24 20 94 st %g1, [ %l0 + 0x94 ] 2008060: 80 a6 60 02 cmp %i1, 2 2008064: 14 80 00 29 bg 2008108 2008068: 80 a6 60 03 cmp %i1, 3 200806c: c6 04 20 80 ld [ %l0 + 0x80 ], %g3 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 2008070: 03 00 80 65 sethi %hi(0x2019400), %g1 2008074: c4 00 61 58 ld [ %g1 + 0x158 ], %g2 ! 2019558 <_Thread_Ticks_per_timeslice> 2008078: 92 10 20 ff mov 0xff, %o1 the_thread->real_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 200807c: 90 10 00 11 mov %l1, %o0 2008080: 92 22 40 03 sub %o1, %g3, %o1 switch ( api->schedpolicy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 2008084: c4 24 60 78 st %g2, [ %l1 + 0x78 ] the_thread->real_priority = 2008088: d2 24 60 18 st %o1, [ %l1 + 0x18 ] _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 200808c: 40 00 09 a8 call 200a72c <_Thread_Change_priority> 2008090: 94 10 20 01 mov 1, %o2 _Watchdog_Remove( &api->Sporadic_timer ); _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); break; } _Thread_Enable_dispatch(); 2008094: 40 00 0b 3c call 200ad84 <_Thread_Enable_dispatch> 2008098: b0 10 20 00 clr %i0 200809c: 81 c7 e0 08 ret 20080a0: 81 e8 00 00 restore case SCHED_SPORADIC: budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; budget_callout = _POSIX_Threads_Sporadic_budget_callout; if ( _Timespec_To_ticks( ¶m->ss_replenish_period ) < 20080a4: 40 00 0f 59 call 200be08 <_Timespec_To_ticks> 20080a8: 90 06 a0 08 add %i2, 8, %o0 20080ac: a0 10 00 08 mov %o0, %l0 20080b0: 40 00 0f 56 call 200be08 <_Timespec_To_ticks> 20080b4: 90 06 a0 10 add %i2, 0x10, %o0 20080b8: 80 a4 00 08 cmp %l0, %o0 20080bc: 2a bf ff f8 bcs,a 200809c <== NEVER TAKEN 20080c0: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED _Timespec_To_ticks( ¶m->ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->ss_low_priority ) ) 20080c4: c2 06 a0 04 ld [ %i2 + 4 ], %g1 20080c8: 82 00 7f ff add %g1, -1, %g1 20080cc: 80 a0 60 fd cmp %g1, 0xfd 20080d0: 18 bf ff c1 bgu 2007fd4 20080d4: 03 00 80 1f sethi %hi(0x2007c00), %g1 20080d8: a4 10 20 03 mov 3, %l2 20080dc: 10 bf ff c1 b 2007fe0 20080e0: a6 10 62 ac or %g1, 0x2ac, %l3 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 20080e4: a4 10 20 02 mov 2, %l2 20080e8: 10 bf ff be b 2007fe0 20080ec: a6 10 20 00 clr %l3 20080f0: 80 a6 60 00 cmp %i1, 0 20080f4: a4 10 20 01 mov 1, %l2 20080f8: 02 bf ff ba be 2007fe0 20080fc: a6 10 20 00 clr %l3 _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); break; } _Thread_Enable_dispatch(); return 0; 2008100: 81 c7 e0 08 ret 2008104: 91 e8 20 16 restore %g0, 0x16, %o0 api->schedpolicy = policy; api->schedparam = *param; the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 2008108: 12 bf ff e3 bne 2008094 <== NEVER TAKEN 200810c: 01 00 00 00 nop TRUE ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 2008110: c6 24 20 98 st %g3, [ %l0 + 0x98 ] _Watchdog_Remove( &api->Sporadic_timer ); 2008114: 40 00 10 bd call 200c408 <_Watchdog_Remove> 2008118: 90 04 20 9c add %l0, 0x9c, %o0 _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 200811c: 92 10 00 11 mov %l1, %o1 2008120: 7f ff ff 77 call 2007efc <_POSIX_Threads_Sporadic_budget_TSR> 2008124: 90 10 20 00 clr %o0 2008128: 30 bf ff db b,a 2008094 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 200812c: 40 00 10 b7 call 200c408 <_Watchdog_Remove> 2008130: 90 04 20 9c add %l0, 0x9c, %o0 api->schedpolicy = policy; 2008134: 10 bf ff bb b 2008020 2008138: f2 24 20 7c st %i1, [ %l0 + 0x7c ] =============================================================================== 02005934 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 2005934: 9d e3 bf 98 save %sp, -104, %sp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 2005938: 03 00 80 59 sethi %hi(0x2016400), %g1 200593c: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 20165d0 <_ISR_Nest_level> 2005940: 80 a0 a0 00 cmp %g2, 0 2005944: 12 80 00 15 bne 2005998 <== NEVER TAKEN 2005948: 07 00 80 59 sethi %hi(0x2016400), %g3 return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 200594c: 33 00 80 59 sethi %hi(0x2016400), %i1 2005950: c2 00 e1 30 ld [ %g3 + 0x130 ], %g1 2005954: c4 06 61 f4 ld [ %i1 + 0x1f4 ], %g2 2005958: 82 00 60 01 inc %g1 200595c: c4 00 a1 6c ld [ %g2 + 0x16c ], %g2 2005960: c2 20 e1 30 st %g1, [ %g3 + 0x130 ] _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2005964: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 2005968: 80 a0 60 00 cmp %g1, 0 200596c: 12 80 00 0d bne 20059a0 <== NEVER TAKEN 2005970: 01 00 00 00 nop 2005974: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 2005978: 80 a0 60 00 cmp %g1, 0 200597c: 02 80 00 09 be 20059a0 2005980: 01 00 00 00 nop thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 2005984: 40 00 0b 13 call 20085d0 <_Thread_Enable_dispatch> 2005988: 01 00 00 00 nop if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 200598c: f0 06 61 f4 ld [ %i1 + 0x1f4 ], %i0 2005990: 7f ff fe 7c call 2005380 <_POSIX_Thread_Exit> 2005994: 93 e8 3f ff restore %g0, -1, %o1 2005998: 81 c7 e0 08 ret <== NOT EXECUTED 200599c: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 20059a0: 40 00 0b 0c call 20085d0 <_Thread_Enable_dispatch> 20059a4: 81 e8 00 00 restore =============================================================================== 02005d1c : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 2005d1c: 9d e3 bf 90 save %sp, -112, %sp Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 2005d20: a2 96 20 00 orcc %i0, 0, %l1 2005d24: 02 80 00 25 be 2005db8 <== NEVER TAKEN 2005d28: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2005d2c: 80 a6 e0 00 cmp %i3, 0 2005d30: 02 80 00 22 be 2005db8 <== NEVER TAKEN 2005d34: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 2005d38: 80 8e 60 10 btst 0x10, %i1 2005d3c: 02 80 00 21 be 2005dc0 2005d40: 80 a6 a0 00 cmp %i2, 0 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 2005d44: 02 80 00 1d be 2005db8 2005d48: b0 10 20 0a mov 0xa, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005d4c: 05 00 80 71 sethi %hi(0x201c400), %g2 2005d50: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 201c5d0 <_Thread_Dispatch_disable_level> if ( !id ) return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 2005d54: c0 27 bf f0 clr [ %fp + -16 ] 2005d58: 82 00 60 01 inc %g1 if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 2005d5c: f4 27 bf f4 st %i2, [ %fp + -12 ] 2005d60: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] * This function allocates a barrier control block from * the inactive chain of free barrier control blocks. */ RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Allocate( void ) { return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information ); 2005d64: 21 00 80 71 sethi %hi(0x201c400), %l0 2005d68: 40 00 08 13 call 2007db4 <_Objects_Allocate> 2005d6c: 90 14 20 54 or %l0, 0x54, %o0 ! 201c454 <_Barrier_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 2005d70: b4 92 20 00 orcc %o0, 0, %i2 2005d74: 02 80 00 20 be 2005df4 <== NEVER TAKEN 2005d78: 90 06 a0 14 add %i2, 0x14, %o0 return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 2005d7c: 92 07 bf f0 add %fp, -16, %o1 2005d80: 40 00 05 b4 call 2007450 <_CORE_barrier_Initialize> 2005d84: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2005d88: c4 06 a0 08 ld [ %i2 + 8 ], %g2 2005d8c: 82 14 20 54 or %l0, 0x54, %g1 information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 2005d90: e2 26 a0 0c st %l1, [ %i2 + 0xc ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2005d94: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 2005d98: c4 26 c0 00 st %g2, [ %i3 ] 2005d9c: 03 00 00 3f sethi %hi(0xfc00), %g1 2005da0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005da4: 84 08 80 01 and %g2, %g1, %g2 2005da8: 85 28 a0 02 sll %g2, 2, %g2 _Thread_Enable_dispatch(); 2005dac: b0 10 20 00 clr %i0 2005db0: 40 00 0b ec call 2008d60 <_Thread_Enable_dispatch> 2005db4: f4 20 c0 02 st %i2, [ %g3 + %g2 ] return RTEMS_SUCCESSFUL; } 2005db8: 81 c7 e0 08 ret 2005dbc: 81 e8 00 00 restore if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 2005dc0: 82 10 20 01 mov 1, %g1 2005dc4: 05 00 80 71 sethi %hi(0x201c400), %g2 2005dc8: c2 27 bf f0 st %g1, [ %fp + -16 ] 2005dcc: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 the_attributes.maximum_count = maximum_waiters; 2005dd0: f4 27 bf f4 st %i2, [ %fp + -12 ] 2005dd4: 82 00 60 01 inc %g1 2005dd8: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] 2005ddc: 21 00 80 71 sethi %hi(0x201c400), %l0 2005de0: 40 00 07 f5 call 2007db4 <_Objects_Allocate> 2005de4: 90 14 20 54 or %l0, 0x54, %o0 ! 201c454 <_Barrier_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 2005de8: b4 92 20 00 orcc %o0, 0, %i2 2005dec: 12 bf ff e4 bne 2005d7c 2005df0: 90 06 a0 14 add %i2, 0x14, %o0 _Thread_Enable_dispatch(); 2005df4: 40 00 0b db call 2008d60 <_Thread_Enable_dispatch> 2005df8: b0 10 20 05 mov 5, %i0 2005dfc: 81 c7 e0 08 ret 2005e00: 81 e8 00 00 restore =============================================================================== 02005ea4 : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 2005ea4: 9d e3 bf 90 save %sp, -112, %sp 2005ea8: a0 10 00 18 mov %i0, %l0 Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 2005eac: 80 a6 60 00 cmp %i1, 0 2005eb0: 02 80 00 12 be 2005ef8 <== NEVER TAKEN 2005eb4: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 2005eb8: 11 00 80 71 sethi %hi(0x201c400), %o0 2005ebc: 92 10 00 10 mov %l0, %o1 2005ec0: 90 12 20 54 or %o0, 0x54, %o0 2005ec4: 40 00 09 24 call 2008354 <_Objects_Get> 2005ec8: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2005ecc: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005ed0: 80 a0 60 00 cmp %g1, 0 2005ed4: 12 80 00 09 bne 2005ef8 2005ed8: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL ); 2005edc: 92 10 00 10 mov %l0, %o1 2005ee0: 94 10 20 00 clr %o2 2005ee4: 40 00 05 67 call 2007480 <_CORE_barrier_Release> 2005ee8: 90 02 20 14 add %o0, 0x14, %o0 _Thread_Enable_dispatch(); 2005eec: b0 10 20 00 clr %i0 2005ef0: 40 00 0b 9c call 2008d60 <_Thread_Enable_dispatch> 2005ef4: d0 26 40 00 st %o0, [ %i1 ] case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2005ef8: 81 c7 e0 08 ret 2005efc: 81 e8 00 00 restore =============================================================================== 02004ee8 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 2004ee8: 9d e3 bf 98 save %sp, -104, %sp 2004eec: 82 10 00 18 mov %i0, %g1 if ( !time_buffer ) 2004ef0: 80 a6 60 00 cmp %i1, 0 2004ef4: 02 80 00 10 be 2004f34 <== NEVER TAKEN 2004ef8: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; switch ( option ) { 2004efc: 80 a0 60 04 cmp %g1, 4 2004f00: 18 80 00 0d bgu 2004f34 2004f04: b0 10 20 0a mov 0xa, %i0 2004f08: 83 28 60 02 sll %g1, 2, %g1 2004f0c: 05 00 80 13 sethi %hi(0x2004c00), %g2 2004f10: 84 10 a2 d4 or %g2, 0x2d4, %g2 ! 2004ed4 2004f14: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2004f18: 81 c0 c0 00 jmp %g3 2004f1c: 01 00 00 00 nop *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TIME_VALUE: return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 2004f20: 40 00 00 5a call 2005088 2004f24: 91 e8 00 19 restore %g0, %i1, %o0 return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_per_second(); 2004f28: 40 00 00 1d call 2004f9c 2004f2c: b0 10 20 00 clr %i0 2004f30: d0 26 40 00 st %o0, [ %i1 ] 2004f34: 81 c7 e0 08 ret 2004f38: 81 e8 00 00 restore return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_since_boot(); 2004f3c: 40 00 00 20 call 2004fbc 2004f40: b0 10 20 00 clr %i0 2004f44: d0 26 40 00 st %o0, [ %i1 ] 2004f48: 81 c7 e0 08 ret 2004f4c: 81 e8 00 00 restore switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 2004f50: 40 00 00 05 call 2004f64 2004f54: 91 e8 00 19 restore %g0, %i1, %o0 if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 2004f58: 40 00 00 1d call 2004fcc 2004f5c: 91 e8 00 19 restore %g0, %i1, %o0 =============================================================================== 02004f64 : rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { if ( !the_interval ) 2004f64: 86 92 20 00 orcc %o0, 0, %g3 2004f68: 02 80 00 0b be 2004f94 <== NEVER TAKEN 2004f6c: 90 10 20 09 mov 9, %o0 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 2004f70: 03 00 80 60 sethi %hi(0x2018000), %g1 2004f74: c4 08 63 24 ldub [ %g1 + 0x324 ], %g2 ! 2018324 <_TOD_Is_set> 2004f78: 80 a0 a0 00 cmp %g2, 0 2004f7c: 02 80 00 06 be 2004f94 2004f80: 90 10 20 0b mov 0xb, %o0 return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; 2004f84: 03 00 80 60 sethi %hi(0x2018000), %g1 2004f88: c4 00 63 a4 ld [ %g1 + 0x3a4 ], %g2 ! 20183a4 <_TOD_Now> 2004f8c: 90 10 20 00 clr %o0 2004f90: c4 20 c0 00 st %g2, [ %g3 ] return RTEMS_SUCCESSFUL; } 2004f94: 81 c3 e0 08 retl =============================================================================== 02004fcc : #include rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_buffer ) { 2004fcc: 9d e3 bf 60 save %sp, -160, %sp rtems_time_of_day *tmbuf = time_buffer; struct tm time; struct timeval now; if ( !time_buffer ) 2004fd0: a2 96 20 00 orcc %i0, 0, %l1 2004fd4: 02 80 00 2b be 2005080 <== NEVER TAKEN 2004fd8: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 2004fdc: 03 00 80 60 sethi %hi(0x2018000), %g1 2004fe0: c4 08 63 24 ldub [ %g1 + 0x324 ], %g2 ! 2018324 <_TOD_Is_set> 2004fe4: 80 a0 a0 00 cmp %g2, 0 2004fe8: 02 80 00 26 be 2005080 2004fec: b0 10 20 0b mov 0xb, %i0 ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 2004ff0: 7f ff f3 7d call 2001de4 2004ff4: 01 00 00 00 nop 2004ff8: a0 10 00 08 mov %o0, %l0 _TOD_Get( &now ); 2004ffc: 40 00 06 13 call 2006848 <_TOD_Get> 2005000: 90 07 bf e8 add %fp, -24, %o0 _ISR_Enable(level); 2005004: 7f ff f3 7c call 2001df4 2005008: 90 10 00 10 mov %l0, %o0 time->tv_sec = now.tv_sec; 200500c: c2 07 bf e8 ld [ %fp + -24 ], %g1 time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 2005010: d0 07 bf ec ld [ %fp + -20 ], %o0 _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 2005014: c2 27 bf f0 st %g1, [ %fp + -16 ] time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 2005018: 40 00 3d 89 call 201463c <.udiv> 200501c: 92 10 23 e8 mov 0x3e8, %o1 /* Obtain the current time */ _TOD_Get_timeval( &now ); /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 2005020: 92 07 bf c4 add %fp, -60, %o1 2005024: d0 27 bf f4 st %o0, [ %fp + -12 ] 2005028: 40 00 24 a7 call 200e2c4 200502c: 90 07 bf f0 add %fp, -16, %o0 /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; 2005030: c4 07 bf d0 ld [ %fp + -48 ], %g2 tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 2005034: 03 00 80 61 sethi %hi(0x2018400), %g1 2005038: d0 07 bf f4 ld [ %fp + -12 ], %o0 200503c: d2 00 60 b0 ld [ %g1 + 0xb0 ], %o1 gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; 2005040: c4 24 60 08 st %g2, [ %l1 + 8 ] tmbuf->hour = time.tm_hour; 2005044: c2 07 bf cc ld [ %fp + -52 ], %g1 tmbuf->minute = time.tm_min; 2005048: c4 07 bf c8 ld [ %fp + -56 ], %g2 /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; 200504c: c2 24 60 0c st %g1, [ %l1 + 0xc ] tmbuf->minute = time.tm_min; 2005050: c4 24 60 10 st %g2, [ %l1 + 0x10 ] /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 2005054: c2 07 bf d8 ld [ %fp + -40 ], %g1 tmbuf->month = time.tm_mon + 1; 2005058: c4 07 bf d4 ld [ %fp + -44 ], %g2 tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; 200505c: c6 07 bf c4 ld [ %fp + -60 ], %g3 /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 2005060: 82 00 67 6c add %g1, 0x76c, %g1 tmbuf->month = time.tm_mon + 1; 2005064: 84 00 a0 01 inc %g2 tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; 2005068: c6 24 60 14 st %g3, [ %l1 + 0x14 ] /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 200506c: c2 24 40 00 st %g1, [ %l1 ] tmbuf->month = time.tm_mon + 1; 2005070: c4 24 60 04 st %g2, [ %l1 + 4 ] tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 2005074: 40 00 3d 72 call 201463c <.udiv> 2005078: b0 10 20 00 clr %i0 200507c: d0 24 60 18 st %o0, [ %l1 + 0x18 ] return RTEMS_SUCCESSFUL; } 2005080: 81 c7 e0 08 ret 2005084: 81 e8 00 00 restore =============================================================================== 02005088 : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 2005088: 9d e3 bf 90 save %sp, -112, %sp if ( !time ) 200508c: a2 96 20 00 orcc %i0, 0, %l1 2005090: 02 80 00 15 be 20050e4 <== NEVER TAKEN 2005094: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 2005098: 03 00 80 60 sethi %hi(0x2018000), %g1 200509c: c4 08 63 24 ldub [ %g1 + 0x324 ], %g2 ! 2018324 <_TOD_Is_set> 20050a0: 80 a0 a0 00 cmp %g2, 0 20050a4: 02 80 00 10 be 20050e4 20050a8: b0 10 20 0b mov 0xb, %i0 ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 20050ac: 7f ff f3 4e call 2001de4 20050b0: 01 00 00 00 nop 20050b4: a0 10 00 08 mov %o0, %l0 _TOD_Get( &now ); 20050b8: 40 00 05 e4 call 2006848 <_TOD_Get> 20050bc: 90 07 bf f0 add %fp, -16, %o0 _ISR_Enable(level); 20050c0: 7f ff f3 4d call 2001df4 20050c4: 90 10 00 10 mov %l0, %o0 time->tv_sec = now.tv_sec; time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 20050c8: d0 07 bf f4 ld [ %fp + -12 ], %o0 _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 20050cc: c2 07 bf f0 ld [ %fp + -16 ], %g1 time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 20050d0: 92 10 23 e8 mov 0x3e8, %o1 _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 20050d4: c2 24 40 00 st %g1, [ %l1 ] time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 20050d8: 40 00 3d 59 call 201463c <.udiv> 20050dc: b0 10 20 00 clr %i0 20050e0: d0 24 60 04 st %o0, [ %l1 + 4 ] return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; } 20050e4: 81 c7 e0 08 ret 20050e8: 81 e8 00 00 restore =============================================================================== 020052e0 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 20052e0: 9d e3 bf 98 save %sp, -104, %sp if ( !uptime ) 20052e4: 90 96 20 00 orcc %i0, 0, %o0 20052e8: 02 80 00 04 be 20052f8 <== NEVER TAKEN 20052ec: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); 20052f0: 40 00 06 6c call 2006ca0 <_TOD_Get_uptime> 20052f4: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 20052f8: 81 c7 e0 08 ret 20052fc: 81 e8 00 00 restore =============================================================================== 020062d4 : */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) { 20062d4: 9d e3 bf 90 save %sp, -112, %sp struct timespec newtime; if ( !time_buffer ) 20062d8: a0 96 20 00 orcc %i0, 0, %l0 20062dc: 02 80 00 08 be 20062fc <== NEVER TAKEN 20062e0: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { 20062e4: 90 10 00 10 mov %l0, %o0 20062e8: 40 00 00 6b call 2006494 <_TOD_Validate> 20062ec: b0 10 20 14 mov 0x14, %i0 20062f0: 80 8a 20 ff btst 0xff, %o0 20062f4: 12 80 00 04 bne 2006304 20062f8: 01 00 00 00 nop _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 20062fc: 81 c7 e0 08 ret 2006300: 81 e8 00 00 restore if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { newtime.tv_sec = _TOD_To_seconds( time_buffer ); 2006304: 40 00 00 2f call 20063c0 <_TOD_To_seconds> 2006308: 90 10 00 10 mov %l0, %o0 newtime.tv_nsec = time_buffer->ticks * 200630c: 03 00 80 93 sethi %hi(0x2024c00), %g1 if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { newtime.tv_sec = _TOD_To_seconds( time_buffer ); 2006310: d0 27 bf f0 st %o0, [ %fp + -16 ] newtime.tv_nsec = time_buffer->ticks * 2006314: d2 00 63 00 ld [ %g1 + 0x300 ], %o1 2006318: 40 00 46 74 call 2017ce8 <.umul> 200631c: d0 04 20 18 ld [ %l0 + 0x18 ], %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006320: 07 00 80 93 sethi %hi(0x2024c00), %g3 2006324: c4 00 e1 60 ld [ %g3 + 0x160 ], %g2 ! 2024d60 <_Thread_Dispatch_disable_level> 2006328: 89 2a 20 02 sll %o0, 2, %g4 200632c: 84 00 a0 01 inc %g2 2006330: 83 2a 20 07 sll %o0, 7, %g1 2006334: c4 20 e1 60 st %g2, [ %g3 + 0x160 ] 2006338: 82 20 40 04 sub %g1, %g4, %g1 200633c: 82 00 40 08 add %g1, %o0, %g1 2006340: 83 28 60 03 sll %g1, 3, %g1 2006344: c2 27 bf f4 st %g1, [ %fp + -12 ] (_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND); _Thread_Disable_dispatch(); _TOD_Set( &newtime ); 2006348: 90 07 bf f0 add %fp, -16, %o0 200634c: 40 00 07 36 call 2008024 <_TOD_Set> 2006350: b0 10 20 00 clr %i0 _Thread_Enable_dispatch(); 2006354: 40 00 0c 6b call 2009500 <_Thread_Enable_dispatch> 2006358: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 200635c: 81 c7 e0 08 ret 2006360: 81 e8 00 00 restore =============================================================================== 020050ec : */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) { if ( !routine ) 20050ec: 84 92 20 00 orcc %o0, 0, %g2 20050f0: 02 80 00 05 be 2005104 <== NEVER TAKEN 20050f4: 90 10 20 09 mov 9, %o0 return RTEMS_INVALID_ADDRESS; _Watchdog_Nanoseconds_since_tick_handler = routine; 20050f8: 03 00 80 61 sethi %hi(0x2018400), %g1 20050fc: 90 10 20 00 clr %o0 2005100: c4 20 60 b8 st %g2, [ %g1 + 0xb8 ] return RTEMS_SUCCESSFUL; } 2005104: 81 c3 e0 08 retl =============================================================================== 02005168 : rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 2005168: 9d e3 bf 98 save %sp, -104, %sp 200516c: 90 10 00 18 mov %i0, %o0 2005170: 96 10 00 1b mov %i3, %o3 2005174: 92 10 00 19 mov %i1, %o1 2005178: 94 10 00 1a mov %i2, %o2 RTEMS_API_Control *api; if ( !event_out ) 200517c: 80 a6 e0 00 cmp %i3, 0 2005180: 02 80 00 15 be 20051d4 <== NEVER TAKEN 2005184: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 2005188: 37 00 80 60 sethi %hi(0x2018000), %i3 200518c: c2 06 e3 d4 ld [ %i3 + 0x3d4 ], %g1 ! 20183d4 <_Thread_Executing> if ( _Event_sets_Is_empty( event_in ) ) { 2005190: 80 a2 20 00 cmp %o0, 0 2005194: 12 80 00 06 bne 20051ac 2005198: c2 00 61 68 ld [ %g1 + 0x168 ], %g1 *event_out = api->pending_events; 200519c: c2 00 40 00 ld [ %g1 ], %g1 20051a0: c2 22 c0 00 st %g1, [ %o3 ] 20051a4: 81 c7 e0 08 ret 20051a8: 91 e8 20 00 restore %g0, 0, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20051ac: 03 00 80 60 sethi %hi(0x2018000), %g1 20051b0: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 2018310 <_Thread_Dispatch_disable_level> 20051b4: 84 00 a0 01 inc %g2 20051b8: c4 20 63 10 st %g2, [ %g1 + 0x310 ] return RTEMS_SUCCESSFUL; } _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); 20051bc: 40 00 00 08 call 20051dc <_Event_Seize> 20051c0: 01 00 00 00 nop _Thread_Enable_dispatch(); 20051c4: 40 00 0a 93 call 2007c10 <_Thread_Enable_dispatch> 20051c8: 01 00 00 00 nop return( _Thread_Executing->Wait.return_code ); 20051cc: c2 06 e3 d4 ld [ %i3 + 0x3d4 ], %g1 20051d0: f0 00 60 34 ld [ %g1 + 0x34 ], %i0 } 20051d4: 81 c7 e0 08 ret 20051d8: 81 e8 00 00 restore =============================================================================== 02006f84 : { /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 2006f84: 9a 92 60 00 orcc %o1, 0, %o5 2006f88: 02 80 00 4d be 20070bc 2006f8c: 80 a2 a0 00 cmp %o2, 0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 2006f90: 02 80 00 4c be 20070c0 2006f94: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 2006f98: c2 03 40 00 ld [ %o5 ], %g1 2006f9c: 80 a0 60 00 cmp %g1, 0 2006fa0: 22 80 00 44 be,a 20070b0 2006fa4: c2 03 60 04 ld [ %o5 + 4 ], %g1 *registered_major = 0; /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 2006fa8: 03 00 80 71 sethi %hi(0x201c400), %g1 return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) return RTEMS_INVALID_ADDRESS; *registered_major = 0; 2006fac: c0 22 80 00 clr [ %o2 ] /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 2006fb0: c8 00 63 30 ld [ %g1 + 0x330 ], %g4 2006fb4: 80 a1 00 08 cmp %g4, %o0 2006fb8: 08 80 00 39 bleu 200709c 2006fbc: 82 10 20 0a mov 0xa, %g1 /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 2006fc0: 80 a2 20 00 cmp %o0, 0 2006fc4: 12 80 00 29 bne 2007068 2006fc8: 03 00 80 71 sethi %hi(0x201c400), %g1 bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 2006fcc: 90 81 3f ff addcc %g4, -1, %o0 2006fd0: 02 80 00 35 be 20070a4 <== NEVER TAKEN 2006fd4: 05 00 80 71 sethi %hi(0x201c400), %g2 2006fd8: c6 00 a3 34 ld [ %g2 + 0x334 ], %g3 ! 201c734 <_IO_Driver_address_table> 2006fdc: 85 29 20 03 sll %g4, 3, %g2 2006fe0: 83 29 20 05 sll %g4, 5, %g1 2006fe4: 82 20 40 02 sub %g1, %g2, %g1 2006fe8: 82 00 7f e8 add %g1, -24, %g1 2006fec: 10 80 00 05 b 2007000 2006ff0: 84 00 c0 01 add %g3, %g1, %g2 2006ff4: 90 82 3f ff addcc %o0, -1, %o0 2006ff8: 02 80 00 2b be 20070a4 2006ffc: 84 00 bf e8 add %g2, -24, %g2 if ( !_IO_Driver_address_table[major].initialization_entry && 2007000: c2 00 80 00 ld [ %g2 ], %g1 2007004: 80 a0 60 00 cmp %g1, 0 2007008: 12 bf ff fb bne 2006ff4 200700c: 88 10 00 02 mov %g2, %g4 2007010: c2 00 a0 04 ld [ %g2 + 4 ], %g1 2007014: 80 a0 60 00 cmp %g1, 0 2007018: 32 bf ff f8 bne,a 2006ff8 <== NEVER TAKEN 200701c: 90 82 3f ff addcc %o0, -1, %o0 <== NOT EXECUTED if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007020: c2 03 40 00 ld [ %o5 ], %g1 *registered_major = major; 2007024: d0 22 80 00 st %o0, [ %o2 ] if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007028: c2 21 00 00 st %g1, [ %g4 ] 200702c: c4 03 60 04 ld [ %o5 + 4 ], %g2 *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 2007030: 92 10 20 00 clr %o1 if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007034: c4 21 20 04 st %g2, [ %g4 + 4 ] 2007038: c2 03 60 08 ld [ %o5 + 8 ], %g1 *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 200703c: 94 10 20 00 clr %o2 if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007040: c2 21 20 08 st %g1, [ %g4 + 8 ] 2007044: c4 03 60 0c ld [ %o5 + 0xc ], %g2 2007048: c4 21 20 0c st %g2, [ %g4 + 0xc ] 200704c: c2 03 60 10 ld [ %o5 + 0x10 ], %g1 2007050: c2 21 20 10 st %g1, [ %g4 + 0x10 ] 2007054: c4 03 60 14 ld [ %o5 + 0x14 ], %g2 2007058: c4 21 20 14 st %g2, [ %g4 + 0x14 ] *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 200705c: 82 13 c0 00 mov %o7, %g1 2007060: 7f ff ff 48 call 2006d80 2007064: 9e 10 40 00 mov %g1, %o7 if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 2007068: c8 00 63 34 ld [ %g1 + 0x334 ], %g4 200706c: 85 2a 20 03 sll %o0, 3, %g2 2007070: 83 2a 20 05 sll %o0, 5, %g1 2007074: 82 20 40 02 sub %g1, %g2, %g1 2007078: c6 01 00 01 ld [ %g4 + %g1 ], %g3 200707c: 80 a0 e0 00 cmp %g3, 0 2007080: 12 80 00 06 bne 2007098 <== ALWAYS TAKEN 2007084: 88 01 00 01 add %g4, %g1, %g4 2007088: c2 01 20 04 ld [ %g4 + 4 ], %g1 <== NOT EXECUTED 200708c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007090: 22 bf ff e5 be,a 2007024 <== NOT EXECUTED 2007094: c2 03 40 00 ld [ %o5 ], %g1 <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 2007098: 82 10 20 0c mov 0xc, %g1 } 200709c: 81 c3 e0 08 retl 20070a0: 90 10 00 01 mov %g1, %o0 _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 20070a4: 82 10 20 05 mov 5, %g1 } 20070a8: 81 c3 e0 08 retl 20070ac: 90 10 00 01 mov %g1, %o0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 20070b0: 80 a0 60 00 cmp %g1, 0 20070b4: 12 bf ff be bne 2006fac <== NEVER TAKEN 20070b8: 03 00 80 71 sethi %hi(0x201c400), %g1 _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 20070bc: 82 10 20 09 mov 9, %g1 } 20070c0: 81 c3 e0 08 retl 20070c4: 90 10 00 01 mov %g1, %o0 =============================================================================== 020070c8 : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 20070c8: 9d e3 bf 98 save %sp, -104, %sp if ( major < _IO_Number_of_drivers ) { 20070cc: 03 00 80 71 sethi %hi(0x201c400), %g1 20070d0: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 ! 201c730 <_IO_Number_of_drivers> */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 20070d4: 86 10 00 18 mov %i0, %g3 if ( major < _IO_Number_of_drivers ) { 20070d8: 80 a0 80 18 cmp %g2, %i0 20070dc: 08 80 00 0c bleu 200710c <== NEVER TAKEN 20070e0: b0 10 20 0d mov 0xd, %i0 memset( 20070e4: 03 00 80 71 sethi %hi(0x201c400), %g1 20070e8: c4 00 63 34 ld [ %g1 + 0x334 ], %g2 ! 201c734 <_IO_Driver_address_table> 20070ec: 83 28 e0 03 sll %g3, 3, %g1 20070f0: 91 28 e0 05 sll %g3, 5, %o0 20070f4: 92 10 20 00 clr %o1 20070f8: 90 22 00 01 sub %o0, %g1, %o0 20070fc: 94 10 20 18 mov 0x18, %o2 2007100: 90 00 80 08 add %g2, %o0, %o0 2007104: 40 00 20 7e call 200f2fc 2007108: b0 10 20 00 clr %i0 sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 200710c: 81 c7 e0 08 ret 2007110: 81 e8 00 00 restore =============================================================================== 02008440 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 2008440: 9d e3 bf 98 save %sp, -104, %sp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 2008444: 80 a6 20 00 cmp %i0, 0 2008448: 02 80 00 23 be 20084d4 <== NEVER TAKEN 200844c: 03 00 80 93 sethi %hi(0x2024c00), %g1 return; 2008450: a4 10 60 c4 or %g1, 0xc4, %l2 ! 2024cc4 <_Objects_Information_table+0x4> 2008454: a6 04 a0 10 add %l2, 0x10, %l3 for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 2008458: c2 04 80 00 ld [ %l2 ], %g1 200845c: 80 a0 60 00 cmp %g1, 0 2008460: 22 80 00 1a be,a 20084c8 2008464: a4 04 a0 04 add %l2, 4, %l2 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 2008468: e2 00 60 04 ld [ %g1 + 4 ], %l1 if ( information ) { 200846c: 80 a4 60 00 cmp %l1, 0 2008470: 22 80 00 16 be,a 20084c8 <== NEVER TAKEN 2008474: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 2008478: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 200847c: 86 90 60 00 orcc %g1, 0, %g3 2008480: 22 80 00 12 be,a 20084c8 2008484: a4 04 a0 04 add %l2, 4, %l2 2008488: a0 10 20 01 mov 1, %l0 the_thread = (Thread_Control *)information->local_table[ i ]; 200848c: c4 04 60 1c ld [ %l1 + 0x1c ], %g2 2008490: 83 2c 20 02 sll %l0, 2, %g1 2008494: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( !the_thread ) 2008498: 80 a2 20 00 cmp %o0, 0 200849c: 02 80 00 05 be 20084b0 <== NEVER TAKEN 20084a0: a0 04 20 01 inc %l0 continue; (*routine)(the_thread); 20084a4: 9f c6 00 00 call %i0 20084a8: 01 00 00 00 nop 20084ac: c6 14 60 10 lduh [ %l1 + 0x10 ], %g3 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 20084b0: 83 28 e0 10 sll %g3, 0x10, %g1 20084b4: 83 30 60 10 srl %g1, 0x10, %g1 20084b8: 80 a0 40 10 cmp %g1, %l0 20084bc: 3a bf ff f5 bcc,a 2008490 20084c0: c4 04 60 1c ld [ %l1 + 0x1c ], %g2 20084c4: a4 04 a0 04 add %l2, 4, %l2 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 20084c8: 80 a4 80 13 cmp %l2, %l3 20084cc: 32 bf ff e4 bne,a 200845c 20084d0: c2 04 80 00 ld [ %l2 ], %g1 20084d4: 81 c7 e0 08 ret 20084d8: 81 e8 00 00 restore =============================================================================== 0200f21c : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 200f21c: 9d e3 bf 90 save %sp, -112, %sp CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 200f220: a2 96 20 00 orcc %i0, 0, %l1 200f224: 02 80 00 26 be 200f2bc 200f228: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 200f22c: 80 a7 20 00 cmp %i4, 0 200f230: 02 80 00 23 be 200f2bc <== NEVER TAKEN 200f234: b0 10 20 09 mov 9, %i0 if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 200f238: 80 a6 60 00 cmp %i1, 0 200f23c: 02 80 00 20 be 200f2bc <== NEVER TAKEN 200f240: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 200f244: 80 a6 a0 00 cmp %i2, 0 200f248: 02 80 00 1d be 200f2bc <== NEVER TAKEN 200f24c: b0 10 20 08 mov 8, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200f250: 05 00 80 c8 sethi %hi(0x2032000), %g2 200f254: c2 00 a2 90 ld [ %g2 + 0x290 ], %g1 ! 2032290 <_Thread_Dispatch_disable_level> 200f258: 82 00 60 01 inc %g1 200f25c: c2 20 a2 90 st %g1, [ %g2 + 0x290 ] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 200f260: 40 00 28 21 call 20192e4 <_Message_queue_Allocate> 200f264: 01 00 00 00 nop if ( !the_message_queue ) { 200f268: a0 92 20 00 orcc %o0, 0, %l0 200f26c: 02 80 00 26 be 200f304 200f270: 80 8e e0 04 btst 4, %i3 } #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) 200f274: 02 80 00 14 be 200f2c4 200f278: f6 24 20 10 st %i3, [ %l0 + 0x10 ] the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 200f27c: 82 10 20 01 mov 1, %g1 200f280: c2 27 bf f4 st %g1, [ %fp + -12 ] else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 200f284: 94 10 00 19 mov %i1, %o2 200f288: 96 10 00 1a mov %i2, %o3 200f28c: 90 04 20 14 add %l0, 0x14, %o0 200f290: 40 00 0d 91 call 20128d4 <_CORE_message_queue_Initialize> 200f294: 92 07 bf f4 add %fp, -12, %o1 200f298: 80 8a 20 ff btst 0xff, %o0 200f29c: 12 80 00 0c bne 200f2cc 200f2a0: 92 10 00 10 mov %l0, %o1 */ RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 200f2a4: 11 00 80 ca sethi %hi(0x2032800), %o0 200f2a8: 90 12 23 bc or %o0, 0x3bc, %o0 ! 2032bbc <_Message_queue_Information> 200f2ac: 40 00 13 94 call 20140fc <_Objects_Free> 200f2b0: b0 10 20 0d mov 0xd, %i0 _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 200f2b4: 40 00 16 94 call 2014d04 <_Thread_Enable_dispatch> 200f2b8: 01 00 00 00 nop 200f2bc: 81 c7 e0 08 ret 200f2c0: 81 e8 00 00 restore the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 200f2c4: 10 bf ff f0 b 200f284 200f2c8: c0 27 bf f4 clr [ %fp + -12 ] 200f2cc: c4 04 20 08 ld [ %l0 + 8 ], %g2 information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 200f2d0: e2 24 20 0c st %l1, [ %l0 + 0xc ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200f2d4: 03 00 80 ca sethi %hi(0x2032800), %g1 200f2d8: c6 00 63 d8 ld [ %g1 + 0x3d8 ], %g3 ! 2032bd8 <_Message_queue_Information+0x1c> &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 200f2dc: c4 27 00 00 st %g2, [ %i4 ] 200f2e0: 03 00 00 3f sethi %hi(0xfc00), %g1 200f2e4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200f2e8: 84 08 80 01 and %g2, %g1, %g2 200f2ec: 85 28 a0 02 sll %g2, 2, %g2 name, 0 ); #endif _Thread_Enable_dispatch(); 200f2f0: b0 10 20 00 clr %i0 200f2f4: 40 00 16 84 call 2014d04 <_Thread_Enable_dispatch> 200f2f8: e0 20 c0 02 st %l0, [ %g3 + %g2 ] return RTEMS_SUCCESSFUL; } 200f2fc: 81 c7 e0 08 ret 200f300: 81 e8 00 00 restore _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); if ( !the_message_queue ) { _Thread_Enable_dispatch(); 200f304: 40 00 16 80 call 2014d04 <_Thread_Enable_dispatch> 200f308: b0 10 20 05 mov 5, %i0 200f30c: 81 c7 e0 08 ret 200f310: 81 e8 00 00 restore =============================================================================== 0200f37c : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 200f37c: 9d e3 bf 90 save %sp, -112, %sp 200f380: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200f384: 80 a6 60 00 cmp %i1, 0 200f388: 02 80 00 0f be 200f3c4 <== NEVER TAKEN 200f38c: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 200f390: 11 00 80 ca sethi %hi(0x2032800), %o0 200f394: 94 07 bf f4 add %fp, -12, %o2 200f398: 40 00 13 d8 call 20142f8 <_Objects_Get> 200f39c: 90 12 23 bc or %o0, 0x3bc, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200f3a0: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f3a4: 80 a0 60 00 cmp %g1, 0 200f3a8: 12 80 00 07 bne 200f3c4 200f3ac: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: *count = _CORE_message_queue_Flush( &the_message_queue->message_queue ); 200f3b0: 40 00 0d 29 call 2012854 <_CORE_message_queue_Flush> 200f3b4: 90 02 20 14 add %o0, 0x14, %o0 _Thread_Enable_dispatch(); 200f3b8: b0 10 20 00 clr %i0 200f3bc: 40 00 16 52 call 2014d04 <_Thread_Enable_dispatch> 200f3c0: d0 26 40 00 st %o0, [ %i1 ] case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200f3c4: 81 c7 e0 08 ret 200f3c8: 81 e8 00 00 restore =============================================================================== 0200f3cc : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 200f3cc: 9d e3 bf 90 save %sp, -112, %sp 200f3d0: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200f3d4: 80 a6 60 00 cmp %i1, 0 200f3d8: 02 80 00 0e be 200f410 <== NEVER TAKEN 200f3dc: b0 10 20 09 mov 9, %i0 200f3e0: 11 00 80 ca sethi %hi(0x2032800), %o0 200f3e4: 94 07 bf f4 add %fp, -12, %o2 200f3e8: 40 00 13 c4 call 20142f8 <_Objects_Get> 200f3ec: 90 12 23 bc or %o0, 0x3bc, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200f3f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f3f4: 80 a0 60 00 cmp %g1, 0 200f3f8: 12 80 00 06 bne 200f410 200f3fc: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 200f400: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 _Thread_Enable_dispatch(); 200f404: b0 10 20 00 clr %i0 200f408: 40 00 16 3f call 2014d04 <_Thread_Enable_dispatch> 200f40c: c2 26 40 00 st %g1, [ %i1 ] case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200f410: 81 c7 e0 08 ret 200f414: 81 e8 00 00 restore =============================================================================== 0200f4dc : rtems_status_code rtems_message_queue_send( Objects_Id id, const void *buffer, size_t size ) { 200f4dc: 9d e3 bf 88 save %sp, -120, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 200f4e0: 80 a6 60 00 cmp %i1, 0 200f4e4: 02 80 00 0c be 200f514 <== NEVER TAKEN 200f4e8: 90 10 20 09 mov 9, %o0 200f4ec: 11 00 80 ca sethi %hi(0x2032800), %o0 200f4f0: 92 10 00 18 mov %i0, %o1 200f4f4: 90 12 23 bc or %o0, 0x3bc, %o0 200f4f8: 40 00 13 80 call 20142f8 <_Objects_Get> 200f4fc: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200f500: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f504: 84 10 00 08 mov %o0, %g2 200f508: 80 a0 60 00 cmp %g1, 0 200f50c: 02 80 00 04 be 200f51c 200f510: 90 10 20 04 mov 4, %o0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200f514: 81 c7 e0 08 ret 200f518: 91 e8 00 08 restore %g0, %o0, %o0 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, bool wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 200f51c: 96 10 00 18 mov %i0, %o3 200f520: 92 10 00 19 mov %i1, %o1 200f524: 94 10 00 1a mov %i2, %o2 200f528: 90 00 a0 14 add %g2, 0x14, %o0 200f52c: 98 10 20 00 clr %o4 200f530: c0 23 a0 5c clr [ %sp + 0x5c ] 200f534: c0 23 a0 60 clr [ %sp + 0x60 ] 200f538: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5 200f53c: 40 00 0d 57 call 2012a98 <_CORE_message_queue_Submit> 200f540: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 200f544: 40 00 15 f0 call 2014d04 <_Thread_Enable_dispatch> 200f548: a0 10 00 08 mov %o0, %l0 /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 200f54c: 40 00 00 04 call 200f55c <_Message_queue_Translate_core_message_queue_return_code> 200f550: 90 10 00 10 mov %l0, %o0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200f554: 81 c7 e0 08 ret 200f558: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 0200f570 : rtems_status_code rtems_message_queue_urgent( Objects_Id id, const void *buffer, size_t size ) { 200f570: 9d e3 bf 88 save %sp, -120, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 200f574: 80 a6 60 00 cmp %i1, 0 200f578: 02 80 00 0c be 200f5a8 <== NEVER TAKEN 200f57c: 90 10 20 09 mov 9, %o0 200f580: 11 00 80 ca sethi %hi(0x2032800), %o0 200f584: 92 10 00 18 mov %i0, %o1 200f588: 90 12 23 bc or %o0, 0x3bc, %o0 200f58c: 40 00 13 5b call 20142f8 <_Objects_Get> 200f590: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200f594: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f598: 84 10 00 08 mov %o0, %g2 200f59c: 80 a0 60 00 cmp %g1, 0 200f5a0: 02 80 00 04 be 200f5b0 200f5a4: 90 10 20 04 mov 4, %o0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200f5a8: 81 c7 e0 08 ret 200f5ac: 91 e8 00 08 restore %g0, %o0, %o0 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, bool wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 200f5b0: 96 10 00 18 mov %i0, %o3 200f5b4: 92 10 00 19 mov %i1, %o1 200f5b8: 94 10 00 1a mov %i2, %o2 200f5bc: 90 00 a0 14 add %g2, 0x14, %o0 200f5c0: 98 10 20 00 clr %o4 200f5c4: 1b 20 00 00 sethi %hi(0x80000000), %o5 200f5c8: c0 23 a0 5c clr [ %sp + 0x5c ] 200f5cc: 40 00 0d 33 call 2012a98 <_CORE_message_queue_Submit> 200f5d0: c0 23 a0 60 clr [ %sp + 0x60 ] id, MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 200f5d4: 40 00 15 cc call 2014d04 <_Thread_Enable_dispatch> 200f5d8: a0 10 00 08 mov %o0, %l0 /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 200f5dc: 7f ff ff e0 call 200f55c <_Message_queue_Translate_core_message_queue_return_code> 200f5e0: 90 10 00 10 mov %l0, %o0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200f5e4: 81 c7 e0 08 ret 200f5e8: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 02006f24 : rtems_status_code rtems_object_get_class_information( uint32_t the_api, uint32_t the_class, rtems_object_api_class_information *info ) { 2006f24: 9d e3 bf 98 save %sp, -104, %sp 2006f28: 90 10 00 18 mov %i0, %o0 2006f2c: 92 10 00 19 mov %i1, %o1 uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 2006f30: 80 a6 a0 00 cmp %i2, 0 2006f34: 02 80 00 1f be 2006fb0 2006f38: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 2006f3c: 40 00 07 2f call 2008bf8 <_Objects_Get_information> 2006f40: b0 10 20 0a mov 0xa, %i0 if ( !obj_info ) 2006f44: 80 a2 20 00 cmp %o0, 0 2006f48: 02 80 00 1a be 2006fb0 2006f4c: 01 00 00 00 nop return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 2006f50: c2 02 20 08 ld [ %o0 + 8 ], %g1 info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; 2006f54: da 12 20 10 lduh [ %o0 + 0x10 ], %o5 return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 2006f58: c2 26 80 00 st %g1, [ %i2 ] info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; 2006f5c: c4 0a 20 12 ldub [ %o0 + 0x12 ], %g2 /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; 2006f60: c2 02 20 0c ld [ %o0 + 0xc ], %g1 info->auto_extend = obj_info->auto_extend; 2006f64: c4 2e a0 0c stb %g2, [ %i2 + 0xc ] /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; 2006f68: c2 26 a0 04 st %g1, [ %i2 + 4 ] info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; 2006f6c: da 26 a0 08 st %o5, [ %i2 + 8 ] for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 2006f70: 80 a3 60 00 cmp %o5, 0 2006f74: 02 80 00 0d be 2006fa8 <== NEVER TAKEN 2006f78: 88 10 20 00 clr %g4 2006f7c: d0 02 20 1c ld [ %o0 + 0x1c ], %o0 2006f80: 88 10 20 00 clr %g4 2006f84: 86 10 20 01 mov 1, %g3 if ( !obj_info->local_table[i] ) 2006f88: 83 28 e0 02 sll %g3, 2, %g1 2006f8c: c4 02 00 01 ld [ %o0 + %g1 ], %g2 info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 2006f90: 86 00 e0 01 inc %g3 if ( !obj_info->local_table[i] ) unallocated++; 2006f94: 80 a0 00 02 cmp %g0, %g2 2006f98: 88 61 3f ff subx %g4, -1, %g4 info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 2006f9c: 80 a3 40 03 cmp %o5, %g3 2006fa0: 1a bf ff fb bcc 2006f8c 2006fa4: 83 28 e0 02 sll %g3, 2, %g1 if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 2006fa8: c8 26 a0 10 st %g4, [ %i2 + 0x10 ] 2006fac: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 2006fb0: 81 c7 e0 08 ret 2006fb4: 81 e8 00 00 restore =============================================================================== 02005c00 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 2005c00: 9d e3 bf 90 save %sp, -112, %sp 2005c04: 90 10 00 18 mov %i0, %o0 Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 2005c08: 80 a6 60 00 cmp %i1, 0 2005c0c: 02 80 00 16 be 2005c64 <== NEVER TAKEN 2005c10: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 2005c14: b0 92 20 00 orcc %o0, 0, %i0 2005c18: 02 80 00 18 be 2005c78 2005c1c: 03 00 80 6f sethi %hi(0x201bc00), %g1 information = _Objects_Get_information_id( tmpId ); 2005c20: 40 00 06 c1 call 2007724 <_Objects_Get_information_id> 2005c24: 90 10 00 18 mov %i0, %o0 if ( !information ) 2005c28: a0 92 20 00 orcc %o0, 0, %l0 2005c2c: 02 80 00 10 be 2005c6c 2005c30: 92 10 00 18 mov %i0, %o1 return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 2005c34: 40 00 07 50 call 2007974 <_Objects_Get> 2005c38: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 2005c3c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005c40: 80 a0 60 00 cmp %g1, 0 2005c44: 32 80 00 08 bne,a 2005c64 2005c48: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 2005c4c: 92 10 00 08 mov %o0, %o1 2005c50: 94 10 00 19 mov %i1, %o2 2005c54: 40 00 07 aa call 2007afc <_Objects_Set_name> 2005c58: 90 10 00 10 mov %l0, %o0 _Thread_Enable_dispatch(); 2005c5c: 40 00 09 d7 call 20083b8 <_Thread_Enable_dispatch> 2005c60: b0 10 20 00 clr %i0 2005c64: 81 c7 e0 08 ret 2005c68: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 2005c6c: b0 10 20 04 mov 4, %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2005c70: 81 c7 e0 08 ret 2005c74: 81 e8 00 00 restore Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 2005c78: c4 00 63 04 ld [ %g1 + 0x304 ], %g2 2005c7c: 10 bf ff e9 b 2005c20 2005c80: f0 00 a0 08 ld [ %g2 + 8 ], %i0 =============================================================================== 0200f5ec : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 200f5ec: 9d e3 bf 98 save %sp, -104, %sp register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 200f5f0: a4 96 20 00 orcc %i0, 0, %l2 200f5f4: 02 80 00 36 be 200f6cc 200f5f8: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 200f5fc: 80 a6 60 00 cmp %i1, 0 200f600: 02 80 00 35 be 200f6d4 <== NEVER TAKEN 200f604: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 200f608: 02 80 00 33 be 200f6d4 <== NEVER TAKEN 200f60c: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 200f610: 12 80 00 04 bne 200f620 200f614: 80 a6 e0 00 cmp %i3, 0 ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 200f618: 81 c7 e0 08 ret 200f61c: 91 e8 20 08 restore %g0, 8, %o0 return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 200f620: 02 80 00 2b be 200f6cc 200f624: b0 10 20 08 mov 8, %i0 200f628: 80 a6 80 1b cmp %i2, %i3 200f62c: 0a 80 00 28 bcs 200f6cc 200f630: 80 8e e0 07 btst 7, %i3 200f634: 12 80 00 26 bne 200f6cc 200f638: 80 8e 60 07 btst 7, %i1 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 200f63c: 12 80 00 26 bne 200f6d4 200f640: 05 00 80 c8 sethi %hi(0x2032000), %g2 200f644: c2 00 a2 90 ld [ %g2 + 0x290 ], %g1 ! 2032290 <_Thread_Dispatch_disable_level> 200f648: 82 00 60 01 inc %g1 200f64c: c2 20 a2 90 st %g1, [ %g2 + 0x290 ] * This function allocates a partition control block from * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 200f650: 31 00 80 c8 sethi %hi(0x2032000), %i0 200f654: 40 00 11 af call 2013d10 <_Objects_Allocate> 200f658: 90 16 20 44 or %i0, 0x44, %o0 ! 2032044 <_Partition_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 200f65c: a2 92 20 00 orcc %o0, 0, %l1 200f660: 02 80 00 1f be 200f6dc 200f664: 92 10 00 1b mov %i3, %o1 #endif the_partition->starting_address = starting_address; the_partition->length = length; the_partition->buffer_size = buffer_size; the_partition->attribute_set = attribute_set; 200f668: f8 24 60 1c st %i4, [ %l1 + 0x1c ] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 200f66c: f2 24 60 10 st %i1, [ %l1 + 0x10 ] the_partition->length = length; 200f670: f4 24 60 14 st %i2, [ %l1 + 0x14 ] the_partition->buffer_size = buffer_size; 200f674: f6 24 60 18 st %i3, [ %l1 + 0x18 ] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 200f678: c0 24 60 20 clr [ %l1 + 0x20 ] _Chain_Initialize( &the_partition->Memory, starting_address, 200f67c: 40 00 4f ed call 2023630 <.udiv> 200f680: 90 10 00 1a mov %i2, %o0 200f684: 92 10 00 19 mov %i1, %o1 200f688: 94 10 00 08 mov %o0, %o2 200f68c: 96 10 00 1b mov %i3, %o3 200f690: a0 04 60 24 add %l1, 0x24, %l0 200f694: 40 00 0c 2c call 2012744 <_Chain_Initialize> 200f698: 90 10 00 10 mov %l0, %o0 200f69c: c4 04 60 08 ld [ %l1 + 8 ], %g2 200f6a0: 82 16 20 44 or %i0, 0x44, %g1 information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 200f6a4: e4 24 60 0c st %l2, [ %l1 + 0xc ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200f6a8: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 200f6ac: c4 27 40 00 st %g2, [ %i5 ] 200f6b0: 03 00 00 3f sethi %hi(0xfc00), %g1 200f6b4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200f6b8: 84 08 80 01 and %g2, %g1, %g2 200f6bc: 85 28 a0 02 sll %g2, 2, %g2 name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 200f6c0: b0 10 20 00 clr %i0 200f6c4: 40 00 15 90 call 2014d04 <_Thread_Enable_dispatch> 200f6c8: e2 20 c0 02 st %l1, [ %g3 + %g2 ] 200f6cc: 81 c7 e0 08 ret 200f6d0: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 200f6d4: 81 c7 e0 08 ret 200f6d8: 91 e8 20 09 restore %g0, 9, %o0 _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { _Thread_Enable_dispatch(); 200f6dc: 40 00 15 8a call 2014d04 <_Thread_Enable_dispatch> 200f6e0: b0 10 20 05 mov 5, %i0 200f6e4: 81 c7 e0 08 ret 200f6e8: 81 e8 00 00 restore =============================================================================== 0200f760 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 200f760: 9d e3 bf 90 save %sp, -112, %sp 200f764: 92 10 00 18 mov %i0, %o1 register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 200f768: 80 a6 60 00 cmp %i1, 0 200f76c: 02 80 00 19 be 200f7d0 <== NEVER TAKEN 200f770: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200f774: 11 00 80 c8 sethi %hi(0x2032000), %o0 200f778: 94 07 bf f4 add %fp, -12, %o2 200f77c: 40 00 12 df call 20142f8 <_Objects_Get> 200f780: 90 12 20 44 or %o0, 0x44, %o0 return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f784: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f788: a0 10 00 08 mov %o0, %l0 200f78c: 80 a0 60 00 cmp %g1, 0 200f790: 12 80 00 10 bne 200f7d0 200f794: b0 10 20 04 mov 4, %i0 */ RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 200f798: 40 00 0b d8 call 20126f8 <_Chain_Get> 200f79c: 90 02 20 24 add %o0, 0x24, %o0 case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 200f7a0: b0 92 20 00 orcc %o0, 0, %i0 200f7a4: 02 80 00 09 be 200f7c8 200f7a8: 01 00 00 00 nop the_partition->number_of_used_blocks += 1; 200f7ac: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 200f7b0: 82 00 60 01 inc %g1 _Thread_Enable_dispatch(); 200f7b4: 40 00 15 54 call 2014d04 <_Thread_Enable_dispatch> 200f7b8: c2 24 20 20 st %g1, [ %l0 + 0x20 ] *buffer = the_buffer; 200f7bc: f0 26 40 00 st %i0, [ %i1 ] 200f7c0: 81 c7 e0 08 ret 200f7c4: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 200f7c8: 40 00 15 4f call 2014d04 <_Thread_Enable_dispatch> 200f7cc: b0 10 20 0d mov 0xd, %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200f7d0: 81 c7 e0 08 ret 200f7d4: 81 e8 00 00 restore =============================================================================== 0200eb30 : void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) { 200eb30: 9d e3 bf 98 save %sp, -104, %sp register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 200eb34: a0 96 20 00 orcc %i0, 0, %l0 200eb38: 02 80 00 22 be 200ebc0 200eb3c: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 200eb40: 80 a7 20 00 cmp %i4, 0 200eb44: 02 80 00 05 be 200eb58 <== NEVER TAKEN 200eb48: 82 16 80 19 or %i2, %i1, %g1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 200eb4c: 80 88 60 07 btst 7, %g1 200eb50: 02 80 00 04 be 200eb60 200eb54: 05 00 80 c8 sethi %hi(0x2032000), %g2 ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 200eb58: 81 c7 e0 08 ret 200eb5c: 91 e8 20 09 restore %g0, 9, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200eb60: c2 00 a2 90 ld [ %g2 + 0x290 ], %g1 200eb64: 82 00 60 01 inc %g1 200eb68: c2 20 a2 90 st %g1, [ %g2 + 0x290 ] * of free port control blocks. */ RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Allocate ( void ) { return (Dual_ported_memory_Control *) 200eb6c: 31 00 80 c8 sethi %hi(0x2032000), %i0 200eb70: 40 00 14 68 call 2013d10 <_Objects_Allocate> 200eb74: 90 16 20 04 or %i0, 4, %o0 ! 2032004 <_Dual_ported_memory_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 200eb78: 80 a2 20 00 cmp %o0, 0 200eb7c: 02 80 00 13 be 200ebc8 200eb80: 82 16 20 04 or %i0, 4, %g1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200eb84: c4 02 20 08 ld [ %o0 + 8 ], %g2 200eb88: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 200eb8c: e0 22 20 0c st %l0, [ %o0 + 0xc ] return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; the_port->external_base = external_start; the_port->length = length - 1; 200eb90: 82 06 ff ff add %i3, -1, %g1 200eb94: c2 22 20 18 st %g1, [ %o0 + 0x18 ] &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 200eb98: c4 27 00 00 st %g2, [ %i4 ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200eb9c: 03 00 00 3f sethi %hi(0xfc00), %g1 200eba0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200eba4: 84 08 80 01 and %g2, %g1, %g2 200eba8: 85 28 a0 02 sll %g2, 2, %g2 if ( !the_port ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 200ebac: f2 22 20 10 st %i1, [ %o0 + 0x10 ] the_port->external_base = external_start; 200ebb0: f4 22 20 14 st %i2, [ %o0 + 0x14 ] 200ebb4: d0 20 c0 02 st %o0, [ %g3 + %g2 ] &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; _Thread_Enable_dispatch(); 200ebb8: 40 00 18 53 call 2014d04 <_Thread_Enable_dispatch> 200ebbc: b0 10 20 00 clr %i0 200ebc0: 81 c7 e0 08 ret 200ebc4: 81 e8 00 00 restore _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { _Thread_Enable_dispatch(); 200ebc8: 40 00 18 4f call 2014d04 <_Thread_Enable_dispatch> 200ebcc: b0 10 20 05 mov 5, %i0 200ebd0: 81 c7 e0 08 ret 200ebd4: 81 e8 00 00 restore =============================================================================== 0200ec30 : rtems_status_code rtems_port_external_to_internal( Objects_Id id, void *external, void **internal ) { 200ec30: 9d e3 bf 90 save %sp, -112, %sp 200ec34: 92 10 00 18 mov %i0, %o1 register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 200ec38: 80 a6 a0 00 cmp %i2, 0 200ec3c: 02 80 00 13 be 200ec88 <== NEVER TAKEN 200ec40: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Get ( Objects_Id id, Objects_Locations *location ) { return (Dual_ported_memory_Control *) 200ec44: 11 00 80 c8 sethi %hi(0x2032000), %o0 200ec48: 94 07 bf f4 add %fp, -12, %o2 200ec4c: 40 00 15 ab call 20142f8 <_Objects_Get> 200ec50: 90 12 20 04 or %o0, 4, %o0 return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 200ec54: c2 07 bf f4 ld [ %fp + -12 ], %g1 200ec58: 80 a0 60 00 cmp %g1, 0 200ec5c: 12 80 00 0b bne 200ec88 200ec60: b0 10 20 04 mov 4, %i0 RTEMS_INLINE_ROUTINE uint32_t _Addresses_Subtract ( void *left, void *right ) { return ((char *) left - (char *) right); 200ec64: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) 200ec68: c4 02 20 18 ld [ %o0 + 0x18 ], %g2 200ec6c: 86 26 40 01 sub %i1, %g1, %g3 200ec70: 80 a0 80 03 cmp %g2, %g3 200ec74: 3a 80 00 07 bcc,a 200ec90 200ec78: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 *internal = external; 200ec7c: f2 26 80 00 st %i1, [ %i2 ] else *internal = _Addresses_Add_offset( the_port->internal_base, ending ); _Thread_Enable_dispatch(); 200ec80: 40 00 18 21 call 2014d04 <_Thread_Enable_dispatch> 200ec84: b0 10 20 00 clr %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200ec88: 81 c7 e0 08 ret 200ec8c: 81 e8 00 00 restore case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) *internal = external; else *internal = _Addresses_Add_offset( the_port->internal_base, 200ec90: 82 00 40 03 add %g1, %g3, %g1 200ec94: 10 bf ff fb b 200ec80 200ec98: c2 26 80 00 st %g1, [ %i2 ] =============================================================================== 0200ecd0 : rtems_status_code rtems_port_internal_to_external( Objects_Id id, void *internal, void **external ) { 200ecd0: 9d e3 bf 90 save %sp, -112, %sp 200ecd4: 92 10 00 18 mov %i0, %o1 register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 200ecd8: 80 a6 a0 00 cmp %i2, 0 200ecdc: 02 80 00 13 be 200ed28 <== NEVER TAKEN 200ece0: b0 10 20 09 mov 9, %i0 200ece4: 11 00 80 c8 sethi %hi(0x2032000), %o0 200ece8: 94 07 bf f4 add %fp, -12, %o2 200ecec: 40 00 15 83 call 20142f8 <_Objects_Get> 200ecf0: 90 12 20 04 or %o0, 4, %o0 return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 200ecf4: c2 07 bf f4 ld [ %fp + -12 ], %g1 200ecf8: 80 a0 60 00 cmp %g1, 0 200ecfc: 12 80 00 0b bne 200ed28 200ed00: b0 10 20 04 mov 4, %i0 200ed04: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) 200ed08: c4 02 20 18 ld [ %o0 + 0x18 ], %g2 200ed0c: 86 26 40 01 sub %i1, %g1, %g3 200ed10: 80 a0 80 03 cmp %g2, %g3 200ed14: 3a 80 00 07 bcc,a 200ed30 200ed18: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 *external = internal; 200ed1c: f2 26 80 00 st %i1, [ %i2 ] else *external = _Addresses_Add_offset( the_port->external_base, ending ); _Thread_Enable_dispatch(); 200ed20: 40 00 17 f9 call 2014d04 <_Thread_Enable_dispatch> 200ed24: b0 10 20 00 clr %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200ed28: 81 c7 e0 08 ret 200ed2c: 81 e8 00 00 restore case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) *external = internal; else *external = _Addresses_Add_offset( the_port->external_base, 200ed30: 82 00 40 03 add %g1, %g3, %g1 200ed34: 10 bf ff fb b 200ed20 200ed38: c2 26 80 00 st %g1, [ %i2 ] =============================================================================== 020066f0 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) { 20066f0: 9d e3 bf 98 save %sp, -104, %sp Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 20066f4: a2 96 20 00 orcc %i0, 0, %l1 20066f8: 02 80 00 33 be 20067c4 20066fc: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2006700: 80 a6 60 00 cmp %i1, 0 2006704: 02 80 00 30 be 20067c4 <== NEVER TAKEN 2006708: b0 10 20 09 mov 9, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200670c: 05 00 80 74 sethi %hi(0x201d000), %g2 2006710: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 201d3b0 <_Thread_Dispatch_disable_level> 2006714: 82 00 60 01 inc %g1 2006718: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] * This function allocates a period control block from * the inactive chain of free period control blocks. */ RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void ) { return (Rate_monotonic_Control *) 200671c: 21 00 80 74 sethi %hi(0x201d000), %l0 2006720: 40 00 08 51 call 2008864 <_Objects_Allocate> 2006724: 90 14 22 3c or %l0, 0x23c, %o0 ! 201d23c <_Rate_monotonic_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 2006728: 80 a2 20 00 cmp %o0, 0 200672c: 02 80 00 28 be 20067cc 2006730: 03 00 80 75 sethi %hi(0x201d400), %g1 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 2006734: c4 00 60 74 ld [ %g1 + 0x74 ], %g2 ! 201d474 <_Thread_Executing> void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 2006738: c0 22 20 30 clr [ %o0 + 0x30 ] the_period->state = RATE_MONOTONIC_INACTIVE; _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 200673c: c0 22 20 54 clr [ %o0 + 0x54 ] if ( !the_period ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 2006740: c4 22 20 50 st %g2, [ %o0 + 0x50 ] the_period->state = RATE_MONOTONIC_INACTIVE; 2006744: c0 22 20 38 clr [ %o0 + 0x38 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2006748: c0 22 20 18 clr [ %o0 + 0x18 ] the_watchdog->routine = routine; 200674c: c0 22 20 2c clr [ %o0 + 0x2c ] the_watchdog->id = id; the_watchdog->user_data = user_data; 2006750: c0 22 20 34 clr [ %o0 + 0x34 ] _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 2006754: 82 02 20 54 add %o0, 0x54, %g1 2006758: c0 20 60 34 clr [ %g1 + 0x34 ] 200675c: c0 20 60 04 clr [ %g1 + 4 ] 2006760: c0 20 60 10 clr [ %g1 + 0x10 ] 2006764: c0 20 60 14 clr [ %g1 + 0x14 ] 2006768: c0 20 60 18 clr [ %g1 + 0x18 ] 200676c: c0 20 60 1c clr [ %g1 + 0x1c ] 2006770: c0 20 60 28 clr [ %g1 + 0x28 ] 2006774: c0 20 60 2c clr [ %g1 + 0x2c ] 2006778: c0 20 60 30 clr [ %g1 + 0x30 ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200677c: c4 02 20 08 ld [ %o0 + 8 ], %g2 2006780: 86 14 22 3c or %l0, 0x23c, %g3 information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 2006784: e2 22 20 0c st %l1, [ %o0 + 0xc ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2006788: c8 00 e0 1c ld [ %g3 + 0x1c ], %g4 200678c: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 2006790: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff 2006794: c2 22 20 78 st %g1, [ %o0 + 0x78 ] 2006798: c2 22 20 5c st %g1, [ %o0 + 0x5c ] 200679c: c2 22 20 60 st %g1, [ %o0 + 0x60 ] 20067a0: c2 22 20 74 st %g1, [ %o0 + 0x74 ] &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 20067a4: c4 26 40 00 st %g2, [ %i1 ] 20067a8: 03 00 00 3f sethi %hi(0xfc00), %g1 20067ac: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20067b0: 84 08 80 01 and %g2, %g1, %g2 20067b4: 85 28 a0 02 sll %g2, 2, %g2 _Thread_Enable_dispatch(); 20067b8: b0 10 20 00 clr %i0 20067bc: 40 00 0c 61 call 2009940 <_Thread_Enable_dispatch> 20067c0: d0 21 00 02 st %o0, [ %g4 + %g2 ] return RTEMS_SUCCESSFUL; } 20067c4: 81 c7 e0 08 ret 20067c8: 81 e8 00 00 restore _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { _Thread_Enable_dispatch(); 20067cc: 40 00 0c 5d call 2009940 <_Thread_Enable_dispatch> 20067d0: b0 10 20 05 mov 5, %i0 20067d4: 81 c7 e0 08 ret 20067d8: 81 e8 00 00 restore =============================================================================== 0200dd74 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 200dd74: 9d e3 bf 90 save %sp, -112, %sp 200dd78: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 200dd7c: 80 a6 60 00 cmp %i1, 0 200dd80: 02 80 00 10 be 200ddc0 <== NEVER TAKEN 200dd84: b0 10 20 09 mov 9, %i0 200dd88: 11 00 80 74 sethi %hi(0x201d000), %o0 200dd8c: 94 07 bf f4 add %fp, -12, %o2 200dd90: 7f ff ec 69 call 2008f34 <_Objects_Get> 200dd94: 90 12 22 3c or %o0, 0x23c, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200dd98: c2 07 bf f4 ld [ %fp + -12 ], %g1 200dd9c: 80 a0 60 00 cmp %g1, 0 200dda0: 12 80 00 08 bne 200ddc0 200dda4: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: *statistics = the_period->Statistics; 200dda8: 92 02 20 54 add %o0, 0x54, %o1 200ddac: 94 10 20 38 mov 0x38, %o2 200ddb0: 40 00 09 7b call 201039c 200ddb4: 90 10 00 19 mov %i1, %o0 _Thread_Enable_dispatch(); 200ddb8: 7f ff ee e2 call 2009940 <_Thread_Enable_dispatch> 200ddbc: b0 10 20 00 clr %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200ddc0: 81 c7 e0 08 ret 200ddc4: 81 e8 00 00 restore =============================================================================== 0200ddc8 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 200ddc8: 9d e3 bf 88 save %sp, -120, %sp 200ddcc: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 200ddd0: 80 a6 60 00 cmp %i1, 0 200ddd4: 02 80 00 1b be 200de40 <== NEVER TAKEN 200ddd8: b0 10 20 09 mov 9, %i0 200dddc: 11 00 80 74 sethi %hi(0x201d000), %o0 200dde0: 94 07 bf f4 add %fp, -12, %o2 200dde4: 7f ff ec 54 call 2008f34 <_Objects_Get> 200dde8: 90 12 22 3c or %o0, 0x23c, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200ddec: c2 07 bf f4 ld [ %fp + -12 ], %g1 200ddf0: a2 10 00 08 mov %o0, %l1 200ddf4: 80 a0 60 00 cmp %g1, 0 200ddf8: 12 80 00 12 bne 200de40 200ddfc: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 200de00: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 200de04: 80 a0 60 00 cmp %g1, 0 200de08: 02 80 00 03 be 200de14 <== NEVER TAKEN 200de0c: 84 10 20 00 clr %g2 200de10: c4 00 60 08 ld [ %g1 + 8 ], %g2 status->state = the_period->state; 200de14: c2 04 60 38 ld [ %l1 + 0x38 ], %g1 the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 200de18: c4 26 40 00 st %g2, [ %i1 ] status->state = the_period->state; if ( status->state == RATE_MONOTONIC_INACTIVE ) { 200de1c: 80 a0 60 00 cmp %g1, 0 200de20: 12 80 00 0a bne 200de48 200de24: c2 26 60 04 st %g1, [ %i1 + 4 ] #else status->since_last_period = 0; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS status->executed_since_last_period.tv_sec = 0; status->executed_since_last_period.tv_nsec = 0; 200de28: c0 26 60 14 clr [ %i1 + 0x14 ] status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); status->state = the_period->state; if ( status->state == RATE_MONOTONIC_INACTIVE ) { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS status->since_last_period.tv_sec = 0; 200de2c: c0 26 60 08 clr [ %i1 + 8 ] status->since_last_period.tv_nsec = 0; 200de30: c0 26 60 0c clr [ %i1 + 0xc ] #else status->since_last_period = 0; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS status->executed_since_last_period.tv_sec = 0; 200de34: c0 26 60 10 clr [ %i1 + 0x10 ] the_period->owner->cpu_time_used - the_period->owner_executed_at_period; #endif } _Thread_Enable_dispatch(); 200de38: 7f ff ee c2 call 2009940 <_Thread_Enable_dispatch> 200de3c: b0 10 20 00 clr %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 200de40: 81 c7 e0 08 ret 200de44: 81 e8 00 00 restore * This lets them share one single invocation of _TOD_Get_uptime(). */ #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 200de48: a0 07 bf ec add %fp, -20, %l0 200de4c: 7f ff e9 7f call 2008448 <_TOD_Get_uptime> 200de50: 90 10 00 10 mov %l0, %o0 #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 200de54: 90 04 60 44 add %l1, 0x44, %o0 200de58: 92 10 00 10 mov %l0, %o1 200de5c: 7f ff f3 85 call 200ac70 <_Timespec_Subtract> 200de60: 94 06 60 08 add %i1, 8, %o2 status->since_last_period = _Watchdog_Ticks_since_boot - the_period->time_at_period; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Subtract( 200de64: 92 10 00 10 mov %l0, %o1 200de68: 94 06 60 10 add %i1, 0x10, %o2 200de6c: 11 00 80 75 sethi %hi(0x201d400), %o0 200de70: 7f ff f3 80 call 200ac70 <_Timespec_Subtract> 200de74: 90 12 20 7c or %o0, 0x7c, %o0 ! 201d47c <_Thread_Time_of_last_context_switch> 200de78: 30 bf ff f0 b,a 200de38 =============================================================================== 020069ec : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 20069ec: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get ( Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) 20069f0: 11 00 80 74 sethi %hi(0x201d000), %o0 20069f4: 92 10 00 18 mov %i0, %o1 20069f8: 90 12 22 3c or %o0, 0x23c, %o0 20069fc: 40 00 09 4e call 2008f34 <_Objects_Get> 2006a00: 94 07 bf f4 add %fp, -12, %o2 rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 2006a04: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006a08: 80 a0 60 00 cmp %g1, 0 2006a0c: 02 80 00 04 be 2006a1c 2006a10: a2 10 00 08 mov %o0, %l1 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2006a14: 81 c7 e0 08 ret 2006a18: 91 e8 20 04 restore %g0, 4, %o0 the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 2006a1c: 25 00 80 75 sethi %hi(0x201d400), %l2 2006a20: c4 02 20 50 ld [ %o0 + 0x50 ], %g2 2006a24: c2 04 a0 74 ld [ %l2 + 0x74 ], %g1 2006a28: 80 a0 80 01 cmp %g2, %g1 2006a2c: 02 80 00 06 be 2006a44 2006a30: 80 a6 60 00 cmp %i1, 0 _Thread_Enable_dispatch(); 2006a34: 40 00 0b c3 call 2009940 <_Thread_Enable_dispatch> 2006a38: b0 10 20 17 mov 0x17, %i0 2006a3c: 81 c7 e0 08 ret 2006a40: 81 e8 00 00 restore return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 2006a44: 12 80 00 0f bne 2006a80 2006a48: 01 00 00 00 nop switch ( the_period->state ) { 2006a4c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 2006a50: 80 a0 60 00 cmp %g1, 0 2006a54: 02 80 00 07 be 2006a70 2006a58: b0 10 20 0b mov 0xb, %i0 2006a5c: 82 00 7f fd add %g1, -3, %g1 2006a60: 80 a0 60 01 cmp %g1, 1 2006a64: 18 80 00 03 bgu 2006a70 2006a68: b0 10 20 00 clr %i0 2006a6c: b0 10 20 06 mov 6, %i0 ); the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 2006a70: 40 00 0b b4 call 2009940 <_Thread_Enable_dispatch> 2006a74: 01 00 00 00 nop 2006a78: 81 c7 e0 08 ret 2006a7c: 81 e8 00 00 restore } _Thread_Enable_dispatch(); return( return_value ); } _ISR_Disable( level ); 2006a80: 7f ff f0 66 call 2002c18 2006a84: 01 00 00 00 nop 2006a88: a0 10 00 08 mov %o0, %l0 switch ( the_period->state ) { 2006a8c: e6 04 60 38 ld [ %l1 + 0x38 ], %l3 2006a90: 80 a4 e0 02 cmp %l3, 2 2006a94: 02 80 00 1a be 2006afc 2006a98: 80 a4 e0 04 cmp %l3, 4 2006a9c: 02 80 00 32 be 2006b64 2006aa0: 80 a4 e0 00 cmp %l3, 0 2006aa4: 12 bf ff dc bne 2006a14 <== NEVER TAKEN 2006aa8: 01 00 00 00 nop case RATE_MONOTONIC_INACTIVE: { _ISR_Enable( level ); 2006aac: 7f ff f0 5f call 2002c28 2006ab0: 01 00 00 00 nop /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 2006ab4: 7f ff ff 58 call 2006814 <_Rate_monotonic_Initiate_statistics> 2006ab8: 90 10 00 11 mov %l1, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 2006abc: 84 10 20 02 mov 2, %g2 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2006ac0: 03 00 80 1b sethi %hi(0x2006c00), %g1 2006ac4: 82 10 62 c0 or %g1, 0x2c0, %g1 ! 2006ec0 <_Rate_monotonic_Timeout> the_watchdog->id = id; 2006ac8: f0 24 60 30 st %i0, [ %l1 + 0x30 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006acc: 92 04 60 10 add %l1, 0x10, %o1 2006ad0: 11 00 80 75 sethi %hi(0x201d400), %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2006ad4: f2 24 60 1c st %i1, [ %l1 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006ad8: 90 12 20 94 or %o0, 0x94, %o0 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2006adc: c0 24 60 18 clr [ %l1 + 0x18 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2006ae0: c0 24 60 34 clr [ %l1 + 0x34 ] _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 2006ae4: f2 24 60 4c st %i1, [ %l1 + 0x4c ] /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); the_period->state = RATE_MONOTONIC_ACTIVE; 2006ae8: c4 24 60 38 st %g2, [ %l1 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2006aec: c2 24 60 2c st %g1, [ %l1 + 0x2c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006af0: 40 00 11 2f call 200afac <_Watchdog_Insert> 2006af4: b0 10 20 00 clr %i0 2006af8: 30 bf ff de b,a 2006a70 case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 2006afc: 7f ff ff 62 call 2006884 <_Rate_monotonic_Update_statistics> 2006b00: 90 10 00 11 mov %l1, %o0 /* * This tells the _Rate_monotonic_Timeout that this task is * in the process of blocking on the period and that we * may be changing the length of the next period. */ the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING; 2006b04: 82 10 20 01 mov 1, %g1 the_period->next_length = length; 2006b08: f2 24 60 4c st %i1, [ %l1 + 0x4c ] /* * This tells the _Rate_monotonic_Timeout that this task is * in the process of blocking on the period and that we * may be changing the length of the next period. */ the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING; 2006b0c: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; _ISR_Enable( level ); 2006b10: 7f ff f0 46 call 2002c28 2006b14: 90 10 00 10 mov %l0, %o0 _Thread_Executing->Wait.id = the_period->Object.id; 2006b18: c2 04 a0 74 ld [ %l2 + 0x74 ], %g1 2006b1c: c4 04 60 08 ld [ %l1 + 8 ], %g2 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 2006b20: 90 10 00 01 mov %g1, %o0 the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING; the_period->next_length = length; _ISR_Enable( level ); _Thread_Executing->Wait.id = the_period->Object.id; 2006b24: c4 20 60 20 st %g2, [ %g1 + 0x20 ] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 2006b28: 40 00 0e 3a call 200a410 <_Thread_Set_state> 2006b2c: 13 00 00 10 sethi %hi(0x4000), %o1 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 2006b30: 7f ff f0 3a call 2002c18 2006b34: 01 00 00 00 nop local_state = the_period->state; 2006b38: e0 04 60 38 ld [ %l1 + 0x38 ], %l0 the_period->state = RATE_MONOTONIC_ACTIVE; 2006b3c: e6 24 60 38 st %l3, [ %l1 + 0x38 ] _ISR_Enable( level ); 2006b40: 7f ff f0 3a call 2002c28 2006b44: 01 00 00 00 nop /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) 2006b48: 80 a4 20 03 cmp %l0, 3 2006b4c: 02 80 00 17 be 2006ba8 <== NEVER TAKEN 2006b50: d0 04 a0 74 ld [ %l2 + 0x74 ], %o0 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); _Thread_Enable_dispatch(); 2006b54: 40 00 0b 7b call 2009940 <_Thread_Enable_dispatch> 2006b58: b0 10 20 00 clr %i0 2006b5c: 81 c7 e0 08 ret 2006b60: 81 e8 00 00 restore case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 2006b64: 7f ff ff 48 call 2006884 <_Rate_monotonic_Update_statistics> 2006b68: 90 10 00 11 mov %l1, %o0 _ISR_Enable( level ); 2006b6c: 7f ff f0 2f call 2002c28 2006b70: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 2006b74: 82 10 20 02 mov 2, %g1 2006b78: 92 04 60 10 add %l1, 0x10, %o1 2006b7c: 11 00 80 75 sethi %hi(0x201d400), %o0 2006b80: 90 12 20 94 or %o0, 0x94, %o0 ! 201d494 <_Watchdog_Ticks_chain> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2006b84: f2 24 60 1c st %i1, [ %l1 + 0x1c ] the_period->next_length = length; 2006b88: f2 24 60 4c st %i1, [ %l1 + 0x4c ] */ _Rate_monotonic_Update_statistics( the_period ); _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 2006b8c: c2 24 60 38 st %g1, [ %l1 + 0x38 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006b90: 40 00 11 07 call 200afac <_Watchdog_Insert> 2006b94: b0 10 20 06 mov 6, %i0 the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 2006b98: 40 00 0b 6a call 2009940 <_Thread_Enable_dispatch> 2006b9c: 01 00 00 00 nop 2006ba0: 81 c7 e0 08 ret 2006ba4: 81 e8 00 00 restore /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 2006ba8: 40 00 0a 4d call 20094dc <_Thread_Clear_state> <== NOT EXECUTED 2006bac: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED 2006bb0: 30 bf ff e9 b,a 2006b54 <== NOT EXECUTED =============================================================================== 02006bb4 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 2006bb4: 9d e3 bf 30 save %sp, -208, %sp rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 2006bb8: 80 a6 60 00 cmp %i1, 0 2006bbc: 02 80 00 4a be 2006ce4 <== NEVER TAKEN 2006bc0: 90 10 00 18 mov %i0, %o0 return; (*print)( context, "Period information by period\n" ); 2006bc4: 13 00 80 6a sethi %hi(0x201a800), %o1 2006bc8: 9f c6 40 00 call %i1 2006bcc: 92 12 63 50 or %o1, 0x350, %o1 ! 201ab50 #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 2006bd0: 90 10 00 18 mov %i0, %o0 2006bd4: 13 00 80 6a sethi %hi(0x201a800), %o1 2006bd8: 9f c6 40 00 call %i1 2006bdc: 92 12 63 70 or %o1, 0x370, %o1 ! 201ab70 #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 2006be0: 90 10 00 18 mov %i0, %o0 2006be4: 13 00 80 6a sethi %hi(0x201a800), %o1 2006be8: 9f c6 40 00 call %i1 2006bec: 92 12 63 98 or %o1, 0x398, %o1 ! 201ab98 Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 2006bf0: 90 10 00 18 mov %i0, %o0 2006bf4: 13 00 80 6a sethi %hi(0x201a800), %o1 2006bf8: 9f c6 40 00 call %i1 2006bfc: 92 12 63 c0 or %o1, 0x3c0, %o1 ! 201abc0 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 2006c00: 90 10 00 18 mov %i0, %o0 2006c04: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006c08: 9f c6 40 00 call %i1 2006c0c: 92 12 60 10 or %o1, 0x10, %o1 ! 201ac10 /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 2006c10: 03 00 80 74 sethi %hi(0x201d000), %g1 2006c14: a6 10 62 3c or %g1, 0x23c, %l3 ! 201d23c <_Rate_monotonic_Information> 2006c18: e4 04 e0 08 ld [ %l3 + 8 ], %l2 id <= _Rate_monotonic_Information.maximum_id ; 2006c1c: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 2006c20: 80 a4 80 01 cmp %l2, %g1 2006c24: 18 80 00 30 bgu 2006ce4 <== NEVER TAKEN 2006c28: 03 00 80 6b sethi %hi(0x201ac00), %g1 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 2006c2c: 05 00 80 6a sethi %hi(0x201a800), %g2 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 2006c30: b6 10 60 60 or %g1, 0x60, %i3 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 2006c34: b8 10 a3 90 or %g2, 0x390, %i4 2006c38: a8 07 bf 98 add %fp, -104, %l4 status = rtems_rate_monotonic_get_statistics( id, &the_stats ); if ( status != RTEMS_SUCCESSFUL ) continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 2006c3c: ae 07 bf d0 add %fp, -48, %l7 2006c40: ac 07 bf f0 add %fp, -16, %l6 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006c44: ba 07 bf b0 add %fp, -80, %i5 2006c48: aa 07 bf e8 add %fp, -24, %l5 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 2006c4c: 10 80 00 06 b 2006c64 2006c50: b4 07 bf c8 add %fp, -56, %i2 * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 2006c54: a4 04 a0 01 inc %l2 /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 2006c58: 80 a0 40 12 cmp %g1, %l2 2006c5c: 0a 80 00 22 bcs 2006ce4 2006c60: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 2006c64: 90 10 00 12 mov %l2, %o0 2006c68: 40 00 1c 43 call 200dd74 2006c6c: 92 10 00 14 mov %l4, %o1 if ( status != RTEMS_SUCCESSFUL ) 2006c70: 80 a2 20 00 cmp %o0, 0 2006c74: 32 bf ff f8 bne,a 2006c54 2006c78: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 2006c7c: 92 10 00 17 mov %l7, %o1 2006c80: 40 00 1c 52 call 200ddc8 2006c84: 90 10 00 12 mov %l2, %o0 continue; #endif name[ 0 ] = '\0'; if ( the_status.owner ) { 2006c88: d0 07 bf d0 ld [ %fp + -48 ], %o0 2006c8c: 80 a2 20 00 cmp %o0, 0 2006c90: 12 80 00 4b bne 2006dbc <== ALWAYS TAKEN 2006c94: c0 2f bf f0 clrb [ %fp + -16 ] /* * Print part of report line that is not dependent on granularity */ (*print)( context, 2006c98: d8 1f bf 98 ldd [ %fp + -104 ], %o4 <== NOT EXECUTED 2006c9c: 94 10 00 12 mov %l2, %o2 2006ca0: 92 10 00 1b mov %i3, %o1 2006ca4: 96 10 00 16 mov %l6, %o3 2006ca8: 9f c6 40 00 call %i1 2006cac: 90 10 00 18 mov %i0, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006cb0: c2 07 bf 98 ld [ %fp + -104 ], %g1 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006cb4: 94 10 00 15 mov %l5, %o2 2006cb8: 90 10 00 1d mov %i5, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006cbc: 80 a0 60 00 cmp %g1, 0 2006cc0: 12 80 00 0b bne 2006cec 2006cc4: 92 10 00 1c mov %i4, %o1 (*print)( context, "\n" ); 2006cc8: 9f c6 40 00 call %i1 2006ccc: 90 10 00 18 mov %i0, %o0 /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 2006cd0: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 id++ ) { 2006cd4: a4 04 a0 01 inc %l2 /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 2006cd8: 80 a0 40 12 cmp %g1, %l2 2006cdc: 1a bf ff e3 bcc 2006c68 <== ALWAYS TAKEN 2006ce0: 90 10 00 12 mov %l2, %o0 2006ce4: 81 c7 e0 08 ret 2006ce8: 81 e8 00 00 restore */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006cec: 40 00 0f 78 call 200aacc <_Timespec_Divide_by_integer> 2006cf0: 92 10 00 01 mov %g1, %o1 &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 2006cf4: d0 07 bf a4 ld [ %fp + -92 ], %o0 2006cf8: 40 00 44 f9 call 20180dc <.div> 2006cfc: 92 10 23 e8 mov 0x3e8, %o1 2006d00: a2 10 00 08 mov %o0, %l1 2006d04: d0 07 bf ac ld [ %fp + -84 ], %o0 2006d08: 40 00 44 f5 call 20180dc <.div> 2006d0c: 92 10 23 e8 mov 0x3e8, %o1 2006d10: c2 07 bf e8 ld [ %fp + -24 ], %g1 2006d14: a0 10 00 08 mov %o0, %l0 2006d18: d0 07 bf ec ld [ %fp + -20 ], %o0 2006d1c: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2006d20: 40 00 44 ef call 20180dc <.div> 2006d24: 92 10 23 e8 mov 0x3e8, %o1 2006d28: d8 07 bf a8 ld [ %fp + -88 ], %o4 2006d2c: d4 07 bf a0 ld [ %fp + -96 ], %o2 2006d30: 96 10 00 11 mov %l1, %o3 2006d34: 9a 10 00 10 mov %l0, %o5 2006d38: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 2006d3c: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006d40: 90 10 00 18 mov %i0, %o0 2006d44: 9f c6 40 00 call %i1 2006d48: 92 12 60 78 or %o1, 0x78, %o1 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 2006d4c: d2 07 bf 98 ld [ %fp + -104 ], %o1 2006d50: 94 10 00 15 mov %l5, %o2 2006d54: 40 00 0f 5e call 200aacc <_Timespec_Divide_by_integer> 2006d58: 90 10 00 1a mov %i2, %o0 &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 2006d5c: d0 07 bf bc ld [ %fp + -68 ], %o0 2006d60: 40 00 44 df call 20180dc <.div> 2006d64: 92 10 23 e8 mov 0x3e8, %o1 2006d68: a2 10 00 08 mov %o0, %l1 2006d6c: d0 07 bf c4 ld [ %fp + -60 ], %o0 2006d70: 40 00 44 db call 20180dc <.div> 2006d74: 92 10 23 e8 mov 0x3e8, %o1 2006d78: c2 07 bf e8 ld [ %fp + -24 ], %g1 2006d7c: a0 10 00 08 mov %o0, %l0 2006d80: d0 07 bf ec ld [ %fp + -20 ], %o0 2006d84: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2006d88: 40 00 44 d5 call 20180dc <.div> 2006d8c: 92 10 23 e8 mov 0x3e8, %o1 2006d90: d4 07 bf b8 ld [ %fp + -72 ], %o2 2006d94: d8 07 bf c0 ld [ %fp + -64 ], %o4 2006d98: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 2006d9c: 96 10 00 11 mov %l1, %o3 2006da0: 9a 10 00 10 mov %l0, %o5 2006da4: 90 10 00 18 mov %i0, %o0 2006da8: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006dac: 9f c6 40 00 call %i1 2006db0: 92 12 60 98 or %o1, 0x98, %o1 ! 201ac98 /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 2006db4: 10 bf ff a8 b 2006c54 2006db8: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 #endif name[ 0 ] = '\0'; if ( the_status.owner ) { rtems_object_get_name( the_status.owner, sizeof(name), name ); 2006dbc: 94 10 00 16 mov %l6, %o2 2006dc0: 40 00 00 70 call 2006f80 2006dc4: 92 10 20 05 mov 5, %o1 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 2006dc8: 10 bf ff b5 b 2006c9c 2006dcc: d8 1f bf 98 ldd [ %fp + -104 ], %o4 =============================================================================== 02006dec : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 2006dec: 9d e3 bf 98 save %sp, -104, %sp 2006df0: 05 00 80 74 sethi %hi(0x201d000), %g2 2006df4: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 201d3b0 <_Thread_Dispatch_disable_level> 2006df8: 82 00 60 01 inc %g1 2006dfc: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 2006e00: 03 00 80 74 sethi %hi(0x201d000), %g1 2006e04: a2 10 62 3c or %g1, 0x23c, %l1 ! 201d23c <_Rate_monotonic_Information> 2006e08: e0 04 60 08 ld [ %l1 + 8 ], %l0 id <= _Rate_monotonic_Information.maximum_id ; 2006e0c: c2 04 60 0c ld [ %l1 + 0xc ], %g1 2006e10: 80 a4 00 01 cmp %l0, %g1 2006e14: 18 80 00 09 bgu 2006e38 <== NEVER TAKEN 2006e18: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 2006e1c: 40 00 00 0a call 2006e44 2006e20: 90 10 00 10 mov %l0, %o0 /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 2006e24: c2 04 60 0c ld [ %l1 + 0xc ], %g1 id++ ) { 2006e28: a0 04 20 01 inc %l0 /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 2006e2c: 80 a0 40 10 cmp %g1, %l0 2006e30: 1a bf ff fb bcc 2006e1c 2006e34: 01 00 00 00 nop } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 2006e38: 40 00 0a c2 call 2009940 <_Thread_Enable_dispatch> 2006e3c: 81 e8 00 00 restore =============================================================================== 02010148 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 2010148: 9d e3 bf 90 save %sp, -112, %sp 201014c: a0 10 00 18 mov %i0, %l0 Heap_Extend_status heap_status; Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Region_Control *the_region; if ( !starting_address ) 2010150: 80 a6 60 00 cmp %i1, 0 2010154: 02 80 00 28 be 20101f4 <== NEVER TAKEN 2010158: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 201015c: 23 00 80 c8 sethi %hi(0x2032000), %l1 2010160: 40 00 09 38 call 2012640 <_API_Mutex_Lock> 2010164: d0 04 63 4c ld [ %l1 + 0x34c ], %o0 ! 203234c <_RTEMS_Allocator_Mutex> RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 2010168: 92 10 00 10 mov %l0, %o1 201016c: 11 00 80 c8 sethi %hi(0x2032000), %o0 2010170: 94 07 bf f0 add %fp, -16, %o2 2010174: 40 00 10 4f call 20142b0 <_Objects_Get_no_protection> 2010178: 90 12 20 c4 or %o0, 0xc4, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 201017c: c2 07 bf f0 ld [ %fp + -16 ], %g1 2010180: 80 a0 60 00 cmp %g1, 0 2010184: 12 80 00 16 bne 20101dc 2010188: a0 10 00 08 mov %o0, %l0 case OBJECTS_LOCAL: heap_status = _Heap_Extend( 201018c: 92 10 00 19 mov %i1, %o1 2010190: 94 10 00 1a mov %i2, %o2 2010194: 90 02 20 68 add %o0, 0x68, %o0 2010198: 96 07 bf f4 add %fp, -12, %o3 201019c: 40 00 0c 6e call 2013354 <_Heap_Extend> 20101a0: b0 10 20 09 mov 9, %i0 starting_address, length, &amount_extended ); switch ( heap_status ) { 20101a4: 80 a2 20 01 cmp %o0, 1 20101a8: 02 80 00 11 be 20101ec 20101ac: 01 00 00 00 nop 20101b0: 1a 80 00 13 bcc 20101fc 20101b4: 80 a2 20 02 cmp %o0, 2 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 20101b8: c6 07 bf f4 ld [ %fp + -12 ], %g3 20101bc: c4 04 20 54 ld [ %l0 + 0x54 ], %g2 the_region->maximum_segment_size += amount_extended; 20101c0: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 20101c4: 84 00 80 03 add %g2, %g3, %g2 the_region->maximum_segment_size += amount_extended; 20101c8: 82 00 40 03 add %g1, %g3, %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 20101cc: c4 24 20 54 st %g2, [ %l0 + 0x54 ] the_region->maximum_segment_size += amount_extended; 20101d0: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 20101d4: 10 80 00 06 b 20101ec 20101d8: b0 10 20 00 clr %i0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 20101dc: 80 a0 60 01 cmp %g1, 1 20101e0: 02 80 00 03 be 20101ec <== ALWAYS TAKEN 20101e4: b0 10 20 04 mov 4, %i0 switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; break; 20101e8: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 20101ec: 40 00 09 2b call 2012698 <_API_Mutex_Unlock> 20101f0: d0 04 63 4c ld [ %l1 + 0x34c ], %o0 return return_status; } 20101f4: 81 c7 e0 08 ret 20101f8: 81 e8 00 00 restore starting_address, length, &amount_extended ); switch ( heap_status ) { 20101fc: 12 bf ff fb bne 20101e8 <== NEVER TAKEN 2010200: b0 10 20 18 mov 0x18, %i0 2010204: 30 bf ff fa b,a 20101ec =============================================================================== 0201030c : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 201030c: 9d e3 bf 90 save %sp, -112, %sp 2010310: a6 10 00 18 mov %i0, %l3 Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; void *the_segment; if ( !segment ) 2010314: 80 a7 20 00 cmp %i4, 0 2010318: 02 80 00 1b be 2010384 <== NEVER TAKEN 201031c: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; *segment = NULL; 2010320: c0 27 00 00 clr [ %i4 ] if ( size == 0 ) 2010324: 80 a6 60 00 cmp %i1, 0 2010328: 02 80 00 17 be 2010384 <== NEVER TAKEN 201032c: b0 10 20 08 mov 8, %i0 return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 2010330: 23 00 80 c8 sethi %hi(0x2032000), %l1 2010334: 40 00 08 c3 call 2012640 <_API_Mutex_Lock> 2010338: d0 04 63 4c ld [ %l1 + 0x34c ], %o0 ! 203234c <_RTEMS_Allocator_Mutex> executing = _Thread_Executing; 201033c: 03 00 80 c8 sethi %hi(0x2032000), %g1 2010340: 92 10 00 13 mov %l3, %o1 2010344: e4 00 63 54 ld [ %g1 + 0x354 ], %l2 2010348: 11 00 80 c8 sethi %hi(0x2032000), %o0 201034c: 94 07 bf f4 add %fp, -12, %o2 2010350: 40 00 0f d8 call 20142b0 <_Objects_Get_no_protection> 2010354: 90 12 20 c4 or %o0, 0xc4, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 2010358: c2 07 bf f4 ld [ %fp + -12 ], %g1 201035c: 80 a0 60 00 cmp %g1, 0 2010360: 02 80 00 0b be 201038c 2010364: a0 10 00 08 mov %o0, %l0 2010368: 82 18 60 01 xor %g1, 1, %g1 201036c: 80 a0 00 01 cmp %g0, %g1 2010370: 84 40 3f ff addx %g0, -1, %g2 2010374: b0 08 bf eb and %g2, -21, %i0 2010378: b0 06 20 19 add %i0, 0x19, %i0 case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 201037c: 40 00 08 c7 call 2012698 <_API_Mutex_Unlock> 2010380: d0 04 63 4c ld [ %l1 + 0x34c ], %o0 return return_status; } 2010384: 81 c7 e0 08 ret 2010388: 81 e8 00 00 restore executing = _Thread_Executing; the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) 201038c: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 2010390: 80 a6 40 01 cmp %i1, %g1 2010394: 18 bf ff fa bgu 201037c 2010398: b0 10 20 08 mov 8, %i0 RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 201039c: 90 02 20 68 add %o0, 0x68, %o0 20103a0: 40 00 0b ab call 201324c <_Heap_Allocate> 20103a4: 92 10 00 19 mov %i1, %o1 the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 20103a8: 80 a2 20 00 cmp %o0, 0 20103ac: 02 80 00 07 be 20103c8 20103b0: b0 10 20 00 clr %i0 the_region->number_of_used_blocks += 1; 20103b4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 *segment = the_segment; 20103b8: d0 27 00 00 st %o0, [ %i4 ] the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { the_region->number_of_used_blocks += 1; 20103bc: 82 00 60 01 inc %g1 20103c0: 10 bf ff ef b 201037c 20103c4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] *segment = the_segment; return_status = RTEMS_SUCCESSFUL; } else if ( _Options_Is_no_wait( option_set ) ) { 20103c8: 80 8e a0 01 btst 1, %i2 20103cc: 12 bf ff ec bne 201037c 20103d0: b0 10 20 0d mov 0xd, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20103d4: 05 00 80 c8 sethi %hi(0x2032000), %g2 20103d8: c2 00 a2 90 ld [ %g2 + 0x290 ], %g1 ! 2032290 <_Thread_Dispatch_disable_level> 20103dc: 82 00 60 01 inc %g1 20103e0: c2 20 a2 90 st %g1, [ %g2 + 0x290 ] * Switch from using the memory allocation mutex to using a * dispatching disabled critical section. We have to do this * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 20103e4: 40 00 08 ad call 2012698 <_API_Mutex_Unlock> 20103e8: d0 04 63 4c ld [ %l1 + 0x34c ], %o0 executing->Wait.queue = &the_region->Wait_queue; 20103ec: 84 04 20 10 add %l0, 0x10, %g2 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 20103f0: 82 10 20 01 mov 1, %g1 executing->Wait.count = size; executing->Wait.return_argument = segment; _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 20103f4: 92 10 00 1b mov %i3, %o1 20103f8: 90 10 00 02 mov %g2, %o0 20103fc: 15 00 80 55 sethi %hi(0x2015400), %o2 2010400: 94 12 a2 d4 or %o2, 0x2d4, %o2 ! 20156d4 <_Thread_queue_Timeout> * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; 2010404: c4 24 a0 44 st %g2, [ %l2 + 0x44 ] 2010408: c2 24 20 40 st %g1, [ %l0 + 0x40 ] executing->Wait.id = id; 201040c: e6 24 a0 20 st %l3, [ %l2 + 0x20 ] executing->Wait.count = size; 2010410: f2 24 a0 24 st %i1, [ %l2 + 0x24 ] executing->Wait.return_argument = segment; _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 2010414: 40 00 13 9a call 201527c <_Thread_queue_Enqueue_with_handler> 2010418: f8 24 a0 28 st %i4, [ %l2 + 0x28 ] _Thread_Enable_dispatch(); 201041c: 40 00 12 3a call 2014d04 <_Thread_Enable_dispatch> 2010420: 01 00 00 00 nop return (rtems_status_code) executing->Wait.return_code; 2010424: f0 04 a0 34 ld [ %l2 + 0x34 ], %i0 2010428: 81 c7 e0 08 ret 201042c: 81 e8 00 00 restore =============================================================================== 02010504 : Objects_Id id, void *segment, size_t size, size_t *old_size ) { 2010504: 9d e3 bf 88 save %sp, -120, %sp uint32_t osize; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) 2010508: 80 a6 e0 00 cmp %i3, 0 201050c: 02 80 00 2e be 20105c4 2010510: 21 00 80 c8 sethi %hi(0x2032000), %l0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 2010514: 40 00 08 4b call 2012640 <_API_Mutex_Lock> 2010518: d0 04 23 4c ld [ %l0 + 0x34c ], %o0 ! 203234c <_RTEMS_Allocator_Mutex> 201051c: 92 10 00 18 mov %i0, %o1 2010520: 11 00 80 c8 sethi %hi(0x2032000), %o0 2010524: 94 07 bf f0 add %fp, -16, %o2 2010528: 40 00 0f 62 call 20142b0 <_Objects_Get_no_protection> 201052c: 90 12 20 c4 or %o0, 0xc4, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 2010530: c2 07 bf f0 ld [ %fp + -16 ], %g1 2010534: 80 a0 60 00 cmp %g1, 0 2010538: 12 80 00 14 bne 2010588 201053c: b0 10 00 08 mov %o0, %i0 case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 2010540: 94 10 00 1a mov %i2, %o2 2010544: 92 10 00 19 mov %i1, %o1 2010548: 90 02 20 68 add %o0, 0x68, %o0 201054c: 96 07 bf ec add %fp, -20, %o3 2010550: 40 00 0d 0b call 201397c <_Heap_Resize_block> 2010554: 98 07 bf f4 add %fp, -12, %o4 segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 2010558: c2 07 bf ec ld [ %fp + -20 ], %g1 _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) 201055c: b4 92 20 00 orcc %o0, 0, %i2 2010560: 12 80 00 13 bne 20105ac <== ALWAYS TAKEN 2010564: c2 26 c0 00 st %g1, [ %i3 ] 2010568: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 201056c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010570: 12 80 00 17 bne 20105cc <== NOT EXECUTED 2010574: d0 04 23 4c ld [ %l0 + 0x34c ], %o0 <== NOT EXECUTED _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 2010578: 40 00 08 48 call 2012698 <_API_Mutex_Unlock> <== NOT EXECUTED 201057c: b0 10 20 00 clr %i0 <== NOT EXECUTED 2010580: 81 c7 e0 08 ret <== NOT EXECUTED 2010584: 81 e8 00 00 restore <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 2010588: d0 04 23 4c ld [ %l0 + 0x34c ], %o0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 201058c: 82 18 60 01 xor %g1, 1, %g1 2010590: 80 a0 00 01 cmp %g0, %g1 2010594: 84 40 3f ff addx %g0, -1, %g2 2010598: b0 08 bf eb and %g2, -21, %i0 case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 201059c: 40 00 08 3f call 2012698 <_API_Mutex_Unlock> 20105a0: b0 06 20 19 add %i0, 0x19, %i0 20105a4: 81 c7 e0 08 ret 20105a8: 81 e8 00 00 restore _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 20105ac: d0 04 23 4c ld [ %l0 + 0x34c ], %o0 20105b0: 40 00 08 3a call 2012698 <_API_Mutex_Unlock> 20105b4: b0 10 20 0d mov 0xd, %i0 return 20105b8: 80 a6 a0 01 cmp %i2, 1 20105bc: 02 80 00 07 be 20105d8 <== NEVER TAKEN 20105c0: 01 00 00 00 nop break; } _RTEMS_Unlock_allocator(); return return_status; } 20105c4: 81 c7 e0 08 ret 20105c8: 91 e8 20 09 restore %g0, 9, %o0 *old_size = (uint32_t) osize; _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) _Region_Process_queue( the_region ); /* unlocks allocator */ 20105cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20105d0: 40 00 23 72 call 2019398 <_Region_Process_queue> <== NOT EXECUTED 20105d4: b0 10 20 00 clr %i0 <== NOT EXECUTED 20105d8: 81 c7 e0 08 ret <== NOT EXECUTED 20105dc: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 020055c4 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 20055c4: 9d e3 bf 80 save %sp, -128, %sp register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attributes; CORE_semaphore_Attributes the_semaphore_attributes; if ( !rtems_is_name_valid( name ) ) 20055c8: a4 96 20 00 orcc %i0, 0, %l2 20055cc: 02 80 00 33 be 2005698 20055d0: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 20055d4: 80 a7 20 00 cmp %i4, 0 20055d8: 02 80 00 30 be 2005698 <== NEVER TAKEN 20055dc: b0 10 20 09 mov 9, %i0 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 20055e0: 82 8e a0 c0 andcc %i2, 0xc0, %g1 20055e4: 12 80 00 2f bne 20056a0 20055e8: a0 0e a0 30 and %i2, 0x30, %l0 if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 20055ec: 80 a4 20 00 cmp %l0, 0 20055f0: 02 80 00 04 be 2005600 20055f4: 80 a6 60 01 cmp %i1, 1 20055f8: 18 80 00 28 bgu 2005698 20055fc: b0 10 20 0a mov 0xa, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005600: 05 00 80 60 sethi %hi(0x2018000), %g2 2005604: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2018310 <_Thread_Dispatch_disable_level> 2005608: 82 00 60 01 inc %g1 200560c: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] * This function allocates a semaphore control block from * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 2005610: 31 00 80 60 sethi %hi(0x2018000), %i0 2005614: 40 00 05 94 call 2006c64 <_Objects_Allocate> 2005618: 90 16 21 d4 or %i0, 0x1d4, %o0 ! 20181d4 <_Semaphore_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 200561c: a2 92 20 00 orcc %o0, 0, %l1 2005620: 02 80 00 4e be 2005758 2005624: 80 a4 20 00 cmp %l0, 0 * If it is not a counting semaphore, then it is either a * simple binary semaphore or a more powerful mutex style binary * semaphore. */ if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { 2005628: 02 80 00 2c be 20056d8 200562c: f4 24 60 10 st %i2, [ %l1 + 0x10 ] CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 2005630: 80 8e a0 40 btst 0x40, %i2 2005634: 02 80 00 44 be 2005744 2005638: 80 8e a0 80 btst 0x80, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 200563c: 82 10 20 02 mov 2, %g1 2005640: c2 27 bf e8 st %g1, [ %fp + -24 ] the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 2005644: 80 a4 20 10 cmp %l0, 0x10 2005648: 02 80 00 48 be 2005768 200564c: 82 10 20 02 mov 2, %g1 the_mutex_attributes.only_owner_release = TRUE; break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; the_mutex_attributes.only_owner_release = FALSE; 2005650: c0 2f bf e4 clrb [ %fp + -28 ] case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; 2005654: c2 27 bf e0 st %g1, [ %fp + -32 ] the_mutex_attributes.only_owner_release = FALSE; } the_mutex_attributes.priority_ceiling = priority_ceiling; mutex_status = _CORE_mutex_Initialize( 2005658: 82 1e 60 01 xor %i1, 1, %g1 200565c: 80 a0 00 01 cmp %g0, %g1 } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; the_mutex_attributes.only_owner_release = FALSE; } the_mutex_attributes.priority_ceiling = priority_ceiling; 2005660: f6 27 bf ec st %i3, [ %fp + -20 ] mutex_status = _CORE_mutex_Initialize( 2005664: 94 60 3f ff subx %g0, -1, %o2 2005668: 90 04 60 14 add %l1, 0x14, %o0 200566c: 40 00 03 64 call 20063fc <_CORE_mutex_Initialize> 2005670: 92 07 bf e0 add %fp, -32, %o1 &the_semaphore->Core_control.mutex, &the_mutex_attributes, (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED ); if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) { 2005674: 80 a2 20 06 cmp %o0, 6 2005678: 32 80 00 26 bne,a 2005710 <== ALWAYS TAKEN 200567c: c4 04 60 08 ld [ %l1 + 8 ], %g2 */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 2005680: 90 16 21 d4 or %i0, 0x1d4, %o0 <== NOT EXECUTED 2005684: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2005688: 40 00 06 72 call 2007050 <_Objects_Free> <== NOT EXECUTED 200568c: b0 10 20 13 mov 0x13, %i0 <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 2005690: 40 00 09 60 call 2007c10 <_Thread_Enable_dispatch> <== NOT EXECUTED 2005694: 01 00 00 00 nop <== NOT EXECUTED 2005698: 81 c7 e0 08 ret 200569c: 81 e8 00 00 restore #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 20056a0: 80 a4 20 10 cmp %l0, 0x10 20056a4: 02 80 00 06 be 20056bc 20056a8: 80 a4 20 20 cmp %l0, 0x20 20056ac: 02 80 00 05 be 20056c0 20056b0: 80 8e a0 04 btst 4, %i2 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 20056b4: 81 c7 e0 08 ret 20056b8: 91 e8 20 0b restore %g0, 0xb, %o0 #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 20056bc: 80 8e a0 04 btst 4, %i2 20056c0: 02 bf ff fd be 20056b4 20056c4: 80 a0 60 c0 cmp %g1, 0xc0 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 20056c8: 12 bf ff ca bne 20055f0 20056cc: 80 a4 20 00 cmp %l0, 0 name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 20056d0: 81 c7 e0 08 ret 20056d4: 91 e8 20 0b restore %g0, 0xb, %o0 _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) 20056d8: 80 8e a0 04 btst 4, %i2 20056dc: 22 80 00 04 be,a 20056ec 20056e0: c0 27 bf f4 clr [ %fp + -12 ] the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 20056e4: 82 10 20 01 mov 1, %g1 20056e8: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 20056ec: 82 10 3f ff mov -1, %g1 /* * The following are just to make Purify happy. */ the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 20056f0: c0 27 bf e0 clr [ %fp + -32 ] the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 20056f4: c0 27 bf ec clr [ %fp + -20 ] _CORE_semaphore_Initialize( 20056f8: 94 10 00 19 mov %i1, %o2 /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 20056fc: c2 27 bf f0 st %g1, [ %fp + -16 ] */ the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; _CORE_semaphore_Initialize( 2005700: 90 04 60 14 add %l1, 0x14, %o0 2005704: 40 00 04 29 call 20067a8 <_CORE_semaphore_Initialize> 2005708: 92 07 bf f0 add %fp, -16, %o1 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200570c: c4 04 60 08 ld [ %l1 + 8 ], %g2 2005710: 82 16 21 d4 or %i0, 0x1d4, %g1 information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 2005714: e4 24 60 0c st %l2, [ %l1 + 0xc ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2005718: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 200571c: c4 27 00 00 st %g2, [ %i4 ] 2005720: 03 00 00 3f sethi %hi(0xfc00), %g1 2005724: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005728: 84 08 80 01 and %g2, %g1, %g2 200572c: 85 28 a0 02 sll %g2, 2, %g2 the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 2005730: b0 10 20 00 clr %i0 2005734: 40 00 09 37 call 2007c10 <_Thread_Enable_dispatch> 2005738: e2 20 c0 02 st %l1, [ %g3 + %g2 ] 200573c: 81 c7 e0 08 ret 2005740: 81 e8 00 00 restore if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 2005744: 02 80 00 0f be 2005780 2005748: 80 8e a0 04 btst 4, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 200574c: 82 10 20 03 mov 3, %g1 2005750: 10 bf ff bd b 2005644 2005754: c2 27 bf e8 st %g1, [ %fp + -24 ] _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 2005758: 40 00 09 2e call 2007c10 <_Thread_Enable_dispatch> 200575c: b0 10 20 05 mov 5, %i0 2005760: 81 c7 e0 08 ret 2005764: 81 e8 00 00 restore if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 2005768: c2 07 bf e8 ld [ %fp + -24 ], %g1 200576c: 80 a0 60 01 cmp %g1, 1 2005770: 18 80 00 09 bgu 2005794 2005774: c0 27 bf e0 clr [ %fp + -32 ] case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; 2005778: 10 bf ff b8 b 2005658 200577c: c0 2f bf e4 clrb [ %fp + -28 ] if ( _Attributes_Is_inherit_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; else if ( _Attributes_Is_priority( attribute_set ) ) 2005780: 22 bf ff b1 be,a 2005644 2005784: c0 27 bf e8 clr [ %fp + -24 ] the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 2005788: 82 10 20 01 mov 1, %g1 200578c: 10 bf ff ae b 2005644 2005790: c2 27 bf e8 st %g1, [ %fp + -24 ] if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 2005794: 80 a0 60 03 cmp %g1, 3 2005798: 18 bf ff b1 bgu 200565c <== NEVER TAKEN 200579c: 82 1e 60 01 xor %i1, 1, %g1 case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 20057a0: 82 10 20 01 mov 1, %g1 20057a4: 10 bf ff ad b 2005658 20057a8: c2 2f bf e4 stb %g1, [ %fp + -28 ] =============================================================================== 0201091c : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 201091c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2010920: 11 00 80 c8 sethi %hi(0x2032000), %o0 2010924: 92 10 00 18 mov %i0, %o1 2010928: 90 12 21 04 or %o0, 0x104, %o0 201092c: 40 00 0e 73 call 20142f8 <_Objects_Get> 2010930: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2010934: c2 07 bf f4 ld [ %fp + -12 ], %g1 2010938: 80 a0 60 00 cmp %g1, 0 201093c: 12 80 00 0b bne 2010968 2010940: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 2010944: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2010948: 80 88 60 30 btst 0x30, %g1 201094c: 12 80 00 09 bne 2010970 <== ALWAYS TAKEN 2010950: 90 02 20 14 add %o0, 0x14, %o0 &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 2010954: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010958: 40 00 09 86 call 2012f70 <_CORE_semaphore_Flush> <== NOT EXECUTED 201095c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED &the_semaphore->Core_control.semaphore, SEND_OBJECT_WAS_DELETED, CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT ); } _Thread_Enable_dispatch(); 2010960: 40 00 10 e9 call 2014d04 <_Thread_Enable_dispatch> 2010964: b0 10 20 00 clr %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2010968: 81 c7 e0 08 ret 201096c: 81 e8 00 00 restore the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Flush( 2010970: 92 10 20 00 clr %o1 2010974: 40 00 08 94 call 2012bc4 <_CORE_mutex_Flush> 2010978: 94 10 20 01 mov 1, %o2 201097c: 30 bf ff f9 b,a 2010960 =============================================================================== 020157cc : */ void rtems_shutdown_executive( uint32_t result ) { 20157cc: 9d e3 bf 10 save %sp, -240, %sp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 20157d0: 05 00 80 61 sethi %hi(0x2018400), %g2 20157d4: c2 00 a0 b4 ld [ %g2 + 0xb4 ], %g1 ! 20184b4 <_System_state_Current> 20157d8: 80 a0 60 04 cmp %g1, 4 20157dc: 02 80 00 07 be 20157f8 <== NEVER TAKEN 20157e0: 82 10 20 04 mov 4, %g1 Context_Control *context_p = &context_area; if ( _System_state_Is_up(_System_state_Get ()) ) context_p = &_Thread_Executing->Registers; _Context_Switch( context_p, &_Thread_BSP_context ); 20157e4: 13 00 80 60 sethi %hi(0x2018000), %o1 20157e8: c2 20 a0 b4 st %g1, [ %g2 + 0xb4 ] 20157ec: 92 12 62 88 or %o1, 0x288, %o1 20157f0: 7f ff cf 02 call 20093f8 <_CPU_Context_switch> 20157f4: 90 07 bf 70 add %fp, -144, %o0 20157f8: 81 c7 e0 08 ret <== NOT EXECUTED 20157fc: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02010b80 : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 2010b80: 9d e3 bf 90 save %sp, -112, %sp 2010b84: 90 10 00 18 mov %i0, %o0 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 2010b88: 80 a6 60 00 cmp %i1, 0 2010b8c: 02 80 00 2f be 2010c48 <== NEVER TAKEN 2010b90: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 2010b94: 40 00 10 6a call 2014d3c <_Thread_Get> 2010b98: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 2010b9c: c2 07 bf f4 ld [ %fp + -12 ], %g1 ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 2010ba0: a0 10 00 08 mov %o0, %l0 switch ( location ) { 2010ba4: 80 a0 60 00 cmp %g1, 0 2010ba8: 12 80 00 28 bne 2010c48 2010bac: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 2010bb0: f0 02 21 68 ld [ %o0 + 0x168 ], %i0 asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 2010bb4: c2 06 20 0c ld [ %i0 + 0xc ], %g1 2010bb8: 80 a0 60 00 cmp %g1, 0 2010bbc: 02 80 00 25 be 2010c50 2010bc0: 01 00 00 00 nop if ( asr->is_enabled ) { 2010bc4: c2 0e 20 08 ldub [ %i0 + 8 ], %g1 2010bc8: 80 a0 60 00 cmp %g1, 0 2010bcc: 02 80 00 16 be 2010c24 2010bd0: 01 00 00 00 nop rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 2010bd4: 7f ff e9 a8 call 200b274 2010bd8: 01 00 00 00 nop *signal_set |= signals; 2010bdc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 2010be0: 82 10 40 19 or %g1, %i1, %g1 2010be4: c2 26 20 14 st %g1, [ %i0 + 0x14 ] _ISR_Enable( _level ); 2010be8: 7f ff e9 a7 call 200b284 2010bec: 01 00 00 00 nop _ASR_Post_signals( signal_set, &asr->signals_posted ); the_thread->do_post_task_switch_extension = true; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 2010bf0: 03 00 80 c8 sethi %hi(0x2032000), %g1 2010bf4: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 ! 2032330 <_ISR_Nest_level> if ( ! _ASR_Is_null_handler( asr->handler ) ) { if ( asr->is_enabled ) { _ASR_Post_signals( signal_set, &asr->signals_posted ); the_thread->do_post_task_switch_extension = true; 2010bf8: 86 10 20 01 mov 1, %g3 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 2010bfc: 80 a0 a0 00 cmp %g2, 0 2010c00: 02 80 00 10 be 2010c40 2010c04: c6 2c 20 75 stb %g3, [ %l0 + 0x75 ] 2010c08: 03 00 80 c8 sethi %hi(0x2032000), %g1 2010c0c: c4 00 63 54 ld [ %g1 + 0x354 ], %g2 ! 2032354 <_Thread_Executing> 2010c10: 80 a4 00 02 cmp %l0, %g2 2010c14: 12 80 00 0b bne 2010c40 <== NEVER TAKEN 2010c18: 03 00 80 c8 sethi %hi(0x2032000), %g1 _ISR_Signals_to_thread_executing = TRUE; 2010c1c: 10 80 00 09 b 2010c40 2010c20: c6 28 63 e8 stb %g3, [ %g1 + 0x3e8 ] ! 20323e8 <_ISR_Signals_to_thread_executing> rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 2010c24: 7f ff e9 94 call 200b274 2010c28: 01 00 00 00 nop *signal_set |= signals; 2010c2c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2010c30: 82 10 40 19 or %g1, %i1, %g1 2010c34: c2 26 20 18 st %g1, [ %i0 + 0x18 ] _ISR_Enable( _level ); 2010c38: 7f ff e9 93 call 200b284 2010c3c: 01 00 00 00 nop } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 2010c40: 40 00 10 31 call 2014d04 <_Thread_Enable_dispatch> 2010c44: b0 10 20 00 clr %i0 ! 0 2010c48: 81 c7 e0 08 ret 2010c4c: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2010c50: 40 00 10 2d call 2014d04 <_Thread_Enable_dispatch> 2010c54: b0 10 20 0b mov 0xb, %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2010c58: 81 c7 e0 08 ret 2010c5c: 81 e8 00 00 restore =============================================================================== 02005a2c : size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, Objects_Id *id ) { 2005a2c: 9d e3 bf 78 save %sp, -136, %sp 2005a30: a4 10 00 18 mov %i0, %l2 Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 2005a34: 80 a7 60 00 cmp %i5, 0 2005a38: 02 80 00 38 be 2005b18 <== NEVER TAKEN 2005a3c: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 2005a40: 80 a4 a0 00 cmp %l2, 0 2005a44: 02 80 00 35 be 2005b18 2005a48: b0 10 20 03 mov 3, %i0 /* * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { 2005a4c: 03 00 00 20 sethi %hi(0x8000), %g1 2005a50: 80 8f 00 01 btst %i4, %g1 2005a54: 12 80 00 09 bne 2005a78 2005a58: 80 a6 60 00 cmp %i1, 0 */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 2005a5c: 02 80 00 2f be 2005b18 2005a60: b0 10 20 13 mov 0x13, %i0 2005a64: 03 00 80 5d sethi %hi(0x2017400), %g1 2005a68: c4 08 60 e4 ldub [ %g1 + 0xe4 ], %g2 ! 20174e4 2005a6c: 80 a6 40 02 cmp %i1, %g2 2005a70: 18 80 00 38 bgu 2005b50 <== NEVER TAKEN 2005a74: 01 00 00 00 nop */ /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 2005a78: 31 00 80 60 sethi %hi(0x2018000), %i0 2005a7c: d0 06 23 cc ld [ %i0 + 0x3cc ], %o0 ! 20183cc <_RTEMS_Allocator_Mutex> 2005a80: 40 00 02 2d call 2006334 <_API_Mutex_Lock> 2005a84: 23 00 80 60 sethi %hi(0x2018000), %l1 * This function allocates a task control block from * the inactive chain of free task control blocks. */ RTEMS_INLINE_ROUTINE Thread_Control *_RTEMS_tasks_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_RTEMS_tasks_Information ); 2005a88: 40 00 04 77 call 2006c64 <_Objects_Allocate> 2005a8c: 90 14 62 14 or %l1, 0x214, %o0 ! 2018214 <_RTEMS_tasks_Information> * the event of an error. */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { 2005a90: a0 92 20 00 orcc %o0, 0, %l0 2005a94: 02 80 00 2c be 2005b44 2005a98: 83 36 e0 08 srl %i3, 8, %g1 /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 2005a9c: 85 36 e0 09 srl %i3, 9, %g2 2005aa0: 82 18 60 01 xor %g1, 1, %g1 2005aa4: 84 08 a0 01 and %g2, 1, %g2 2005aa8: 82 08 60 01 and %g1, 1, %g1 2005aac: c4 23 a0 60 st %g2, [ %sp + 0x60 ] 2005ab0: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2005ab4: 84 07 bf f4 add %fp, -12, %g2 2005ab8: 82 0e e0 0f and %i3, 0xf, %g1 2005abc: e4 27 bf f4 st %l2, [ %fp + -12 ] 2005ac0: c0 23 a0 64 clr [ %sp + 0x64 ] 2005ac4: 90 14 62 14 or %l1, 0x214, %o0 2005ac8: 96 10 00 1a mov %i2, %o3 2005acc: 98 0f 20 01 and %i4, 1, %o4 2005ad0: 9a 10 00 19 mov %i1, %o5 2005ad4: c2 23 a0 68 st %g1, [ %sp + 0x68 ] 2005ad8: c4 23 a0 6c st %g2, [ %sp + 0x6c ] 2005adc: 92 10 00 10 mov %l0, %o1 2005ae0: 40 00 08 86 call 2007cf8 <_Thread_Initialize> 2005ae4: 94 10 20 00 clr %o2 NULL, /* no budget algorithm callout */ _Modes_Get_interrupt_level(initial_modes), (Objects_Name) name ); if ( !status ) { 2005ae8: 80 8a 20 ff btst 0xff, %o0 2005aec: 02 80 00 0d be 2005b20 2005af0: d0 06 23 cc ld [ %i0 + 0x3cc ], %o0 api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; *id = the_thread->Object.id; 2005af4: c2 04 20 08 ld [ %l0 + 8 ], %g1 } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 2005af8: c6 04 21 68 ld [ %l0 + 0x168 ], %g3 2005afc: 85 36 e0 0a srl %i3, 0xa, %g2 2005b00: 84 18 a0 01 xor %g2, 1, %g2 2005b04: 84 08 a0 01 and %g2, 1, %g2 *id = the_thread->Object.id; 2005b08: c2 27 40 00 st %g1, [ %i5 ] } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 2005b0c: c4 28 e0 08 stb %g2, [ %g3 + 8 ] ); } #endif _RTEMS_Unlock_allocator(); 2005b10: 40 00 02 1f call 200638c <_API_Mutex_Unlock> 2005b14: b0 10 20 00 clr %i0 2005b18: 81 c7 e0 08 ret 2005b1c: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free ( Thread_Control *the_task ) { _Objects_Free( 2005b20: 40 00 05 71 call 20070e4 <_Objects_Get_information_id> 2005b24: d0 04 20 08 ld [ %l0 + 8 ], %o0 2005b28: 40 00 05 4a call 2007050 <_Objects_Free> 2005b2c: 92 10 00 10 mov %l0, %o1 #if defined(RTEMS_MULTIPROCESSING) if ( is_global ) _Objects_MP_Free_global_object( the_global_object ); #endif _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 2005b30: d0 06 23 cc ld [ %i0 + 0x3cc ], %o0 2005b34: 40 00 02 16 call 200638c <_API_Mutex_Unlock> 2005b38: b0 10 20 0d mov 0xd, %i0 2005b3c: 81 c7 e0 08 ret 2005b40: 81 e8 00 00 restore */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { _RTEMS_Unlock_allocator(); 2005b44: d0 06 23 cc ld [ %i0 + 0x3cc ], %o0 2005b48: 40 00 02 11 call 200638c <_API_Mutex_Unlock> 2005b4c: b0 10 20 05 mov 5, %i0 2005b50: 81 c7 e0 08 ret 2005b54: 81 e8 00 00 restore =============================================================================== 020076f8 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 20076f8: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 20076fc: 03 00 80 78 sethi %hi(0x201e000), %g1 2007700: c4 00 61 ac ld [ %g1 + 0x1ac ], %g2 ! 201e1ac <_Configuration_Table> rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 2007704: 90 10 00 18 mov %i0, %o0 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 2007708: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 200770c: c4 08 60 04 ldub [ %g1 + 4 ], %g2 2007710: 80 a0 a0 00 cmp %g2, 0 2007714: 02 80 00 20 be 2007794 <== NEVER TAKEN 2007718: b0 10 20 16 mov 0x16, %i0 return RTEMS_NOT_CONFIGURED; if ( !note ) 200771c: 80 a6 a0 00 cmp %i2, 0 2007720: 02 80 00 1d be 2007794 <== NEVER TAKEN 2007724: b0 10 20 09 mov 9, %i0 /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 2007728: 80 a6 60 0f cmp %i1, 0xf 200772c: 18 80 00 1a bgu 2007794 2007730: b0 10 20 0a mov 0xa, %i0 2007734: 03 00 80 78 sethi %hi(0x201e000), %g1 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 2007738: 80 a2 20 00 cmp %o0, 0 200773c: 02 80 00 18 be 200779c 2007740: 86 10 61 d4 or %g1, 0x1d4, %g3 2007744: 03 00 80 78 sethi %hi(0x201e000), %g1 2007748: c4 00 61 d4 ld [ %g1 + 0x1d4 ], %g2 ! 201e1d4 <_Thread_Executing> 200774c: 86 10 61 d4 or %g1, 0x1d4, %g3 2007750: c2 00 a0 08 ld [ %g2 + 8 ], %g1 2007754: 80 a2 00 01 cmp %o0, %g1 2007758: 22 80 00 12 be,a 20077a0 200775c: c4 00 c0 00 ld [ %g3 ], %g2 api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 2007760: 40 00 08 f6 call 2009b38 <_Thread_Get> 2007764: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 2007768: c2 07 bf f4 ld [ %fp + -12 ], %g1 200776c: 80 a0 60 00 cmp %g1, 0 2007770: 12 80 00 09 bne 2007794 2007774: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 2007778: c2 02 21 68 ld [ %o0 + 0x168 ], %g1 200777c: 84 06 60 08 add %i1, 8, %g2 2007780: 85 28 a0 02 sll %g2, 2, %g2 2007784: c6 00 40 02 ld [ %g1 + %g2 ], %g3 _Thread_Enable_dispatch(); 2007788: b0 10 20 00 clr %i0 200778c: 40 00 08 dd call 2009b00 <_Thread_Enable_dispatch> 2007790: c6 26 80 00 st %g3, [ %i2 ] case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2007794: 81 c7 e0 08 ret 2007798: 81 e8 00 00 restore */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 200779c: c4 00 c0 00 ld [ %g3 ], %g2 20077a0: 82 06 60 08 add %i1, 8, %g1 20077a4: c6 00 a1 68 ld [ %g2 + 0x168 ], %g3 20077a8: 83 28 60 02 sll %g1, 2, %g1 20077ac: c4 00 c0 01 ld [ %g3 + %g1 ], %g2 20077b0: c4 26 80 00 st %g2, [ %i2 ] 20077b4: 81 c7 e0 08 ret 20077b8: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 02005bd4 : rtems_status_code rtems_task_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 2005bd4: 9d e3 bf 98 save %sp, -104, %sp 2005bd8: 92 10 00 18 mov %i0, %o1 2005bdc: 96 10 00 1a mov %i2, %o3 2005be0: 94 10 00 19 mov %i1, %o2 Objects_Name_or_id_lookup_errors status; if ( !id ) 2005be4: 80 a6 a0 00 cmp %i2, 0 2005be8: 02 80 00 11 be 2005c2c <== NEVER TAKEN 2005bec: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( name == OBJECTS_ID_OF_SELF ) { 2005bf0: 80 a2 60 00 cmp %o1, 0 2005bf4: 12 80 00 07 bne 2005c10 2005bf8: 03 00 80 60 sethi %hi(0x2018000), %g1 *id = _Thread_Executing->Object.id; 2005bfc: c4 00 63 d4 ld [ %g1 + 0x3d4 ], %g2 ! 20183d4 <_Thread_Executing> 2005c00: c2 00 a0 08 ld [ %g2 + 8 ], %g1 2005c04: c2 26 80 00 st %g1, [ %i2 ] 2005c08: 81 c7 e0 08 ret 2005c0c: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); 2005c10: 11 00 80 60 sethi %hi(0x2018000), %o0 2005c14: 40 00 05 dc call 2007384 <_Objects_Name_to_id_u32> 2005c18: 90 12 22 14 or %o0, 0x214, %o0 ! 2018214 <_RTEMS_tasks_Information> return _Status_Object_name_errors_to_status[ status ]; 2005c1c: 03 00 80 59 sethi %hi(0x2016400), %g1 2005c20: 91 2a 20 02 sll %o0, 2, %o0 2005c24: 82 10 63 34 or %g1, 0x334, %g1 2005c28: f0 00 40 08 ld [ %g1 + %o0 ], %i0 } 2005c2c: 81 c7 e0 08 ret 2005c30: 81 e8 00 00 restore =============================================================================== 02006258 : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 2006258: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 200625c: 90 10 00 18 mov %i0, %o0 2006260: 40 00 07 fa call 2008248 <_Thread_Get> 2006264: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 2006268: c2 07 bf f4 ld [ %fp + -12 ], %g1 200626c: 80 a0 60 00 cmp %g1, 0 2006270: 12 80 00 08 bne 2006290 <== NEVER TAKEN 2006274: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 2006278: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 200627c: 80 88 60 02 btst 2, %g1 2006280: 02 80 00 06 be 2006298 2006284: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2006288: 40 00 07 e2 call 2008210 <_Thread_Enable_dispatch> 200628c: b0 10 20 0f mov 0xf, %i0 ! f case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2006290: 81 c7 e0 08 ret 2006294: 81 e8 00 00 restore the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Enable_dispatch(); 2006298: 40 00 07 de call 2008210 <_Thread_Enable_dispatch> 200629c: b0 10 20 00 clr %i0 20062a0: 81 c7 e0 08 ret 20062a4: 81 e8 00 00 restore =============================================================================== 0200d4ac : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 200d4ac: 9d e3 bf 98 save %sp, -104, %sp 200d4b0: a8 10 00 18 mov %i0, %l4 ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 200d4b4: 80 a6 a0 00 cmp %i2, 0 200d4b8: 02 80 00 44 be 200d5c8 <== NEVER TAKEN 200d4bc: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 200d4c0: 03 00 80 60 sethi %hi(0x2018000), %g1 200d4c4: e4 00 63 d4 ld [ %g1 + 0x3d4 ], %l2 ! 20183d4 <_Thread_Executing> api = executing->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 200d4c8: c4 0c a0 76 ldub [ %l2 + 0x76 ], %g2 if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 200d4cc: c6 04 a0 7c ld [ %l2 + 0x7c ], %g3 executing = _Thread_Executing; api = executing->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 200d4d0: 80 a0 00 02 cmp %g0, %g2 if ( !previous_mode_set ) return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; api = executing->API_Extensions[ THREAD_API_RTEMS ]; 200d4d4: e6 04 a1 68 ld [ %l2 + 0x168 ], %l3 asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 200d4d8: 82 60 3f ff subx %g0, -1, %g1 if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 200d4dc: 80 a0 e0 00 cmp %g3, 0 200d4e0: 12 80 00 3c bne 200d5d0 200d4e4: a3 28 60 08 sll %g1, 8, %l1 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 200d4e8: c2 0c e0 08 ldub [ %l3 + 8 ], %g1 200d4ec: 80 a0 00 01 cmp %g0, %g1 old_mode |= _ISR_Get_level(); 200d4f0: 7f ff f0 c7 call 200980c <_CPU_ISR_Get_level> 200d4f4: a0 60 3f ff subx %g0, -1, %l0 if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 200d4f8: a1 2c 20 0a sll %l0, 0xa, %l0 200d4fc: a0 14 00 08 or %l0, %o0, %l0 old_mode |= _ISR_Get_level(); *previous_mode_set = old_mode; 200d500: a0 14 00 11 or %l0, %l1, %l0 /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 200d504: 80 8e 61 00 btst 0x100, %i1 200d508: 02 80 00 06 be 200d520 200d50c: e0 26 80 00 st %l0, [ %i2 ] executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; 200d510: 83 35 20 08 srl %l4, 8, %g1 200d514: 82 18 60 01 xor %g1, 1, %g1 200d518: 82 08 60 01 and %g1, 1, %g1 200d51c: c2 2c a0 76 stb %g1, [ %l2 + 0x76 ] if ( mask & RTEMS_TIMESLICE_MASK ) { 200d520: 80 8e 62 00 btst 0x200, %i1 200d524: 02 80 00 0b be 200d550 200d528: 80 8e 60 0f btst 0xf, %i1 if ( _Modes_Is_timeslice(mode_set) ) { 200d52c: 80 8d 22 00 btst 0x200, %l4 200d530: 22 80 00 07 be,a 200d54c 200d534: c0 24 a0 7c clr [ %l2 + 0x7c ] executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 200d538: 03 00 80 60 sethi %hi(0x2018000), %g1 200d53c: c4 00 62 68 ld [ %g1 + 0x268 ], %g2 ! 2018268 <_Thread_Ticks_per_timeslice> if ( mask & RTEMS_PREEMPT_MASK ) executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; if ( mask & RTEMS_TIMESLICE_MASK ) { if ( _Modes_Is_timeslice(mode_set) ) { executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 200d540: 82 10 20 01 mov 1, %g1 executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 200d544: c4 24 a0 78 st %g2, [ %l2 + 0x78 ] if ( mask & RTEMS_PREEMPT_MASK ) executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; if ( mask & RTEMS_TIMESLICE_MASK ) { if ( _Modes_Is_timeslice(mode_set) ) { executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 200d548: c2 24 a0 7c st %g1, [ %l2 + 0x7c ] /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 200d54c: 80 8e 60 0f btst 0xf, %i1 200d550: 12 80 00 2d bne 200d604 200d554: 01 00 00 00 nop */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 200d558: 80 8e 64 00 btst 0x400, %i1 200d55c: 02 80 00 16 be 200d5b4 200d560: a0 10 20 00 clr %l0 is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; if ( is_asr_enabled != asr->is_enabled ) { 200d564: c4 0c e0 08 ldub [ %l3 + 8 ], %g2 */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 200d568: 83 35 20 0a srl %l4, 0xa, %g1 200d56c: 82 18 60 01 xor %g1, 1, %g1 200d570: 82 08 60 01 and %g1, 1, %g1 is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; if ( is_asr_enabled != asr->is_enabled ) { 200d574: 80 a0 80 01 cmp %g2, %g1 200d578: 22 80 00 10 be,a 200d5b8 200d57c: 03 00 80 61 sethi %hi(0x2018400), %g1 ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 200d580: 7f ff d2 19 call 2001de4 200d584: c2 2c e0 08 stb %g1, [ %l3 + 8 ] _signals = information->signals_pending; 200d588: c2 04 e0 18 ld [ %l3 + 0x18 ], %g1 information->signals_pending = information->signals_posted; 200d58c: c4 04 e0 14 ld [ %l3 + 0x14 ], %g2 information->signals_posted = _signals; 200d590: c2 24 e0 14 st %g1, [ %l3 + 0x14 ] rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); _signals = information->signals_pending; information->signals_pending = information->signals_posted; 200d594: c4 24 e0 18 st %g2, [ %l3 + 0x18 ] information->signals_posted = _signals; _ISR_Enable( _level ); 200d598: 7f ff d2 17 call 2001df4 200d59c: 01 00 00 00 nop asr->is_enabled = is_asr_enabled; _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 200d5a0: c2 04 e0 14 ld [ %l3 + 0x14 ], %g1 200d5a4: 80 a0 60 00 cmp %g1, 0 200d5a8: 12 80 00 27 bne 200d644 200d5ac: 82 10 20 01 mov 1, %g1 needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 200d5b0: a0 10 20 00 clr %l0 } } } if ( _System_state_Is_up(_System_state_Current) ) 200d5b4: 03 00 80 61 sethi %hi(0x2018400), %g1 200d5b8: c4 00 60 b4 ld [ %g1 + 0xb4 ], %g2 ! 20184b4 <_System_state_Current> 200d5bc: 80 a0 a0 03 cmp %g2, 3 200d5c0: 02 80 00 16 be 200d618 <== ALWAYS TAKEN 200d5c4: b0 10 20 00 clr %i0 if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 200d5c8: 81 c7 e0 08 ret 200d5cc: 81 e8 00 00 restore if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 200d5d0: c2 0c e0 08 ldub [ %l3 + 8 ], %g1 old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 200d5d4: a2 14 62 00 or %l1, 0x200, %l1 old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 200d5d8: 80 a0 00 01 cmp %g0, %g1 old_mode |= _ISR_Get_level(); 200d5dc: 7f ff f0 8c call 200980c <_CPU_ISR_Get_level> 200d5e0: a0 60 3f ff subx %g0, -1, %l0 if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 200d5e4: a1 2c 20 0a sll %l0, 0xa, %l0 200d5e8: a0 14 00 08 or %l0, %o0, %l0 old_mode |= _ISR_Get_level(); *previous_mode_set = old_mode; 200d5ec: a0 14 00 11 or %l0, %l1, %l0 /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 200d5f0: 80 8e 61 00 btst 0x100, %i1 200d5f4: 02 bf ff cb be 200d520 200d5f8: e0 26 80 00 st %l0, [ %i2 ] executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; 200d5fc: 10 bf ff c6 b 200d514 200d600: 83 35 20 08 srl %l4, 8, %g1 */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 200d604: 90 0d 20 0f and %l4, 0xf, %o0 200d608: 7f ff d1 fb call 2001df4 200d60c: 91 2a 20 08 sll %o0, 8, %o0 */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 200d610: 10 bf ff d3 b 200d55c 200d614: 80 8e 64 00 btst 0x400, %i1 } } } if ( _System_state_Is_up(_System_state_Current) ) if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) 200d618: 40 00 00 7c call 200d808 <_Thread_Evaluate_mode> 200d61c: 01 00 00 00 nop 200d620: 80 8a 20 ff btst 0xff, %o0 200d624: 12 80 00 04 bne 200d634 200d628: 80 8c 20 ff btst 0xff, %l0 200d62c: 22 bf ff e7 be,a 200d5c8 200d630: b0 10 20 00 clr %i0 _Thread_Dispatch(); 200d634: 7f ff e9 10 call 2007a74 <_Thread_Dispatch> 200d638: b0 10 20 00 clr %i0 200d63c: 81 c7 e0 08 ret 200d640: 81 e8 00 00 restore if ( is_asr_enabled != asr->is_enabled ) { asr->is_enabled = is_asr_enabled; _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 200d644: a0 10 20 01 mov 1, %l0 200d648: 10 bf ff db b 200d5b4 200d64c: c2 2c a0 75 stb %g1, [ %l2 + 0x75 ] =============================================================================== 020078c4 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 20078c4: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 20078c8: 03 00 80 78 sethi %hi(0x201e000), %g1 20078cc: c4 00 61 ac ld [ %g1 + 0x1ac ], %g2 ! 201e1ac <_Configuration_Table> rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 20078d0: 90 10 00 18 mov %i0, %o0 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 20078d4: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 20078d8: c4 08 60 04 ldub [ %g1 + 4 ], %g2 20078dc: 80 a0 a0 00 cmp %g2, 0 20078e0: 02 80 00 1c be 2007950 <== NEVER TAKEN 20078e4: b0 10 20 16 mov 0x16, %i0 /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 20078e8: 80 a6 60 0f cmp %i1, 0xf 20078ec: 18 80 00 19 bgu 2007950 20078f0: b0 10 20 0a mov 0xa, %i0 20078f4: 03 00 80 78 sethi %hi(0x201e000), %g1 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 20078f8: 80 a2 20 00 cmp %o0, 0 20078fc: 02 80 00 17 be 2007958 2007900: 86 10 61 d4 or %g1, 0x1d4, %g3 2007904: 03 00 80 78 sethi %hi(0x201e000), %g1 2007908: c4 00 61 d4 ld [ %g1 + 0x1d4 ], %g2 ! 201e1d4 <_Thread_Executing> 200790c: 86 10 61 d4 or %g1, 0x1d4, %g3 2007910: c2 00 a0 08 ld [ %g2 + 8 ], %g1 2007914: 80 a2 00 01 cmp %o0, %g1 2007918: 22 80 00 11 be,a 200795c <== NEVER TAKEN 200791c: c2 00 c0 00 ld [ %g3 ], %g1 <== NOT EXECUTED api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 2007920: 40 00 08 86 call 2009b38 <_Thread_Get> 2007924: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 2007928: c2 07 bf f4 ld [ %fp + -12 ], %g1 200792c: 80 a0 60 00 cmp %g1, 0 2007930: 12 80 00 08 bne 2007950 2007934: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 2007938: c4 02 21 68 ld [ %o0 + 0x168 ], %g2 200793c: 82 06 60 08 add %i1, 8, %g1 2007940: 83 28 60 02 sll %g1, 2, %g1 _Thread_Enable_dispatch(); 2007944: b0 10 20 00 clr %i0 2007948: 40 00 08 6e call 2009b00 <_Thread_Enable_dispatch> 200794c: f4 20 80 01 st %i2, [ %g2 + %g1 ] case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2007950: 81 c7 e0 08 ret 2007954: 81 e8 00 00 restore */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 2007958: c2 00 c0 00 ld [ %g3 ], %g1 200795c: 84 06 60 08 add %i1, 8, %g2 2007960: c6 00 61 68 ld [ %g1 + 0x168 ], %g3 2007964: 85 28 a0 02 sll %g2, 2, %g2 2007968: f4 20 c0 02 st %i2, [ %g3 + %g2 ] 200796c: 81 c7 e0 08 ret 2007970: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 02006e40 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 2006e40: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 2006e44: 80 a6 60 00 cmp %i1, 0 2006e48: 02 80 00 07 be 2006e64 2006e4c: 90 10 00 18 mov %i0, %o0 */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 2006e50: 03 00 80 6e sethi %hi(0x201b800), %g1 2006e54: c4 08 62 94 ldub [ %g1 + 0x294 ], %g2 ! 201ba94 2006e58: 80 a6 40 02 cmp %i1, %g2 2006e5c: 18 80 00 1c bgu 2006ecc 2006e60: b0 10 20 13 mov 0x13, %i0 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 2006e64: 80 a6 a0 00 cmp %i2, 0 2006e68: 02 80 00 19 be 2006ecc <== NEVER TAKEN 2006e6c: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 2006e70: 40 00 08 4f call 2008fac <_Thread_Get> 2006e74: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 2006e78: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006e7c: 80 a0 60 00 cmp %g1, 0 2006e80: 12 80 00 13 bne 2006ecc 2006e84: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 2006e88: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 2006e8c: 80 a6 60 00 cmp %i1, 0 2006e90: 02 80 00 0d be 2006ec4 2006e94: c2 26 80 00 st %g1, [ %i2 ] the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 2006e98: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006e9c: 80 a0 60 00 cmp %g1, 0 2006ea0: 02 80 00 06 be 2006eb8 2006ea4: f2 22 20 18 st %i1, [ %o0 + 0x18 ] 2006ea8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2006eac: 80 a6 40 01 cmp %i1, %g1 2006eb0: 1a 80 00 05 bcc 2006ec4 <== ALWAYS TAKEN 2006eb4: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 2006eb8: 92 10 00 19 mov %i1, %o1 2006ebc: 40 00 06 98 call 200891c <_Thread_Change_priority> 2006ec0: 94 10 20 00 clr %o2 } _Thread_Enable_dispatch(); 2006ec4: 40 00 08 2c call 2008f74 <_Thread_Enable_dispatch> 2006ec8: b0 10 20 00 clr %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2006ecc: 81 c7 e0 08 ret 2006ed0: 81 e8 00 00 restore =============================================================================== 02006e14 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 2006e14: 9d e3 bf 90 save %sp, -112, %sp 2006e18: 90 10 00 18 mov %i0, %o0 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 2006e1c: 80 a6 60 00 cmp %i1, 0 2006e20: 02 80 00 18 be 2006e80 <== NEVER TAKEN 2006e24: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 2006e28: 40 00 08 59 call 2008f8c <_Thread_Get> 2006e2c: 92 07 bf f4 add %fp, -12, %o1 switch (location) { 2006e30: c2 07 bf f4 ld [ %fp + -12 ], %g1 rtems_task_variable_t *tvp, *new; if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 2006e34: a0 10 00 08 mov %o0, %l0 switch (location) { 2006e38: 80 a0 60 00 cmp %g1, 0 2006e3c: 12 80 00 11 bne 2006e80 <== NEVER TAKEN 2006e40: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 2006e44: c4 02 21 78 ld [ %o0 + 0x178 ], %g2 while (tvp) { 2006e48: 80 a0 a0 00 cmp %g2, 0 2006e4c: 32 80 00 07 bne,a 2006e68 2006e50: c2 00 a0 04 ld [ %g2 + 4 ], %g1 2006e54: 30 80 00 0d b,a 2006e88 2006e58: 80 a0 a0 00 cmp %g2, 0 2006e5c: 02 80 00 0b be 2006e88 2006e60: 01 00 00 00 nop if (tvp->ptr == ptr) { 2006e64: c2 00 a0 04 ld [ %g2 + 4 ], %g1 2006e68: 80 a0 40 19 cmp %g1, %i1 2006e6c: 32 bf ff fb bne,a 2006e58 2006e70: c4 00 80 00 ld [ %g2 ], %g2 tvp->dtor = dtor; 2006e74: f4 20 a0 10 st %i2, [ %g2 + 0x10 ] _Thread_Enable_dispatch(); 2006e78: 40 00 08 37 call 2008f54 <_Thread_Enable_dispatch> 2006e7c: b0 10 20 00 clr %i0 2006e80: 81 c7 e0 08 ret 2006e84: 81 e8 00 00 restore } /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) 2006e88: 40 00 0d 67 call 200a424 <_Workspace_Allocate> 2006e8c: 90 10 20 14 mov 0x14, %o0 _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 2006e90: 80 a2 20 00 cmp %o0, 0 2006e94: 02 80 00 0d be 2006ec8 2006e98: 01 00 00 00 nop } new->gval = *ptr; new->ptr = ptr; new->dtor = dtor; new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 2006e9c: c4 04 21 78 ld [ %l0 + 0x178 ], %g2 _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 2006ea0: c2 06 40 00 ld [ %i1 ], %g1 new->ptr = ptr; new->dtor = dtor; new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; the_thread->task_variables = new; 2006ea4: d0 24 21 78 st %o0, [ %l0 + 0x178 ] _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 2006ea8: c2 22 20 08 st %g1, [ %o0 + 8 ] new->ptr = ptr; 2006eac: f2 22 20 04 st %i1, [ %o0 + 4 ] new->dtor = dtor; 2006eb0: f4 22 20 10 st %i2, [ %o0 + 0x10 ] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 2006eb4: c4 22 00 00 st %g2, [ %o0 ] the_thread->task_variables = new; _Thread_Enable_dispatch(); 2006eb8: 40 00 08 27 call 2008f54 <_Thread_Enable_dispatch> 2006ebc: b0 10 20 00 clr %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2006ec0: 81 c7 e0 08 ret 2006ec4: 81 e8 00 00 restore * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); 2006ec8: 40 00 08 23 call 2008f54 <_Thread_Enable_dispatch> 2006ecc: b0 10 20 1a mov 0x1a, %i0 2006ed0: 81 c7 e0 08 ret 2006ed4: 81 e8 00 00 restore =============================================================================== 02006ed8 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 2006ed8: 9d e3 bf 90 save %sp, -112, %sp 2006edc: 90 10 00 18 mov %i0, %o0 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 2006ee0: 80 a6 60 00 cmp %i1, 0 2006ee4: 02 80 00 1c be 2006f54 2006ee8: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 2006eec: 40 00 08 28 call 2008f8c <_Thread_Get> 2006ef0: 92 07 bf f4 add %fp, -12, %o1 switch (location) { 2006ef4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006ef8: 80 a0 60 00 cmp %g1, 0 2006efc: 12 80 00 16 bne 2006f54 <== NEVER TAKEN 2006f00: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: tvp = the_thread->task_variables; 2006f04: d2 02 21 78 ld [ %o0 + 0x178 ], %o1 while (tvp) { 2006f08: 80 a2 60 00 cmp %o1, 0 2006f0c: 02 80 00 10 be 2006f4c 2006f10: 01 00 00 00 nop if (tvp->ptr == ptr) { 2006f14: c2 02 60 04 ld [ %o1 + 4 ], %g1 2006f18: 80 a0 40 19 cmp %g1, %i1 2006f1c: 12 80 00 08 bne 2006f3c 2006f20: 84 10 00 09 mov %o1, %g2 if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 2006f24: 10 80 00 15 b 2006f78 2006f28: c2 02 40 00 ld [ %o1 ], %g1 switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 2006f2c: 80 a0 40 19 cmp %g1, %i1 2006f30: 22 80 00 0b be,a 2006f5c 2006f34: c2 02 40 00 ld [ %o1 ], %g1 else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 2006f38: 84 10 00 09 mov %o1, %g2 } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 2006f3c: d2 02 40 00 ld [ %o1 ], %o1 the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 2006f40: 80 a2 60 00 cmp %o1, 0 2006f44: 32 bf ff fa bne,a 2006f2c <== ALWAYS TAKEN 2006f48: c2 02 60 04 ld [ %o1 + 4 ], %g1 return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 2006f4c: 40 00 08 02 call 2008f54 <_Thread_Enable_dispatch> 2006f50: b0 10 20 09 mov 9, %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2006f54: 81 c7 e0 08 ret 2006f58: 81 e8 00 00 restore case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 2006f5c: c2 20 80 00 st %g1, [ %g2 ] else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 2006f60: 40 00 00 2d call 2007014 <_RTEMS_Tasks_Invoke_task_variable_dtor> 2006f64: b0 10 20 00 clr %i0 _Thread_Enable_dispatch(); 2006f68: 40 00 07 fb call 2008f54 <_Thread_Enable_dispatch> 2006f6c: 01 00 00 00 nop 2006f70: 81 c7 e0 08 ret 2006f74: 81 e8 00 00 restore while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 2006f78: 10 bf ff fa b 2006f60 2006f7c: c2 22 21 78 st %g1, [ %o0 + 0x178 ] =============================================================================== 02006f80 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 2006f80: 9d e3 bf 90 save %sp, -112, %sp Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 2006f84: 80 a6 60 00 cmp %i1, 0 2006f88: 02 80 00 1d be 2006ffc 2006f8c: 90 10 00 18 mov %i0, %o0 return RTEMS_INVALID_ADDRESS; if ( !result ) 2006f90: 80 a6 a0 00 cmp %i2, 0 2006f94: 02 80 00 18 be 2006ff4 2006f98: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 2006f9c: 40 00 07 fc call 2008f8c <_Thread_Get> 2006fa0: 92 07 bf f4 add %fp, -12, %o1 switch (location) { 2006fa4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006fa8: 80 a0 60 00 cmp %g1, 0 2006fac: 12 80 00 12 bne 2006ff4 <== NEVER TAKEN 2006fb0: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 2006fb4: d0 02 21 78 ld [ %o0 + 0x178 ], %o0 while (tvp) { 2006fb8: 80 a2 20 00 cmp %o0, 0 2006fbc: 32 80 00 07 bne,a 2006fd8 2006fc0: c2 02 20 04 ld [ %o0 + 4 ], %g1 2006fc4: 30 80 00 10 b,a 2007004 2006fc8: 80 a2 20 00 cmp %o0, 0 2006fcc: 02 80 00 0e be 2007004 <== NEVER TAKEN 2006fd0: 01 00 00 00 nop if (tvp->ptr == ptr) { 2006fd4: c2 02 20 04 ld [ %o0 + 4 ], %g1 2006fd8: 80 a0 40 19 cmp %g1, %i1 2006fdc: 32 bf ff fb bne,a 2006fc8 2006fe0: d0 02 00 00 ld [ %o0 ], %o0 /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 2006fe4: c2 02 20 0c ld [ %o0 + 0xc ], %g1 _Thread_Enable_dispatch(); 2006fe8: b0 10 20 00 clr %i0 2006fec: 40 00 07 da call 2008f54 <_Thread_Enable_dispatch> 2006ff0: c2 26 80 00 st %g1, [ %i2 ] 2006ff4: 81 c7 e0 08 ret 2006ff8: 81 e8 00 00 restore case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2006ffc: 81 c7 e0 08 ret 2007000: 91 e8 20 09 restore %g0, 9, %o0 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 2007004: 40 00 07 d4 call 2008f54 <_Thread_Enable_dispatch> 2007008: b0 10 20 09 mov 9, %i0 200700c: 81 c7 e0 08 ret 2007010: 81 e8 00 00 restore =============================================================================== 02007358 : */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 2007358: 9d e3 bf 98 save %sp, -104, %sp Watchdog_Interval seconds; if ( !_TOD_Is_set ) 200735c: 03 00 80 70 sethi %hi(0x201c000), %g1 2007360: c4 08 62 a4 ldub [ %g1 + 0x2a4 ], %g2 ! 201c2a4 <_TOD_Is_set> */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 2007364: a0 10 00 18 mov %i0, %l0 Watchdog_Interval seconds; if ( !_TOD_Is_set ) 2007368: 80 a0 a0 00 cmp %g2, 0 200736c: 02 80 00 2e be 2007424 2007370: b0 10 20 0b mov 0xb, %i0 return RTEMS_NOT_DEFINED; if ( !time_buffer ) 2007374: 80 a4 20 00 cmp %l0, 0 2007378: 02 80 00 2b be 2007424 <== NEVER TAKEN 200737c: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 2007380: c0 24 20 18 clr [ %l0 + 0x18 ] if ( !_TOD_Validate( time_buffer ) ) 2007384: 7f ff fc bd call 2006678 <_TOD_Validate> 2007388: 90 10 00 10 mov %l0, %o0 200738c: 80 8a 20 ff btst 0xff, %o0 2007390: 12 80 00 04 bne 20073a0 2007394: 01 00 00 00 nop &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 2007398: 81 c7 e0 08 ret 200739c: 91 e8 20 14 restore %g0, 0x14, %o0 time_buffer->ticks = 0; if ( !_TOD_Validate( time_buffer ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 20073a0: 7f ff fc 81 call 20065a4 <_TOD_To_seconds> 20073a4: 90 10 00 10 mov %l0, %o0 if ( seconds <= _TOD_Seconds_since_epoch ) 20073a8: 23 00 80 70 sethi %hi(0x201c000), %l1 20073ac: c2 04 63 24 ld [ %l1 + 0x324 ], %g1 ! 201c324 <_TOD_Now> 20073b0: 80 a2 00 01 cmp %o0, %g1 20073b4: 08 bf ff f9 bleu 2007398 20073b8: b0 10 00 08 mov %o0, %i0 20073bc: 05 00 80 70 sethi %hi(0x201c000), %g2 20073c0: c2 00 a2 90 ld [ %g2 + 0x290 ], %g1 ! 201c290 <_Thread_Dispatch_disable_level> 20073c4: 82 00 60 01 inc %g1 20073c8: c2 20 a2 90 st %g1, [ %g2 + 0x290 ] return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 20073cc: 21 00 80 70 sethi %hi(0x201c000), %l0 20073d0: d0 04 23 54 ld [ %l0 + 0x354 ], %o0 ! 201c354 <_Thread_Executing> 20073d4: 40 00 0a 4c call 2009d04 <_Thread_Set_state> 20073d8: 92 10 20 10 mov 0x10, %o1 _Watchdog_Initialize( 20073dc: c4 04 23 54 ld [ %l0 + 0x354 ], %g2 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 20073e0: 11 00 80 70 sethi %hi(0x201c000), %o0 20073e4: c6 00 a0 08 ld [ %g2 + 8 ], %g3 20073e8: 90 12 23 68 or %o0, 0x368, %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 20073ec: c6 20 a0 68 st %g3, [ %g2 + 0x68 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20073f0: c2 04 63 24 ld [ %l1 + 0x324 ], %g1 _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 20073f4: 92 00 a0 48 add %g2, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20073f8: 82 26 00 01 sub %i0, %g1, %g1 20073fc: c2 20 a0 54 st %g1, [ %g2 + 0x54 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2007400: 03 00 80 24 sethi %hi(0x2009000), %g1 2007404: 82 10 60 b0 or %g1, 0xb0, %g1 ! 20090b0 <_Thread_Delay_ended> Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2007408: c0 20 a0 50 clr [ %g2 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 200740c: c0 20 a0 6c clr [ %g2 + 0x6c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2007410: c2 20 a0 64 st %g1, [ %g2 + 0x64 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2007414: 40 00 0c 84 call 200a624 <_Watchdog_Insert> 2007418: b0 10 20 00 clr %i0 ); _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 200741c: 40 00 07 9c call 200928c <_Thread_Enable_dispatch> 2007420: 01 00 00 00 nop 2007424: 81 c7 e0 08 ret 2007428: 81 e8 00 00 restore =============================================================================== 020113e4 : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 20113e4: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 20113e8: 11 00 80 ca sethi %hi(0x2032800), %o0 20113ec: 92 10 00 18 mov %i0, %o1 20113f0: 90 12 23 fc or %o0, 0x3fc, %o0 20113f4: 40 00 0b c1 call 20142f8 <_Objects_Get> 20113f8: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20113fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 2011400: 80 a0 60 00 cmp %g1, 0 2011404: 12 80 00 0a bne 201142c 2011408: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 201140c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 2011410: 80 a0 60 04 cmp %g1, 4 2011414: 02 80 00 04 be 2011424 <== NEVER TAKEN 2011418: 01 00 00 00 nop (void) _Watchdog_Remove( &the_timer->Ticker ); 201141c: 40 00 14 c4 call 201672c <_Watchdog_Remove> 2011420: 90 02 20 10 add %o0, 0x10, %o0 _Thread_Enable_dispatch(); 2011424: 40 00 0e 38 call 2014d04 <_Thread_Enable_dispatch> 2011428: b0 10 20 00 clr %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 201142c: 81 c7 e0 08 ret 2011430: 81 e8 00 00 restore =============================================================================== 020069b4 : rtems_status_code rtems_timer_create( rtems_name name, Objects_Id *id ) { 20069b4: 9d e3 bf 98 save %sp, -104, %sp Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 20069b8: a2 96 20 00 orcc %i0, 0, %l1 20069bc: 02 80 00 20 be 2006a3c 20069c0: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 20069c4: 80 a6 60 00 cmp %i1, 0 20069c8: 02 80 00 1d be 2006a3c <== NEVER TAKEN 20069cc: b0 10 20 09 mov 9, %i0 20069d0: 05 00 80 5c sethi %hi(0x2017000), %g2 20069d4: c2 00 a0 f0 ld [ %g2 + 0xf0 ], %g1 ! 20170f0 <_Thread_Dispatch_disable_level> 20069d8: 82 00 60 01 inc %g1 20069dc: c2 20 a0 f0 st %g1, [ %g2 + 0xf0 ] * This function allocates a timer control block from * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void ) { return (Timer_Control *) _Objects_Allocate( &_Timer_Information ); 20069e0: 21 00 80 5d sethi %hi(0x2017400), %l0 20069e4: 40 00 04 33 call 2007ab0 <_Objects_Allocate> 20069e8: 90 14 22 c4 or %l0, 0x2c4, %o0 ! 20176c4 <_Timer_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 20069ec: 80 a2 20 00 cmp %o0, 0 20069f0: 02 80 00 15 be 2006a44 20069f4: 82 14 22 c4 or %l0, 0x2c4, %g1 20069f8: c6 02 20 08 ld [ %o0 + 8 ], %g3 information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 20069fc: e2 22 20 0c st %l1, [ %o0 + 0xc ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 2006a00: c8 00 60 1c ld [ %g1 + 0x1c ], %g4 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 2006a04: c0 22 20 30 clr [ %o0 + 0x30 ] &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 2006a08: c6 26 40 00 st %g3, [ %i1 ] if ( !the_timer ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 2006a0c: 84 10 20 04 mov 4, %g2 2006a10: 03 00 00 3f sethi %hi(0xfc00), %g1 2006a14: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2006a18: 86 08 c0 01 and %g3, %g1, %g3 2006a1c: 87 28 e0 02 sll %g3, 2, %g3 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2006a20: c0 22 20 18 clr [ %o0 + 0x18 ] the_watchdog->routine = routine; 2006a24: c0 22 20 2c clr [ %o0 + 0x2c ] the_watchdog->id = id; the_watchdog->user_data = user_data; 2006a28: c0 22 20 34 clr [ %o0 + 0x34 ] 2006a2c: c4 22 20 38 st %g2, [ %o0 + 0x38 ] 2006a30: d0 21 00 03 st %o0, [ %g4 + %g3 ] &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); 2006a34: 40 00 07 dc call 20089a4 <_Thread_Enable_dispatch> 2006a38: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 2006a3c: 81 c7 e0 08 ret 2006a40: 81 e8 00 00 restore _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { _Thread_Enable_dispatch(); 2006a44: 40 00 07 d8 call 20089a4 <_Thread_Enable_dispatch> 2006a48: b0 10 20 05 mov 5, %i0 2006a4c: 81 c7 e0 08 ret 2006a50: 81 e8 00 00 restore =============================================================================== 02006a54 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 2006a54: 9d e3 bf 90 save %sp, -112, %sp 2006a58: a4 10 00 18 mov %i0, %l2 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 2006a5c: 80 a6 60 00 cmp %i1, 0 2006a60: 02 80 00 26 be 2006af8 2006a64: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( !routine ) 2006a68: 80 a6 a0 00 cmp %i2, 0 2006a6c: 02 80 00 23 be 2006af8 <== NEVER TAKEN 2006a70: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2006a74: 11 00 80 5d sethi %hi(0x2017400), %o0 2006a78: 92 10 00 12 mov %l2, %o1 2006a7c: 90 12 22 c4 or %o0, 0x2c4, %o0 2006a80: 40 00 05 74 call 2008050 <_Objects_Get> 2006a84: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2006a88: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006a8c: a0 10 00 08 mov %o0, %l0 2006a90: 80 a0 60 00 cmp %g1, 0 2006a94: 12 80 00 19 bne 2006af8 2006a98: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 2006a9c: a2 02 20 10 add %o0, 0x10, %l1 2006aa0: 40 00 0d 12 call 2009ee8 <_Watchdog_Remove> 2006aa4: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 2006aa8: 7f ff ee 89 call 20024cc 2006aac: 01 00 00 00 nop /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 2006ab0: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 2006ab4: 80 a0 60 00 cmp %g1, 0 2006ab8: 12 80 00 12 bne 2006b00 <== NEVER TAKEN 2006abc: 01 00 00 00 nop Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2006ac0: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 2006ac4: e4 24 20 30 st %l2, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 2006ac8: f6 24 20 34 st %i3, [ %l0 + 0x34 ] /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL; 2006acc: c0 24 20 38 clr [ %l0 + 0x38 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2006ad0: c0 24 20 18 clr [ %l0 + 0x18 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 2006ad4: 7f ff ee 82 call 20024dc 2006ad8: b0 10 20 00 clr %i0 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006adc: 92 10 00 11 mov %l1, %o1 2006ae0: 11 00 80 5c sethi %hi(0x2017000), %o0 2006ae4: 90 12 21 d4 or %o0, 0x1d4, %o0 ! 20171d4 <_Watchdog_Ticks_chain> 2006ae8: 40 00 0c 95 call 2009d3c <_Watchdog_Insert> 2006aec: f2 24 20 1c st %i1, [ %l0 + 0x1c ] _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 2006af0: 40 00 07 ad call 20089a4 <_Thread_Enable_dispatch> 2006af4: 01 00 00 00 nop case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2006af8: 81 c7 e0 08 ret 2006afc: 81 e8 00 00 restore * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 2006b00: 7f ff ee 77 call 20024dc <== NOT EXECUTED 2006b04: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 2006b08: 40 00 07 a7 call 20089a4 <_Thread_Enable_dispatch> <== NOT EXECUTED 2006b0c: 01 00 00 00 nop <== NOT EXECUTED 2006b10: 81 c7 e0 08 ret <== NOT EXECUTED 2006b14: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 020115f8 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 20115f8: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 20115fc: 03 00 80 c8 sethi %hi(0x2032000), %g1 2011600: c4 08 62 a4 ldub [ %g1 + 0x2a4 ], %g2 ! 20322a4 <_TOD_Is_set> Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 2011604: a4 10 00 18 mov %i0, %l2 Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 2011608: 80 a0 a0 00 cmp %g2, 0 201160c: 02 80 00 2f be 20116c8 2011610: b0 10 20 0b mov 0xb, %i0 return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 2011614: 7f ff f5 10 call 200ea54 <_TOD_Validate> 2011618: 90 10 00 19 mov %i1, %o0 201161c: 80 8a 20 ff btst 0xff, %o0 2011620: 02 80 00 0b be 201164c 2011624: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_CLOCK; if ( !routine ) 2011628: 02 80 00 28 be 20116c8 <== NEVER TAKEN 201162c: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 2011630: 7f ff f4 d4 call 200e980 <_TOD_To_seconds> 2011634: 90 10 00 19 mov %i1, %o0 if ( seconds <= _TOD_Seconds_since_epoch ) 2011638: 27 00 80 c8 sethi %hi(0x2032000), %l3 201163c: c2 04 e3 24 ld [ %l3 + 0x324 ], %g1 ! 2032324 <_TOD_Now> 2011640: 80 a2 00 01 cmp %o0, %g1 2011644: 18 80 00 04 bgu 2011654 2011648: a2 10 00 08 mov %o0, %l1 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 201164c: 81 c7 e0 08 ret 2011650: 91 e8 20 14 restore %g0, 0x14, %o0 2011654: 11 00 80 ca sethi %hi(0x2032800), %o0 2011658: 92 10 00 12 mov %l2, %o1 201165c: 90 12 23 fc or %o0, 0x3fc, %o0 2011660: 40 00 0b 26 call 20142f8 <_Objects_Get> 2011664: 94 07 bf f4 add %fp, -12, %o2 seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2011668: c2 07 bf f4 ld [ %fp + -12 ], %g1 201166c: b2 10 00 08 mov %o0, %i1 2011670: 80 a0 60 00 cmp %g1, 0 2011674: 12 80 00 15 bne 20116c8 2011678: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 201167c: a0 02 20 10 add %o0, 0x10, %l0 2011680: 40 00 14 2b call 201672c <_Watchdog_Remove> 2011684: 90 10 00 10 mov %l0, %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 2011688: e4 26 60 30 st %l2, [ %i1 + 0x30 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 201168c: c2 04 e3 24 ld [ %l3 + 0x324 ], %g1 _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2011690: 92 10 00 10 mov %l0, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2011694: 82 24 40 01 sub %l1, %g1, %g1 _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2011698: 11 00 80 c8 sethi %hi(0x2032000), %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 201169c: c2 26 60 1c st %g1, [ %i1 + 0x1c ] _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 20116a0: 90 12 23 68 or %o0, 0x368, %o0 the_timer->the_class = TIMER_TIME_OF_DAY; 20116a4: 82 10 20 02 mov 2, %g1 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 20116a8: f4 26 60 2c st %i2, [ %i1 + 0x2c ] 20116ac: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_watchdog->id = id; the_watchdog->user_data = user_data; 20116b0: f6 26 60 34 st %i3, [ %i1 + 0x34 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20116b4: c0 26 60 18 clr [ %i1 + 0x18 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 20116b8: 40 00 13 b2 call 2016580 <_Watchdog_Insert> 20116bc: b0 10 20 00 clr %i0 _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 20116c0: 40 00 0d 91 call 2014d04 <_Thread_Enable_dispatch> 20116c4: 01 00 00 00 nop 20116c8: 81 c7 e0 08 ret 20116cc: 81 e8 00 00 restore =============================================================================== 020116d0 : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 20116d0: 9d e3 bf 90 save %sp, -112, %sp 20116d4: 92 10 00 18 mov %i0, %o1 Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 20116d8: 80 a6 60 00 cmp %i1, 0 20116dc: 02 80 00 14 be 201172c <== NEVER TAKEN 20116e0: b0 10 20 09 mov 9, %i0 20116e4: 11 00 80 ca sethi %hi(0x2032800), %o0 20116e8: 94 07 bf f4 add %fp, -12, %o2 20116ec: 40 00 0b 03 call 20142f8 <_Objects_Get> 20116f0: 90 12 23 fc or %o0, 0x3fc, %o0 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20116f4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20116f8: 80 a0 60 00 cmp %g1, 0 20116fc: 12 80 00 0c bne 201172c 2011700: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; the_info->initial = the_timer->Ticker.initial; 2011704: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 2011708: c6 02 20 38 ld [ %o0 + 0x38 ], %g3 the_info->initial = the_timer->Ticker.initial; 201170c: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->start_time = the_timer->Ticker.start_time; 2011710: c4 02 20 24 ld [ %o0 + 0x24 ], %g2 the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 2011714: c6 26 40 00 st %g3, [ %i1 ] the_info->initial = the_timer->Ticker.initial; the_info->start_time = the_timer->Ticker.start_time; 2011718: c4 26 60 08 st %g2, [ %i1 + 8 ] the_info->stop_time = the_timer->Ticker.stop_time; 201171c: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 _Thread_Enable_dispatch(); 2011720: b0 10 20 00 clr %i0 2011724: 40 00 0d 78 call 2014d04 <_Thread_Enable_dispatch> 2011728: c2 26 60 0c st %g1, [ %i1 + 0xc ] case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 201172c: 81 c7 e0 08 ret 2011730: 81 e8 00 00 restore =============================================================================== 020119ec : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 20119ec: 9d e3 bf 90 save %sp, -112, %sp 20119f0: 92 96 20 00 orcc %i0, 0, %o1 20119f4: 12 80 00 05 bne 2011a08 20119f8: 03 00 80 b4 sethi %hi(0x202d000), %g1 * but there is actually no way (in normal circumstances) that the * start can fail. The id and starting address are known to be * be good. If this service fails, something is weirdly wrong on the * target such as a stray write in an ISR or incorrect memory layout. */ initialized = false; 20119fc: 90 10 20 13 mov 0x13, %o0 } return status; } 2011a00: 81 c7 e0 08 ret 2011a04: 91 e8 00 08 restore %g0, %o0, %o0 2011a08: c4 08 60 c4 ldub [ %g1 + 0xc4 ], %g2 2011a0c: 80 a2 40 02 cmp %o1, %g2 2011a10: 18 80 00 56 bgu 2011b68 <== ALWAYS TAKEN 2011a14: 80 a2 7f ff cmp %o1, -1 2011a18: b0 10 00 09 mov %o1, %i0 <== NOT EXECUTED 2011a1c: 05 00 80 c8 sethi %hi(0x2032000), %g2 2011a20: c2 00 a2 90 ld [ %g2 + 0x290 ], %g1 ! 2032290 <_Thread_Dispatch_disable_level> 2011a24: 82 00 60 01 inc %g1 2011a28: c2 20 a2 90 st %g1, [ %g2 + 0x290 ] /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 2011a2c: 23 00 80 b7 sethi %hi(0x202dc00), %l1 initialized = true; 2011a30: 82 10 20 01 mov 1, %g1 /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 2011a34: e0 0c 60 0c ldub [ %l1 + 0xc ], %l0 initialized = true; _Thread_Enable_dispatch(); 2011a38: 40 00 0c b3 call 2014d04 <_Thread_Enable_dispatch> 2011a3c: c2 2c 60 0c stb %g1, [ %l1 + 0xc ] if ( tmpInitialized ) 2011a40: 80 a4 20 00 cmp %l0, 0 2011a44: 12 bf ff ef bne 2011a00 2011a48: 90 10 20 0e mov 0xe, %o0 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2011a4c: 05 00 80 c8 sethi %hi(0x2032000), %g2 2011a50: 82 10 a1 a4 or %g2, 0x1a4, %g1 ! 20321a4 <_Timer_To_be_inserted> the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2011a54: c2 20 60 08 st %g1, [ %g1 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2011a58: c0 20 60 04 clr [ %g1 + 4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2011a5c: 82 00 60 04 add %g1, 4, %g1 * other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 2011a60: 92 10 00 18 mov %i0, %o1 2011a64: 94 10 00 19 mov %i1, %o2 2011a68: 19 00 00 20 sethi %hi(0x8000), %o4 2011a6c: c2 20 a1 a4 st %g1, [ %g2 + 0x1a4 ] 2011a70: 98 16 80 0c or %i2, %o4, %o4 2011a74: 11 15 12 53 sethi %hi(0x54494c00), %o0 2011a78: 96 10 21 00 mov 0x100, %o3 2011a7c: 90 12 21 45 or %o0, 0x145, %o0 2011a80: 7f ff fc 78 call 2010c60 2011a84: 9a 07 bf f4 add %fp, -12, %o5 /* user may want floating point but we need */ /* system task specified for 0 priority */ attribute_set | RTEMS_SYSTEM_TASK, &id /* get the id back */ ); if (status) { 2011a88: 80 a2 20 00 cmp %o0, 0 2011a8c: 12 80 00 34 bne 2011b5c 2011a90: 03 00 80 c8 sethi %hi(0x2032000), %g1 * to a TCB pointer from here out. * * NOTE: Setting the pointer to the Timer Server TCB to a value other than * NULL indicates that task-based timer support is initialized. */ _Timer_Server = (Thread_Control *)_Objects_Get_local_object( 2011a94: d6 07 bf f4 ld [ %fp + -12 ], %o3 RTEMS_INLINE_ROUTINE Objects_Control *_Objects_Get_local_object( Objects_Information *information, uint16_t index ) { if ( index > information->maximum ) 2011a98: 86 10 61 44 or %g1, 0x144, %g3 2011a9c: c4 10 e0 10 lduh [ %g3 + 0x10 ], %g2 2011aa0: 03 00 00 3f sethi %hi(0xfc00), %g1 2011aa4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2011aa8: 82 0a c0 01 and %o3, %g1, %g1 2011aac: 80 a0 40 02 cmp %g1, %g2 2011ab0: 18 80 00 05 bgu 2011ac4 <== NEVER TAKEN 2011ab4: 98 10 20 00 clr %o4 2011ab8: c4 00 e0 1c ld [ %g3 + 0x1c ], %g2 2011abc: 83 28 60 02 sll %g1, 2, %g1 2011ac0: d8 00 80 01 ld [ %g2 + %g1 ], %o4 2011ac4: 09 00 80 c8 sethi %hi(0x2032000), %g4 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2011ac8: 1b 00 80 c8 sethi %hi(0x2032000), %o5 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2011acc: 84 11 21 84 or %g4, 0x184, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2011ad0: 82 13 61 98 or %o5, 0x198, %g1 2011ad4: c4 20 a0 08 st %g2, [ %g2 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2011ad8: c0 20 a0 04 clr [ %g2 + 4 ] the_chain->last = _Chain_Head(the_chain); 2011adc: c2 20 60 08 st %g1, [ %g1 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2011ae0: c0 20 60 04 clr [ %g1 + 4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2011ae4: 84 00 a0 04 add %g2, 4, %g2 2011ae8: 82 00 60 04 add %g1, 4, %g1 the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2011aec: c0 23 20 6c clr [ %o4 + 0x6c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2011af0: c0 23 20 50 clr [ %o4 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; 2011af4: d6 23 20 68 st %o3, [ %o4 + 0x68 ] 2011af8: c4 21 21 84 st %g2, [ %g4 + 0x184 ] 2011afc: c2 23 61 98 st %g1, [ %o5 + 0x198 ] 2011b00: 05 00 80 cb sethi %hi(0x2032c00), %g2 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2011b04: 07 00 80 52 sethi %hi(0x2014800), %g3 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2011b08: 03 00 80 c8 sethi %hi(0x2032000), %g1 the_watchdog->routine = routine; 2011b0c: 86 10 e3 28 or %g3, 0x328, %g3 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2011b10: 82 10 61 b0 or %g1, 0x1b0, %g1 the_watchdog->routine = routine; 2011b14: c6 23 20 64 st %g3, [ %o4 + 0x64 ] 2011b18: d8 20 a0 40 st %o4, [ %g2 + 0x40 ] 2011b1c: c6 20 60 1c st %g3, [ %g1 + 0x1c ] the_watchdog->id = id; the_watchdog->user_data = user_data; 2011b20: c0 20 60 24 clr [ %g1 + 0x24 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2011b24: c0 20 60 08 clr [ %g1 + 8 ] the_watchdog->routine = routine; the_watchdog->id = id; 2011b28: d6 20 60 20 st %o3, [ %g1 + 0x20 ] /* * Initialize the pointer to the timer reset method so applications * that do not use the Timer Server do not have to pull it in. */ _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method; 2011b2c: 05 00 80 46 sethi %hi(0x2011800), %g2 2011b30: 03 00 80 cb sethi %hi(0x2032c00), %g1 2011b34: 84 10 a3 78 or %g2, 0x378, %g2 /* * Start the timer server */ status = rtems_task_start( 2011b38: 90 10 00 0b mov %o3, %o0 /* * Initialize the pointer to the timer reset method so applications * that do not use the Timer Server do not have to pull it in. */ _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method; 2011b3c: c4 20 60 3c st %g2, [ %g1 + 0x3c ] /* * Start the timer server */ status = rtems_task_start( 2011b40: 13 00 80 47 sethi %hi(0x2011c00), %o1 2011b44: 94 10 20 00 clr %o2 2011b48: 7f ff fd 9e call 20111c0 2011b4c: 92 12 60 4c or %o1, 0x4c, %o1 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 2011b50: 80 a2 20 00 cmp %o0, 0 2011b54: 02 bf ff ab be 2011a00 <== ALWAYS TAKEN 2011b58: 01 00 00 00 nop * but there is actually no way (in normal circumstances) that the * start can fail. The id and starting address are known to be * be good. If this service fails, something is weirdly wrong on the * target such as a stray write in an ISR or incorrect memory layout. */ initialized = false; 2011b5c: c0 2c 60 0c clrb [ %l1 + 0xc ] } return status; } 2011b60: 81 c7 e0 08 ret 2011b64: 91 e8 00 08 restore %g0, %o0, %o0 * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 2011b68: 02 bf ff ad be 2011a1c 2011b6c: b0 10 20 00 clr %i0 * but there is actually no way (in normal circumstances) that the * start can fail. The id and starting address are known to be * be good. If this service fails, something is weirdly wrong on the * target such as a stray write in an ISR or incorrect memory layout. */ initialized = false; 2011b70: 10 bf ff a4 b 2011a00 2011b74: 90 10 20 13 mov 0x13, %o0 =============================================================================== 0201176c : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 201176c: 9d e3 bf 90 save %sp, -112, %sp 2011770: 11 00 80 ca sethi %hi(0x2032800), %o0 2011774: 92 10 00 18 mov %i0, %o1 2011778: 90 12 23 fc or %o0, 0x3fc, %o0 201177c: 40 00 0a df call 20142f8 <_Objects_Get> 2011780: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2011784: c2 07 bf f4 ld [ %fp + -12 ], %g1 2011788: a0 10 00 08 mov %o0, %l0 201178c: 80 a0 60 00 cmp %g1, 0 2011790: 12 80 00 11 bne 20117d4 2011794: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 2011798: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 201179c: 80 a0 60 01 cmp %g1, 1 20117a0: 22 80 00 15 be,a 20117f4 20117a4: 31 00 80 cb sethi %hi(0x2032c00), %i0 20117a8: 1a 80 00 0d bcc 20117dc 20117ac: 80 a0 60 04 cmp %g1, 4 case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); 20117b0: a0 02 20 10 add %o0, 0x10, %l0 20117b4: 40 00 13 de call 201672c <_Watchdog_Remove> 20117b8: 90 10 00 10 mov %l0, %o0 _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 20117bc: 11 00 80 c8 sethi %hi(0x2032000), %o0 20117c0: 92 10 00 10 mov %l0, %o1 20117c4: 40 00 13 6f call 2016580 <_Watchdog_Insert> 20117c8: 90 12 23 74 or %o0, 0x374, %o0 case TIMER_TIME_OF_DAY_ON_TASK: case TIMER_DORMANT: _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } _Thread_Enable_dispatch(); 20117cc: 40 00 0d 4e call 2014d04 <_Thread_Enable_dispatch> 20117d0: b0 10 20 00 clr %i0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 20117d4: 81 c7 e0 08 ret 20117d8: 81 e8 00 00 restore the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 20117dc: 18 bf ff fc bgu 20117cc <== NEVER TAKEN 20117e0: 01 00 00 00 nop (*_Timer_Server_schedule_operation)( the_timer ); break; case TIMER_TIME_OF_DAY: case TIMER_TIME_OF_DAY_ON_TASK: case TIMER_DORMANT: _Thread_Enable_dispatch(); 20117e4: 40 00 0d 48 call 2014d04 <_Thread_Enable_dispatch> 20117e8: b0 10 20 0b mov 0xb, %i0 ! b 20117ec: 81 c7 e0 08 ret 20117f0: 81 e8 00 00 restore case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: if ( !_Timer_Server_schedule_operation ) { 20117f4: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 20117f8: 80 a0 60 00 cmp %g1, 0 20117fc: 02 80 00 08 be 201181c <== NEVER TAKEN 2011800: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } _Watchdog_Remove( &the_timer->Ticker ); 2011804: 40 00 13 ca call 201672c <_Watchdog_Remove> 2011808: 90 02 20 10 add %o0, 0x10, %o0 (*_Timer_Server_schedule_operation)( the_timer ); 201180c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 2011810: 9f c0 40 00 call %g1 2011814: 90 10 00 10 mov %l0, %o0 2011818: 30 bf ff ed b,a 20117cc _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: if ( !_Timer_Server_schedule_operation ) { _Thread_Enable_dispatch(); 201181c: 40 00 0d 3a call 2014d04 <_Thread_Enable_dispatch> <== NOT EXECUTED 2011820: b0 10 20 0e mov 0xe, %i0 <== NOT EXECUTED 2011824: 81 c7 e0 08 ret <== NOT EXECUTED 2011828: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 0201182c : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 201182c: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 2011830: 03 00 80 cb sethi %hi(0x2032c00), %g1 2011834: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2032c40 <_Timer_Server> Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 2011838: a2 10 00 18 mov %i0, %l1 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 201183c: 80 a0 a0 00 cmp %g2, 0 2011840: 02 80 00 28 be 20118e0 2011844: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; if ( !routine ) 2011848: 80 a6 a0 00 cmp %i2, 0 201184c: 02 80 00 25 be 20118e0 <== NEVER TAKEN 2011850: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 2011854: 80 a6 60 00 cmp %i1, 0 2011858: 02 80 00 22 be 20118e0 201185c: b0 10 20 0a mov 0xa, %i0 2011860: 11 00 80 ca sethi %hi(0x2032800), %o0 2011864: 92 10 00 11 mov %l1, %o1 2011868: 90 12 23 fc or %o0, 0x3fc, %o0 201186c: 40 00 0a a3 call 20142f8 <_Objects_Get> 2011870: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2011874: c2 07 bf f4 ld [ %fp + -12 ], %g1 2011878: a0 10 00 08 mov %o0, %l0 201187c: 80 a0 60 00 cmp %g1, 0 2011880: 12 80 00 18 bne 20118e0 2011884: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 2011888: 40 00 13 a9 call 201672c <_Watchdog_Remove> 201188c: 90 02 20 10 add %o0, 0x10, %o0 _ISR_Disable( level ); 2011890: 7f ff e6 79 call 200b274 2011894: 01 00 00 00 nop /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 2011898: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 201189c: 80 a0 60 00 cmp %g1, 0 20118a0: 12 80 00 12 bne 20118e8 <== NEVER TAKEN 20118a4: 82 10 20 01 mov 1, %g1 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 20118a8: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 20118ac: e2 24 20 30 st %l1, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 20118b0: f6 24 20 34 st %i3, [ %l0 + 0x34 ] * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL_ON_TASK; _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 20118b4: f2 24 20 1c st %i1, [ %l0 + 0x1c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20118b8: c0 24 20 18 clr [ %l0 + 0x18 ] /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL_ON_TASK; 20118bc: c2 24 20 38 st %g1, [ %l0 + 0x38 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; _ISR_Enable( level ); 20118c0: 7f ff e6 71 call 200b284 20118c4: b0 10 20 00 clr %i0 /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 20118c8: 03 00 80 cb sethi %hi(0x2032c00), %g1 20118cc: c4 00 60 3c ld [ %g1 + 0x3c ], %g2 ! 2032c3c <_Timer_Server_schedule_operation> 20118d0: 9f c0 80 00 call %g2 20118d4: 90 10 00 10 mov %l0, %o0 _Thread_Enable_dispatch(); 20118d8: 40 00 0d 0b call 2014d04 <_Thread_Enable_dispatch> 20118dc: 01 00 00 00 nop case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 20118e0: 81 c7 e0 08 ret 20118e4: 81 e8 00 00 restore * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 20118e8: 7f ff e6 67 call 200b284 <== NOT EXECUTED 20118ec: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 20118f0: 40 00 0d 05 call 2014d04 <_Thread_Enable_dispatch> <== NOT EXECUTED 20118f4: 01 00 00 00 nop <== NOT EXECUTED 20118f8: 81 c7 e0 08 ret <== NOT EXECUTED 20118fc: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02011900 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 2011900: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_Timer_Server ) 2011904: 03 00 80 cb sethi %hi(0x2032c00), %g1 2011908: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2032c40 <_Timer_Server> Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 201190c: a2 10 00 18 mov %i0, %l1 Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_Timer_Server ) 2011910: 80 a0 a0 00 cmp %g2, 0 2011914: 02 80 00 34 be 20119e4 2011918: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 201191c: 03 00 80 c8 sethi %hi(0x2032000), %g1 2011920: c4 08 62 a4 ldub [ %g1 + 0x2a4 ], %g2 ! 20322a4 <_TOD_Is_set> 2011924: 80 a0 a0 00 cmp %g2, 0 2011928: 02 80 00 2f be 20119e4 <== NEVER TAKEN 201192c: b0 10 20 0b mov 0xb, %i0 return RTEMS_NOT_DEFINED; if ( !routine ) 2011930: 80 a6 a0 00 cmp %i2, 0 2011934: 02 80 00 2c be 20119e4 <== NEVER TAKEN 2011938: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 201193c: 7f ff f4 46 call 200ea54 <_TOD_Validate> 2011940: 90 10 00 19 mov %i1, %o0 2011944: 80 8a 20 ff btst 0xff, %o0 2011948: 12 80 00 04 bne 2011958 201194c: 01 00 00 00 nop case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 2011950: 81 c7 e0 08 ret 2011954: 91 e8 20 14 restore %g0, 0x14, %o0 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 2011958: 7f ff f4 0a call 200e980 <_TOD_To_seconds> 201195c: 90 10 00 19 mov %i1, %o0 if ( seconds <= _TOD_Seconds_since_epoch ) 2011960: 25 00 80 c8 sethi %hi(0x2032000), %l2 2011964: c2 04 a3 24 ld [ %l2 + 0x324 ], %g1 ! 2032324 <_TOD_Now> 2011968: 80 a2 00 01 cmp %o0, %g1 201196c: 08 bf ff f9 bleu 2011950 2011970: a0 10 00 08 mov %o0, %l0 2011974: 11 00 80 ca sethi %hi(0x2032800), %o0 2011978: 92 10 00 11 mov %l1, %o1 201197c: 90 12 23 fc or %o0, 0x3fc, %o0 2011980: 40 00 0a 5e call 20142f8 <_Objects_Get> 2011984: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2011988: c2 07 bf f4 ld [ %fp + -12 ], %g1 201198c: b2 10 00 08 mov %o0, %i1 2011990: 80 a0 60 00 cmp %g1, 0 2011994: 12 80 00 14 bne 20119e4 2011998: b0 10 20 04 mov 4, %i0 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 201199c: 40 00 13 64 call 201672c <_Watchdog_Remove> 20119a0: 90 02 20 10 add %o0, 0x10, %o0 the_watchdog->routine = routine; the_watchdog->id = id; 20119a4: e2 26 60 30 st %l1, [ %i1 + 0x30 ] the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch; 20119a8: c4 04 a3 24 ld [ %l2 + 0x324 ], %g2 /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 20119ac: 03 00 80 cb sethi %hi(0x2032c00), %g1 20119b0: c6 00 60 3c ld [ %g1 + 0x3c ], %g3 ! 2032c3c <_Timer_Server_schedule_operation> case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch; 20119b4: 84 24 00 02 sub %l0, %g2, %g2 the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 20119b8: 82 10 20 03 mov 3, %g1 /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 20119bc: 90 10 00 19 mov %i1, %o0 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch; 20119c0: c4 26 60 1c st %g2, [ %i1 + 0x1c ] the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 20119c4: c2 26 60 38 st %g1, [ %i1 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 20119c8: f4 26 60 2c st %i2, [ %i1 + 0x2c ] the_watchdog->id = id; the_watchdog->user_data = user_data; 20119cc: f6 26 60 34 st %i3, [ %i1 + 0x34 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20119d0: c0 26 60 18 clr [ %i1 + 0x18 ] /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 20119d4: 9f c0 c0 00 call %g3 20119d8: b0 10 20 00 clr %i0 _Thread_Enable_dispatch(); 20119dc: 40 00 0c ca call 2014d04 <_Thread_Enable_dispatch> 20119e0: 01 00 00 00 nop 20119e4: 81 c7 e0 08 ret 20119e8: 81 e8 00 00 restore =============================================================================== 020066e8 : */ bool rtems_workspace_allocate( uintptr_t bytes, void **pointer ) { 20066e8: 9d e3 bf 98 save %sp, -104, %sp void *ptr; /* * check the arguments */ if ( !pointer ) 20066ec: 80 a6 60 00 cmp %i1, 0 20066f0: 02 80 00 05 be 2006704 <== NEVER TAKEN 20066f4: 92 10 00 18 mov %i0, %o1 return false; if ( !bytes ) 20066f8: 80 a6 20 00 cmp %i0, 0 20066fc: 12 80 00 04 bne 200670c <== ALWAYS TAKEN 2006700: 11 00 80 73 sethi %hi(0x201cc00), %o0 if (!ptr) return false; *pointer = ptr; return true; } 2006704: 81 c7 e0 08 ret <== NOT EXECUTED 2006708: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED return false; /* * Allocate the memory */ ptr = _Protected_heap_Allocate( &_Workspace_Area, (intptr_t) bytes ); 200670c: 40 00 05 fd call 2007f00 <_Protected_heap_Allocate> 2006710: 90 12 22 c4 or %o0, 0x2c4, %o0 if (!ptr) 2006714: 80 a2 20 00 cmp %o0, 0 2006718: 02 bf ff fb be 2006704 <== NEVER TAKEN 200671c: 01 00 00 00 nop return false; *pointer = ptr; 2006720: d0 26 40 00 st %o0, [ %i1 ] 2006724: 81 c7 e0 08 ret 2006728: 91 e8 20 01 restore %g0, 1, %o0 =============================================================================== 020066cc : * _Workspace_Allocate */ bool rtems_workspace_free( void *pointer ) { 20066cc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED return _Protected_heap_Free( &_Workspace_Area, pointer ); 20066d0: 11 00 80 73 sethi %hi(0x201cc00), %o0 <== NOT EXECUTED 20066d4: 90 12 22 c4 or %o0, 0x2c4, %o0 ! 201cec4 <_Workspace_Area><== NOT EXECUTED 20066d8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 20066dc: 40 00 06 15 call 2007f30 <_Protected_heap_Free> <== NOT EXECUTED 20066e0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED =============================================================================== 0200672c : bool rtems_workspace_get_information( Heap_Information_block *the_info ) { if ( !the_info ) 200672c: 80 a2 20 00 cmp %o0, 0 2006730: 02 80 00 07 be 200674c <== NEVER TAKEN 2006734: 92 10 00 08 mov %o0, %o1 return false; return _Protected_heap_Get_information( &_Workspace_Area, the_info ); 2006738: 11 00 80 73 sethi %hi(0x201cc00), %o0 200673c: 90 12 22 c4 or %o0, 0x2c4, %o0 ! 201cec4 <_Workspace_Area> 2006740: 82 13 c0 00 mov %o7, %g1 2006744: 40 00 06 07 call 2007f60 <_Protected_heap_Get_information> 2006748: 9e 10 40 00 mov %g1, %o7 } 200674c: 81 c3 e0 08 retl <== NOT EXECUTED =============================================================================== 02006e50 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 2006e50: 9d e3 bf 98 save %sp, -104, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 2006e54: 80 a6 20 00 cmp %i0, 0 2006e58: 12 80 00 0a bne 2006e80 <== ALWAYS TAKEN 2006e5c: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); if ( !interval ) 2006e60: 02 80 00 13 be 2006eac 2006e64: 03 00 80 71 sethi %hi(0x201c400), %g1 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 2006e68: d0 00 61 d8 ld [ %g1 + 0x1d8 ], %o0 ! 201c5d8 <_Thread_Ticks_per_timeslice> 2006e6c: 92 10 00 19 mov %i1, %o1 2006e70: 40 00 0f d0 call 200adb0 <_Timespec_From_ticks> 2006e74: b0 10 20 00 clr %i0 return 0; } 2006e78: 81 c7 e0 08 ret 2006e7c: 81 e8 00 00 restore { /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 2006e80: 7f ff f1 aa call 2003528 2006e84: 01 00 00 00 nop 2006e88: 80 a2 00 18 cmp %o0, %i0 2006e8c: 02 bf ff f5 be 2006e60 2006e90: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 2006e94: 40 00 22 d5 call 200f9e8 <__errno> 2006e98: b0 10 3f ff mov -1, %i0 2006e9c: 82 10 20 03 mov 3, %g1 2006ea0: c2 22 00 00 st %g1, [ %o0 ] 2006ea4: 81 c7 e0 08 ret 2006ea8: 81 e8 00 00 restore if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 2006eac: 40 00 22 cf call 200f9e8 <__errno> 2006eb0: b0 10 3f ff mov -1, %i0 2006eb4: 82 10 20 16 mov 0x16, %g1 2006eb8: c2 22 00 00 st %g1, [ %o0 ] 2006ebc: 81 c7 e0 08 ret 2006ec0: 81 e8 00 00 restore =============================================================================== 02007edc : */ int sem_destroy( sem_t *sem ) { 2007edc: 9d e3 bf 90 save %sp, -112, %sp 2007ee0: d2 06 00 00 ld [ %i0 ], %o1 2007ee4: 11 00 80 7b sethi %hi(0x201ec00), %o0 2007ee8: 94 07 bf f4 add %fp, -12, %o2 2007eec: 40 00 09 78 call 200a4cc <_Objects_Get> 2007ef0: 90 12 21 b0 or %o0, 0x1b0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 2007ef4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007ef8: 80 a0 60 00 cmp %g1, 0 2007efc: 22 80 00 08 be,a 2007f1c 2007f00: c2 0a 20 14 ldub [ %o0 + 0x14 ], %g1 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 2007f04: 40 00 25 9f call 2011580 <__errno> 2007f08: b0 10 3f ff mov -1, %i0 2007f0c: 82 10 20 16 mov 0x16, %g1 2007f10: c2 22 00 00 st %g1, [ %o0 ] } 2007f14: 81 c7 e0 08 ret 2007f18: 81 e8 00 00 restore case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { 2007f1c: 80 a0 60 00 cmp %g1, 0 2007f20: 12 80 00 08 bne 2007f40 <== NEVER TAKEN 2007f24: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } _POSIX_Semaphore_Delete( the_semaphore ); 2007f28: 40 00 1c b6 call 200f200 <_POSIX_Semaphore_Delete> 2007f2c: b0 10 20 00 clr %i0 ! 0 _Thread_Enable_dispatch(); 2007f30: 40 00 0b bc call 200ae20 <_Thread_Enable_dispatch> 2007f34: 01 00 00 00 nop 2007f38: 81 c7 e0 08 ret 2007f3c: 81 e8 00 00 restore /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { _Thread_Enable_dispatch(); 2007f40: 40 00 0b b8 call 200ae20 <_Thread_Enable_dispatch> <== NOT EXECUTED 2007f44: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 2007f48: 40 00 25 8e call 2011580 <__errno> <== NOT EXECUTED 2007f4c: 01 00 00 00 nop <== NOT EXECUTED 2007f50: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 2007f54: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2007f58: 81 c7 e0 08 ret <== NOT EXECUTED 2007f5c: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02007fb4 : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 2007fb4: 9d e3 bf 90 save %sp, -112, %sp 2007fb8: 92 10 00 19 mov %i1, %o1 int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 2007fbc: 80 a6 20 00 cmp %i0, 0 2007fc0: 02 80 00 0c be 2007ff0 <== NEVER TAKEN 2007fc4: 94 10 00 1a mov %i2, %o2 rtems_set_errno_and_return_minus_one( EINVAL ); status = _POSIX_Semaphore_Create_support( 2007fc8: 90 10 20 00 clr %o0 2007fcc: 40 00 1c 41 call 200f0d0 <_POSIX_Semaphore_Create_support> 2007fd0: 96 07 bf f4 add %fp, -12, %o3 pshared, value, &the_semaphore ); if ( status != -1 ) 2007fd4: 80 a2 3f ff cmp %o0, -1 2007fd8: 02 80 00 04 be 2007fe8 2007fdc: c2 07 bf f4 ld [ %fp + -12 ], %g1 *sem = the_semaphore->Object.id; 2007fe0: c4 00 60 08 ld [ %g1 + 8 ], %g2 2007fe4: c4 26 00 00 st %g2, [ %i0 ] return status; } 2007fe8: 81 c7 e0 08 ret 2007fec: 91 e8 00 08 restore %g0, %o0, %o0 { int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) rtems_set_errno_and_return_minus_one( EINVAL ); 2007ff0: 40 00 25 64 call 2011580 <__errno> <== NOT EXECUTED 2007ff4: 01 00 00 00 nop <== NOT EXECUTED 2007ff8: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 2007ffc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2008000: 10 bf ff fa b 2007fe8 <== NOT EXECUTED 2008004: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED =============================================================================== 02008008 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 2008008: 9d e3 bf 88 save %sp, -120, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200800c: 05 00 80 7a sethi %hi(0x201e800), %g2 2008010: c2 00 a2 a0 ld [ %g2 + 0x2a0 ], %g1 ! 201eaa0 <_Thread_Dispatch_disable_level> Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); 2008014: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 2008018: 82 00 60 01 inc %g1 200801c: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 2008020: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 2008024: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 2008028: c2 20 a2 a0 st %g1, [ %g2 + 0x2a0 ] POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 200802c: ba 8e 62 00 andcc %i1, 0x200, %i5 2008030: 12 80 00 26 bne 20080c8 2008034: 82 07 a0 54 add %fp, 0x54, %g1 2008038: b8 10 20 00 clr %i4 mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 200803c: 90 10 00 18 mov %i0, %o0 2008040: 40 00 1c 86 call 200f258 <_POSIX_Semaphore_Name_to_id> 2008044: 92 07 bf f0 add %fp, -16, %o1 * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "semaphore does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 2008048: a0 92 20 00 orcc %o0, 0, %l0 200804c: 02 80 00 0e be 2008084 2008050: 82 0e 6a 00 and %i1, 0xa00, %g1 /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 2008054: 80 a4 20 02 cmp %l0, 2 2008058: 12 80 00 04 bne 2008068 <== NEVER TAKEN 200805c: 80 a7 60 00 cmp %i5, 0 2008060: 12 80 00 25 bne 20080f4 2008064: 94 10 00 1c mov %i4, %o2 _Thread_Enable_dispatch(); 2008068: 40 00 0b 6e call 200ae20 <_Thread_Enable_dispatch> 200806c: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 2008070: 40 00 25 44 call 2011580 <__errno> 2008074: 01 00 00 00 nop 2008078: e0 22 00 00 st %l0, [ %o0 ] 200807c: 81 c7 e0 08 ret 2008080: 81 e8 00 00 restore /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 2008084: 80 a0 6a 00 cmp %g1, 0xa00 2008088: 02 80 00 13 be 20080d4 200808c: d2 07 bf f0 ld [ %fp + -16 ], %o1 2008090: 94 07 bf e8 add %fp, -24, %o2 2008094: 11 00 80 7b sethi %hi(0x201ec00), %o0 2008098: 40 00 09 0d call 200a4cc <_Objects_Get> 200809c: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 201edb0 <_POSIX_Semaphore_Information> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); the_semaphore->open_count += 1; 20080a0: c2 02 20 18 ld [ %o0 + 0x18 ], %g1 if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 20080a4: d0 27 bf ec st %o0, [ %fp + -20 ] the_semaphore->open_count += 1; 20080a8: 82 00 60 01 inc %g1 _Thread_Enable_dispatch(); 20080ac: 40 00 0b 5d call 200ae20 <_Thread_Enable_dispatch> 20080b0: c2 22 20 18 st %g1, [ %o0 + 0x18 ] _Thread_Enable_dispatch(); 20080b4: 40 00 0b 5b call 200ae20 <_Thread_Enable_dispatch> 20080b8: 01 00 00 00 nop id = &the_semaphore->Object.id; return (sem_t *)id; 20080bc: c2 07 bf ec ld [ %fp + -20 ], %g1 20080c0: 81 c7 e0 08 ret 20080c4: 91 e8 60 08 restore %g1, 8, %o0 _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 20080c8: f8 07 a0 50 ld [ %fp + 0x50 ], %i4 20080cc: 10 bf ff dc b 200803c 20080d0: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _Thread_Enable_dispatch(); 20080d4: 40 00 0b 53 call 200ae20 <_Thread_Enable_dispatch> 20080d8: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 20080dc: 40 00 25 29 call 2011580 <__errno> 20080e0: 01 00 00 00 nop 20080e4: 82 10 20 11 mov 0x11, %g1 ! 11 20080e8: c2 22 00 00 st %g1, [ %o0 ] 20080ec: 81 c7 e0 08 ret 20080f0: 81 e8 00 00 restore /* * At this point, the semaphore does not exist and everything has been * checked. We should go ahead and create a semaphore. */ status =_POSIX_Semaphore_Create_support( 20080f4: 90 10 00 18 mov %i0, %o0 20080f8: 92 10 20 00 clr %o1 20080fc: 40 00 1b f5 call 200f0d0 <_POSIX_Semaphore_Create_support> 2008100: 96 07 bf ec add %fp, -20, %o3 /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 2008104: 40 00 0b 47 call 200ae20 <_Thread_Enable_dispatch> 2008108: a0 10 00 08 mov %o0, %l0 if ( status == -1 ) 200810c: 80 a4 3f ff cmp %l0, -1 2008110: 02 bf ff db be 200807c <== NEVER TAKEN 2008114: b0 10 3f ff mov -1, %i0 return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; 2008118: c2 07 bf ec ld [ %fp + -20 ], %g1 200811c: b0 00 60 08 add %g1, 8, %i0 } 2008120: 81 c7 e0 08 ret 2008124: 81 e8 00 00 restore =============================================================================== 02008184 : int sem_timedwait( sem_t *sem, const struct timespec *abstime ) { 2008184: 9d e3 bf 90 save %sp, -112, %sp * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 2008188: 90 10 00 19 mov %i1, %o0 200818c: 40 00 19 5c call 200e6fc <_POSIX_Absolute_timeout_to_ticks> 2008190: 92 07 bf f4 add %fp, -12, %o1 switch ( status ) { 2008194: 80 a2 20 02 cmp %o0, 2 2008198: 08 80 00 07 bleu 20081b4 <== NEVER TAKEN 200819c: d4 07 bf f4 ld [ %fp + -12 ], %o2 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = true; break; } lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 20081a0: 90 10 00 18 mov %i0, %o0 20081a4: 40 00 1c 4b call 200f2d0 <_POSIX_Semaphore_Wait_support> 20081a8: 92 10 20 01 mov 1, %o1 break; } } return lock_status; } 20081ac: 81 c7 e0 08 ret 20081b0: 91 e8 00 08 restore %g0, %o0, %o0 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = true; break; } lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 20081b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20081b8: 40 00 1c 46 call 200f2d0 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED 20081bc: 92 10 20 00 clr %o1 <== NOT EXECUTED break; } } return lock_status; } 20081c0: 81 c7 e0 08 ret <== NOT EXECUTED 20081c4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED =============================================================================== 020081e0 : */ int sem_unlink( const char *name ) { 20081e0: 9d e3 bf 90 save %sp, -112, %sp 20081e4: 03 00 80 7a sethi %hi(0x201e800), %g1 20081e8: c4 00 62 a0 ld [ %g1 + 0x2a0 ], %g2 ! 201eaa0 <_Thread_Dispatch_disable_level> 20081ec: 90 10 00 18 mov %i0, %o0 20081f0: 84 00 a0 01 inc %g2 20081f4: c4 20 62 a0 st %g2, [ %g1 + 0x2a0 ] register POSIX_Semaphore_Control *the_semaphore; sem_t the_semaphore_id; _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 20081f8: 40 00 1c 18 call 200f258 <_POSIX_Semaphore_Name_to_id> 20081fc: 92 07 bf f4 add %fp, -12, %o1 if ( status != 0 ) { 2008200: b0 92 20 00 orcc %o0, 0, %i0 2008204: 12 80 00 19 bne 2008268 2008208: 11 00 80 7b sethi %hi(0x201ec00), %o0 RTEMS_INLINE_ROUTINE Objects_Control *_Objects_Get_local_object( Objects_Information *information, uint16_t index ) { if ( index > information->maximum ) 200820c: c6 07 bf f4 ld [ %fp + -12 ], %g3 2008210: 88 12 21 b0 or %o0, 0x1b0, %g4 2008214: c2 11 20 10 lduh [ %g4 + 0x10 ], %g1 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( status ); } the_semaphore = (POSIX_Semaphore_Control *) _Objects_Get_local_object( 2008218: 05 00 00 3f sethi %hi(0xfc00), %g2 200821c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2008220: 86 08 c0 02 and %g3, %g2, %g3 2008224: 80 a0 c0 01 cmp %g3, %g1 2008228: 18 80 00 05 bgu 200823c <== NEVER TAKEN 200822c: b0 10 20 00 clr %i0 2008230: c4 01 20 1c ld [ %g4 + 0x1c ], %g2 2008234: 83 28 e0 02 sll %g3, 2, %g1 2008238: f0 00 80 01 ld [ %g2 + %g1 ], %i0 RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Namespace_remove ( POSIX_Semaphore_Control *the_semaphore ) { _Objects_Namespace_remove( 200823c: 92 10 00 18 mov %i0, %o1 &_POSIX_Semaphore_Information, _Objects_Get_index( the_semaphore_id ) ); the_semaphore->linked = FALSE; 2008240: c0 2e 20 15 clrb [ %i0 + 0x15 ] 2008244: 40 00 08 f4 call 200a614 <_Objects_Namespace_remove> 2008248: 90 12 21 b0 or %o0, 0x1b0, %o0 _POSIX_Semaphore_Namespace_remove( the_semaphore ); _POSIX_Semaphore_Delete( the_semaphore ); 200824c: 90 10 00 18 mov %i0, %o0 2008250: 40 00 1b ec call 200f200 <_POSIX_Semaphore_Delete> 2008254: b0 10 20 00 clr %i0 _Thread_Enable_dispatch(); 2008258: 40 00 0a f2 call 200ae20 <_Thread_Enable_dispatch> 200825c: 01 00 00 00 nop return 0; } 2008260: 81 c7 e0 08 ret 2008264: 81 e8 00 00 restore _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); if ( status != 0 ) { _Thread_Enable_dispatch(); 2008268: 40 00 0a ee call 200ae20 <_Thread_Enable_dispatch> 200826c: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( status ); 2008270: 40 00 24 c4 call 2011580 <__errno> 2008274: 01 00 00 00 nop 2008278: f0 22 00 00 st %i0, [ %o0 ] 200827c: 81 c7 e0 08 ret 2008280: 91 e8 3f ff restore %g0, -1, %o0 =============================================================================== 02005f54 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 2005f54: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; if ( oact ) 2005f58: 80 a6 a0 00 cmp %i2, 0 2005f5c: 02 80 00 0e be 2005f94 2005f60: a0 10 00 18 mov %i0, %l0 *oact = _POSIX_signals_Vectors[ sig ]; 2005f64: 87 2e 20 02 sll %i0, 2, %g3 2005f68: 05 00 80 6e sethi %hi(0x201b800), %g2 2005f6c: 83 2e 20 04 sll %i0, 4, %g1 2005f70: 84 10 a0 a0 or %g2, 0xa0, %g2 2005f74: 82 20 40 03 sub %g1, %g3, %g1 2005f78: c8 00 80 01 ld [ %g2 + %g1 ], %g4 2005f7c: 84 00 80 01 add %g2, %g1, %g2 2005f80: c8 26 80 00 st %g4, [ %i2 ] 2005f84: c2 00 a0 04 ld [ %g2 + 4 ], %g1 2005f88: c2 26 a0 04 st %g1, [ %i2 + 4 ] 2005f8c: c6 00 a0 08 ld [ %g2 + 8 ], %g3 2005f90: c6 26 a0 08 st %g3, [ %i2 + 8 ] if ( !sig ) 2005f94: 80 a4 20 00 cmp %l0, 0 2005f98: 02 80 00 33 be 2006064 2005f9c: b4 04 3f ff add %l0, -1, %i2 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 2005fa0: 80 a6 a0 1f cmp %i2, 0x1f 2005fa4: 18 80 00 30 bgu 2006064 2005fa8: 80 a4 20 09 cmp %l0, 9 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 2005fac: 02 80 00 2e be 2006064 2005fb0: 80 a6 60 00 cmp %i1, 0 /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 2005fb4: 02 80 00 1a be 200601c <== NEVER TAKEN 2005fb8: b0 10 20 00 clr %i0 /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); 2005fbc: 7f ff f1 12 call 2002404 2005fc0: 01 00 00 00 nop 2005fc4: b0 10 00 08 mov %o0, %i0 if ( act->sa_handler == SIG_DFL ) { 2005fc8: c2 06 60 08 ld [ %i1 + 8 ], %g1 2005fcc: 80 a0 60 00 cmp %g1, 0 2005fd0: 02 80 00 15 be 2006024 2005fd4: 90 10 20 01 mov 1, %o0 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; } else { _POSIX_signals_Clear_process_signals( signo_to_mask(sig) ); 2005fd8: 40 00 1a ab call 200ca84 <_POSIX_signals_Clear_process_signals> 2005fdc: 91 2a 00 1a sll %o0, %i2, %o0 _POSIX_signals_Vectors[ sig ] = *act; 2005fe0: da 06 40 00 ld [ %i1 ], %o5 2005fe4: 85 2c 20 02 sll %l0, 2, %g2 2005fe8: 87 2c 20 04 sll %l0, 4, %g3 2005fec: 03 00 80 6e sethi %hi(0x201b800), %g1 2005ff0: 86 20 c0 02 sub %g3, %g2, %g3 2005ff4: 82 10 60 a0 or %g1, 0xa0, %g1 2005ff8: da 20 40 03 st %o5, [ %g1 + %g3 ] 2005ffc: c8 06 60 04 ld [ %i1 + 4 ], %g4 2006000: 82 00 40 03 add %g1, %g3, %g1 2006004: c8 20 60 04 st %g4, [ %g1 + 4 ] 2006008: c4 06 60 08 ld [ %i1 + 8 ], %g2 200600c: c4 20 60 08 st %g2, [ %g1 + 8 ] } _ISR_Enable( level ); 2006010: 90 10 00 18 mov %i0, %o0 2006014: 7f ff f1 00 call 2002414 2006018: b0 10 20 00 clr %i0 * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; } 200601c: 81 c7 e0 08 ret 2006020: 81 e8 00 00 restore * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); if ( act->sa_handler == SIG_DFL ) { _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 2006024: 85 2c 20 02 sll %l0, 2, %g2 2006028: 87 2c 20 04 sll %l0, 4, %g3 200602c: 03 00 80 66 sethi %hi(0x2019800), %g1 2006030: 86 20 c0 02 sub %g3, %g2, %g3 2006034: 82 10 61 08 or %g1, 0x108, %g1 2006038: c8 00 40 03 ld [ %g1 + %g3 ], %g4 200603c: 82 00 40 03 add %g1, %g3, %g1 2006040: da 00 60 08 ld [ %g1 + 8 ], %o5 2006044: d8 00 60 04 ld [ %g1 + 4 ], %o4 2006048: 05 00 80 6e sethi %hi(0x201b800), %g2 200604c: 84 10 a0 a0 or %g2, 0xa0, %g2 ! 201b8a0 <_POSIX_signals_Vectors> 2006050: c8 20 80 03 st %g4, [ %g2 + %g3 ] 2006054: 84 00 80 03 add %g2, %g3, %g2 2006058: da 20 a0 08 st %o5, [ %g2 + 8 ] 200605c: 10 bf ff ed b 2006010 2006060: d8 20 a0 04 st %o4, [ %g2 + 4 ] * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) rtems_set_errno_and_return_minus_one( EINVAL ); 2006064: 40 00 23 58 call 200edc4 <__errno> 2006068: b0 10 3f ff mov -1, %i0 200606c: 82 10 20 16 mov 0x16, %g1 2006070: c2 22 00 00 st %g1, [ %o0 ] 2006074: 81 c7 e0 08 ret 2006078: 81 e8 00 00 restore =============================================================================== 020080e4 : #include int sigsuspend( const sigset_t *sigmask ) { 20080e4: 9d e3 bf 90 save %sp, -112, %sp int status; POSIX_API_Control *api; api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked ); 20080e8: 90 10 20 01 mov 1, %o0 20080ec: 92 10 00 18 mov %i0, %o1 20080f0: a0 07 bf f4 add %fp, -12, %l0 20080f4: 7f ff ff f1 call 20080b8 20080f8: 94 10 00 10 mov %l0, %o2 (void) sigfillset( &all_signals ); 20080fc: a2 07 bf f0 add %fp, -16, %l1 2008100: 7f ff ff b7 call 2007fdc 2008104: 90 10 00 11 mov %l1, %o0 status = sigtimedwait( &all_signals, NULL, NULL ); 2008108: 90 10 00 11 mov %l1, %o0 200810c: 92 10 20 00 clr %o1 2008110: 40 00 00 2e call 20081c8 2008114: 94 10 20 00 clr %o2 (void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL ); 2008118: 92 10 00 10 mov %l0, %o1 status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked ); (void) sigfillset( &all_signals ); status = sigtimedwait( &all_signals, NULL, NULL ); 200811c: a2 10 00 08 mov %o0, %l1 (void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL ); 2008120: 94 10 20 00 clr %o2 2008124: 7f ff ff e5 call 20080b8 2008128: 90 10 20 00 clr %o0 /* * sigtimedwait() returns the signal number while sigsuspend() * is supposed to return -1 and EINTR when a signal is caught. */ if ( status != -1 ) 200812c: 80 a4 7f ff cmp %l1, -1 2008130: 12 80 00 05 bne 2008144 <== ALWAYS TAKEN 2008134: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINTR ); return status; } 2008138: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200813c: 81 c7 e0 08 ret <== NOT EXECUTED 2008140: 81 e8 00 00 restore <== NOT EXECUTED /* * sigtimedwait() returns the signal number while sigsuspend() * is supposed to return -1 and EINTR when a signal is caught. */ if ( status != -1 ) rtems_set_errno_and_return_minus_one( EINTR ); 2008144: 40 00 24 9f call 20113c0 <__errno> 2008148: b0 10 3f ff mov -1, %i0 200814c: 82 10 20 04 mov 4, %g1 2008150: c2 22 00 00 st %g1, [ %o0 ] 2008154: 81 c7 e0 08 ret 2008158: 81 e8 00 00 restore =============================================================================== 02006410 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 2006410: 9d e3 bf 88 save %sp, -120, %sp * NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 2006414: 80 a6 a0 00 cmp %i2, 0 2006418: 02 80 00 0c be 2006448 200641c: a4 10 20 00 clr %l2 if ( !_Timespec_Is_valid( timeout ) ) 2006420: 40 00 0f 74 call 200a1f0 <_Timespec_Is_valid> 2006424: 90 10 00 1a mov %i2, %o0 2006428: 80 8a 20 ff btst 0xff, %o0 200642c: 02 80 00 62 be 20065b4 2006430: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 2006434: 40 00 0f 97 call 200a290 <_Timespec_To_ticks> 2006438: 90 10 00 1a mov %i2, %o0 if ( !interval ) 200643c: a4 92 20 00 orcc %o0, 0, %l2 2006440: 02 80 00 5d be 20065b4 <== NEVER TAKEN 2006444: 01 00 00 00 nop /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 2006448: 80 a6 60 00 cmp %i1, 0 200644c: 02 80 00 03 be 2006458 2006450: b4 07 bf ec add %fp, -20, %i2 2006454: b4 10 00 19 mov %i1, %i2 the_thread = _Thread_Executing; 2006458: 27 00 80 6e sethi %hi(0x201b800), %l3 200645c: f2 04 e3 d4 ld [ %l3 + 0x3d4 ], %i1 ! 201bbd4 <_Thread_Executing> * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 2006460: 7f ff f0 b8 call 2002740 2006464: e2 06 61 6c ld [ %i1 + 0x16c ], %l1 2006468: a0 10 00 08 mov %o0, %l0 if ( *set & api->signals_pending ) { 200646c: c4 06 00 00 ld [ %i0 ], %g2 2006470: c2 04 60 c8 ld [ %l1 + 0xc8 ], %g1 2006474: 80 88 80 01 btst %g2, %g1 2006478: 12 80 00 3e bne 2006570 200647c: 01 00 00 00 nop return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 2006480: 03 00 80 70 sethi %hi(0x201c000), %g1 2006484: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 201c2ac <_POSIX_signals_Pending> 2006488: 80 88 80 01 btst %g2, %g1 200648c: 12 80 00 28 bne 200652c 2006490: 07 00 80 6e sethi %hi(0x201b800), %g3 2006494: c2 00 e3 10 ld [ %g3 + 0x310 ], %g1 ! 201bb10 <_Thread_Dispatch_disable_level> the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 2006498: 84 10 3f ff mov -1, %g2 200649c: 82 00 60 01 inc %g1 20064a0: c4 26 80 00 st %g2, [ %i2 ] 20064a4: c2 20 e3 10 st %g1, [ %g3 + 0x310 ] _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; the_thread->Wait.return_code = EINTR; 20064a8: 82 10 20 04 mov 4, %g1 20064ac: c2 26 60 34 st %g1, [ %i1 + 0x34 ] the_thread->Wait.option = *set; 20064b0: c4 06 00 00 ld [ %i0 ], %g2 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 20064b4: 82 10 20 01 mov 1, %g1 the_thread->Wait.return_argument = the_info; 20064b8: f4 26 60 28 st %i2, [ %i1 + 0x28 ] the_info->si_signo = -1; _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; the_thread->Wait.return_code = EINTR; the_thread->Wait.option = *set; 20064bc: c4 26 60 30 st %g2, [ %i1 + 0x30 ] } the_info->si_signo = -1; _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 20064c0: 21 00 80 70 sethi %hi(0x201c000), %l0 20064c4: a0 14 22 6c or %l0, 0x26c, %l0 ! 201c26c <_POSIX_signals_Wait_queue> 20064c8: e0 26 60 44 st %l0, [ %i1 + 0x44 ] 20064cc: c2 24 20 30 st %g1, [ %l0 + 0x30 ] the_thread->Wait.return_code = EINTR; the_thread->Wait.option = *set; the_thread->Wait.return_argument = the_info; _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 20064d0: 7f ff f0 a0 call 2002750 20064d4: 01 00 00 00 nop _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 20064d8: 90 10 00 10 mov %l0, %o0 20064dc: 92 10 00 12 mov %l2, %o1 20064e0: 15 00 80 27 sethi %hi(0x2009c00), %o2 20064e4: 40 00 0c ba call 20097cc <_Thread_queue_Enqueue_with_handler> 20064e8: 94 12 a0 24 or %o2, 0x24, %o2 ! 2009c24 <_Thread_queue_Timeout> _Thread_Enable_dispatch(); 20064ec: 40 00 0b 5a call 2009254 <_Thread_Enable_dispatch> 20064f0: 01 00 00 00 nop /* * When the thread is set free by a signal, it is need to eliminate * the signal. */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); 20064f4: d2 06 80 00 ld [ %i2 ], %o1 20064f8: 94 10 00 1a mov %i2, %o2 20064fc: 96 10 20 00 clr %o3 2006500: 98 10 20 00 clr %o4 2006504: 40 00 1b 49 call 200d228 <_POSIX_signals_Clear_signals> 2006508: 90 10 00 11 mov %l1, %o0 errno = _Thread_Executing->Wait.return_code; 200650c: 40 00 23 f8 call 200f4ec <__errno> 2006510: 01 00 00 00 nop 2006514: c2 04 e3 d4 ld [ %l3 + 0x3d4 ], %g1 2006518: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 200651c: c4 22 00 00 st %g2, [ %o0 ] return the_info->si_signo; 2006520: f0 06 80 00 ld [ %i2 ], %i0 } 2006524: 81 c7 e0 08 ret 2006528: 81 e8 00 00 restore } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 200652c: 7f ff ff 9e call 20063a4 <_POSIX_signals_Get_highest> 2006530: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 2006534: 94 10 00 1a mov %i2, %o2 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 2006538: b0 10 00 08 mov %o0, %i0 _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 200653c: 96 10 20 01 mov 1, %o3 2006540: 90 10 00 11 mov %l1, %o0 2006544: 92 10 00 18 mov %i0, %o1 2006548: 40 00 1b 38 call 200d228 <_POSIX_signals_Clear_signals> 200654c: 98 10 20 00 clr %o4 _ISR_Enable( level ); 2006550: 7f ff f0 80 call 2002750 2006554: 90 10 00 10 mov %l0, %o0 the_info->si_signo = signo; the_info->si_code = SI_USER; 2006558: 82 10 20 01 mov 1, %g1 the_info->si_value.sival_int = 0; 200655c: c0 26 a0 08 clr [ %i2 + 8 ] if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); _ISR_Enable( level ); the_info->si_signo = signo; 2006560: f0 26 80 00 st %i0, [ %i2 ] the_info->si_code = SI_USER; 2006564: c2 26 a0 04 st %g1, [ %i2 + 4 ] 2006568: 81 c7 e0 08 ret 200656c: 81 e8 00 00 restore /* API signals pending? */ _ISR_Disable( level ); if ( *set & api->signals_pending ) { /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending ); 2006570: 7f ff ff 8d call 20063a4 <_POSIX_signals_Get_highest> 2006574: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( 2006578: 94 10 00 1a mov %i2, %o2 /* API signals pending? */ _ISR_Disable( level ); if ( *set & api->signals_pending ) { /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending ); 200657c: 92 10 00 08 mov %o0, %o1 _POSIX_signals_Clear_signals( 2006580: 96 10 20 00 clr %o3 2006584: 90 10 00 11 mov %l1, %o0 /* API signals pending? */ _ISR_Disable( level ); if ( *set & api->signals_pending ) { /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending ); 2006588: d2 26 80 00 st %o1, [ %i2 ] _POSIX_signals_Clear_signals( 200658c: 40 00 1b 27 call 200d228 <_POSIX_signals_Clear_signals> 2006590: 98 10 20 00 clr %o4 the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 2006594: 7f ff f0 6f call 2002750 2006598: 90 10 00 10 mov %l0, %o0 the_info->si_code = SI_USER; 200659c: 82 10 20 01 mov 1, %g1 the_info->si_value.sival_int = 0; 20065a0: c0 26 a0 08 clr [ %i2 + 8 ] return the_info->si_signo; 20065a4: f0 06 80 00 ld [ %i2 ], %i0 false, false ); _ISR_Enable( level ); the_info->si_code = SI_USER; 20065a8: c2 26 a0 04 st %g1, [ %i2 + 4 ] 20065ac: 81 c7 e0 08 ret 20065b0: 81 e8 00 00 restore rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 20065b4: 40 00 23 ce call 200f4ec <__errno> 20065b8: b0 10 3f ff mov -1, %i0 20065bc: 82 10 20 16 mov 0x16, %g1 20065c0: c2 22 00 00 st %g1, [ %o0 ] 20065c4: 81 c7 e0 08 ret 20065c8: 81 e8 00 00 restore =============================================================================== 02008398 : int sigwait( const sigset_t *set, int *sig ) { 2008398: 9d e3 bf 98 save %sp, -104, %sp int status; status = sigtimedwait( set, NULL, NULL ); 200839c: 92 10 20 00 clr %o1 20083a0: 90 10 00 18 mov %i0, %o0 20083a4: 7f ff ff 89 call 20081c8 20083a8: 94 10 20 00 clr %o2 if ( status != -1 ) { 20083ac: 80 a2 3f ff cmp %o0, -1 20083b0: 02 80 00 07 be 20083cc <== NEVER TAKEN 20083b4: 80 a6 60 00 cmp %i1, 0 if ( sig ) 20083b8: 02 80 00 03 be 20083c4 <== NEVER TAKEN 20083bc: b0 10 20 00 clr %i0 *sig = status; 20083c0: d0 26 40 00 st %o0, [ %i1 ] 20083c4: 81 c7 e0 08 ret 20083c8: 81 e8 00 00 restore return 0; } return errno; 20083cc: 40 00 23 fd call 20113c0 <__errno> <== NOT EXECUTED 20083d0: 01 00 00 00 nop <== NOT EXECUTED 20083d4: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED } 20083d8: 81 c7 e0 08 ret <== NOT EXECUTED 20083dc: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02005138 : */ long sysconf( int name ) { 2005138: 9d e3 bf 98 save %sp, -104, %sp switch (name) { 200513c: 80 a6 20 08 cmp %i0, 8 2005140: 02 80 00 10 be 2005180 2005144: 11 00 00 04 sethi %hi(0x1000), %o0 2005148: 80 a6 20 08 cmp %i0, 8 200514c: 04 80 00 0f ble 2005188 2005150: 80 a6 20 02 cmp %i0, 2 2005154: 80 a6 20 33 cmp %i0, 0x33 2005158: 02 80 00 0a be 2005180 200515c: 90 10 24 00 mov 0x400, %o0 2005160: 80 a6 22 03 cmp %i0, 0x203 2005164: 02 80 00 07 be 2005180 <== NEVER TAKEN 2005168: 90 10 20 00 clr %o0 default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 200516c: 40 00 23 ad call 200e020 <__errno> 2005170: 01 00 00 00 nop 2005174: 82 10 20 16 mov 0x16, %g1 ! 16 2005178: c2 22 00 00 st %g1, [ %o0 ] 200517c: 90 10 3f ff mov -1, %o0 } 2005180: 81 c7 e0 08 ret 2005184: 91 e8 00 08 restore %g0, %o0, %o0 long sysconf( int name ) { switch (name) { 2005188: 02 80 00 07 be 20051a4 200518c: 80 a6 20 04 cmp %i0, 4 2005190: 12 bf ff f7 bne 200516c 2005194: 03 00 80 54 sethi %hi(0x2015000), %g1 case _SC_CLK_TCK: return (TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick); case _SC_OPEN_MAX: { return rtems_libio_number_iops; 2005198: d0 00 60 48 ld [ %g1 + 0x48 ], %o0 ! 2015048 default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 200519c: 81 c7 e0 08 ret 20051a0: 91 e8 00 08 restore %g0, %o0, %o0 ) { switch (name) { case _SC_CLK_TCK: return (TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick); 20051a4: 03 00 80 58 sethi %hi(0x2016000), %g1 20051a8: d2 00 60 90 ld [ %g1 + 0x90 ], %o1 ! 2016090 <_TOD_Microseconds_per_tick> 20051ac: 11 00 03 d0 sethi %hi(0xf4000), %o0 20051b0: 40 00 32 62 call 2011b38 <.udiv> 20051b4: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 20051b8: 81 c7 e0 08 ret 20051bc: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 0200ab30 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 200ab30: 9d e3 bf 98 save %sp, -104, %sp POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 200ab34: 80 a6 20 01 cmp %i0, 1 200ab38: 12 80 00 3f bne 200ac34 200ab3c: 80 a6 a0 00 cmp %i2, 0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 200ab40: 02 80 00 3d be 200ac34 200ab44: 80 a6 60 00 cmp %i1, 0 /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 200ab48: 02 80 00 0e be 200ab80 200ab4c: 05 00 80 8a sethi %hi(0x2022800), %g2 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 200ab50: c2 06 40 00 ld [ %i1 ], %g1 200ab54: 82 00 7f ff add %g1, -1, %g1 200ab58: 80 a0 60 01 cmp %g1, 1 200ab5c: 18 80 00 36 bgu 200ac34 <== NEVER TAKEN 200ab60: 01 00 00 00 nop ( evp->sigev_notify != SIGEV_SIGNAL ) ) { /* The value of the field sigev_notify is not valid */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !evp->sigev_signo ) 200ab64: c2 06 60 04 ld [ %i1 + 4 ], %g1 200ab68: 80 a0 60 00 cmp %g1, 0 200ab6c: 02 80 00 32 be 200ac34 <== NEVER TAKEN 200ab70: 82 00 7f ff add %g1, -1, %g1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 200ab74: 80 a0 60 1f cmp %g1, 0x1f 200ab78: 18 80 00 2f bgu 200ac34 <== NEVER TAKEN 200ab7c: 01 00 00 00 nop 200ab80: c2 00 a3 00 ld [ %g2 + 0x300 ], %g1 200ab84: 82 00 60 01 inc %g1 200ab88: c2 20 a3 00 st %g1, [ %g2 + 0x300 ] * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void ) { return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information ); 200ab8c: 31 00 80 8b sethi %hi(0x2022c00), %i0 200ab90: 40 00 08 46 call 200cca8 <_Objects_Allocate> 200ab94: 90 16 22 50 or %i0, 0x250, %o0 ! 2022e50 <_POSIX_Timer_Information> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 200ab98: 80 a2 20 00 cmp %o0, 0 200ab9c: 02 80 00 2c be 200ac4c 200aba0: 82 10 20 02 mov 2, %g1 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; ptimer->thread_id = _Thread_Executing->Object.id; 200aba4: 05 00 80 8a sethi %hi(0x2022800), %g2 rtems_set_errno_and_return_minus_one( EAGAIN ); } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 200aba8: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ] ptimer->thread_id = _Thread_Executing->Object.id; 200abac: c6 00 a3 c4 ld [ %g2 + 0x3c4 ], %g3 if ( evp != NULL ) { 200abb0: 80 a6 60 00 cmp %i1, 0 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; ptimer->thread_id = _Thread_Executing->Object.id; 200abb4: c2 00 e0 08 ld [ %g3 + 8 ], %g1 if ( evp != NULL ) { 200abb8: 02 80 00 08 be 200abd8 200abbc: c2 22 20 38 st %g1, [ %o0 + 0x38 ] ptimer->inf.sigev_notify = evp->sigev_notify; ptimer->inf.sigev_signo = evp->sigev_signo; ptimer->inf.sigev_value = evp->sigev_value; 200abc0: c2 06 60 08 ld [ %i1 + 8 ], %g1 ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; ptimer->thread_id = _Thread_Executing->Object.id; if ( evp != NULL ) { ptimer->inf.sigev_notify = evp->sigev_notify; 200abc4: c4 06 40 00 ld [ %i1 ], %g2 ptimer->inf.sigev_signo = evp->sigev_signo; 200abc8: c6 06 60 04 ld [ %i1 + 4 ], %g3 ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; ptimer->thread_id = _Thread_Executing->Object.id; if ( evp != NULL ) { ptimer->inf.sigev_notify = evp->sigev_notify; 200abcc: c4 22 20 40 st %g2, [ %o0 + 0x40 ] ptimer->inf.sigev_signo = evp->sigev_signo; 200abd0: c6 22 20 44 st %g3, [ %o0 + 0x44 ] ptimer->inf.sigev_value = evp->sigev_value; 200abd4: c2 22 20 48 st %g1, [ %o0 + 0x48 ] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 200abd8: c6 02 20 08 ld [ %o0 + 8 ], %g3 200abdc: 82 16 22 50 or %i0, 0x250, %g1 200abe0: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 200abe4: 03 00 00 3f sethi %hi(0xfc00), %g1 200abe8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200abec: 82 08 c0 01 and %g3, %g1, %g1 200abf0: 83 28 60 02 sll %g1, 2, %g1 200abf4: d0 20 80 01 st %o0, [ %g2 + %g1 ] _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == FALSE */ the_object->name.name_u32 = name; 200abf8: c0 22 20 0c clr [ %o0 + 0xc ] } ptimer->overrun = 0; 200abfc: c0 22 20 68 clr [ %o0 + 0x68 ] ptimer->timer_data.it_value.tv_sec = 0; 200ac00: c0 22 20 5c clr [ %o0 + 0x5c ] ptimer->timer_data.it_value.tv_nsec = 0; 200ac04: c0 22 20 60 clr [ %o0 + 0x60 ] ptimer->timer_data.it_interval.tv_sec = 0; 200ac08: c0 22 20 54 clr [ %o0 + 0x54 ] ptimer->timer_data.it_interval.tv_nsec = 0; 200ac0c: c0 22 20 58 clr [ %o0 + 0x58 ] void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200ac10: c0 22 20 30 clr [ %o0 + 0x30 ] _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; 200ac14: c6 26 80 00 st %g3, [ %i2 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200ac18: c0 22 20 18 clr [ %o0 + 0x18 ] the_watchdog->routine = routine; 200ac1c: c0 22 20 2c clr [ %o0 + 0x2c ] the_watchdog->id = id; the_watchdog->user_data = user_data; 200ac20: c0 22 20 34 clr [ %o0 + 0x34 ] _Thread_Enable_dispatch(); 200ac24: 40 00 0c 0a call 200dc4c <_Thread_Enable_dispatch> 200ac28: b0 10 20 00 clr %i0 return 0; } 200ac2c: 81 c7 e0 08 ret 200ac30: 81 e8 00 00 restore if ( !evp->sigev_signo ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 200ac34: 40 00 25 c2 call 201433c <__errno> 200ac38: b0 10 3f ff mov -1, %i0 200ac3c: 82 10 20 16 mov 0x16, %g1 200ac40: c2 22 00 00 st %g1, [ %o0 ] 200ac44: 81 c7 e0 08 ret 200ac48: 81 e8 00 00 restore /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { _Thread_Enable_dispatch(); 200ac4c: 40 00 0c 00 call 200dc4c <_Thread_Enable_dispatch> 200ac50: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one( EAGAIN ); 200ac54: 40 00 25 ba call 201433c <__errno> 200ac58: 01 00 00 00 nop 200ac5c: 82 10 20 0b mov 0xb, %g1 ! b 200ac60: c2 22 00 00 st %g1, [ %o0 ] 200ac64: 81 c7 e0 08 ret 200ac68: 81 e8 00 00 restore =============================================================================== 02006f40 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 2006f40: 9d e3 bf 80 save %sp, -128, %sp Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 2006f44: 80 a6 a0 00 cmp %i2, 0 2006f48: 02 80 00 54 be 2007098 <== NEVER TAKEN 2006f4c: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 rtems_set_errno_and_return_minus_one( EINVAL ); /* First, it verifies if the structure "value" is correct */ if ( ( value->it_value.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) || 2006f50: c4 06 a0 0c ld [ %i2 + 0xc ], %g2 2006f54: 82 10 61 ff or %g1, 0x1ff, %g1 2006f58: 80 a0 80 01 cmp %g2, %g1 2006f5c: 18 80 00 4f bgu 2007098 2006f60: 01 00 00 00 nop 2006f64: c4 06 a0 04 ld [ %i2 + 4 ], %g2 2006f68: 80 a0 80 01 cmp %g2, %g1 2006f6c: 18 80 00 4b bgu 2007098 <== NEVER TAKEN 2006f70: 80 a0 a0 00 cmp %g2, 0 2006f74: 06 80 00 49 bl 2007098 <== NEVER TAKEN 2006f78: 80 a6 60 04 cmp %i1, 4 ( value->it_interval.tv_nsec < 0 )) { /* The number of nanoseconds is not correct */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 2006f7c: 02 80 00 04 be 2006f8c 2006f80: 80 a6 60 00 cmp %i1, 0 2006f84: 12 80 00 45 bne 2007098 2006f88: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 2006f8c: c2 06 80 00 ld [ %i2 ], %g1 2006f90: c4 06 a0 04 ld [ %i2 + 4 ], %g2 2006f94: c6 06 a0 08 ld [ %i2 + 8 ], %g3 2006f98: c8 06 a0 0c ld [ %i2 + 0xc ], %g4 2006f9c: c2 27 bf e4 st %g1, [ %fp + -28 ] 2006fa0: c4 27 bf e8 st %g2, [ %fp + -24 ] 2006fa4: c6 27 bf ec st %g3, [ %fp + -20 ] /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 2006fa8: 80 a6 60 04 cmp %i1, 4 2006fac: 02 80 00 5c be 200711c 2006fb0: c8 27 bf f0 st %g4, [ %fp + -16 ] 2006fb4: 92 10 00 18 mov %i0, %o1 2006fb8: 11 00 80 75 sethi %hi(0x201d400), %o0 2006fbc: 94 07 bf f4 add %fp, -12, %o2 2006fc0: 40 00 09 1f call 200943c <_Objects_Get> 2006fc4: 90 12 20 30 or %o0, 0x30, %o0 * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 2006fc8: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006fcc: 80 a0 60 00 cmp %g1, 0 2006fd0: 12 80 00 67 bne 200716c <== NEVER TAKEN 2006fd4: b2 10 00 08 mov %o0, %i1 case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { 2006fd8: c2 07 bf ec ld [ %fp + -20 ], %g1 2006fdc: 80 a0 60 00 cmp %g1, 0 2006fe0: 12 80 00 05 bne 2006ff4 2006fe4: c2 07 bf f0 ld [ %fp + -16 ], %g1 2006fe8: 80 a0 60 00 cmp %g1, 0 2006fec: 02 80 00 31 be 20070b0 <== ALWAYS TAKEN 2006ff0: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 2006ff4: 40 00 0f 8b call 200ae20 <_Timespec_To_ticks> 2006ff8: 90 10 00 1a mov %i2, %o0 2006ffc: d0 26 60 64 st %o0, [ %i1 + 0x64 ] initial_period = _Timespec_To_ticks( &normalize.it_value ); 2007000: 40 00 0f 88 call 200ae20 <_Timespec_To_ticks> 2007004: 90 07 bf ec add %fp, -20, %o0 activated = _POSIX_Timer_Insert_helper( 2007008: d4 06 60 08 ld [ %i1 + 8 ], %o2 return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); initial_period = _Timespec_To_ticks( &normalize.it_value ); 200700c: 92 10 00 08 mov %o0, %o1 activated = _POSIX_Timer_Insert_helper( 2007010: 17 00 80 1c sethi %hi(0x2007000), %o3 2007014: 90 06 60 10 add %i1, 0x10, %o0 2007018: 96 12 e1 84 or %o3, 0x184, %o3 200701c: 40 00 1c 2b call 200e0c8 <_POSIX_Timer_Insert_helper> 2007020: 98 10 00 19 mov %i1, %o4 initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 2007024: 80 8a 20 ff btst 0xff, %o0 2007028: 02 80 00 18 be 2007088 <== NEVER TAKEN 200702c: 80 a6 e0 00 cmp %i3, 0 /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 2007030: 02 80 00 0b be 200705c 2007034: c2 07 bf e4 ld [ %fp + -28 ], %g1 *ovalue = ptimer->timer_data; 2007038: c2 06 60 54 ld [ %i1 + 0x54 ], %g1 200703c: c2 26 c0 00 st %g1, [ %i3 ] 2007040: c4 06 60 58 ld [ %i1 + 0x58 ], %g2 2007044: c4 26 e0 04 st %g2, [ %i3 + 4 ] 2007048: c2 06 60 5c ld [ %i1 + 0x5c ], %g1 200704c: c2 26 e0 08 st %g1, [ %i3 + 8 ] 2007050: c4 06 60 60 ld [ %i1 + 0x60 ], %g2 2007054: c4 26 e0 0c st %g2, [ %i3 + 0xc ] ptimer->timer_data = normalize; 2007058: c2 07 bf e4 ld [ %fp + -28 ], %g1 /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; _TOD_Get( &ptimer->time ); 200705c: 90 06 60 6c add %i1, 0x6c, %o0 * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) *ovalue = ptimer->timer_data; ptimer->timer_data = normalize; 2007060: c2 26 60 54 st %g1, [ %i1 + 0x54 ] 2007064: c4 07 bf e8 ld [ %fp + -24 ], %g2 2007068: c4 26 60 58 st %g2, [ %i1 + 0x58 ] 200706c: c2 07 bf ec ld [ %fp + -20 ], %g1 2007070: c2 26 60 5c st %g1, [ %i1 + 0x5c ] 2007074: c4 07 bf f0 ld [ %fp + -16 ], %g2 /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 2007078: 82 10 20 03 mov 3, %g1 * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) *ovalue = ptimer->timer_data; ptimer->timer_data = normalize; 200707c: c4 26 60 60 st %g2, [ %i1 + 0x60 ] /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; _TOD_Get( &ptimer->time ); 2007080: 40 00 06 80 call 2008a80 <_TOD_Get> 2007084: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] _Thread_Enable_dispatch(); 2007088: 40 00 0b 42 call 2009d90 <_Thread_Enable_dispatch> 200708c: b0 10 20 00 clr %i0 2007090: 81 c7 e0 08 ret 2007094: 81 e8 00 00 restore /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { /* Check for seconds in the past */ if ( _Timespec_Greater_than( &_TOD_Now, &normalize.it_value ) ) rtems_set_errno_and_return_minus_one( EINVAL ); 2007098: 40 00 23 fd call 201008c <__errno> 200709c: b0 10 3f ff mov -1, %i0 20070a0: 82 10 20 16 mov 0x16, %g1 20070a4: c2 22 00 00 st %g1, [ %o0 ] 20070a8: 81 c7 e0 08 ret 20070ac: 81 e8 00 00 restore case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 20070b0: 40 00 10 ac call 200b360 <_Watchdog_Remove> 20070b4: 90 02 20 10 add %o0, 0x10, %o0 /* The old data of the timer are returned */ if ( ovalue ) 20070b8: 80 a6 e0 00 cmp %i3, 0 20070bc: 02 80 00 0b be 20070e8 <== ALWAYS TAKEN 20070c0: c2 07 bf e4 ld [ %fp + -28 ], %g1 *ovalue = ptimer->timer_data; 20070c4: c2 06 60 54 ld [ %i1 + 0x54 ], %g1 <== NOT EXECUTED 20070c8: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED 20070cc: c4 06 60 58 ld [ %i1 + 0x58 ], %g2 <== NOT EXECUTED 20070d0: c4 26 e0 04 st %g2, [ %i3 + 4 ] <== NOT EXECUTED 20070d4: c2 06 60 5c ld [ %i1 + 0x5c ], %g1 <== NOT EXECUTED 20070d8: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED 20070dc: c4 06 60 60 ld [ %i1 + 0x60 ], %g2 <== NOT EXECUTED 20070e0: c4 26 e0 0c st %g2, [ %i3 + 0xc ] <== NOT EXECUTED /* The new data are set */ ptimer->timer_data = normalize; 20070e4: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; /* Returns with success */ _Thread_Enable_dispatch(); 20070e8: b0 10 20 00 clr %i0 (void) _Watchdog_Remove( &ptimer->Timer ); /* The old data of the timer are returned */ if ( ovalue ) *ovalue = ptimer->timer_data; /* The new data are set */ ptimer->timer_data = normalize; 20070ec: c2 26 60 54 st %g1, [ %i1 + 0x54 ] 20070f0: c4 07 bf e8 ld [ %fp + -24 ], %g2 20070f4: c4 26 60 58 st %g2, [ %i1 + 0x58 ] 20070f8: c2 07 bf ec ld [ %fp + -20 ], %g1 20070fc: c2 26 60 5c st %g1, [ %i1 + 0x5c ] 2007100: c4 07 bf f0 ld [ %fp + -16 ], %g2 /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 2007104: 82 10 20 04 mov 4, %g1 (void) _Watchdog_Remove( &ptimer->Timer ); /* The old data of the timer are returned */ if ( ovalue ) *ovalue = ptimer->timer_data; /* The new data are set */ ptimer->timer_data = normalize; 2007108: c4 26 60 60 st %g2, [ %i1 + 0x60 ] /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; /* Returns with success */ _Thread_Enable_dispatch(); 200710c: 40 00 0b 21 call 2009d90 <_Thread_Enable_dispatch> 2007110: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] 2007114: 81 c7 e0 08 ret 2007118: 81 e8 00 00 restore normalize = *value; /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { /* Check for seconds in the past */ if ( _Timespec_Greater_than( &_TOD_Now, &normalize.it_value ) ) 200711c: b2 07 bf ec add %fp, -20, %i1 2007120: 21 00 80 74 sethi %hi(0x201d000), %l0 2007124: 92 10 00 19 mov %i1, %o1 2007128: 40 00 0f 16 call 200ad80 <_Timespec_Greater_than> 200712c: 90 14 21 74 or %l0, 0x174, %o0 2007130: 80 8a 20 ff btst 0xff, %o0 2007134: 12 bf ff d9 bne 2007098 2007138: 92 10 00 19 mov %i1, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &_TOD_Now, &normalize.it_value, &normalize.it_value ); 200713c: 94 10 00 19 mov %i1, %o2 2007140: 40 00 0f 22 call 200adc8 <_Timespec_Subtract> 2007144: 90 14 21 74 or %l0, 0x174, %o0 2007148: 92 10 00 18 mov %i0, %o1 200714c: 11 00 80 75 sethi %hi(0x201d400), %o0 2007150: 94 07 bf f4 add %fp, -12, %o2 2007154: 40 00 08 ba call 200943c <_Objects_Get> 2007158: 90 12 20 30 or %o0, 0x30, %o0 * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 200715c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007160: 80 a0 60 00 cmp %g1, 0 2007164: 02 bf ff 9d be 2006fd8 <== ALWAYS TAKEN 2007168: b2 10 00 08 mov %o0, %i1 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 200716c: 40 00 23 c8 call 201008c <__errno> <== NOT EXECUTED 2007170: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2007174: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2007178: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 200717c: 81 c7 e0 08 ret <== NOT EXECUTED 2007180: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 02005468 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 2005468: 9d e3 bf 90 save %sp, -112, %sp /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 200546c: 03 00 80 59 sethi %hi(0x2016400), %g1 2005470: a2 10 60 64 or %g1, 0x64, %l1 ! 2016464 <_POSIX_signals_Ualarm_timer> 2005474: c4 04 60 1c ld [ %l1 + 0x1c ], %g2 2005478: 80 a0 a0 00 cmp %g2, 0 200547c: 02 80 00 3c be 200556c 2005480: a4 10 00 18 mov %i0, %l2 _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 2005484: 40 00 10 dd call 20097f8 <_Watchdog_Remove> 2005488: 90 10 00 11 mov %l1, %o0 200548c: 90 02 3f fe add %o0, -2, %o0 2005490: 80 a2 20 01 cmp %o0, 1 2005494: 08 80 00 07 bleu 20054b0 <== ALWAYS TAKEN 2005498: b0 10 20 00 clr %i0 /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 200549c: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 20054a0: 12 80 00 1a bne 2005508 <== NOT EXECUTED 20054a4: 21 00 03 d0 sethi %hi(0xf4000), %l0 <== NOT EXECUTED _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); } return remaining; } 20054a8: 81 c7 e0 08 ret 20054ac: 81 e8 00 00 restore * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 20054b0: c2 04 60 0c ld [ %l1 + 0xc ], %g1 /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 20054b4: c4 04 60 18 ld [ %l1 + 0x18 ], %g2 * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 20054b8: d0 04 60 14 ld [ %l1 + 0x14 ], %o0 /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 20054bc: 92 07 bf f0 add %fp, -16, %o1 * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 20054c0: 90 02 00 01 add %o0, %g1, %o0 /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 20054c4: 40 00 0f 31 call 2009188 <_Timespec_From_ticks> 20054c8: 90 22 00 02 sub %o0, %g2, %o0 remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 20054cc: c4 07 bf f0 ld [ %fp + -16 ], %g2 remaining += tp.tv_nsec / 1000; 20054d0: d0 07 bf f4 ld [ %fp + -12 ], %o0 ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 20054d4: 87 28 a0 03 sll %g2, 3, %g3 20054d8: 83 28 a0 08 sll %g2, 8, %g1 20054dc: 82 20 40 03 sub %g1, %g3, %g1 remaining += tp.tv_nsec / 1000; 20054e0: 92 10 23 e8 mov 0x3e8, %o1 ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 20054e4: a1 28 60 06 sll %g1, 6, %l0 20054e8: a0 24 00 01 sub %l0, %g1, %l0 remaining += tp.tv_nsec / 1000; 20054ec: 40 00 35 50 call 2012a2c <.div> 20054f0: a0 04 00 02 add %l0, %g2, %l0 ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 20054f4: a1 2c 20 06 sll %l0, 6, %l0 /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 20054f8: 80 a4 a0 00 cmp %l2, 0 20054fc: 02 bf ff eb be 20054a8 <== ALWAYS TAKEN 2005500: b0 02 00 10 add %o0, %l0, %i0 Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 2005504: 21 00 03 d0 sethi %hi(0xf4000), %l0 <== NOT EXECUTED 2005508: 90 10 00 12 mov %l2, %o0 200550c: 40 00 35 46 call 2012a24 <.udiv> 2005510: 92 14 22 40 or %l0, 0x240, %o1 tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 2005514: 92 14 22 40 or %l0, 0x240, %o1 * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 2005518: d0 27 bf f0 st %o0, [ %fp + -16 ] tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 200551c: 40 00 35 ee call 2012cd4 <.urem> 2005520: 90 10 00 12 mov %l2, %o0 2005524: 85 2a 20 02 sll %o0, 2, %g2 2005528: 83 2a 20 07 sll %o0, 7, %g1 200552c: 82 20 40 02 sub %g1, %g2, %g1 2005530: 82 00 40 08 add %g1, %o0, %g1 2005534: 83 28 60 03 sll %g1, 3, %g1 ticks = _Timespec_To_ticks( &tp ); 2005538: a0 07 bf f0 add %fp, -16, %l0 */ if ( useconds ) { Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 200553c: c2 27 bf f4 st %g1, [ %fp + -12 ] ticks = _Timespec_To_ticks( &tp ); 2005540: 40 00 0f 3d call 2009234 <_Timespec_To_ticks> 2005544: 90 10 00 10 mov %l0, %o0 if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 2005548: 40 00 0f 3b call 2009234 <_Timespec_To_ticks> 200554c: 90 10 00 10 mov %l0, %o0 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2005550: 92 10 00 11 mov %l1, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2005554: d0 24 60 0c st %o0, [ %l1 + 0xc ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2005558: 11 00 80 59 sethi %hi(0x2016400), %o0 200555c: 40 00 10 3c call 200964c <_Watchdog_Insert> 2005560: 90 12 22 a4 or %o0, 0x2a4, %o0 ! 20166a4 <_Watchdog_Ticks_chain> } return remaining; } 2005564: 81 c7 e0 08 ret 2005568: 81 e8 00 00 restore Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 200556c: 03 00 80 15 sethi %hi(0x2005400), %g1 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2005570: c0 24 60 08 clr [ %l1 + 8 ] the_watchdog->routine = routine; 2005574: 82 10 61 98 or %g1, 0x198, %g1 the_watchdog->id = id; 2005578: c0 24 60 20 clr [ %l1 + 0x20 ] the_watchdog->user_data = user_data; 200557c: c0 24 60 24 clr [ %l1 + 0x24 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2005580: c2 24 60 1c st %g1, [ %l1 + 0x1c ] /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 2005584: 80 a4 a0 00 cmp %l2, 0 2005588: 02 bf ff c8 be 20054a8 <== NEVER TAKEN 200558c: b0 10 20 00 clr %i0 Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 2005590: 10 bf ff de b 2005508 2005594: 21 00 03 d0 sethi %hi(0xf4000), %l0