40026518 : assert( 0 ); return 0; } int POSIX_BOTTOM_REACHED() { 40026518: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 4002651c: 92 10 20 22 mov 0x22, %o1 <== NOT EXECUTED 40026520: 11 10 00 a8 sethi %hi(0x4002a000), %o0 <== NOT EXECUTED 40026524: 15 10 00 9a sethi %hi(0x40026800), %o2 <== NOT EXECUTED 40026528: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED 4002652c: 94 12 a1 80 or %o2, 0x180, %o2 <== NOT EXECUTED 40026530: 7f ff 89 20 call 400089b0 <__assert> <== NOT EXECUTED 40026534: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 40026538: 81 c7 e0 08 ret <== NOT EXECUTED 4002653c: 81 e8 00 00 restore <== NOT EXECUTED 40026540 : */ #include int POSIX_MP_NOT_IMPLEMENTED() { 40026540: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 40026544: 92 10 20 1c mov 0x1c, %o1 <== NOT EXECUTED 40026548: 11 10 00 a8 sethi %hi(0x4002a000), %o0 <== NOT EXECUTED 4002654c: 15 10 00 9a sethi %hi(0x40026800), %o2 <== NOT EXECUTED 40026550: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED 40026554: 94 12 a1 80 or %o2, 0x180, %o2 <== NOT EXECUTED 40026558: 7f ff 89 16 call 400089b0 <__assert> <== NOT EXECUTED 4002655c: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 40026560: 81 c7 e0 08 ret <== NOT EXECUTED 40026564: 81 e8 00 00 restore <== NOT EXECUTED 400264f0 : assert( 0 ); return 0; } int POSIX_NOT_IMPLEMENTED() { 400264f0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 400264f4: 92 10 20 28 mov 0x28, %o1 <== NOT EXECUTED 400264f8: 11 10 00 a8 sethi %hi(0x4002a000), %o0 <== NOT EXECUTED 400264fc: 15 10 00 9a sethi %hi(0x40026800), %o2 <== NOT EXECUTED 40026500: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED 40026504: 94 12 a1 80 or %o2, 0x180, %o2 <== NOT EXECUTED 40026508: 7f ff 89 2a call 400089b0 <__assert> <== NOT EXECUTED 4002650c: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 40026510: 81 c7 e0 08 ret <== NOT EXECUTED 40026514: 81 e8 00 00 restore <== NOT EXECUTED 40006c64 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 40006c64: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 40006c68: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006c6c: e0 00 61 f0 ld [ %g1 + 0x1f0 ], %l0 ! 4001adf0 <_API_extensions_List> 40006c70: 82 10 61 f0 or %g1, 0x1f0, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40006c74: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 40006c78: 80 a4 00 11 cmp %l0, %l1 40006c7c: 02 80 00 0c be 40006cac <_API_extensions_Run_postdriver+0x48> 40006c80: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 40006c84: c2 04 20 0c ld [ %l0 + 0xc ], %g1 40006c88: 80 a0 60 00 cmp %g1, 0 40006c8c: 22 80 00 05 be,a 40006ca0 <_API_extensions_Run_postdriver+0x3c> 40006c90: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postdriver_hook)(); 40006c94: 9f c0 40 00 call %g1 40006c98: 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 ) { 40006c9c: 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 ) ; 40006ca0: 80 a4 00 11 cmp %l0, %l1 40006ca4: 32 bf ff f9 bne,a 40006c88 <_API_extensions_Run_postdriver+0x24> 40006ca8: c2 04 20 0c ld [ %l0 + 0xc ], %g1 40006cac: 81 c7 e0 08 ret 40006cb0: 81 e8 00 00 restore 40006d20 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 40006d20: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 40006d24: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006d28: e0 00 61 f0 ld [ %g1 + 0x1f0 ], %l0 ! 4001adf0 <_API_extensions_List> 40006d2c: 82 10 61 f0 or %g1, 0x1f0, %g1 40006d30: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 40006d34: 80 a4 00 11 cmp %l0, %l1 40006d38: 02 80 00 0c be 40006d68 <_API_extensions_Run_postswitch+0x48> 40006d3c: 25 10 00 6b sethi %hi(0x4001ac00), %l2 the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 40006d40: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 40006d44: 80 a0 60 00 cmp %g1, 0 40006d48: 22 80 00 05 be,a 40006d5c <_API_extensions_Run_postswitch+0x3c> 40006d4c: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 40006d50: 9f c0 40 00 call %g1 40006d54: d0 04 a0 3c ld [ %l2 + 0x3c ], %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 ) { 40006d58: 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 ) ; 40006d5c: 80 a4 00 11 cmp %l0, %l1 40006d60: 32 bf ff f9 bne,a 40006d44 <_API_extensions_Run_postswitch+0x24> 40006d64: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 40006d68: 81 c7 e0 08 ret 40006d6c: 81 e8 00 00 restore 40006cd0 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 40006cd0: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 40006cd4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006cd8: e0 00 61 f0 ld [ %g1 + 0x1f0 ], %l0 ! 4001adf0 <_API_extensions_List> 40006cdc: 82 10 61 f0 or %g1, 0x1f0, %g1 40006ce0: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 40006ce4: 80 a4 00 11 cmp %l0, %l1 40006ce8: 02 80 00 0c be 40006d18 <_API_extensions_Run_predriver+0x48> 40006cec: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 40006cf0: c2 04 20 08 ld [ %l0 + 8 ], %g1 40006cf4: 80 a0 60 00 cmp %g1, 0 40006cf8: 22 80 00 05 be,a 40006d0c <_API_extensions_Run_predriver+0x3c> 40006cfc: e0 04 00 00 ld [ %l0 ], %l0 (*the_extension->predriver_hook)(); 40006d00: 9f c0 40 00 call %g1 <== NOT EXECUTED 40006d04: 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 ) { 40006d08: 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 ) ; 40006d0c: 80 a4 00 11 cmp %l0, %l1 40006d10: 32 bf ff f9 bne,a 40006cf4 <_API_extensions_Run_predriver+0x24> 40006d14: c2 04 20 08 ld [ %l0 + 8 ], %g1 40006d18: 81 c7 e0 08 ret 40006d1c: 81 e8 00 00 restore 400091f4 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 400091f4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing = _Thread_Executing; 400091f8: 03 10 00 76 sethi %hi(0x4001d800), %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 ); 400091fc: 7f ff e6 dd call 40002d70 40009200: e0 00 60 ac ld [ %g1 + 0xac ], %l0 ! 4001d8ac <_Thread_Executing> 40009204: 84 10 00 08 mov %o0, %g2 switch ( the_rwlock->current_state ) { 40009208: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 4000920c: 80 a0 60 01 cmp %g1, 1 40009210: 22 80 00 2d be,a 400092c4 <_CORE_RWLock_Release+0xd0> 40009214: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 40009218: 0a 80 00 24 bcs 400092a8 <_CORE_RWLock_Release+0xb4> 4000921c: 80 a0 60 02 cmp %g1, 2 40009220: 22 80 00 02 be,a 40009228 <_CORE_RWLock_Release+0x34> 40009224: 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; 40009228: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 4000922c: 7f ff e6 d5 call 40002d80 40009230: 90 10 00 02 mov %g2, %o0 next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 40009234: 40 00 09 93 call 4000b880 <_Thread_queue_Dequeue> 40009238: 90 10 00 18 mov %i0, %o0 if ( next ) { 4000923c: 80 a2 20 00 cmp %o0, 0 40009240: 22 80 00 1f be,a 400092bc <_CORE_RWLock_Release+0xc8> 40009244: b0 10 20 00 clr %i0 if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 40009248: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 4000924c: 80 a0 60 01 cmp %g1, 1 40009250: 02 80 00 26 be 400092e8 <_CORE_RWLock_Release+0xf4> 40009254: 84 10 20 01 mov 1, %g2 } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 40009258: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 4000925c: 82 00 60 01 inc %g1 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 40009260: c4 26 20 44 st %g2, [ %i0 + 0x44 ] } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 40009264: 10 80 00 0a b 4000928c <_CORE_RWLock_Release+0x98> 40009268: 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 || 4000926c: 80 a0 60 01 cmp %g1, 1 40009270: 02 80 00 12 be 400092b8 <_CORE_RWLock_Release+0xc4> 40009274: 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; 40009278: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 4000927c: 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; 40009280: 82 00 60 01 inc %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 40009284: 40 00 0a cd call 4000bdb8 <_Thread_queue_Extract> 40009288: 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 ); 4000928c: 40 00 0b 3b call 4000bf78 <_Thread_queue_First> 40009290: 90 10 00 18 mov %i0, %o0 if ( !next || 40009294: 80 a2 20 00 cmp %o0, 0 40009298: 32 bf ff f5 bne,a 4000926c <_CORE_RWLock_Release+0x78> 4000929c: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 } } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 400092a0: 81 c7 e0 08 ret 400092a4: 91 e8 20 00 restore %g0, 0, %o0 */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { case CORE_RWLOCK_UNLOCKED: _ISR_Enable( level ); 400092a8: 7f ff e6 b6 call 40002d80 <== NOT EXECUTED 400092ac: 01 00 00 00 nop <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 400092b0: 82 10 20 02 mov 2, %g1 ! 2 <== NOT EXECUTED 400092b4: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED } } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 400092b8: b0 10 20 00 clr %i0 <== NOT EXECUTED 400092bc: 81 c7 e0 08 ret 400092c0: 81 e8 00 00 restore _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; case CORE_RWLOCK_LOCKED_FOR_READING: the_rwlock->number_of_readers -= 1; 400092c4: 82 00 7f ff add %g1, -1, %g1 if ( the_rwlock->number_of_readers != 0 ) { 400092c8: 80 a0 60 00 cmp %g1, 0 400092cc: 12 80 00 04 bne 400092dc <_CORE_RWLock_Release+0xe8> 400092d0: c2 26 20 48 st %g1, [ %i0 + 0x48 ] return CORE_RWLOCK_SUCCESSFUL; } executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; break; case CORE_RWLOCK_LOCKED_FOR_WRITING: executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 400092d4: 10 bf ff d5 b 40009228 <_CORE_RWLock_Release+0x34> 400092d8: c0 24 20 34 clr [ %l0 + 0x34 ] case CORE_RWLOCK_LOCKED_FOR_READING: the_rwlock->number_of_readers -= 1; if ( the_rwlock->number_of_readers != 0 ) { /* must be unlocked again */ _ISR_Enable( level ); 400092dc: 7f ff e6 a9 call 40002d80 400092e0: b0 10 20 00 clr %i0 400092e4: 30 bf ff f6 b,a 400092bc <_CORE_RWLock_Release+0xc8> 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; 400092e8: 82 10 20 02 mov 2, %g1 400092ec: c2 26 20 44 st %g1, [ %i0 + 0x44 ] } } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 400092f0: 81 c7 e0 08 ret 400092f4: 91 e8 20 00 restore %g0, 0, %o0 400092f8 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 400092f8: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 400092fc: 92 96 20 00 orcc %i0, 0, %o1 40009300: 12 80 00 1a bne 40009368 <_CORE_RWLock_Timeout+0x70> 40009304: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009308: 31 10 00 75 sethi %hi(0x4001d400), %i0 <== NOT EXECUTED 4000930c: c2 06 23 d0 ld [ %i0 + 0x3d0 ], %g1 ! 4001d7d0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009310: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009314: c2 26 23 d0 st %g1, [ %i0 + 0x3d0 ] <== NOT EXECUTED 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; 40009318: 03 10 00 76 sethi %hi(0x4001d800), %g1 <== NOT EXECUTED 4000931c: d2 00 60 ac ld [ %g1 + 0xac ], %o1 ! 4001d8ac <_Thread_Executing> <== NOT EXECUTED 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; 40009320: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED */ static inline void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 40009324: d0 02 60 44 ld [ %o1 + 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_QUEUE_SYNCHRONIZED && 40009328: c6 02 20 30 ld [ %o0 + 0x30 ], %g3 4000932c: 80 a0 e0 00 cmp %g3, 0 40009330: 02 80 00 06 be 40009348 <_CORE_RWLock_Timeout+0x50> 40009334: 03 10 00 76 sethi %hi(0x4001d800), %g1 40009338: c4 00 60 ac ld [ %g1 + 0xac ], %g2 ! 4001d8ac <_Thread_Executing> <== NOT EXECUTED 4000933c: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED 40009340: 02 80 00 20 be 400093c0 <_CORE_RWLock_Timeout+0xc8> <== NOT EXECUTED 40009344: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 40009348: c2 02 20 3c ld [ %o0 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 4000934c: 40 00 0a 9b call 4000bdb8 <_Thread_queue_Extract> 40009350: c2 22 60 34 st %g1, [ %o1 + 0x34 ] */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 40009354: c2 06 23 d0 ld [ %i0 + 0x3d0 ], %g1 40009358: 82 00 7f ff add %g1, -1, %g1 4000935c: c2 26 23 d0 st %g1, [ %i0 + 0x3d0 ] 40009360: 81 c7 e0 08 ret 40009364: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40009368: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 4000936c: 80 a0 a0 04 cmp %g2, 4 40009370: 18 bf ff fc bgu 40009360 <_CORE_RWLock_Timeout+0x68> 40009374: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40009378: 80 a0 60 01 cmp %g1, 1 4000937c: 12 bf ff f9 bne 40009360 <_CORE_RWLock_Timeout+0x68> 40009380: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40009384: 05 10 00 75 sethi %hi(0x4001d400), %g2 40009388: 84 10 a3 30 or %g2, 0x330, %g2 ! 4001d730 <_Objects_Information_table> 4000938c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40009390: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40009394: 80 a2 20 00 cmp %o0, 0 40009398: 02 bf ff f2 be 40009360 <_CORE_RWLock_Timeout+0x68> 4000939c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 400093a0: 40 00 03 4a call 4000a0c8 <_Objects_Get> 400093a4: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 400093a8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400093ac: 80 a0 60 00 cmp %g1, 0 400093b0: 12 bf ff ec bne 40009360 <_CORE_RWLock_Timeout+0x68> 400093b4: 92 10 00 08 mov %o0, %o1 400093b8: 10 bf ff db b 40009324 <_CORE_RWLock_Timeout+0x2c> 400093bc: 31 10 00 75 sethi %hi(0x4001d400), %i0 * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 400093c0: 02 bf ff e5 be 40009354 <_CORE_RWLock_Timeout+0x5c> <== NOT EXECUTED 400093c4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 400093c8: 10 bf ff e3 b 40009354 <_CORE_RWLock_Timeout+0x5c> <== NOT EXECUTED 400093cc: c2 22 20 30 st %g1, [ %o0 + 0x30 ] <== NOT EXECUTED 40013fcc <_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 ) { 40013fcc: 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 ) { 40013fd0: 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 ) { 40013fd4: 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 ) { 40013fd8: 80 a0 40 1a cmp %g1, %i2 40013fdc: 0a 80 00 17 bcs 40014038 <_CORE_message_queue_Broadcast+0x6c> 40013fe0: 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 ) { 40013fe4: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1 40013fe8: 80 a0 60 00 cmp %g1, 0 40013fec: 02 80 00 0a be 40014014 <_CORE_message_queue_Broadcast+0x48> 40013ff0: a2 10 20 00 clr %l1 *count = 0; 40013ff4: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED 40013ff8: 81 c7 e0 08 ret <== NOT EXECUTED 40013ffc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 40014000: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 40014004: 40 00 24 ab call 4001d2b0 40014008: a2 04 60 01 inc %l1 buffer, waitp->return_argument, size ); *(uint32_t *)the_thread->Wait.return_argument_1 = size; 4001400c: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 40014010: 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))) { 40014014: 40 00 0b 94 call 40016e64 <_Thread_queue_Dequeue> 40014018: 90 10 00 12 mov %l2, %o0 4001401c: 92 10 00 19 mov %i1, %o1 40014020: a0 10 00 08 mov %o0, %l0 40014024: 80 a2 20 00 cmp %o0, 0 40014028: 12 bf ff f6 bne 40014000 <_CORE_message_queue_Broadcast+0x34> 4001402c: 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; 40014030: e2 27 40 00 st %l1, [ %i5 ] 40014034: b0 10 20 00 clr %i0 return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 40014038: 81 c7 e0 08 ret 4001403c: 81 e8 00 00 restore 40014934 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, uint32_t maximum_message_size ) { 40014934: 9d e3 bf 98 save %sp, -104, %sp uint32_t message_buffering_required; uint32_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; the_message_queue->number_of_pending_messages = 0; 40014938: c0 26 20 48 clr [ %i0 + 0x48 ] ) { uint32_t message_buffering_required; uint32_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 4001493c: 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; 40014940: 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; 40014944: c0 26 20 60 clr [ %i0 + 0x60 ] the_message_queue->notify_argument = the_argument; 40014948: 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)) { 4001494c: 80 8e e0 03 btst 3, %i3 40014950: 02 80 00 07 be 4001496c <_CORE_message_queue_Initialize+0x38> 40014954: a0 10 00 1b mov %i3, %l0 allocated_message_size += sizeof(uint32_t); 40014958: 82 06 e0 04 add %i3, 4, %g1 allocated_message_size &= ~(sizeof(uint32_t) - 1); 4001495c: a0 08 7f fc and %g1, -4, %l0 } if (allocated_message_size < maximum_message_size) 40014960: 80 a6 c0 10 cmp %i3, %l0 40014964: 18 80 00 09 bgu 40014988 <_CORE_message_queue_Initialize+0x54> 40014968: 01 00 00 00 nop /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ message_buffering_required = maximum_pending_messages * 4001496c: b6 04 20 14 add %l0, 0x14, %i3 40014970: 92 10 00 1a mov %i2, %o1 40014974: 40 00 2a d1 call 4001f4b8 <.umul> 40014978: 90 10 00 1b mov %i3, %o0 (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 4001497c: 80 a2 00 10 cmp %o0, %l0 40014980: 1a 80 00 04 bcc 40014990 <_CORE_message_queue_Initialize+0x5c> 40014984: 92 10 00 08 mov %o0, %o1 STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return TRUE; } 40014988: 81 c7 e0 08 ret <== NOT EXECUTED 4001498c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 40014990: 11 10 00 98 sethi %hi(0x40026000), %o0 40014994: 7f ff e6 5b call 4000e300 <_Heap_Allocate> 40014998: 90 12 20 4c or %o0, 0x4c, %o0 ! 4002604c <_Workspace_Area> * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 4001499c: 80 a2 20 00 cmp %o0, 0 400149a0: 02 bf ff fa be 40014988 <_CORE_message_queue_Initialize+0x54> 400149a4: d0 26 20 5c st %o0, [ %i0 + 0x5c ] /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 400149a8: 92 10 00 08 mov %o0, %o1 400149ac: 94 10 00 1a mov %i2, %o2 400149b0: 90 06 20 68 add %i0, 0x68, %o0 400149b4: 7f ff ff 73 call 40014780 <_Chain_Initialize> 400149b8: 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( 400149bc: 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); 400149c0: 84 06 20 50 add %i0, 0x50, %g2 400149c4: 82 18 60 01 xor %g1, 1, %g1 400149c8: 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); 400149cc: 82 06 20 54 add %i0, 0x54, %g1 the_chain->permanent_null = NULL; 400149d0: c0 26 20 54 clr [ %i0 + 0x54 ] 400149d4: 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); 400149d8: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 400149dc: c4 26 20 58 st %g2, [ %i0 + 0x58 ] 400149e0: 92 60 3f ff subx %g0, -1, %o1 400149e4: 94 10 20 80 mov 0x80, %o2 400149e8: 96 10 20 06 mov 6, %o3 400149ec: 7f ff f0 5f call 40010b68 <_Thread_queue_Initialize> 400149f0: b0 10 20 01 mov 1, %i0 400149f4: 81 c7 e0 08 ret 400149f8: 81 e8 00 00 restore 40016bcc <_CORE_message_queue_Submit>: CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, CORE_message_queue_Submit_types submit_type, boolean wait, Watchdog_Interval timeout ) { 40016bcc: 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 ) { 40016bd0: 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, boolean wait, Watchdog_Interval timeout ) { 40016bd4: 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 ) { 40016bd8: 80 a0 40 1a cmp %g1, %i2 40016bdc: 0a 80 00 22 bcs 40016c64 <_CORE_message_queue_Submit+0x98> 40016be0: 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 ) { 40016be4: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 40016be8: 80 a0 a0 00 cmp %g2, 0 40016bec: 02 80 00 22 be 40016c74 <_CORE_message_queue_Submit+0xa8> 40016bf0: 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 < 40016bf4: c2 04 60 44 ld [ %l1 + 0x44 ], %g1 40016bf8: 80 a0 40 02 cmp %g1, %g2 40016bfc: 18 80 00 2b bgu 40016ca8 <_CORE_message_queue_Submit+0xdc> 40016c00: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 * 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 ) { 40016c04: 80 a0 60 00 cmp %g1, 0 40016c08: 02 80 00 17 be 40016c64 <_CORE_message_queue_Submit+0x98> 40016c0c: 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() ) { 40016c10: 03 10 00 b2 sethi %hi(0x4002c800), %g1 40016c14: c4 00 61 64 ld [ %g1 + 0x164 ], %g2 ! 4002c964 <_ISR_Nest_level> 40016c18: 80 a0 a0 00 cmp %g2, 0 40016c1c: 12 80 00 14 bne 40016c6c <_CORE_message_queue_Submit+0xa0> 40016c20: 03 10 00 b2 sethi %hi(0x4002c800), %g1 */ { Thread_Control *executing = _Thread_Executing; _ISR_Disable( level ); 40016c24: 7f ff ae 7d call 40002618 40016c28: e0 00 61 7c ld [ %g1 + 0x17c ], %l0 ! 4002c97c <_Thread_Executing> 40016c2c: 82 10 20 01 mov 1, %g1 _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 = buffer; executing->Wait.option = size; executing->Wait.count = submit_type; 40016c30: 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; 40016c34: f6 24 20 20 st %i3, [ %l0 + 0x20 ] executing->Wait.return_argument = buffer; 40016c38: f2 24 20 28 st %i1, [ %l0 + 0x28 ] executing->Wait.option = size; 40016c3c: 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; 40016c40: e2 24 20 44 st %l1, [ %l0 + 0x44 ] 40016c44: c2 24 60 30 st %g1, [ %l1 + 0x30 ] executing->Wait.id = id; executing->Wait.return_argument = buffer; executing->Wait.option = size; executing->Wait.count = submit_type; _ISR_Enable( level ); 40016c48: 7f ff ae 78 call 40002628 40016c4c: b0 10 20 07 mov 7, %i0 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 40016c50: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 40016c54: 90 10 00 11 mov %l1, %o0 40016c58: 15 10 00 43 sethi %hi(0x40010c00), %o2 40016c5c: 7f ff e7 89 call 40010a80 <_Thread_queue_Enqueue_with_handler> 40016c60: 94 12 a3 c0 or %o2, 0x3c0, %o2 ! 40010fc0 <_Thread_queue_Timeout> 40016c64: 81 c7 e0 08 ret 40016c68: 81 e8 00 00 restore } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 40016c6c: 81 c7 e0 08 ret <== NOT EXECUTED 40016c70: 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 ); 40016c74: 7f ff e7 15 call 400108c8 <_Thread_queue_Dequeue> 40016c78: 90 10 00 11 mov %l1, %o0 if ( the_thread ) { 40016c7c: a0 92 20 00 orcc %o0, 0, %l0 40016c80: 02 80 00 1b be 40016cec <_CORE_message_queue_Submit+0x120> 40016c84: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 40016c88: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 40016c8c: 40 00 13 b0 call 4001bb4c 40016c90: 94 10 00 1a mov %i2, %o2 _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument, size ); *(size_t *)the_thread->Wait.return_argument_1 = size; 40016c94: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 the_thread->Wait.count = submit_type; 40016c98: fa 24 20 24 st %i5, [ %l0 + 0x24 ] _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument, size ); *(size_t *)the_thread->Wait.return_argument_1 = size; 40016c9c: f4 20 40 00 st %i2, [ %g1 ] the_thread->Wait.count = submit_type; 40016ca0: 81 c7 e0 08 ret 40016ca4: 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 *) 40016ca8: 7f ff dc d3 call 4000dff4 <_Chain_Get> 40016cac: 90 04 60 68 add %l1, 0x68, %o0 /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 40016cb0: a0 92 20 00 orcc %o0, 0, %l0 40016cb4: 02 bf ff ee be 40016c6c <_CORE_message_queue_Submit+0xa0> 40016cb8: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 40016cbc: 94 10 00 1a mov %i2, %o2 40016cc0: 40 00 13 a3 call 4001bb4c 40016cc4: 90 04 20 10 add %l0, 0x10, %o0 size ); the_message->Contents.size = size; the_message->priority = submit_type; _CORE_message_queue_Insert_message( 40016cc8: 90 10 00 11 mov %l1, %o0 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 40016ccc: f4 24 20 0c st %i2, [ %l0 + 0xc ] the_message->priority = submit_type; 40016cd0: fa 24 20 08 st %i5, [ %l0 + 8 ] _CORE_message_queue_Insert_message( 40016cd4: 92 10 00 10 mov %l0, %o1 40016cd8: 94 10 00 1d mov %i5, %o2 40016cdc: 40 00 0c 60 call 40019e5c <_CORE_message_queue_Insert_message> 40016ce0: b0 10 20 00 clr %i0 40016ce4: 81 c7 e0 08 ret 40016ce8: 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 ) { 40016cec: 10 bf ff c2 b 40016bf4 <_CORE_message_queue_Submit+0x28> 40016cf0: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 40006dfc <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 40006dfc: 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; 40006e00: 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 ) { 40006e04: 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; 40006e08: c2 26 20 40 st %g1, [ %i0 + 0x40 ] 40006e0c: c4 06 60 04 ld [ %i1 + 4 ], %g2 the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 40006e10: 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; 40006e14: c4 26 20 44 st %g2, [ %i0 + 0x44 ] 40006e18: c8 06 60 08 ld [ %i1 + 8 ], %g4 40006e1c: c8 26 20 48 st %g4, [ %i0 + 0x48 ] 40006e20: da 06 60 0c ld [ %i1 + 0xc ], %o5 the_mutex->lock = initial_lock; 40006e24: 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; 40006e28: da 26 20 4c st %o5, [ %i0 + 0x4c ] the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 40006e2c: 12 80 00 1c bne 40006e9c <_CORE_mutex_Initialize+0xa0> 40006e30: c0 26 20 58 clr [ %i0 + 0x58 ] the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; 40006e34: 19 10 00 6b sethi %hi(0x4001ac00), %o4 40006e38: c6 03 20 3c ld [ %o4 + 0x3c ], %g3 ! 4001ac3c <_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; 40006e3c: 82 10 20 01 mov 1, %g1 40006e40: c2 26 20 54 st %g1, [ %i0 + 0x54 ] the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; 40006e44: c4 00 e0 08 ld [ %g3 + 8 ], %g2 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; 40006e48: c6 26 20 5c st %g3, [ %i0 + 0x5c ] the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40006e4c: 80 a1 20 02 cmp %g4, 2 40006e50: 12 80 00 1f bne 40006ecc <_CORE_mutex_Initialize+0xd0> 40006e54: c4 26 20 60 st %g2, [ %i0 + 0x60 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < 40006e58: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 40006e5c: 80 a0 40 0d cmp %g1, %o5 40006e60: 0a 80 00 0d bcs 40006e94 <_CORE_mutex_Initialize+0x98> 40006e64: b0 10 20 06 mov 6, %i0 the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 40006e68: c4 03 20 3c ld [ %o4 + 0x3c ], %g2 the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40006e6c: 94 10 24 00 mov 0x400, %o2 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 40006e70: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40006e74: 96 10 20 05 mov 5, %o3 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 40006e78: 82 00 60 01 inc %g1 40006e7c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40006e80: c2 06 60 08 ld [ %i1 + 8 ], %g1 40006e84: b0 10 20 00 clr %i0 40006e88: 80 a0 00 01 cmp %g0, %g1 40006e8c: 40 00 0b 60 call 40009c0c <_Thread_queue_Initialize> 40006e90: 92 40 20 00 addx %g0, 0, %o1 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 40006e94: 81 c7 e0 08 ret 40006e98: 81 e8 00 00 restore the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40006e9c: c2 06 60 08 ld [ %i1 + 8 ], %g1 if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; } else { the_mutex->nest_count = 0; 40006ea0: c0 26 20 54 clr [ %i0 + 0x54 ] the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40006ea4: 80 a0 00 01 cmp %g0, %g1 the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; } else { the_mutex->nest_count = 0; the_mutex->holder = NULL; 40006ea8: c0 26 20 5c clr [ %i0 + 0x5c ] the_mutex->holder_id = 0; 40006eac: c0 26 20 60 clr [ %i0 + 0x60 ] } _Thread_queue_Initialize( 40006eb0: 92 40 20 00 addx %g0, 0, %o1 40006eb4: 94 10 24 00 mov 0x400, %o2 40006eb8: 96 10 20 05 mov 5, %o3 40006ebc: 40 00 0b 54 call 40009c0c <_Thread_queue_Initialize> 40006ec0: b0 10 20 00 clr %i0 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 40006ec4: 81 c7 e0 08 ret 40006ec8: 81 e8 00 00 restore if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40006ecc: 80 a1 20 03 cmp %g4, 3 40006ed0: 32 bf ff e7 bne,a 40006e6c <_CORE_mutex_Initialize+0x70> 40006ed4: c4 03 20 3c ld [ %o4 + 0x3c ], %g2 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < 40006ed8: 10 bf ff e1 b 40006e5c <_CORE_mutex_Initialize+0x60> <== NOT EXECUTED 40006edc: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED 40006ee0 <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 40006ee0: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 40006ee4: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 Watchdog_Interval timeout ) { Thread_Control *executing; executing = _Thread_Executing; 40006ee8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 40006eec: 80 a0 a0 02 cmp %g2, 2 40006ef0: 12 80 00 08 bne 40006f10 <_CORE_mutex_Seize_interrupt_blocking+0x30> 40006ef4: d2 00 60 3c ld [ %g1 + 0x3c ], %o1 if ( the_mutex->holder->current_priority > executing->current_priority ) { 40006ef8: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 40006efc: d2 02 60 14 ld [ %o1 + 0x14 ], %o1 40006f00: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40006f04: 80 a0 40 09 cmp %g1, %o1 40006f08: 18 80 00 16 bgu 40006f60 <_CORE_mutex_Seize_interrupt_blocking+0x80> 40006f0c: 01 00 00 00 nop FALSE ); } } the_mutex->blocked_count++; 40006f10: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 40006f14: 90 10 00 18 mov %i0, %o0 FALSE ); } } the_mutex->blocked_count++; 40006f18: 82 00 60 01 inc %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 40006f1c: 92 10 00 19 mov %i1, %o1 FALSE ); } } the_mutex->blocked_count++; 40006f20: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 40006f24: 15 10 00 27 sethi %hi(0x40009c00), %o2 40006f28: 40 00 0a 2b call 400097d4 <_Thread_queue_Enqueue_with_handler> 40006f2c: 94 12 a1 14 or %o2, 0x114, %o2 ! 40009d14 <_Thread_queue_Timeout> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006f30: 05 10 00 6a sethi %hi(0x4001a800), %g2 40006f34: c2 00 a3 60 ld [ %g2 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> 40006f38: 82 00 7f ff add %g1, -1, %g1 40006f3c: c2 20 a3 60 st %g1, [ %g2 + 0x360 ] 40006f40: c6 00 a3 60 ld [ %g2 + 0x360 ], %g3 40006f44: 80 a0 e0 00 cmp %g3, 0 40006f48: 02 80 00 04 be 40006f58 <_CORE_mutex_Seize_interrupt_blocking+0x78> 40006f4c: 01 00 00 00 nop 40006f50: 81 c7 e0 08 ret <== NOT EXECUTED 40006f54: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40006f58: 40 00 08 af call 40009214 <_Thread_Dispatch> 40006f5c: 81 e8 00 00 restore Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { if ( the_mutex->holder->current_priority > executing->current_priority ) { _Thread_Change_priority( 40006f60: 40 00 07 89 call 40008d84 <_Thread_Change_priority> 40006f64: 94 10 20 00 clr %o2 FALSE ); } } the_mutex->blocked_count++; 40006f68: 10 bf ff eb b 40006f14 <_CORE_mutex_Seize_interrupt_blocking+0x34> 40006f6c: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 40006f70 <_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 ) { 40006f70: 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 ) { 40006f74: c2 06 20 44 ld [ %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 ) { 40006f78: 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 ) { 40006f7c: 80 a0 60 00 cmp %g1, 0 40006f80: 02 80 00 07 be 40006f9c <_CORE_mutex_Surrender+0x2c> 40006f84: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 if ( !_Thread_Is_executing( holder ) ) 40006f88: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006f8c: c4 00 60 3c ld [ %g1 + 0x3c ], %g2 ! 4001ac3c <_Thread_Executing> 40006f90: 80 a2 00 02 cmp %o0, %g2 40006f94: 12 80 00 49 bne 400070b8 <_CORE_mutex_Surrender+0x148> 40006f98: 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 ) 40006f9c: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 40006fa0: 80 a0 60 00 cmp %g1, 0 40006fa4: 22 80 00 45 be,a 400070b8 <_CORE_mutex_Surrender+0x148> 40006fa8: b0 10 20 00 clr %i0 return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 40006fac: 82 00 7f ff add %g1, -1, %g1 if ( the_mutex->nest_count != 0 ) { 40006fb0: 80 a0 60 00 cmp %g1, 0 40006fb4: 02 80 00 09 be 40006fd8 <_CORE_mutex_Surrender+0x68> 40006fb8: c2 24 20 54 st %g1, [ %l0 + 0x54 ] switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40006fbc: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 40006fc0: 80 a0 60 00 cmp %g1, 0 40006fc4: 02 80 00 3d be 400070b8 <_CORE_mutex_Surrender+0x148> 40006fc8: b0 10 20 00 clr %i0 40006fcc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40006fd0: 02 80 00 3a be 400070b8 <_CORE_mutex_Surrender+0x148> <== NOT EXECUTED 40006fd4: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 40006fd8: 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 ) || 40006fdc: 80 a0 a0 02 cmp %g2, 2 40006fe0: 22 80 00 2a be,a 40007088 <_CORE_mutex_Surrender+0x118> 40006fe4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 40006fe8: 80 a0 a0 03 cmp %g2, 3 40006fec: 22 80 00 27 be,a 40007088 <_CORE_mutex_Surrender+0x118> 40006ff0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; the_mutex->holder = NULL; 40006ff4: 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 ) || 40006ff8: 80 a0 a0 02 cmp %g2, 2 40006ffc: 02 80 00 17 be 40007058 <_CORE_mutex_Surrender+0xe8> 40007000: c0 24 20 60 clr [ %l0 + 0x60 ] 40007004: 80 a0 a0 03 cmp %g2, 3 40007008: 22 80 00 15 be,a 4000705c <_CORE_mutex_Surrender+0xec> 4000700c: 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 ) ) ) { 40007010: 40 00 09 83 call 4000961c <_Thread_queue_Dequeue> 40007014: 90 10 00 10 mov %l0, %o0 40007018: 86 92 20 00 orcc %o0, 0, %g3 4000701c: 02 80 00 2e be 400070d4 <_CORE_mutex_Surrender+0x164> 40007020: 82 10 20 01 mov 1, %g1 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 40007024: c2 00 e0 08 ld [ %g3 + 8 ], %g1 the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 40007028: c4 04 20 48 ld [ %l0 + 0x48 ], %g2 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 4000702c: c2 24 20 60 st %g1, [ %l0 + 0x60 ] } else #endif { the_mutex->holder = the_thread; 40007030: c6 24 20 5c st %g3, [ %l0 + 0x5c ] the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; 40007034: 82 10 20 01 mov 1, %g1 switch ( the_mutex->Attributes.discipline ) { 40007038: 80 a0 a0 02 cmp %g2, 2 4000703c: 02 80 00 21 be 400070c0 <_CORE_mutex_Surrender+0x150> 40007040: c2 24 20 54 st %g1, [ %l0 + 0x54 ] 40007044: 80 a0 a0 03 cmp %g2, 3 40007048: 22 80 00 13 be,a 40007094 <_CORE_mutex_Surrender+0x124> 4000704c: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 40007050: 81 c7 e0 08 ret 40007054: 91 e8 20 00 restore %g0, 0, %o0 * 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 ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( holder->resource_count == 0 && 40007058: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 4000705c: 80 a0 60 00 cmp %g1, 0 40007060: 12 bf ff ec bne 40007010 <_CORE_mutex_Surrender+0xa0> 40007064: 01 00 00 00 nop 40007068: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 4000706c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40007070: 80 a2 40 01 cmp %o1, %g1 40007074: 02 bf ff e7 be 40007010 <_CORE_mutex_Surrender+0xa0> 40007078: 01 00 00 00 nop holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 4000707c: 40 00 07 42 call 40008d84 <_Thread_Change_priority> 40007080: 94 10 20 01 mov 1, %o2 ! 1 40007084: 30 bf ff e3 b,a 40007010 <_CORE_mutex_Surrender+0xa0> * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; 40007088: 82 00 7f ff add %g1, -1, %g1 4000708c: 10 bf ff da b 40006ff4 <_CORE_mutex_Surrender+0x84> 40007090: c2 22 20 1c st %g1, [ %o0 + 0x1c ] case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; if (the_mutex->Attributes.priority_ceiling < 40007094: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2 break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; 40007098: 82 00 60 01 inc %g1 4000709c: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if (the_mutex->Attributes.priority_ceiling < 400070a0: d2 04 20 4c ld [ %l0 + 0x4c ], %o1 400070a4: 80 a2 40 02 cmp %o1, %g2 400070a8: 1a 80 00 04 bcc 400070b8 <_CORE_mutex_Surrender+0x148> 400070ac: b0 10 20 00 clr %i0 the_thread->current_priority){ _Thread_Change_priority( 400070b0: 40 00 07 35 call 40008d84 <_Thread_Change_priority> 400070b4: 94 10 20 00 clr %o2 400070b8: 81 c7 e0 08 ret 400070bc: 81 e8 00 00 restore switch ( the_mutex->Attributes.discipline ) { case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; 400070c0: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 400070c4: 82 00 60 01 inc %g1 400070c8: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] 400070cc: 81 c7 e0 08 ret 400070d0: 91 e8 20 00 restore %g0, 0, %o0 } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 400070d4: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 400070d8: 81 c7 e0 08 ret 400070dc: 91 e8 20 00 restore %g0, 0, %o0 40007c7c <_CORE_spinlock_Release>: */ CORE_spinlock_Status _CORE_spinlock_Release( CORE_spinlock_Control *the_spinlock ) { 40007c7c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 40007c80: 7f ff ea 0c call 400024b0 40007c84: 01 00 00 00 nop /* * It must locked before it can be unlocked. */ if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 40007c88: c2 06 20 04 ld [ %i0 + 4 ], %g1 40007c8c: 80 a0 60 00 cmp %g1, 0 40007c90: 12 80 00 06 bne 40007ca8 <_CORE_spinlock_Release+0x2c> 40007c94: 03 10 00 54 sethi %hi(0x40015000), %g1 _ISR_Enable( level ); 40007c98: 7f ff ea 0a call 400024c0 40007c9c: b0 10 20 06 mov 6, %i0 40007ca0: 81 c7 e0 08 ret 40007ca4: 81 e8 00 00 restore } /* * It must locked by the current thread before it can be unlocked. */ if ( the_spinlock->holder != _Thread_Executing->Object.id ) { 40007ca8: c4 00 60 8c ld [ %g1 + 0x8c ], %g2 40007cac: c6 06 20 0c ld [ %i0 + 0xc ], %g3 40007cb0: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40007cb4: 80 a0 c0 01 cmp %g3, %g1 40007cb8: 02 80 00 06 be 40007cd0 <_CORE_spinlock_Release+0x54> 40007cbc: 01 00 00 00 nop _ISR_Enable( level ); 40007cc0: 7f ff ea 00 call 400024c0 <== NOT EXECUTED 40007cc4: b0 10 20 02 mov 2, %i0 ! 2 <== NOT EXECUTED 40007cc8: 81 c7 e0 08 ret <== NOT EXECUTED 40007ccc: 81 e8 00 00 restore <== NOT EXECUTED } /* * Let it be unlocked. */ the_spinlock->users -= 1; 40007cd0: c2 06 20 08 ld [ %i0 + 8 ], %g1 40007cd4: 82 00 7f ff add %g1, -1, %g1 40007cd8: c2 26 20 08 st %g1, [ %i0 + 8 ] the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; 40007cdc: c0 26 20 04 clr [ %i0 + 4 ] the_spinlock->holder = 0; 40007ce0: c0 26 20 0c clr [ %i0 + 0xc ] _ISR_Enable( level ); 40007ce4: 7f ff e9 f7 call 400024c0 40007ce8: b0 10 20 00 clr %i0 return CORE_SPINLOCK_SUCCESSFUL; } 40007cec: 81 c7 e0 08 ret 40007cf0: 81 e8 00 00 restore 40007cf4 <_CORE_spinlock_Wait>: CORE_spinlock_Status _CORE_spinlock_Wait( CORE_spinlock_Control *the_spinlock, boolean wait, Watchdog_Interval timeout ) { 40007cf4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; 40007cf8: 23 10 00 54 sethi %hi(0x40015000), %l1 40007cfc: c2 04 61 34 ld [ %l1 + 0x134 ], %g1 ! 40015134 <_Watchdog_Ticks_since_boot> _ISR_Disable( level ); 40007d00: 7f ff e9 ec call 400024b0 40007d04: a0 06 80 01 add %i2, %g1, %l0 40007d08: 88 10 00 08 mov %o0, %g4 if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 40007d0c: c2 06 20 04 ld [ %i0 + 4 ], %g1 40007d10: 80 a0 60 01 cmp %g1, 1 40007d14: 02 80 00 45 be 40007e28 <_CORE_spinlock_Wait+0x134> 40007d18: 03 10 00 54 sethi %hi(0x40015000), %g1 (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 40007d1c: c2 06 20 08 ld [ %i0 + 8 ], %g1 40007d20: 82 00 60 01 inc %g1 40007d24: c2 26 20 08 st %g1, [ %i0 + 8 ] for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 40007d28: c4 06 20 04 ld [ %i0 + 4 ], %g2 40007d2c: 80 a0 a0 00 cmp %g2, 0 40007d30: 02 80 00 2b be 40007ddc <_CORE_spinlock_Wait+0xe8> 40007d34: 80 a6 60 00 cmp %i1, 0 } /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { 40007d38: 12 80 00 0d bne 40007d6c <_CORE_spinlock_Wait+0x78> 40007d3c: 33 10 00 53 sethi %hi(0x40014c00), %i1 40007d40: 30 80 00 32 b,a 40007e08 <_CORE_spinlock_Wait+0x114> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007d44: c2 06 63 b0 ld [ %i1 + 0x3b0 ], %g1 ! 40014fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40007d48: 82 00 60 01 inc %g1 <== NOT EXECUTED 40007d4c: c2 26 63 b0 st %g1, [ %i1 + 0x3b0 ] <== NOT EXECUTED /* Another thread could get dispatched here */ /* Reenter the critical sections so we can attempt the lock again. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 40007d50: 7f ff e9 d8 call 400024b0 <== NOT EXECUTED 40007d54: 01 00 00 00 nop <== NOT EXECUTED 40007d58: 88 10 00 08 mov %o0, %g4 <== NOT EXECUTED _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 40007d5c: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 40007d60: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40007d64: 02 80 00 1f be 40007de0 <_CORE_spinlock_Wait+0xec> <== NOT EXECUTED 40007d68: 03 10 00 54 sethi %hi(0x40015000), %g1 <== NOT EXECUTED } /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { 40007d6c: 80 a6 a0 00 cmp %i2, 0 40007d70: 02 80 00 06 be 40007d88 <_CORE_spinlock_Wait+0x94> 40007d74: 01 00 00 00 nop 40007d78: c2 04 61 34 ld [ %l1 + 0x134 ], %g1 <== NOT EXECUTED 40007d7c: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 40007d80: 08 80 00 34 bleu 40007e50 <_CORE_spinlock_Wait+0x15c> <== NOT EXECUTED 40007d84: 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 ); 40007d88: 7f ff e9 ce call 400024c0 40007d8c: 90 10 00 04 mov %g4, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007d90: c2 06 63 b0 ld [ %i1 + 0x3b0 ], %g1 40007d94: 82 00 7f ff add %g1, -1, %g1 40007d98: c2 26 63 b0 st %g1, [ %i1 + 0x3b0 ] 40007d9c: c4 06 63 b0 ld [ %i1 + 0x3b0 ], %g2 40007da0: 80 a0 a0 00 cmp %g2, 0 40007da4: 12 bf ff e8 bne 40007d44 <_CORE_spinlock_Wait+0x50> 40007da8: 01 00 00 00 nop _Thread_Dispatch(); 40007dac: 40 00 08 17 call 40009e08 <_Thread_Dispatch> 40007db0: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007db4: c2 06 63 b0 ld [ %i1 + 0x3b0 ], %g1 40007db8: 82 00 60 01 inc %g1 40007dbc: c2 26 63 b0 st %g1, [ %i1 + 0x3b0 ] /* Another thread could get dispatched here */ /* Reenter the critical sections so we can attempt the lock again. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 40007dc0: 7f ff e9 bc call 400024b0 40007dc4: 01 00 00 00 nop 40007dc8: 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 ) { 40007dcc: c2 06 20 04 ld [ %i0 + 4 ], %g1 40007dd0: 80 a0 60 00 cmp %g1, 0 40007dd4: 12 bf ff e7 bne 40007d70 <_CORE_spinlock_Wait+0x7c> 40007dd8: 80 a6 a0 00 cmp %i2, 0 the_spinlock->lock = CORE_SPINLOCK_LOCKED; the_spinlock->holder = _Thread_Executing->Object.id; 40007ddc: 03 10 00 54 sethi %hi(0x40015000), %g1 40007de0: c6 00 60 8c ld [ %g1 + 0x8c ], %g3 ! 4001508c <_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; 40007de4: 84 10 20 01 mov 1, %g2 40007de8: c4 26 20 04 st %g2, [ %i0 + 4 ] the_spinlock->holder = _Thread_Executing->Object.id; 40007dec: c2 00 e0 08 ld [ %g3 + 8 ], %g1 40007df0: c2 26 20 0c st %g1, [ %i0 + 0xc ] _ISR_Enable( level ); 40007df4: b0 10 20 00 clr %i0 40007df8: 7f ff e9 b2 call 400024c0 40007dfc: 90 10 00 04 mov %g4, %o0 40007e00: 81 c7 e0 08 ret 40007e04: 81 e8 00 00 restore /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { the_spinlock->users -= 1; 40007e08: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 40007e0c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40007e10: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 40007e14: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 40007e18: 7f ff e9 aa call 400024c0 <== NOT EXECUTED 40007e1c: 90 10 00 04 mov %g4, %o0 <== NOT EXECUTED 40007e20: 81 c7 e0 08 ret <== NOT EXECUTED 40007e24: 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) && 40007e28: c4 00 60 8c ld [ %g1 + 0x8c ], %g2 40007e2c: c6 06 20 0c ld [ %i0 + 0xc ], %g3 40007e30: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40007e34: 80 a0 c0 01 cmp %g3, %g1 40007e38: 12 bf ff b9 bne 40007d1c <_CORE_spinlock_Wait+0x28> 40007e3c: 01 00 00 00 nop (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); 40007e40: 7f ff e9 a0 call 400024c0 40007e44: b0 10 20 01 mov 1, %i0 ! 1 40007e48: 81 c7 e0 08 ret 40007e4c: 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; 40007e50: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 40007e54: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40007e58: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 40007e5c: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED 40007e60: 7f ff e9 98 call 400024c0 <== NOT EXECUTED 40007e64: 90 10 00 04 mov %g4, %o0 <== NOT EXECUTED 40007e68: 81 c7 e0 08 ret <== NOT EXECUTED 40007e6c: 81 e8 00 00 restore <== NOT EXECUTED 4000d328 <_Debug_Is_enabled>: */ boolean _Debug_Is_enabled( rtems_debug_control level ) { 4000d328: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000d32c: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 4001ac40 <_Debug_Level> <== NOT EXECUTED 4000d330: 90 0a 00 02 and %o0, %g2, %o0 <== NOT EXECUTED return (_Debug_Level & level) ? TRUE : FALSE; } 4000d334: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 4000d338: 81 c3 e0 08 retl <== NOT EXECUTED 4000d33c: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED 40005508 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 40005508: 9d e3 bf 98 save %sp, -104, %sp rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Event_Sync_states sync_state; executing = _Thread_Executing; 4000550c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40005510: e0 00 60 3c ld [ %g1 + 0x3c ], %l0 ! 4001ac3c <_Thread_Executing> executing->Wait.return_code = RTEMS_SUCCESSFUL; 40005514: c0 24 20 34 clr [ %l0 + 0x34 ] api = executing->API_Extensions[ THREAD_API_RTEMS ]; _ISR_Disable( level ); 40005518: 7f ff f2 37 call 40001df4 4000551c: e4 04 21 6c ld [ %l0 + 0x16c ], %l2 40005520: 84 10 00 08 mov %o0, %g2 pending_events = api->pending_events; 40005524: c2 04 a0 40 ld [ %l2 + 0x40 ], %g1 seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 40005528: a2 8e 00 01 andcc %i0, %g1, %l1 4000552c: 02 80 00 0e be 40005564 <_Event_Seize+0x5c> 40005530: 80 8e 60 01 btst 1, %i1 40005534: 80 a6 00 11 cmp %i0, %l1 40005538: 02 80 00 04 be 40005548 <_Event_Seize+0x40> 4000553c: 80 8e 60 02 btst 2, %i1 40005540: 02 80 00 09 be 40005564 <_Event_Seize+0x5c> 40005544: 80 8e 60 01 btst 1, %i1 (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 40005548: 82 28 40 11 andn %g1, %l1, %g1 4000554c: c2 24 a0 40 st %g1, [ %l2 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 40005550: 7f ff f2 2d call 40001e04 40005554: 01 00 00 00 nop *event_out = seized_events; 40005558: e2 26 c0 00 st %l1, [ %i3 ] 4000555c: 81 c7 e0 08 ret 40005560: 81 e8 00 00 restore return; } if ( _Options_Is_no_wait( option_set ) ) { 40005564: 12 80 00 1e bne 400055dc <_Event_Seize+0xd4> 40005568: 82 10 20 01 mov 1, %g1 executing->Wait.return_code = RTEMS_UNSATISFIED; *event_out = seized_events; return; } _Event_Sync_state = EVENT_SYNC_NOTHING_HAPPENED; 4000556c: 23 10 00 6d sethi %hi(0x4001b400), %l1 executing->Wait.option = (uint32_t ) option_set; 40005570: f2 24 20 30 st %i1, [ %l0 + 0x30 ] executing->Wait.count = (uint32_t ) event_in; 40005574: f0 24 20 24 st %i0, [ %l0 + 0x24 ] executing->Wait.return_argument = event_out; 40005578: f6 24 20 28 st %i3, [ %l0 + 0x28 ] executing->Wait.return_code = RTEMS_UNSATISFIED; *event_out = seized_events; return; } _Event_Sync_state = EVENT_SYNC_NOTHING_HAPPENED; 4000557c: c2 24 61 44 st %g1, [ %l1 + 0x144 ] executing->Wait.option = (uint32_t ) option_set; executing->Wait.count = (uint32_t ) event_in; executing->Wait.return_argument = event_out; _ISR_Enable( level ); 40005580: 7f ff f2 21 call 40001e04 40005584: 90 10 00 02 mov %g2, %o0 if ( ticks ) { 40005588: 80 a6 a0 00 cmp %i2, 0 4000558c: 32 80 00 24 bne,a 4000561c <_Event_Seize+0x114> 40005590: c2 04 20 08 ld [ %l0 + 8 ], %g1 NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 40005594: 90 10 00 10 mov %l0, %o0 40005598: 40 00 12 2f call 40009e54 <_Thread_Set_state> 4000559c: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 400055a0: 7f ff f2 15 call 40001df4 400055a4: 01 00 00 00 nop 400055a8: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 400055ac: c4 04 61 44 ld [ %l1 + 0x144 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 400055b0: c0 24 61 44 clr [ %l1 + 0x144 ] switch ( sync_state ) { 400055b4: 80 a0 a0 02 cmp %g2, 2 400055b8: 02 80 00 30 be 40005678 <_Event_Seize+0x170> 400055bc: 82 10 20 06 mov 6, %g1 400055c0: 80 a0 a0 03 cmp %g2, 3 400055c4: 02 80 00 0d be 400055f8 <_Event_Seize+0xf0> 400055c8: 80 a0 a0 01 cmp %g2, 1 400055cc: 02 80 00 31 be 40005690 <_Event_Seize+0x188> 400055d0: 01 00 00 00 nop 400055d4: 81 c7 e0 08 ret <== NOT EXECUTED 400055d8: 81 e8 00 00 restore <== NOT EXECUTED *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 400055dc: 7f ff f2 0a call 40001e04 400055e0: 90 10 00 02 mov %g2, %o0 executing->Wait.return_code = RTEMS_UNSATISFIED; 400055e4: 82 10 20 0d mov 0xd, %g1 400055e8: c2 24 20 34 st %g1, [ %l0 + 0x34 ] *event_out = seized_events; 400055ec: e2 26 c0 00 st %l1, [ %i3 ] 400055f0: 81 c7 e0 08 ret 400055f4: 81 e8 00 00 restore _ISR_Enable( level ); _Thread_Unblock( executing ); return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { 400055f8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400055fc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40005600: 22 80 00 26 be,a 40005698 <_Event_Seize+0x190> <== NOT EXECUTED 40005604: c4 24 20 50 st %g2, [ %l0 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &executing->Timer ); } else _ISR_Enable( level ); 40005608: 7f ff f1 ff call 40001e04 <== NOT EXECUTED 4000560c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 40005610: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 40005614: 40 00 0e 4b call 40008f40 <_Thread_Clear_state> <== NOT EXECUTED 40005618: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4000561c: 92 04 20 48 add %l0, 0x48, %o1 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 40005620: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40005624: 03 10 00 16 sethi %hi(0x40005800), %g1 40005628: 82 10 60 cc or %g1, 0xcc, %g1 ! 400058cc <_Event_Timeout> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000562c: f4 24 20 54 st %i2, [ %l0 + 0x54 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40005630: c2 24 20 64 st %g1, [ %l0 + 0x64 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40005634: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 40005638: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4000563c: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40005640: 40 00 14 1c call 4000a6b0 <_Watchdog_Insert> 40005644: 90 12 20 5c or %o0, 0x5c, %o0 ! 4001ac5c <_Watchdog_Ticks_chain> NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 40005648: 90 10 00 10 mov %l0, %o0 4000564c: 40 00 12 02 call 40009e54 <_Thread_Set_state> 40005650: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 40005654: 7f ff f1 e8 call 40001df4 40005658: 01 00 00 00 nop 4000565c: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 40005660: c4 04 61 44 ld [ %l1 + 0x144 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 40005664: c0 24 61 44 clr [ %l1 + 0x144 ] switch ( sync_state ) { 40005668: 80 a0 a0 02 cmp %g2, 2 4000566c: 12 bf ff d6 bne 400055c4 <_Event_Seize+0xbc> 40005670: 80 a0 a0 03 cmp %g2, 3 case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); return; case EVENT_SYNC_TIMEOUT: executing->Wait.return_code = RTEMS_TIMEOUT; 40005674: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 40005678: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 4000567c: 7f ff f1 e2 call 40001e04 <== NOT EXECUTED 40005680: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 40005684: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 40005688: 40 00 0e 2e call 40008f40 <_Thread_Clear_state> <== NOT EXECUTED 4000568c: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED * enter the synchronization states above. */ return; case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); 40005690: 7f ff f1 dd call 40001e04 40005694: 81 e8 00 00 restore return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); 40005698: 7f ff f1 db call 40001e04 <== NOT EXECUTED 4000569c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED (void) _Watchdog_Remove( &executing->Timer ); 400056a0: 40 00 14 6e call 4000a858 <_Watchdog_Remove> <== NOT EXECUTED 400056a4: 90 04 20 48 add %l0, 0x48, %o0 <== NOT EXECUTED 400056a8: 10 bf ff db b 40005614 <_Event_Seize+0x10c> <== NOT EXECUTED 400056ac: b2 16 63 f8 or %i1, 0x3f8, %i1 <== NOT EXECUTED 400057ac <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 400057ac: 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 ]; 400057b0: e0 06 21 6c ld [ %i0 + 0x16c ], %l0 option_set = (rtems_option) the_thread->Wait.option; 400057b4: e4 06 20 30 ld [ %i0 + 0x30 ], %l2 _ISR_Disable( level ); 400057b8: 7f ff f1 8f call 40001df4 400057bc: b2 10 00 18 mov %i0, %i1 400057c0: a2 10 00 08 mov %o0, %l1 pending_events = api->pending_events; 400057c4: c8 04 20 40 ld [ %l0 + 0x40 ], %g4 event_condition = (rtems_event_set) the_thread->Wait.count; 400057c8: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { 400057cc: 9a 88 c0 04 andcc %g3, %g4, %o5 400057d0: 02 80 00 20 be 40005850 <_Event_Surrender+0xa4> 400057d4: 01 00 00 00 nop if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 400057d8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 400057dc: 80 88 61 00 btst 0x100, %g1 400057e0: 02 80 00 08 be 40005800 <_Event_Surrender+0x54> 400057e4: 19 10 00 6d sethi %hi(0x4001b400), %o4 if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 400057e8: 80 a0 c0 0d cmp %g3, %o5 400057ec: 02 80 00 1b be 40005858 <_Event_Surrender+0xac> 400057f0: 80 8c a0 02 btst 2, %l2 400057f4: 12 80 00 1a bne 4000585c <_Event_Surrender+0xb0> 400057f8: 82 29 00 0d andn %g4, %o5, %g1 } return; } } switch ( _Event_Sync_state ) { 400057fc: 19 10 00 6d sethi %hi(0x4001b400), %o4 <== NOT EXECUTED 40005800: c2 03 21 44 ld [ %o4 + 0x144 ], %g1 ! 4001b544 <_Event_Sync_state> <== NOT EXECUTED 40005804: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40005808: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000580c: 18 80 00 11 bgu 40005850 <_Event_Surrender+0xa4> <== NOT EXECUTED 40005810: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED case EVENT_SYNC_SATISFIED: break; case EVENT_SYNC_NOTHING_HAPPENED: case EVENT_SYNC_TIMEOUT: if ( !_Thread_Is_executing( the_thread ) ) 40005814: c4 00 60 3c ld [ %g1 + 0x3c ], %g2 ! 4001ac3c <_Thread_Executing> <== NOT EXECUTED 40005818: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED 4000581c: 12 80 00 0d bne 40005850 <_Event_Surrender+0xa4> <== NOT EXECUTED 40005820: 80 a0 c0 0d cmp %g3, %o5 <== NOT EXECUTED break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 40005824: 02 80 00 04 be 40005834 <_Event_Surrender+0x88> <== NOT EXECUTED 40005828: 80 8c a0 02 btst 2, %l2 <== NOT EXECUTED 4000582c: 02 80 00 09 be 40005850 <_Event_Surrender+0xa4> <== NOT EXECUTED 40005830: 01 00 00 00 nop <== NOT EXECUTED api->pending_events = 40005834: 82 29 00 0d andn %g4, %o5, %g1 <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 40005838: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED case EVENT_SYNC_TIMEOUT: if ( !_Thread_Is_executing( the_thread ) ) break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { api->pending_events = 4000583c: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 40005840: c0 26 60 24 clr [ %i1 + 0x24 ] <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; _Event_Sync_state = EVENT_SYNC_SATISFIED; 40005844: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 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; 40005848: da 20 80 00 st %o5, [ %g2 ] <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_SATISFIED; 4000584c: c2 23 21 44 st %g1, [ %o4 + 0x144 ] <== NOT EXECUTED } break; } } _ISR_Enable( level ); 40005850: 7f ff f1 6d call 40001e04 40005854: 91 e8 00 11 restore %g0, %l1, %o0 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { api->pending_events = 40005858: 82 29 00 0d andn %g4, %o5, %g1 _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 4000585c: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { api->pending_events = 40005860: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 40005864: c0 26 60 24 clr [ %i1 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 40005868: da 20 80 00 st %o5, [ %g2 ] _ISR_Flash( level ); 4000586c: 7f ff f1 66 call 40001e04 40005870: 01 00 00 00 nop 40005874: 7f ff f1 60 call 40001df4 40005878: 01 00 00 00 nop if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 4000587c: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 40005880: 80 a0 60 02 cmp %g1, 2 40005884: 02 80 00 08 be 400058a4 <_Event_Surrender+0xf8> 40005888: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 4000588c: 90 10 00 11 mov %l1, %o0 40005890: 7f ff f1 5d call 40001e04 40005894: 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 ); 40005898: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000589c: 40 00 0d a9 call 40008f40 <_Thread_Clear_state> 400058a0: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 400058a4: c2 26 60 50 st %g1, [ %i1 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 400058a8: 7f ff f1 57 call 40001e04 400058ac: 90 10 00 11 mov %l1, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 400058b0: 40 00 13 ea call 4000a858 <_Watchdog_Remove> 400058b4: 90 06 60 48 add %i1, 0x48, %o0 400058b8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 400058bc: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 400058c0: 40 00 0d a0 call 40008f40 <_Thread_Clear_state> 400058c4: 81 e8 00 00 restore 400058c8: 01 00 00 00 nop 400058cc <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 400058cc: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 400058d0: 92 96 20 00 orcc %i0, 0, %o1 400058d4: 12 80 00 25 bne 40005968 <_Event_Timeout+0x9c> 400058d8: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400058dc: 21 10 00 6a sethi %hi(0x4001a800), %l0 <== NOT EXECUTED 400058e0: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400058e4: 82 00 60 01 inc %g1 <== NOT EXECUTED 400058e8: c2 24 23 60 st %g1, [ %l0 + 0x360 ] <== NOT EXECUTED 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; 400058ec: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 400058f0: f0 00 60 3c ld [ %g1 + 0x3c ], %i0 ! 4001ac3c <_Thread_Executing> <== NOT EXECUTED 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; 400058f4: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED * 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. */ _ISR_Disable( level ); 400058f8: 7f ff f1 3f call 40001df4 400058fc: 01 00 00 00 nop 40005900: 88 10 00 08 mov %o0, %g4 if ( the_thread->Wait.count ) { /* verify thread is waiting */ 40005904: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 40005908: 80 a0 60 00 cmp %g1, 0 4000590c: 02 80 00 3a be 400059f4 <_Event_Timeout+0x128> 40005910: 07 10 00 6d sethi %hi(0x4001b400), %g3 the_thread->Wait.count = 0; if ( _Event_Sync_state != EVENT_SYNC_SYNCHRONIZED && 40005914: c2 00 e1 44 ld [ %g3 + 0x144 ], %g1 ! 4001b544 <_Event_Sync_state> 40005918: 80 a0 60 00 cmp %g1, 0 4000591c: 02 80 00 29 be 400059c0 <_Event_Timeout+0xf4> 40005920: c0 26 20 24 clr [ %i0 + 0x24 ] 40005924: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40005928: c4 00 60 3c ld [ %g1 + 0x3c ], %g2 ! 4001ac3c <_Thread_Executing> <== NOT EXECUTED 4000592c: 80 a6 00 02 cmp %i0, %g2 <== NOT EXECUTED 40005930: 12 80 00 25 bne 400059c4 <_Event_Timeout+0xf8> <== NOT EXECUTED 40005934: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { 40005938: c2 00 e1 44 ld [ %g3 + 0x144 ], %g1 <== NOT EXECUTED 4000593c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 40005940: 02 80 00 03 be 4000594c <_Event_Timeout+0x80> <== NOT EXECUTED 40005944: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_TIMEOUT; 40005948: c2 20 e1 44 st %g1, [ %g3 + 0x144 ] <== NOT EXECUTED } _ISR_Enable( level ); 4000594c: 7f ff f1 2e call 40001e04 <== NOT EXECUTED 40005950: 01 00 00 00 nop <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 40005954: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 <== NOT EXECUTED 40005958: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000595c: c2 24 23 60 st %g1, [ %l0 + 0x360 ] <== NOT EXECUTED 40005960: 81 c7 e0 08 ret <== NOT EXECUTED 40005964: 81 e8 00 00 restore <== NOT EXECUTED 40005968: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 4000596c: 80 a0 a0 04 cmp %g2, 4 40005970: 18 bf ff fc bgu 40005960 <_Event_Timeout+0x94> 40005974: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40005978: 80 a0 60 01 cmp %g1, 1 4000597c: 12 bf ff f9 bne 40005960 <_Event_Timeout+0x94> 40005980: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40005984: 05 10 00 6a sethi %hi(0x4001a800), %g2 40005988: 84 10 a2 c0 or %g2, 0x2c0, %g2 ! 4001aac0 <_Objects_Information_table> 4000598c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40005990: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40005994: 80 a2 20 00 cmp %o0, 0 40005998: 02 80 00 15 be 400059ec <_Event_Timeout+0x120> 4000599c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 400059a0: 40 00 08 f5 call 40007d74 <_Objects_Get> 400059a4: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); switch ( location ) { 400059a8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400059ac: 80 a0 60 00 cmp %g1, 0 400059b0: 12 bf ff ec bne 40005960 <_Event_Timeout+0x94> 400059b4: b0 10 00 08 mov %o0, %i0 400059b8: 10 bf ff d0 b 400058f8 <_Event_Timeout+0x2c> 400059bc: 21 10 00 6a sethi %hi(0x4001a800), %l0 if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { _Event_Sync_state = EVENT_SYNC_TIMEOUT; } _ISR_Enable( level ); } else { the_thread->Wait.return_code = RTEMS_TIMEOUT; 400059c0: 82 10 20 06 mov 6, %g1 400059c4: c2 26 20 34 st %g1, [ %i0 + 0x34 ] _ISR_Enable( level ); 400059c8: 7f ff f1 0f call 40001e04 400059cc: 90 10 00 04 mov %g4, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 400059d0: 13 04 00 ff sethi %hi(0x1003fc00), %o1 400059d4: 90 10 00 18 mov %i0, %o0 400059d8: 40 00 0d 5a call 40008f40 <_Thread_Clear_state> 400059dc: 92 12 63 f8 or %o1, 0x3f8, %o1 */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 400059e0: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 400059e4: 82 00 7f ff add %g1, -1, %g1 400059e8: c2 24 23 60 st %g1, [ %l0 + 0x360 ] 400059ec: 81 c7 e0 08 ret 400059f0: 81 e8 00 00 restore _Thread_Unblock( the_thread ); } } else { _ISR_Enable( level ); 400059f4: 7f ff f1 04 call 40001e04 <== NOT EXECUTED 400059f8: 01 00 00 00 nop <== NOT EXECUTED 400059fc: 30 bf ff f9 b,a 400059e0 <_Event_Timeout+0x114> <== NOT EXECUTED 400072b4 <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 400072b4: 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 = 400072b8: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 400072bc: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 400072c0: 90 10 00 19 mov %i1, %o0 400072c4: 40 00 00 cd call 400075f8 <_Heap_Calc_block_size> 400072c8: 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) 400072cc: 80 a2 20 00 cmp %o0, 0 400072d0: 22 80 00 1a be,a 40007338 <_Heap_Allocate+0x84> 400072d4: b0 10 20 00 clr %i0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 400072d8: 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; 400072dc: 80 a4 00 18 cmp %l0, %i0 400072e0: 22 80 00 16 be,a 40007338 <_Heap_Allocate+0x84> 400072e4: b0 10 20 00 clr %i0 /* 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) { 400072e8: c2 06 20 04 ld [ %i0 + 4 ], %g1 400072ec: 80 a2 00 01 cmp %o0, %g1 400072f0: 08 80 00 16 bleu 40007348 <_Heap_Allocate+0x94> 400072f4: b2 10 20 00 clr %i1 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) 400072f8: 10 80 00 07 b 40007314 <_Heap_Allocate+0x60> 400072fc: f0 06 20 08 ld [ %i0 + 8 ], %i0 /* 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) { 40007300: c2 06 20 04 ld [ %i0 + 4 ], %g1 40007304: 80 a2 00 01 cmp %o0, %g1 40007308: 08 80 00 11 bleu 4000734c <_Heap_Allocate+0x98> 4000730c: 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) 40007310: 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; 40007314: 80 a4 00 18 cmp %l0, %i0 40007318: 12 bf ff fa bne 40007300 <_Heap_Allocate+0x4c> 4000731c: b2 06 60 01 inc %i1 40007320: b0 10 20 00 clr %i0 _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 40007324: c2 04 20 44 ld [ %l0 + 0x44 ], %g1 40007328: 80 a6 40 01 cmp %i1, %g1 4000732c: 08 80 00 05 bleu 40007340 <_Heap_Allocate+0x8c> 40007330: 01 00 00 00 nop stats->max_search = search_count; 40007334: f2 24 20 44 st %i1, [ %l0 + 0x44 ] 40007338: 81 c7 e0 08 ret 4000733c: 81 e8 00 00 restore return ptr; } 40007340: 81 c7 e0 08 ret 40007344: 81 e8 00 00 restore _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 ); 40007348: 94 10 00 08 mov %o0, %o2 4000734c: 92 10 00 18 mov %i0, %o1 40007350: 40 00 00 7e call 40007548 <_Heap_Block_allocate> 40007354: 90 10 00 10 mov %l0, %o0 ptr = _Heap_User_area(the_block); stats->allocs += 1; 40007358: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 stats->searches += search_count + 1; 4000735c: 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; 40007360: 82 00 60 01 inc %g1 stats->searches += search_count + 1; 40007364: 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; 40007368: c2 24 20 48 st %g1, [ %l0 + 0x48 ] stats->searches += search_count + 1; 4000736c: 84 00 80 19 add %g2, %i1, %g2 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( void *base, uint32_t offset ) { return (void *)((char *)base + offset); 40007370: b0 06 20 08 add %i0, 8, %i0 40007374: 10 bf ff ec b 40007324 <_Heap_Allocate+0x70> 40007378: c4 24 20 4c st %g2, [ %l0 + 0x4c ] 4001b3c4 <_Heap_Get_free_information>: */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 4001b3c4: da 02 20 08 ld [ %o0 + 8 ], %o5 <== NOT EXECUTED ) { Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 4001b3c8: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED info->largest = 0; 4001b3cc: c0 22 60 04 clr [ %o1 + 4 ] <== NOT EXECUTED info->total = 0; 4001b3d0: c0 22 60 08 clr [ %o1 + 8 ] <== NOT EXECUTED for(the_block = _Heap_First(the_heap); the_block != tail; 4001b3d4: 80 a2 00 0d cmp %o0, %o5 <== NOT EXECUTED 4001b3d8: 02 80 00 12 be 4001b420 <_Heap_Get_free_information+0x5c> <== NOT EXECUTED 4001b3dc: 98 10 20 00 clr %o4 <== NOT EXECUTED 4001b3e0: 84 10 00 0c mov %o4, %g2 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 4001b3e4: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED /* 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 ) 4001b3e8: c6 02 60 04 ld [ %o1 + 4 ], %g3 <== NOT EXECUTED 4001b3ec: 88 08 7f fe and %g1, -2, %g4 <== NOT EXECUTED 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++; 4001b3f0: 84 00 a0 01 inc %g2 <== NOT EXECUTED info->total += the_size; 4001b3f4: 82 03 00 04 add %o4, %g4, %g1 <== NOT EXECUTED 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++; 4001b3f8: c4 22 40 00 st %g2, [ %o1 ] <== NOT EXECUTED info->total += the_size; 4001b3fc: c2 22 60 08 st %g1, [ %o1 + 8 ] <== NOT EXECUTED if ( info->largest < the_size ) 4001b400: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED 4001b404: 08 80 00 03 bleu 4001b410 <_Heap_Get_free_information+0x4c> <== NOT EXECUTED 4001b408: 98 10 00 01 mov %g1, %o4 <== NOT EXECUTED info->largest = the_size; 4001b40c: c8 22 60 04 st %g4, [ %o1 + 4 ] <== NOT EXECUTED info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 4001b410: da 03 60 08 ld [ %o5 + 8 ], %o5 <== NOT EXECUTED info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; 4001b414: 80 a2 00 0d cmp %o0, %o5 <== NOT EXECUTED 4001b418: 32 bf ff f4 bne,a 4001b3e8 <_Heap_Get_free_information+0x24> <== NOT EXECUTED 4001b41c: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED 4001b420: 81 c3 e0 08 retl <== NOT EXECUTED 4001b424: 01 00 00 00 nop 40007648 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 40007648: 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) 4000764c: 80 a6 e0 00 cmp %i3, 0 40007650: 12 80 00 43 bne 4000775c <_Heap_Initialize+0x114> 40007654: 84 8e e0 07 andcc %i3, 7, %g2 40007658: b6 10 20 08 mov 8, %i3 <== NOT EXECUTED 4000765c: a4 10 20 00 clr %l2 <== NOT EXECUTED /* 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; 40007660: 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; 40007664: 92 10 00 1b mov %i3, %o1 40007668: 40 00 3a b6 call 40016140 <.urem> 4000766c: 90 10 00 10 mov %l0, %o0 *value = r ? v - r + a : v; 40007670: 80 a2 20 00 cmp %o0, 0 40007674: 02 80 00 05 be 40007688 <_Heap_Initialize+0x40> 40007678: a2 04 3f f8 add %l0, -8, %l1 4000767c: 82 06 c0 10 add %i3, %l0, %g1 40007680: a0 20 40 08 sub %g1, %o0, %l0 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 40007684: a2 04 3f f8 add %l0, -8, %l1 ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 40007688: 80 a4 a0 00 cmp %l2, 0 4000768c: 02 80 00 04 be 4000769c <_Heap_Initialize+0x54> 40007690: 82 10 20 10 mov 0x10, %g1 40007694: 82 06 e0 10 add %i3, 0x10, %g1 40007698: 82 20 40 12 sub %g1, %l2, %g1 4000769c: 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); 400076a0: 82 24 40 19 sub %l1, %i1, %g1 400076a4: 82 00 60 08 add %g1, 8, %g1 if ( size < overhead ) 400076a8: 80 a0 40 1a cmp %g1, %i2 400076ac: 18 80 00 2a bgu 40007754 <_Heap_Initialize+0x10c> 400076b0: a0 26 80 01 sub %i2, %g1, %l0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 400076b4: 92 10 00 1b mov %i3, %o1 400076b8: 40 00 3a a2 call 40016140 <.urem> 400076bc: 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 ) 400076c0: a0 a4 00 08 subcc %l0, %o0, %l0 400076c4: 02 80 00 24 be 40007754 <_Heap_Initialize+0x10c> 400076c8: 09 10 00 6a sethi %hi(0x4001a800), %g4 return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 400076cc: 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; 400076d0: f6 24 40 00 st %i3, [ %l1 ] the_block->size = the_size | HEAP_PREV_USED; 400076d4: 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++; 400076d8: c6 01 21 38 ld [ %g4 + 0x138 ], %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; 400076dc: c2 24 60 04 st %g1, [ %l1 + 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 */ 400076e0: e0 24 40 10 st %l0, [ %l1 + %l0 ] RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 400076e4: 9a 04 40 10 add %l1, %l0, %o5 the_block->size = page_size; 400076e8: 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 ); 400076ec: f0 24 60 08 st %i0, [ %l1 + 8 ] the_block->prev = _Heap_Head( the_heap ); 400076f0: f0 24 60 0c st %i0, [ %l1 + 0xc ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 400076f4: 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; 400076f8: f4 26 20 2c st %i2, [ %i0 + 0x2c ] stats->free_size = the_size; 400076fc: e0 26 20 30 st %l0, [ %i0 + 0x30 ] stats->min_free_size = the_size; 40007700: e0 26 20 34 st %l0, [ %i0 + 0x34 ] stats->free_blocks = 1; stats->max_free_blocks = 1; stats->used_blocks = 0; 40007704: c0 26 20 40 clr [ %i0 + 0x40 ] stats->max_search = 0; 40007708: c0 26 20 44 clr [ %i0 + 0x44 ] stats->allocs = 0; 4000770c: c0 26 20 48 clr [ %i0 + 0x48 ] stats->searches = 0; 40007710: c0 26 20 4c clr [ %i0 + 0x4c ] stats->frees = 0; 40007714: c0 26 20 50 clr [ %i0 + 0x50 ] stats->resizes = 0; 40007718: 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; 4000771c: 84 10 20 01 mov 1, %g2 stats->max_free_blocks = 1; 40007720: 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; 40007724: 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; 40007728: 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++; 4000772c: 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; 40007730: 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; 40007734: 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; 40007738: e2 26 20 08 st %l1, [ %i0 + 8 ] _Heap_Tail(the_heap)->prev = the_block; 4000773c: e2 26 20 0c st %l1, [ %i0 + 0xc ] the_heap->start = the_block; 40007740: e2 26 20 20 st %l1, [ %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 */ 40007744: 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++; 40007748: c6 21 21 38 st %g3, [ %g4 + 0x138 ] return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 4000774c: 81 c7 e0 08 ret 40007750: 91 ec 3f fc restore %l0, -4, %o0 } 40007754: 81 c7 e0 08 ret 40007758: 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; 4000775c: 02 80 00 04 be 4000776c <_Heap_Initialize+0x124> 40007760: 90 10 20 10 mov 0x10, %o0 40007764: 82 06 e0 08 add %i3, 8, %g1 40007768: b6 20 40 02 sub %g1, %g2, %i3 4000776c: 40 00 3a 75 call 40016140 <.urem> 40007770: 92 10 00 1b mov %i3, %o1 40007774: 10 bf ff bb b 40007660 <_Heap_Initialize+0x18> 40007778: a4 10 00 08 mov %o0, %l2 4000d54c <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 4000d54c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED 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; uint32_t const page_size = the_heap->page_size; 4000d550: e6 06 20 10 ld [ %i0 + 0x10 ], %l3 <== NOT EXECUTED 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; 4000d554: ee 06 20 14 ld [ %i0 + 0x14 ], %l7 <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; *old_mem_size = 0; 4000d558: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED *avail_mem_size = 0; 4000d55c: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED /* 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); 4000d560: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4000d564: 40 00 22 f7 call 40016140 <.urem> <== NOT EXECUTED 4000d568: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _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 ); 4000d56c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED /* 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); 4000d570: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 4000d574: a4 02 3f f8 add %o0, -8, %l2 <== NOT EXECUTED _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)) 4000d578: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED 4000d57c: 1a 80 00 05 bcc 4000d590 <_Heap_Resize_block+0x44> <== NOT EXECUTED 4000d580: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 4000d584: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED } 4000d588: 81 c7 e0 08 ret <== NOT EXECUTED 4000d58c: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED *old_mem_size = 0; *avail_mem_size = 0; _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)) 4000d590: 80 a4 80 02 cmp %l2, %g2 <== NOT EXECUTED 4000d594: 38 bf ff fd bgu,a 4000d588 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 4000d598: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 4000d59c: c6 04 a0 04 ld [ %l2 + 4 ], %g3 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 4000d5a0: a8 08 ff fe and %g3, -2, %l4 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 4000d5a4: a2 04 80 14 add %l2, %l4, %l1 <== NOT EXECUTED 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) || 4000d5a8: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 4000d5ac: 2a bf ff f7 bcs,a 4000d588 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 4000d5b0: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 4000d5b4: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 4000d5b8: 38 bf ff f4 bgu,a 4000d588 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 4000d5bc: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _Heap_Is_prev_used ( Heap_Block *the_block ) { return (the_block->size & HEAP_PREV_USED); 4000d5c0: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED 4000d5c4: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 4000d5c8: 02 bf ff ef be 4000d584 <_Heap_Resize_block+0x38> <== NOT EXECUTED 4000d5cc: aa 08 7f fe and %g1, -2, %l5 <== NOT EXECUTED !_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) || 4000d5d0: 80 a0 80 11 cmp %g2, %l1 <== NOT EXECUTED 4000d5d4: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED 4000d5d8: 02 80 00 04 be 4000d5e8 <_Heap_Resize_block+0x9c> <== NOT EXECUTED 4000d5dc: ba 04 40 15 add %l1, %l5, %i5 <== NOT EXECUTED 4000d5e0: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED 4000d5e4: ac 08 60 01 and %g1, 1, %l6 <== NOT EXECUTED _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) 4000d5e8: 82 24 40 19 sub %l1, %i1, %g1 <== NOT EXECUTED 4000d5ec: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 4000d5f0: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED if (size > old_user_size) { 4000d5f4: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED 4000d5f8: 1a 80 00 16 bcc 4000d650 <_Heap_Resize_block+0x104> <== NOT EXECUTED 4000d5fc: b6 08 e0 01 and %g3, 1, %i3 <== NOT EXECUTED /* 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 */ 4000d600: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 4000d604: 12 80 00 10 bne 4000d644 <_Heap_Resize_block+0xf8> <== NOT EXECUTED 4000d608: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 4000d60c: a0 26 80 01 sub %i2, %g1, %l0 <== NOT EXECUTED uint32_t alignment ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; 4000d610: 40 00 22 cc call 40016140 <.urem> <== NOT EXECUTED 4000d614: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED *value = r ? v - r + a : v; 4000d618: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000d61c: 02 80 00 05 be 4000d630 <_Heap_Resize_block+0xe4> <== NOT EXECUTED 4000d620: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED 4000d624: 82 04 00 13 add %l0, %l3, %g1 <== NOT EXECUTED 4000d628: a0 20 40 08 sub %g1, %o0, %l0 <== NOT EXECUTED 4000d62c: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED 4000d630: 0a 80 00 1d bcs 4000d6a4 <_Heap_Resize_block+0x158> <== NOT EXECUTED 4000d634: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _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) 4000d638: 80 a5 40 08 cmp %l5, %o0 <== NOT EXECUTED 4000d63c: 1a 80 00 1f bcc 4000d6b8 <_Heap_Resize_block+0x16c> <== NOT EXECUTED 4000d640: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 4000d644: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED } 4000d648: 81 c7 e0 08 ret <== NOT EXECUTED 4000d64c: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED --stats->used_blocks; } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 4000d650: a0 20 40 1a sub %g1, %i2, %l0 <== NOT EXECUTED uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 4000d654: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 4000d658: 40 00 22 ba call 40016140 <.urem> <== NOT EXECUTED 4000d65c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 4000d660: a0 a4 00 08 subcc %l0, %o0, %l0 <== NOT EXECUTED 4000d664: 22 80 00 0b be,a 4000d690 <_Heap_Resize_block+0x144> <== NOT EXECUTED 4000d668: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED /* 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; 4000d66c: 86 25 00 10 sub %l4, %l0, %g3 <== NOT EXECUTED if (new_block_size < min_block_size) { 4000d670: 80 a5 c0 03 cmp %l7, %g3 <== NOT EXECUTED 4000d674: 08 80 00 1c bleu 4000d6e4 <_Heap_Resize_block+0x198> <== NOT EXECUTED 4000d678: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 4000d67c: 82 25 c0 03 sub %l7, %g3, %g1 <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 4000d680: a0 a4 00 01 subcc %l0, %g1, %l0 <== NOT EXECUTED 4000d684: 32 80 00 17 bne,a 4000d6e0 <_Heap_Resize_block+0x194> <== NOT EXECUTED 4000d688: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 4000d68c: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 4000d690: 84 10 20 00 clr %g2 <== NOT EXECUTED 4000d694: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000d698: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } 4000d69c: 81 c7 e0 08 ret <== NOT EXECUTED 4000d6a0: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 4000d6a4: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED 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) 4000d6a8: 80 a5 40 08 cmp %l5, %o0 <== NOT EXECUTED 4000d6ac: 0a bf ff e7 bcs 4000d648 <_Heap_Resize_block+0xfc> <== NOT EXECUTED 4000d6b0: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 4000d6b4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4000d6b8: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 4000d6bc: 7f ff e7 a3 call 40007548 <_Heap_Block_allocate> <== NOT EXECUTED 4000d6c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _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; 4000d6c4: 90 02 00 14 add %o0, %l4, %o0 <== NOT EXECUTED 4000d6c8: 90 12 00 1b or %o0, %i3, %o0 <== NOT EXECUTED 4000d6cc: d0 24 a0 04 st %o0, [ %l2 + 4 ] <== NOT EXECUTED --stats->used_blocks; 4000d6d0: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED 4000d6d4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000d6d8: 10 bf ff ed b 4000d68c <_Heap_Resize_block+0x140> <== NOT EXECUTED 4000d6dc: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED _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) { 4000d6e0: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 4000d6e4: 12 80 00 15 bne 4000d738 <_Heap_Resize_block+0x1ec> <== NOT EXECUTED 4000d6e8: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED 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; 4000d6ec: 82 10 c0 1b or %g3, %i3, %g1 <== NOT EXECUTED 4000d6f0: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 4000d6f4: 86 04 80 03 add %l2, %g3, %g3 <== NOT EXECUTED 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; 4000d6f8: 88 04 00 15 add %l0, %l5, %g4 <== NOT EXECUTED Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; 4000d6fc: d8 04 60 0c ld [ %l1 + 0xc ], %o4 <== NOT EXECUTED _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; 4000d700: c8 27 40 00 st %g4, [ %i5 ] <== NOT EXECUTED Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; 4000d704: da 04 60 08 ld [ %l1 + 8 ], %o5 <== NOT EXECUTED _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; 4000d708: 84 11 20 01 or %g4, 1, %g2 <== NOT EXECUTED 4000d70c: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED 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; 4000d710: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED Heap_Block *prev = block->prev; block = new_block; block->next = next; 4000d714: da 20 e0 08 st %o5, [ %g3 + 8 ] <== NOT EXECUTED 4000d718: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED block->prev = prev; 4000d71c: d8 20 e0 0c st %o4, [ %g3 + 0xc ] <== NOT EXECUTED 4000d720: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 4000d724: 88 01 3f fc add %g4, -4, %g4 <== NOT EXECUTED next->prev = prev->next = block; 4000d728: c6 23 60 0c st %g3, [ %o5 + 0xc ] <== NOT EXECUTED 4000d72c: c6 23 20 08 st %g3, [ %o4 + 8 ] <== NOT EXECUTED 4000d730: 10 bf ff d7 b 4000d68c <_Heap_Resize_block+0x140> <== NOT EXECUTED 4000d734: c8 27 00 00 st %g4, [ %i4 ] <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 4000d738: 2a bf ff d6 bcs,a 4000d690 <_Heap_Resize_block+0x144> <== NOT EXECUTED 4000d73c: c2 06 20 54 ld [ %i0 + 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; 4000d740: 82 10 c0 1b or %g3, %i3, %g1 <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 4000d744: 84 14 20 01 or %l0, 1, %g2 <== NOT EXECUTED 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) { /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; 4000d748: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 4000d74c: 92 04 80 03 add %l2, %g3, %o1 <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 4000d750: c4 22 60 04 st %g2, [ %o1 + 4 ] <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 4000d754: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000d758: c4 06 20 50 ld [ %i0 + 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 */ 4000d75c: 82 00 60 01 inc %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000d760: 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 */ 4000d764: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000d768: c4 26 20 50 st %g2, [ %i0 + 0x50 ] <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 4000d76c: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 4000d770: 7f ff e7 03 call 4000737c <_Heap_Free> <== NOT EXECUTED 4000d774: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 4000d778: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED 4000d77c: 10 bf ff c4 b 4000d68c <_Heap_Resize_block+0x140> <== NOT EXECUTED 4000d780: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED 4000d784 <_Heap_Size_of_user_area>: boolean _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 4000d784: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Heap_Block *the_block; Heap_Block *next_block; uint32_t the_size; if ( !_Addresses_Is_in_range( 4000d788: e0 06 20 20 ld [ %i0 + 0x20 ], %l0 <== NOT EXECUTED 4000d78c: 80 a6 40 10 cmp %i1, %l0 <== NOT EXECUTED 4000d790: 0a 80 00 05 bcs 4000d7a4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000d794: e2 06 20 24 ld [ %i0 + 0x24 ], %l1 <== NOT EXECUTED 4000d798: 80 a6 40 11 cmp %i1, %l1 <== NOT EXECUTED 4000d79c: 28 80 00 04 bleu,a 4000d7ac <_Heap_Size_of_user_area+0x28> <== NOT EXECUTED 4000d7a0: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 <== NOT EXECUTED *size = _Addresses_Subtract ( next_block, starting_address ) + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); } 4000d7a4: 81 c7 e0 08 ret <== NOT EXECUTED 4000d7a8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED /* 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); 4000d7ac: 40 00 22 65 call 40016140 <.urem> <== NOT EXECUTED 4000d7b0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4000d7b4: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 4000d7b8: 90 02 3f f8 add %o0, -8, %o0 <== NOT EXECUTED 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 ) ) 4000d7bc: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 4000d7c0: 0a bf ff f9 bcs 4000d7a4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000d7c4: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 4000d7c8: 18 bf ff f7 bgu 4000d7a4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000d7cc: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 4000d7d0: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4000d7d4: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 4000d7d8: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED 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 ( 4000d7dc: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 4000d7e0: 0a bf ff f1 bcs 4000d7a4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000d7e4: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 4000d7e8: 18 bf ff ef bgu 4000d7a4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000d7ec: 01 00 00 00 nop <== NOT EXECUTED 4000d7f0: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4000d7f4: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 4000d7f8: 02 bf ff eb be 4000d7a4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000d7fc: 82 22 00 19 sub %o0, %i1, %g1 <== NOT EXECUTED 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 ) 4000d800: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED 4000d804: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 4000d808: 81 c7 e0 08 ret <== NOT EXECUTED 4000d80c: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED 40006a84 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 40006a84: 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 ) 40006a88: 80 a6 80 19 cmp %i2, %i1 40006a8c: 08 80 00 27 bleu 40006b28 <_IO_Manager_initialization+0xa4> 40006a90: 03 10 00 6d sethi %hi(0x4001b400), %g1 /* * 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 *) 40006a94: 83 2e a0 03 sll %i2, 3, %g1 <== NOT EXECUTED 40006a98: a1 2e a0 05 sll %i2, 5, %l0 <== NOT EXECUTED 40006a9c: a0 24 00 01 sub %l0, %g1, %l0 <== NOT EXECUTED 40006aa0: 40 00 0f cf call 4000a9dc <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 40006aa4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 40006aa8: 03 10 00 6d sethi %hi(0x4001b400), %g1 <== NOT EXECUTED memset( 40006aac: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED _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; 40006ab0: f4 20 61 94 st %i2, [ %g1 + 0x194 ] <== NOT EXECUTED /* * 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 *) 40006ab4: 21 10 00 6d sethi %hi(0x4001b400), %l0 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 40006ab8: 92 10 20 00 clr %o1 <== NOT EXECUTED 40006abc: 40 00 22 ce call 4000f5f4 <== NOT EXECUTED 40006ac0: d0 24 21 98 st %o0, [ %l0 + 0x198 ] <== NOT EXECUTED _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 40006ac4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40006ac8: 02 80 00 16 be 40006b20 <_IO_Manager_initialization+0x9c> <== NOT EXECUTED 40006acc: d4 04 21 98 ld [ %l0 + 0x198 ], %o2 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40006ad0: 96 10 20 00 clr %o3 <== NOT EXECUTED 40006ad4: 98 10 20 00 clr %o4 <== NOT EXECUTED 40006ad8: c2 03 00 18 ld [ %o4 + %i0 ], %g1 <== NOT EXECUTED 40006adc: 9a 03 00 18 add %o4, %i0, %o5 <== NOT EXECUTED 40006ae0: c2 23 00 0a st %g1, [ %o4 + %o2 ] <== NOT EXECUTED 40006ae4: c4 03 60 04 ld [ %o5 + 4 ], %g2 <== NOT EXECUTED 40006ae8: 86 03 00 0a add %o4, %o2, %g3 <== NOT EXECUTED 40006aec: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED 40006af0: c2 03 60 08 ld [ %o5 + 8 ], %g1 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 40006af4: 96 02 e0 01 inc %o3 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40006af8: c2 20 e0 08 st %g1, [ %g3 + 8 ] <== NOT EXECUTED 40006afc: c4 03 60 0c ld [ %o5 + 0xc ], %g2 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 40006b00: 98 03 20 18 add %o4, 0x18, %o4 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40006b04: c4 20 e0 0c st %g2, [ %g3 + 0xc ] <== NOT EXECUTED 40006b08: c8 03 60 10 ld [ %o5 + 0x10 ], %g4 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 40006b0c: 80 a2 c0 19 cmp %o3, %i1 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40006b10: c8 20 e0 10 st %g4, [ %g3 + 0x10 ] <== NOT EXECUTED 40006b14: c2 03 60 14 ld [ %o5 + 0x14 ], %g1 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 40006b18: 12 bf ff f0 bne 40006ad8 <_IO_Manager_initialization+0x54> <== NOT EXECUTED 40006b1c: c2 20 e0 14 st %g1, [ %g3 + 0x14 ] <== NOT EXECUTED 40006b20: 81 c7 e0 08 ret <== NOT EXECUTED 40006b24: 81 e8 00 00 restore <== NOT EXECUTED * 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; _IO_Number_of_drivers = number_of_drivers; 40006b28: 05 10 00 6d sethi %hi(0x4001b400), %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; 40006b2c: f0 20 61 98 st %i0, [ %g1 + 0x198 ] _IO_Number_of_drivers = number_of_drivers; 40006b30: f2 20 a1 94 st %i1, [ %g2 + 0x194 ] 40006b34: 81 c7 e0 08 ret 40006b38: 81 e8 00 00 restore 400077bc <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 400077bc: 9d e3 bf 98 save %sp, -104, %sp _ISR_Signals_to_thread_executing = FALSE; 400077c0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _ISR_Nest_level = 0; 400077c4: 05 10 00 6b sethi %hi(0x4001ac00), %g2 * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { _ISR_Signals_to_thread_executing = FALSE; 400077c8: c0 20 60 e8 clr [ %g1 + 0xe8 ] _ISR_Nest_level = 0; 400077cc: c0 20 a0 24 clr [ %g2 + 0x24 ] _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 400077d0: 40 00 0c 83 call 4000a9dc <_Workspace_Allocate_or_fatal_error> 400077d4: 90 10 24 00 mov 0x400, %o0 _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 400077d8: 03 10 00 6a sethi %hi(0x4001a800), %g1 400077dc: a0 10 63 74 or %g1, 0x374, %l0 ! 4001ab74 <_CPU_Table> 400077e0: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 { _ISR_Signals_to_thread_executing = FALSE; _ISR_Nest_level = 0; _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 400077e4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 400077e8: 80 a0 af ff cmp %g2, 0xfff 400077ec: 18 80 00 07 bgu 40007808 <_ISR_Handler_initialization+0x4c> 400077f0: d0 20 60 04 st %o0, [ %g1 + 4 ] _Internal_error_Occurred( 400077f4: 90 10 20 00 clr %o0 <== NOT EXECUTED 400077f8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400077fc: 7f ff ff e0 call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 40007800: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED 40007804: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 40007808: 40 00 0c 75 call 4000a9dc <_Workspace_Allocate_or_fatal_error> 4000780c: 90 10 00 02 mov %g2, %o0 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 40007810: c6 04 20 18 ld [ %l0 + 0x18 ], %g3 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 40007814: 03 10 00 6a sethi %hi(0x4001a800), %g1 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 40007818: 86 02 00 03 add %o0, %g3, %g3 4000781c: 05 10 00 6a sethi %hi(0x4001a800), %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 40007820: d0 20 63 70 st %o0, [ %g1 + 0x370 ] _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 40007824: c6 20 a2 bc st %g3, [ %g2 + 0x2bc ] #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 40007828: 81 c7 e0 08 ret 4000782c: 81 e8 00 00 restore 40019fb0 <_Objects_Copy_name_raw>: const size_t length ) { uint32_t *source_p = (uint32_t *) source; uint32_t *destination_p = (uint32_t *) destination; size_t tmp_length = length / OBJECTS_NAME_ALIGNMENT; 40019fb0: 95 32 a0 02 srl %o2, 2, %o2 <== NOT EXECUTED while ( tmp_length-- ) 40019fb4: 80 a2 a0 00 cmp %o2, 0 <== NOT EXECUTED 40019fb8: 02 80 00 09 be 40019fdc <_Objects_Copy_name_raw+0x2c> <== NOT EXECUTED 40019fbc: 86 10 20 00 clr %g3 <== NOT EXECUTED 40019fc0: 84 10 20 00 clr %g2 <== NOT EXECUTED *destination_p++ = *source_p++; 40019fc4: c2 00 80 08 ld [ %g2 + %o0 ], %g1 <== NOT EXECUTED 40019fc8: 86 00 e0 01 inc %g3 <== NOT EXECUTED 40019fcc: c2 20 80 09 st %g1, [ %g2 + %o1 ] <== NOT EXECUTED { uint32_t *source_p = (uint32_t *) source; uint32_t *destination_p = (uint32_t *) destination; size_t tmp_length = length / OBJECTS_NAME_ALIGNMENT; while ( tmp_length-- ) 40019fd0: 80 a0 c0 0a cmp %g3, %o2 <== NOT EXECUTED 40019fd4: 12 bf ff fc bne 40019fc4 <_Objects_Copy_name_raw+0x14> <== NOT EXECUTED 40019fd8: 84 00 a0 04 add %g2, 4, %g2 <== NOT EXECUTED 40019fdc: 81 c3 e0 08 retl <== NOT EXECUTED 40019fe0: 01 00 00 00 nop 400078e4 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 400078e4: 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; 400078e8: 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 ) 400078ec: e4 16 20 10 lduh [ %i0 + 0x10 ], %l2 400078f0: 03 00 00 3f sethi %hi(0xfc00), %g1 400078f4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400078f8: a2 08 80 01 and %g2, %g1, %l1 400078fc: 80 a4 40 12 cmp %l1, %l2 40007900: 08 80 00 8c bleu 40007b30 <_Objects_Extend_information+0x24c> 40007904: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 40007908: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; if ( information->maximum < minimum_index ) 4000790c: a8 10 00 11 mov %l1, %l4 40007910: ac 10 20 00 clr %l6 40007914: a6 10 20 01 mov 1, %l3 40007918: 90 10 20 03 mov 3, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 4000791c: 80 a0 60 00 cmp %g1, 0 40007920: 12 80 00 a4 bne 40007bb0 <_Objects_Extend_information+0x2cc> 40007924: ba 04 00 12 add %l0, %l2, %i5 if ( !object_blocks ) return; } else { object_blocks = (void**) 40007928: 90 02 00 11 add %o0, %l1, %o0 4000792c: 90 02 00 1d add %o0, %i5, %o0 40007930: 40 00 0c 2b call 4000a9dc <_Workspace_Allocate_or_fatal_error> 40007934: 91 2a 20 02 sll %o0, 2, %o0 40007938: ae 10 00 08 mov %o0, %l7 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 4000793c: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 40007940: 83 2c e0 02 sll %l3, 2, %g1 /* * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; 40007944: 86 04 ff ff add %l3, -1, %g3 if ( information->maximum > minimum_index ) { 40007948: 80 a4 40 02 cmp %l1, %g2 /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 4000794c: a6 05 c0 01 add %l7, %g1, %l3 object_blocks, block_count * sizeof(void*) ); name_table = (Objects_Name *) _Addresses_Add_offset( 40007950: aa 00 40 13 add %g1, %l3, %l5 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 40007954: 0a 80 00 ac bcs 40007c04 <_Objects_Extend_information+0x320> 40007958: a4 00 40 15 add %g1, %l5, %l2 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 4000795c: 80 a4 60 00 cmp %l1, 0 40007960: 02 80 00 09 be 40007984 <_Objects_Extend_information+0xa0> 40007964: a1 28 e0 02 sll %g3, 2, %l0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 40007968: 84 10 20 00 clr %g2 /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 4000796c: 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++ ) { 40007970: 84 00 a0 01 inc %g2 40007974: 80 a0 80 11 cmp %g2, %l1 40007978: 12 bf ff fd bne 4000796c <_Objects_Extend_information+0x88> 4000797c: c0 20 40 12 clr [ %g1 + %l2 ] 40007980: a1 28 e0 02 sll %g3, 2, %l0 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 40007984: c0 24 00 17 clr [ %l0 + %l7 ] inactive_per_block[block_count] = 0; 40007988: c0 24 00 13 clr [ %l0 + %l3 ] name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); 4000798c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40007990: 86 05 00 01 add %l4, %g1, %g3 40007994: 80 a0 c0 14 cmp %g3, %l4 40007998: 08 80 00 0a bleu 400079c0 <_Objects_Extend_information+0xdc> 4000799c: c0 25 40 10 clr [ %l5 + %l0 ] 400079a0: 83 2d 20 02 sll %l4, 2, %g1 400079a4: 84 04 80 01 add %l2, %g1, %g2 400079a8: 82 10 00 14 mov %l4, %g1 index++ ) { local_table[ index ] = NULL; 400079ac: c0 20 80 00 clr [ %g2 ] inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 400079b0: 82 00 60 01 inc %g1 object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); 400079b4: 80 a0 40 03 cmp %g1, %g3 400079b8: 12 bf ff fd bne 400079ac <_Objects_Extend_information+0xc8> 400079bc: 84 00 a0 04 add %g2, 4, %g2 index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 400079c0: 7f ff e9 0d call 40001df4 400079c4: 01 00 00 00 nop information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 400079c8: c4 06 00 00 ld [ %i0 ], %g2 400079cc: c8 16 20 04 lduh [ %i0 + 4 ], %g4 400079d0: 87 2f 60 10 sll %i5, 0x10, %g3 400079d4: 89 29 20 1b sll %g4, 0x1b, %g4 400079d8: 87 30 e0 10 srl %g3, 0x10, %g3 local_table[ index ] = NULL; } _ISR_Disable( level ); old_tables = information->object_blocks; 400079dc: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 400079e0: 03 00 00 40 sethi %hi(0x10000), %g1 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; 400079e4: e6 26 20 38 st %l3, [ %i0 + 0x38 ] information->name_table = name_table; 400079e8: ea 26 20 24 st %l5, [ %i0 + 0x24 ] information->local_table = local_table; 400079ec: e4 26 20 20 st %l2, [ %i0 + 0x20 ] information->maximum = maximum; information->maximum_id = _Objects_Build_id( 400079f0: 85 28 a0 18 sll %g2, 0x18, %g2 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; 400079f4: fa 36 20 10 sth %i5, [ %i0 + 0x10 ] information->maximum_id = _Objects_Build_id( 400079f8: 84 10 80 01 or %g2, %g1, %g2 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; 400079fc: ee 26 20 3c st %l7, [ %i0 + 0x3c ] information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 40007a00: 84 10 80 04 or %g2, %g4, %g2 40007a04: 84 10 80 03 or %g2, %g3, %g2 40007a08: c4 26 20 0c st %g2, [ %i0 + 0xc ] information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 40007a0c: 7f ff e8 fe call 40001e04 40007a10: 01 00 00 00 nop if ( old_tables ) 40007a14: 80 a4 20 00 cmp %l0, 0 40007a18: 02 80 00 05 be 40007a2c <_Objects_Extend_information+0x148> 40007a1c: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 40007a20: 11 10 00 6a sethi %hi(0x4001a800), %o0 40007a24: 7f ff fe 56 call 4000737c <_Heap_Free> 40007a28: 90 12 23 ac or %o0, 0x3ac, %o0 ! 4001abac <_Workspace_Area> /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 40007a2c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40007a30: 80 a0 60 00 cmp %g1, 0 40007a34: 02 80 00 6a be 40007bdc <_Objects_Extend_information+0x2f8> 40007a38: c2 16 20 44 lduh [ %i0 + 0x44 ], %g1 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 40007a3c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40007a40: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 information->object_blocks[ block ] = 40007a44: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 40007a48: 40 00 38 d8 call 40015da8 <.umul> 40007a4c: 90 00 40 08 add %g1, %o0, %o0 40007a50: 92 10 00 08 mov %o0, %o1 40007a54: 11 10 00 6a sethi %hi(0x4001a800), %o0 40007a58: 7f ff fe 17 call 400072b4 <_Heap_Allocate> 40007a5c: 90 12 23 ac or %o0, 0x3ac, %o0 ! 4001abac <_Workspace_Area> _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 40007a60: e4 06 20 3c ld [ %i0 + 0x3c ], %l2 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { information->object_blocks[ block ] = 40007a64: a7 2d a0 02 sll %l6, 2, %l3 40007a68: d0 24 c0 10 st %o0, [ %l3 + %l0 ] _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 40007a6c: c2 04 c0 12 ld [ %l3 + %l2 ], %g1 40007a70: 80 a0 60 00 cmp %g1, 0 40007a74: 02 80 00 7b be 40007c60 <_Objects_Extend_information+0x37c> 40007a78: 01 00 00 00 nop 40007a7c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40007a80: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 40007a84: 40 00 38 c9 call 40015da8 <.umul> 40007a88: a2 10 00 14 mov %l4, %l1 40007a8c: c2 04 80 13 ld [ %l2 + %l3 ], %g1 name_area = (Objects_Name *) _Addresses_Add_offset( information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 40007a90: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 40007a94: a0 02 00 01 add %o0, %g1, %l0 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 40007a98: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 name_area = (Objects_Name *) _Addresses_Add_offset( information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 40007a9c: e0 20 80 13 st %l0, [ %g2 + %l3 ] /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 40007aa0: d6 06 20 1c ld [ %i0 + 0x1c ], %o3 40007aa4: d2 04 80 13 ld [ %l2 + %l3 ], %o1 40007aa8: a8 07 bf ec add %fp, -20, %l4 index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 40007aac: 2b 00 00 40 sethi %hi(0x10000), %l5 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 40007ab0: 90 10 00 14 mov %l4, %o0 40007ab4: 40 00 16 42 call 4000d3bc <_Chain_Initialize> 40007ab8: a4 06 20 28 add %i0, 0x28, %l2 40007abc: 30 80 00 0f b,a 40007af8 <_Objects_Extend_information+0x214> index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 40007ac0: c4 16 20 04 lduh [ %i0 + 4 ], %g2 40007ac4: c6 16 20 44 lduh [ %i0 + 0x44 ], %g3 40007ac8: 83 28 60 18 sll %g1, 0x18, %g1 40007acc: 85 28 a0 1b sll %g2, 0x1b, %g2 40007ad0: 82 10 40 15 or %g1, %l5, %g1 40007ad4: 82 10 40 02 or %g1, %g2, %g1 40007ad8: 82 10 40 11 or %g1, %l1, %g1 information->the_class, _Objects_Local_node, index ); the_object->name = (void *) name_area; 40007adc: e0 22 20 0c st %l0, [ %o0 + 0xc ] index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 40007ae0: c2 22 20 08 st %g1, [ %o0 + 8 ] the_object->name = (void *) name_area; name_area = _Addresses_Add_offset( name_area, information->name_length ); _Chain_Append( &information->Inactive, &the_object->Node ); 40007ae4: 92 10 00 08 mov %o0, %o1 40007ae8: a0 04 00 03 add %l0, %g3, %l0 index++; 40007aec: a2 04 60 01 inc %l1 the_object->name = (void *) name_area; name_area = _Addresses_Add_offset( name_area, information->name_length ); _Chain_Append( &information->Inactive, &the_object->Node ); 40007af0: 7f ff fc a0 call 40006d70 <_Chain_Append> 40007af4: 90 10 00 12 mov %l2, %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 ) { 40007af8: 7f ff fc aa call 40006da0 <_Chain_Get> 40007afc: 90 10 00 14 mov %l4, %o0 40007b00: 80 a2 20 00 cmp %o0, 0 40007b04: 32 bf ff ef bne,a 40007ac0 <_Objects_Extend_information+0x1dc> 40007b08: c2 06 00 00 ld [ %i0 ], %g1 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 40007b0c: c6 06 20 38 ld [ %i0 + 0x38 ], %g3 40007b10: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 information->inactive += information->allocation_size; 40007b14: c8 16 20 34 lduh [ %i0 + 0x34 ], %g4 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 40007b18: c4 20 c0 13 st %g2, [ %g3 + %l3 ] information->inactive += information->allocation_size; 40007b1c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40007b20: 82 00 40 04 add %g1, %g4, %g1 40007b24: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 40007b28: 81 c7 e0 08 ret 40007b2c: 81 e8 00 00 restore block = 0; if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; 40007b30: 90 10 00 12 mov %l2, %o0 40007b34: 40 00 38 d7 call 40015e90 <.udiv> 40007b38: 92 10 00 10 mov %l0, %o1 for ( ; block < block_count; block++ ) { 40007b3c: 80 a2 20 00 cmp %o0, 0 40007b40: 02 80 00 46 be 40007c58 <_Objects_Extend_information+0x374> 40007b44: a8 10 00 11 mov %l1, %l4 if ( information->object_blocks[ block ] == NULL ) 40007b48: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 40007b4c: c2 00 80 00 ld [ %g2 ], %g1 40007b50: 80 a0 60 00 cmp %g1, 0 40007b54: 12 80 00 08 bne 40007b74 <_Objects_Extend_information+0x290> 40007b58: ac 10 20 00 clr %l6 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 40007b5c: 10 80 00 0c b 40007b8c <_Objects_Extend_information+0x2a8> <== NOT EXECUTED 40007b60: 80 a5 00 12 cmp %l4, %l2 <== NOT EXECUTED block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 40007b64: c2 00 40 02 ld [ %g1 + %g2 ], %g1 40007b68: 80 a0 60 00 cmp %g1, 0 40007b6c: 02 80 00 08 be 40007b8c <_Objects_Extend_information+0x2a8> 40007b70: 80 a5 00 12 cmp %l4, %l2 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 40007b74: ac 05 a0 01 inc %l6 if ( information->object_blocks[ block ] == NULL ) break; else index_base += information->allocation_size; 40007b78: a8 05 00 10 add %l4, %l0, %l4 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 40007b7c: 80 a5 80 08 cmp %l6, %o0 40007b80: 12 bf ff f9 bne 40007b64 <_Objects_Extend_information+0x280> 40007b84: 83 2d a0 02 sll %l6, 2, %g1 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 40007b88: 80 a5 00 12 cmp %l4, %l2 40007b8c: 2a bf ff a9 bcs,a 40007a30 <_Objects_Extend_information+0x14c> 40007b90: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40007b94: a6 02 20 01 add %o0, 1, %l3 40007b98: 83 2c e0 01 sll %l3, 1, %g1 40007b9c: 90 00 40 13 add %g1, %l3, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 40007ba0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40007ba4: 80 a0 60 00 cmp %g1, 0 40007ba8: 02 bf ff 60 be 40007928 <_Objects_Extend_information+0x44> 40007bac: ba 04 00 12 add %l0, %l2, %i5 40007bb0: 92 02 00 11 add %o0, %l1, %o1 40007bb4: 11 10 00 6a sethi %hi(0x4001a800), %o0 40007bb8: 92 02 40 1d add %o1, %i5, %o1 40007bbc: 90 12 23 ac or %o0, 0x3ac, %o0 40007bc0: 7f ff fd bd call 400072b4 <_Heap_Allocate> 40007bc4: 93 2a 60 02 sll %o1, 2, %o1 block_count * (sizeof(void *) + sizeof(uint32_t ) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 40007bc8: ae 92 20 00 orcc %o0, 0, %l7 40007bcc: 32 bf ff 5d bne,a 40007940 <_Objects_Extend_information+0x5c> 40007bd0: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 40007bd4: 81 c7 e0 08 ret <== NOT EXECUTED 40007bd8: 81 e8 00 00 restore <== NOT EXECUTED if ( !information->object_blocks[ block ] ) return; } else { information->object_blocks[ block ] = 40007bdc: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 40007be0: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40007be4: 40 00 38 71 call 40015da8 <.umul> 40007be8: 90 00 40 08 add %g1, %o0, %o0 40007bec: 40 00 0b 7c call 4000a9dc <_Workspace_Allocate_or_fatal_error> 40007bf0: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 40007bf4: e4 06 20 3c ld [ %i0 + 0x3c ], %l2 40007bf8: a7 2d a0 02 sll %l6, 2, %l3 40007bfc: 10 bf ff a0 b 40007a7c <_Objects_Extend_information+0x198> 40007c00: d0 24 c0 10 st %o0, [ %l3 + %l0 ] /* * 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, 40007c04: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 40007c08: a1 28 e0 02 sll %g3, 2, %l0 40007c0c: 90 10 00 17 mov %l7, %o0 40007c10: 40 00 1e 4c call 4000f540 40007c14: 94 10 00 10 mov %l0, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 40007c18: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 40007c1c: 94 10 00 10 mov %l0, %o2 40007c20: 40 00 1e 48 call 4000f540 40007c24: 90 10 00 13 mov %l3, %o0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, 40007c28: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 40007c2c: 94 10 00 10 mov %l0, %o2 40007c30: 40 00 1e 44 call 4000f540 40007c34: 90 10 00 15 mov %l5, %o0 information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 40007c38: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 40007c3c: d2 06 20 20 ld [ %i0 + 0x20 ], %o1 40007c40: 94 02 80 11 add %o2, %l1, %o2 40007c44: 90 10 00 12 mov %l2, %o0 40007c48: 40 00 1e 3e call 4000f540 40007c4c: 95 2a a0 02 sll %o2, 2, %o2 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 40007c50: 10 bf ff 4e b 40007988 <_Objects_Extend_information+0xa4> 40007c54: c0 24 00 17 clr [ %l0 + %l7 ] if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 40007c58: 10 bf ff cc b 40007b88 <_Objects_Extend_information+0x2a4> <== NOT EXECUTED 40007c5c: ac 10 20 00 clr %l6 <== NOT EXECUTED 40007c60: 81 c7 e0 08 ret <== NOT EXECUTED 40007c64: 81 e8 00 00 restore <== NOT EXECUTED 40009810 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 40009810: 9d e3 bf 88 save %sp, -120, %sp 40009814: 92 10 00 18 mov %i0, %o1 uint32_t i; char lname[5]; Objects_Control *the_object; Objects_Locations location; if ( length == 0 ) 40009818: 80 a6 60 00 cmp %i1, 0 4000981c: 12 80 00 04 bne 4000982c <_Objects_Get_name_as_string+0x1c> 40009820: b0 10 00 1a mov %i2, %i0 _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 40009824: 81 c7 e0 08 ret <== NOT EXECUTED 40009828: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED Objects_Locations location; if ( length == 0 ) return NULL; if ( name == NULL ) 4000982c: 80 a6 a0 00 cmp %i2, 0 40009830: 02 80 00 40 be 40009930 <_Objects_Get_name_as_string+0x120> 40009834: 87 32 60 16 srl %o1, 0x16, %g3 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 40009838: 03 10 00 9d sethi %hi(0x40027400), %g1 4000983c: 86 08 e0 1c and %g3, 0x1c, %g3 40009840: 82 10 63 f0 or %g1, 0x3f0, %g1 40009844: c8 00 40 03 ld [ %g1 + %g3 ], %g4 40009848: 85 32 60 1b srl %o1, 0x1b, %g2 4000984c: 85 28 a0 02 sll %g2, 2, %g2 40009850: f4 01 00 02 ld [ %g4 + %g2 ], %i2 return NULL; information = _Objects_Get_information( id ); if ( !information ) 40009854: 80 a6 a0 00 cmp %i2, 0 40009858: 22 80 00 36 be,a 40009930 <_Objects_Get_name_as_string+0x120> 4000985c: b0 10 20 00 clr %i0 <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, id, &location ); 40009860: 90 10 00 1a mov %i2, %o0 40009864: 40 00 00 3f call 40009960 <_Objects_Get> 40009868: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 4000986c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009870: 80 a0 60 00 cmp %g1, 0 40009874: 32 80 00 2f bne,a 40009930 <_Objects_Get_name_as_string+0x120> 40009878: b0 10 20 00 clr %i0 <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 4000987c: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1 40009880: 80 a0 60 00 cmp %g1, 0 40009884: 22 80 00 2d be,a 40009938 <_Objects_Get_name_as_string+0x128> 40009888: c2 02 20 0c ld [ %o0 + 0xc ], %g1 s = the_object->name; 4000988c: d0 02 20 0c ld [ %o0 + 0xc ], %o0 lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { 40009890: 80 a6 60 01 cmp %i1, 1 40009894: 02 80 00 1c be 40009904 <_Objects_Get_name_as_string+0xf4> 40009898: 9a 10 00 18 mov %i0, %o5 4000989c: c8 0a 00 00 ldub [ %o0 ], %g4 400098a0: 85 29 20 18 sll %g4, 0x18, %g2 400098a4: 80 a0 a0 00 cmp %g2, 0 400098a8: 22 80 00 18 be,a 40009908 <_Objects_Get_name_as_string+0xf8> 400098ac: c0 2b 40 00 clrb [ %o5 ] <== NOT EXECUTED 400098b0: b2 06 7f ff add %i1, -1, %i1 400098b4: 98 10 20 00 clr %o4 400098b8: 10 80 00 07 b 400098d4 <_Objects_Get_name_as_string+0xc4> 400098bc: 17 10 00 7c sethi %hi(0x4001f000), %o3 400098c0: c8 0a 00 00 ldub [ %o0 ], %g4 400098c4: 85 29 20 18 sll %g4, 0x18, %g2 400098c8: 80 a0 a0 00 cmp %g2, 0 400098cc: 22 80 00 0f be,a 40009908 <_Objects_Get_name_as_string+0xf8> 400098d0: c0 2b 40 00 clrb [ %o5 ] <== NOT EXECUTED *d = (!isprint(*s)) ? '*' : *s; 400098d4: c2 02 e2 10 ld [ %o3 + 0x210 ], %g1 400098d8: 85 38 a0 18 sra %g2, 0x18, %g2 400098dc: c6 48 80 01 ldsb [ %g2 + %g1 ], %g3 400098e0: 80 88 e0 97 btst 0x97, %g3 400098e4: 12 80 00 03 bne 400098f0 <_Objects_Get_name_as_string+0xe0> 400098e8: 90 02 20 01 inc %o0 400098ec: 88 10 20 2a mov 0x2a, %g4 <== NOT EXECUTED 400098f0: c8 2b 40 00 stb %g4, [ %o5 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { 400098f4: 98 03 20 01 inc %o4 400098f8: 80 a3 00 19 cmp %o4, %i1 400098fc: 12 bf ff f1 bne 400098c0 <_Objects_Get_name_as_string+0xb0> 40009900: 9a 03 60 01 inc %o5 *d = (!isprint(*s)) ? '*' : *s; } *d = '\0'; 40009904: c0 2b 40 00 clrb [ %o5 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40009908: 03 10 00 9e sethi %hi(0x40027800), %g1 4000990c: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 40027890 <_Thread_Dispatch_disable_level> 40009910: 84 00 bf ff add %g2, -1, %g2 40009914: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 40009918: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 4000991c: 80 a0 e0 00 cmp %g3, 0 40009920: 12 80 00 04 bne 40009930 <_Objects_Get_name_as_string+0x120> 40009924: 01 00 00 00 nop _Thread_Dispatch(); 40009928: 40 00 04 fa call 4000ad10 <_Thread_Dispatch> 4000992c: 01 00 00 00 nop 40009930: 81 c7 e0 08 ret 40009934: 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'; 40009938: c0 2f bf f3 clrb [ %fp + -13 ] if ( information->is_string ) { s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; 4000993c: 85 30 60 18 srl %g1, 0x18, %g2 lname[ 1 ] = (u32_name >> 16) & 0xff; 40009940: 87 30 60 10 srl %g1, 0x10, %g3 lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; 40009944: c2 2f bf f2 stb %g1, [ %fp + -14 ] if ( information->is_string ) { s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; 40009948: c4 2f bf ef stb %g2, [ %fp + -17 ] lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 4000994c: 83 30 60 08 srl %g1, 8, %g1 s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; 40009950: c6 2f bf f0 stb %g3, [ %fp + -16 ] lname[ 2 ] = (u32_name >> 8) & 0xff; 40009954: c2 2f bf f1 stb %g1, [ %fp + -15 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 40009958: 10 bf ff ce b 40009890 <_Objects_Get_name_as_string+0x80> 4000995c: 90 07 bf ef add %fp, -17, %o0 40019fe4 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 40019fe4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Objects_Control *object; Objects_Id next_id; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 40019fe8: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 40019fec: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <== NOT EXECUTED 40019ff0: 80 8e 40 01 btst %i1, %g1 <== NOT EXECUTED 40019ff4: 22 80 00 02 be,a 40019ffc <_Objects_Get_next+0x18> <== NOT EXECUTED 40019ff8: f2 06 20 08 ld [ %i0 + 8 ], %i1 <== NOT EXECUTED else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 40019ffc: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 4001a000: a0 10 63 ff or %g1, 0x3ff, %l0 ! ffff <== NOT EXECUTED 4001a004: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED 4001a008: 82 0e 40 10 and %i1, %l0, %g1 <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 4001a00c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001a010: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 4001a014: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 4001a018: 18 80 00 0b bgu 4001a044 <_Objects_Get_next+0x60> <== NOT EXECUTED 4001a01c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 4001a020: 7f ff d3 ea call 4000efc8 <_Objects_Get> <== NOT EXECUTED 4001a024: b2 06 60 01 inc %i1 <== NOT EXECUTED next_id++; } while (*location_p != OBJECTS_LOCAL); 4001a028: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 4001a02c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001a030: 32 bf ff f6 bne,a 4001a008 <_Objects_Get_next+0x24> <== NOT EXECUTED 4001a034: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED *next_id_p = next_id; 4001a038: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 4001a03c: 81 c7 e0 08 ret <== NOT EXECUTED 4001a040: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 4001a044: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 4001a048: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED 4001a04c: 90 10 20 00 clr %o0 <== NOT EXECUTED do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 4001a050: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 4001a054: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED return 0; } 4001a058: 81 c7 e0 08 ret <== NOT EXECUTED 4001a05c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 4001556c <_Objects_Get_no_protection>: ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 4001556c: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->maximum >= index ) { 40015570: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 40015574: 92 22 40 01 sub %o1, %g1, %o1 40015578: 82 02 60 01 add %o1, 1, %g1 if ( information->maximum >= index ) { 4001557c: 80 a0 40 02 cmp %g1, %g2 40015580: 18 80 00 09 bgu 400155a4 <_Objects_Get_no_protection+0x38> 40015584: 83 28 60 02 sll %g1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 40015588: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4001558c: d0 00 80 01 ld [ %g2 + %g1 ], %o0 40015590: 80 a2 20 00 cmp %o0, 0 40015594: 02 80 00 08 be 400155b4 <_Objects_Get_no_protection+0x48> 40015598: 82 10 20 02 mov 2, %g1 *location = OBJECTS_LOCAL; 4001559c: 81 c3 e0 08 retl 400155a0: c0 22 80 00 clr [ %o2 ] return the_object; } *location = OBJECTS_ERROR; return NULL; } *location = OBJECTS_ERROR; 400155a4: 82 10 20 02 mov 2, %g1 400155a8: 90 10 20 00 clr %o0 /* * Not supported for multiprocessing */ return NULL; } 400155ac: 81 c3 e0 08 retl 400155b0: c2 22 80 00 st %g1, [ %o2 ] if ( information->maximum >= index ) { if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; return the_object; } *location = OBJECTS_ERROR; 400155b4: 81 c3 e0 08 retl <== NOT EXECUTED 400155b8: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED 40007fd8 <_Objects_Handler_initialization>: uint32_t node, uint32_t maximum_nodes, uint32_t maximum_global_objects ) { if ( node < 1 || node > maximum_nodes ) 40007fd8: 80 a2 20 00 cmp %o0, 0 40007fdc: 22 80 00 07 be,a 40007ff8 <_Objects_Handler_initialization+0x20> 40007fe0: 90 10 20 00 clr %o0 <== NOT EXECUTED 40007fe4: 80 a2 00 09 cmp %o0, %o1 40007fe8: 18 80 00 04 bgu 40007ff8 <_Objects_Handler_initialization+0x20> 40007fec: 90 10 20 00 clr %o0 40007ff0: 81 c3 e0 08 retl 40007ff4: 01 00 00 00 nop _Internal_error_Occurred( 40007ff8: 92 10 20 01 mov 1, %o1 ! 1 <== NOT EXECUTED 40007ffc: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED 40008000: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40008004: 7f ff fd de call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 40008008: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 4000800c: 01 00 00 00 nop 4000930c <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 4000930c: 9d e3 bf 90 save %sp, -112, %sp 40009310: 92 10 00 18 mov %i0, %o1 uint32_t the_class; Objects_Information *information; Objects_Control *the_object = (Objects_Control *) 0; Objects_Locations ignored_location; if ( !name ) 40009314: 80 a6 60 00 cmp %i1, 0 40009318: 02 80 00 24 be 400093a8 <_Objects_Id_to_name+0x9c> 4000931c: b0 10 20 01 mov 1, %i0 */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40009320: 83 32 60 18 srl %o1, 0x18, %g1 40009324: 82 08 60 07 and %g1, 7, %g1 return OBJECTS_INVALID_NAME; the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) 40009328: 80 a0 60 04 cmp %g1, 4 4000932c: 18 80 00 25 bgu 400093c0 <_Objects_Id_to_name+0xb4> 40009330: 87 28 60 02 sll %g1, 2, %g3 return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( id ); information = _Objects_Information_table[ the_api ][ the_class ]; 40009334: 03 10 00 7d sethi %hi(0x4001f400), %g1 40009338: 82 10 61 50 or %g1, 0x150, %g1 ! 4001f550 <_Objects_Information_table> 4000933c: c8 00 40 03 ld [ %g1 + %g3 ], %g4 40009340: 85 32 60 1b srl %o1, 0x1b, %g2 40009344: 85 28 a0 02 sll %g2, 2, %g2 40009348: d0 01 00 02 ld [ %g4 + %g2 ], %o0 if ( !information ) 4000934c: 80 a2 20 00 cmp %o0, 0 40009350: 02 80 00 1c be 400093c0 <_Objects_Id_to_name+0xb4> 40009354: 01 00 00 00 nop return OBJECTS_INVALID_ID; if ( information->is_string ) 40009358: c2 02 20 40 ld [ %o0 + 0x40 ], %g1 4000935c: 80 a0 60 00 cmp %g1, 0 40009360: 12 80 00 18 bne 400093c0 <_Objects_Id_to_name+0xb4> 40009364: 01 00 00 00 nop return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, id, &ignored_location ); 40009368: 7f ff ff c2 call 40009270 <_Objects_Get> 4000936c: 94 07 bf f4 add %fp, -12, %o2 if ( !the_object ) 40009370: 80 a2 20 00 cmp %o0, 0 40009374: 02 80 00 13 be 400093c0 <_Objects_Id_to_name+0xb4> 40009378: 01 00 00 00 nop return OBJECTS_INVALID_ID; *name = the_object->name; 4000937c: c2 02 20 0c ld [ %o0 + 0xc ], %g1 40009380: c2 26 40 00 st %g1, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40009384: 07 10 00 7d sethi %hi(0x4001f400), %g3 40009388: c2 00 e1 f0 ld [ %g3 + 0x1f0 ], %g1 ! 4001f5f0 <_Thread_Dispatch_disable_level> 4000938c: b0 10 20 00 clr %i0 40009390: 82 00 7f ff add %g1, -1, %g1 40009394: c2 20 e1 f0 st %g1, [ %g3 + 0x1f0 ] 40009398: c4 00 e1 f0 ld [ %g3 + 0x1f0 ], %g2 4000939c: 80 a0 a0 00 cmp %g2, 0 400093a0: 02 80 00 04 be 400093b0 <_Objects_Id_to_name+0xa4> 400093a4: 01 00 00 00 nop _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 400093a8: 81 c7 e0 08 ret <== NOT EXECUTED 400093ac: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 400093b0: 40 00 05 07 call 4000a7cc <_Thread_Dispatch> 400093b4: 01 00 00 00 nop 400093b8: 81 c7 e0 08 ret 400093bc: 81 e8 00 00 restore 400093c0: 81 c7 e0 08 ret <== NOT EXECUTED 400093c4: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED 40007ee8 <_Objects_Name_to_id>: Objects_Information *information, Objects_Name name, uint32_t node, Objects_Id *id ) { 40007ee8: 9d e3 bf 98 save %sp, -104, %sp 40007eec: a2 10 00 18 mov %i0, %l1 Objects_Control *the_object; uint32_t index; uint32_t name_length; Objects_Name_comparators compare_them; if ( !id ) 40007ef0: 80 a6 e0 00 cmp %i3, 0 40007ef4: 02 80 00 2d be 40007fa8 <_Objects_Name_to_id+0xc0> 40007ef8: b0 10 20 02 mov 2, %i0 return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 40007efc: 80 a6 60 00 cmp %i1, 0 40007f00: 02 80 00 28 be 40007fa0 <_Objects_Name_to_id+0xb8> 40007f04: 01 00 00 00 nop return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40007f08: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 40007f0c: 86 90 60 00 orcc %g1, 0, %g3 40007f10: 02 80 00 24 be 40007fa0 <_Objects_Name_to_id+0xb8> 40007f14: 80 a6 a0 00 cmp %i2, 0 40007f18: 12 80 00 26 bne 40007fb0 <_Objects_Name_to_id+0xc8> 40007f1c: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; 40007f20: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 40007f24: 05 10 00 36 sethi %hi(0x4000d800), %g2 40007f28: 80 a0 60 00 cmp %g1, 0 40007f2c: a4 10 a0 10 or %g2, 0x10, %l2 40007f30: 02 80 00 04 be 40007f40 <_Objects_Name_to_id+0x58> 40007f34: c8 14 60 44 lduh [ %l1 + 0x44 ], %g4 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40007f38: 03 10 00 36 sethi %hi(0x4000d800), %g1 40007f3c: a4 10 60 20 or %g1, 0x20, %l2 ! 4000d820 <_Objects_Compare_name_string> for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; if ( !the_object || !the_object->name ) continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 40007f40: 83 29 20 10 sll %g4, 0x10, %g1 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40007f44: a0 10 20 01 mov 1, %l0 for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; if ( !the_object || !the_object->name ) continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 40007f48: b1 30 60 10 srl %g1, 0x10, %i0 if ( information->is_string ) compare_them = _Objects_Compare_name_string; else compare_them = _Objects_Compare_name_raw; for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; 40007f4c: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 40007f50: 83 2c 20 02 sll %l0, 2, %g1 40007f54: f4 00 80 01 ld [ %g2 + %g1 ], %i2 if ( !the_object || !the_object->name ) 40007f58: 80 a6 a0 00 cmp %i2, 0 40007f5c: 02 80 00 0c be 40007f8c <_Objects_Name_to_id+0xa4> 40007f60: a0 04 20 01 inc %l0 40007f64: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 40007f68: 80 a2 60 00 cmp %o1, 0 40007f6c: 02 80 00 08 be 40007f8c <_Objects_Name_to_id+0xa4> 40007f70: 90 10 00 19 mov %i1, %o0 continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 40007f74: 9f c4 80 00 call %l2 40007f78: 94 10 00 18 mov %i0, %o2 40007f7c: 80 a2 20 00 cmp %o0, 0 40007f80: 32 80 00 13 bne,a 40007fcc <_Objects_Name_to_id+0xe4> 40007f84: c2 06 a0 08 ld [ %i2 + 8 ], %g1 40007f88: c6 14 60 10 lduh [ %l1 + 0x10 ], %g3 name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; else compare_them = _Objects_Compare_name_raw; for ( index = 1; index <= information->maximum; index++ ) { 40007f8c: 83 28 e0 10 sll %g3, 0x10, %g1 40007f90: 83 30 60 10 srl %g1, 0x10, %g1 40007f94: 80 a0 40 10 cmp %g1, %l0 40007f98: 3a bf ff ee bcc,a 40007f50 <_Objects_Name_to_id+0x68> 40007f9c: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 40007fa0: 81 c7 e0 08 ret 40007fa4: 91 e8 20 01 restore %g0, 1, %o0 return ( _Objects_MP_Global_name_search( information, name, node, id ) ); #else return OBJECTS_INVALID_NAME; #endif } 40007fa8: 81 c7 e0 08 ret <== NOT EXECUTED 40007fac: 81 e8 00 00 restore <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40007fb0: 82 10 63 ff or %g1, 0x3ff, %g1 40007fb4: 80 a6 80 01 cmp %i2, %g1 40007fb8: 02 bf ff da be 40007f20 <_Objects_Name_to_id+0x38> 40007fbc: 80 a6 a0 01 cmp %i2, 1 40007fc0: 22 bf ff d9 be,a 40007f24 <_Objects_Name_to_id+0x3c> 40007fc4: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 40007fc8: 30 bf ff f6 b,a 40007fa0 <_Objects_Name_to_id+0xb8> the_object = information->local_table[ index ]; if ( !the_object || !the_object->name ) continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { *id = the_object->id; 40007fcc: c2 26 c0 00 st %g1, [ %i3 ] 40007fd0: 81 c7 e0 08 ret 40007fd4: 91 e8 20 00 restore %g0, 0, %o0 40008010 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 40008010: 9d e3 bf 98 save %sp, -104, %sp 40008014: 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; 40008018: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 4000801c: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0 40008020: 03 00 00 3f sethi %hi(0xfc00), %g1 40008024: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40008028: 92 10 00 10 mov %l0, %o1 4000802c: a2 08 80 01 and %g2, %g1, %l1 40008030: 40 00 37 98 call 40015e90 <.udiv> 40008034: 90 22 00 11 sub %o0, %l1, %o0 for ( block = 0; block < block_count; block++ ) { 40008038: 80 a2 20 00 cmp %o0, 0 4000803c: 02 80 00 15 be 40008090 <_Objects_Shrink_information+0x80> 40008040: 86 10 20 00 clr %g3 if ( information->inactive_per_block[ block ] == information->allocation_size ) { 40008044: c8 06 20 38 ld [ %i0 + 0x38 ], %g4 40008048: c2 01 00 00 ld [ %g4 ], %g1 4000804c: 84 10 20 04 mov 4, %g2 40008050: 80 a4 00 01 cmp %l0, %g1 40008054: a8 10 20 00 clr %l4 40008058: 12 80 00 0a bne 40008080 <_Objects_Shrink_information+0x70> 4000805c: a4 10 20 00 clr %l2 /* * 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; 40008060: 10 80 00 10 b 400080a0 <_Objects_Shrink_information+0x90> <== NOT EXECUTED 40008064: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 <== NOT EXECUTED information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 40008068: a2 04 40 10 add %l1, %l0, %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++ ) { if ( information->inactive_per_block[ block ] == information->allocation_size ) { 4000806c: 80 a4 00 01 cmp %l0, %g1 information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 40008070: a4 10 00 02 mov %g2, %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 ) { 40008074: 02 80 00 09 be 40008098 <_Objects_Shrink_information+0x88> 40008078: 82 00 a0 04 add %g2, 4, %g1 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; return; 4000807c: 84 10 00 01 mov %g1, %g2 */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 40008080: 86 00 e0 01 inc %g3 40008084: 80 a0 c0 08 cmp %g3, %o0 40008088: 32 bf ff f8 bne,a 40008068 <_Objects_Shrink_information+0x58> 4000808c: c2 00 80 04 ld [ %g2 + %g4 ], %g1 40008090: 81 c7 e0 08 ret 40008094: 81 e8 00 00 restore if ( information->inactive_per_block[ block ] == information->allocation_size ) { 40008098: a8 10 00 02 mov %g2, %l4 /* * 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; 4000809c: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 400080a0: 03 00 00 3f sethi %hi(0xfc00), %g1 400080a4: e0 02 00 00 ld [ %o0 ], %l0 400080a8: 10 80 00 10 b 400080e8 <_Objects_Shrink_information+0xd8> 400080ac: a6 10 63 ff or %g1, 0x3ff, %l3 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 400080b0: 82 04 40 01 add %l1, %g1, %g1 400080b4: 80 a0 80 01 cmp %g2, %g1 400080b8: 3a 80 00 12 bcc,a 40008100 <_Objects_Shrink_information+0xf0> 400080bc: 90 10 00 10 mov %l0, %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 ); 400080c0: 40 00 14 b5 call 4000d394 <_Chain_Extract> 400080c4: 01 00 00 00 nop 400080c8: 90 10 00 10 mov %l0, %o0 } else { the_object = (Objects_Control *) the_object->Node.next; } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 400080cc: 80 a2 20 00 cmp %o0, 0 400080d0: 22 80 00 10 be,a 40008110 <_Objects_Shrink_information+0x100> 400080d4: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_last( const Chain_Node *the_node ) { return (the_node->next == NULL); 400080d8: e0 02 00 00 ld [ %o0 ], %l0 400080dc: 80 a4 20 00 cmp %l0, 0 400080e0: 22 80 00 0c be,a 40008110 <_Objects_Shrink_information+0x100> 400080e4: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 400080e8: c2 02 20 08 ld [ %o0 + 8 ], %g1 400080ec: 84 08 40 13 and %g1, %l3, %g2 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 400080f0: 80 a4 40 02 cmp %l1, %g2 400080f4: 28 bf ff ef bleu,a 400080b0 <_Objects_Shrink_information+0xa0> 400080f8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 400080fc: 90 10 00 10 mov %l0, %o0 } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 40008100: 80 a2 20 00 cmp %o0, 0 40008104: 32 bf ff f6 bne,a 400080dc <_Objects_Shrink_information+0xcc> 40008108: e0 02 00 00 ld [ %o0 ], %l0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4000810c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED 40008110: 11 10 00 6a sethi %hi(0x4001a800), %o0 40008114: d2 00 40 14 ld [ %g1 + %l4 ], %o1 40008118: 7f ff fc 99 call 4000737c <_Heap_Free> 4000811c: 90 12 23 ac or %o0, 0x3ac, %o0 */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 40008120: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 40008124: c8 06 20 24 ld [ %i0 + 0x24 ], %g4 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 40008128: c0 24 80 02 clr [ %l2 + %g2 ] information->inactive -= information->allocation_size; 4000812c: c2 16 20 34 lduh [ %i0 + 0x34 ], %g1 * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; 40008130: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 40008134: c6 06 20 18 ld [ %i0 + 0x18 ], %g3 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 40008138: c0 25 00 04 clr [ %l4 + %g4 ] information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 4000813c: 82 20 40 03 sub %g1, %g3, %g1 * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; 40008140: c0 25 00 02 clr [ %l4 + %g2 ] information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 40008144: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 40008148: 81 c7 e0 08 ret 4000814c: 81 e8 00 00 restore 40006b3c <_POSIX_API_Initialize>: void _POSIX_API_Initialize( rtems_configuration_table *configuration_table ) { 40006b3c: 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; 40006b40: f0 06 20 30 ld [ %i0 + 0x30 ], %i0 if ( !api_configuration ) 40006b44: 80 a6 20 00 cmp %i0, 0 40006b48: 02 80 00 1f be 40006bc4 <_POSIX_API_Initialize+0x88> 40006b4c: 03 10 00 6a sethi %hi(0x4001a800), %g1 api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; _POSIX_signals_Manager_Initialization( 40006b50: 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; 40006b54: 05 10 00 6a sethi %hi(0x4001a800), %g2 40006b58: 03 10 00 6c sethi %hi(0x4001b000), %g1 40006b5c: 82 10 60 f8 or %g1, 0xf8, %g1 ! 4001b0f8 <_POSIX_Objects> _POSIX_signals_Manager_Initialization( 40006b60: 40 00 17 69 call 4000c904 <_POSIX_signals_Manager_Initialization> 40006b64: c2 20 a2 cc st %g1, [ %g2 + 0x2cc ] api_configuration->maximum_queued_signals ); _POSIX_Threads_Manager_initialization( 40006b68: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 40006b6c: d4 06 20 30 ld [ %i0 + 0x30 ], %o2 40006b70: 40 00 17 da call 4000cad8 <_POSIX_Threads_Manager_initialization> 40006b74: 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( 40006b78: 40 00 17 11 call 4000c7bc <_POSIX_Condition_variables_Manager_initialization> 40006b7c: d0 06 20 08 ld [ %i0 + 8 ], %o0 api_configuration->maximum_condition_variables ); _POSIX_Key_Manager_initialization( api_configuration->maximum_keys ); 40006b80: 40 00 17 1b call 4000c7ec <_POSIX_Key_Manager_initialization> 40006b84: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _POSIX_Mutex_Manager_initialization( 40006b88: 40 00 17 3b call 4000c874 <_POSIX_Mutex_Manager_initialization> 40006b8c: d0 06 20 04 ld [ %i0 + 4 ], %o0 api_configuration->maximum_mutexes ); _POSIX_Message_queue_Manager_initialization( 40006b90: 40 00 17 23 call 4000c81c <_POSIX_Message_queue_Manager_initialization> 40006b94: d0 06 20 18 ld [ %i0 + 0x18 ], %o0 api_configuration->maximum_message_queues ); _POSIX_Semaphore_Manager_initialization( 40006b98: 40 00 18 a5 call 4000ce2c <_POSIX_Semaphore_Manager_initialization> 40006b9c: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 api_configuration->maximum_semaphores ); _POSIX_Timer_Manager_initialization( api_configuration->maximum_timers ); 40006ba0: 40 00 18 96 call 4000cdf8 <_POSIX_Timer_Manager_initialization> 40006ba4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); 40006ba8: 40 00 17 3f call 4000c8a4 <_POSIX_Barrier_Manager_initialization> 40006bac: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); 40006bb0: 40 00 17 49 call 4000c8d4 <_POSIX_RWLock_Manager_initialization> 40006bb4: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 40006bb8: f0 06 20 28 ld [ %i0 + 0x28 ], %i0 40006bbc: 40 00 17 b1 call 4000ca80 <_POSIX_Spinlock_Manager_initialization> 40006bc0: 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 ) 40006bc4: 10 bf ff e3 b 40006b50 <_POSIX_API_Initialize+0x14> <== NOT EXECUTED 40006bc8: b0 10 61 04 or %g1, 0x104, %i0 <== NOT EXECUTED 4000df5c <_POSIX_Barrier_Translate_core_barrier_return_code>: int _POSIX_Barrier_Translate_core_barrier_return_code( CORE_barrier_Status the_barrier_status ) { if ( the_barrier_status <= CORE_BARRIER_TIMEOUT ) 4000df5c: 80 a2 20 03 cmp %o0, 3 4000df60: 18 80 00 06 bgu 4000df78 <_POSIX_Barrier_Translate_core_barrier_return_code+0x1c> 4000df64: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_Barrier_Return_codes[the_barrier_status]; return POSIX_BOTTOM_REACHED(); } 4000df68: 03 10 00 6a sethi %hi(0x4001a800), %g1 4000df6c: 82 10 60 98 or %g1, 0x98, %g1 ! 4001a898 <_POSIX_Barrier_Return_codes> 4000df70: 81 c3 e0 08 retl 4000df74: d0 00 40 02 ld [ %g1 + %g2 ], %o0 CORE_barrier_Status the_barrier_status ) { if ( the_barrier_status <= CORE_BARRIER_TIMEOUT ) return _POSIX_Barrier_Return_codes[the_barrier_status]; return POSIX_BOTTOM_REACHED(); 4000df78: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000df7c: 7f ff e1 9e call 400065f4 <== NOT EXECUTED 4000df80: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 4000df84: 01 00 00 00 nop 40006870 <_POSIX_Condition_variables_Signal_support>: int _POSIX_Condition_variables_Signal_support( pthread_cond_t *cond, boolean is_broadcast ) { 40006870: 9d e3 bf 90 save %sp, -112, %sp ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 40006874: 80 a6 20 00 cmp %i0, 0 40006878: 32 80 00 05 bne,a 4000688c <_POSIX_Condition_variables_Signal_support+0x1c> 4000687c: d2 06 00 00 ld [ %i0 ], %o1 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40006880: 90 10 20 16 mov 0x16, %o0 } 40006884: 81 c7 e0 08 ret 40006888: 91 e8 00 08 restore %g0, %o0, %o0 *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 4000688c: 80 a2 7f ff cmp %o1, -1 40006890: 22 80 00 27 be,a 4000692c <_POSIX_Condition_variables_Signal_support+0xbc> 40006894: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 40006898: 11 10 00 65 sethi %hi(0x40019400), %o0 4000689c: 94 07 bf f4 add %fp, -12, %o2 400068a0: 40 00 0f 68 call 4000a640 <_Objects_Get> 400068a4: 90 12 23 2c or %o0, 0x32c, %o0 register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; Thread_Control *the_thread; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 400068a8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400068ac: a0 10 00 08 mov %o0, %l0 400068b0: 80 a0 60 00 cmp %g1, 0 400068b4: 02 80 00 08 be 400068d4 <_POSIX_Condition_variables_Signal_support+0x64> 400068b8: b0 02 20 18 add %o0, 0x18, %i0 400068bc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 400068c0: 28 bf ff f1 bleu,a 40006884 <_POSIX_Condition_variables_Signal_support+0x14> <== NOT EXECUTED 400068c4: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400068c8: 40 00 04 b6 call 40007ba0 <== NOT EXECUTED 400068cc: 01 00 00 00 nop <== NOT EXECUTED 400068d0: 30 bf ff ed b,a 40006884 <_POSIX_Condition_variables_Signal_support+0x14> <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); 400068d4: 40 00 15 49 call 4000bdf8 <_Thread_queue_Dequeue> 400068d8: 90 10 00 18 mov %i0, %o0 if ( !the_thread ) 400068dc: 80 a2 20 00 cmp %o0, 0 400068e0: 02 80 00 11 be 40006924 <_POSIX_Condition_variables_Signal_support+0xb4> 400068e4: 80 a6 60 00 cmp %i1, 0 the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; } while ( is_broadcast && the_thread ); 400068e8: 12 bf ff fb bne 400068d4 <_POSIX_Condition_variables_Signal_support+0x64> 400068ec: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400068f0: 03 10 00 64 sethi %hi(0x40019000), %g1 400068f4: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 400191e0 <_Thread_Dispatch_disable_level> 400068f8: 90 10 20 00 clr %o0 400068fc: 84 00 bf ff add %g2, -1, %g2 40006900: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 40006904: c6 00 61 e0 ld [ %g1 + 0x1e0 ], %g3 40006908: 80 a0 e0 00 cmp %g3, 0 4000690c: 12 bf ff de bne 40006884 <_POSIX_Condition_variables_Signal_support+0x14> 40006910: 01 00 00 00 nop _Thread_Dispatch(); 40006914: 40 00 14 37 call 4000b9f0 <_Thread_Dispatch> 40006918: 01 00 00 00 nop 4000691c: 10 bf ff da b 40006884 <_POSIX_Condition_variables_Signal_support+0x14> 40006920: 90 10 20 00 clr %o0 ! 0 case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); if ( !the_thread ) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 40006924: 10 bf ff f3 b 400068f0 <_POSIX_Condition_variables_Signal_support+0x80> 40006928: c0 24 20 14 clr [ %l0 + 0x14 ] if ( *id == PTHREAD_COND_INITIALIZER ) { /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 4000692c: 7f ff ff 83 call 40006738 <== NOT EXECUTED 40006930: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 40006934: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40006938: 32 bf ff d3 bne,a 40006884 <_POSIX_Condition_variables_Signal_support+0x14> <== NOT EXECUTED 4000693c: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 40006940: 10 bf ff d6 b 40006898 <_POSIX_Condition_variables_Signal_support+0x28> <== NOT EXECUTED 40006944: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 400069c0 <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, boolean already_timedout ) { 400069c0: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 400069c4: 80 a6 60 00 cmp %i1, 0 400069c8: 32 80 00 04 bne,a 400069d8 <_POSIX_Condition_variables_Wait_support+0x18> 400069cc: d2 06 40 00 ld [ %i1 ], %o1 return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); } 400069d0: 81 c7 e0 08 ret 400069d4: 91 e8 20 16 restore %g0, 0x16, %o0 400069d8: 80 a2 7f ff cmp %o1, -1 400069dc: 22 80 00 37 be,a 40006ab8 <_POSIX_Condition_variables_Wait_support+0xf8> 400069e0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED return (POSIX_Mutex_Control *) 400069e4: a2 07 bf f4 add %fp, -12, %l1 400069e8: 11 10 00 65 sethi %hi(0x40019400), %o0 400069ec: 94 10 00 11 mov %l1, %o2 400069f0: 40 00 0f 14 call 4000a640 <_Objects_Get> 400069f4: 90 12 22 44 or %o0, 0x244, %o0 register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 400069f8: 80 a2 20 00 cmp %o0, 0 400069fc: 02 bf ff f5 be 400069d0 <_POSIX_Condition_variables_Wait_support+0x10> 40006a00: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 40006a04: 21 10 00 64 sethi %hi(0x40019000), %l0 40006a08: c2 04 21 e0 ld [ %l0 + 0x1e0 ], %g1 ! 400191e0 <_Thread_Dispatch_disable_level> ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 40006a0c: 80 a6 20 00 cmp %i0, 0 40006a10: 82 00 7f ff add %g1, -1, %g1 40006a14: c2 24 21 e0 st %g1, [ %l0 + 0x1e0 ] 40006a18: 02 bf ff ee be 400069d0 <_POSIX_Condition_variables_Wait_support+0x10> 40006a1c: 01 00 00 00 nop *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 40006a20: d2 06 00 00 ld [ %i0 ], %o1 40006a24: 80 a2 7f ff cmp %o1, -1 40006a28: 22 80 00 42 be,a 40006b30 <_POSIX_Condition_variables_Wait_support+0x170> 40006a2c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 40006a30: 94 10 00 11 mov %l1, %o2 40006a34: 11 10 00 65 sethi %hi(0x40019400), %o0 40006a38: 40 00 0f 02 call 4000a640 <_Objects_Get> 40006a3c: 90 12 23 2c or %o0, 0x32c, %o0 ! 4001972c <_POSIX_Condition_variables_Information> } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 40006a40: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006a44: 80 a0 60 00 cmp %g1, 0 40006a48: 12 80 00 15 bne 40006a9c <_POSIX_Condition_variables_Wait_support+0xdc> 40006a4c: a2 10 00 08 mov %o0, %l1 #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { 40006a50: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 40006a54: 80 a0 a0 00 cmp %g2, 0 40006a58: 02 80 00 1f be 40006ad4 <_POSIX_Condition_variables_Wait_support+0x114> 40006a5c: 01 00 00 00 nop 40006a60: c2 06 40 00 ld [ %i1 ], %g1 40006a64: 80 a0 80 01 cmp %g2, %g1 40006a68: 02 80 00 1b be 40006ad4 <_POSIX_Condition_variables_Wait_support+0x114> 40006a6c: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006a70: c2 04 21 e0 ld [ %l0 + 0x1e0 ], %g1 <== NOT EXECUTED 40006a74: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40006a78: c2 24 21 e0 st %g1, [ %l0 + 0x1e0 ] <== NOT EXECUTED 40006a7c: c4 04 21 e0 ld [ %l0 + 0x1e0 ], %g2 <== NOT EXECUTED 40006a80: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40006a84: 12 bf ff d3 bne 400069d0 <_POSIX_Condition_variables_Wait_support+0x10> <== NOT EXECUTED 40006a88: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 40006a8c: 40 00 13 d9 call 4000b9f0 <_Thread_Dispatch> <== NOT EXECUTED 40006a90: b0 10 20 16 mov 0x16, %i0 ! 16 <== NOT EXECUTED 40006a94: 81 c7 e0 08 ret <== NOT EXECUTED 40006a98: 81 e8 00 00 restore <== NOT EXECUTED } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 40006a9c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40006aa0: 08 bf ff cc bleu 400069d0 <_POSIX_Condition_variables_Wait_support+0x10> <== NOT EXECUTED 40006aa4: 01 00 00 00 nop <== NOT EXECUTED if ( mutex_status ) return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); 40006aa8: 40 00 04 3e call 40007ba0 <== NOT EXECUTED 40006aac: 01 00 00 00 nop <== NOT EXECUTED 40006ab0: 81 c7 e0 08 ret <== NOT EXECUTED 40006ab4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40006ab8: 40 00 00 94 call 40006d08 <== NOT EXECUTED 40006abc: 92 10 20 00 clr %o1 <== NOT EXECUTED 40006ac0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40006ac4: 12 bf ff c3 bne 400069d0 <_POSIX_Condition_variables_Wait_support+0x10> <== NOT EXECUTED 40006ac8: 01 00 00 00 nop <== NOT EXECUTED 40006acc: 10 bf ff c6 b 400069e4 <_POSIX_Condition_variables_Wait_support+0x24> <== NOT EXECUTED 40006ad0: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { _Thread_Enable_dispatch(); return EINVAL; } (void) pthread_mutex_unlock( mutex ); 40006ad4: 40 00 01 a2 call 4000715c 40006ad8: 90 10 00 19 mov %i1, %o0 _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 40006adc: 80 a6 e0 00 cmp %i3, 0 40006ae0: 22 80 00 1b be,a 40006b4c <_POSIX_Condition_variables_Wait_support+0x18c> 40006ae4: c2 06 40 00 ld [ %i1 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006ae8: c2 04 21 e0 ld [ %l0 + 0x1e0 ], %g1 40006aec: b0 10 20 74 mov 0x74, %i0 40006af0: 82 00 7f ff add %g1, -1, %g1 40006af4: c2 24 21 e0 st %g1, [ %l0 + 0x1e0 ] 40006af8: c4 04 21 e0 ld [ %l0 + 0x1e0 ], %g2 40006afc: 80 a0 a0 00 cmp %g2, 0 40006b00: 02 80 00 09 be 40006b24 <_POSIX_Condition_variables_Wait_support+0x164> 40006b04: 01 00 00 00 nop /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 40006b08: 40 00 00 e8 call 40006ea8 40006b0c: 90 10 00 19 mov %i1, %o0 if ( mutex_status ) 40006b10: 80 a2 20 00 cmp %o0, 0 40006b14: 12 bf ff af bne 400069d0 <_POSIX_Condition_variables_Wait_support+0x10> 40006b18: 01 00 00 00 nop return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); } 40006b1c: 81 c7 e0 08 ret 40006b20: 81 e8 00 00 restore _Thread_Dispatch(); 40006b24: 40 00 13 b3 call 4000b9f0 <_Thread_Dispatch> 40006b28: 01 00 00 00 nop 40006b2c: 30 bf ff f7 b,a 40006b08 <_POSIX_Condition_variables_Wait_support+0x148> if ( *id == PTHREAD_COND_INITIALIZER ) { /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 40006b30: 7f ff ff 02 call 40006738 <== NOT EXECUTED 40006b34: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 40006b38: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40006b3c: 12 bf ff a5 bne 400069d0 <_POSIX_Condition_variables_Wait_support+0x10> <== NOT EXECUTED 40006b40: 01 00 00 00 nop <== NOT EXECUTED 40006b44: 10 bf ff bb b 40006a30 <_POSIX_Condition_variables_Wait_support+0x70> <== NOT EXECUTED 40006b48: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED if ( !already_timedout ) { the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 40006b4c: 37 10 00 64 sethi %hi(0x40019000), %i3 return EINVAL; } */ if ( !already_timedout ) { the_cond->Mutex = *mutex; 40006b50: c2 24 60 14 st %g1, [ %l1 + 0x14 ] _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 40006b54: c2 06 e2 bc ld [ %i3 + 0x2bc ], %g1 _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; 40006b58: c4 06 00 00 ld [ %i0 ], %g2 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; 40006b5c: 90 04 60 18 add %l1, 0x18, %o0 _Thread_Executing->Wait.id = *cond; 40006b60: c4 20 60 20 st %g2, [ %g1 + 0x20 ] 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; 40006b64: d0 20 60 44 st %o0, [ %g1 + 0x44 ] if ( !already_timedout ) { the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 40006b68: c0 20 60 34 clr [ %g1 + 0x34 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 40006b6c: 82 10 20 01 mov 1, %g1 _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 40006b70: 92 10 00 1a mov %i2, %o1 40006b74: c2 24 60 48 st %g1, [ %l1 + 0x48 ] 40006b78: 15 10 00 31 sethi %hi(0x4000c400), %o2 40006b7c: 40 00 15 0d call 4000bfb0 <_Thread_queue_Enqueue_with_handler> 40006b80: 94 12 a1 78 or %o2, 0x178, %o2 ! 4000c578 <_Thread_queue_Timeout> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006b84: c2 04 21 e0 ld [ %l0 + 0x1e0 ], %g1 40006b88: 82 00 7f ff add %g1, -1, %g1 40006b8c: c2 24 21 e0 st %g1, [ %l0 + 0x1e0 ] 40006b90: c4 04 21 e0 ld [ %l0 + 0x1e0 ], %g2 40006b94: 80 a0 a0 00 cmp %g2, 0 40006b98: 12 80 00 05 bne 40006bac <_POSIX_Condition_variables_Wait_support+0x1ec> 40006b9c: c2 06 e2 bc ld [ %i3 + 0x2bc ], %g1 _Thread_Dispatch(); 40006ba0: 40 00 13 94 call 4000b9f0 <_Thread_Dispatch> 40006ba4: 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; 40006ba8: c2 06 e2 bc ld [ %i3 + 0x2bc ], %g1 40006bac: f0 00 60 34 ld [ %g1 + 0x34 ], %i0 if ( status && status != ETIMEDOUT ) 40006bb0: 80 a6 20 00 cmp %i0, 0 40006bb4: 02 bf ff d5 be 40006b08 <_POSIX_Condition_variables_Wait_support+0x148> 40006bb8: 80 a6 20 74 cmp %i0, 0x74 40006bbc: 02 bf ff d3 be 40006b08 <_POSIX_Condition_variables_Wait_support+0x148> 40006bc0: 01 00 00 00 nop return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); } 40006bc4: 81 c7 e0 08 ret <== NOT EXECUTED 40006bc8: 81 e8 00 00 restore <== NOT EXECUTED 4000e394 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 4000e394: 9d e3 bf 98 save %sp, -104, %sp uint32_t iterations; boolean are_all_null; POSIX_Keys_Control *the_key; void *value; thread_index = _Objects_Get_index( thread->Object.id ); 4000e398: c2 06 20 08 ld [ %i0 + 8 ], %g1 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 ]; 4000e39c: 05 00 00 3f sethi %hi(0xfc00), %g2 4000e3a0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000e3a4: 84 08 40 02 and %g1, %g2, %g2 4000e3a8: aa 10 20 00 clr %l5 4000e3ac: a9 28 a0 02 sll %g2, 2, %l4 */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 4000e3b0: 83 30 60 16 srl %g1, 0x16, %g1 4000e3b4: 05 10 00 6c sethi %hi(0x4001b000), %g2 4000e3b8: a6 08 60 1c and %g1, 0x1c, %l3 4000e3bc: a2 10 a0 60 or %g2, 0x60, %l1 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 4000e3c0: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 4000e3c4: 80 a0 60 00 cmp %g1, 0 4000e3c8: 02 80 00 27 be 4000e464 <_POSIX_Keys_Run_destructors+0xd0> 4000e3cc: b0 10 20 01 mov 1, %i0 4000e3d0: a4 10 20 01 mov 1, %l2 the_key = (POSIX_Keys_Control *) 4000e3d4: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 4000e3d8: 83 2e 20 02 sll %i0, 2, %g1 4000e3dc: c4 00 80 01 ld [ %g2 + %g1 ], %g2 _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { 4000e3e0: 80 a0 a0 00 cmp %g2, 0 4000e3e4: 02 80 00 16 be 4000e43c <_POSIX_Keys_Run_destructors+0xa8> 4000e3e8: b0 06 20 01 inc %i0 4000e3ec: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 4000e3f0: 80 a0 60 00 cmp %g1, 0 4000e3f4: 02 80 00 12 be 4000e43c <_POSIX_Keys_Run_destructors+0xa8> 4000e3f8: a0 04 c0 02 add %l3, %g2, %l0 4000e3fc: c6 00 a0 14 ld [ %g2 + 0x14 ], %g3 4000e400: 80 a0 e0 00 cmp %g3, 0 4000e404: 22 80 00 0f be,a 4000e440 <_POSIX_Keys_Run_destructors+0xac> 4000e408: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 <== NOT EXECUTED value = the_key->Values[ thread_api ][ thread_index ]; 4000e40c: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 4000e410: c4 00 40 14 ld [ %g1 + %l4 ], %g2 if ( value ) { 4000e414: 90 90 a0 00 orcc %g2, 0, %o0 4000e418: 22 80 00 0a be,a 4000e440 <_POSIX_Keys_Run_destructors+0xac> 4000e41c: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 <== NOT EXECUTED (*the_key->destructor)( value ); 4000e420: 9f c0 c0 00 call %g3 4000e424: 01 00 00 00 nop if ( the_key->Values[ thread_api ][ thread_index ] ) 4000e428: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 4000e42c: c4 05 00 01 ld [ %l4 + %g1 ], %g2 4000e430: 80 a0 00 02 cmp %g0, %g2 4000e434: 82 40 3f ff addx %g0, -1, %g1 4000e438: a4 0c 80 01 and %l2, %g1, %l2 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 4000e43c: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 4000e440: 80 a0 40 18 cmp %g1, %i0 4000e444: 3a bf ff e5 bcc,a 4000e3d8 <_POSIX_Keys_Run_destructors+0x44> 4000e448: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 are_all_null = FALSE; } } } if ( are_all_null == TRUE ) 4000e44c: 80 a4 a0 01 cmp %l2, 1 4000e450: 02 80 00 05 be 4000e464 <_POSIX_Keys_Run_destructors+0xd0> 4000e454: aa 05 60 01 inc %l5 * 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 ) 4000e458: 80 a5 60 04 cmp %l5, 4 4000e45c: 32 bf ff da bne,a 4000e3c4 <_POSIX_Keys_Run_destructors+0x30> 4000e460: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 4000e464: 81 c7 e0 08 ret 4000e468: 81 e8 00 00 restore 40013944 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 40013944: 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 ); 40013948: 92 10 20 ff mov 0xff, %o1 4001394c: 90 10 00 18 mov %i0, %o0 40013950: 40 00 12 6f call 4001830c 40013954: aa 10 00 18 mov %i0, %l5 if ( n > NAME_MAX ) 40013958: b0 10 20 5b mov 0x5b, %i0 4001395c: 80 a2 20 ff cmp %o0, 0xff 40013960: 18 80 00 42 bgu 40013a68 <_POSIX_Message_queue_Create_support+0x124> 40013964: a4 10 00 08 mov %o0, %l2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40013968: 27 10 00 98 sethi %hi(0x40026000), %l3 4001396c: c2 04 e0 00 ld [ %l3 ], %g1 40013970: 82 00 60 01 inc %g1 40013974: c2 24 e0 00 st %g1, [ %l3 ] * 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 ) { 40013978: 80 a6 a0 00 cmp %i2, 0 4001397c: 22 80 00 41 be,a 40013a80 <_POSIX_Message_queue_Create_support+0x13c> 40013980: b4 10 20 10 mov 0x10, %i2 attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 40013984: e2 06 a0 04 ld [ %i2 + 4 ], %l1 40013988: 80 a4 60 00 cmp %l1, 0 4001398c: 04 80 00 4c ble 40013abc <_POSIX_Message_queue_Create_support+0x178> 40013990: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 40013994: f4 06 a0 08 ld [ %i2 + 8 ], %i2 40013998: 80 a6 a0 00 cmp %i2, 0 4001399c: 04 80 00 48 ble 40013abc <_POSIX_Message_queue_Create_support+0x178> 400139a0: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void ) { return (POSIX_Message_queue_Control *) 400139a4: 29 10 00 99 sethi %hi(0x40026400), %l4 400139a8: 7f ff eb b5 call 4000e87c <_Objects_Allocate> 400139ac: 90 15 20 18 or %l4, 0x18, %o0 ! 40026418 <_POSIX_Message_queue_Information> rtems_set_errno_and_return_minus_one( ENFILE ); } #endif the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 400139b0: a0 92 20 00 orcc %o0, 0, %l0 400139b4: 02 80 00 35 be 40013a88 <_POSIX_Message_queue_Create_support+0x144> 400139b8: 82 10 20 01 mov 1, %g1 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; 400139bc: f2 24 20 10 st %i1, [ %l0 + 0x10 ] 400139c0: 92 10 00 12 mov %l2, %o1 the_mq->named = TRUE; the_mq->open_count = 1; the_mq->linked = TRUE; 400139c4: c2 24 20 18 st %g1, [ %l0 + 0x18 ] _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; the_mq->named = TRUE; 400139c8: c2 24 20 14 st %g1, [ %l0 + 0x14 ] the_mq->open_count = 1; 400139cc: c2 24 20 1c st %g1, [ %l0 + 0x1c ] 400139d0: 25 10 00 98 sethi %hi(0x40026000), %l2 400139d4: 7f ff ea 4b call 4000e300 <_Heap_Allocate> 400139d8: 90 14 a0 4c or %l2, 0x4c, %o0 ! 4002604c <_Workspace_Area> * Make a copy of the user's string for name just in case it was * dynamically constructed. */ name = _Workspace_Allocate(n); if (!name) { 400139dc: b2 92 20 00 orcc %o0, 0, %i1 400139e0: 22 80 00 56 be,a 40013b38 <_POSIX_Message_queue_Create_support+0x1f4> 400139e4: 90 15 20 18 or %l4, 0x18, %o0 <== NOT EXECUTED _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOMEM ); } strcpy( name, name_arg ); 400139e8: 40 00 0f e4 call 40017978 400139ec: 92 10 00 15 mov %l5, %o1 */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 400139f0: 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; 400139f4: c0 24 20 60 clr [ %l0 + 0x60 ] if ( ! _CORE_message_queue_Initialize( 400139f8: 96 10 00 1a mov %i2, %o3 400139fc: 90 04 20 20 add %l0, 0x20, %o0 40013a00: 40 00 03 cd call 40014934 <_CORE_message_queue_Initialize> 40013a04: 92 04 20 60 add %l0, 0x60, %o1 40013a08: 80 a2 20 00 cmp %o0, 0 40013a0c: 02 80 00 39 be 40013af0 <_POSIX_Message_queue_Create_support+0x1ac> 40013a10: 90 15 20 18 or %l4, 0x18, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40013a14: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40013a18: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40013a1c: 05 00 00 3f sethi %hi(0xfc00), %g2 40013a20: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40013a24: 82 08 40 02 and %g1, %g2, %g1 40013a28: 80 a0 40 03 cmp %g1, %g3 40013a2c: 38 80 00 06 bgu,a 40013a44 <_POSIX_Message_queue_Create_support+0x100> 40013a30: e0 26 c0 00 st %l0, [ %i3 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40013a34: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40013a38: 83 28 60 02 sll %g1, 2, %g1 40013a3c: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_POSIX_Message_queue_Information, &the_mq->Object, (char *) name ); *message_queue = the_mq; 40013a40: e0 26 c0 00 st %l0, [ %i3 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 40013a44: f2 24 20 0c st %i1, [ %l0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40013a48: c2 04 e0 00 ld [ %l3 ], %g1 40013a4c: b0 10 20 00 clr %i0 40013a50: 82 00 7f ff add %g1, -1, %g1 40013a54: c2 24 e0 00 st %g1, [ %l3 ] 40013a58: c4 04 e0 00 ld [ %l3 ], %g2 40013a5c: 80 a0 a0 00 cmp %g2, 0 40013a60: 02 80 00 04 be 40013a70 <_POSIX_Message_queue_Create_support+0x12c> 40013a64: 01 00 00 00 nop ); #endif _Thread_Enable_dispatch(); return 0; } 40013a68: 81 c7 e0 08 ret 40013a6c: 81 e8 00 00 restore _Thread_Dispatch(); 40013a70: 7f ff f1 c0 call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 40013a74: 01 00 00 00 nop <== NOT EXECUTED 40013a78: 81 c7 e0 08 ret <== NOT EXECUTED 40013a7c: 81 e8 00 00 restore <== NOT EXECUTED 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 ); 40013a80: 10 bf ff c9 b 400139a4 <_POSIX_Message_queue_Create_support+0x60> 40013a84: a2 10 20 0a mov 0xa, %l1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40013a88: c2 04 e0 00 ld [ %l3 ], %g1 <== NOT EXECUTED 40013a8c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40013a90: c2 24 e0 00 st %g1, [ %l3 ] <== NOT EXECUTED 40013a94: c4 04 e0 00 ld [ %l3 ], %g2 <== NOT EXECUTED 40013a98: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40013a9c: 02 80 00 36 be 40013b74 <_POSIX_Message_queue_Create_support+0x230> <== NOT EXECUTED 40013aa0: 01 00 00 00 nop <== NOT EXECUTED #endif the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); 40013aa4: 40 00 0a d1 call 400165e8 <__errno> <== NOT EXECUTED 40013aa8: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 40013aac: 82 10 20 17 mov 0x17, %g1 <== NOT EXECUTED 40013ab0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40013ab4: 81 c7 e0 08 ret <== NOT EXECUTED 40013ab8: 81 e8 00 00 restore <== NOT EXECUTED 40013abc: c2 04 e0 00 ld [ %l3 ], %g1 40013ac0: 82 00 7f ff add %g1, -1, %g1 40013ac4: c2 24 e0 00 st %g1, [ %l3 ] 40013ac8: c4 04 e0 00 ld [ %l3 ], %g2 40013acc: 80 a0 a0 00 cmp %g2, 0 40013ad0: 02 80 00 2c be 40013b80 <_POSIX_Message_queue_Create_support+0x23c> 40013ad4: 01 00 00 00 nop 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 ); 40013ad8: 40 00 0a c4 call 400165e8 <__errno> 40013adc: b0 10 3f ff mov -1, %i0 ! ffffffff 40013ae0: 82 10 20 16 mov 0x16, %g1 40013ae4: c2 22 00 00 st %g1, [ %o0 ] 40013ae8: 81 c7 e0 08 ret 40013aec: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free ( POSIX_Message_queue_Control *the_mq ) { _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object ); 40013af0: 7f ff ec 71 call 4000ecb4 <_Objects_Free> <== NOT EXECUTED 40013af4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 40013af8: 90 14 a0 4c or %l2, 0x4c, %o0 <== NOT EXECUTED 40013afc: 7f ff ea 33 call 4000e3c8 <_Heap_Free> <== NOT EXECUTED 40013b00: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40013b04: c2 04 e0 00 ld [ %l3 ], %g1 <== NOT EXECUTED 40013b08: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40013b0c: c2 24 e0 00 st %g1, [ %l3 ] <== NOT EXECUTED 40013b10: c4 04 e0 00 ld [ %l3 ], %g2 <== NOT EXECUTED 40013b14: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40013b18: 02 80 00 1d be 40013b8c <_POSIX_Message_queue_Create_support+0x248> <== NOT EXECUTED 40013b1c: 01 00 00 00 nop <== NOT EXECUTED #endif _POSIX_Message_queue_Free( the_mq ); _Workspace_Free(name); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSPC ); 40013b20: 40 00 0a b2 call 400165e8 <__errno> <== NOT EXECUTED 40013b24: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 40013b28: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED 40013b2c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40013b30: 81 c7 e0 08 ret <== NOT EXECUTED 40013b34: 81 e8 00 00 restore <== NOT EXECUTED 40013b38: 7f ff ec 5f call 4000ecb4 <_Objects_Free> <== NOT EXECUTED 40013b3c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 40013b40: c2 04 e0 00 ld [ %l3 ], %g1 <== NOT EXECUTED 40013b44: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40013b48: c2 24 e0 00 st %g1, [ %l3 ] <== NOT EXECUTED 40013b4c: c4 04 e0 00 ld [ %l3 ], %g2 <== NOT EXECUTED 40013b50: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40013b54: 02 80 00 11 be 40013b98 <_POSIX_Message_queue_Create_support+0x254> <== NOT EXECUTED 40013b58: 01 00 00 00 nop <== NOT EXECUTED name = _Workspace_Allocate(n); if (!name) { _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOMEM ); 40013b5c: 40 00 0a a3 call 400165e8 <__errno> <== NOT EXECUTED 40013b60: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 40013b64: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED 40013b68: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40013b6c: 81 c7 e0 08 ret <== NOT EXECUTED 40013b70: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40013b74: 7f ff f1 7f call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 40013b78: 01 00 00 00 nop <== NOT EXECUTED 40013b7c: 30 bf ff ca b,a 40013aa4 <_POSIX_Message_queue_Create_support+0x160> <== NOT EXECUTED 40013b80: 7f ff f1 7c call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 40013b84: 01 00 00 00 nop <== NOT EXECUTED 40013b88: 30 bf ff d4 b,a 40013ad8 <_POSIX_Message_queue_Create_support+0x194> <== NOT EXECUTED 40013b8c: 7f ff f1 79 call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 40013b90: 01 00 00 00 nop <== NOT EXECUTED 40013b94: 30 bf ff e3 b,a 40013b20 <_POSIX_Message_queue_Create_support+0x1dc> <== NOT EXECUTED 40013b98: 7f ff f1 76 call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 40013b9c: 01 00 00 00 nop <== NOT EXECUTED 40013ba0: 30 bf ff ef b,a 40013b5c <_POSIX_Message_queue_Create_support+0x218> <== NOT EXECUTED 40009f10 <_POSIX_Message_queue_Delete>: */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq ) { 40009f10: 9d e3 bf 98 save %sp, -104, %sp if ( !the_mq->linked && !the_mq->open_count ) { 40009f14: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40009f18: 80 a0 60 00 cmp %g1, 0 40009f1c: 12 80 00 1f bne 40009f98 <_POSIX_Message_queue_Delete+0x88> 40009f20: b2 10 00 18 mov %i0, %i1 40009f24: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 40009f28: 80 a0 60 00 cmp %g1, 0 40009f2c: 12 80 00 1b bne 40009f98 <_POSIX_Message_queue_Delete+0x88> 40009f30: 01 00 00 00 nop /* the name memory may have been freed by unlink. */ if ( the_mq->Object.name ) 40009f34: d2 06 20 0c ld [ %i0 + 0xc ], %o1 40009f38: 80 a2 60 00 cmp %o1, 0 40009f3c: 02 80 00 04 be 40009f4c <_POSIX_Message_queue_Delete+0x3c> 40009f40: 11 10 00 98 sethi %hi(0x40026000), %o0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 40009f44: 40 00 11 21 call 4000e3c8 <_Heap_Free> <== NOT EXECUTED 40009f48: 90 12 20 4c or %o0, 0x4c, %o0 ! 4002604c <_Workspace_Area> <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40009f4c: 03 10 00 99 sethi %hi(0x40026400), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40009f50: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40009f54: b0 10 60 18 or %g1, 0x18, %i0 40009f58: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 40009f5c: 03 00 00 3f sethi %hi(0xfc00), %g1 40009f60: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40009f64: 82 08 c0 01 and %g3, %g1, %g1 40009f68: 80 a0 40 02 cmp %g1, %g2 40009f6c: 18 80 00 05 bgu 40009f80 <_POSIX_Message_queue_Delete+0x70> 40009f70: 90 06 60 20 add %i1, 0x20, %o0 information->local_table[ index ] = the_object; 40009f74: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 40009f78: 83 28 60 02 sll %g1, 2, %g1 40009f7c: c0 20 80 01 clr [ %g2 + %g1 ] _Workspace_Free( the_mq->Object.name ); _Objects_Close( &_POSIX_Message_queue_Information, &the_mq->Object ); _CORE_message_queue_Close( 40009f80: 92 10 20 00 clr %o1 40009f84: 94 10 20 05 mov 5, %o2 40009f88: 40 00 0e dc call 4000daf8 <_CORE_message_queue_Close> 40009f8c: c0 26 60 0c clr [ %i1 + 0xc ] RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free ( POSIX_Message_queue_Control *the_mq ) { _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object ); 40009f90: 40 00 13 49 call 4000ecb4 <_Objects_Free> 40009f94: 81 e8 00 00 restore 40009f98: 81 c7 e0 08 ret 40009f9c: 81 e8 00 00 restore 4000a530 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, boolean wait, Watchdog_Interval timeout ) { 4000a530: 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 *) 4000a534: 11 10 00 99 sethi %hi(0x40026400), %o0 4000a538: 94 07 bf f4 add %fp, -12, %o2 4000a53c: 90 12 21 d0 or %o0, 0x1d0, %o0 4000a540: 40 00 12 20 call 4000edc0 <_Objects_Get> 4000a544: 92 10 00 18 mov %i0, %o1 Objects_Locations location; size_t length_out; boolean do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 4000a548: c2 07 bf f4 ld [ %fp + -12 ], %g1 size_t msg_len, unsigned int *msg_prio, boolean wait, Watchdog_Interval timeout ) { 4000a54c: 94 10 00 19 mov %i1, %o2 Objects_Locations location; size_t length_out; boolean do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 4000a550: 80 a0 60 01 cmp %g1, 1 4000a554: 02 80 00 43 be 4000a660 <_POSIX_Message_queue_Receive_support+0x130> 4000a558: 9a 10 00 1d mov %i5, %o5 4000a55c: 80 a0 60 01 cmp %g1, 1 4000a560: 1a 80 00 29 bcc 4000a604 <_POSIX_Message_queue_Receive_support+0xd4> 4000a564: 80 a0 60 02 cmp %g1, 2 case OBJECTS_REMOTE: _Thread_Dispatch(); return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 4000a568: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 4000a56c: 82 08 a0 03 and %g2, 3, %g1 4000a570: 80 a0 60 01 cmp %g1, 1 4000a574: 02 80 00 2a be 4000a61c <_POSIX_Message_queue_Receive_support+0xec> 4000a578: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 4000a57c: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 4000a580: c2 02 20 6c ld [ %o0 + 0x6c ], %g1 4000a584: 80 a0 40 1a cmp %g1, %i2 4000a588: 18 80 00 44 bgu 4000a698 <_POSIX_Message_queue_Receive_support+0x168> 4000a58c: 80 a7 20 00 cmp %i4, 0 length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 4000a590: 12 80 00 3a bne 4000a678 <_POSIX_Message_queue_Receive_support+0x148> 4000a594: 98 10 20 00 clr %o4 /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 4000a598: 82 10 3f ff mov -1, %g1 do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 4000a59c: 90 02 20 20 add %o0, 0x20, %o0 4000a5a0: 92 10 00 18 mov %i0, %o1 /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 4000a5a4: c2 27 bf f0 st %g1, [ %fp + -16 ] do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 4000a5a8: 40 00 0d 7a call 4000db90 <_CORE_message_queue_Seize> 4000a5ac: 96 07 bf f0 add %fp, -16, %o3 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a5b0: 05 10 00 98 sethi %hi(0x40026000), %g2 4000a5b4: c2 00 a0 00 ld [ %g2 ], %g1 4000a5b8: 82 00 7f ff add %g1, -1, %g1 4000a5bc: c2 20 a0 00 st %g1, [ %g2 ] 4000a5c0: c6 00 a0 00 ld [ %g2 ], %g3 4000a5c4: 80 a0 e0 00 cmp %g3, 0 4000a5c8: 02 80 00 30 be 4000a688 <_POSIX_Message_queue_Receive_support+0x158> 4000a5cc: 01 00 00 00 nop do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 4000a5d0: 3b 10 00 98 sethi %hi(0x40026000), %i5 <== NOT EXECUTED 4000a5d4: c4 07 60 dc ld [ %i5 + 0xdc ], %g2 ! 400260dc <_Thread_Executing> <== NOT EXECUTED 4000a5d8: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 4000a5dc: c8 00 a0 34 ld [ %g2 + 0x34 ], %g4 do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 4000a5e0: 87 38 60 1f sra %g1, 0x1f, %g3 4000a5e4: 82 18 c0 01 xor %g3, %g1, %g1 4000a5e8: 82 20 40 03 sub %g1, %g3, %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 4000a5ec: 80 a1 20 00 cmp %g4, 0 4000a5f0: 12 80 00 38 bne 4000a6d0 <_POSIX_Message_queue_Receive_support+0x1a0> 4000a5f4: c2 26 c0 00 st %g1, [ %i3 ] return length_out; 4000a5f8: d0 07 bf f0 ld [ %fp + -16 ], %o0 _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); } 4000a5fc: 81 c7 e0 08 ret 4000a600: 91 e8 00 08 restore %g0, %o0, %o0 Objects_Locations location; size_t length_out; boolean do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 4000a604: 02 80 00 10 be 4000a644 <_POSIX_Message_queue_Receive_support+0x114> 4000a608: 01 00 00 00 nop _POSIX_Message_queue_Translate_core_message_queue_return_code( _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); 4000a60c: 40 00 06 8e call 4000c044 <== NOT EXECUTED 4000a610: 01 00 00 00 nop <== NOT EXECUTED } 4000a614: 81 c7 e0 08 ret 4000a618: 91 e8 00 08 restore %g0, %o0, %o0 4000a61c: 03 10 00 98 sethi %hi(0x40026000), %g1 4000a620: c4 00 60 00 ld [ %g1 ], %g2 4000a624: 84 00 bf ff add %g2, -1, %g2 4000a628: c4 20 60 00 st %g2, [ %g1 ] 4000a62c: c6 00 60 00 ld [ %g1 ], %g3 4000a630: 80 a0 e0 00 cmp %g3, 0 4000a634: 12 80 00 04 bne 4000a644 <_POSIX_Message_queue_Receive_support+0x114> 4000a638: 01 00 00 00 nop _Thread_Dispatch(); 4000a63c: 40 00 16 cd call 40010170 <_Thread_Dispatch> 4000a640: 01 00 00 00 nop return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); 4000a644: 40 00 2f e9 call 400165e8 <__errno> 4000a648: 01 00 00 00 nop 4000a64c: 82 10 20 09 mov 9, %g1 ! 9 4000a650: c2 22 00 00 st %g1, [ %o0 ] 4000a654: 90 10 3f ff mov -1, %o0 _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); } 4000a658: 81 c7 e0 08 ret 4000a65c: 91 e8 00 08 restore %g0, %o0, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 4000a660: 40 00 16 c4 call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000a664: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000a668: 40 00 06 81 call 4000c06c <== NOT EXECUTED 4000a66c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); } 4000a670: 81 c7 e0 08 ret <== NOT EXECUTED 4000a674: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 4000a678: 83 30 a0 0e srl %g2, 0xe, %g1 4000a67c: 82 18 60 01 xor %g1, 1, %g1 4000a680: 10 bf ff c6 b 4000a598 <_POSIX_Message_queue_Receive_support+0x68> 4000a684: 98 08 60 01 and %g1, 1, %o4 4000a688: 40 00 16 ba call 40010170 <_Thread_Dispatch> 4000a68c: 3b 10 00 98 sethi %hi(0x40026000), %i5 do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 4000a690: 10 bf ff d2 b 4000a5d8 <_POSIX_Message_queue_Receive_support+0xa8> 4000a694: c4 07 60 dc ld [ %i5 + 0xdc ], %g2 ! 400260dc <_Thread_Executing> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a698: 03 10 00 98 sethi %hi(0x40026000), %g1 4000a69c: c4 00 60 00 ld [ %g1 ], %g2 4000a6a0: 84 00 bf ff add %g2, -1, %g2 4000a6a4: c4 20 60 00 st %g2, [ %g1 ] 4000a6a8: c6 00 60 00 ld [ %g1 ], %g3 4000a6ac: 80 a0 e0 00 cmp %g3, 0 4000a6b0: 02 80 00 11 be 4000a6f4 <_POSIX_Message_queue_Receive_support+0x1c4> 4000a6b4: 01 00 00 00 nop the_mq = the_mq_fd->Queue; if ( msg_len < the_mq->Message_queue.maximum_message_size ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EMSGSIZE ); 4000a6b8: 40 00 2f cc call 400165e8 <__errno> 4000a6bc: 01 00 00 00 nop 4000a6c0: 82 10 20 7a mov 0x7a, %g1 ! 7a 4000a6c4: c2 22 00 00 st %g1, [ %o0 ] 4000a6c8: 10 bf ff d3 b 4000a614 <_POSIX_Message_queue_Receive_support+0xe4> 4000a6cc: 90 10 3f ff mov -1, %o0 _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( 4000a6d0: 40 00 2f c6 call 400165e8 <__errno> 4000a6d4: 01 00 00 00 nop 4000a6d8: c2 07 60 dc ld [ %i5 + 0xdc ], %g1 4000a6dc: a0 10 00 08 mov %o0, %l0 4000a6e0: 40 00 00 e5 call 4000aa74 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 4000a6e4: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 4000a6e8: d0 24 00 00 st %o0, [ %l0 ] 4000a6ec: 10 bf ff ca b 4000a614 <_POSIX_Message_queue_Receive_support+0xe4> 4000a6f0: 90 10 3f ff mov -1, %o0 _Thread_Dispatch(); 4000a6f4: 40 00 16 9f call 40010170 <_Thread_Dispatch> 4000a6f8: 01 00 00 00 nop 4000a6fc: 30 bf ff ef b,a 4000a6b8 <_POSIX_Message_queue_Receive_support+0x188> 4000a718 <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, boolean wait, Watchdog_Interval timeout ) { 4000a718: 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 ) 4000a71c: 80 a6 e0 20 cmp %i3, 0x20 4000a720: 18 80 00 5b bgu 4000a88c <_POSIX_Message_queue_Send_support+0x174> 4000a724: 92 10 00 18 mov %i0, %o1 4000a728: 11 10 00 99 sethi %hi(0x40026400), %o0 4000a72c: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 400265d0 <_POSIX_Message_queue_Information_fds> 4000a730: 40 00 11 a4 call 4000edc0 <_Objects_Get> 4000a734: 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 ) { 4000a738: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000a73c: 80 a0 60 01 cmp %g1, 1 4000a740: 02 80 00 42 be 4000a848 <_POSIX_Message_queue_Send_support+0x130> 4000a744: 01 00 00 00 nop 4000a748: 2a 80 00 09 bcs,a 4000a76c <_POSIX_Message_queue_Send_support+0x54> 4000a74c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 4000a750: 80 a0 60 02 cmp %g1, 2 4000a754: 02 80 00 36 be 4000a82c <_POSIX_Message_queue_Send_support+0x114> 4000a758: 01 00 00 00 nop _POSIX_Message_queue_Translate_core_message_queue_return_code( msg_status ) ); } return POSIX_BOTTOM_REACHED(); 4000a75c: 40 00 06 3a call 4000c044 <== NOT EXECUTED 4000a760: 01 00 00 00 nop <== NOT EXECUTED } 4000a764: 81 c7 e0 08 ret 4000a768: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { 4000a76c: 80 88 60 03 btst 3, %g1 4000a770: 02 80 00 25 be 4000a804 <_POSIX_Message_queue_Send_support+0xec> 4000a774: 80 a7 20 00 cmp %i4, 0 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 4000a778: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 4000a77c: 12 80 00 39 bne 4000a860 <_POSIX_Message_queue_Send_support+0x148> 4000a780: 84 10 20 00 clr %g2 do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 4000a784: fa 23 a0 60 st %i5, [ %sp + 0x60 ] 4000a788: c4 23 a0 5c st %g2, [ %sp + 0x5c ] 4000a78c: 92 10 00 19 mov %i1, %o1 4000a790: 94 10 00 1a mov %i2, %o2 4000a794: 96 10 00 18 mov %i0, %o3 4000a798: 9a 20 00 1b neg %i3, %o5 4000a79c: 98 10 20 00 clr %o4 4000a7a0: 40 00 0d 43 call 4000dcac <_CORE_message_queue_Submit> 4000a7a4: 90 02 20 20 add %o0, 0x20, %o0 4000a7a8: ba 10 00 08 mov %o0, %i5 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a7ac: 03 10 00 98 sethi %hi(0x40026000), %g1 4000a7b0: c4 00 60 00 ld [ %g1 ], %g2 4000a7b4: 84 00 bf ff add %g2, -1, %g2 4000a7b8: c4 20 60 00 st %g2, [ %g1 ] 4000a7bc: c6 00 60 00 ld [ %g1 ], %g3 4000a7c0: 80 a0 e0 00 cmp %g3, 0 4000a7c4: 02 80 00 2b be 4000a870 <_POSIX_Message_queue_Send_support+0x158> 4000a7c8: 01 00 00 00 nop * 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 ) 4000a7cc: 80 a7 60 07 cmp %i5, 7 <== NOT EXECUTED 4000a7d0: 02 80 00 2c be 4000a880 <_POSIX_Message_queue_Send_support+0x168> 4000a7d4: 03 10 00 98 sethi %hi(0x40026000), %g1 msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) 4000a7d8: 80 a7 60 00 cmp %i5, 0 4000a7dc: 02 bf ff e2 be 4000a764 <_POSIX_Message_queue_Send_support+0x4c> 4000a7e0: 90 10 20 00 clr %o0 return msg_status; rtems_set_errno_and_return_minus_one( 4000a7e4: 40 00 2f 81 call 400165e8 <__errno> 4000a7e8: 01 00 00 00 nop 4000a7ec: a0 10 00 08 mov %o0, %l0 4000a7f0: 40 00 00 a1 call 4000aa74 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 4000a7f4: 90 10 00 1d mov %i5, %o0 4000a7f8: d0 24 00 00 st %o0, [ %l0 ] 4000a7fc: 10 bf ff da b 4000a764 <_POSIX_Message_queue_Send_support+0x4c> 4000a800: 90 10 3f ff mov -1, %o0 4000a804: 03 10 00 98 sethi %hi(0x40026000), %g1 4000a808: c4 00 60 00 ld [ %g1 ], %g2 4000a80c: 84 00 bf ff add %g2, -1, %g2 4000a810: c4 20 60 00 st %g2, [ %g1 ] 4000a814: c6 00 60 00 ld [ %g1 ], %g3 4000a818: 80 a0 e0 00 cmp %g3, 0 4000a81c: 12 80 00 04 bne 4000a82c <_POSIX_Message_queue_Send_support+0x114> 4000a820: 01 00 00 00 nop _Thread_Dispatch(); 4000a824: 40 00 16 53 call 40010170 <_Thread_Dispatch> 4000a828: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); 4000a82c: 40 00 2f 6f call 400165e8 <__errno> 4000a830: 01 00 00 00 nop 4000a834: 82 10 20 09 mov 9, %g1 ! 9 4000a838: c2 22 00 00 st %g1, [ %o0 ] 4000a83c: 90 10 3f ff mov -1, %o0 msg_status ) ); } return POSIX_BOTTOM_REACHED(); } 4000a840: 81 c7 e0 08 ret 4000a844: 91 e8 00 08 restore %g0, %o0, %o0 switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 4000a848: 40 00 16 4a call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000a84c: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000a850: 40 00 06 07 call 4000c06c <== NOT EXECUTED 4000a854: 01 00 00 00 nop <== NOT EXECUTED msg_status ) ); } return POSIX_BOTTOM_REACHED(); } 4000a858: 81 c7 e0 08 ret <== NOT EXECUTED 4000a85c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 4000a860: 83 30 60 0e srl %g1, 0xe, %g1 4000a864: 82 18 60 01 xor %g1, 1, %g1 4000a868: 10 bf ff c7 b 4000a784 <_POSIX_Message_queue_Send_support+0x6c> 4000a86c: 84 08 60 01 and %g1, 1, %g2 4000a870: 40 00 16 40 call 40010170 <_Thread_Dispatch> 4000a874: 01 00 00 00 nop * 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 ) 4000a878: 10 bf ff d6 b 4000a7d0 <_POSIX_Message_queue_Send_support+0xb8> 4000a87c: 80 a7 60 07 cmp %i5, 7 msg_status = _Thread_Executing->Wait.return_code; 4000a880: c4 00 60 dc ld [ %g1 + 0xdc ], %g2 4000a884: 10 bf ff d5 b 4000a7d8 <_POSIX_Message_queue_Send_support+0xc0> 4000a888: fa 00 a0 34 ld [ %g2 + 0x34 ], %i5 * 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 ); 4000a88c: 40 00 2f 57 call 400165e8 <__errno> 4000a890: 01 00 00 00 nop 4000a894: 82 10 20 16 mov 0x16, %g1 ! 16 4000a898: c2 22 00 00 st %g1, [ %o0 ] 4000a89c: 10 bf ff b2 b 4000a764 <_POSIX_Message_queue_Send_support+0x4c> 4000a8a0: 90 10 3f ff mov -1, %o0 4000aa74 <_POSIX_Message_queue_Translate_core_message_queue_return_code>: */ int _POSIX_Message_queue_Translate_core_message_queue_return_code( uint32_t the_message_queue_status ) { 4000aa74: 9d e3 bf 98 save %sp, -104, %sp switch ( the_message_queue_status ) { 4000aa78: 80 a6 20 03 cmp %i0, 3 4000aa7c: 02 80 00 21 be 4000ab00 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x8c> 4000aa80: 94 10 00 18 mov %i0, %o2 4000aa84: 80 a6 20 03 cmp %i0, 3 4000aa88: 08 80 00 12 bleu 4000aad0 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x5c> 4000aa8c: 80 a6 20 01 cmp %i0, 1 4000aa90: 80 a6 20 05 cmp %i0, 5 4000aa94: 02 80 00 19 be 4000aaf8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x84> 4000aa98: 01 00 00 00 nop 4000aa9c: 2a 80 00 13 bcs,a 4000aae8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x74> 4000aaa0: b0 10 20 0b mov 0xb, %i0 ! b 4000aaa4: 80 a6 20 06 cmp %i0, 6 4000aaa8: 02 80 00 1a be 4000ab10 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x9c> 4000aaac: 03 00 44 44 sethi %hi(0x1111000), %g1 4000aab0: 82 10 61 11 or %g1, 0x111, %g1 ! 1111111 <== NOT EXECUTED 4000aab4: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 4000aab8: 02 80 00 14 be 4000ab08 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x94> <== NOT EXECUTED 4000aabc: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED * RTEMS POSIX API implementation does not support multiprocessing. */ case THREAD_STATUS_PROXY_BLOCKING: return ENOSYS; } _Internal_error_Occurred( 4000aac0: 40 00 0f 42 call 4000e7c8 <_Internal_error_Occurred> <== NOT EXECUTED 4000aac4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED INTERNAL_ERROR_POSIX_API, TRUE, the_message_queue_status ); return POSIX_BOTTOM_REACHED(); 4000aac8: 40 00 05 5f call 4000c044 <== NOT EXECUTED 4000aacc: 81 e8 00 00 restore <== NOT EXECUTED int _POSIX_Message_queue_Translate_core_message_queue_return_code( uint32_t the_message_queue_status ) { switch ( the_message_queue_status ) { 4000aad0: 02 80 00 06 be 4000aae8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x74> 4000aad4: b0 10 20 7a mov 0x7a, %i0 4000aad8: 80 a2 a0 01 cmp %o2, 1 4000aadc: 08 80 00 05 bleu 4000aaf0 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x7c> 4000aae0: 01 00 00 00 nop _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, the_message_queue_status ); return POSIX_BOTTOM_REACHED(); 4000aae4: b0 10 20 0b mov 0xb, %i0 ! b } 4000aae8: 81 c7 e0 08 ret 4000aaec: 81 e8 00 00 restore int _POSIX_Message_queue_Translate_core_message_queue_return_code( uint32_t the_message_queue_status ) { switch ( the_message_queue_status ) { 4000aaf0: 81 c7 e0 08 ret <== NOT EXECUTED 4000aaf4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED /* * Out of message buffers to queue pending message */ case CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED: return ENOMEM; 4000aaf8: 81 c7 e0 08 ret 4000aafc: 91 e8 20 09 restore %g0, 9, %o0 /* * Bad message size */ case CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE: return EMSGSIZE; 4000ab00: 81 c7 e0 08 ret <== NOT EXECUTED 4000ab04: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED int _POSIX_Message_queue_Translate_core_message_queue_return_code( uint32_t the_message_queue_status ) { switch ( the_message_queue_status ) { 4000ab08: 81 c7 e0 08 ret <== NOT EXECUTED 4000ab0c: 91 e8 20 58 restore %g0, 0x58, %o0 <== NOT EXECUTED 4000ab10: 81 c7 e0 08 ret 4000ab14: 91 e8 20 74 restore %g0, 0x74, %o0 40010258 <_POSIX_Mutex_From_core_mutex_status>: */ int _POSIX_Mutex_From_core_mutex_status( CORE_mutex_Status status ) { 40010258: 9d e3 bf 98 save %sp, -104, %sp switch ( status ) { 4001025c: 80 a6 20 06 cmp %i0, 6 40010260: 08 80 00 0b bleu 4001028c <_POSIX_Mutex_From_core_mutex_status+0x34> 40010264: 83 2e 20 02 sll %i0, 2, %g1 case CORE_MUTEX_STATUS_CEILING_VIOLATED: return EINVAL; default: break; } assert( 0 ); 40010268: 92 10 20 32 mov 0x32, %o1 <== NOT EXECUTED 4001026c: 11 10 00 65 sethi %hi(0x40019400), %o0 <== NOT EXECUTED 40010270: 15 10 00 5f sethi %hi(0x40017c00), %o2 <== NOT EXECUTED 40010274: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED 40010278: 94 12 a1 40 or %o2, 0x140, %o2 <== NOT EXECUTED 4001027c: 7f ff cf 64 call 4000400c <__assert> <== NOT EXECUTED 40010280: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 40010284: 81 c7 e0 08 ret <== NOT EXECUTED 40010288: 81 e8 00 00 restore <== NOT EXECUTED int _POSIX_Mutex_From_core_mutex_status( CORE_mutex_Status status ) { switch ( status ) { 4001028c: 05 10 00 40 sethi %hi(0x40010000), %g2 40010290: 84 10 a2 3c or %g2, 0x23c, %g2 ! 4001023c <_POSIX_Message_queue_Manager_initialization+0x58> 40010294: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40010298: 81 c0 c0 00 jmp %g3 4001029c: 01 00 00 00 nop 400102a0: 81 c7 e0 08 ret 400102a4: 91 e8 20 74 restore %g0, 0x74, %o0 400102a8: 81 c7 e0 08 ret 400102ac: 91 e8 20 00 restore %g0, 0, %o0 case CORE_MUTEX_STATUS_SUCCESSFUL: return 0; 400102b0: 81 c7 e0 08 ret 400102b4: 91 e8 20 10 restore %g0, 0x10, %o0 case CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT: return EBUSY; 400102b8: 81 c7 e0 08 ret 400102bc: 91 e8 20 2d restore %g0, 0x2d, %o0 case CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED: return EDEADLK; 400102c0: 81 c7 e0 08 ret 400102c4: 91 e8 20 01 restore %g0, 1, %o0 int _POSIX_Mutex_From_core_mutex_status( CORE_mutex_Status status ) { switch ( status ) { 400102c8: 81 c7 e0 08 ret 400102cc: 91 e8 20 16 restore %g0, 0x16, %o0 400079d4 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, boolean blocking, Watchdog_Interval timeout ) { 400079d4: 9d e3 bf 90 save %sp, -112, %sp ISR_Level *level ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 400079d8: 80 a6 20 00 cmp %i0, 0 400079dc: 32 80 00 05 bne,a 400079f0 <_POSIX_Mutex_Lock_support+0x1c> 400079e0: d2 06 00 00 ld [ %i0 ], %o1 ); return _POSIX_Mutex_From_core_mutex_status( (CORE_mutex_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 400079e4: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED } 400079e8: 81 c7 e0 08 ret 400079ec: 91 e8 00 08 restore %g0, %o0, %o0 400079f0: 80 a2 7f ff cmp %o1, -1 400079f4: 02 80 00 94 be 40007c44 <_POSIX_Mutex_Lock_support+0x270> 400079f8: 90 10 00 18 mov %i0, %o0 return (POSIX_Mutex_Control *) 400079fc: 11 10 00 6d sethi %hi(0x4001b400), %o0 40007a00: 94 07 bf f4 add %fp, -12, %o2 40007a04: 90 12 21 54 or %o0, 0x154, %o0 40007a08: 40 00 0e d8 call 4000b568 <_Objects_Get_isr_disable> 40007a0c: 96 07 bf f0 add %fp, -16, %o3 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); switch ( location ) { 40007a10: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007a14: 80 a0 60 00 cmp %g1, 0 40007a18: 12 80 00 21 bne 40007a9c <_POSIX_Mutex_Lock_support+0xc8> 40007a1c: a0 10 00 08 mov %o0, %l0 ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 40007a20: 31 10 00 6c sethi %hi(0x4001b000), %i0 40007a24: c2 06 20 f0 ld [ %i0 + 0xf0 ], %g1 ! 4001b0f0 <_Thread_Dispatch_disable_level> 40007a28: 80 a0 60 00 cmp %g1, 0 40007a2c: 12 80 00 22 bne 40007ab4 <_POSIX_Mutex_Lock_support+0xe0> 40007a30: 80 a6 60 00 cmp %i1, 0 Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40007a34: 23 10 00 6c sethi %hi(0x4001b000), %l1 40007a38: c4 04 61 cc ld [ %l1 + 0x1cc ], %g2 ! 4001b1cc <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 40007a3c: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40007a40: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40007a44: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 40007a48: 80 a0 60 00 cmp %g1, 0 40007a4c: 22 80 00 26 be,a 40007ae4 <_POSIX_Mutex_Lock_support+0x110> 40007a50: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 40007a54: c0 24 20 64 clr [ %l0 + 0x64 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40007a58: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 40007a5c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 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; the_mutex->nest_count = 1; 40007a60: 88 10 20 01 mov 1, %g4 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; 40007a64: c2 24 20 74 st %g1, [ %l0 + 0x74 ] 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; 40007a68: c4 24 20 70 st %g2, [ %l0 + 0x70 ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40007a6c: 80 a0 e0 02 cmp %g3, 2 40007a70: 02 80 00 2b be 40007b1c <_POSIX_Mutex_Lock_support+0x148> 40007a74: c8 24 20 68 st %g4, [ %l0 + 0x68 ] 40007a78: 80 a0 e0 03 cmp %g3, 3 40007a7c: 22 80 00 2a be,a 40007b24 <_POSIX_Mutex_Lock_support+0x150> 40007a80: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 40007a84: 7f ff f1 0f call 40003ec0 40007a88: 01 00 00 00 nop the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 40007a8c: c2 04 61 cc ld [ %l1 + 0x1cc ], %g1 40007a90: 40 00 21 f2 call 40010258 <_POSIX_Mutex_From_core_mutex_status> 40007a94: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 40007a98: 30 bf ff d4 b,a 400079e8 <_POSIX_Mutex_Lock_support+0x14> register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); switch ( location ) { 40007a9c: 80 a0 60 02 cmp %g1, 2 40007aa0: 28 bf ff d2 bleu,a 400079e8 <_POSIX_Mutex_Lock_support+0x14> 40007aa4: 90 10 20 16 mov 0x16, %o0 ); return _POSIX_Mutex_From_core_mutex_status( (CORE_mutex_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40007aa8: 40 00 04 15 call 40008afc <== NOT EXECUTED 40007aac: 01 00 00 00 nop <== NOT EXECUTED 40007ab0: 30 bf ff ce b,a 400079e8 <_POSIX_Mutex_Lock_support+0x14> <== NOT EXECUTED ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 40007ab4: 02 bf ff e1 be 40007a38 <_POSIX_Mutex_Lock_support+0x64> <== NOT EXECUTED 40007ab8: 23 10 00 6c sethi %hi(0x4001b000), %l1 <== NOT EXECUTED 40007abc: 03 10 00 6c sethi %hi(0x4001b000), %g1 <== NOT EXECUTED 40007ac0: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 4001b2d0 <_System_state_Current> <== NOT EXECUTED 40007ac4: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40007ac8: 08 bf ff dc bleu 40007a38 <_POSIX_Mutex_Lock_support+0x64> <== NOT EXECUTED 40007acc: 90 10 20 00 clr %o0 <== NOT EXECUTED 40007ad0: 92 10 20 00 clr %o1 <== NOT EXECUTED 40007ad4: 40 00 0d 45 call 4000afe8 <_Internal_error_Occurred> <== NOT EXECUTED 40007ad8: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40007adc: 10 bf ff d7 b 40007a38 <_POSIX_Mutex_Lock_support+0x64> <== NOT EXECUTED 40007ae0: 23 10 00 6c sethi %hi(0x4001b000), %l1 <== NOT EXECUTED /* * 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 ) ) { 40007ae4: 80 a0 40 02 cmp %g1, %g2 40007ae8: 12 80 00 2d bne 40007b9c <_POSIX_Mutex_Lock_support+0x1c8> 40007aec: 80 a6 60 00 cmp %i1, 0 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40007af0: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 40007af4: 80 a0 60 00 cmp %g1, 0 40007af8: 12 80 00 41 bne 40007bfc <_POSIX_Mutex_Lock_support+0x228> 40007afc: 80 a0 60 01 cmp %g1, 1 case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40007b00: c2 04 20 68 ld [ %l0 + 0x68 ], %g1 <== NOT EXECUTED 40007b04: 82 00 60 01 inc %g1 <== NOT EXECUTED 40007b08: c2 24 20 68 st %g1, [ %l0 + 0x68 ] <== NOT EXECUTED _ISR_Enable( level ); 40007b0c: 7f ff f0 ed call 40003ec0 <== NOT EXECUTED 40007b10: 01 00 00 00 nop <== NOT EXECUTED the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 40007b14: 10 bf ff df b 40007a90 <_POSIX_Mutex_Lock_support+0xbc> <== NOT EXECUTED 40007b18: c2 04 61 cc ld [ %l1 + 0x1cc ], %g1 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40007b1c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40007b20: 80 a0 e0 03 cmp %g3, 3 the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40007b24: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40007b28: 12 bf ff d7 bne 40007a84 <_POSIX_Mutex_Lock_support+0xb0> 40007b2c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40007b30: c6 04 20 60 ld [ %l0 + 0x60 ], %g3 current = executing->current_priority; 40007b34: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 if ( current == ceiling ) { 40007b38: 80 a0 40 03 cmp %g1, %g3 40007b3c: 02 80 00 49 be 40007c60 <_POSIX_Mutex_Lock_support+0x28c> 40007b40: 80 a0 c0 01 cmp %g3, %g1 _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40007b44: 1a 80 00 36 bcc 40007c1c <_POSIX_Mutex_Lock_support+0x248> 40007b48: 82 10 20 06 mov 6, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007b4c: c2 06 20 f0 ld [ %i0 + 0xf0 ], %g1 40007b50: 82 00 60 01 inc %g1 40007b54: c2 26 20 f0 st %g1, [ %i0 + 0xf0 ] _Thread_Disable_dispatch(); _ISR_Enable( level ); 40007b58: 7f ff f0 da call 40003ec0 40007b5c: 01 00 00 00 nop _Thread_Change_priority( 40007b60: d2 04 20 60 ld [ %l0 + 0x60 ], %o1 40007b64: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 40007b68: 40 00 12 66 call 4000c500 <_Thread_Change_priority> 40007b6c: 94 10 20 00 clr %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007b70: c2 06 20 f0 ld [ %i0 + 0xf0 ], %g1 40007b74: 82 00 7f ff add %g1, -1, %g1 40007b78: c2 26 20 f0 st %g1, [ %i0 + 0xf0 ] 40007b7c: c4 06 20 f0 ld [ %i0 + 0xf0 ], %g2 40007b80: 80 a0 a0 00 cmp %g2, 0 40007b84: 32 bf ff c3 bne,a 40007a90 <_POSIX_Mutex_Lock_support+0xbc> 40007b88: c2 04 61 cc ld [ %l1 + 0x1cc ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 40007b8c: 40 00 13 81 call 4000c990 <_Thread_Dispatch> 40007b90: 01 00 00 00 nop 40007b94: 10 bf ff bf b 40007a90 <_POSIX_Mutex_Lock_support+0xbc> 40007b98: c2 04 61 cc ld [ %l1 + 0x1cc ], %g1 ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 40007b9c: 32 80 00 08 bne,a 40007bbc <_POSIX_Mutex_Lock_support+0x1e8> 40007ba0: c4 04 20 08 ld [ %l0 + 8 ], %g2 40007ba4: 7f ff f0 c7 call 40003ec0 40007ba8: d0 07 bf f0 ld [ %fp + -16 ], %o0 40007bac: c4 04 61 cc ld [ %l1 + 0x1cc ], %g2 40007bb0: 82 10 20 01 mov 1, %g1 40007bb4: 10 bf ff b6 b 40007a8c <_POSIX_Mutex_Lock_support+0xb8> 40007bb8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] 40007bbc: c6 04 61 cc ld [ %l1 + 0x1cc ], %g3 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007bc0: c2 06 20 f0 ld [ %i0 + 0xf0 ], %g1 40007bc4: c4 20 e0 20 st %g2, [ %g3 + 0x20 ] 40007bc8: 82 00 60 01 inc %g1 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 40007bcc: 84 10 20 01 mov 1, %g2 40007bd0: c2 26 20 f0 st %g1, [ %i0 + 0xf0 ] 40007bd4: c4 24 20 44 st %g2, [ %l0 + 0x44 ] 40007bd8: a0 04 20 14 add %l0, 0x14, %l0 40007bdc: e0 20 e0 44 st %l0, [ %g3 + 0x44 ] 40007be0: 7f ff f0 b8 call 40003ec0 40007be4: d0 07 bf f0 ld [ %fp + -16 ], %o0 40007be8: 90 10 00 10 mov %l0, %o0 40007bec: 40 00 0a ae call 4000a6a4 <_CORE_mutex_Seize_interrupt_blocking> 40007bf0: 92 10 00 1a mov %i2, %o1 the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 40007bf4: 10 bf ff a7 b 40007a90 <_POSIX_Mutex_Lock_support+0xbc> 40007bf8: c2 04 61 cc ld [ %l1 + 0x1cc ], %g1 * 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 ) { 40007bfc: 12 bf ff e8 bne 40007b9c <_POSIX_Mutex_Lock_support+0x1c8> 40007c00: 80 a6 60 00 cmp %i1, 0 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; 40007c04: 82 10 20 02 mov 2, %g1 40007c08: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] _ISR_Enable( level ); 40007c0c: 7f ff f0 ad call 40003ec0 40007c10: 01 00 00 00 nop 40007c14: 10 bf ff 9f b 40007a90 <_POSIX_Mutex_Lock_support+0xbc> 40007c18: c2 04 61 cc ld [ %l1 + 0x1cc ], %g1 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40007c1c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] the_mutex->lock = CORE_MUTEX_UNLOCKED; 40007c20: c8 24 20 64 st %g4, [ %l0 + 0x64 ] the_mutex->nest_count = 0; /* undo locking above */ 40007c24: c0 24 20 68 clr [ %l0 + 0x68 ] executing->resource_count--; /* undo locking above */ 40007c28: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 40007c2c: 82 00 7f ff add %g1, -1, %g1 40007c30: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 40007c34: 7f ff f0 a3 call 40003ec0 40007c38: 01 00 00 00 nop 40007c3c: 10 bf ff 95 b 40007a90 <_POSIX_Mutex_Lock_support+0xbc> 40007c40: c2 04 61 cc ld [ %l1 + 0x1cc ], %g1 ISR_Level *level ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40007c44: 7f ff fe f6 call 4000781c <== NOT EXECUTED 40007c48: 92 10 20 00 clr %o1 <== NOT EXECUTED 40007c4c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007c50: 12 bf ff 66 bne 400079e8 <_POSIX_Mutex_Lock_support+0x14> <== NOT EXECUTED 40007c54: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 40007c58: 10 bf ff 69 b 400079fc <_POSIX_Mutex_Lock_support+0x28> <== NOT EXECUTED 40007c5c: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40007c60: 7f ff f0 98 call 40003ec0 <== NOT EXECUTED 40007c64: 01 00 00 00 nop <== NOT EXECUTED 40007c68: 10 bf ff 8a b 40007a90 <_POSIX_Mutex_Lock_support+0xbc> <== NOT EXECUTED 40007c6c: c2 04 61 cc ld [ %l1 + 0x1cc ], %g1 <== NOT EXECUTED 40006774 <_POSIX_RWLock_Translate_core_RWLock_return_code>: int _POSIX_RWLock_Translate_core_RWLock_return_code( CORE_RWLock_Status the_rwlock_status ) { if ( the_rwlock_status <= CORE_RWLOCK_STATUS_LAST ) 40006774: 80 a2 20 03 cmp %o0, 3 40006778: 18 80 00 06 bgu 40006790 <_POSIX_RWLock_Translate_core_RWLock_return_code+0x1c> 4000677c: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_RWLock_Return_codes[the_rwlock_status]; return POSIX_BOTTOM_REACHED(); } 40006780: 03 10 00 6e sethi %hi(0x4001b800), %g1 40006784: 82 10 61 9c or %g1, 0x19c, %g1 ! 4001b99c <_POSIX_RWLock_Return_codes> 40006788: 81 c3 e0 08 retl 4000678c: d0 00 40 02 ld [ %g1 + %g2 ], %o0 CORE_RWLock_Status the_rwlock_status ) { if ( the_rwlock_status <= CORE_RWLOCK_STATUS_LAST ) return _POSIX_RWLock_Return_codes[the_rwlock_status]; return POSIX_BOTTOM_REACHED(); 40006790: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40006794: 40 00 02 95 call 400071e8 <== NOT EXECUTED 40006798: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 4000679c: 01 00 00 00 nop 4000f3ec <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 4000f3ec: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000f3f0: 21 10 00 80 sethi %hi(0x40020000), %l0 4000f3f4: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 ! 400203b0 <_Thread_Dispatch_disable_level> 4000f3f8: 82 00 60 01 inc %g1 4000f3fc: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] char *name_p = (char *)name; _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { 4000f400: 80 a6 60 00 cmp %i1, 0 4000f404: 12 80 00 3b bne 4000f4f0 <_POSIX_Semaphore_Create_support+0x104> 4000f408: 80 a6 20 00 cmp %i0, 0 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSYS ); } if ( name ) { 4000f40c: 02 80 00 07 be 4000f428 <_POSIX_Semaphore_Create_support+0x3c> 4000f410: 23 10 00 81 sethi %hi(0x40020400), %l1 if( strlen(name) > PATH_MAX ) { 4000f414: 40 00 0f b9 call 400132f8 4000f418: 90 10 00 18 mov %i0, %o0 4000f41c: 80 a2 20 ff cmp %o0, 0xff 4000f420: 18 80 00 41 bgu 4000f524 <_POSIX_Semaphore_Create_support+0x138> 4000f424: 23 10 00 81 sethi %hi(0x40020400), %l1 * _POSIX_Semaphore_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void ) { return (POSIX_Semaphore_Control *) 4000f428: 7f ff e9 91 call 40009a6c <_Objects_Allocate> 4000f42c: 90 14 63 30 or %l1, 0x330, %o0 ! 40020730 <_POSIX_Semaphore_Information> } } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 4000f430: b2 92 20 00 orcc %o0, 0, %i1 4000f434: 02 80 00 4f be 4000f570 <_POSIX_Semaphore_Create_support+0x184> 4000f438: 80 a6 20 00 cmp %i0, 0 } #endif the_semaphore->process_shared = pshared; if ( name ) { 4000f43c: 02 80 00 29 be 4000f4e0 <_POSIX_Semaphore_Create_support+0xf4> 4000f440: c0 26 60 10 clr [ %i1 + 0x10 ] the_semaphore->named = TRUE; 4000f444: 82 10 20 01 mov 1, %g1 the_semaphore->open_count = 1; the_semaphore->linked = TRUE; 4000f448: c2 26 60 18 st %g1, [ %i1 + 0x18 ] #endif the_semaphore->process_shared = pshared; if ( name ) { the_semaphore->named = TRUE; 4000f44c: c2 26 60 14 st %g1, [ %i1 + 0x14 ] the_semaphore->open_count = 1; 4000f450: c2 26 60 1c st %g1, [ %i1 + 0x1c ] /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 4000f454: 82 10 3f ff mov -1, %g1 _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 4000f458: 90 06 60 20 add %i1, 0x20, %o0 /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 4000f45c: c2 26 60 60 st %g1, [ %i1 + 0x60 ] * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; 4000f460: c0 26 60 64 clr [ %i1 + 0x64 ] * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 4000f464: 94 10 00 1a mov %i2, %o2 4000f468: 7f ff e7 b1 call 4000932c <_CORE_semaphore_Initialize> 4000f46c: 92 06 60 60 add %i1, 0x60, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f470: 90 14 63 30 or %l1, 0x330, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000f474: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f478: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4000f47c: 03 00 00 3f sethi %hi(0xfc00), %g1 4000f480: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000f484: 82 08 80 01 and %g2, %g1, %g1 4000f488: 80 a0 40 03 cmp %g1, %g3 4000f48c: 38 80 00 06 bgu,a 4000f4a4 <_POSIX_Semaphore_Create_support+0xb8> 4000f490: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000f494: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000f498: 83 28 60 02 sll %g1, 2, %g1 4000f49c: f2 20 80 01 st %i1, [ %g2 + %g1 ] * Make the semaphore available for use. */ _Objects_Open(&_POSIX_Semaphore_Information, &the_semaphore->Object, name_p); *the_sem = the_semaphore; 4000f4a0: f2 26 c0 00 st %i1, [ %i3 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 4000f4a4: f0 26 60 0c st %i0, [ %i1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f4a8: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 4000f4ac: b0 10 20 00 clr %i0 4000f4b0: 82 00 7f ff add %g1, -1, %g1 4000f4b4: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] 4000f4b8: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 4000f4bc: 80 a0 a0 00 cmp %g2, 0 4000f4c0: 02 80 00 04 be 4000f4d0 <_POSIX_Semaphore_Create_support+0xe4> 4000f4c4: 01 00 00 00 nop ); #endif _Thread_Enable_dispatch(); return 0; } 4000f4c8: 81 c7 e0 08 ret 4000f4cc: 81 e8 00 00 restore _Thread_Dispatch(); 4000f4d0: 7f ff ef a4 call 4000b360 <_Thread_Dispatch> 4000f4d4: 01 00 00 00 nop 4000f4d8: 81 c7 e0 08 ret 4000f4dc: 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; 4000f4e0: c0 26 60 14 clr [ %i1 + 0x14 ] the_semaphore->open_count = 0; 4000f4e4: c0 26 60 1c clr [ %i1 + 0x1c ] the_semaphore->linked = FALSE; 4000f4e8: 10 bf ff db b 4000f454 <_POSIX_Semaphore_Create_support+0x68> 4000f4ec: c0 26 60 18 clr [ %i1 + 0x18 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f4f0: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 4000f4f4: 82 00 7f ff add %g1, -1, %g1 4000f4f8: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] 4000f4fc: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 4000f500: 80 a0 a0 00 cmp %g2, 0 4000f504: 02 80 00 15 be 4000f558 <_POSIX_Semaphore_Create_support+0x16c> 4000f508: 01 00 00 00 nop _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSYS ); 4000f50c: 40 00 09 03 call 40011918 <__errno> 4000f510: b0 10 3f ff mov -1, %i0 ! ffffffff 4000f514: 82 10 20 58 mov 0x58, %g1 4000f518: c2 22 00 00 st %g1, [ %o0 ] 4000f51c: 81 c7 e0 08 ret 4000f520: 81 e8 00 00 restore 4000f524: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 <== NOT EXECUTED 4000f528: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000f52c: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] <== NOT EXECUTED 4000f530: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 <== NOT EXECUTED 4000f534: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000f538: 02 80 00 0b be 4000f564 <_POSIX_Semaphore_Create_support+0x178> <== NOT EXECUTED 4000f53c: 01 00 00 00 nop <== NOT EXECUTED } if ( name ) { if( strlen(name) > PATH_MAX ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 4000f540: 40 00 08 f6 call 40011918 <__errno> <== NOT EXECUTED 4000f544: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 4000f548: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED 4000f54c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000f550: 81 c7 e0 08 ret <== NOT EXECUTED 4000f554: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4000f558: 7f ff ef 82 call 4000b360 <_Thread_Dispatch> 4000f55c: 01 00 00 00 nop 4000f560: 30 bf ff eb b,a 4000f50c <_POSIX_Semaphore_Create_support+0x120> 4000f564: 7f ff ef 7f call 4000b360 <_Thread_Dispatch> <== NOT EXECUTED 4000f568: 01 00 00 00 nop <== NOT EXECUTED 4000f56c: 30 bf ff f5 b,a 4000f540 <_POSIX_Semaphore_Create_support+0x154> <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f570: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 4000f574: 82 00 7f ff add %g1, -1, %g1 4000f578: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] 4000f57c: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 4000f580: 80 a0 a0 00 cmp %g2, 0 4000f584: 02 80 00 08 be 4000f5a4 <_POSIX_Semaphore_Create_support+0x1b8> 4000f588: 01 00 00 00 nop the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSPC ); 4000f58c: 40 00 08 e3 call 40011918 <__errno> 4000f590: b0 10 3f ff mov -1, %i0 ! ffffffff 4000f594: 82 10 20 1c mov 0x1c, %g1 4000f598: c2 22 00 00 st %g1, [ %o0 ] 4000f59c: 81 c7 e0 08 ret 4000f5a0: 81 e8 00 00 restore _Thread_Dispatch(); 4000f5a4: 7f ff ef 6f call 4000b360 <_Thread_Dispatch> 4000f5a8: 01 00 00 00 nop 4000f5ac: 30 bf ff f8 b,a 4000f58c <_POSIX_Semaphore_Create_support+0x1a0> 4000f6a0 <_POSIX_Semaphore_Wait_support>: int _POSIX_Semaphore_Wait_support( sem_t *sem, boolean blocking, Watchdog_Interval timeout ) { 4000f6a0: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get ( sem_t *id, Objects_Locations *location ) { return (POSIX_Semaphore_Control *) 4000f6a4: d2 06 00 00 ld [ %i0 ], %o1 4000f6a8: 94 07 bf f4 add %fp, -12, %o2 4000f6ac: 11 10 00 81 sethi %hi(0x40020400), %o0 4000f6b0: 7f ff ea 40 call 40009fb0 <_Objects_Get> 4000f6b4: 90 12 23 30 or %o0, 0x330, %o0 ! 40020730 <_POSIX_Semaphore_Information> POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 4000f6b8: c2 07 bf f4 ld [ %fp + -12 ], %g1 int _POSIX_Semaphore_Wait_support( sem_t *sem, boolean blocking, Watchdog_Interval timeout ) { 4000f6bc: 94 10 00 19 mov %i1, %o2 POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 4000f6c0: 80 a0 60 01 cmp %g1, 1 4000f6c4: 02 80 00 24 be 4000f754 <_POSIX_Semaphore_Wait_support+0xb4> 4000f6c8: 96 10 00 1a mov %i2, %o3 4000f6cc: 80 a0 60 01 cmp %g1, 1 4000f6d0: 2a 80 00 07 bcs,a 4000f6ec <_POSIX_Semaphore_Wait_support+0x4c> 4000f6d4: d2 02 20 08 ld [ %o0 + 8 ], %o1 4000f6d8: 80 a0 60 02 cmp %g1, 2 4000f6dc: 02 80 00 20 be 4000f75c <_POSIX_Semaphore_Wait_support+0xbc> 4000f6e0: 01 00 00 00 nop */ break; } } return 0; } 4000f6e4: 81 c7 e0 08 ret 4000f6e8: 91 e8 20 00 restore %g0, 0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: _CORE_semaphore_Seize( 4000f6ec: 40 00 01 9b call 4000fd58 <_CORE_semaphore_Seize> 4000f6f0: 90 02 20 20 add %o0, 0x20, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f6f4: 03 10 00 80 sethi %hi(0x40020000), %g1 4000f6f8: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 400203b0 <_Thread_Dispatch_disable_level> 4000f6fc: 84 00 bf ff add %g2, -1, %g2 4000f700: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 4000f704: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 4000f708: 80 a0 e0 00 cmp %g3, 0 4000f70c: 02 80 00 1a be 4000f774 <_POSIX_Semaphore_Wait_support+0xd4> 4000f710: 01 00 00 00 nop the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); switch ( _Thread_Executing->Wait.return_code ) { 4000f714: 03 10 00 81 sethi %hi(0x40020400), %g1 <== NOT EXECUTED 4000f718: c4 00 60 8c ld [ %g1 + 0x8c ], %g2 ! 4002048c <_Thread_Executing> 4000f71c: c2 00 a0 34 ld [ %g2 + 0x34 ], %g1 4000f720: 80 a0 60 02 cmp %g1, 2 4000f724: 02 80 00 06 be 4000f73c <_POSIX_Semaphore_Wait_support+0x9c> 4000f728: 80 a0 60 03 cmp %g1, 3 4000f72c: 02 80 00 16 be 4000f784 <_POSIX_Semaphore_Wait_support+0xe4> 4000f730: 80 a0 60 01 cmp %g1, 1 4000f734: 12 bf ff ec bne 4000f6e4 <_POSIX_Semaphore_Wait_support+0x44> 4000f738: 01 00 00 00 nop case CORE_SEMAPHORE_STATUS_SUCCESSFUL: break; case CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT: rtems_set_errno_and_return_minus_one( EAGAIN ); case CORE_SEMAPHORE_WAS_DELETED: rtems_set_errno_and_return_minus_one( EAGAIN ); 4000f73c: 40 00 08 77 call 40011918 <__errno> 4000f740: b0 10 3f ff mov -1, %i0 ! ffffffff 4000f744: 82 10 20 0b mov 0xb, %g1 4000f748: c2 22 00 00 st %g1, [ %o0 ] 4000f74c: 81 c7 e0 08 ret 4000f750: 81 e8 00 00 restore the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 4000f754: 7f ff ef 03 call 4000b360 <_Thread_Dispatch> <== NOT EXECUTED 4000f758: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 4000f75c: 40 00 08 6f call 40011918 <__errno> 4000f760: b0 10 3f ff mov -1, %i0 ! ffffffff 4000f764: 82 10 20 16 mov 0x16, %g1 4000f768: c2 22 00 00 st %g1, [ %o0 ] 4000f76c: 81 c7 e0 08 ret 4000f770: 81 e8 00 00 restore _Thread_Dispatch(); 4000f774: 7f ff ee fb call 4000b360 <_Thread_Dispatch> 4000f778: 01 00 00 00 nop the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); switch ( _Thread_Executing->Wait.return_code ) { 4000f77c: 10 bf ff e7 b 4000f718 <_POSIX_Semaphore_Wait_support+0x78> 4000f780: 03 10 00 81 sethi %hi(0x40020400), %g1 case CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT: rtems_set_errno_and_return_minus_one( EAGAIN ); case CORE_SEMAPHORE_WAS_DELETED: rtems_set_errno_and_return_minus_one( EAGAIN ); case CORE_SEMAPHORE_TIMEOUT: rtems_set_errno_and_return_minus_one( ETIMEDOUT ); 4000f784: 40 00 08 65 call 40011918 <__errno> 4000f788: b0 10 3f ff mov -1, %i0 4000f78c: 82 10 20 74 mov 0x74, %g1 4000f790: c2 22 00 00 st %g1, [ %o0 ] 4000f794: 81 c7 e0 08 ret 4000f798: 81 e8 00 00 restore 40005b78 <_POSIX_Spinlock_Translate_core_spinlock_return_code>: int _POSIX_Spinlock_Translate_core_spinlock_return_code( CORE_spinlock_Status the_spinlock_status ) { if ( the_spinlock_status <= CORE_SPINLOCK_STATUS_LAST ) 40005b78: 80 a2 20 06 cmp %o0, 6 40005b7c: 18 80 00 06 bgu 40005b94 <_POSIX_Spinlock_Translate_core_spinlock_return_code+0x1c> 40005b80: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_Spinlock_Return_codes[the_spinlock_status]; return POSIX_BOTTOM_REACHED(); } 40005b84: 03 10 00 4d sethi %hi(0x40013400), %g1 40005b88: 82 10 61 2c or %g1, 0x12c, %g1 ! 4001352c <_POSIX_Spinlock_Return_codes> 40005b8c: 81 c3 e0 08 retl 40005b90: d0 00 40 02 ld [ %g1 + %g2 ], %o0 CORE_spinlock_Status the_spinlock_status ) { if ( the_spinlock_status <= CORE_SPINLOCK_STATUS_LAST ) return _POSIX_Spinlock_Return_codes[the_spinlock_status]; return POSIX_BOTTOM_REACHED(); 40005b94: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40005b98: 40 00 00 66 call 40005d30 <== NOT EXECUTED 40005b9c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 40005ba0: 01 00 00 00 nop 400069b8 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body( void ) { 400069b8: 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; 400069bc: 03 10 00 7b sethi %hi(0x4001ec00), %g1 400069c0: e4 00 63 5c ld [ %g1 + 0x35c ], %l2 ! 4001ef5c <_POSIX_Threads_User_initialization_threads> maximum = _POSIX_Threads_Number_of_initialization_threads; 400069c4: 03 10 00 7c sethi %hi(0x4001f000), %g1 if ( !user_threads || maximum == 0 ) 400069c8: 80 a4 a0 00 cmp %l2, 0 400069cc: 02 80 00 54 be 40006b1c <_POSIX_Threads_Initialize_user_threads_body+0x164> 400069d0: ec 00 60 2c ld [ %g1 + 0x2c ], %l6 400069d4: 80 a5 a0 00 cmp %l6, 0 400069d8: 02 80 00 51 be 40006b1c <_POSIX_Threads_Initialize_user_threads_body+0x164> 400069dc: 03 10 00 72 sethi %hi(0x4001c800), %g1 * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { status = pthread_attr_init( &attr ); assert( !status ); 400069e0: 05 10 00 6f sethi %hi(0x4001bc00), %g2 400069e4: aa 10 63 88 or %g1, 0x388, %l5 400069e8: a8 10 a3 68 or %g2, 0x368, %l4 * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 400069ec: a6 10 20 00 clr %l3 400069f0: a2 10 20 00 clr %l1 400069f4: a0 07 bf bc add %fp, -68, %l0 400069f8: 10 80 00 1a b 40006a60 <_POSIX_Threads_Initialize_user_threads_body+0xa8> 400069fc: ae 07 bf f4 add %fp, -12, %l7 status = pthread_attr_init( &attr ); assert( !status ); status = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 40006a00: 40 00 20 db call 4000ed6c 40006a04: 90 10 00 10 mov %l0, %o0 assert( !status ); 40006a08: 80 a2 20 00 cmp %o0, 0 40006a0c: 12 80 00 26 bne 40006aa4 <_POSIX_Threads_Initialize_user_threads_body+0xec> 40006a10: 94 10 00 14 mov %l4, %o2 status = pthread_attr_setstacksize( &attr, user_threads[ index ].stack_size); 40006a14: 82 04 80 11 add %l2, %l1, %g1 40006a18: d2 00 60 04 ld [ %g1 + 4 ], %o1 40006a1c: 40 00 20 e4 call 4000edac 40006a20: 90 10 00 10 mov %l0, %o0 assert( !status ); 40006a24: 80 a2 20 00 cmp %o0, 0 40006a28: 12 80 00 2a bne 40006ad0 <_POSIX_Threads_Initialize_user_threads_body+0x118> 40006a2c: 90 10 00 15 mov %l5, %o0 status = pthread_create( 40006a30: d4 04 40 12 ld [ %l1 + %l2 ], %o2 40006a34: 92 10 00 10 mov %l0, %o1 40006a38: 96 10 20 00 clr %o3 40006a3c: 90 10 00 17 mov %l7, %o0 40006a40: 7f ff fe dd call 400065b4 40006a44: a2 04 60 08 add %l1, 8, %l1 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); assert( !status ); 40006a48: 80 a2 20 00 cmp %o0, 0 40006a4c: 12 80 00 2e bne 40006b04 <_POSIX_Threads_Initialize_user_threads_body+0x14c> 40006a50: 90 10 00 15 mov %l5, %o0 * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 40006a54: 80 a4 c0 16 cmp %l3, %l6 40006a58: 02 80 00 31 be 40006b1c <_POSIX_Threads_Initialize_user_threads_body+0x164> 40006a5c: 01 00 00 00 nop status = pthread_attr_init( &attr ); 40006a60: 90 10 00 10 mov %l0, %o0 40006a64: 40 00 20 b7 call 4000ed40 40006a68: a6 04 e0 01 inc %l3 assert( !status ); 40006a6c: 80 a2 20 00 cmp %o0, 0 40006a70: 02 bf ff e4 be 40006a00 <_POSIX_Threads_Initialize_user_threads_body+0x48> 40006a74: 92 10 20 02 mov 2, %o1 40006a78: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED 40006a7c: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 40006a80: 7f ff f0 ff call 40002e7c <__assert> <== NOT EXECUTED 40006a84: 92 10 20 47 mov 0x47, %o1 <== NOT EXECUTED status = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 40006a88: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 40006a8c: 40 00 20 b8 call 4000ed6c <== NOT EXECUTED 40006a90: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED assert( !status ); 40006a94: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40006a98: 02 bf ff e0 be 40006a18 <_POSIX_Threads_Initialize_user_threads_body+0x60> <== NOT EXECUTED 40006a9c: 82 04 80 11 add %l2, %l1, %g1 <== NOT EXECUTED 40006aa0: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED 40006aa4: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 40006aa8: 7f ff f0 f5 call 40002e7c <__assert> <== NOT EXECUTED 40006aac: 92 10 20 4a mov 0x4a, %o1 <== NOT EXECUTED status = pthread_attr_setstacksize( &attr, user_threads[ index ].stack_size); 40006ab0: 82 04 80 11 add %l2, %l1, %g1 <== NOT EXECUTED 40006ab4: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED 40006ab8: 40 00 20 bd call 4000edac <== NOT EXECUTED 40006abc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED assert( !status ); 40006ac0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40006ac4: 22 bf ff dc be,a 40006a34 <_POSIX_Threads_Initialize_user_threads_body+0x7c> <== NOT EXECUTED 40006ac8: d4 04 40 12 ld [ %l1 + %l2 ], %o2 <== NOT EXECUTED 40006acc: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 40006ad0: 92 10 20 4d mov 0x4d, %o1 <== NOT EXECUTED 40006ad4: 7f ff f0 ea call 40002e7c <__assert> <== NOT EXECUTED 40006ad8: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED status = pthread_create( 40006adc: d4 04 40 12 ld [ %l1 + %l2 ], %o2 <== NOT EXECUTED 40006ae0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 40006ae4: 96 10 20 00 clr %o3 <== NOT EXECUTED 40006ae8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED 40006aec: 7f ff fe b2 call 400065b4 <== NOT EXECUTED 40006af0: a2 04 60 08 add %l1, 8, %l1 <== NOT EXECUTED &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); assert( !status ); 40006af4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40006af8: 02 bf ff d8 be 40006a58 <_POSIX_Threads_Initialize_user_threads_body+0xa0> <== NOT EXECUTED 40006afc: 80 a4 c0 16 cmp %l3, %l6 <== NOT EXECUTED 40006b00: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 40006b04: 92 10 20 55 mov 0x55, %o1 <== NOT EXECUTED 40006b08: 7f ff f0 dd call 40002e7c <__assert> <== NOT EXECUTED 40006b0c: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 40006b10: 80 a4 c0 16 cmp %l3, %l6 <== NOT EXECUTED 40006b14: 12 bf ff d4 bne 40006a64 <_POSIX_Threads_Initialize_user_threads_body+0xac> <== NOT EXECUTED 40006b18: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 40006b1c: 81 c7 e0 08 ret 40006b20: 81 e8 00 00 restore 4000cd1c <_POSIX_Threads_Sporadic_budget_TSR>: void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id, void *argument ) { 4000cd1c: 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 ]; 4000cd20: f0 06 61 70 ld [ %i1 + 0x170 ], %i0 ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); 4000cd24: 40 00 04 09 call 4000dd48 <_Timespec_To_ticks> 4000cd28: 90 06 20 90 add %i0, 0x90, %o0 if ( !ticks ) 4000cd2c: 80 a2 20 00 cmp %o0, 0 4000cd30: 22 80 00 02 be,a 4000cd38 <_POSIX_Threads_Sporadic_budget_TSR+0x1c> 4000cd34: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 4000cd38: 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 || 4000cd3c: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 4000cd40: 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; 4000cd44: d0 26 60 84 st %o0, [ %i1 + 0x84 ] 4000cd48: 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 || 4000cd4c: 80 a0 e0 00 cmp %g3, 0 4000cd50: 02 80 00 10 be 4000cd90 <_POSIX_Threads_Sporadic_budget_TSR+0x74> 4000cd54: d2 26 60 18 st %o1, [ %i1 + 0x18 ] 4000cd58: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 4000cd5c: 80 a2 40 01 cmp %o1, %g1 4000cd60: 0a 80 00 0d bcs 4000cd94 <_POSIX_Threads_Sporadic_budget_TSR+0x78> 4000cd64: 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 ); 4000cd68: 40 00 03 f8 call 4000dd48 <_Timespec_To_ticks> <== NOT EXECUTED 4000cd6c: 90 06 20 88 add %i0, 0x88, %o0 <== NOT EXECUTED if ( !ticks ) 4000cd70: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000cd74: 22 80 00 10 be,a 4000cdb4 <_POSIX_Threads_Sporadic_budget_TSR+0x98> <== NOT EXECUTED 4000cd78: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000cd7c: d0 26 20 a8 st %o0, [ %i0 + 0xa8 ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4000cd80: b2 06 20 9c add %i0, 0x9c, %i1 4000cd84: 31 10 00 6b sethi %hi(0x4001ac00), %i0 4000cd88: 7f ff f6 4a call 4000a6b0 <_Watchdog_Insert> 4000cd8c: 91 ee 20 5c restore %i0, 0x5c, %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 ); 4000cd90: 90 10 00 19 mov %i1, %o0 4000cd94: 7f ff ef fc call 40008d84 <_Thread_Change_priority> 4000cd98: 94 10 20 01 mov 1, %o2 ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 4000cd9c: 40 00 03 eb call 4000dd48 <_Timespec_To_ticks> 4000cda0: 90 06 20 88 add %i0, 0x88, %o0 if ( !ticks ) 4000cda4: 80 a2 20 00 cmp %o0, 0 4000cda8: 32 bf ff f6 bne,a 4000cd80 <_POSIX_Threads_Sporadic_budget_TSR+0x64> 4000cdac: d0 26 20 a8 st %o0, [ %i0 + 0xa8 ] 4000cdb0: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 4000cdb4: b2 06 20 9c add %i0, 0x9c, %i1 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000cdb8: d0 26 20 a8 st %o0, [ %i0 + 0xa8 ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4000cdbc: 31 10 00 6b sethi %hi(0x4001ac00), %i0 <== NOT EXECUTED 4000cdc0: 7f ff f6 3c call 4000a6b0 <_Watchdog_Insert> <== NOT EXECUTED 4000cdc4: 91 ee 20 5c restore %i0, 0x5c, %o0 <== NOT EXECUTED 4000cdc8: 01 00 00 00 nop 4000cccc <_POSIX_Threads_Sporadic_budget_callout>: ) { POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 4000cccc: c4 02 21 70 ld [ %o0 + 0x170 ], %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 || 4000ccd0: c8 02 20 1c ld [ %o0 + 0x1c ], %g4 RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (255 - priority); 4000ccd4: 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 */ 4000ccd8: 82 10 3f ff mov -1, %g1 4000ccdc: 84 10 20 ff mov 0xff, %g2 4000cce0: c2 22 20 84 st %g1, [ %o0 + 0x84 ] 4000cce4: 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 || 4000cce8: 80 a1 20 00 cmp %g4, 0 4000ccec: 02 80 00 06 be 4000cd04 <_POSIX_Threads_Sporadic_budget_callout+0x38> 4000ccf0: d2 22 20 18 st %o1, [ %o0 + 0x18 ] 4000ccf4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED 4000ccf8: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED 4000ccfc: 1a 80 00 06 bcc 4000cd14 <_POSIX_Threads_Sporadic_budget_callout+0x48> <== NOT EXECUTED 4000cd00: 01 00 00 00 nop <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 4000cd04: 94 10 20 01 mov 1, %o2 ! 1 4000cd08: 82 13 c0 00 mov %o7, %g1 4000cd0c: 7f ff f0 1e call 40008d84 <_Thread_Change_priority> 4000cd10: 9e 10 40 00 mov %g1, %o7 4000cd14: 81 c3 e0 08 retl <== NOT EXECUTED 4000cd18: 01 00 00 00 nop 4000541c <_POSIX_Threads_cancel_run>: */ void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 4000541c: 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 ]; 40005420: e2 06 21 70 ld [ %i0 + 0x170 ], %l1 handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 40005424: 82 10 20 01 mov 1, %g1 while ( !_Chain_Is_empty( handler_stack ) ) { 40005428: 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; 4000542c: b2 04 60 dc add %l1, 0xdc, %i1 40005430: 80 a0 80 19 cmp %g2, %i1 40005434: 02 80 00 17 be 40005490 <_POSIX_Threads_cancel_run+0x74> 40005438: c2 24 60 cc st %g1, [ %l1 + 0xcc ] 4000543c: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED 40005440: a4 10 60 9c or %g1, 0x9c, %l2 ! 40017c9c <_Workspace_Area> <== NOT EXECUTED _ISR_Disable( level ); 40005444: 7f ff f2 aa call 40001eec <== NOT EXECUTED 40005448: 01 00 00 00 nop <== NOT EXECUTED handler = (POSIX_Cancel_Handler_control *) 4000544c: e0 06 60 04 ld [ %i1 + 4 ], %l0 <== NOT EXECUTED ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 40005450: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED previous = the_node->previous; 40005454: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 40005458: 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; 4000545c: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 40005460: 7f ff f2 a7 call 40001efc <== NOT EXECUTED 40005464: 01 00 00 00 nop <== NOT EXECUTED (*handler->routine)( handler->arg ); 40005468: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 4000546c: 9f c0 40 00 call %g1 <== NOT EXECUTED 40005470: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 40005474: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40005478: 40 00 0a e8 call 40008018 <_Heap_Free> <== NOT EXECUTED 4000547c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; while ( !_Chain_Is_empty( handler_stack ) ) { 40005480: c2 04 60 d8 ld [ %l1 + 0xd8 ], %g1 <== NOT EXECUTED 40005484: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 40005488: 12 bf ff ef bne 40005444 <_POSIX_Threads_cancel_run+0x28> <== NOT EXECUTED 4000548c: 01 00 00 00 nop <== NOT EXECUTED } /* Now we can delete the thread */ the_thread->Wait.return_argument = PTHREAD_CANCELED; _Thread_Close( 40005490: c6 06 20 08 ld [ %i0 + 8 ], %g3 40005494: 03 10 00 5e sethi %hi(0x40017800), %g1 40005498: 85 30 e0 16 srl %g3, 0x16, %g2 4000549c: 82 10 63 b0 or %g1, 0x3b0, %g1 400054a0: 84 08 a0 1c and %g2, 0x1c, %g2 400054a4: c8 00 40 02 ld [ %g1 + %g2 ], %g4 400054a8: 87 30 e0 1b srl %g3, 0x1b, %g3 400054ac: 87 28 e0 02 sll %g3, 2, %g3 400054b0: d0 01 00 03 ld [ %g4 + %g3 ], %o0 400054b4: 92 10 00 18 mov %i0, %o1 _Workspace_Free( handler ); } /* Now we can delete the thread */ the_thread->Wait.return_argument = PTHREAD_CANCELED; 400054b8: 82 10 3f ff mov -1, %g1 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 400054bc: b2 10 00 18 mov %i0, %i1 400054c0: c2 26 20 28 st %g1, [ %i0 + 0x28 ] _Thread_Close( 400054c4: 40 00 11 c1 call 40009bc8 <_Thread_Close> 400054c8: 31 10 00 5f sethi %hi(0x40017c00), %i0 400054cc: 40 00 0d 0e call 40008904 <_Objects_Free> 400054d0: 91 ee 23 38 restore %i0, 0x338, %o0 400054d4: 01 00 00 00 nop 4000b694 <_POSIX_Timer_TSR>: * Description: This is the operation that is ran when a timer expires * ***************************************************************************/ void _POSIX_Timer_TSR(Objects_Id timer, void *data) { 4000b694: 9d e3 bf 98 save %sp, -104, %sp boolean activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 4000b698: c2 06 60 68 ld [ %i1 + 0x68 ], %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 4000b69c: c4 06 60 54 ld [ %i1 + 0x54 ], %g2 boolean activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 4000b6a0: 82 00 60 01 inc %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 4000b6a4: 80 a0 a0 00 cmp %g2, 0 4000b6a8: 12 80 00 0e bne 4000b6e0 <_POSIX_Timer_TSR+0x4c> 4000b6ac: c2 26 60 68 st %g1, [ %i1 + 0x68 ] 4000b6b0: c2 06 60 58 ld [ %i1 + 0x58 ], %g1 <== NOT EXECUTED 4000b6b4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000b6b8: 32 80 00 0b bne,a 4000b6e4 <_POSIX_Timer_TSR+0x50> <== NOT EXECUTED 4000b6bc: 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; 4000b6c0: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED 4000b6c4: 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 ) ) { 4000b6c8: d0 06 60 38 ld [ %i1 + 0x38 ], %o0 4000b6cc: 40 00 22 7b call 400140b8 4000b6d0: 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; 4000b6d4: c0 26 60 68 clr [ %i1 + 0x68 ] 4000b6d8: 81 c7 e0 08 ret 4000b6dc: 81 e8 00 00 restore ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { #if 0 status = rtems_timer_fire_after( ptimer->timer_id, ptimer->ticks, _POSIX_Timer_TSR, ptimer ); #endif activated = _Watchdog_Insert_ticks_helper( 4000b6e0: d2 06 60 64 ld [ %i1 + 0x64 ], %o1 4000b6e4: d4 06 60 08 ld [ %i1 + 8 ], %o2 4000b6e8: 90 06 60 10 add %i1, 0x10, %o0 4000b6ec: 17 10 00 2d sethi %hi(0x4000b400), %o3 4000b6f0: 98 10 00 19 mov %i1, %o4 4000b6f4: 7f ff ff cd call 4000b628 <_Watchdog_Insert_ticks_helper> 4000b6f8: 96 12 e2 94 or %o3, 0x294, %o3 ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 4000b6fc: 80 a2 20 00 cmp %o0, 0 4000b700: 02 bf ff f6 be 4000b6d8 <_POSIX_Timer_TSR+0x44> 4000b704: 01 00 00 00 nop return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 4000b708: 40 00 0a 9b call 4000e174 <_TOD_Get> 4000b70c: 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; 4000b710: 82 10 20 03 mov 3, %g1 4000b714: 10 bf ff ed b 4000b6c8 <_POSIX_Timer_TSR+0x34> 4000b718: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] 4000ca70 <_POSIX_signals_Abnormal_termination_handler>: /*** PROCESS WIDE STUFF ****/ sigset_t _POSIX_signals_Pending; void _POSIX_signals_Abnormal_termination_handler( int signo ) { 4000ca70: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED exit( 1 ); 4000ca74: 40 00 08 e1 call 4000edf8 <== NOT EXECUTED 4000ca78: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 4000ca7c: 01 00 00 00 nop 4000e46c <_POSIX_signals_Check_signal>: boolean _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, boolean is_global ) { 4000e46c: 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, 4000e470: 98 10 20 01 mov 1, %o4 4000e474: 96 10 00 1a mov %i2, %o3 4000e478: a6 07 bf ec add %fp, -20, %l3 4000e47c: 90 10 00 18 mov %i0, %o0 4000e480: 92 10 00 19 mov %i1, %o1 4000e484: 40 00 00 2f call 4000e540 <_POSIX_signals_Clear_signals> 4000e488: 94 10 00 13 mov %l3, %o2 4000e48c: 80 a2 20 00 cmp %o0, 0 4000e490: 02 80 00 23 be 4000e51c <_POSIX_signals_Check_signal+0xb0> 4000e494: 03 10 00 6c sethi %hi(0x4001b000), %g1 /* * Since we made a union of these, only one test is necessary but this is * safer. */ assert( _POSIX_signals_Vectors[ signo ].sa_handler || 4000e498: a4 10 61 f4 or %g1, 0x1f4, %l2 ! 4001b1f4 <_POSIX_signals_Vectors> 4000e49c: 83 2e 60 04 sll %i1, 4, %g1 4000e4a0: 85 2e 60 02 sll %i1, 2, %g2 4000e4a4: a0 20 40 02 sub %g1, %g2, %l0 4000e4a8: b4 04 00 12 add %l0, %l2, %i2 4000e4ac: c2 06 a0 08 ld [ %i2 + 8 ], %g1 4000e4b0: 80 a0 60 00 cmp %g1, 0 4000e4b4: 02 80 00 1c be 4000e524 <_POSIX_signals_Check_signal+0xb8> 4000e4b8: 11 10 00 64 sethi %hi(0x40019000), %o0 /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 4000e4bc: 80 a0 60 01 cmp %g1, 1 4000e4c0: 02 80 00 17 be 4000e51c <_POSIX_signals_Check_signal+0xb0> 4000e4c4: 01 00 00 00 nop /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 4000e4c8: e2 06 20 c4 ld [ %i0 + 0xc4 ], %l1 api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 4000e4cc: c2 06 a0 04 ld [ %i2 + 4 ], %g1 /* Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 4000e4d0: c4 04 80 10 ld [ %l2 + %l0 ], %g2 /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 4000e4d4: 82 10 40 11 or %g1, %l1, %g1 /* Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 4000e4d8: 80 a0 a0 02 cmp %g2, 2 4000e4dc: 02 80 00 08 be 4000e4fc <_POSIX_signals_Check_signal+0x90> 4000e4e0: 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 ); 4000e4e4: c2 06 a0 08 ld [ %i2 + 8 ], %g1 4000e4e8: 9f c0 40 00 call %g1 4000e4ec: 90 10 00 19 mov %i1, %o0 /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 4000e4f0: e2 26 20 c4 st %l1, [ %i0 + 0xc4 ] 4000e4f4: 81 c7 e0 08 ret 4000e4f8: 91 e8 20 01 restore %g0, 1, %o0 case SA_SIGINFO: /* * * assert( is_global ); */ (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 4000e4fc: c2 06 a0 08 ld [ %i2 + 8 ], %g1 4000e500: 90 10 00 19 mov %i1, %o0 4000e504: 92 10 00 13 mov %l3, %o1 4000e508: 9f c0 40 00 call %g1 4000e50c: 94 10 20 00 clr %o2 /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 4000e510: e2 26 20 c4 st %l1, [ %i0 + 0xc4 ] 4000e514: 81 c7 e0 08 ret 4000e518: 91 e8 20 01 restore %g0, 1, %o0 return TRUE; } 4000e51c: 81 c7 e0 08 ret 4000e520: 91 e8 20 00 restore %g0, 0, %o0 /* * Since we made a union of these, only one test is necessary but this is * safer. */ assert( _POSIX_signals_Vectors[ signo ].sa_handler || 4000e524: 92 10 20 33 mov 0x33, %o1 <== NOT EXECUTED 4000e528: 90 12 20 f0 or %o0, 0xf0, %o0 <== NOT EXECUTED 4000e52c: 15 10 00 64 sethi %hi(0x40019000), %o2 <== NOT EXECUTED 4000e530: 7f ff ce 88 call 40001f50 <__assert> <== NOT EXECUTED 4000e534: 94 12 a1 40 or %o2, 0x140, %o2 ! 40019140 <_POSIX_Threads_Default_attributes+0x178> <== NOT EXECUTED 4000e538: 10 bf ff e1 b 4000e4bc <_POSIX_signals_Check_signal+0x50> <== NOT EXECUTED 4000e53c: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED 4000e540 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, boolean is_global, boolean check_blocked ) { 4000e540: 9d e3 bf 98 save %sp, -104, %sp sigset_t signals_blocked; ISR_Level level; boolean do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); 4000e544: 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 ) 4000e548: 80 a7 20 00 cmp %i4, 0 sigset_t signals_blocked; ISR_Level level; boolean do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); 4000e54c: 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 ) 4000e550: b8 10 3f ff mov -1, %i4 4000e554: 02 80 00 04 be 4000e564 <_POSIX_signals_Clear_signals+0x24> 4000e558: a1 28 40 02 sll %g1, %g2, %l0 signals_blocked = ~api->signals_blocked; 4000e55c: c2 06 20 c4 ld [ %i0 + 0xc4 ], %g1 4000e560: 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 ); 4000e564: 7f ff ce 24 call 40001df4 4000e568: 01 00 00 00 nop 4000e56c: a2 10 00 08 mov %o0, %l1 if ( is_global ) { 4000e570: 80 a6 e0 00 cmp %i3, 0 4000e574: 22 80 00 16 be,a 4000e5cc <_POSIX_signals_Clear_signals+0x8c> 4000e578: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0 if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 4000e57c: 05 10 00 6c sethi %hi(0x4001b000), %g2 4000e580: c2 00 a3 c0 ld [ %g2 + 0x3c0 ], %g1 ! 4001b3c0 <_POSIX_signals_Pending> 4000e584: 82 0c 00 01 and %l0, %g1, %g1 4000e588: 80 88 40 1c btst %g1, %i4 4000e58c: 02 80 00 1a be 4000e5f4 <_POSIX_signals_Clear_signals+0xb4> 4000e590: 85 2e 60 02 sll %i1, 2, %g2 if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 4000e594: 87 2e 60 04 sll %i1, 4, %g3 4000e598: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000e59c: 86 20 c0 02 sub %g3, %g2, %g3 4000e5a0: 82 10 61 f4 or %g1, 0x1f4, %g1 4000e5a4: c4 00 40 03 ld [ %g1 + %g3 ], %g2 4000e5a8: 80 a0 a0 02 cmp %g2, 2 4000e5ac: 02 80 00 17 be 4000e608 <_POSIX_signals_Clear_signals+0xc8> 4000e5b0: 90 10 00 10 mov %l0, %o0 &psiginfo->Node ); } else do_callout = FALSE; } else _POSIX_signals_Clear_process_signals( mask ); 4000e5b4: 40 00 01 f6 call 4000ed8c <_POSIX_signals_Clear_process_signals> 4000e5b8: b0 10 20 01 mov 1, %i0 if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; do_callout = TRUE; } } _ISR_Enable( level ); 4000e5bc: 7f ff ce 12 call 40001e04 4000e5c0: 90 10 00 11 mov %l1, %o0 return do_callout; } 4000e5c4: 81 c7 e0 08 ret 4000e5c8: 81 e8 00 00 restore } else _POSIX_signals_Clear_process_signals( mask ); do_callout = TRUE; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 4000e5cc: 82 0c 00 08 and %l0, %o0, %g1 4000e5d0: 80 88 40 1c btst %g1, %i4 4000e5d4: 02 80 00 08 be 4000e5f4 <_POSIX_signals_Clear_signals+0xb4> 4000e5d8: 82 2a 00 10 andn %o0, %l0, %g1 api->signals_pending &= ~mask; 4000e5dc: c2 26 20 c8 st %g1, [ %i0 + 0xc8 ] 4000e5e0: b0 10 20 01 mov 1, %i0 do_callout = TRUE; } } _ISR_Enable( level ); 4000e5e4: 7f ff ce 08 call 40001e04 4000e5e8: 90 10 00 11 mov %l1, %o0 return do_callout; } 4000e5ec: 81 c7 e0 08 ret 4000e5f0: 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; 4000e5f4: b0 10 20 00 clr %i0 do_callout = TRUE; } } _ISR_Enable( level ); 4000e5f8: 7f ff ce 03 call 40001e04 4000e5fc: 90 10 00 11 mov %l1, %o0 return do_callout; } 4000e600: 81 c7 e0 08 ret 4000e604: 81 e8 00 00 restore _ISR_Disable( level ); if ( is_global ) { if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) 4000e608: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000e60c: 82 10 63 c4 or %g1, 0x3c4, %g1 ! 4001b3c4 <_POSIX_signals_Siginfo> */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 4000e610: f8 00 c0 01 ld [ %g3 + %g1 ], %i4 4000e614: 88 00 c0 01 add %g3, %g1, %g4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4000e618: 9a 01 20 04 add %g4, 4, %o5 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 4000e61c: 80 a7 00 0d cmp %i4, %o5 4000e620: 32 80 00 1b bne,a 4000e68c <_POSIX_signals_Clear_signals+0x14c> 4000e624: c4 07 00 00 ld [ %i4 ], %g2 4000e628: b8 10 20 00 clr %i4 <== NOT EXECUTED 4000e62c: b6 10 20 00 clr %i3 <== NOT EXECUTED _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) _POSIX_signals_Clear_process_signals( mask ); 4000e630: 40 00 01 d7 call 4000ed8c <_POSIX_signals_Clear_process_signals> 4000e634: 90 10 00 10 mov %l0, %o0 if ( psiginfo ) { 4000e638: 80 a7 20 00 cmp %i4, 0 4000e63c: 02 bf ff ea be 4000e5e4 <_POSIX_signals_Clear_signals+0xa4> 4000e640: b0 10 20 01 mov 1, %i0 *info = psiginfo->Info; 4000e644: c2 06 e0 08 ld [ %i3 + 8 ], %g1 4000e648: c2 26 80 00 st %g1, [ %i2 ] 4000e64c: c4 06 e0 0c ld [ %i3 + 0xc ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4000e650: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000e654: c4 26 a0 04 st %g2, [ %i2 + 4 ] 4000e658: 82 10 63 78 or %g1, 0x378, %g1 4000e65c: c6 06 e0 10 ld [ %i3 + 0x10 ], %g3 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000e660: c2 26 c0 00 st %g1, [ %i3 ] old_last_node = the_chain->last; 4000e664: 82 00 7f fc add %g1, -4, %g1 4000e668: c4 00 60 08 ld [ %g1 + 8 ], %g2 the_chain->last = the_node; 4000e66c: f6 20 60 08 st %i3, [ %g1 + 8 ] 4000e670: c6 26 a0 08 st %g3, [ %i2 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000e674: c4 26 e0 04 st %g2, [ %i3 + 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; 4000e678: f6 20 80 00 st %i3, [ %g2 ] if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; do_callout = TRUE; } } _ISR_Enable( level ); 4000e67c: 7f ff cd e2 call 40001e04 4000e680: 90 10 00 11 mov %l1, %o0 return do_callout; } 4000e684: 81 c7 e0 08 ret 4000e688: 81 e8 00 00 restore Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; 4000e68c: c4 20 c0 01 st %g2, [ %g3 + %g1 ] new_first->previous = _Chain_Head(the_chain); 4000e690: c8 20 a0 04 st %g4, [ %g2 + 4 ] if ( is_global ) { 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 ] ) ) 4000e694: c2 00 c0 01 ld [ %g3 + %g1 ], %g1 4000e698: 80 a3 40 01 cmp %o5, %g1 4000e69c: 12 bf ff e7 bne 4000e638 <_POSIX_signals_Clear_signals+0xf8> 4000e6a0: b6 10 00 1c mov %i4, %i3 4000e6a4: 30 bf ff e3 b,a 4000e630 <_POSIX_signals_Clear_signals+0xf0> 400068ac <_POSIX_signals_Get_highest>: #include int _POSIX_signals_Get_highest( sigset_t set ) { 400068ac: 86 10 00 08 mov %o0, %g3 400068b0: 90 10 20 1b mov 0x1b, %o0 int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) 400068b4: 84 02 3f ff add %o0, -1, %g2 400068b8: 82 10 20 01 mov 1, %g1 400068bc: 83 28 40 02 sll %g1, %g2, %g1 400068c0: 80 88 40 03 btst %g1, %g3 400068c4: 12 80 00 11 bne 40006908 <_POSIX_signals_Get_highest+0x5c> 400068c8: 01 00 00 00 nop sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 400068cc: 90 02 20 01 inc %o0 400068d0: 80 a2 20 20 cmp %o0, 0x20 400068d4: 12 bf ff f9 bne 400068b8 <_POSIX_signals_Get_highest+0xc> 400068d8: 84 02 3f ff add %o0, -1, %g2 400068dc: 10 80 00 05 b 400068f0 <_POSIX_signals_Get_highest+0x44> 400068e0: 90 10 20 01 mov 1, %o0 return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 400068e4: 80 a2 20 1b cmp %o0, 0x1b 400068e8: 02 80 00 0a be 40006910 <_POSIX_signals_Get_highest+0x64> 400068ec: 01 00 00 00 nop if ( set & signo_to_mask( signo ) ) 400068f0: 84 02 3f ff add %o0, -1, %g2 400068f4: 82 10 20 01 mov 1, %g1 400068f8: 83 28 40 02 sll %g1, %g2, %g1 400068fc: 80 88 40 03 btst %g1, %g3 40006900: 22 bf ff f9 be,a 400068e4 <_POSIX_signals_Get_highest+0x38> 40006904: 90 02 20 01 inc %o0 return signo; } return 0; } 40006908: 81 c3 e0 08 retl 4000690c: 01 00 00 00 nop 40006910: 81 c3 e0 08 retl <== NOT EXECUTED 40006914: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED 4000c99c <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) { 4000c99c: 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 ]; 4000c9a0: e0 06 21 70 ld [ %i0 + 0x170 ], %l0 4000c9a4: 23 10 00 6c sethi %hi(0x4001b000), %l1 * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ restart: _ISR_Disable( level ); 4000c9a8: 7f ff d5 13 call 40001df4 4000c9ac: 01 00 00 00 nop 4000c9b0: b0 10 00 08 mov %o0, %i0 if ( !(~api->signals_blocked & 4000c9b4: c2 04 63 c0 ld [ %l1 + 0x3c0 ], %g1 4000c9b8: c4 04 20 c8 ld [ %l0 + 0xc8 ], %g2 4000c9bc: c6 04 20 c4 ld [ %l0 + 0xc4 ], %g3 4000c9c0: 82 10 40 02 or %g1, %g2, %g1 4000c9c4: 80 a8 40 03 andncc %g1, %g3, %g0 4000c9c8: 02 80 00 27 be 4000ca64 <_POSIX_signals_Post_switch_extension+0xc8> 4000c9cc: 01 00 00 00 nop (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); return; } _ISR_Enable( level ); 4000c9d0: 7f ff d5 0d call 40001e04 4000c9d4: b0 10 20 1b mov 0x1b, %i0 ! 1b for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, FALSE ) ) 4000c9d8: 92 10 00 18 mov %i0, %o1 4000c9dc: 94 10 20 00 clr %o2 4000c9e0: 40 00 06 a3 call 4000e46c <_POSIX_signals_Check_signal> 4000c9e4: 90 10 00 10 mov %l0, %o0 4000c9e8: 80 a2 20 00 cmp %o0, 0 4000c9ec: 12 bf ff ef bne 4000c9a8 <_POSIX_signals_Post_switch_extension+0xc> 4000c9f0: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) 4000c9f4: 90 10 00 10 mov %l0, %o0 4000c9f8: 94 10 20 01 mov 1, %o2 4000c9fc: 40 00 06 9c call 4000e46c <_POSIX_signals_Check_signal> 4000ca00: b0 06 20 01 inc %i0 4000ca04: 80 a2 20 00 cmp %o0, 0 4000ca08: 12 bf ff e8 bne 4000c9a8 <_POSIX_signals_Post_switch_extension+0xc> 4000ca0c: 80 a6 20 20 cmp %i0, 0x20 _ISR_Enable( level ); return; } _ISR_Enable( level ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 4000ca10: 12 bf ff f3 bne 4000c9dc <_POSIX_signals_Post_switch_extension+0x40> 4000ca14: 92 10 00 18 mov %i0, %o1 4000ca18: 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 ) ) 4000ca1c: 92 10 00 18 mov %i0, %o1 4000ca20: 94 10 20 00 clr %o2 4000ca24: 40 00 06 92 call 4000e46c <_POSIX_signals_Check_signal> 4000ca28: 90 10 00 10 mov %l0, %o0 4000ca2c: 80 a2 20 00 cmp %o0, 0 4000ca30: 12 bf ff de bne 4000c9a8 <_POSIX_signals_Post_switch_extension+0xc> 4000ca34: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) 4000ca38: 90 10 00 10 mov %l0, %o0 4000ca3c: 94 10 20 01 mov 1, %o2 4000ca40: 40 00 06 8b call 4000e46c <_POSIX_signals_Check_signal> 4000ca44: b0 06 20 01 inc %i0 4000ca48: 80 a2 20 00 cmp %o0, 0 4000ca4c: 12 bf ff d7 bne 4000c9a8 <_POSIX_signals_Post_switch_extension+0xc> 4000ca50: 80 a6 20 1b cmp %i0, 0x1b } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 4000ca54: 12 bf ff f3 bne 4000ca20 <_POSIX_signals_Post_switch_extension+0x84> 4000ca58: 92 10 00 18 mov %i0, %o1 if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) goto restart; } } 4000ca5c: 81 c7 e0 08 ret <== NOT EXECUTED 4000ca60: 81 e8 00 00 restore <== NOT EXECUTED restart: _ISR_Disable( level ); if ( !(~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); 4000ca64: 7f ff d4 e8 call 40001e04 4000ca68: 81 e8 00 00 restore 4000ca6c: 01 00 00 00 nop 4002627c <_POSIX_signals_Unblock_thread>: boolean _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 4002627c: 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 ) ) { 40026280: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 40026284: 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 ); 40026288: 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 ) ) { 4002628c: 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 ); 40026290: 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 ) ) { 40026294: 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 ); 40026298: 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 ) ) { 4002629c: 02 80 00 1d be 40026310 <_POSIX_signals_Unblock_thread+0x94> 400262a0: c6 06 21 70 ld [ %i0 + 0x170 ], %g3 */ return FALSE; } if ( ~api->signals_blocked & mask ) { 400262a4: c2 00 e0 c4 ld [ %g3 + 0xc4 ], %g1 400262a8: 80 a8 80 01 andncc %g2, %g1, %g0 400262ac: 02 80 00 21 be 40026330 <_POSIX_signals_Unblock_thread+0xb4> 400262b0: 03 04 00 00 sethi %hi(0x10000000), %g1 the_thread->do_post_task_switch_extension = TRUE; if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 400262b4: 80 89 00 01 btst %g4, %g1 400262b8: 02 80 00 1e be 40026330 <_POSIX_signals_Unblock_thread+0xb4> 400262bc: da 26 20 78 st %o5, [ %i0 + 0x78 ] the_thread->Wait.return_code = EINTR; 400262c0: 84 10 20 04 mov 4, %g2 if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) 400262c4: 03 00 00 ef sethi %hi(0x3bc00), %g1 400262c8: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 400262cc: 80 89 00 01 btst %g4, %g1 400262d0: 12 80 00 29 bne 40026374 <_POSIX_signals_Unblock_thread+0xf8> 400262d4: c4 26 20 34 st %g2, [ %i0 + 0x34 ] _Thread_queue_Extract_with_proxy( the_thread ); else if ( _States_Is_delaying(the_thread->current_state)){ 400262d8: 80 89 20 08 btst 8, %g4 400262dc: 02 80 00 15 be 40026330 <_POSIX_signals_Unblock_thread+0xb4> 400262e0: 01 00 00 00 nop if ( _Watchdog_Is_active( &the_thread->Timer ) ) 400262e4: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 400262e8: 80 a0 60 02 cmp %g1, 2 400262ec: 02 80 00 2b be 40026398 <_POSIX_signals_Unblock_thread+0x11c> 400262f0: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 400262f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400262f8: 13 04 00 ff sethi %hi(0x1003fc00), %o1 400262fc: b0 10 20 00 clr %i0 40026300: 7f ff a7 a5 call 40010194 <_Thread_Clear_state> 40026304: 92 12 63 f8 or %o1, 0x3f8, %o1 40026308: 81 c7 e0 08 ret 4002630c: 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) ) { 40026310: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 40026314: 80 88 80 01 btst %g2, %g1 40026318: 12 80 00 08 bne 40026338 <_POSIX_signals_Unblock_thread+0xbc> 4002631c: 82 10 20 04 mov 4, %g1 40026320: c2 00 e0 c4 ld [ %g3 + 0xc4 ], %g1 40026324: 80 a8 80 01 andncc %g2, %g1, %g0 40026328: 12 80 00 04 bne 40026338 <_POSIX_signals_Unblock_thread+0xbc> 4002632c: 82 10 20 04 mov 4, %g1 } } } return FALSE; } 40026330: 81 c7 e0 08 ret 40026334: 91 e8 20 00 restore %g0, 0, %o0 */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { the_thread->Wait.return_code = EINTR; 40026338: c2 26 20 34 st %g1, [ %i0 + 0x34 ] the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { 4002633c: 80 a6 a0 00 cmp %i2, 0 40026340: 02 80 00 12 be 40026388 <_POSIX_signals_Unblock_thread+0x10c> 40026344: 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; 40026348: c2 06 80 00 ld [ %i2 ], %g1 4002634c: c2 20 c0 00 st %g1, [ %g3 ] 40026350: c4 06 a0 04 ld [ %i2 + 4 ], %g2 40026354: c4 20 e0 04 st %g2, [ %g3 + 4 ] 40026358: c2 06 a0 08 ld [ %i2 + 8 ], %g1 4002635c: c2 20 e0 08 st %g1, [ %g3 + 8 ] } _Thread_queue_Extract_with_proxy( the_thread ); 40026360: 90 10 00 18 mov %i0, %o0 40026364: 7f ff aa a7 call 40010e00 <_Thread_queue_Extract_with_proxy> 40026368: b0 10 20 01 mov 1, %i0 4002636c: 81 c7 e0 08 ret 40026370: 81 e8 00 00 restore the_thread->do_post_task_switch_extension = TRUE; if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { the_thread->Wait.return_code = EINTR; if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) _Thread_queue_Extract_with_proxy( the_thread ); 40026374: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40026378: 7f ff aa a2 call 40010e00 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 4002637c: b0 10 20 00 clr %i0 <== NOT EXECUTED 40026380: 81 c7 e0 08 ret <== NOT EXECUTED 40026384: 81 e8 00 00 restore <== NOT EXECUTED the_thread->Wait.return_code = EINTR; the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { the_info->si_signo = signo; 40026388: f2 20 c0 00 st %i1, [ %g3 ] the_info->si_code = SI_USER; 4002638c: da 20 e0 04 st %o5, [ %g3 + 4 ] the_info->si_value.sival_int = 0; 40026390: 10 bf ff f4 b 40026360 <_POSIX_signals_Unblock_thread+0xe4> 40026394: c0 20 e0 08 clr [ %g3 + 8 ] the_thread->Wait.return_code = EINTR; if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) _Thread_queue_Extract_with_proxy( the_thread ); else if ( _States_Is_delaying(the_thread->current_state)){ if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 40026398: 7f ff ad f9 call 40011b7c <_Watchdog_Remove> 4002639c: 90 06 20 48 add %i0, 0x48, %o0 400263a0: 10 bf ff d6 b 400262f8 <_POSIX_signals_Unblock_thread+0x7c> 400263a4: 90 10 00 18 mov %i0, %o0 40008150 <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 40008150: 9d e3 bf 98 save %sp, -104, %sp void *p; _RTEMS_Lock_allocator(); 40008154: 7f ff e7 28 call 40001df4 40008158: 01 00 00 00 nop 4000815c: a4 10 00 08 mov %o0, %l2 40008160: 23 10 00 6a sethi %hi(0x4001a800), %l1 40008164: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> 40008168: 80 a0 60 00 cmp %g1, 0 4000816c: 02 80 00 0b be 40008198 <_Protected_heap_Allocate+0x48> 40008170: 27 10 00 6b sethi %hi(0x4001ac00), %l3 40008174: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008178: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 4001ad40 <_System_state_Current> 4000817c: 80 a0 a0 01 cmp %g2, 1 40008180: 08 80 00 06 bleu 40008198 <_Protected_heap_Allocate+0x48> 40008184: 90 10 20 00 clr %o0 40008188: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000818c: 7f ff fd 7c call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 40008190: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40008194: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40008198: 09 10 00 6b sethi %hi(0x4001ac00), %g4 4000819c: e0 04 e0 34 ld [ %l3 + 0x34 ], %l0 400081a0: c4 01 20 3c ld [ %g4 + 0x3c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 400081a4: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 400081a8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 400081ac: 80 a0 60 00 cmp %g1, 0 400081b0: 22 80 00 27 be,a 4000824c <_Protected_heap_Allocate+0xfc> 400081b4: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 400081b8: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400081bc: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 400081c0: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; the_mutex->nest_count = 1; 400081c4: 88 10 20 01 mov 1, %g4 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; 400081c8: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 400081cc: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400081d0: 80 a0 e0 02 cmp %g3, 2 400081d4: 12 80 00 2d bne 40008288 <_Protected_heap_Allocate+0x138> 400081d8: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400081dc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400081e0: 80 a0 e0 03 cmp %g3, 3 the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400081e4: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400081e8: 02 80 00 46 be 40008300 <_Protected_heap_Allocate+0x1b0> 400081ec: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 400081f0: 7f ff e7 05 call 40001e04 400081f4: 90 10 00 12 mov %l2, %o0 p = _Heap_Allocate( the_heap, size ); 400081f8: 90 10 00 18 mov %i0, %o0 400081fc: 7f ff fc 2e call 400072b4 <_Heap_Allocate> 40008200: 92 10 00 19 mov %i1, %o1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008204: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40008208: b0 10 00 08 mov %o0, %i0 4000820c: 82 00 60 01 inc %g1 40008210: c2 24 63 60 st %g1, [ %l1 + 0x360 ] _RTEMS_Unlock_allocator(); 40008214: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 40008218: 94 10 20 00 clr %o2 4000821c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40008220: 7f ff fb 54 call 40006f70 <_CORE_mutex_Surrender> 40008224: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008228: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 4000822c: 82 00 7f ff add %g1, -1, %g1 40008230: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40008234: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40008238: 80 a0 a0 00 cmp %g2, 0 4000823c: 02 80 00 2d be 400082f0 <_Protected_heap_Allocate+0x1a0> 40008240: 01 00 00 00 nop return p; } 40008244: 81 c7 e0 08 ret 40008248: 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 ) ) { 4000824c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40008250: 12 80 00 16 bne 400082a8 <_Protected_heap_Allocate+0x158> <== NOT EXECUTED 40008254: c6 04 e0 34 ld [ %l3 + 0x34 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40008258: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 4000825c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008260: 22 80 00 43 be,a 4000836c <_Protected_heap_Allocate+0x21c> <== NOT EXECUTED 40008264: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40008268: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000826c: 12 80 00 0f bne 400082a8 <_Protected_heap_Allocate+0x158> <== NOT EXECUTED 40008270: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 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; 40008274: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40008278: 7f ff e6 e3 call 40001e04 <== NOT EXECUTED 4000827c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { void *p; _RTEMS_Lock_allocator(); p = _Heap_Allocate( the_heap, size ); 40008280: 10 bf ff df b 400081fc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40008284: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40008288: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 4000828c: 12 bf ff d9 bne 400081f0 <_Protected_heap_Allocate+0xa0> <== NOT EXECUTED 40008290: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008294: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008298: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000829c: 02 80 00 19 be 40008300 <_Protected_heap_Allocate+0x1b0> <== NOT EXECUTED 400082a0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 400082a4: 30 bf ff d3 b,a 400081f0 <_Protected_heap_Allocate+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400082a8: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED size_t size ) { void *p; _RTEMS_Lock_allocator(); 400082ac: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 400082b0: c8 01 20 3c ld [ %g4 + 0x3c ], %g4 <== NOT EXECUTED 400082b4: 82 00 60 01 inc %g1 <== NOT EXECUTED 400082b8: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 400082bc: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 400082c0: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 400082c4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 400082c8: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 400082cc: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 400082d0: 7f ff e6 cd call 40001e04 <== NOT EXECUTED 400082d4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400082d8: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 400082dc: 92 10 20 00 clr %o1 <== NOT EXECUTED 400082e0: 7f ff fb 00 call 40006ee0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 400082e4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 400082e8: 10 bf ff c5 b 400081fc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 400082ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 400082f0: 40 00 03 c9 call 40009214 <_Thread_Dispatch> 400082f4: 01 00 00 00 nop 400082f8: 81 c7 e0 08 ret 400082fc: 81 e8 00 00 restore */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40008300: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40008304: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40008308: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4000830c: 02 80 00 28 be 400083ac <_Protected_heap_Allocate+0x25c> <== NOT EXECUTED 40008310: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40008314: 1a 80 00 1c bcc 40008384 <_Protected_heap_Allocate+0x234> <== NOT EXECUTED 40008318: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000831c: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008320: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008324: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40008328: 7f ff e6 b7 call 40001e04 <== NOT EXECUTED 4000832c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40008330: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40008334: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40008338: 40 00 02 93 call 40008d84 <_Thread_Change_priority> <== NOT EXECUTED 4000833c: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008340: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008344: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008348: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 4000834c: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 40008350: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008354: 32 bf ff aa bne,a 400081fc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40008358: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000835c: 40 00 03 ae call 40009214 <_Thread_Dispatch> <== NOT EXECUTED 40008360: 01 00 00 00 nop <== NOT EXECUTED 40008364: 10 bf ff a6 b 400081fc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40008368: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * 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++; 4000836c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008370: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40008374: 7f ff e6 a4 call 40001e04 <== NOT EXECUTED 40008378: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000837c: 10 bf ff a0 b 400081fc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40008380: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40008384: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008388: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4000838c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40008390: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008394: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008398: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000839c: 7f ff e6 9a call 40001e04 <== NOT EXECUTED 400083a0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400083a4: 10 bf ff 96 b 400081fc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 400083a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 400083ac: 7f ff e6 96 call 40001e04 <== NOT EXECUTED 400083b0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400083b4: 10 bf ff 92 b 400081fc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 400083b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400083bc <_Protected_heap_Extend>: boolean _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 400083bc: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 400083c0: 7f ff e6 8d call 40001df4 <== NOT EXECUTED 400083c4: 01 00 00 00 nop <== NOT EXECUTED 400083c8: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 400083cc: 23 10 00 6a sethi %hi(0x4001a800), %l1 <== NOT EXECUTED 400083d0: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400083d4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400083d8: 02 80 00 0b be 40008404 <_Protected_heap_Extend+0x48> <== NOT EXECUTED 400083dc: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED 400083e0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 400083e4: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 4001ad40 <_System_state_Current> <== NOT EXECUTED 400083e8: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 400083ec: 08 80 00 06 bleu 40008404 <_Protected_heap_Extend+0x48> <== NOT EXECUTED 400083f0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400083f4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400083f8: 7f ff fc e1 call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 400083fc: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40008400: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40008404: 09 10 00 6b sethi %hi(0x4001ac00), %g4 <== NOT EXECUTED 40008408: e0 04 e0 34 ld [ %l3 + 0x34 ], %l0 <== NOT EXECUTED 4000840c: c4 01 20 3c ld [ %g4 + 0x3c ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40008410: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40008414: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 40008418: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000841c: 22 80 00 2d be,a 400084d0 <_Protected_heap_Extend+0x114> <== NOT EXECUTED 40008420: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40008424: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40008428: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 4000842c: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; the_mutex->nest_count = 1; 40008430: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED 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; 40008434: c2 24 20 70 st %g1, [ %l0 + 0x70 ] <== NOT EXECUTED 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; 40008438: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4000843c: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 40008440: 12 80 00 33 bne 4000850c <_Protected_heap_Extend+0x150> <== NOT EXECUTED 40008444: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008448: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000844c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008450: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008454: 02 80 00 48 be 40008574 <_Protected_heap_Extend+0x1b8> <== NOT EXECUTED 40008458: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000845c: 7f ff e6 6a call 40001e04 <== NOT EXECUTED 40008460: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 40008464: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008468: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000846c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40008470: 40 00 14 04 call 4000d480 <_Heap_Extend> <== NOT EXECUTED 40008474: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008478: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 4000847c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 40008480: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008484: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 40008488: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 4000848c: 94 10 20 00 clr %o2 <== NOT EXECUTED 40008490: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40008494: 7f ff fa b7 call 40006f70 <_CORE_mutex_Surrender> <== NOT EXECUTED 40008498: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000849c: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 400084a0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400084a4: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 400084a8: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 400084ac: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400084b0: 12 80 00 05 bne 400084c4 <_Protected_heap_Extend+0x108> <== NOT EXECUTED 400084b4: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED _Thread_Dispatch(); 400084b8: 40 00 03 57 call 40009214 <_Thread_Dispatch> <== NOT EXECUTED 400084bc: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 400084c0: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 400084c4: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 400084c8: 81 c7 e0 08 ret <== NOT EXECUTED 400084cc: 81 e8 00 00 restore <== NOT EXECUTED /* * 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 ) ) { 400084d0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400084d4: 12 80 00 16 bne 4000852c <_Protected_heap_Extend+0x170> <== NOT EXECUTED 400084d8: c6 04 e0 34 ld [ %l3 + 0x34 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400084dc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400084e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400084e4: 22 80 00 3f be,a 400085e0 <_Protected_heap_Extend+0x224> <== NOT EXECUTED 400084e8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 400084ec: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400084f0: 12 80 00 0f bne 4000852c <_Protected_heap_Extend+0x170> <== NOT EXECUTED 400084f4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 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; 400084f8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400084fc: 7f ff e6 42 call 40001e04 <== NOT EXECUTED 40008500: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 40008504: 10 bf ff d9 b 40008468 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 40008508: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4000850c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40008510: 12 bf ff d3 bne 4000845c <_Protected_heap_Extend+0xa0> <== NOT EXECUTED 40008514: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008518: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4000851c: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008520: 02 80 00 15 be 40008574 <_Protected_heap_Extend+0x1b8> <== NOT EXECUTED 40008524: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40008528: 30 bf ff cd b,a 4000845c <_Protected_heap_Extend+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000852c: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED ) { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 40008530: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40008534: c8 01 20 3c ld [ %g4 + 0x3c ], %g4 <== NOT EXECUTED 40008538: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000853c: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40008540: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40008544: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40008548: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4000854c: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40008550: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40008554: 7f ff e6 2c call 40001e04 <== NOT EXECUTED 40008558: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000855c: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 40008560: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008564: 7f ff fa 5f call 40006ee0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40008568: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 4000856c: 10 bf ff bf b 40008468 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 40008570: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40008574: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40008578: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 4000857c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40008580: 02 80 00 28 be 40008620 <_Protected_heap_Extend+0x264> <== NOT EXECUTED 40008584: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40008588: 1a 80 00 1c bcc 400085f8 <_Protected_heap_Extend+0x23c> <== NOT EXECUTED 4000858c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 40008590: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008594: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008598: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 4000859c: 7f ff e6 1a call 40001e04 <== NOT EXECUTED 400085a0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 400085a4: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 400085a8: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 400085ac: 40 00 01 f6 call 40008d84 <_Thread_Change_priority> <== NOT EXECUTED 400085b0: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400085b4: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 400085b8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400085bc: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 400085c0: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 400085c4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400085c8: 32 bf ff a8 bne,a 40008468 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 400085cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 400085d0: 40 00 03 11 call 40009214 <_Thread_Dispatch> <== NOT EXECUTED 400085d4: 01 00 00 00 nop <== NOT EXECUTED 400085d8: 10 bf ff a4 b 40008468 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 400085dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * 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++; 400085e0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400085e4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400085e8: 7f ff e6 07 call 40001e04 <== NOT EXECUTED 400085ec: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400085f0: 10 bf ff 9e b 40008468 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 400085f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 400085f8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400085fc: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40008600: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40008604: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008608: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000860c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40008610: 7f ff e5 fd call 40001e04 <== NOT EXECUTED 40008614: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008618: 10 bf ff 94 b 40008468 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 4000861c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40008620: 7f ff e5 f9 call 40001e04 <== NOT EXECUTED 40008624: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008628: 10 bf ff 90 b 40008468 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 4000862c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008630 <_Protected_heap_Free>: boolean _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 40008630: 9d e3 bf 98 save %sp, -104, %sp boolean status; _RTEMS_Lock_allocator(); 40008634: 7f ff e5 f0 call 40001df4 40008638: 01 00 00 00 nop 4000863c: a4 10 00 08 mov %o0, %l2 40008640: 23 10 00 6a sethi %hi(0x4001a800), %l1 40008644: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> 40008648: 80 a0 60 00 cmp %g1, 0 4000864c: 02 80 00 0b be 40008678 <_Protected_heap_Free+0x48> 40008650: 27 10 00 6b sethi %hi(0x4001ac00), %l3 40008654: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008658: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 4001ad40 <_System_state_Current> <== NOT EXECUTED 4000865c: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40008660: 08 80 00 06 bleu 40008678 <_Protected_heap_Free+0x48> <== NOT EXECUTED 40008664: 90 10 20 00 clr %o0 <== NOT EXECUTED 40008668: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000866c: 7f ff fc 44 call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 40008670: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40008674: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40008678: 09 10 00 6b sethi %hi(0x4001ac00), %g4 4000867c: e0 04 e0 34 ld [ %l3 + 0x34 ], %l0 40008680: c4 01 20 3c ld [ %g4 + 0x3c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40008684: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40008688: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 4000868c: 80 a0 60 00 cmp %g1, 0 40008690: 22 80 00 27 be,a 4000872c <_Protected_heap_Free+0xfc> 40008694: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40008698: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 4000869c: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 400086a0: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; the_mutex->nest_count = 1; 400086a4: 88 10 20 01 mov 1, %g4 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; 400086a8: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 400086ac: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400086b0: 80 a0 e0 02 cmp %g3, 2 400086b4: 12 80 00 2d bne 40008768 <_Protected_heap_Free+0x138> 400086b8: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400086bc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400086c0: 80 a0 e0 03 cmp %g3, 3 the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400086c4: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400086c8: 02 80 00 46 be 400087e0 <_Protected_heap_Free+0x1b0> 400086cc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 400086d0: 7f ff e5 cd call 40001e04 400086d4: 90 10 00 12 mov %l2, %o0 status = _Heap_Free( the_heap, start_address ); 400086d8: 90 10 00 18 mov %i0, %o0 400086dc: 7f ff fb 28 call 4000737c <_Heap_Free> 400086e0: 92 10 00 19 mov %i1, %o1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400086e4: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 400086e8: b0 10 00 08 mov %o0, %i0 400086ec: 82 00 60 01 inc %g1 400086f0: c2 24 63 60 st %g1, [ %l1 + 0x360 ] _RTEMS_Unlock_allocator(); 400086f4: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 400086f8: 94 10 20 00 clr %o2 400086fc: d2 02 20 08 ld [ %o0 + 8 ], %o1 40008700: 7f ff fa 1c call 40006f70 <_CORE_mutex_Surrender> 40008704: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008708: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 4000870c: 82 00 7f ff add %g1, -1, %g1 40008710: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40008714: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40008718: 80 a0 a0 00 cmp %g2, 0 4000871c: 02 80 00 2d be 400087d0 <_Protected_heap_Free+0x1a0> 40008720: 01 00 00 00 nop return status; } 40008724: 81 c7 e0 08 ret <== NOT EXECUTED 40008728: 81 e8 00 00 restore <== NOT EXECUTED /* * 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 ) ) { 4000872c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40008730: 12 80 00 16 bne 40008788 <_Protected_heap_Free+0x158> <== NOT EXECUTED 40008734: c6 04 e0 34 ld [ %l3 + 0x34 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40008738: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 4000873c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008740: 22 80 00 43 be,a 4000884c <_Protected_heap_Free+0x21c> <== NOT EXECUTED 40008744: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40008748: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000874c: 12 80 00 0f bne 40008788 <_Protected_heap_Free+0x158> <== NOT EXECUTED 40008750: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 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; 40008754: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40008758: 7f ff e5 ab call 40001e04 <== NOT EXECUTED 4000875c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { boolean status; _RTEMS_Lock_allocator(); status = _Heap_Free( the_heap, start_address ); 40008760: 10 bf ff df b 400086dc <_Protected_heap_Free+0xac> <== NOT EXECUTED 40008764: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40008768: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 4000876c: 12 bf ff d9 bne 400086d0 <_Protected_heap_Free+0xa0> <== NOT EXECUTED 40008770: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008774: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008778: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000877c: 02 80 00 19 be 400087e0 <_Protected_heap_Free+0x1b0> <== NOT EXECUTED 40008780: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40008784: 30 bf ff d3 b,a 400086d0 <_Protected_heap_Free+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008788: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED void *start_address ) { boolean status; _RTEMS_Lock_allocator(); 4000878c: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40008790: c8 01 20 3c ld [ %g4 + 0x3c ], %g4 <== NOT EXECUTED 40008794: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008798: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 4000879c: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 400087a0: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 400087a4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 400087a8: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 400087ac: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 400087b0: 7f ff e5 95 call 40001e04 <== NOT EXECUTED 400087b4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400087b8: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 400087bc: 92 10 20 00 clr %o1 <== NOT EXECUTED 400087c0: 7f ff f9 c8 call 40006ee0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 400087c4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 400087c8: 10 bf ff c5 b 400086dc <_Protected_heap_Free+0xac> <== NOT EXECUTED 400087cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 400087d0: 40 00 02 91 call 40009214 <_Thread_Dispatch> 400087d4: 01 00 00 00 nop 400087d8: 81 c7 e0 08 ret 400087dc: 81 e8 00 00 restore */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 400087e0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 400087e4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 400087e8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 400087ec: 02 80 00 28 be 4000888c <_Protected_heap_Free+0x25c> <== NOT EXECUTED 400087f0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 400087f4: 1a 80 00 1c bcc 40008864 <_Protected_heap_Free+0x234> <== NOT EXECUTED 400087f8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400087fc: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008800: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008804: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40008808: 7f ff e5 7f call 40001e04 <== NOT EXECUTED 4000880c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40008810: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40008814: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40008818: 40 00 01 5b call 40008d84 <_Thread_Change_priority> <== NOT EXECUTED 4000881c: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008820: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008824: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008828: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 4000882c: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 40008830: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008834: 32 bf ff aa bne,a 400086dc <_Protected_heap_Free+0xac> <== NOT EXECUTED 40008838: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000883c: 40 00 02 76 call 40009214 <_Thread_Dispatch> <== NOT EXECUTED 40008840: 01 00 00 00 nop <== NOT EXECUTED 40008844: 10 bf ff a6 b 400086dc <_Protected_heap_Free+0xac> <== NOT EXECUTED 40008848: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * 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++; 4000884c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008850: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40008854: 7f ff e5 6c call 40001e04 <== NOT EXECUTED 40008858: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000885c: 10 bf ff a0 b 400086dc <_Protected_heap_Free+0xac> <== NOT EXECUTED 40008860: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40008864: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008868: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4000886c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40008870: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008874: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008878: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000887c: 7f ff e5 62 call 40001e04 <== NOT EXECUTED 40008880: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008884: 10 bf ff 96 b 400086dc <_Protected_heap_Free+0xac> <== NOT EXECUTED 40008888: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 4000888c: 7f ff e5 5e call 40001e04 <== NOT EXECUTED 40008890: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008894: 10 bf ff 92 b 400086dc <_Protected_heap_Free+0xac> <== NOT EXECUTED 40008898: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000889c <_Protected_heap_Get_block_size>: boolean _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 4000889c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED boolean status; _RTEMS_Lock_allocator(); 400088a0: 7f ff e5 55 call 40001df4 <== NOT EXECUTED 400088a4: 01 00 00 00 nop <== NOT EXECUTED 400088a8: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 400088ac: 23 10 00 6a sethi %hi(0x4001a800), %l1 <== NOT EXECUTED 400088b0: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400088b4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400088b8: 02 80 00 0b be 400088e4 <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 400088bc: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED 400088c0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 400088c4: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 4001ad40 <_System_state_Current> <== NOT EXECUTED 400088c8: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 400088cc: 08 80 00 06 bleu 400088e4 <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 400088d0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400088d4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400088d8: 7f ff fb a9 call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 400088dc: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400088e0: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400088e4: 09 10 00 6b sethi %hi(0x4001ac00), %g4 <== NOT EXECUTED 400088e8: e0 04 e0 34 ld [ %l3 + 0x34 ], %l0 <== NOT EXECUTED 400088ec: c4 01 20 3c ld [ %g4 + 0x3c ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 400088f0: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 400088f4: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 400088f8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400088fc: 22 80 00 28 be,a 4000899c <_Protected_heap_Get_block_size+0x100> <== NOT EXECUTED 40008900: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40008904: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40008908: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 4000890c: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; the_mutex->nest_count = 1; 40008910: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED 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; 40008914: c2 24 20 70 st %g1, [ %l0 + 0x70 ] <== NOT EXECUTED 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; 40008918: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4000891c: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 40008920: 12 80 00 2e bne 400089d8 <_Protected_heap_Get_block_size+0x13c> <== NOT EXECUTED 40008924: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008928: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000892c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008930: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008934: 02 80 00 47 be 40008a50 <_Protected_heap_Get_block_size+0x1b4> <== NOT EXECUTED 40008938: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000893c: 7f ff e5 32 call 40001e04 <== NOT EXECUTED 40008940: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 40008944: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008948: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000894c: 40 00 13 8e call 4000d784 <_Heap_Size_of_user_area> <== NOT EXECUTED 40008950: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008954: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008958: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 4000895c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008960: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 40008964: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 40008968: 94 10 20 00 clr %o2 <== NOT EXECUTED 4000896c: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40008970: 7f ff f9 80 call 40006f70 <_CORE_mutex_Surrender> <== NOT EXECUTED 40008974: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008978: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 4000897c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008980: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40008984: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 40008988: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000898c: 02 80 00 2d be 40008a40 <_Protected_heap_Get_block_size+0x1a4> <== NOT EXECUTED 40008990: 01 00 00 00 nop <== NOT EXECUTED return status; } 40008994: 81 c7 e0 08 ret <== NOT EXECUTED 40008998: 81 e8 00 00 restore <== NOT EXECUTED /* * 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 ) ) { 4000899c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400089a0: 12 80 00 16 bne 400089f8 <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 400089a4: c6 04 e0 34 ld [ %l3 + 0x34 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400089a8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400089ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400089b0: 22 80 00 43 be,a 40008abc <_Protected_heap_Get_block_size+0x220> <== NOT EXECUTED 400089b4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 400089b8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400089bc: 12 80 00 0f bne 400089f8 <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 400089c0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 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; 400089c4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400089c8: 7f ff e5 0f call 40001e04 <== NOT EXECUTED 400089cc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { boolean status; _RTEMS_Lock_allocator(); status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 400089d0: 10 bf ff de b 40008948 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 400089d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400089d8: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 400089dc: 12 bf ff d8 bne 4000893c <_Protected_heap_Get_block_size+0xa0> <== NOT EXECUTED 400089e0: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400089e4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400089e8: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400089ec: 02 80 00 19 be 40008a50 <_Protected_heap_Get_block_size+0x1b4> <== NOT EXECUTED 400089f0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 400089f4: 30 bf ff d2 b,a 4000893c <_Protected_heap_Get_block_size+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400089f8: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED size_t *size ) { boolean status; _RTEMS_Lock_allocator(); 400089fc: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40008a00: c8 01 20 3c ld [ %g4 + 0x3c ], %g4 <== NOT EXECUTED 40008a04: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008a08: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40008a0c: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40008a10: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40008a14: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40008a18: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40008a1c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40008a20: 7f ff e4 f9 call 40001e04 <== NOT EXECUTED 40008a24: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008a28: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 40008a2c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008a30: 7f ff f9 2c call 40006ee0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40008a34: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 40008a38: 10 bf ff c4 b 40008948 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008a3c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40008a40: 40 00 01 f5 call 40009214 <_Thread_Dispatch> <== NOT EXECUTED 40008a44: 01 00 00 00 nop <== NOT EXECUTED 40008a48: 81 c7 e0 08 ret <== NOT EXECUTED 40008a4c: 81 e8 00 00 restore <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40008a50: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40008a54: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40008a58: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40008a5c: 02 80 00 28 be 40008afc <_Protected_heap_Get_block_size+0x260> <== NOT EXECUTED 40008a60: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40008a64: 1a 80 00 1c bcc 40008ad4 <_Protected_heap_Get_block_size+0x238> <== NOT EXECUTED 40008a68: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008a6c: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008a70: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008a74: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40008a78: 7f ff e4 e3 call 40001e04 <== NOT EXECUTED 40008a7c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40008a80: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40008a84: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40008a88: 40 00 00 bf call 40008d84 <_Thread_Change_priority> <== NOT EXECUTED 40008a8c: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008a90: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008a94: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008a98: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40008a9c: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 40008aa0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008aa4: 32 bf ff a9 bne,a 40008948 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008aa8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40008aac: 40 00 01 da call 40009214 <_Thread_Dispatch> <== NOT EXECUTED 40008ab0: 01 00 00 00 nop <== NOT EXECUTED 40008ab4: 10 bf ff a5 b 40008948 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008ab8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * 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++; 40008abc: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008ac0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40008ac4: 7f ff e4 d0 call 40001e04 <== NOT EXECUTED 40008ac8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008acc: 10 bf ff 9f b 40008948 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008ad0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40008ad4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008ad8: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40008adc: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40008ae0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008ae4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008ae8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40008aec: 7f ff e4 c6 call 40001e04 <== NOT EXECUTED 40008af0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008af4: 10 bf ff 95 b 40008948 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008af8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40008afc: 7f ff e4 c2 call 40001e04 <== NOT EXECUTED 40008b00: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008b04: 10 bf ff 91 b 40008948 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008b08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000c2e8 <_Protected_heap_Get_free_information>: void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 4000c2e8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 4000c2ec: 7f ff de 75 call 40003cc0 <== NOT EXECUTED 4000c2f0: 01 00 00 00 nop <== NOT EXECUTED 4000c2f4: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 4000c2f8: 23 10 00 fa sethi %hi(0x4003e800), %l1 <== NOT EXECUTED 4000c2fc: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 ! 4003e9d0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000c300: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000c304: 02 80 00 0b be 4000c330 <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 4000c308: 27 10 00 fa sethi %hi(0x4003e800), %l3 <== NOT EXECUTED 4000c30c: 03 10 00 fa sethi %hi(0x4003e800), %g1 <== NOT EXECUTED 4000c310: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 4003ebb0 <_System_state_Current> <== NOT EXECUTED 4000c314: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 4000c318: 08 80 00 06 bleu 4000c330 <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 4000c31c: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000c320: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000c324: 7f ff fb 49 call 4000b048 <_Internal_error_Occurred> <== NOT EXECUTED 4000c328: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 4000c32c: 27 10 00 fa sethi %hi(0x4003e800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 4000c330: 09 10 00 fa sethi %hi(0x4003e800), %g4 <== NOT EXECUTED 4000c334: e0 04 e2 a4 ld [ %l3 + 0x2a4 ], %l0 <== NOT EXECUTED 4000c338: c4 01 22 ac ld [ %g4 + 0x2ac ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 4000c33c: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 4000c340: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 4000c344: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000c348: 22 80 00 26 be,a 4000c3e0 <_Protected_heap_Get_free_information+0xf8> <== NOT EXECUTED 4000c34c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 4000c350: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 4000c354: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 4000c358: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; the_mutex->nest_count = 1; 4000c35c: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED 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; 4000c360: c2 24 20 70 st %g1, [ %l0 + 0x70 ] <== NOT EXECUTED 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; 4000c364: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4000c368: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 4000c36c: 12 80 00 2c bne 4000c41c <_Protected_heap_Get_free_information+0x134> <== NOT EXECUTED 4000c370: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4000c374: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000c378: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4000c37c: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000c380: 02 80 00 43 be 4000c48c <_Protected_heap_Get_free_information+0x1a4> <== NOT EXECUTED 4000c384: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000c388: 7f ff de 52 call 40003cd0 <== NOT EXECUTED 4000c38c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 4000c390: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000c394: 40 00 3c 0c call 4001b3c4 <_Heap_Get_free_information> <== NOT EXECUTED 4000c398: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000c39c: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 <== NOT EXECUTED 4000c3a0: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c3a4: c2 24 61 d0 st %g1, [ %l1 + 0x1d0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 4000c3a8: d0 04 e2 a4 ld [ %l3 + 0x2a4 ], %o0 <== NOT EXECUTED 4000c3ac: 94 10 20 00 clr %o2 <== NOT EXECUTED 4000c3b0: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 4000c3b4: 7f ff f9 22 call 4000a83c <_CORE_mutex_Surrender> <== NOT EXECUTED 4000c3b8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000c3bc: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 <== NOT EXECUTED 4000c3c0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000c3c4: c2 24 61 d0 st %g1, [ %l1 + 0x1d0 ] <== NOT EXECUTED 4000c3c8: c4 04 61 d0 ld [ %l1 + 0x1d0 ], %g2 <== NOT EXECUTED 4000c3cc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000c3d0: 02 80 00 2d be 4000c484 <_Protected_heap_Get_free_information+0x19c> <== NOT EXECUTED 4000c3d4: 01 00 00 00 nop <== NOT EXECUTED 4000c3d8: 81 c7 e0 08 ret <== NOT EXECUTED 4000c3dc: 81 e8 00 00 restore <== NOT EXECUTED /* * 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 ) ) { 4000c3e0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 4000c3e4: 12 80 00 16 bne 4000c43c <_Protected_heap_Get_free_information+0x154> <== NOT EXECUTED 4000c3e8: c6 04 e2 a4 ld [ %l3 + 0x2a4 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 4000c3ec: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 4000c3f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000c3f4: 22 80 00 41 be,a 4000c4f8 <_Protected_heap_Get_free_information+0x210> <== NOT EXECUTED 4000c3f8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 4000c3fc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000c400: 12 80 00 0f bne 4000c43c <_Protected_heap_Get_free_information+0x154> <== NOT EXECUTED 4000c404: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 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; 4000c408: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 4000c40c: 7f ff de 31 call 40003cd0 <== NOT EXECUTED 4000c410: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); _Heap_Get_free_information( the_heap, info ); 4000c414: 10 bf ff e0 b 4000c394 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c418: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4000c41c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 4000c420: 12 bf ff da bne 4000c388 <_Protected_heap_Get_free_information+0xa0> <== NOT EXECUTED 4000c424: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4000c428: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4000c42c: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000c430: 02 80 00 17 be 4000c48c <_Protected_heap_Get_free_information+0x1a4> <== NOT EXECUTED 4000c434: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 4000c438: 30 bf ff d4 b,a 4000c388 <_Protected_heap_Get_free_information+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000c43c: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 <== NOT EXECUTED void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); 4000c440: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 4000c444: c8 01 22 ac ld [ %g4 + 0x2ac ], %g4 <== NOT EXECUTED 4000c448: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c44c: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 4000c450: c2 24 61 d0 st %g1, [ %l1 + 0x1d0 ] <== NOT EXECUTED 4000c454: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 4000c458: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4000c45c: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 4000c460: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 4000c464: 7f ff de 1b call 40003cd0 <== NOT EXECUTED 4000c468: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000c46c: d0 04 e2 a4 ld [ %l3 + 0x2a4 ], %o0 <== NOT EXECUTED 4000c470: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000c474: 7f ff f8 ce call 4000a7ac <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 4000c478: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 4000c47c: 10 bf ff c6 b 4000c394 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c480: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4000c484: 40 00 01 f3 call 4000cc50 <_Thread_Dispatch> <== NOT EXECUTED 4000c488: 81 e8 00 00 restore <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 4000c48c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 4000c490: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 4000c494: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4000c498: 02 80 00 28 be 4000c538 <_Protected_heap_Get_free_information+0x250> <== NOT EXECUTED 4000c49c: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 4000c4a0: 1a 80 00 1c bcc 4000c510 <_Protected_heap_Get_free_information+0x228> <== NOT EXECUTED 4000c4a4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000c4a8: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 <== NOT EXECUTED 4000c4ac: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c4b0: c2 24 61 d0 st %g1, [ %l1 + 0x1d0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 4000c4b4: 7f ff de 07 call 40003cd0 <== NOT EXECUTED 4000c4b8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 4000c4bc: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 4000c4c0: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 4000c4c4: 40 00 00 bf call 4000c7c0 <_Thread_Change_priority> <== NOT EXECUTED 4000c4c8: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000c4cc: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 <== NOT EXECUTED 4000c4d0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000c4d4: c2 24 61 d0 st %g1, [ %l1 + 0x1d0 ] <== NOT EXECUTED 4000c4d8: c4 04 61 d0 ld [ %l1 + 0x1d0 ], %g2 <== NOT EXECUTED 4000c4dc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000c4e0: 32 bf ff ad bne,a 4000c394 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c4e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000c4e8: 40 00 01 da call 4000cc50 <_Thread_Dispatch> <== NOT EXECUTED 4000c4ec: 01 00 00 00 nop <== NOT EXECUTED 4000c4f0: 10 bf ff a9 b 4000c394 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c4f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * 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++; 4000c4f8: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c4fc: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 4000c500: 7f ff dd f4 call 40003cd0 <== NOT EXECUTED 4000c504: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000c508: 10 bf ff a3 b 4000c394 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c50c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 4000c510: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 4000c514: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4000c518: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 4000c51c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4000c520: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000c524: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000c528: 7f ff dd ea call 40003cd0 <== NOT EXECUTED 4000c52c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000c530: 10 bf ff 99 b 4000c394 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c534: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 4000c538: 7f ff dd e6 call 40003cd0 <== NOT EXECUTED 4000c53c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000c540: 10 bf ff 95 b 4000c394 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c544: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008b0c <_Protected_heap_Resize_block>: boolean _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 40008b0c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 40008b10: 7f ff e4 b9 call 40001df4 <== NOT EXECUTED 40008b14: 01 00 00 00 nop <== NOT EXECUTED 40008b18: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 40008b1c: 23 10 00 6a sethi %hi(0x4001a800), %l1 <== NOT EXECUTED 40008b20: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40008b24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008b28: 02 80 00 0b be 40008b54 <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 40008b2c: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED 40008b30: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008b34: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 4001ad40 <_System_state_Current> <== NOT EXECUTED 40008b38: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40008b3c: 08 80 00 06 bleu 40008b54 <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 40008b40: 90 10 20 00 clr %o0 <== NOT EXECUTED 40008b44: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008b48: 7f ff fb 0d call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 40008b4c: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40008b50: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40008b54: 09 10 00 6b sethi %hi(0x4001ac00), %g4 <== NOT EXECUTED 40008b58: e0 04 e0 34 ld [ %l3 + 0x34 ], %l0 <== NOT EXECUTED 40008b5c: c4 01 20 3c ld [ %g4 + 0x3c ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40008b60: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40008b64: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 40008b68: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008b6c: 22 80 00 2e be,a 40008c24 <_Protected_heap_Resize_block+0x118> <== NOT EXECUTED 40008b70: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40008b74: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40008b78: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 40008b7c: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; the_mutex->nest_count = 1; 40008b80: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED 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; 40008b84: c2 24 20 70 st %g1, [ %l0 + 0x70 ] <== NOT EXECUTED 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; 40008b88: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40008b8c: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 40008b90: 12 80 00 34 bne 40008c60 <_Protected_heap_Resize_block+0x154> <== NOT EXECUTED 40008b94: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008b98: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008b9c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008ba0: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008ba4: 02 80 00 49 be 40008cc8 <_Protected_heap_Resize_block+0x1bc> <== NOT EXECUTED 40008ba8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40008bac: 7f ff e4 96 call 40001e04 <== NOT EXECUTED 40008bb0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 40008bb4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008bb8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40008bbc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40008bc0: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 40008bc4: 40 00 12 62 call 4000d54c <_Heap_Resize_block> <== NOT EXECUTED 40008bc8: 98 07 bf f0 add %fp, -16, %o4 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008bcc: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008bd0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 40008bd4: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008bd8: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 40008bdc: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 40008be0: 94 10 20 00 clr %o2 <== NOT EXECUTED 40008be4: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40008be8: 7f ff f8 e2 call 40006f70 <_CORE_mutex_Surrender> <== NOT EXECUTED 40008bec: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008bf0: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008bf4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008bf8: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40008bfc: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 40008c00: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008c04: 12 80 00 05 bne 40008c18 <_Protected_heap_Resize_block+0x10c> <== NOT EXECUTED 40008c08: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED _Thread_Dispatch(); 40008c0c: 40 00 01 82 call 40009214 <_Thread_Dispatch> <== NOT EXECUTED 40008c10: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 40008c14: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 40008c18: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 40008c1c: 81 c7 e0 08 ret <== NOT EXECUTED 40008c20: 81 e8 00 00 restore <== NOT EXECUTED /* * 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 ) ) { 40008c24: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40008c28: 12 80 00 16 bne 40008c80 <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 40008c2c: c6 04 e0 34 ld [ %l3 + 0x34 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40008c30: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40008c34: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008c38: 22 80 00 3f be,a 40008d34 <_Protected_heap_Resize_block+0x228> <== NOT EXECUTED 40008c3c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40008c40: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40008c44: 12 80 00 0f bne 40008c80 <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 40008c48: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 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; 40008c4c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40008c50: 7f ff e4 6d call 40001e04 <== NOT EXECUTED 40008c54: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); status = _Heap_Resize_block( 40008c58: 10 bf ff d8 b 40008bb8 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008c5c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40008c60: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40008c64: 12 bf ff d2 bne 40008bac <_Protected_heap_Resize_block+0xa0> <== NOT EXECUTED 40008c68: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008c6c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008c70: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008c74: 02 80 00 15 be 40008cc8 <_Protected_heap_Resize_block+0x1bc> <== NOT EXECUTED 40008c78: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40008c7c: 30 bf ff cc b,a 40008bac <_Protected_heap_Resize_block+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008c80: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED { Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 40008c84: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40008c88: c8 01 20 3c ld [ %g4 + 0x3c ], %g4 <== NOT EXECUTED 40008c8c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008c90: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40008c94: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40008c98: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40008c9c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40008ca0: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40008ca4: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40008ca8: 7f ff e4 57 call 40001e04 <== NOT EXECUTED 40008cac: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008cb0: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 40008cb4: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008cb8: 7f ff f8 8a call 40006ee0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40008cbc: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 40008cc0: 10 bf ff be b 40008bb8 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008cc4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40008cc8: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40008ccc: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40008cd0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40008cd4: 02 80 00 28 be 40008d74 <_Protected_heap_Resize_block+0x268> <== NOT EXECUTED 40008cd8: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40008cdc: 1a 80 00 1c bcc 40008d4c <_Protected_heap_Resize_block+0x240> <== NOT EXECUTED 40008ce0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 40008ce4: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008ce8: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008cec: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40008cf0: 7f ff e4 45 call 40001e04 <== NOT EXECUTED 40008cf4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40008cf8: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40008cfc: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40008d00: 40 00 00 21 call 40008d84 <_Thread_Change_priority> <== NOT EXECUTED 40008d04: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008d08: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40008d0c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008d10: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40008d14: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 40008d18: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008d1c: 32 bf ff a7 bne,a 40008bb8 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008d20: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40008d24: 40 00 01 3c call 40009214 <_Thread_Dispatch> <== NOT EXECUTED 40008d28: 01 00 00 00 nop <== NOT EXECUTED 40008d2c: 10 bf ff a3 b 40008bb8 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008d30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * 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++; 40008d34: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008d38: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40008d3c: 7f ff e4 32 call 40001e04 <== NOT EXECUTED 40008d40: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008d44: 10 bf ff 9d b 40008bb8 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008d48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40008d4c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008d50: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40008d54: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40008d58: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008d5c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008d60: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40008d64: 7f ff e4 28 call 40001e04 <== NOT EXECUTED 40008d68: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008d6c: 10 bf ff 93 b 40008bb8 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008d70: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40008d74: 7f ff e4 24 call 40001e04 <== NOT EXECUTED 40008d78: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008d7c: 10 bf ff 8f b 40008bb8 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008d80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000d230 <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 4000d230: 9d e3 bf 98 save %sp, -104, %sp /* * Free per task variable memory */ tvp = deleted->task_variables; 4000d234: e0 06 61 7c ld [ %i1 + 0x17c ], %l0 deleted->task_variables = NULL; 4000d238: c0 26 61 7c clr [ %i1 + 0x17c ] while (tvp) { 4000d23c: 80 a4 20 00 cmp %l0, 0 4000d240: 02 80 00 25 be 4000d2d4 <_RTEMS_tasks_Delete_extension+0xa4> 4000d244: 29 10 00 6a sethi %hi(0x4001a800), %l4 4000d248: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED 4000d24c: 10 80 00 12 b 4000d294 <_RTEMS_tasks_Delete_extension+0x64> <== NOT EXECUTED 4000d250: a4 15 23 ac or %l4, 0x3ac, %l2 <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { if (tvp->dtor) 4000d254: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED 4000d258: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000d25c: 22 80 00 06 be,a 4000d274 <_RTEMS_tasks_Delete_extension+0x44> <== NOT EXECUTED 4000d260: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED (*tvp->dtor)(*tvp->ptr); 4000d264: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 4000d268: 9f c0 80 00 call %g2 <== NOT EXECUTED 4000d26c: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 4000d270: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED 4000d274: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 4000d278: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4000d27c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 4000d280: 7f ff e8 3f call 4000737c <_Heap_Free> <== NOT EXECUTED 4000d284: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 4000d288: a0 94 60 00 orcc %l1, 0, %l0 <== NOT EXECUTED 4000d28c: 22 80 00 13 be,a 4000d2d8 <_RTEMS_tasks_Delete_extension+0xa8> <== NOT EXECUTED 4000d290: d2 06 61 6c ld [ %i1 + 0x16c ], %o1 <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 4000d294: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 <== NOT EXECUTED 4000d298: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 4000d29c: 02 bf ff ee be 4000d254 <_RTEMS_tasks_Delete_extension+0x24> <== NOT EXECUTED 4000d2a0: e2 04 00 00 ld [ %l0 ], %l1 <== NOT EXECUTED if (tvp->dtor) (*tvp->dtor)(*tvp->ptr); *tvp->ptr = tvp->gval; } else { if (tvp->dtor) 4000d2a4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 4000d2a8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000d2ac: 02 bf ff f5 be 4000d280 <_RTEMS_tasks_Delete_extension+0x50> <== NOT EXECUTED 4000d2b0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 4000d2b4: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000d2b8: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED 4000d2bc: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 4000d2c0: 7f ff e8 2f call 4000737c <_Heap_Free> <== NOT EXECUTED 4000d2c4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 4000d2c8: a0 94 60 00 orcc %l1, 0, %l0 <== NOT EXECUTED 4000d2cc: 12 bf ff f3 bne 4000d298 <_RTEMS_tasks_Delete_extension+0x68> <== NOT EXECUTED 4000d2d0: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 <== NOT EXECUTED 4000d2d4: d2 06 61 6c ld [ %i1 + 0x16c ], %o1 4000d2d8: 7f ff e8 29 call 4000737c <_Heap_Free> 4000d2dc: 90 15 23 ac or %l4, 0x3ac, %o0 /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 4000d2e0: c0 26 61 6c clr [ %i1 + 0x16c ] } 4000d2e4: 81 c7 e0 08 ret 4000d2e8: 81 e8 00 00 restore 40006538 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 40006538: 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; 4000653c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006540: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 ! 4001ac20 <_Configuration_Table> 40006544: c6 00 a0 2c ld [ %g2 + 0x2c ], %g3 /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 40006548: d0 00 e0 28 ld [ %g3 + 0x28 ], %o0 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) 4000654c: 80 a2 20 00 cmp %o0, 0 40006550: 02 80 00 2f be 4000660c <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 40006554: e4 00 e0 24 ld [ %g3 + 0x24 ], %l2 40006558: 80 a4 a0 00 cmp %l2, 0 4000655c: 02 80 00 2c be 4000660c <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 40006560: a0 10 00 08 mov %o0, %l0 return; for ( index=0 ; index < maximum ; index++ ) { 40006564: a2 10 20 00 clr %l1 40006568: 10 80 00 0c b 40006598 <_RTEMS_tasks_Initialize_user_tasks_body+0x60> 4000656c: a6 07 bf f4 add %fp, -12, %l3 ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); return_value = rtems_task_start( 40006570: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 40006574: d0 07 bf f4 ld [ %fp + -12 ], %o0 40006578: 40 00 00 27 call 40006614 4000657c: a2 04 60 01 inc %l1 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 40006580: 80 a2 20 00 cmp %o0, 0 40006584: 12 80 00 1c bne 400065f4 <_RTEMS_tasks_Initialize_user_tasks_body+0xbc> 40006588: 94 10 00 08 mov %o0, %o2 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 4000658c: 80 a4 40 12 cmp %l1, %l2 40006590: 02 80 00 1f be 4000660c <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 40006594: a0 04 20 1c add %l0, 0x1c, %l0 return_value = rtems_task_create( 40006598: d6 04 20 14 ld [ %l0 + 0x14 ], %o3 4000659c: d8 04 20 0c ld [ %l0 + 0xc ], %o4 400065a0: d2 04 20 08 ld [ %l0 + 8 ], %o1 400065a4: d4 04 20 04 ld [ %l0 + 4 ], %o2 400065a8: d0 04 00 00 ld [ %l0 ], %o0 400065ac: 7f ff ff 1a call 40006214 400065b0: 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 ) ) 400065b4: 80 a2 20 00 cmp %o0, 0 400065b8: 22 bf ff ee be,a 40006570 <_RTEMS_tasks_Initialize_user_tasks_body+0x38> 400065bc: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 400065c0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 400065c4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400065c8: 40 00 04 6d call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 400065cc: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED return_value = rtems_task_start( 400065d0: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED 400065d4: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 <== NOT EXECUTED 400065d8: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED 400065dc: 40 00 00 0e call 40006614 <== NOT EXECUTED 400065e0: a2 04 60 01 inc %l1 <== NOT EXECUTED id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 400065e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400065e8: 02 bf ff ea be 40006590 <_RTEMS_tasks_Initialize_user_tasks_body+0x58> <== NOT EXECUTED 400065ec: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 400065f0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 400065f4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400065f8: 40 00 04 61 call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 400065fc: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 40006600: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED 40006604: 12 bf ff e5 bne 40006598 <_RTEMS_tasks_Initialize_user_tasks_body+0x60> <== NOT EXECUTED 40006608: a0 04 20 1c add %l0, 0x1c, %l0 <== NOT EXECUTED 4000660c: 81 c7 e0 08 ret 40006610: 81 e8 00 00 restore 400071f8 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 400071f8: 9d e3 bf 90 save %sp, -112, %sp 400071fc: 11 10 00 7e sethi %hi(0x4001f800), %o0 40007200: 92 10 00 18 mov %i0, %o1 40007204: 90 12 21 48 or %o0, 0x148, %o0 40007208: 40 00 09 cd call 4000993c <_Objects_Get> 4000720c: 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 ) { 40007210: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007214: 80 a0 60 00 cmp %g1, 0 40007218: 12 80 00 11 bne 4000725c <_Rate_monotonic_Timeout+0x64> 4000721c: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: /* impossible */ case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; 40007220: d0 02 20 50 ld [ %o0 + 0x50 ], %o0 if ( _States_Is_waiting_for_period( the_thread->current_state ) && 40007224: 03 00 00 10 sethi %hi(0x4000), %g1 40007228: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 4000722c: 80 88 80 01 btst %g2, %g1 40007230: 32 80 00 0d bne,a 40007264 <_Rate_monotonic_Timeout+0x6c> 40007234: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 40007238: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 4000723c: 80 a0 60 01 cmp %g1, 1 40007240: 02 80 00 17 be 4000729c <_Rate_monotonic_Timeout+0xa4> 40007244: 82 10 20 04 mov 4, %g1 the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 40007248: 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; 4000724c: 05 10 00 7e sethi %hi(0x4001f800), %g2 40007250: c2 00 a2 e0 ld [ %g2 + 0x2e0 ], %g1 ! 4001fae0 <_Thread_Dispatch_disable_level> 40007254: 82 00 7f ff add %g1, -1, %g1 40007258: c2 20 a2 e0 st %g1, [ %g2 + 0x2e0 ] 4000725c: 81 c7 e0 08 ret 40007260: 81 e8 00 00 restore case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; if ( _States_Is_waiting_for_period( the_thread->current_state ) && 40007264: c2 06 20 08 ld [ %i0 + 8 ], %g1 40007268: 80 a0 80 01 cmp %g2, %g1 4000726c: 32 bf ff f4 bne,a 4000723c <_Rate_monotonic_Timeout+0x44> 40007270: 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 ); 40007274: 13 04 00 ff sethi %hi(0x1003fc00), %o1 40007278: 40 00 0e 24 call 4000ab08 <_Thread_Clear_state> 4000727c: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40007280: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40007284: 92 06 20 10 add %i0, 0x10, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40007288: c2 26 20 1c st %g1, [ %i0 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4000728c: 11 10 00 7e sethi %hi(0x4001f800), %o0 40007290: 40 00 14 59 call 4000c3f4 <_Watchdog_Insert> 40007294: 90 12 23 dc or %o0, 0x3dc, %o0 ! 4001fbdc <_Watchdog_Ticks_chain> 40007298: 30 bf ff ed b,a 4000724c <_Rate_monotonic_Timeout+0x54> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000729c: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 <== NOT EXECUTED the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _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; 400072a0: 84 10 20 03 mov 3, %g2 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400072a4: 92 06 20 10 add %i0, 0x10, %o1 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400072a8: c2 26 20 1c st %g1, [ %i0 + 0x1c ] <== NOT EXECUTED 400072ac: c4 26 20 38 st %g2, [ %i0 + 0x38 ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400072b0: 11 10 00 7e sethi %hi(0x4001f800), %o0 <== NOT EXECUTED 400072b4: 40 00 14 50 call 4000c3f4 <_Watchdog_Insert> <== NOT EXECUTED 400072b8: 90 12 23 dc or %o0, 0x3dc, %o0 ! 4001fbdc <_Watchdog_Ticks_chain> <== NOT EXECUTED 400072bc: 30 bf ff e4 b,a 4000724c <_Rate_monotonic_Timeout+0x54> <== NOT EXECUTED 4001ade0 <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 4001ade0: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001ade4: 27 10 00 d3 sethi %hi(0x40034c00), %l3 4001ade8: c2 04 e0 80 ld [ %l3 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 4001adec: 82 00 60 01 inc %g1 4001adf0: c2 24 e0 80 st %g1, [ %l3 + 0x80 ] 4001adf4: c2 04 e0 80 ld [ %l3 + 0x80 ], %g1 4001adf8: 82 00 60 01 inc %g1 4001adfc: c2 24 e0 80 st %g1, [ %l3 + 0x80 ] * NOTE: Be sure to disable dispatching before unlocking the mutex * since we do not want to open a window where a context * switch could occur. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 4001ae00: 03 10 00 d3 sethi %hi(0x40034c00), %g1 4001ae04: d0 00 61 54 ld [ %g1 + 0x154 ], %o0 ! 40034d54 <_RTEMS_Allocator_Mutex> 4001ae08: 94 10 20 00 clr %o2 4001ae0c: d2 02 20 08 ld [ %o0 + 8 ], %o1 4001ae10: 7f ff e5 e0 call 40014590 <_CORE_mutex_Surrender> 4001ae14: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001ae18: c2 04 e0 80 ld [ %l3 + 0x80 ], %g1 4001ae1c: a2 06 20 10 add %i0, 0x10, %l1 4001ae20: 82 00 7f ff add %g1, -1, %g1 4001ae24: c2 24 e0 80 st %g1, [ %l3 + 0x80 ] 4001ae28: c4 04 e0 80 ld [ %l3 + 0x80 ], %g2 4001ae2c: 80 a0 a0 00 cmp %g2, 0 4001ae30: 02 80 00 21 be 4001aeb4 <_Region_Process_queue+0xd4> 4001ae34: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 4001ae38: 10 80 00 10 b 4001ae78 <_Region_Process_queue+0x98> 4001ae3c: a4 06 20 68 add %i0, 0x68, %l2 the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 4001ae40: 7f ff e6 e8 call 400149e0 <_Heap_Allocate> 4001ae44: d2 04 20 24 ld [ %l0 + 0x24 ], %o1 4001ae48: 80 a2 20 00 cmp %o0, 0 4001ae4c: 02 80 00 11 be 4001ae90 <_Region_Process_queue+0xb0> 4001ae50: 01 00 00 00 nop break; *(void **)the_thread->Wait.return_argument = the_segment; the_region->number_of_used_blocks += 1; 4001ae54: c2 06 20 64 ld [ %i0 + 0x64 ], %g1 ); if ( the_segment == NULL ) break; *(void **)the_thread->Wait.return_argument = the_segment; 4001ae58: c4 04 20 28 ld [ %l0 + 0x28 ], %g2 the_region->number_of_used_blocks += 1; 4001ae5c: 82 00 60 01 inc %g1 ); if ( the_segment == NULL ) break; *(void **)the_thread->Wait.return_argument = the_segment; 4001ae60: d0 20 80 00 st %o0, [ %g2 ] the_region->number_of_used_blocks += 1; 4001ae64: c2 26 20 64 st %g1, [ %i0 + 0x64 ] _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 4001ae68: 90 10 00 11 mov %l1, %o0 4001ae6c: 40 00 02 79 call 4001b850 <_Thread_queue_Extract> 4001ae70: 92 10 00 10 mov %l0, %o1 the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 4001ae74: c0 24 20 34 clr [ %l0 + 0x34 ] /* * NOTE: The following loop is O(n) where n is the number of * threads whose memory request is satisfied. */ for ( ; ; ) { the_thread = _Thread_queue_First( &the_region->Wait_queue ); 4001ae78: 40 00 02 c0 call 4001b978 <_Thread_queue_First> 4001ae7c: 90 10 00 11 mov %l1, %o0 4001ae80: a0 10 00 08 mov %o0, %l0 if ( the_thread == NULL ) 4001ae84: 80 a4 20 00 cmp %l0, 0 4001ae88: 12 bf ff ee bne 4001ae40 <_Region_Process_queue+0x60> 4001ae8c: 90 10 00 12 mov %l2, %o0 4001ae90: c2 04 e0 80 ld [ %l3 + 0x80 ], %g1 4001ae94: 82 00 7f ff add %g1, -1, %g1 4001ae98: c2 24 e0 80 st %g1, [ %l3 + 0x80 ] 4001ae9c: c4 04 e0 80 ld [ %l3 + 0x80 ], %g2 4001aea0: 80 a0 a0 00 cmp %g2, 0 4001aea4: 02 80 00 07 be 4001aec0 <_Region_Process_queue+0xe0> 4001aea8: 01 00 00 00 nop 4001aeac: 81 c7 e0 08 ret <== NOT EXECUTED 4001aeb0: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4001aeb4: 7f ff ee ea call 40016a5c <_Thread_Dispatch> <== NOT EXECUTED 4001aeb8: a4 06 20 68 add %i0, 0x68, %l2 <== NOT EXECUTED 4001aebc: 30 bf ff ef b,a 4001ae78 <_Region_Process_queue+0x98> <== NOT EXECUTED 4001aec0: 7f ff ee e7 call 40016a5c <_Thread_Dispatch> 4001aec4: 81 e8 00 00 restore 4001aec8: 01 00 00 00 nop 40008b84 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 40008b84: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008b88: 23 10 00 9e sethi %hi(0x40027800), %l1 40008b8c: c2 04 60 90 ld [ %l1 + 0x90 ], %g1 ! 40027890 <_Thread_Dispatch_disable_level> 40008b90: 82 00 60 01 inc %g1 40008b94: c2 24 60 90 st %g1, [ %l1 + 0x90 ] _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 40008b98: 21 10 00 9e sethi %hi(0x40027800), %l0 40008b9c: c2 06 00 00 ld [ %i0 ], %g1 40008ba0: d4 04 21 48 ld [ %l0 + 0x148 ], %o2 40008ba4: 80 a0 40 0a cmp %g1, %o2 40008ba8: 36 80 00 18 bge,a 40008c08 <_TOD_Set+0x84> 40008bac: 94 20 40 0a sub %g1, %o2, %o2 Watchdog_Adjust_directions direction, Watchdog_Interval units ) { _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units ); 40008bb0: 11 10 00 9e sethi %hi(0x40027800), %o0 40008bb4: 94 22 80 01 sub %o2, %g1, %o2 40008bb8: 90 12 21 80 or %o0, 0x180, %o0 40008bbc: 40 00 0e ea call 4000c764 <_Watchdog_Adjust> 40008bc0: 92 10 20 01 mov 1, %o1 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 40008bc4: c4 06 00 00 ld [ %i0 ], %g2 40008bc8: 86 14 21 48 or %l0, 0x148, %g3 40008bcc: c4 24 21 48 st %g2, [ %l0 + 0x148 ] 40008bd0: c2 06 20 04 ld [ %i0 + 4 ], %g1 _TOD_Is_set = TRUE; 40008bd4: 84 10 20 01 mov 1, %g2 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 40008bd8: c2 20 e0 04 st %g1, [ %g3 + 4 ] _TOD_Is_set = TRUE; 40008bdc: 03 10 00 9e sethi %hi(0x40027800), %g1 40008be0: c4 20 60 cc st %g2, [ %g1 + 0xcc ] ! 400278cc <_TOD_Is_set> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008be4: c2 04 60 90 ld [ %l1 + 0x90 ], %g1 40008be8: 82 00 7f ff add %g1, -1, %g1 40008bec: c2 24 60 90 st %g1, [ %l1 + 0x90 ] 40008bf0: c4 04 60 90 ld [ %l1 + 0x90 ], %g2 40008bf4: 80 a0 a0 00 cmp %g2, 0 40008bf8: 02 80 00 0a be 40008c20 <_TOD_Set+0x9c> 40008bfc: 01 00 00 00 nop 40008c00: 81 c7 e0 08 ret 40008c04: 81 e8 00 00 restore 40008c08: 11 10 00 9e sethi %hi(0x40027800), %o0 40008c0c: 92 10 20 00 clr %o1 40008c10: 40 00 0e d5 call 4000c764 <_Watchdog_Adjust> 40008c14: 90 12 21 80 or %o0, 0x180, %o0 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 40008c18: 10 bf ff ec b 40008bc8 <_TOD_Set+0x44> 40008c1c: c4 06 00 00 ld [ %i0 ], %g2 _Thread_Dispatch(); 40008c20: 40 00 08 3c call 4000ad10 <_Thread_Dispatch> <== NOT EXECUTED 40008c24: 81 e8 00 00 restore <== NOT EXECUTED 40008c28: 01 00 00 00 nop 400090c4 <_Thread_Create_idle>: */ const char *_Thread_Idle_name = "IDLE"; void _Thread_Create_idle( void ) { 400090c4: 9d e3 bf 80 save %sp, -128, %sp * This routine allocates an internal thread. */ RTEMS_INLINE_ROUTINE Thread_Control *_Thread_Internal_allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_Thread_Internal_information ); 400090c8: 39 10 00 6b sethi %hi(0x4001ac00), %i4 400090cc: 7f ff f9 d9 call 40007830 <_Objects_Allocate> 400090d0: 90 17 20 f0 or %i4, 0xf0, %o0 ! 4001acf0 <_Thread_Internal_information> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 400090d4: 03 10 00 6a sethi %hi(0x4001a800), %g1 400090d8: 96 10 63 74 or %g1, 0x374, %o3 ! 4001ab74 <_CPU_Table> 400090dc: c4 02 e0 0c ld [ %o3 + 0xc ], %g2 * 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(); 400090e0: 37 10 00 6b sethi %hi(0x4001ac00), %i3 400090e4: d0 26 e1 48 st %o0, [ %i3 + 0x148 ] ! 4001ad48 <_Thread_Idle> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 400090e8: 03 10 00 24 sethi %hi(0x40009000), %g1 400090ec: 92 10 00 08 mov %o0, %o1 400090f0: 80 a0 a0 00 cmp %g2, 0 400090f4: 02 80 00 03 be 40009100 <_Thread_Create_idle+0x3c> 400090f8: b4 10 63 70 or %g1, 0x370, %i2 idle = _CPU_Table.idle_task; 400090fc: b4 10 00 02 mov %g2, %i2 <== NOT EXECUTED idle_task_stack_size = _CPU_Table.idle_task_stack_size; 40009100: d6 02 e0 14 ld [ %o3 + 0x14 ], %o3 if ( idle_task_stack_size < STACK_MINIMUM_SIZE ) 40009104: 80 a2 ef ff cmp %o3, 0xfff 40009108: 28 80 00 02 bleu,a 40009110 <_Thread_Create_idle+0x4c> 4000910c: 17 00 00 04 sethi %hi(0x1000), %o3 idle_task_stack_size = STACK_MINIMUM_SIZE; _Thread_Initialize( 40009110: 03 10 00 67 sethi %hi(0x40019c00), %g1 40009114: c4 00 62 58 ld [ %g1 + 0x258 ], %g2 ! 40019e58 <_Thread_Idle_name> 40009118: 82 10 20 01 mov 1, %g1 4000911c: c4 23 a0 6c st %g2, [ %sp + 0x6c ] 40009120: 90 17 20 f0 or %i4, 0xf0, %o0 40009124: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 40009128: c0 23 a0 60 clr [ %sp + 0x60 ] 4000912c: c0 23 a0 64 clr [ %sp + 0x64 ] 40009130: c0 23 a0 68 clr [ %sp + 0x68 ] 40009134: 94 10 20 00 clr %o2 40009138: 98 10 20 00 clr %o4 4000913c: 40 00 00 8e call 40009374 <_Thread_Initialize> 40009140: 9a 10 20 ff mov 0xff, %o5 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 40009144: c6 06 e1 48 ld [ %i3 + 0x148 ], %g3 40009148: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000914c: 05 10 00 6b sethi %hi(0x4001ac00), %g2 _Thread_Executing = _Thread_Idle; _Thread_Start( 40009150: 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 = 40009154: c6 20 60 3c st %g3, [ %g1 + 0x3c ] 40009158: c6 20 a0 14 st %g3, [ %g2 + 0x14 ] _Thread_Executing = _Thread_Idle; _Thread_Start( 4000915c: b2 10 20 00 clr %i1 40009160: b6 10 20 00 clr %i3 40009164: 40 00 04 07 call 4000a180 <_Thread_Start> 40009168: 99 e8 20 00 restore %g0, 0, %o4 4000916c: 01 00 00 00 nop 40009170 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 40009170: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 40009174: 92 96 20 00 orcc %i0, 0, %o1 40009178: 12 80 00 11 bne 400091bc <_Thread_Delay_ended+0x4c> 4000917c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009180: 31 10 00 6a sethi %hi(0x4001a800), %i0 <== NOT EXECUTED 40009184: c2 06 23 60 ld [ %i0 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009188: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000918c: c2 26 23 60 st %g1, [ %i0 + 0x360 ] <== NOT EXECUTED 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; 40009190: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009194: d0 00 60 3c ld [ %g1 + 0x3c ], %o0 ! 4001ac3c <_Thread_Executing> <== NOT EXECUTED 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; 40009198: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000919c: 13 04 00 ff sethi %hi(0x1003fc00), %o1 <== NOT EXECUTED 400091a0: 7f ff ff 68 call 40008f40 <_Thread_Clear_state> 400091a4: 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; 400091a8: c2 06 23 60 ld [ %i0 + 0x360 ], %g1 400091ac: 82 00 7f ff add %g1, -1, %g1 400091b0: c2 26 23 60 st %g1, [ %i0 + 0x360 ] 400091b4: 81 c7 e0 08 ret 400091b8: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 400091bc: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 400091c0: 80 a0 a0 04 cmp %g2, 4 400091c4: 18 bf ff fc bgu 400091b4 <_Thread_Delay_ended+0x44> 400091c8: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 400091cc: 80 a0 60 01 cmp %g1, 1 400091d0: 12 bf ff f9 bne 400091b4 <_Thread_Delay_ended+0x44> 400091d4: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400091d8: 05 10 00 6a sethi %hi(0x4001a800), %g2 400091dc: 84 10 a2 c0 or %g2, 0x2c0, %g2 ! 4001aac0 <_Objects_Information_table> 400091e0: c6 00 80 01 ld [ %g2 + %g1 ], %g3 400091e4: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 400091e8: 80 a2 20 00 cmp %o0, 0 400091ec: 02 bf ff f2 be 400091b4 <_Thread_Delay_ended+0x44> 400091f0: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 400091f4: 7f ff fa e0 call 40007d74 <_Objects_Get> 400091f8: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 400091fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009200: 80 a0 60 00 cmp %g1, 0 40009204: 12 bf ff ec bne 400091b4 <_Thread_Delay_ended+0x44> 40009208: 31 10 00 6a sethi %hi(0x4001a800), %i0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000920c: 10 bf ff e5 b 400091a0 <_Thread_Delay_ended+0x30> 40009210: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000eb10 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 4000eb10: 9d e3 bf 98 save %sp, -104, %sp #endif #if defined(__USE__MAIN__) extern void _main(void); #endif executing = _Thread_Executing; 4000eb14: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000eb18: f4 00 60 3c ld [ %g1 + 0x3c ], %i2 ! 4001ac3c <_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(); 4000eb1c: 3f 10 00 3a sethi %hi(0x4000e800), %i7 4000eb20: be 17 e3 10 or %i7, 0x310, %i7 ! 4000eb10 <_Thread_Handler> * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; _ISR_Set_level(level); 4000eb24: d0 06 a0 c4 ld [ %i2 + 0xc4 ], %o0 4000eb28: 7f ff cc b7 call 40001e04 4000eb2c: 91 2a 20 08 sll %o0, 8, %o0 #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 4000eb30: 05 10 00 6a sethi %hi(0x4001a800), %g2 doneConstructors = 1; 4000eb34: 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; 4000eb38: f2 08 a1 7c ldub [ %g2 + 0x17c ], %i1 * 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 ); 4000eb3c: 90 10 00 1a mov %i2, %o0 4000eb40: 7f ff ee 4e call 4000a478 <_User_extensions_Thread_begin> 4000eb44: c2 28 a1 7c stb %g1, [ %g2 + 0x17c ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000eb48: 05 10 00 6a sethi %hi(0x4001a800), %g2 4000eb4c: c2 00 a3 60 ld [ %g2 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> 4000eb50: 82 00 7f ff add %g1, -1, %g1 4000eb54: c2 20 a3 60 st %g1, [ %g2 + 0x360 ] 4000eb58: c6 00 a3 60 ld [ %g2 + 0x360 ], %g3 4000eb5c: 80 a0 e0 00 cmp %g3, 0 4000eb60: 02 80 00 36 be 4000ec38 <_Thread_Handler+0x128> 4000eb64: 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) */ 4000eb68: 83 2e 60 18 sll %i1, 0x18, %g1 <== NOT EXECUTED 4000eb6c: 80 a0 60 00 cmp %g1, 0 4000eb70: 02 80 00 22 be 4000ebf8 <_Thread_Handler+0xe8> 4000eb74: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 4000eb78: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 4000eb7c: 80 a0 60 01 cmp %g1, 1 4000eb80: 22 80 00 25 be,a 4000ec14 <_Thread_Handler+0x104> 4000eb84: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 4000eb88: 80 a0 60 01 cmp %g1, 1 4000eb8c: 1a 80 00 0c bcc 4000ebbc <_Thread_Handler+0xac> 4000eb90: 80 a0 60 02 cmp %g1, 2 case THREAD_START_NUMERIC: executing->Wait.return_argument = 4000eb94: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 4000eb98: 9f c0 40 00 call %g1 4000eb9c: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 4000eba0: d0 26 a0 28 st %o0, [ %i2 + 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 ); 4000eba4: 90 10 00 1a mov %i2, %o0 4000eba8: 7f ff ee 5c call 4000a518 <_User_extensions_Thread_exitted> 4000ebac: b0 10 20 00 clr %i0 _Internal_error_Occurred( 4000ebb0: b2 10 20 01 mov 1, %i1 4000ebb4: 7f ff e2 f2 call 4000777c <_Internal_error_Occurred> 4000ebb8: 95 e8 20 06 restore %g0, 6, %o2 #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 4000ebbc: 02 80 00 23 be 4000ec48 <_Thread_Handler+0x138> <== NOT EXECUTED 4000ebc0: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 4000ebc4: 12 bf ff f9 bne 4000eba8 <_Thread_Handler+0x98> <== NOT EXECUTED 4000ebc8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 4000ebcc: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 4000ebd0: d2 06 a0 b0 ld [ %i2 + 0xb0 ], %o1 <== NOT EXECUTED 4000ebd4: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 <== NOT EXECUTED 4000ebd8: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000ebdc: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000ebe0: d0 26 a0 28 st %o0, [ %i2 + 0x28 ] <== NOT EXECUTED * 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 ); 4000ebe4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000ebe8: 7f ff ee 4c call 4000a518 <_User_extensions_Thread_exitted> <== NOT EXECUTED 4000ebec: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 4000ebf0: 7f ff e2 e3 call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 4000ebf4: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED * _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) */ _init (); 4000ebf8: 40 00 2b 32 call 400198c0 <_init> 4000ebfc: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 4000ec00: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 4000ec04: 80 a0 60 01 cmp %g1, 1 4000ec08: 12 bf ff e1 bne 4000eb8c <_Thread_Handler+0x7c> 4000ec0c: 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 = 4000ec10: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 4000ec14: d0 06 a0 b0 ld [ %i2 + 0xb0 ], %o0 4000ec18: 9f c0 40 00 call %g1 4000ec1c: b0 10 20 00 clr %i0 4000ec20: d0 26 a0 28 st %o0, [ %i2 + 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 ); 4000ec24: 90 10 00 1a mov %i2, %o0 4000ec28: 7f ff ee 3c call 4000a518 <_User_extensions_Thread_exitted> 4000ec2c: b2 10 20 01 mov 1, %i1 _Internal_error_Occurred( 4000ec30: 7f ff e2 d3 call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 4000ec34: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED _Thread_Dispatch(); 4000ec38: 7f ff e9 77 call 40009214 <_Thread_Dispatch> 4000ec3c: 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) */ 4000ec40: 10 bf ff cb b 4000eb6c <_Thread_Handler+0x5c> 4000ec44: 83 2e 60 18 sll %i1, 0x18, %g1 (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 4000ec48: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 4000ec4c: d0 1e a0 b0 ldd [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED 4000ec50: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000ec54: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000ec58: d0 26 a0 28 st %o0, [ %i2 + 0x28 ] <== NOT EXECUTED * 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 ); 4000ec5c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000ec60: 7f ff ee 2e call 4000a518 <_User_extensions_Thread_exitted> <== NOT EXECUTED 4000ec64: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 4000ec68: 7f ff e2 c5 call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 4000ec6c: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED 4000ec70: 01 00 00 00 nop 40009530 <_Thread_Handler_initialization>: void _Thread_Handler_initialization( uint32_t ticks_per_timeslice, uint32_t maximum_extensions, uint32_t maximum_proxies ) { 40009530: 9d e3 bf 90 save %sp, -112, %sp /* * BOTH stacks hooks must be set or both must be NULL. * Do not allow mixture. */ if ( !( ( _CPU_Table.stack_allocate_hook == 0 ) 40009534: 03 10 00 6a sethi %hi(0x4001a800), %g1 40009538: 82 10 63 74 or %g1, 0x374, %g1 ! 4001ab74 <_CPU_Table> 4000953c: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 40009540: c6 00 60 24 ld [ %g1 + 0x24 ], %g3 40009544: 80 a0 00 02 cmp %g0, %g2 40009548: 88 60 3f ff subx %g0, -1, %g4 4000954c: 80 a0 00 03 cmp %g0, %g3 40009550: 82 60 3f ff subx %g0, -1, %g1 40009554: 80 a1 00 01 cmp %g4, %g1 40009558: 12 80 00 2c bne 40009608 <_Thread_Handler_initialization+0xd8> 4000955c: 90 10 20 00 clr %o0 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 40009560: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _Thread_Executing = NULL; 40009564: 05 10 00 6b sethi %hi(0x4001ac00), %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 40009568: c0 20 60 4c clr [ %g1 + 0x4c ] _Thread_Executing = NULL; 4000956c: c0 20 a0 3c clr [ %g2 + 0x3c ] _Thread_Heir = NULL; 40009570: 03 10 00 6b sethi %hi(0x4001ac00), %g1 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; 40009574: 05 10 00 6b sethi %hi(0x4001ac00), %g2 INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; _Thread_Executing = NULL; _Thread_Heir = NULL; 40009578: c0 20 60 14 clr [ %g1 + 0x14 ] #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; 4000957c: c0 20 a0 2c clr [ %g2 + 0x2c ] _Thread_Maximum_extensions = maximum_extensions; 40009580: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _Thread_Ticks_per_timeslice = ticks_per_timeslice; 40009584: 05 10 00 6a sethi %hi(0x4001a800), %g2 _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; _Thread_Maximum_extensions = maximum_extensions; 40009588: f2 20 60 28 st %i1, [ %g1 + 0x28 ] _Thread_Ticks_per_timeslice = ticks_per_timeslice; 4000958c: f0 20 a2 b8 st %i0, [ %g2 + 0x2b8 ] _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 40009590: 40 00 05 13 call 4000a9dc <_Workspace_Allocate_or_fatal_error> 40009594: 90 10 2c 00 mov 0xc00, %o0 40009598: 03 10 00 6a sethi %hi(0x4001a800), %g1 4000959c: 84 10 00 08 mov %o0, %g2 400095a0: d0 20 62 b4 st %o0, [ %g1 + 0x2b4 ] 400095a4: 86 02 2c 00 add %o0, 0xc00, %g3 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 400095a8: 82 00 a0 04 add %g2, 4, %g1 the_chain->permanent_null = NULL; 400095ac: c0 20 a0 04 clr [ %g2 + 4 ] the_chain->last = _Chain_Head(the_chain); 400095b0: 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); 400095b4: c2 20 80 00 st %g1, [ %g2 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 400095b8: 84 00 a0 0c add %g2, 0xc, %g2 (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 400095bc: 80 a0 80 03 cmp %g2, %g3 400095c0: 12 bf ff fb bne 400095ac <_Thread_Handler_initialization+0x7c> 400095c4: 82 00 a0 04 add %g2, 4, %g1 /* * Initialize this class of objects. */ _Objects_Initialize_information( 400095c8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400095cc: c4 00 60 68 ld [ %g1 + 0x68 ], %g2 ! 4001ac68 <_System_state_Is_multiprocessing> 400095d0: 82 10 20 08 mov 8, %g1 400095d4: 80 a0 00 02 cmp %g0, %g2 400095d8: 96 10 20 02 mov 2, %o3 400095dc: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 400095e0: 96 42 ff ff addx %o3, -1, %o3 400095e4: 11 10 00 6b sethi %hi(0x4001ac00), %o0 400095e8: 92 10 20 01 mov 1, %o1 400095ec: 90 12 20 f0 or %o0, 0xf0, %o0 400095f0: 94 10 20 01 mov 1, %o2 400095f4: 98 10 21 80 mov 0x180, %o4 400095f8: 7f ff fa 06 call 40007e10 <_Objects_Initialize_information> 400095fc: 9a 10 20 01 mov 1, %o5 FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 40009600: 81 c7 e0 08 ret 40009604: 81 e8 00 00 restore * Do not allow mixture. */ if ( !( ( _CPU_Table.stack_allocate_hook == 0 ) == ( _CPU_Table.stack_free_hook == 0 ) ) ) _Internal_error_Occurred( 40009608: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 4000960c: 7f ff f8 5c call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 40009610: 94 10 20 0f mov 0xf, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 40009614: 10 bf ff d4 b 40009564 <_Thread_Handler_initialization+0x34> <== NOT EXECUTED 40009618: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009374 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 40009374: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the Ada self pointer */ the_thread->rtems_ada_self = NULL; 40009378: c0 26 60 80 clr [ %i1 + 0x80 ] /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 4000937c: 80 a6 a0 00 cmp %i2, 0 40009380: 02 80 00 59 be 400094e4 <_Thread_Initialize+0x170> 40009384: e2 07 a0 60 ld [ %fp + 0x60 ], %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; 40009388: c0 26 60 cc clr [ %i1 + 0xcc ] <== NOT EXECUTED 4000938c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 40009390: 21 10 00 6b sethi %hi(0x4001ac00), %l0 40009394: d2 04 20 28 ld [ %l0 + 0x28 ], %o1 ! 4001ac28 <_Thread_Maximum_extensions> Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 40009398: f4 26 60 d4 st %i2, [ %i1 + 0xd4 ] the_stack->size = size; 4000939c: d0 26 60 d0 st %o0, [ %i1 + 0xd0 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 400093a0: c0 26 60 50 clr [ %i1 + 0x50 ] the_watchdog->routine = routine; 400093a4: c0 26 60 64 clr [ %i1 + 0x64 ] the_watchdog->id = id; 400093a8: c0 26 60 68 clr [ %i1 + 0x68 ] the_watchdog->user_data = user_data; 400093ac: c0 26 60 6c clr [ %i1 + 0x6c ] 400093b0: 80 a2 60 00 cmp %o1, 0 400093b4: 12 80 00 38 bne 40009494 <_Thread_Initialize+0x120> 400093b8: c0 26 61 68 clr [ %i1 + 0x168 ] return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 400093bc: c0 26 61 78 clr [ %i1 + 0x178 ] 400093c0: b6 10 20 00 clr %i3 /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 400093c4: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 the_thread->Start.budget_algorithm = budget_algorithm; 400093c8: e2 26 60 bc st %l1, [ %i1 + 0xbc ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 400093cc: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 400093d0: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 switch ( budget_algorithm ) { 400093d4: 80 a4 60 02 cmp %l1, 2 400093d8: 12 80 00 05 bne 400093ec <_Thread_Initialize+0x78> 400093dc: c2 26 60 c0 st %g1, [ %i1 + 0xc0 ] 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; 400093e0: 03 10 00 6a sethi %hi(0x4001a800), %g1 <== NOT EXECUTED 400093e4: c4 00 62 b8 ld [ %g1 + 0x2b8 ], %g2 ! 4001aab8 <_Thread_Ticks_per_timeslice> <== NOT EXECUTED 400093e8: c4 26 60 84 st %g2, [ %i1 + 0x84 ] <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 400093ec: c2 07 a0 68 ld [ %fp + 0x68 ], %g1 the_thread->current_state = STATES_DORMANT; the_thread->Wait.queue = NULL; 400093f0: c0 26 60 44 clr [ %i1 + 0x44 ] break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 400093f4: c2 26 60 c4 st %g1, [ %i1 + 0xc4 ] the_thread->current_state = STATES_DORMANT; 400093f8: 82 10 20 01 mov 1, %g1 the_thread->Wait.queue = NULL; the_thread->resource_count = 0; 400093fc: c0 26 60 1c clr [ %i1 + 0x1c ] break; } the_thread->Start.isr_level = isr_level; the_thread->current_state = STATES_DORMANT; 40009400: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_thread->Wait.queue = NULL; the_thread->resource_count = 0; the_thread->suspend_count = 0; 40009404: c0 26 60 70 clr [ %i1 + 0x70 ] the_thread->real_priority = priority; 40009408: fa 26 60 18 st %i5, [ %i1 + 0x18 ] the_thread->Start.initial_priority = priority; 4000940c: fa 26 60 c8 st %i5, [ %i1 + 0xc8 ] _Thread_Set_priority( the_thread, priority ); 40009410: 92 10 00 1d mov %i5, %o1 40009414: 40 00 02 76 call 40009dec <_Thread_Set_priority> 40009418: 90 10 00 19 mov %i1, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000941c: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40009420: c6 16 20 10 lduh [ %i0 + 0x10 ], %g3 /* * Initialize the CPU usage statistics */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS the_thread->cpu_time_used.tv_sec = 0; 40009424: c0 26 60 90 clr [ %i1 + 0x90 ] 40009428: 03 00 00 3f sethi %hi(0xfc00), %g1 4000942c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40009430: 82 08 80 01 and %g2, %g1, %g1 40009434: 80 a0 40 03 cmp %g1, %g3 40009438: 08 80 00 13 bleu 40009484 <_Thread_Initialize+0x110> 4000943c: c0 26 60 94 clr [ %i1 + 0x94 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 40009440: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 /* * Invoke create extensions */ if ( !_User_extensions_Thread_create( the_thread ) ) { 40009444: 90 10 00 19 mov %i1, %o0 40009448: c2 26 60 0c st %g1, [ %i1 + 0xc ] 4000944c: 40 00 04 46 call 4000a564 <_User_extensions_Thread_create> 40009450: b0 10 20 01 mov 1, %i0 40009454: 80 a2 20 00 cmp %o0, 0 40009458: 12 80 00 34 bne 40009528 <_Thread_Initialize+0x1b4> 4000945c: 80 a6 e0 00 cmp %i3, 0 if ( extensions_area ) 40009460: 02 80 00 05 be 40009474 <_Thread_Initialize+0x100> <== NOT EXECUTED 40009464: 11 10 00 6a sethi %hi(0x4001a800), %o0 <== NOT EXECUTED 40009468: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 4000946c: 7f ff f7 c4 call 4000737c <_Heap_Free> <== NOT EXECUTED 40009470: 90 12 23 ac or %o0, 0x3ac, %o0 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); 40009474: 40 00 03 22 call 4000a0fc <_Thread_Stack_Free> <== NOT EXECUTED 40009478: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4000947c: 81 c7 e0 08 ret 40009480: 91 e8 20 00 restore %g0, 0, %o0 uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) information->local_table[ index ] = the_object; 40009484: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 40009488: 83 28 60 02 sll %g1, 2, %g1 4000948c: 10 bf ff ed b 40009440 <_Thread_Initialize+0xcc> 40009490: f2 20 80 01 st %i1, [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 40009494: 92 02 60 01 inc %o1 40009498: 11 10 00 6a sethi %hi(0x4001a800), %o0 4000949c: 93 2a 60 02 sll %o1, 2, %o1 400094a0: 7f ff f7 85 call 400072b4 <_Heap_Allocate> 400094a4: 90 12 23 ac or %o0, 0x3ac, %o0 if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 400094a8: b6 92 20 00 orcc %o0, 0, %i3 400094ac: 02 80 00 1c be 4000951c <_Thread_Initialize+0x1a8> 400094b0: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 400094b4: 80 a0 7f ff cmp %g1, -1 400094b8: 02 bf ff c3 be 400093c4 <_Thread_Initialize+0x50> 400094bc: f6 26 61 78 st %i3, [ %i1 + 0x178 ] 400094c0: 86 00 60 01 add %g1, 1, %g3 400094c4: 84 10 20 00 clr %g2 the_thread->extensions[i] = NULL; 400094c8: 83 28 a0 02 sll %g2, 2, %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 400094cc: 84 00 a0 01 inc %g2 400094d0: 80 a0 80 03 cmp %g2, %g3 400094d4: 12 bf ff fd bne 400094c8 <_Thread_Initialize+0x154> 400094d8: c0 26 c0 01 clr [ %i3 + %g1 ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 400094dc: 10 bf ff bb b 400093c8 <_Thread_Initialize+0x54> 400094e0: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { if ( !_Stack_Is_enough( stack_size ) ) 400094e4: 80 a6 ef ff cmp %i3, 0xfff 400094e8: 08 80 00 03 bleu 400094f4 <_Thread_Initialize+0x180> 400094ec: 13 00 00 04 sethi %hi(0x1000), %o1 400094f0: 92 10 00 1b mov %i3, %o1 actual_stack_size = STACK_MINIMUM_SIZE; else actual_stack_size = stack_size; actual_stack_size = _Thread_Stack_Allocate( the_thread, actual_stack_size ); 400094f4: 40 00 02 e7 call 4000a090 <_Thread_Stack_Allocate> 400094f8: 90 10 00 19 mov %i1, %o0 if ( !actual_stack_size || actual_stack_size < stack_size ) 400094fc: 80 a2 20 00 cmp %o0, 0 40009500: 02 bf ff df be 4000947c <_Thread_Initialize+0x108> 40009504: 80 a6 c0 08 cmp %i3, %o0 40009508: 18 bf ff dd bgu 4000947c <_Thread_Initialize+0x108> 4000950c: 82 10 20 01 mov 1, %g1 return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 40009510: f4 06 60 d8 ld [ %i1 + 0xd8 ], %i2 the_thread->Start.core_allocated_stack = TRUE; 40009514: 10 bf ff 9f b 40009390 <_Thread_Initialize+0x1c> 40009518: c2 26 60 cc st %g1, [ %i1 + 0xcc ] #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); 4000951c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40009520: 40 00 02 f7 call 4000a0fc <_Thread_Stack_Free> <== NOT EXECUTED 40009524: b0 10 20 00 clr %i0 <== NOT EXECUTED 40009528: 81 c7 e0 08 ret 4000952c: 81 e8 00 00 restore 4000eaa4 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { 4000eaa4: 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; 4000eaa8: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000eaac: c4 06 20 bc ld [ %i0 + 0xbc ], %g2 the_thread->budget_callout = the_thread->Start.budget_callout; 4000eab0: c6 06 20 c0 ld [ %i0 + 0xc0 ], %g3 uint32_t numeric_argument ) { the_thread->resource_count = 0; the_thread->suspend_count = 0; the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000eab4: c2 26 20 7c st %g1, [ %i0 + 0x7c ] the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout; 4000eab8: c4 3e 20 88 std %g2, [ %i0 + 0x88 ] the_thread->Start.pointer_argument = pointer_argument; 4000eabc: f2 26 20 b0 st %i1, [ %i0 + 0xb0 ] the_thread->Start.numeric_argument = numeric_argument; 4000eac0: f4 26 20 b4 st %i2, [ %i0 + 0xb4 ] Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { the_thread->resource_count = 0; 4000eac4: c0 26 20 1c clr [ %i0 + 0x1c ] the_thread->suspend_count = 0; 4000eac8: 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 ) ) { 4000eacc: 7f ff ef 4f call 4000a808 <_Thread_queue_Extract_with_proxy> 4000ead0: 90 10 00 18 mov %i0, %o0 4000ead4: 80 a2 20 00 cmp %o0, 0 4000ead8: 32 80 00 07 bne,a 4000eaf4 <_Thread_Reset+0x50> 4000eadc: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 if ( _Watchdog_Is_active( &the_thread->Timer ) ) 4000eae0: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000eae4: 80 a0 60 02 cmp %g1, 2 4000eae8: 02 80 00 0c be 4000eb18 <_Thread_Reset+0x74> 4000eaec: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 4000eaf0: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 4000eaf4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4000eaf8: 80 a0 40 19 cmp %g1, %i1 4000eafc: 02 80 00 05 be 4000eb10 <_Thread_Reset+0x6c> 4000eb00: 01 00 00 00 nop the_thread->real_priority = the_thread->Start.initial_priority; 4000eb04: f2 26 20 18 st %i1, [ %i0 + 0x18 ] _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 4000eb08: 7f ff f0 01 call 4000ab0c <_Thread_Set_priority> 4000eb0c: 81 e8 00 00 restore 4000eb10: 81 c7 e0 08 ret 4000eb14: 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 ); 4000eb18: 7f ff f2 ac call 4000b5c8 <_Watchdog_Remove> <== NOT EXECUTED 4000eb1c: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 4000eb20: 10 bf ff f5 b 4000eaf4 <_Thread_Reset+0x50> <== NOT EXECUTED 4000eb24: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 <== NOT EXECUTED 4000dcac <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 4000dcac: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 4000dcb0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000dcb4: e0 00 60 3c ld [ %g1 + 0x3c ], %l0 ! 4001ac3c <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 4000dcb8: 7f ff d0 4f call 40001df4 4000dcbc: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 4000dcc0: b0 10 00 08 mov %o0, %i0 if ( _Chain_Has_only_one_node( ready ) ) { 4000dcc4: c4 04 40 00 ld [ %l1 ], %g2 4000dcc8: c2 04 60 08 ld [ %l1 + 8 ], %g1 4000dccc: 80 a0 80 01 cmp %g2, %g1 4000dcd0: 32 80 00 04 bne,a 4000dce0 <_Thread_Reset_timeslice+0x34> 4000dcd4: c6 04 00 00 ld [ %l0 ], %g3 _ISR_Enable( level ); 4000dcd8: 7f ff d0 4b call 40001e04 4000dcdc: 81 e8 00 00 restore { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 4000dce0: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000dce4: 82 04 60 04 add %l1, 4, %g1 Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; previous->next = next; 4000dce8: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000dcec: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000dcf0: 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; 4000dcf4: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 4000dcf8: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000dcfc: 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; 4000dd00: e0 20 40 00 st %l0, [ %g1 ] return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 4000dd04: 7f ff d0 40 call 40001e04 4000dd08: 01 00 00 00 nop 4000dd0c: 7f ff d0 3a call 40001df4 4000dd10: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 4000dd14: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000dd18: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 ! 4001ac14 <_Thread_Heir> 4000dd1c: 80 a4 00 01 cmp %l0, %g1 4000dd20: 32 80 00 05 bne,a 4000dd34 <_Thread_Reset_timeslice+0x88> 4000dd24: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 4000dd28: c2 04 40 00 ld [ %l1 ], %g1 4000dd2c: c2 20 a0 14 st %g1, [ %g2 + 0x14 ] _Context_Switch_necessary = TRUE; 4000dd30: 84 10 20 01 mov 1, %g2 4000dd34: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000dd38: c4 20 60 4c st %g2, [ %g1 + 0x4c ] ! 4001ac4c <_Context_Switch_necessary> _ISR_Enable( level ); 4000dd3c: 7f ff d0 32 call 40001e04 4000dd40: 81 e8 00 00 restore 4000dd44: 01 00 00 00 nop 4000b940 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, boolean force ) { 4000b940: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; States_Control current_state; _ISR_Disable( level ); 4000b944: 7f ff dc 74 call 40002b14 4000b948: 01 00 00 00 nop 4000b94c: a0 10 00 08 mov %o0, %l0 if ( force == TRUE ) 4000b950: 80 a6 60 01 cmp %i1, 1 4000b954: 22 80 00 13 be,a 4000b9a0 <_Thread_Resume+0x60> 4000b958: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 the_thread->suspend_count = 0; else the_thread->suspend_count--; 4000b95c: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED 4000b960: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 4000b964: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000b968: 12 80 00 0c bne 4000b998 <_Thread_Resume+0x58> <== NOT EXECUTED 4000b96c: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED _ISR_Enable( level ); return; } current_state = the_thread->current_state; 4000b970: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 4000b974: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 4000b978: 02 80 00 06 be 4000b990 <_Thread_Resume+0x50> <== NOT EXECUTED 4000b97c: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 4000b980: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 4000b984: 80 a0 60 00 cmp %g1, 0 4000b988: 02 80 00 0b be 4000b9b4 <_Thread_Resume+0x74> 4000b98c: c2 26 20 10 st %g1, [ %i0 + 0x10 ] _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 4000b990: 7f ff dc 65 call 40002b24 4000b994: 91 e8 00 10 restore %g0, %l0, %o0 the_thread->suspend_count = 0; else the_thread->suspend_count--; if ( the_thread->suspend_count > 0 ) { _ISR_Enable( level ); 4000b998: 7f ff dc 63 call 40002b24 <== NOT EXECUTED 4000b99c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { 4000b9a0: 80 88 60 02 btst 2, %g1 4000b9a4: 02 bf ff fb be 4000b990 <_Thread_Resume+0x50> 4000b9a8: c0 26 20 70 clr [ %i0 + 0x70 ] 4000b9ac: 10 bf ff f6 b 4000b984 <_Thread_Resume+0x44> 4000b9b0: 82 08 7f fd and %g1, -3, %g1 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 4000b9b4: c8 06 20 9c ld [ %i0 + 0x9c ], %g4 4000b9b8: c4 16 20 a2 lduh [ %i0 + 0xa2 ], %g2 4000b9bc: 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); 4000b9c0: c6 06 20 98 ld [ %i0 + 0x98 ], %g3 4000b9c4: 82 10 40 02 or %g1, %g2, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 4000b9c8: 1b 10 00 9e sethi %hi(0x40027800), %o5 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 4000b9cc: c2 31 00 00 sth %g1, [ %g4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000b9d0: 82 00 e0 04 add %g3, 4, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 4000b9d4: d8 16 20 a0 lduh [ %i0 + 0xa0 ], %o4 4000b9d8: c2 26 00 00 st %g1, [ %i0 ] 4000b9dc: c4 13 61 60 lduh [ %o5 + 0x160 ], %g2 old_last_node = the_chain->last; 4000b9e0: c8 00 e0 08 ld [ %g3 + 8 ], %g4 the_chain->last = the_node; 4000b9e4: f0 20 e0 08 st %i0, [ %g3 + 8 ] 4000b9e8: 84 10 80 0c or %g2, %o4, %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 4000b9ec: c8 26 20 04 st %g4, [ %i0 + 4 ] 4000b9f0: c4 33 61 60 sth %g2, [ %o5 + 0x160 ] 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; 4000b9f4: f0 21 00 00 st %i0, [ %g4 ] _ISR_Flash( level ); 4000b9f8: 7f ff dc 4b call 40002b24 4000b9fc: 90 10 00 10 mov %l0, %o0 4000ba00: 7f ff dc 45 call 40002b14 4000ba04: 01 00 00 00 nop if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 4000ba08: 09 10 00 9e sethi %hi(0x40027800), %g4 4000ba0c: c4 01 21 44 ld [ %g4 + 0x144 ], %g2 ! 40027944 <_Thread_Heir> 4000ba10: c6 06 20 14 ld [ %i0 + 0x14 ], %g3 4000ba14: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 4000ba18: 80 a0 c0 01 cmp %g3, %g1 4000ba1c: 1a bf ff dd bcc 4000b990 <_Thread_Resume+0x50> 4000ba20: 01 00 00 00 nop _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 4000ba24: 03 10 00 9e sethi %hi(0x40027800), %g1 4000ba28: c4 00 61 6c ld [ %g1 + 0x16c ], %g2 ! 4002796c <_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; 4000ba2c: f0 21 21 44 st %i0, [ %g4 + 0x144 ] if ( _Thread_Executing->is_preemptible || 4000ba30: c2 00 a0 7c ld [ %g2 + 0x7c ], %g1 4000ba34: 80 a0 60 00 cmp %g1, 0 4000ba38: 02 80 00 06 be 4000ba50 <_Thread_Resume+0x110> 4000ba3c: 80 a0 e0 00 cmp %g3, 0 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 4000ba40: 84 10 20 01 mov 1, %g2 4000ba44: 03 10 00 9e sethi %hi(0x40027800), %g1 4000ba48: c4 20 61 7c st %g2, [ %g1 + 0x17c ] ! 4002797c <_Context_Switch_necessary> 4000ba4c: 30 bf ff d1 b,a 4000b990 <_Thread_Resume+0x50> _ISR_Flash( level ); if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 4000ba50: 12 bf ff d0 bne 4000b990 <_Thread_Resume+0x50> 4000ba54: 84 10 20 01 mov 1, %g2 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 4000ba58: 10 bf ff fc b 4000ba48 <_Thread_Resume+0x108> <== NOT EXECUTED 4000ba5c: 03 10 00 9e sethi %hi(0x40027800), %g1 <== NOT EXECUTED 4000a090 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 4000a090: 9d e3 bf 98 save %sp, -104, %sp void *stack_addr = 0; size_t the_stack_size = stack_size; if ( !_Stack_Is_enough( the_stack_size ) ) 4000a094: 80 a6 6f ff cmp %i1, 0xfff 4000a098: 28 80 00 02 bleu,a 4000a0a0 <_Thread_Stack_Allocate+0x10> 4000a09c: 33 00 00 04 sethi %hi(0x1000), %i1 <== NOT EXECUTED * 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 ( _CPU_Table.stack_allocate_hook ) { 4000a0a0: 03 10 00 6a sethi %hi(0x4001a800), %g1 4000a0a4: c2 00 63 94 ld [ %g1 + 0x394 ], %g1 ! 4001ab94 <_CPU_Table+0x20> 4000a0a8: 80 a0 60 00 cmp %g1, 0 4000a0ac: 02 80 00 0a be 4000a0d4 <_Thread_Stack_Allocate+0x44> 4000a0b0: 92 06 60 10 add %i1, 0x10, %o1 stack_addr = (*_CPU_Table.stack_allocate_hook)( the_stack_size ); 4000a0b4: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a0b8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 4000a0bc: d0 26 20 d8 st %o0, [ %i0 + 0xd8 ] <== NOT EXECUTED the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 4000a0c0: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 4000a0c4: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 4000a0c8: b0 0e 40 18 and %i1, %i0, %i0 <== NOT EXECUTED 4000a0cc: 81 c7 e0 08 ret <== NOT EXECUTED 4000a0d0: 81 e8 00 00 restore <== NOT EXECUTED 4000a0d4: 11 10 00 6a sethi %hi(0x4001a800), %o0 4000a0d8: b2 10 00 09 mov %o1, %i1 4000a0dc: 7f ff f4 76 call 400072b4 <_Heap_Allocate> 4000a0e0: 90 12 23 ac or %o0, 0x3ac, %o0 } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 4000a0e4: d0 26 20 d8 st %o0, [ %i0 + 0xd8 ] the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 4000a0e8: 80 a0 00 08 cmp %g0, %o0 4000a0ec: b0 60 20 00 subx %g0, 0, %i0 the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 4000a0f0: b0 0e 40 18 and %i1, %i0, %i0 4000a0f4: 81 c7 e0 08 ret 4000a0f8: 81 e8 00 00 restore 4000a0fc <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 4000a0fc: 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 ) 4000a100: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 4000a104: 80 a0 60 00 cmp %g1, 0 4000a108: 02 80 00 08 be 4000a128 <_Thread_Stack_Free+0x2c> 4000a10c: 03 10 00 6a sethi %hi(0x4001a800), %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 ( _CPU_Table.stack_free_hook ) 4000a110: c2 00 63 98 ld [ %g1 + 0x398 ], %g1 ! 4001ab98 <_CPU_Table+0x24> 4000a114: 80 a0 60 00 cmp %g1, 0 4000a118: 22 80 00 06 be,a 4000a130 <_Thread_Stack_Free+0x34> 4000a11c: f2 06 20 d4 ld [ %i0 + 0xd4 ], %i1 (*_CPU_Table.stack_free_hook)( the_thread->Start.Initial_stack.area ); 4000a120: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a124: d0 06 20 d4 ld [ %i0 + 0xd4 ], %o0 <== NOT EXECUTED 4000a128: 81 c7 e0 08 ret <== NOT EXECUTED 4000a12c: 81 e8 00 00 restore <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4000a130: 31 10 00 6a sethi %hi(0x4001a800), %i0 4000a134: 7f ff f4 92 call 4000737c <_Heap_Free> 4000a138: 91 ee 23 ac restore %i0, 0x3ac, %o0 4000a13c: 01 00 00 00 nop 4000a274 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 4000a274: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 4000a278: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a27c: e0 00 60 3c ld [ %g1 + 0x3c ], %l0 ! 4001ac3c <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 4000a280: 7f ff de dd call 40001df4 4000a284: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 4000a288: b0 10 00 08 mov %o0, %i0 if ( !_Chain_Has_only_one_node( ready ) ) { 4000a28c: c4 04 40 00 ld [ %l1 ], %g2 4000a290: c2 04 60 08 ld [ %l1 + 8 ], %g1 4000a294: 80 a0 80 01 cmp %g2, %g1 4000a298: 12 80 00 0b bne 4000a2c4 <_Thread_Yield_processor+0x50> 4000a29c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 4000a2a0: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 ! 4001ac14 <_Thread_Heir> 4000a2a4: 80 a4 00 02 cmp %l0, %g2 4000a2a8: 02 80 00 05 be 4000a2bc <_Thread_Yield_processor+0x48> 4000a2ac: 01 00 00 00 nop _Context_Switch_necessary = TRUE; 4000a2b0: 84 10 20 01 mov 1, %g2 ! 1 4000a2b4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a2b8: c4 20 60 4c st %g2, [ %g1 + 0x4c ] ! 4001ac4c <_Context_Switch_necessary> _ISR_Enable( level ); 4000a2bc: 7f ff de d2 call 40001e04 4000a2c0: 81 e8 00 00 restore ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 4000a2c4: c6 04 00 00 ld [ %l0 ], %g3 previous = the_node->previous; 4000a2c8: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000a2cc: 82 04 60 04 add %l1, 4, %g1 Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; previous->next = next; 4000a2d0: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000a2d4: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000a2d8: 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; 4000a2dc: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 4000a2e0: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000a2e4: 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; 4000a2e8: e0 20 40 00 st %l0, [ %g1 ] _ISR_Disable( level ); if ( !_Chain_Has_only_one_node( ready ) ) { _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 4000a2ec: 7f ff de c6 call 40001e04 4000a2f0: 01 00 00 00 nop 4000a2f4: 7f ff de c0 call 40001df4 4000a2f8: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 4000a2fc: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000a300: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 ! 4001ac14 <_Thread_Heir> 4000a304: 80 a4 00 01 cmp %l0, %g1 4000a308: 32 bf ff eb bne,a 4000a2b4 <_Thread_Yield_processor+0x40> 4000a30c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 4000a310: c2 04 40 00 ld [ %l1 ], %g1 4000a314: 10 bf ff e7 b 4000a2b0 <_Thread_Yield_processor+0x3c> 4000a318: c2 20 a0 14 st %g1, [ %g2 + 0x14 ] 4000961c <_Thread_queue_Dequeue>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 4000961c: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 40009620: 80 a0 60 00 cmp %g1, 0 40009624: 12 80 00 05 bne 40009638 <_Thread_queue_Dequeue+0x1c> 40009628: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); 4000962c: 82 13 c0 00 mov %o7, %g1 40009630: 40 00 10 97 call 4000d88c <_Thread_queue_Dequeue_fifo> 40009634: 9e 10 40 00 mov %g1, %o7 Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 40009638: 02 80 00 04 be 40009648 <_Thread_queue_Dequeue+0x2c> 4000963c: 01 00 00 00 nop the_thread = NULL; break; } return( the_thread ); } 40009640: 81 c3 e0 08 retl <== NOT EXECUTED 40009644: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED switch ( the_thread_queue->discipline ) { case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_Dequeue_priority( the_thread_queue ); 40009648: 82 13 c0 00 mov %o7, %g1 4000964c: 40 00 00 03 call 40009658 <_Thread_queue_Dequeue_priority> 40009650: 9e 10 40 00 mov %g1, %o7 40009654: 01 00 00 00 nop 4000d88c <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 4000d88c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 4000d890: 7f ff d1 59 call 40001df4 4000d894: a0 10 00 18 mov %i0, %l0 4000d898: 84 10 00 08 mov %o0, %g2 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 4000d89c: f0 06 00 00 ld [ %i0 ], %i0 if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 4000d8a0: 82 04 20 04 add %l0, 4, %g1 4000d8a4: 80 a6 00 01 cmp %i0, %g1 4000d8a8: 22 80 00 1d be,a 4000d91c <_Thread_queue_Dequeue_fifo+0x90> 4000d8ac: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 4000d8b0: c2 06 00 00 ld [ %i0 ], %g1 the_chain->first = new_first; 4000d8b4: c2 24 00 00 st %g1, [ %l0 ] the_thread = (Thread_Control *) _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 4000d8b8: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 new_first->previous = _Chain_Head(the_chain); 4000d8bc: e0 20 60 04 st %l0, [ %g1 + 4 ] 4000d8c0: 80 a0 a0 02 cmp %g2, 2 4000d8c4: 02 80 00 0a be 4000d8ec <_Thread_queue_Dequeue_fifo+0x60> 4000d8c8: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 4000d8cc: 7f ff d1 4e call 40001e04 4000d8d0: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000d8d4: 90 10 00 18 mov %i0, %o0 4000d8d8: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000d8dc: 7f ff ed 99 call 40008f40 <_Thread_Clear_state> 4000d8e0: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 4000d8e4: 81 c7 e0 08 ret 4000d8e8: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 4000d8ec: 82 10 20 03 mov 3, %g1 4000d8f0: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000d8f4: 7f ff d1 44 call 40001e04 4000d8f8: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 4000d8fc: 7f ff f3 d7 call 4000a858 <_Watchdog_Remove> 4000d900: 90 06 20 48 add %i0, 0x48, %o0 4000d904: 90 10 00 18 mov %i0, %o0 4000d908: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000d90c: 7f ff ed 8d call 40008f40 <_Thread_Clear_state> 4000d910: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 4000d914: 81 c7 e0 08 ret 4000d918: 81 e8 00 00 restore #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 4000d91c: 80 a0 60 02 cmp %g1, 2 4000d920: 18 80 00 0c bgu 4000d950 <_Thread_queue_Dequeue_fifo+0xc4> 4000d924: 80 a0 60 03 cmp %g1, 3 4000d928: 80 a0 60 01 cmp %g1, 1 4000d92c: 0a 80 00 0b bcs 4000d958 <_Thread_queue_Dequeue_fifo+0xcc> 4000d930: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 4000d934: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 4000d938: 7f ff d1 33 call 40001e04 <== NOT EXECUTED 4000d93c: 01 00 00 00 nop <== NOT EXECUTED return _Thread_Executing; 4000d940: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000d944: f0 00 60 3c ld [ %g1 + 0x3c ], %i0 ! 4001ac3c <_Thread_Executing> <== NOT EXECUTED } return NULL; /* this is only to prevent warnings */ } 4000d948: 81 c7 e0 08 ret <== NOT EXECUTED 4000d94c: 81 e8 00 00 restore <== NOT EXECUTED #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 4000d950: 12 bf ff e5 bne 4000d8e4 <_Thread_queue_Dequeue_fifo+0x58> <== NOT EXECUTED 4000d954: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 4000d958: b0 10 20 00 clr %i0 4000d95c: 7f ff d1 2a call 40001e04 4000d960: 90 10 00 02 mov %g2, %o0 4000d964: 81 c7 e0 08 ret 4000d968: 81 e8 00 00 restore 40009658 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 40009658: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *new_second_node; Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); 4000965c: 7f ff e1 e6 call 40001df4 40009660: 01 00 00 00 nop 40009664: 9a 10 00 08 mov %o0, %o5 40009668: 86 10 20 00 clr %g3 4000966c: 88 10 20 00 clr %g4 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 40009670: d0 01 00 18 ld [ %g4 + %i0 ], %o0 for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { 40009674: 85 28 e0 02 sll %g3, 2, %g2 40009678: 83 28 e0 04 sll %g3, 4, %g1 4000967c: 82 20 40 02 sub %g1, %g2, %g1 40009680: 82 06 00 01 add %i0, %g1, %g1 40009684: 82 00 60 04 add %g1, 4, %g1 40009688: 80 a2 00 01 cmp %o0, %g1 4000968c: 12 80 00 50 bne 400097cc <_Thread_queue_Dequeue_priority+0x174> 40009690: 88 01 20 0c add %g4, 0xc, %g4 Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 40009694: 86 00 e0 01 inc %g3 Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 40009698: 80 a0 e0 04 cmp %g3, 4 4000969c: 32 bf ff f6 bne,a 40009674 <_Thread_queue_Dequeue_priority+0x1c> 400096a0: d0 01 00 18 ld [ %g4 + %i0 ], %o0 the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 400096a4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 400096a8: 80 a0 60 02 cmp %g1, 2 400096ac: 08 80 00 23 bleu 40009738 <_Thread_queue_Dequeue_priority+0xe0> 400096b0: 80 a0 60 01 cmp %g1, 1 400096b4: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 400096b8: 02 80 00 29 be 4000975c <_Thread_queue_Dequeue_priority+0x104> <== NOT EXECUTED 400096bc: b0 10 20 00 clr %i0 <== NOT EXECUTED return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; new_first_node = the_thread->Wait.Block2n.first; 400096c0: c6 06 20 38 ld [ %i0 + 0x38 ], %g3 new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 400096c4: 82 06 20 3c add %i0, 0x3c, %g1 _ISR_Enable( level ); return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; 400096c8: c0 26 20 44 clr [ %i0 + 0x44 ] new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 400096cc: 80 a0 c0 01 cmp %g3, %g1 dequeue: the_thread->Wait.queue = NULL; new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 400096d0: c4 06 00 00 ld [ %i0 ], %g2 previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 400096d4: 02 80 00 27 be 40009770 <_Thread_queue_Dequeue_priority+0x118> 400096d8: c2 06 20 04 ld [ %i0 + 4 ], %g1 last_node = the_thread->Wait.Block2n.last; 400096dc: d8 06 20 40 ld [ %i0 + 0x40 ], %o4 new_second_node = new_first_node->next; 400096e0: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 400096e4: c6 20 a0 04 st %g3, [ %g2 + 4 ] if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { last_node = the_thread->Wait.Block2n.last; new_second_node = new_first_node->next; previous_node->next = new_first_node; 400096e8: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 400096ec: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 400096f0: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 400096f4: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 400096f8: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 400096fc: 80 a0 80 01 cmp %g2, %g1 40009700: 12 80 00 2d bne 400097b4 <_Thread_queue_Dequeue_priority+0x15c> 40009704: 82 00 e0 38 add %g3, 0x38, %g1 } else { previous_node->next = next_node; next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 40009708: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000970c: 80 a0 60 02 cmp %g1, 2 40009710: 02 80 00 1e be 40009788 <_Thread_queue_Dequeue_priority+0x130> 40009714: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 40009718: 7f ff e1 bb call 40001e04 4000971c: 90 10 00 0d mov %o5, %o0 40009720: 90 10 00 18 mov %i0, %o0 40009724: 13 04 00 ff sethi %hi(0x1003fc00), %o1 40009728: 7f ff fe 06 call 40008f40 <_Thread_Clear_state> 4000972c: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 40009730: 81 c7 e0 08 ret 40009734: 81 e8 00 00 restore the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 40009738: 0a 80 00 09 bcs 4000975c <_Thread_queue_Dequeue_priority+0x104> 4000973c: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 40009740: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 40009744: 7f ff e1 b0 call 40001e04 <== NOT EXECUTED 40009748: 90 10 00 0d mov %o5, %o0 <== NOT EXECUTED return _Thread_Executing; 4000974c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009750: f0 00 60 3c ld [ %g1 + 0x3c ], %i0 ! 4001ac3c <_Thread_Executing> <== NOT EXECUTED 40009754: 81 c7 e0 08 ret <== NOT EXECUTED 40009758: 81 e8 00 00 restore <== NOT EXECUTED } switch ( the_thread_queue->sync_state ) { case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 4000975c: b0 10 20 00 clr %i0 40009760: 7f ff e1 a9 call 40001e04 40009764: 90 10 00 0d mov %o5, %o0 40009768: 81 c7 e0 08 ret 4000976c: 81 e8 00 00 restore last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; next_node->previous = previous_node; 40009770: 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; 40009774: c4 20 40 00 st %g2, [ %g1 ] next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 40009778: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000977c: 80 a0 60 02 cmp %g1, 2 40009780: 12 bf ff e6 bne 40009718 <_Thread_queue_Dequeue_priority+0xc0> 40009784: 82 10 20 03 mov 3, %g1 RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 40009788: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000978c: 7f ff e1 9e call 40001e04 40009790: 90 10 00 0d mov %o5, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 40009794: 40 00 04 31 call 4000a858 <_Watchdog_Remove> 40009798: 90 06 20 48 add %i0, 0x48, %o0 4000979c: 90 10 00 18 mov %i0, %o0 400097a0: 13 04 00 ff sethi %hi(0x1003fc00), %o1 400097a4: 7f ff fd e7 call 40008f40 <_Thread_Clear_state> 400097a8: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 400097ac: 81 c7 e0 08 ret 400097b0: 81 e8 00 00 restore new_first_node->next = next_node; new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ new_second_node->previous = 400097b4: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 400097b8: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] new_first_thread->Wait.Block2n.last = last_node; 400097bc: d8 20 e0 40 st %o4, [ %g3 + 0x40 ] last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 400097c0: 82 00 e0 3c add %g3, 0x3c, %g1 400097c4: 10 bf ff d1 b 40009708 <_Thread_queue_Dequeue_priority+0xb0> 400097c8: c2 23 00 00 st %g1, [ %o4 ] _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { the_thread = (Thread_Control *) 400097cc: 10 bf ff bd b 400096c0 <_Thread_queue_Dequeue_priority+0x68> 400097d0: b0 10 00 08 mov %o0, %i0 4000d96c <_Thread_queue_Enqueue_fifo>: void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000d96c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); 4000d970: 7f ff d1 21 call 40001df4 4000d974: 01 00 00 00 nop sync_state = the_thread_queue->sync_state; 4000d978: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 4000d97c: 80 a0 a0 02 cmp %g2, 2 4000d980: 02 80 00 22 be 4000da08 <_Thread_queue_Enqueue_fifo+0x9c> 4000d984: c0 26 20 30 clr [ %i0 + 0x30 ] 4000d988: 80 a0 a0 03 cmp %g2, 3 4000d98c: 02 80 00 11 be 4000d9d0 <_Thread_queue_Enqueue_fifo+0x64> 4000d990: 80 a0 a0 01 cmp %g2, 1 4000d994: 02 80 00 07 be 4000d9b0 <_Thread_queue_Enqueue_fifo+0x44> 4000d998: 82 06 20 04 add %i0, 4, %g1 4000d99c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000d9a0: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000d9a4: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000d9a8: 7f ff ed 66 call 40008f40 <_Thread_Clear_state> <== NOT EXECUTED 4000d9ac: 81 e8 00 00 restore <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000d9b0: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 4000d9b4: c4 06 20 08 ld [ %i0 + 8 ], %g2 the_chain->last = the_node; 4000d9b8: f2 26 20 08 st %i1, [ %i0 + 8 ] case THREAD_QUEUE_NOTHING_HAPPENED: _Chain_Append_unprotected( &the_thread_queue->Queues.Fifo, &the_thread->Object.Node ); the_thread->Wait.queue = the_thread_queue; 4000d9bc: f0 26 60 44 st %i0, [ %i1 + 0x44 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000d9c0: c4 26 60 04 st %g2, [ %i1 + 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; 4000d9c4: f2 20 80 00 st %i1, [ %g2 ] _ISR_Enable( level ); 4000d9c8: 7f ff d1 0f call 40001e04 4000d9cc: 91 e8 00 08 restore %g0, %o0, %o0 the_thread->Wait.queue = NULL; _ISR_Enable( level ); break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 4000d9d0: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 4000d9d4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000d9d8: 12 80 00 16 bne 4000da30 <_Thread_queue_Enqueue_fifo+0xc4> <== NOT EXECUTED 4000d9dc: 01 00 00 00 nop <== NOT EXECUTED 4000d9e0: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 4000d9e4: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 4000d9e8: 7f ff d1 07 call 40001e04 <== NOT EXECUTED 4000d9ec: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 4000d9f0: 7f ff f3 9a call 4000a858 <_Watchdog_Remove> <== NOT EXECUTED 4000d9f4: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 4000d9f8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000d9fc: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000da00: 7f ff ed 50 call 40008f40 <_Thread_Clear_state> <== NOT EXECUTED 4000da04: 81 e8 00 00 restore <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 4000da08: c4 06 60 44 ld [ %i1 + 0x44 ], %g2 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000da0c: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 4000da10: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED 4000da14: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 4000da18: 7f ff d0 fb call 40001e04 <== NOT EXECUTED 4000da1c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000da20: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000da24: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000da28: 7f ff ed 46 call 40008f40 <_Thread_Clear_state> <== NOT EXECUTED 4000da2c: 81 e8 00 00 restore <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); } else _ISR_Enable( level ); 4000da30: 7f ff d0 f5 call 40001e04 <== NOT EXECUTED 4000da34: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000da38: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000da3c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000da40: 7f ff ed 40 call 40008f40 <_Thread_Clear_state> <== NOT EXECUTED 4000da44: 81 e8 00 00 restore <== NOT EXECUTED 4000da48: 01 00 00 00 nop 40009858 <_Thread_queue_Enqueue_priority>: void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 40009858: 9d e3 bf 98 save %sp, -104, %sp States_Control block_state; Thread_queue_States sync_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 4000985c: 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); 40009860: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009864: 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); 40009868: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; 4000986c: c0 26 60 3c clr [ %i1 + 0x3c ] the_chain->last = _Chain_Head(the_chain); 40009870: c4 26 60 40 st %g2, [ %i1 + 0x40 ] void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 40009874: aa 10 00 18 mov %i0, %l5 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 ) ) 40009878: 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); 4000987c: 83 34 a0 06 srl %l2, 6, %g1 40009880: 12 80 00 40 bne 40009980 <_Thread_queue_Enqueue_priority+0x128> 40009884: e8 06 20 38 ld [ %i0 + 0x38 ], %l4 40009888: 85 28 60 04 sll %g1, 4, %g2 4000988c: 83 28 60 02 sll %g1, 2, %g1 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 40009890: ac 20 80 01 sub %g2, %g1, %l6 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40009894: 82 06 00 16 add %i0, %l6, %g1 40009898: 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 ); 4000989c: 7f ff e1 56 call 40001df4 400098a0: 01 00 00 00 nop 400098a4: b0 10 00 08 mov %o0, %i0 search_thread = (Thread_Control *) header->first; 400098a8: e0 05 40 16 ld [ %l5 + %l6 ], %l0 while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 400098ac: 80 a4 00 13 cmp %l0, %l3 400098b0: 02 80 00 24 be 40009940 <_Thread_queue_Enqueue_priority+0xe8> 400098b4: a2 10 3f ff mov -1, %l1 search_priority = search_thread->current_priority; 400098b8: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 400098bc: 80 a4 80 11 cmp %l2, %l1 400098c0: 28 80 00 21 bleu,a 40009944 <_Thread_queue_Enqueue_priority+0xec> 400098c4: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 400098c8: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 400098cc: 80 a4 c0 10 cmp %l3, %l0 400098d0: 32 80 00 19 bne,a 40009934 <_Thread_queue_Enqueue_priority+0xdc> 400098d4: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 400098d8: 10 80 00 1b b 40009944 <_Thread_queue_Enqueue_priority+0xec> 400098dc: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 400098e0: 7f ff e1 49 call 40001e04 400098e4: 90 10 00 18 mov %i0, %o0 400098e8: 7f ff e1 43 call 40001df4 400098ec: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 400098f0: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 400098f4: 80 8d 00 01 btst %l4, %g1 400098f8: 02 80 00 91 be 40009b3c <_Thread_queue_Enqueue_priority+0x2e4> 400098fc: 01 00 00 00 nop _ISR_Enable( level ); goto restart_forward_search; } search_thread = 40009900: 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 ) ) { 40009904: 80 a4 00 13 cmp %l0, %l3 40009908: 22 80 00 0f be,a 40009944 <_Thread_queue_Enqueue_priority+0xec> 4000990c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 search_priority = search_thread->current_priority; 40009910: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 40009914: 80 a4 80 11 cmp %l2, %l1 40009918: 28 80 00 0b bleu,a 40009944 <_Thread_queue_Enqueue_priority+0xec> 4000991c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 40009920: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 40009924: 80 a4 00 13 cmp %l0, %l3 40009928: 22 80 00 07 be,a 40009944 <_Thread_queue_Enqueue_priority+0xec> 4000992c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 40009930: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 40009934: 80 a4 80 11 cmp %l2, %l1 40009938: 18 bf ff ea bgu 400098e0 <_Thread_queue_Enqueue_priority+0x88> 4000993c: 01 00 00 00 nop } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 40009940: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 40009944: 80 a0 60 01 cmp %g1, 1 40009948: 02 80 00 63 be 40009ad4 <_Thread_queue_Enqueue_priority+0x27c> 4000994c: 80 a4 80 11 cmp %l2, %l1 return; synchronize: sync_state = the_thread_queue->sync_state; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; 40009950: c0 25 60 30 clr [ %l5 + 0x30 ] <== NOT EXECUTED switch ( sync_state ) { 40009954: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40009958: 02 80 00 54 be 40009aa8 <_Thread_queue_Enqueue_priority+0x250> <== NOT EXECUTED 4000995c: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED 40009960: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 40009964: 22 80 00 43 be,a 40009a70 <_Thread_queue_Enqueue_priority+0x218> <== NOT EXECUTED 40009968: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 4000996c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 40009970: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 40009974: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 40009978: 7f ff fd 72 call 40008f40 <_Thread_Clear_state> <== NOT EXECUTED 4000997c: 81 e8 00 00 restore <== NOT EXECUTED 40009980: 85 28 60 04 sll %g1, 4, %g2 40009984: 83 28 60 02 sll %g1, 2, %g1 restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 40009988: 82 20 80 01 sub %g2, %g1, %g1 4000998c: a6 00 40 18 add %g1, %i0, %l3 return; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); 40009990: 7f ff e1 19 call 40001df4 40009994: 01 00 00 00 nop 40009998: b0 10 00 08 mov %o0, %i0 search_thread = (Thread_Control *) header->last; 4000999c: e0 04 e0 08 ld [ %l3 + 8 ], %l0 while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 400099a0: 80 a4 00 13 cmp %l0, %l3 400099a4: 02 80 00 24 be 40009a34 <_Thread_queue_Enqueue_priority+0x1dc> 400099a8: a2 10 21 00 mov 0x100, %l1 search_priority = search_thread->current_priority; 400099ac: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority >= search_priority ) 400099b0: 80 a4 80 11 cmp %l2, %l1 400099b4: 3a 80 00 21 bcc,a 40009a38 <_Thread_queue_Enqueue_priority+0x1e0> 400099b8: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 400099bc: e0 04 20 04 ld [ %l0 + 4 ], %l0 if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 400099c0: 80 a4 c0 10 cmp %l3, %l0 400099c4: 32 80 00 19 bne,a 40009a28 <_Thread_queue_Enqueue_priority+0x1d0> 400099c8: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 400099cc: 10 80 00 1b b 40009a38 <_Thread_queue_Enqueue_priority+0x1e0> 400099d0: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 400099d4: 7f ff e1 0c call 40001e04 400099d8: 90 10 00 18 mov %i0, %o0 400099dc: 7f ff e1 06 call 40001df4 400099e0: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 400099e4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 400099e8: 80 8d 00 01 btst %l4, %g1 400099ec: 02 80 00 57 be 40009b48 <_Thread_queue_Enqueue_priority+0x2f0> 400099f0: 01 00 00 00 nop _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 400099f4: 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 ) ) { 400099f8: 80 a4 00 13 cmp %l0, %l3 400099fc: 22 80 00 0f be,a 40009a38 <_Thread_queue_Enqueue_priority+0x1e0> 40009a00: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 search_priority = search_thread->current_priority; 40009a04: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED if ( priority >= search_priority ) 40009a08: 80 a4 80 11 cmp %l2, %l1 <== NOT EXECUTED 40009a0c: 3a 80 00 0b bcc,a 40009a38 <_Thread_queue_Enqueue_priority+0x1e0> <== NOT EXECUTED 40009a10: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 <== NOT EXECUTED break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 40009a14: e0 04 20 04 ld [ %l0 + 4 ], %l0 <== NOT EXECUTED if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 40009a18: 80 a4 00 13 cmp %l0, %l3 <== NOT EXECUTED 40009a1c: 22 80 00 07 be,a 40009a38 <_Thread_queue_Enqueue_priority+0x1e0> <== NOT EXECUTED 40009a20: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 <== NOT EXECUTED break; search_priority = search_thread->current_priority; 40009a24: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED if ( priority >= search_priority ) 40009a28: 80 a4 80 11 cmp %l2, %l1 40009a2c: 0a bf ff ea bcs 400099d4 <_Thread_queue_Enqueue_priority+0x17c> 40009a30: 01 00 00 00 nop } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 40009a34: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 40009a38: 80 a0 60 01 cmp %g1, 1 40009a3c: 12 bf ff c6 bne 40009954 <_Thread_queue_Enqueue_priority+0xfc> 40009a40: c0 25 60 30 clr [ %l5 + 0x30 ] goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 40009a44: 80 a4 80 11 cmp %l2, %l1 40009a48: 22 80 00 35 be,a 40009b1c <_Thread_queue_Enqueue_priority+0x2c4> 40009a4c: 82 04 20 3c add %l0, 0x3c, %g1 goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 40009a50: c2 04 00 00 ld [ %l0 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 40009a54: 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; 40009a58: 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; 40009a5c: ea 26 60 44 st %l5, [ %i1 + 0x44 ] 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; 40009a60: f2 24 00 00 st %i1, [ %l0 ] next_node->previous = the_node; 40009a64: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 40009a68: 7f ff e0 e7 call 40001e04 40009a6c: 81 e8 00 00 restore the_thread->Wait.queue = NULL; _ISR_Enable( level ); break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 40009a70: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40009a74: 12 80 00 22 bne 40009afc <_Thread_queue_Enqueue_priority+0x2a4> <== NOT EXECUTED 40009a78: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 40009a7c: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 40009a80: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 40009a84: 7f ff e0 e0 call 40001e04 <== NOT EXECUTED 40009a88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 40009a8c: 40 00 03 73 call 4000a858 <_Watchdog_Remove> <== NOT EXECUTED 40009a90: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 40009a94: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 40009a98: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 40009a9c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 40009aa0: 7f ff fd 28 call 40008f40 <_Thread_Clear_state> <== NOT EXECUTED 40009aa4: 81 e8 00 00 restore <== NOT EXECUTED * This should never happen. All of this was dealt with above. */ break; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 40009aa8: c4 06 60 44 ld [ %i1 + 0x44 ], %g2 <== NOT EXECUTED the_thread->Wait.queue = NULL; 40009aac: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED * This should never happen. All of this was dealt with above. */ break; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 40009ab0: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED 40009ab4: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 40009ab8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009abc: 7f ff e0 d2 call 40001e04 <== NOT EXECUTED 40009ac0: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 40009ac4: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 40009ac8: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 40009acc: 7f ff fd 1d call 40008f40 <_Thread_Clear_state> <== NOT EXECUTED 40009ad0: 81 e8 00 00 restore <== NOT EXECUTED if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 40009ad4: 02 80 00 11 be 40009b18 <_Thread_queue_Enqueue_priority+0x2c0> 40009ad8: c0 25 60 30 clr [ %l5 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 40009adc: c2 04 20 04 ld [ %l0 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 40009ae0: e0 26 40 00 st %l0, [ %i1 ] the_node->previous = previous_node; 40009ae4: 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; 40009ae8: ea 26 60 44 st %l5, [ %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; 40009aec: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 40009af0: f2 24 20 04 st %i1, [ %l0 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 40009af4: 7f ff e0 c4 call 40001e04 40009af8: 81 e8 00 00 restore _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); } else _ISR_Enable( level ); 40009afc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009b00: 7f ff e0 c1 call 40001e04 <== NOT EXECUTED 40009b04: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 40009b08: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 40009b0c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 40009b10: 7f ff fd 0c call 40008f40 <_Thread_Clear_state> <== NOT EXECUTED 40009b14: 81 e8 00 00 restore <== NOT EXECUTED 40009b18: 82 04 20 3c add %l0, 0x3c, %g1 _ISR_Enable( level ); return; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 40009b1c: c4 00 60 04 ld [ %g1 + 4 ], %g2 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 40009b20: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = previous_node; 40009b24: 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; 40009b28: ea 26 60 44 st %l5, [ %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; 40009b2c: f2 20 80 00 st %i1, [ %g2 ] search_node->previous = the_node; 40009b30: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 40009b34: 7f ff e0 b4 call 40001e04 40009b38: 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 ); 40009b3c: 7f ff e0 b2 call 40001e04 <== NOT EXECUTED 40009b40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009b44: 30 bf ff 56 b,a 4000989c <_Thread_queue_Enqueue_priority+0x44> <== NOT EXECUTED if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 40009b48: 7f ff e0 af call 40001e04 <== NOT EXECUTED 40009b4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009b50: 30 bf ff 90 b,a 40009990 <_Thread_queue_Enqueue_priority+0x138> <== NOT EXECUTED 400097d4 <_Thread_queue_Enqueue_with_handler>: void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 400097d4: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; the_thread = _Thread_Executing; 400097d8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 400097dc: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 Thread_queue_Timeout_callout handler ) { Thread_Control *the_thread; the_thread = _Thread_Executing; 400097e0: e0 00 60 3c ld [ %g1 + 0x3c ], %l0 void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 400097e4: a2 10 00 18 mov %i0, %l1 else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 400097e8: 40 00 01 9b call 40009e54 <_Thread_Set_state> 400097ec: 90 10 00 10 mov %l0, %o0 /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 400097f0: 80 a6 60 00 cmp %i1, 0 400097f4: 32 80 00 0e bne,a 4000982c <_Thread_queue_Enqueue_with_handler+0x58> 400097f8: c2 04 20 08 ld [ %l0 + 8 ], %g1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 400097fc: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 40009800: 80 a0 60 00 cmp %g1, 0 40009804: 12 80 00 04 bne 40009814 <_Thread_queue_Enqueue_with_handler+0x40> 40009808: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); 4000980c: 40 00 10 58 call 4000d96c <_Thread_queue_Enqueue_fifo> 40009810: 93 e8 00 10 restore %g0, %l0, %o1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 40009814: 02 80 00 04 be 40009824 <_Thread_queue_Enqueue_with_handler+0x50> 40009818: 01 00 00 00 nop 4000981c: 81 c7 e0 08 ret <== NOT EXECUTED 40009820: 81 e8 00 00 restore <== NOT EXECUTED case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Enqueue_priority( the_thread_queue, the_thread ); 40009824: 40 00 00 0d call 40009858 <_Thread_queue_Enqueue_priority> 40009828: 93 e8 00 10 restore %g0, %l0, %o1 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 4000982c: f4 24 20 64 st %i2, [ %l0 + 0x64 ] the_watchdog->id = id; 40009830: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40009834: f2 24 20 54 st %i1, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40009838: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 4000983c: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40009840: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40009844: 92 04 20 48 add %l0, 0x48, %o1 40009848: 40 00 03 9a call 4000a6b0 <_Watchdog_Insert> 4000984c: 90 12 20 5c or %o0, 0x5c, %o0 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 40009850: 10 bf ff ec b 40009800 <_Thread_queue_Enqueue_with_handler+0x2c> 40009854: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 4000da4c <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 4000da4c: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4000da50: 80 a0 60 00 cmp %g1, 0 4000da54: 12 80 00 05 bne 4000da68 <_Thread_queue_Extract+0x1c> 4000da58: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 4000da5c: 82 13 c0 00 mov %o7, %g1 4000da60: 40 00 04 85 call 4000ec74 <_Thread_queue_Extract_fifo> 4000da64: 9e 10 40 00 mov %g1, %o7 void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 4000da68: 02 80 00 04 be 4000da78 <_Thread_queue_Extract+0x2c> 4000da6c: 94 10 20 00 clr %o2 4000da70: 81 c3 e0 08 retl <== NOT EXECUTED 4000da74: 01 00 00 00 nop <== NOT EXECUTED case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 4000da78: 82 13 c0 00 mov %o7, %g1 4000da7c: 40 00 00 03 call 4000da88 <_Thread_queue_Extract_priority_helper> 4000da80: 9e 10 40 00 mov %g1, %o7 4000da84: 01 00 00 00 nop 4000ec74 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000ec74: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 4000ec78: 7f ff cc 5f call 40001df4 4000ec7c: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 4000ec80: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 4000ec84: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000ec88: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000ec8c: 80 88 80 01 btst %g2, %g1 4000ec90: 02 80 00 19 be 4000ecf4 <_Thread_queue_Extract_fifo+0x80> 4000ec94: 01 00 00 00 nop ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 4000ec98: c2 06 40 00 ld [ %i1 ], %g1 previous = the_node->previous; 4000ec9c: 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 ) ) { 4000eca0: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 next->previous = previous; previous->next = next; 4000eca4: c2 20 80 00 st %g1, [ %g2 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000eca8: c4 20 60 04 st %g2, [ %g1 + 4 ] 4000ecac: 80 a0 e0 02 cmp %g3, 2 4000ecb0: 12 80 00 0c bne 4000ece0 <_Thread_queue_Extract_fifo+0x6c> 4000ecb4: c0 26 60 44 clr [ %i1 + 0x44 ] 4000ecb8: 82 10 20 03 mov 3, %g1 4000ecbc: c2 26 60 50 st %g1, [ %i1 + 0x50 ] _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000ecc0: 7f ff cc 51 call 40001e04 4000ecc4: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 4000ecc8: 7f ff ee e4 call 4000a858 <_Watchdog_Remove> 4000eccc: 90 06 60 48 add %i1, 0x48, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000ecd0: 33 04 00 ff sethi %hi(0x1003fc00), %i1 4000ecd4: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000ecd8: 7f ff e8 9a call 40008f40 <_Thread_Clear_state> 4000ecdc: 81 e8 00 00 restore _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); 4000ece0: 7f ff cc 49 call 40001e04 4000ece4: 33 04 00 ff sethi %hi(0x1003fc00), %i1 4000ece8: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000ecec: 7f ff e8 95 call 40008f40 <_Thread_Clear_state> 4000ecf0: 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 ); 4000ecf4: 7f ff cc 44 call 40001e04 <== NOT EXECUTED 4000ecf8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 4000ecfc: 01 00 00 00 nop 4000da88 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, boolean requeuing ) { 4000da88: 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 ); 4000da8c: 7f ff d0 da call 40001df4 4000da90: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 4000da94: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 4000da98: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000da9c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000daa0: 80 88 80 01 btst %g2, %g1 4000daa4: 02 80 00 29 be 4000db48 <_Thread_queue_Extract_priority_helper+0xc0> 4000daa8: 82 06 60 3c add %i1, 0x3c, %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 4000daac: 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; 4000dab0: c4 06 40 00 ld [ %i1 ], %g2 previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 4000dab4: 80 a0 c0 01 cmp %g3, %g1 4000dab8: 12 80 00 10 bne 4000daf8 <_Thread_queue_Extract_priority_helper+0x70> 4000dabc: c2 06 60 04 ld [ %i1 + 4 ], %g1 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; 4000dac0: 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; 4000dac4: c4 20 40 00 st %g2, [ %g1 ] /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 4000dac8: 80 a6 a0 00 cmp %i2, 0 4000dacc: 12 80 00 1d bne 4000db40 <_Thread_queue_Extract_priority_helper+0xb8> 4000dad0: 01 00 00 00 nop _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 4000dad4: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000dad8: 80 a0 60 02 cmp %g1, 2 4000dadc: 02 80 00 1d be 4000db50 <_Thread_queue_Extract_priority_helper+0xc8> 4000dae0: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 4000dae4: 7f ff d0 c8 call 40001e04 4000dae8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 4000daec: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000daf0: 7f ff ed 14 call 40008f40 <_Thread_Clear_state> 4000daf4: 81 e8 00 00 restore previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 4000daf8: da 06 60 40 ld [ %i1 + 0x40 ], %o5 new_second_node = new_first_node->next; 4000dafc: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 4000db00: 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; 4000db04: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 4000db08: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 4000db0c: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 4000db10: c4 06 60 38 ld [ %i1 + 0x38 ], %g2 4000db14: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 4000db18: 80 a0 80 01 cmp %g2, %g1 4000db1c: 02 bf ff ec be 4000dacc <_Thread_queue_Extract_priority_helper+0x44> 4000db20: 80 a6 a0 00 cmp %i2, 0 /* > two threads on 2-n */ new_second_node->previous = 4000db24: 82 00 e0 38 add %g3, 0x38, %g1 <== NOT EXECUTED 4000db28: c2 21 20 04 st %g1, [ %g4 + 4 ] <== NOT EXECUTED _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 4000db2c: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 4000db30: da 20 e0 40 st %o5, [ %g3 + 0x40 ] <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 4000db34: 82 00 e0 3c add %g3, 0x3c, %g1 <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 4000db38: 02 bf ff e7 be 4000dad4 <_Thread_queue_Extract_priority_helper+0x4c> <== NOT EXECUTED 4000db3c: c2 23 40 00 st %g1, [ %o5 ] <== NOT EXECUTED _ISR_Enable( level ); 4000db40: 7f ff d0 b1 call 40001e04 4000db44: 91 e8 00 08 restore %g0, %o0, %o0 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 ); 4000db48: 7f ff d0 af call 40001e04 <== NOT EXECUTED 4000db4c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 4000db50: 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 ); 4000db54: 7f ff d0 ac call 40001e04 4000db58: 33 04 00 ff sethi %hi(0x1003fc00), %i1 (void) _Watchdog_Remove( &the_thread->Timer ); 4000db5c: 7f ff f3 3f call 4000a858 <_Watchdog_Remove> 4000db60: 90 06 20 48 add %i0, 0x48, %o0 4000db64: b2 16 63 f8 or %i1, 0x3f8, %i1 4000db68: 7f ff ec f6 call 40008f40 <_Thread_Clear_state> 4000db6c: 81 e8 00 00 restore 4000db70: 01 00 00 00 nop 40009b54 <_Thread_queue_Extract_with_proxy>: */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 40009b54: 9d e3 bf 98 save %sp, -104, %sp States_Control state; Objects_Information *the_information; Objects_Thread_queue_Extract_callout proxy_extract_callout; state = the_thread->current_state; 40009b58: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 40009b5c: a0 10 00 18 mov %i0, %l0 Objects_Information *the_information; Objects_Thread_queue_Extract_callout proxy_extract_callout; state = the_thread->current_state; if ( _States_Is_waiting_on_thread_queue( state ) ) { 40009b60: 03 00 00 ef sethi %hi(0x3bc00), %g1 40009b64: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 40009b68: 80 88 80 01 btst %g2, %g1 40009b6c: 02 80 00 1e be 40009be4 <_Thread_queue_Extract_with_proxy+0x90> 40009b70: b0 10 20 00 clr %i0 if ( _States_Is_waiting_for_rpc_reply( state ) && 40009b74: 03 00 00 08 sethi %hi(0x2000), %g1 40009b78: 80 88 80 01 btst %g2, %g1 40009b7c: 22 80 00 17 be,a 40009bd8 <_Thread_queue_Extract_with_proxy+0x84> 40009b80: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 40009b84: 03 00 00 e7 sethi %hi(0x39c00), %g1 <== NOT EXECUTED 40009b88: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 39ee0 <== NOT EXECUTED 40009b8c: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 40009b90: 22 80 00 12 be,a 40009bd8 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 40009b94: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED _States_Is_locally_blocked( state ) ) { the_information = _Objects_Get_information( the_thread->Wait.id ); 40009b98: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED proxy_extract_callout = 40009b9c: 03 10 00 6a sethi %hi(0x4001a800), %g1 <== NOT EXECUTED 40009ba0: 85 30 e0 16 srl %g3, 0x16, %g2 <== NOT EXECUTED 40009ba4: 82 10 62 c0 or %g1, 0x2c0, %g1 <== NOT EXECUTED 40009ba8: 84 08 a0 1c and %g2, 0x1c, %g2 <== NOT EXECUTED 40009bac: c8 00 40 02 ld [ %g1 + %g2 ], %g4 <== NOT EXECUTED 40009bb0: 87 30 e0 1b srl %g3, 0x1b, %g3 <== NOT EXECUTED 40009bb4: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED 40009bb8: c2 01 00 03 ld [ %g4 + %g3 ], %g1 <== NOT EXECUTED 40009bbc: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 <== NOT EXECUTED (Objects_Thread_queue_Extract_callout) the_information->extract; if ( proxy_extract_callout ) 40009bc0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009bc4: 22 80 00 05 be,a 40009bd8 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 40009bc8: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED (*proxy_extract_callout)( the_thread ); 40009bcc: 9f c0 40 00 call %g1 <== NOT EXECUTED 40009bd0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 40009bd4: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED 40009bd8: 92 10 00 10 mov %l0, %o1 40009bdc: 40 00 0f 9c call 4000da4c <_Thread_queue_Extract> 40009be0: b0 10 20 01 mov 1, %i0 return TRUE; } return FALSE; } 40009be4: 81 c7 e0 08 ret 40009be8: 81 e8 00 00 restore 4000c3c8 <_Thread_queue_First>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 4000c3c8: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4000c3cc: 80 a0 60 00 cmp %g1, 0 4000c3d0: 12 80 00 05 bne 4000c3e4 <_Thread_queue_First+0x1c> 4000c3d4: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); 4000c3d8: 82 13 c0 00 mov %o7, %g1 4000c3dc: 40 00 10 43 call 400104e8 <_Thread_queue_First_fifo> 4000c3e0: 9e 10 40 00 mov %g1, %o7 Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 4000c3e4: 02 80 00 04 be 4000c3f4 <_Thread_queue_First+0x2c> 4000c3e8: 01 00 00 00 nop the_thread = NULL; break; } return the_thread; } 4000c3ec: 81 c3 e0 08 retl <== NOT EXECUTED 4000c3f0: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED switch ( the_thread_queue->discipline ) { case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_First_priority( the_thread_queue ); 4000c3f4: 82 13 c0 00 mov %o7, %g1 4000c3f8: 40 00 00 03 call 4000c404 <_Thread_queue_First_priority> 4000c3fc: 9e 10 40 00 mov %g1, %o7 4000c400: 01 00 00 00 nop 40009c0c <_Thread_queue_Initialize>: uint32_t timeout_status ) { uint32_t index; the_thread_queue->state = state; 40009c0c: d4 22 20 38 st %o2, [ %o0 + 0x38 ] the_thread_queue->discipline = the_discipline; the_thread_queue->timeout_status = timeout_status; 40009c10: d6 22 20 3c st %o3, [ %o0 + 0x3c ] the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; 40009c14: c0 22 20 30 clr [ %o0 + 0x30 ] switch ( the_discipline ) { 40009c18: 80 a2 60 00 cmp %o1, 0 40009c1c: 12 80 00 07 bne 40009c38 <_Thread_queue_Initialize+0x2c> 40009c20: d2 22 20 34 st %o1, [ %o0 + 0x34 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40009c24: 82 02 20 04 add %o0, 4, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009c28: d0 22 20 08 st %o0, [ %o0 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 40009c2c: c0 22 20 04 clr [ %o0 + 4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40009c30: 81 c3 e0 08 retl 40009c34: c2 22 00 00 st %g1, [ %o0 ] 40009c38: 80 a2 60 01 cmp %o1, 1 40009c3c: 02 80 00 04 be 40009c4c <_Thread_queue_Initialize+0x40> 40009c40: 82 02 20 04 add %o0, 4, %g1 40009c44: 81 c3 e0 08 retl <== NOT EXECUTED 40009c48: 01 00 00 00 nop <== NOT EXECUTED 40009c4c: 84 02 20 10 add %o0, 0x10, %g2 40009c50: c2 22 00 00 st %g1, [ %o0 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009c54: 82 02 20 0c add %o0, 0xc, %g1 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40009c58: c4 22 20 0c st %g2, [ %o0 + 0xc ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009c5c: c2 22 20 14 st %g1, [ %o0 + 0x14 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40009c60: 84 02 20 1c add %o0, 0x1c, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009c64: 82 02 20 18 add %o0, 0x18, %g1 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40009c68: c4 22 20 18 st %g2, [ %o0 + 0x18 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009c6c: c2 22 20 20 st %g1, [ %o0 + 0x20 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40009c70: 84 02 20 28 add %o0, 0x28, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009c74: 82 02 20 24 add %o0, 0x24, %g1 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 40009c78: c0 22 20 04 clr [ %o0 + 4 ] the_chain->last = _Chain_Head(the_chain); 40009c7c: d0 22 20 08 st %o0, [ %o0 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 40009c80: c0 22 20 10 clr [ %o0 + 0x10 ] 40009c84: c0 22 20 1c clr [ %o0 + 0x1c ] 40009c88: c0 22 20 28 clr [ %o0 + 0x28 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40009c8c: c4 22 20 24 st %g2, [ %o0 + 0x24 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009c90: 81 c3 e0 08 retl 40009c94: c2 22 20 2c st %g1, [ %o0 + 0x2c ] 40009c98 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 40009c98: 9d e3 bf 98 save %sp, -104, %sp /* just in case the thread really wasn't blocked here */ if ( !the_thread_queue ) { 40009c9c: 80 a6 20 00 cmp %i0, 0 40009ca0: 02 80 00 06 be 40009cb8 <_Thread_queue_Requeue+0x20> 40009ca4: 01 00 00 00 nop return; } switch ( the_thread_queue->discipline ) { 40009ca8: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 40009cac: 80 a4 20 01 cmp %l0, 1 40009cb0: 02 80 00 04 be 40009cc0 <_Thread_queue_Requeue+0x28> 40009cb4: 01 00 00 00 nop 40009cb8: 81 c7 e0 08 ret <== NOT EXECUTED 40009cbc: 81 e8 00 00 restore <== NOT EXECUTED break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; _ISR_Disable( level ); 40009cc0: 7f ff e0 4d call 40001df4 40009cc4: 01 00 00 00 nop 40009cc8: a2 10 00 08 mov %o0, %l1 if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 40009ccc: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 40009cd0: 03 00 00 ef sethi %hi(0x3bc00), %g1 40009cd4: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 40009cd8: 80 88 80 01 btst %g2, %g1 40009cdc: 12 80 00 04 bne 40009cec <_Thread_queue_Requeue+0x54> 40009ce0: 94 10 20 01 mov 1, %o2 _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); _Thread_queue_Enqueue_priority( tq, the_thread ); } _ISR_Enable( level ); 40009ce4: 7f ff e0 48 call 40001e04 <== NOT EXECUTED 40009ce8: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED ISR_Level level; _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 ); 40009cec: 90 10 00 18 mov %i0, %o0 40009cf0: 92 10 00 19 mov %i1, %o1 40009cf4: 40 00 0f 65 call 4000da88 <_Thread_queue_Extract_priority_helper> 40009cf8: e0 26 20 30 st %l0, [ %i0 + 0x30 ] _Thread_queue_Enqueue_priority( tq, the_thread ); 40009cfc: 90 10 00 18 mov %i0, %o0 40009d00: 7f ff fe d6 call 40009858 <_Thread_queue_Enqueue_priority> 40009d04: 92 10 00 19 mov %i1, %o1 } _ISR_Enable( level ); 40009d08: 7f ff e0 3f call 40001e04 40009d0c: 91 e8 00 11 restore %g0, %l1, %o0 40009d10: 01 00 00 00 nop 40009d14 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 40009d14: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 40009d18: 92 96 20 00 orcc %i0, 0, %o1 40009d1c: 12 80 00 1a bne 40009d84 <_Thread_queue_Timeout+0x70> 40009d20: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009d24: 31 10 00 6a sethi %hi(0x4001a800), %i0 <== NOT EXECUTED 40009d28: c2 06 23 60 ld [ %i0 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009d2c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009d30: c2 26 23 60 st %g1, [ %i0 + 0x360 ] <== NOT EXECUTED 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; 40009d34: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009d38: d2 00 60 3c ld [ %g1 + 0x3c ], %o1 ! 4001ac3c <_Thread_Executing> <== NOT EXECUTED 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; 40009d3c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED */ static inline void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 40009d40: d0 02 60 44 ld [ %o1 + 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_QUEUE_SYNCHRONIZED && 40009d44: c6 02 20 30 ld [ %o0 + 0x30 ], %g3 40009d48: 80 a0 e0 00 cmp %g3, 0 40009d4c: 02 80 00 06 be 40009d64 <_Thread_queue_Timeout+0x50> 40009d50: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009d54: c4 00 60 3c ld [ %g1 + 0x3c ], %g2 ! 4001ac3c <_Thread_Executing> <== NOT EXECUTED 40009d58: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED 40009d5c: 02 80 00 20 be 40009ddc <_Thread_queue_Timeout+0xc8> <== NOT EXECUTED 40009d60: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 40009d64: c2 02 20 3c ld [ %o0 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 40009d68: 40 00 0f 39 call 4000da4c <_Thread_queue_Extract> 40009d6c: c2 22 60 34 st %g1, [ %o1 + 0x34 ] */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 40009d70: c2 06 23 60 ld [ %i0 + 0x360 ], %g1 40009d74: 82 00 7f ff add %g1, -1, %g1 40009d78: c2 26 23 60 st %g1, [ %i0 + 0x360 ] 40009d7c: 81 c7 e0 08 ret 40009d80: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40009d84: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 40009d88: 80 a0 a0 04 cmp %g2, 4 40009d8c: 18 bf ff fc bgu 40009d7c <_Thread_queue_Timeout+0x68> 40009d90: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40009d94: 80 a0 60 01 cmp %g1, 1 40009d98: 12 bf ff f9 bne 40009d7c <_Thread_queue_Timeout+0x68> 40009d9c: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40009da0: 05 10 00 6a sethi %hi(0x4001a800), %g2 40009da4: 84 10 a2 c0 or %g2, 0x2c0, %g2 ! 4001aac0 <_Objects_Information_table> 40009da8: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40009dac: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40009db0: 80 a2 20 00 cmp %o0, 0 40009db4: 02 bf ff f2 be 40009d7c <_Thread_queue_Timeout+0x68> 40009db8: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40009dbc: 7f ff f7 ee call 40007d74 <_Objects_Get> 40009dc0: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40009dc4: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009dc8: 80 a0 60 00 cmp %g1, 0 40009dcc: 12 bf ff ec bne 40009d7c <_Thread_queue_Timeout+0x68> 40009dd0: 92 10 00 08 mov %o0, %o1 40009dd4: 10 bf ff db b 40009d40 <_Thread_queue_Timeout+0x2c> 40009dd8: 31 10 00 6a sethi %hi(0x4001a800), %i0 * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 40009ddc: 02 bf ff e5 be 40009d70 <_Thread_queue_Timeout+0x5c> <== NOT EXECUTED 40009de0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 40009de4: 10 bf ff e3 b 40009d70 <_Thread_queue_Timeout+0x5c> <== NOT EXECUTED 40009de8: c2 22 20 30 st %g1, [ %o0 + 0x30 ] <== NOT EXECUTED 400133dc <_Timer_Server_body>: */ Thread _Timer_Server_body( uint32_t ignored ) { 400133dc: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 400133e0: 03 10 00 d3 sethi %hi(0x40034c00), %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400133e4: 21 10 00 d3 sethi %hi(0x40034c00), %l0 400133e8: c6 00 62 04 ld [ %g1 + 0x204 ], %g3 _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 400133ec: 05 10 00 d3 sethi %hi(0x40034c00), %g2 400133f0: c2 04 20 80 ld [ %l0 + 0x80 ], %g1 400133f4: c8 00 a1 38 ld [ %g2 + 0x138 ], %g4 /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 400133f8: 05 10 00 d2 sethi %hi(0x40034800), %g2 400133fc: 82 00 60 01 inc %g1 40013400: c6 20 a3 8c st %g3, [ %g2 + 0x38c ] 40013404: c2 24 20 80 st %g1, [ %l0 + 0x80 ] _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 40013408: 05 10 00 d2 sethi %hi(0x40034800), %g2 4001340c: c8 20 a3 88 st %g4, [ %g2 + 0x388 ] ! 40034b88 <_Timer_Server_seconds_last_time> RTEMS_COMPILER_MEMORY_BARRIER(); 40013410: 03 10 00 d2 sethi %hi(0x40034800), %g1 40013414: 05 10 00 d3 sethi %hi(0x40034c00), %g2 40013418: ba 10 63 80 or %g1, 0x380, %i5 4001341c: 03 10 00 d2 sethi %hi(0x40034800), %g1 40013420: 39 10 00 d5 sethi %hi(0x40035400), %i4 /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 40013424: b4 10 a1 7c or %g2, 0x17c, %i2 40013428: ae 10 63 94 or %g1, 0x394, %l7 4001342c: 05 10 00 d2 sethi %hi(0x40034800), %g2 40013430: 03 10 00 d3 sethi %hi(0x40034c00), %g1 40013434: a6 10 a3 9c or %g2, 0x39c, %l3 40013438: b6 10 61 70 or %g1, 0x170, %i3 4001343c: 2d 10 00 d2 sethi %hi(0x40034800), %l6 40013440: 2b 10 00 d2 sethi %hi(0x40034800), %l5 40013444: a4 10 00 1c mov %i4, %l2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40013448: a2 10 00 10 mov %l0, %l1 4001344c: 10 80 00 18 b 400134ac <_Timer_Server_body+0xd0> 40013450: a8 10 00 13 mov %l3, %l4 _Timer_Server_reset_ticks_timer(); _Timer_Server_reset_seconds_timer(); 40013454: 80 a0 40 17 cmp %g1, %l7 40013458: 32 80 00 27 bne,a 400134f4 <_Timer_Server_body+0x118> 4001345c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED 40013460: c2 04 20 80 ld [ %l0 + 0x80 ], %g1 40013464: 82 00 7f ff add %g1, -1, %g1 40013468: c2 24 20 80 st %g1, [ %l0 + 0x80 ] 4001346c: c4 04 20 80 ld [ %l0 + 0x80 ], %g2 40013470: 80 a0 a0 00 cmp %g2, 0 40013474: 02 80 00 2b be 40013520 <_Timer_Server_body+0x144> 40013478: 01 00 00 00 nop * 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(); 4001347c: d0 04 a3 08 ld [ %l2 + 0x308 ], %o0 <== NOT EXECUTED 40013480: 40 00 14 3f call 4001857c <_Watchdog_Remove> 40013484: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_stop_seconds_timer(); 40013488: 40 00 14 3d call 4001857c <_Watchdog_Remove> 4001348c: 90 10 00 14 mov %l4, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40013490: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40013494: 82 00 60 01 inc %g1 40013498: c2 24 60 80 st %g1, [ %l1 + 0x80 ] * This ensures that the primary difference is that _ISR_Nest_level * is 0 for task-based timers and non-zero for the others. */ _Thread_Disable_dispatch(); _Timer_Server_process_ticks_chain(); 4001349c: 7f ff ff bf call 40013398 <_Timer_Server_process_ticks_chain> 400134a0: 01 00 00 00 nop _Timer_Server_process_seconds_chain(); 400134a4: 7f ff ff a2 call 4001332c <_Timer_Server_process_seconds_chain> 400134a8: 01 00 00 00 nop /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 400134ac: d0 07 23 08 ld [ %i4 + 0x308 ], %o0 400134b0: 40 00 10 de call 40017828 <_Thread_Set_state> 400134b4: 92 10 20 08 mov 8, %o1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 400134b8: c2 05 a3 7c ld [ %l6 + 0x37c ], %g1 _Timer_Server_reset_ticks_timer(); 400134bc: 80 a0 40 1d cmp %g1, %i5 400134c0: 22 bf ff e5 be,a 40013454 <_Timer_Server_body+0x78> 400134c4: c2 05 63 90 ld [ %l5 + 0x390 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400134c8: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 400134cc: d2 04 a3 08 ld [ %l2 + 0x308 ], %o1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400134d0: 90 10 00 1a mov %i2, %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400134d4: c2 22 60 54 st %g1, [ %o1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400134d8: 40 00 13 bf call 400183d4 <_Watchdog_Insert> 400134dc: 92 02 60 48 add %o1, 0x48, %o1 400134e0: c2 05 63 90 ld [ %l5 + 0x390 ], %g1 _Timer_Server_reset_seconds_timer(); 400134e4: 80 a0 40 17 cmp %g1, %l7 400134e8: 02 bf ff de be 40013460 <_Timer_Server_body+0x84> 400134ec: 01 00 00 00 nop Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400134f0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 400134f4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400134f8: c2 24 e0 0c st %g1, [ %l3 + 0xc ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 400134fc: 40 00 13 b6 call 400183d4 <_Watchdog_Insert> <== NOT EXECUTED 40013500: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40013504: c2 04 20 80 ld [ %l0 + 0x80 ], %g1 <== NOT EXECUTED 40013508: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001350c: c2 24 20 80 st %g1, [ %l0 + 0x80 ] <== NOT EXECUTED 40013510: c4 04 20 80 ld [ %l0 + 0x80 ], %g2 <== NOT EXECUTED 40013514: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40013518: 32 bf ff da bne,a 40013480 <_Timer_Server_body+0xa4> <== NOT EXECUTED 4001351c: d0 04 a3 08 ld [ %l2 + 0x308 ], %o0 <== NOT EXECUTED _Thread_Dispatch(); 40013520: 40 00 0d 4f call 40016a5c <_Thread_Dispatch> 40013524: 01 00 00 00 nop * 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(); 40013528: 10 bf ff d6 b 40013480 <_Timer_Server_body+0xa4> 4001352c: d0 04 a3 08 ld [ %l2 + 0x308 ], %o0 40013398 <_Timer_Server_process_ticks_chain>: void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 40013398: 03 10 00 d3 sethi %hi(0x40034c00), %g1 if ( snapshot >= _Timer_Server_ticks_last_time ) 4001339c: 07 10 00 d2 sethi %hi(0x40034800), %g3 void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 400133a0: c4 00 62 04 ld [ %g1 + 0x204 ], %g2 if ( snapshot >= _Timer_Server_ticks_last_time ) 400133a4: c2 00 e3 8c ld [ %g3 + 0x38c ], %g1 400133a8: 80 a0 80 01 cmp %g2, %g1 400133ac: 1a 80 00 04 bcc 400133bc <_Timer_Server_process_ticks_chain+0x24> 400133b0: 94 20 80 01 sub %g2, %g1, %o2 ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 400133b4: 82 38 00 01 xnor %g0, %g1, %g1 <== NOT EXECUTED 400133b8: 94 00 40 02 add %g1, %g2, %o2 <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 400133bc: 11 10 00 d2 sethi %hi(0x40034800), %o0 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; 400133c0: c4 20 e3 8c st %g2, [ %g3 + 0x38c ] _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 400133c4: 90 12 23 7c or %o0, 0x37c, %o0 400133c8: 92 10 20 00 clr %o1 400133cc: 82 13 c0 00 mov %o7, %g1 400133d0: 40 00 13 d0 call 40018310 <_Watchdog_Adjust> 400133d4: 9e 10 40 00 mov %g1, %o7 400133d8: 01 00 00 00 nop 4000c1ac <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 4000c1ac: 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; 4000c1b0: c2 06 40 00 ld [ %i1 ], %g1 /* * 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; 4000c1b4: de 06 20 04 ld [ %i0 + 4 ], %o7 right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4000c1b8: 96 10 00 01 mov %g1, %o3 4000c1bc: 95 38 60 1f sra %g1, 0x1f, %o2 4000c1c0: 83 30 60 1d srl %g1, 0x1d, %g1 4000c1c4: 9b 2a e0 03 sll %o3, 3, %o5 4000c1c8: 99 2a a0 03 sll %o2, 3, %o4 4000c1cc: 98 10 40 0c or %g1, %o4, %o4 4000c1d0: 83 33 60 1b srl %o5, 0x1b, %g1 4000c1d4: 85 2b 20 05 sll %o4, 5, %g2 4000c1d8: 87 2b 60 05 sll %o5, 5, %g3 4000c1dc: 84 10 40 02 or %g1, %g2, %g2 4000c1e0: 86 a0 c0 0d subcc %g3, %o5, %g3 4000c1e4: 83 30 e0 1a srl %g3, 0x1a, %g1 4000c1e8: 84 60 80 0c subx %g2, %o4, %g2 4000c1ec: 9b 28 e0 06 sll %g3, 6, %o5 4000c1f0: 99 28 a0 06 sll %g2, 6, %o4 4000c1f4: 9a a3 40 03 subcc %o5, %g3, %o5 4000c1f8: 98 10 40 0c or %g1, %o4, %o4 4000c1fc: 98 63 00 02 subx %o4, %g2, %o4 4000c200: 9a 83 40 0b addcc %o5, %o3, %o5 4000c204: 83 33 60 1e srl %o5, 0x1e, %g1 4000c208: 98 43 00 0a addx %o4, %o2, %o4 4000c20c: 87 2b 60 02 sll %o5, 2, %g3 4000c210: 85 2b 20 02 sll %o4, 2, %g2 4000c214: 9a 83 40 03 addcc %o5, %g3, %o5 4000c218: 84 10 40 02 or %g1, %g2, %g2 4000c21c: 83 33 60 1e srl %o5, 0x1e, %g1 4000c220: 98 43 00 02 addx %o4, %g2, %o4 4000c224: 87 2b 60 02 sll %o5, 2, %g3 4000c228: 85 2b 20 02 sll %o4, 2, %g2 4000c22c: 9a 83 40 03 addcc %o5, %g3, %o5 4000c230: 84 10 40 02 or %g1, %g2, %g2 4000c234: 83 33 60 1e srl %o5, 0x1e, %g1 4000c238: 98 43 00 02 addx %o4, %g2, %o4 4000c23c: 85 2b 20 02 sll %o4, 2, %g2 4000c240: 84 10 40 02 or %g1, %g2, %g2 right += rhs->tv_nsec; 4000c244: c2 06 60 04 ld [ %i1 + 4 ], %g1 * 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; 4000c248: 87 2b 60 02 sll %o5, 2, %g3 4000c24c: 9a 83 40 03 addcc %o5, %g3, %o5 right += rhs->tv_nsec; 4000c250: 95 38 60 1f sra %g1, 0x1f, %o2 * 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; 4000c254: 98 43 00 02 addx %o4, %g2, %o4 4000c258: 89 33 60 17 srl %o5, 0x17, %g4 4000c25c: 85 2b 20 09 sll %o4, 9, %g2 4000c260: 87 2b 60 09 sll %o5, 9, %g3 4000c264: 84 11 00 02 or %g4, %g2, %g2 right += rhs->tv_nsec; 4000c268: 96 80 c0 01 addcc %g3, %g1, %o3 4000c26c: 94 40 80 0a addx %g2, %o2, %o2 if ( right == 0 ) { 4000c270: 80 92 80 0b orcc %o2, %o3, %g0 4000c274: 12 80 00 06 bne 4000c28c <_Timespec_Divide+0xe0> 4000c278: f0 06 00 00 ld [ %i0 ], %i0 *ival_percentage = 0; 4000c27c: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED *fval_percentage = 0; 4000c280: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 4000c284: 81 c7 e0 08 ret <== NOT EXECUTED 4000c288: 81 e8 00 00 restore <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4000c28c: 83 36 20 1d srl %i0, 0x1d, %g1 4000c290: 9b 2e 20 03 sll %i0, 3, %o5 4000c294: 91 3e 20 1f sra %i0, 0x1f, %o0 4000c298: 99 2a 20 03 sll %o0, 3, %o4 4000c29c: 98 10 40 0c or %g1, %o4, %o4 4000c2a0: 83 33 60 1b srl %o5, 0x1b, %g1 4000c2a4: 85 2b 20 05 sll %o4, 5, %g2 4000c2a8: 87 2b 60 05 sll %o5, 5, %g3 4000c2ac: 84 10 40 02 or %g1, %g2, %g2 4000c2b0: 86 a0 c0 0d subcc %g3, %o5, %g3 4000c2b4: 83 30 e0 1a srl %g3, 0x1a, %g1 4000c2b8: 84 60 80 0c subx %g2, %o4, %g2 4000c2bc: 9b 28 e0 06 sll %g3, 6, %o5 4000c2c0: 99 28 a0 06 sll %g2, 6, %o4 4000c2c4: 9a a3 40 03 subcc %o5, %g3, %o5 4000c2c8: 98 10 40 0c or %g1, %o4, %o4 4000c2cc: 98 63 00 02 subx %o4, %g2, %o4 4000c2d0: 9a 83 40 18 addcc %o5, %i0, %o5 4000c2d4: 83 33 60 1e srl %o5, 0x1e, %g1 4000c2d8: 98 43 00 08 addx %o4, %o0, %o4 4000c2dc: 87 2b 60 02 sll %o5, 2, %g3 4000c2e0: 85 2b 20 02 sll %o4, 2, %g2 4000c2e4: 9a 83 40 03 addcc %o5, %g3, %o5 4000c2e8: 84 10 40 02 or %g1, %g2, %g2 4000c2ec: 83 33 60 1e srl %o5, 0x1e, %g1 4000c2f0: 98 43 00 02 addx %o4, %g2, %o4 4000c2f4: 87 2b 60 02 sll %o5, 2, %g3 4000c2f8: 85 2b 20 02 sll %o4, 2, %g2 4000c2fc: 9a 83 40 03 addcc %o5, %g3, %o5 4000c300: 84 10 40 02 or %g1, %g2, %g2 4000c304: 83 33 60 1e srl %o5, 0x1e, %g1 4000c308: 98 43 00 02 addx %o4, %g2, %o4 4000c30c: 87 2b 60 02 sll %o5, 2, %g3 4000c310: 85 2b 20 02 sll %o4, 2, %g2 4000c314: 9a 83 40 03 addcc %o5, %g3, %o5 4000c318: 84 10 40 02 or %g1, %g2, %g2 4000c31c: 83 33 60 17 srl %o5, 0x17, %g1 4000c320: 98 43 00 02 addx %o4, %g2, %o4 4000c324: 93 2b 60 09 sll %o5, 9, %o1 4000c328: 91 2b 20 09 sll %o4, 9, %o0 * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 4000c32c: 92 82 40 0f addcc %o1, %o7, %o1 /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4000c330: 90 10 40 08 or %g1, %o0, %o0 * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 4000c334: 83 32 60 1e srl %o1, 0x1e, %g1 4000c338: a1 3b e0 1f sra %o7, 0x1f, %l0 4000c33c: 87 2a 60 02 sll %o1, 2, %g3 4000c340: 90 42 00 10 addx %o0, %l0, %o0 4000c344: 85 2a 20 02 sll %o0, 2, %g2 4000c348: 84 10 40 02 or %g1, %g2, %g2 4000c34c: 83 30 e0 1b srl %g3, 0x1b, %g1 4000c350: 99 28 a0 05 sll %g2, 5, %o4 4000c354: 9b 28 e0 05 sll %g3, 5, %o5 4000c358: 98 10 40 0c or %g1, %o4, %o4 4000c35c: 9a a3 40 03 subcc %o5, %g3, %o5 4000c360: 98 63 00 02 subx %o4, %g2, %o4 4000c364: 9a 83 40 09 addcc %o5, %o1, %o5 4000c368: 83 33 60 1e srl %o5, 0x1e, %g1 4000c36c: 98 43 00 08 addx %o4, %o0, %o4 4000c370: 87 2b 60 02 sll %o5, 2, %g3 4000c374: 85 2b 20 02 sll %o4, 2, %g2 4000c378: 9a 83 40 03 addcc %o5, %g3, %o5 4000c37c: 84 10 40 02 or %g1, %g2, %g2 4000c380: 83 33 60 1e srl %o5, 0x1e, %g1 4000c384: 87 2b 60 02 sll %o5, 2, %g3 4000c388: 98 43 00 02 addx %o4, %g2, %o4 4000c38c: 9a 83 40 03 addcc %o5, %g3, %o5 4000c390: 85 2b 20 02 sll %o4, 2, %g2 4000c394: 84 10 40 02 or %g1, %g2, %g2 4000c398: 83 33 60 1b srl %o5, 0x1b, %g1 4000c39c: 98 43 00 02 addx %o4, %g2, %o4 4000c3a0: 93 2b 60 05 sll %o5, 5, %o1 4000c3a4: 91 2b 20 05 sll %o4, 5, %o0 4000c3a8: 40 00 36 56 call 40019d00 <__udivdi3> 4000c3ac: 90 10 40 08 or %g1, %o0, %o0 *ival_percentage = answer / 1000; 4000c3b0: 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; 4000c3b4: a0 10 00 08 mov %o0, %l0 4000c3b8: a2 10 00 09 mov %o1, %l1 *ival_percentage = answer / 1000; 4000c3bc: 96 10 23 e8 mov 0x3e8, %o3 4000c3c0: 40 00 36 50 call 40019d00 <__udivdi3> 4000c3c4: 90 10 00 10 mov %l0, %o0 *fval_percentage = answer % 1000; 4000c3c8: 90 10 00 10 mov %l0, %o0 * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 4000c3cc: d2 26 80 00 st %o1, [ %i2 ] *fval_percentage = answer % 1000; 4000c3d0: 94 10 20 00 clr %o2 4000c3d4: 92 10 00 11 mov %l1, %o1 4000c3d8: 40 00 37 29 call 4001a07c <__umoddi3> 4000c3dc: 96 10 23 e8 mov 0x3e8, %o3 4000c3e0: d2 26 c0 00 st %o1, [ %i3 ] 4000c3e4: 81 c7 e0 08 ret 4000c3e8: 81 e8 00 00 restore 4000a4c8 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, boolean is_internal, uint32_t the_error ) { 4000a4c8: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 4000a4cc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a4d0: 82 10 61 e4 or %g1, 0x1e4, %g1 ! 4001ade4 <_User_extensions_List> 4000a4d4: e0 00 60 08 ld [ %g1 + 8 ], %l0 !_Chain_Is_head( &_User_extensions_List, the_node ) ; 4000a4d8: 80 a4 00 01 cmp %l0, %g1 4000a4dc: 02 80 00 0d be 4000a510 <_User_extensions_Fatal+0x48> 4000a4e0: 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 ) 4000a4e4: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 4000a4e8: 80 a0 60 00 cmp %g1, 0 4000a4ec: 02 80 00 05 be 4000a500 <_User_extensions_Fatal+0x38> 4000a4f0: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 4000a4f4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000a4f8: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a4fc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 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 ) { 4000a500: 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 ) ; 4000a504: 80 a4 00 11 cmp %l0, %l1 4000a508: 32 bf ff f8 bne,a 4000a4e8 <_User_extensions_Fatal+0x20> 4000a50c: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 4000a510: 81 c7 e0 08 ret 4000a514: 81 e8 00 00 restore 40011770 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 40011770: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 40011774: 40 00 14 87 call 40016990 <_Chain_Extract> <== NOT EXECUTED 40011778: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 4001177c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED 40011780: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40011784: 02 80 00 04 be 40011794 <_User_extensions_Remove_set+0x24> <== NOT EXECUTED 40011788: 01 00 00 00 nop <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 4001178c: 40 00 14 81 call 40016990 <_Chain_Extract> <== NOT EXECUTED 40011790: 91 ee 20 08 restore %i0, 8, %o0 <== NOT EXECUTED 40011794: 81 c7 e0 08 ret <== NOT EXECUTED 40011798: 81 e8 00 00 restore <== NOT EXECUTED 4000a564 <_User_extensions_Thread_create>: */ boolean _User_extensions_Thread_create ( Thread_Control *the_thread ) { 4000a564: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; boolean status; for ( the_node = _User_extensions_List.first ; 4000a568: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a56c: e0 00 61 e4 ld [ %g1 + 0x1e4 ], %l0 ! 4001ade4 <_User_extensions_List> 4000a570: 82 10 61 e4 or %g1, 0x1e4, %g1 4000a574: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 4000a578: 80 a4 00 11 cmp %l0, %l1 4000a57c: 02 80 00 0f be 4000a5b8 <_User_extensions_Thread_create+0x54> 4000a580: 25 10 00 6b sethi %hi(0x4001ac00), %l2 the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 4000a584: c2 04 20 14 ld [ %l0 + 0x14 ], %g1 4000a588: 80 a0 60 00 cmp %g1, 0 4000a58c: 02 80 00 07 be 4000a5a8 <_User_extensions_Thread_create+0x44> 4000a590: 92 10 00 18 mov %i0, %o1 status = (*the_extension->Callouts.thread_create)( 4000a594: 9f c0 40 00 call %g1 4000a598: d0 04 a0 3c ld [ %l2 + 0x3c ], %o0 _Thread_Executing, the_thread ); if ( !status ) 4000a59c: 80 a2 20 00 cmp %o0, 0 4000a5a0: 02 80 00 08 be 4000a5c0 <_User_extensions_Thread_create+0x5c> 4000a5a4: 01 00 00 00 nop User_extensions_Control *the_extension; boolean status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 4000a5a8: e0 04 00 00 ld [ %l0 ], %l0 Chain_Node *the_node; User_extensions_Control *the_extension; boolean status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 4000a5ac: 80 a4 00 11 cmp %l0, %l1 4000a5b0: 32 bf ff f6 bne,a 4000a588 <_User_extensions_Thread_create+0x24> 4000a5b4: c2 04 20 14 ld [ %l0 + 0x14 ], %g1 return FALSE; } } return TRUE; } 4000a5b8: 81 c7 e0 08 ret 4000a5bc: 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 ) 4000a5c0: 81 c7 e0 08 ret <== NOT EXECUTED 4000a5c4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 4000a6b0 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 4000a6b0: 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; 4000a6b4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 4000a6b8: 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; 4000a6bc: e6 00 60 24 ld [ %g1 + 0x24 ], %l3 _ISR_Disable( level ); 4000a6c0: 7f ff dd cd call 40001df4 4000a6c4: 01 00 00 00 nop 4000a6c8: 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 ) { 4000a6cc: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000a6d0: 80 a0 60 00 cmp %g1, 0 4000a6d4: 12 80 00 49 bne 4000a7f8 <_Watchdog_Insert+0x148> 4000a6d8: 01 00 00 00 nop _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 4000a6dc: 2b 10 00 6b sethi %hi(0x4001ac00), %l5 4000a6e0: c2 05 60 e0 ld [ %l5 + 0xe0 ], %g1 ! 4001ace0 <_Watchdog_Sync_count> if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 4000a6e4: 84 10 20 01 mov 1, %g2 _Watchdog_Sync_count++; 4000a6e8: 82 00 60 01 inc %g1 4000a6ec: 29 10 00 6b sethi %hi(0x4001ac00), %l4 if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 4000a6f0: c4 26 60 08 st %g2, [ %i1 + 8 ] _Watchdog_Sync_count++; 4000a6f4: c2 25 60 e0 st %g1, [ %l5 + 0xe0 ] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 4000a6f8: ae 10 00 14 mov %l4, %l7 the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 4000a6fc: 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 ; 4000a700: e2 05 80 00 ld [ %l6 ], %l1 ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 4000a704: 80 a4 a0 00 cmp %l2, 0 4000a708: 02 80 00 2b be 4000a7b4 <_Watchdog_Insert+0x104> 4000a70c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 4000a710: c2 04 40 00 ld [ %l1 ], %g1 4000a714: 80 a0 60 00 cmp %g1, 0 4000a718: 02 80 00 27 be 4000a7b4 <_Watchdog_Insert+0x104> 4000a71c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 break; if ( delta_interval < after->delta_interval ) { 4000a720: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 4000a724: 80 a4 80 10 cmp %l2, %l0 4000a728: 1a 80 00 13 bcc 4000a774 <_Watchdog_Insert+0xc4> 4000a72c: 01 00 00 00 nop after->delta_interval -= delta_interval; 4000a730: 10 80 00 1f b 4000a7ac <_Watchdog_Insert+0xfc> 4000a734: a0 24 00 12 sub %l0, %l2, %l0 if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 4000a738: c2 05 20 38 ld [ %l4 + 0x38 ], %g1 4000a73c: 80 a4 c0 01 cmp %l3, %g1 4000a740: 0a 80 00 30 bcs 4000a800 <_Watchdog_Insert+0x150> 4000a744: 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 ) ) 4000a748: a4 a4 80 10 subcc %l2, %l0, %l2 4000a74c: 02 80 00 19 be 4000a7b0 <_Watchdog_Insert+0x100> 4000a750: e2 04 40 00 ld [ %l1 ], %l1 4000a754: c2 04 40 00 ld [ %l1 ], %g1 4000a758: 80 a0 60 00 cmp %g1, 0 4000a75c: 02 80 00 16 be 4000a7b4 <_Watchdog_Insert+0x104> 4000a760: 03 10 00 6b sethi %hi(0x4001ac00), %g1 break; if ( delta_interval < after->delta_interval ) { 4000a764: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 4000a768: 80 a4 00 12 cmp %l0, %l2 4000a76c: 38 80 00 10 bgu,a 4000a7ac <_Watchdog_Insert+0xfc> 4000a770: a0 24 00 12 sub %l0, %l2, %l0 * 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 ); 4000a774: 7f ff dd a4 call 40001e04 4000a778: 90 10 00 18 mov %i0, %o0 4000a77c: 7f ff dd 9e call 40001df4 4000a780: 01 00 00 00 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 4000a784: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000a788: 80 a0 60 01 cmp %g1, 1 4000a78c: 02 bf ff eb be 4000a738 <_Watchdog_Insert+0x88> 4000a790: 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; 4000a794: e6 25 20 38 st %l3, [ %l4 + 0x38 ] <== NOT EXECUTED _Watchdog_Sync_count--; 4000a798: c2 05 60 e0 ld [ %l5 + 0xe0 ], %g1 <== NOT EXECUTED 4000a79c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000a7a0: c2 25 60 e0 st %g1, [ %l5 + 0xe0 ] <== NOT EXECUTED _ISR_Enable( level ); 4000a7a4: 7f ff dd 98 call 40001e04 <== NOT EXECUTED 4000a7a8: 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; 4000a7ac: e0 24 60 10 st %l0, [ %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; 4000a7b0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a7b4: c6 00 60 e4 ld [ %g1 + 0xe4 ], %g3 ! 4001ace4 <_Watchdog_Ticks_since_boot> _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 4000a7b8: c4 04 60 04 ld [ %l1 + 4 ], %g2 the_watchdog->start_time = _Watchdog_Ticks_since_boot; 4000a7bc: c6 26 60 14 st %g3, [ %i1 + 0x14 ] } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 4000a7c0: e4 26 60 10 st %l2, [ %i1 + 0x10 ] RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 4000a7c4: 82 10 20 02 mov 2, %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 4000a7c8: 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; 4000a7cc: e6 25 20 38 st %l3, [ %l4 + 0x38 ] 4000a7d0: c2 26 60 08 st %g1, [ %i1 + 8 ] _Watchdog_Sync_count--; 4000a7d4: c2 05 60 e0 ld [ %l5 + 0xe0 ], %g1 after_node->next = the_node; 4000a7d8: f2 20 80 00 st %i1, [ %g2 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 4000a7dc: c4 26 60 04 st %g2, [ %i1 + 4 ] 4000a7e0: 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; 4000a7e4: 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; 4000a7e8: c8 26 40 00 st %g4, [ %i1 ] 4000a7ec: c2 25 60 e0 st %g1, [ %l5 + 0xe0 ] _ISR_Enable( level ); 4000a7f0: 7f ff dd 85 call 40001e04 4000a7f4: 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 ); 4000a7f8: 7f ff dd 83 call 40001e04 <== NOT EXECUTED 4000a7fc: 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; 4000a800: e6 25 e0 38 st %l3, [ %l7 + 0x38 ] the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 4000a804: 10 bf ff bf b 4000a700 <_Watchdog_Insert+0x50> 4000a808: e4 06 60 0c ld [ %i1 + 0xc ], %l2 4000b628 <_Watchdog_Insert_ticks_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 4000b628: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; (void) _Watchdog_Remove( timer ); 4000b62c: 40 00 18 b1 call 400118f0 <_Watchdog_Remove> 4000b630: 90 10 00 18 mov %i0, %o0 _ISR_Disable( level ); 4000b634: 7f ff ec 96 call 4000688c 4000b638: 01 00 00 00 nop 4000b63c: 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 ) { 4000b640: c2 06 20 08 ld [ %i0 + 8 ], %g1 4000b644: 80 a0 60 00 cmp %g1, 0 4000b648: 22 80 00 06 be,a 4000b660 <_Watchdog_Insert_ticks_helper+0x38> 4000b64c: f6 26 20 1c st %i3, [ %i0 + 0x1c ] _ISR_Enable( level ); 4000b650: 7f ff ec 93 call 4000689c <== NOT EXECUTED 4000b654: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000b658: 81 c7 e0 08 ret <== NOT EXECUTED 4000b65c: 81 e8 00 00 restore <== NOT EXECUTED void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 4000b660: f4 26 20 20 st %i2, [ %i0 + 0x20 ] the_watchdog->user_data = user_data; 4000b664: f8 26 20 24 st %i4, [ %i0 + 0x24 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000b668: f2 26 20 0c st %i1, [ %i0 + 0xc ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4000b66c: c0 26 20 08 clr [ %i0 + 8 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4000b670: 92 10 00 18 mov %i0, %o1 4000b674: 11 10 00 98 sethi %hi(0x40026000), %o0 4000b678: 40 00 18 34 call 40011748 <_Watchdog_Insert> 4000b67c: 90 12 20 fc or %o0, 0xfc, %o0 ! 400260fc <_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 ); 4000b680: b0 10 20 01 mov 1, %i0 4000b684: 7f ff ec 86 call 4000689c 4000b688: 90 10 00 10 mov %l0, %o0 return TRUE; } 4000b68c: 81 c7 e0 08 ret 4000b690: 81 e8 00 00 restore 4000a858 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 4000a858: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 4000a85c: 7f ff dd 66 call 40001df4 4000a860: a0 10 00 18 mov %i0, %l0 previous_state = the_watchdog->state; 4000a864: f0 06 20 08 ld [ %i0 + 8 ], %i0 switch ( previous_state ) { 4000a868: 80 a6 20 01 cmp %i0, 1 4000a86c: 02 80 00 2a be 4000a914 <_Watchdog_Remove+0xbc> 4000a870: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a874: 1a 80 00 09 bcc 4000a898 <_Watchdog_Remove+0x40> 4000a878: 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; 4000a87c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a880: c4 00 60 e4 ld [ %g1 + 0xe4 ], %g2 ! 4001ace4 <_Watchdog_Ticks_since_boot> 4000a884: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 4000a888: 7f ff dd 5f call 40001e04 4000a88c: 01 00 00 00 nop return( previous_state ); } 4000a890: 81 c7 e0 08 ret 4000a894: 81 e8 00 00 restore Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 4000a898: 18 bf ff fa bgu 4000a880 <_Watchdog_Remove+0x28> 4000a89c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 4000a8a0: c8 04 00 00 ld [ %l0 ], %g4 break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 4000a8a4: c0 24 20 08 clr [ %l0 + 8 ] next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 4000a8a8: c2 01 00 00 ld [ %g4 ], %g1 4000a8ac: 80 a0 60 00 cmp %g1, 0 4000a8b0: 02 80 00 07 be 4000a8cc <_Watchdog_Remove+0x74> 4000a8b4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 next_watchdog->delta_interval += the_watchdog->delta_interval; 4000a8b8: c2 01 20 10 ld [ %g4 + 0x10 ], %g1 4000a8bc: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 4000a8c0: 82 00 40 02 add %g1, %g2, %g1 4000a8c4: c2 21 20 10 st %g1, [ %g4 + 0x10 ] if ( _Watchdog_Sync_count ) 4000a8c8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a8cc: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 4001ace0 <_Watchdog_Sync_count> 4000a8d0: 80 a0 a0 00 cmp %g2, 0 4000a8d4: 22 80 00 07 be,a 4000a8f0 <_Watchdog_Remove+0x98> 4000a8d8: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Watchdog_Sync_level = _ISR_Nest_level; 4000a8dc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000a8e0: c6 00 60 24 ld [ %g1 + 0x24 ], %g3 ! 4001ac24 <_ISR_Nest_level> <== NOT EXECUTED 4000a8e4: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 4000a8e8: c6 20 a0 38 st %g3, [ %g2 + 0x38 ] ! 4001ac38 <_Watchdog_Sync_level> <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 4000a8ec: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 4000a8f0: c8 20 40 00 st %g4, [ %g1 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000a8f4: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 4000a8f8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a8fc: c4 00 60 e4 ld [ %g1 + 0xe4 ], %g2 ! 4001ace4 <_Watchdog_Ticks_since_boot> 4000a900: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 4000a904: 7f ff dd 40 call 40001e04 4000a908: 01 00 00 00 nop return( previous_state ); } 4000a90c: 81 c7 e0 08 ret 4000a910: 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; 4000a914: c4 00 60 e4 ld [ %g1 + 0xe4 ], %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; 4000a918: 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; 4000a91c: c4 24 20 18 st %g2, [ %l0 + 0x18 ] <== NOT EXECUTED _ISR_Enable( level ); 4000a920: 7f ff dd 39 call 40001e04 <== NOT EXECUTED 4000a924: 01 00 00 00 nop <== NOT EXECUTED return( previous_state ); } 4000a928: 81 c7 e0 08 ret <== NOT EXECUTED 4000a92c: 81 e8 00 00 restore <== NOT EXECUTED 4000a9dc <_Workspace_Allocate_or_fatal_error>: */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 4000a9dc: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 4000a9e0: 11 10 00 6a sethi %hi(0x4001a800), %o0 4000a9e4: 92 10 00 18 mov %i0, %o1 4000a9e8: 7f ff f2 33 call 400072b4 <_Heap_Allocate> 4000a9ec: 90 12 23 ac or %o0, 0x3ac, %o0 void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 4000a9f0: b0 92 20 00 orcc %o0, 0, %i0 4000a9f4: 12 80 00 04 bne 4000aa04 <_Workspace_Allocate_or_fatal_error+0x28> 4000a9f8: 92 10 20 01 mov 1, %o1 _Internal_error_Occurred( 4000a9fc: 7f ff f3 60 call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 4000aa00: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 4000aa04: 81 c7 e0 08 ret 4000aa08: 81 e8 00 00 restore 4000aa0c <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 4000aa0c: 9d e3 bf 98 save %sp, -104, %sp uint32_t *zero_out_array; uint32_t index; uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 4000aa10: 80 a6 20 00 cmp %i0, 0 4000aa14: 02 80 00 1d be 4000aa88 <_Workspace_Handler_initialization+0x7c> 4000aa18: 80 8e 20 07 btst 7, %i0 4000aa1c: 12 80 00 1c bne 4000aa8c <_Workspace_Handler_initialization+0x80> 4000aa20: 90 10 20 00 clr %o0 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { 4000aa24: 03 10 00 6a sethi %hi(0x4001a800), %g1 4000aa28: c4 00 63 84 ld [ %g1 + 0x384 ], %g2 ! 4001ab84 <_CPU_Table+0x10> 4000aa2c: 80 a0 a0 00 cmp %g2, 0 4000aa30: 02 80 00 0c be 4000aa60 <_Workspace_Handler_initialization+0x54> 4000aa34: 92 10 00 18 mov %i0, %o1 for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; 4000aa38: 87 36 60 02 srl %i1, 2, %g3 <== NOT EXECUTED 4000aa3c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000aa40: 02 80 00 08 be 4000aa60 <_Workspace_Handler_initialization+0x54> <== NOT EXECUTED 4000aa44: 84 10 20 00 clr %g2 <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; 4000aa48: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; index++ ) 4000aa4c: 84 00 a0 01 inc %g2 <== NOT EXECUTED INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; 4000aa50: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED 4000aa54: 12 bf ff fd bne 4000aa48 <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED 4000aa58: c0 20 40 18 clr [ %g1 + %i0 ] <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 4000aa5c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000aa60: 94 10 00 19 mov %i1, %o2 4000aa64: 11 10 00 6a sethi %hi(0x4001a800), %o0 4000aa68: 96 10 20 08 mov 8, %o3 4000aa6c: 7f ff f2 f7 call 40007648 <_Heap_Initialize> 4000aa70: 90 12 23 ac or %o0, 0x3ac, %o0 starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 4000aa74: 80 a2 20 00 cmp %o0, 0 4000aa78: 02 80 00 0a be 4000aaa0 <_Workspace_Handler_initialization+0x94> 4000aa7c: b0 10 20 00 clr %i0 4000aa80: 81 c7 e0 08 ret 4000aa84: 81 e8 00 00 restore uint32_t *zero_out_array; uint32_t index; uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) _Internal_error_Occurred( 4000aa88: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000aa8c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 4000aa90: 7f ff f3 3b call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 4000aa94: 94 10 20 02 mov 2, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { 4000aa98: 10 bf ff e4 b 4000aa28 <_Workspace_Handler_initialization+0x1c> <== NOT EXECUTED 4000aa9c: 03 10 00 6a sethi %hi(0x4001a800), %g1 <== NOT EXECUTED size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 4000aaa0: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED 4000aaa4: 7f ff f3 36 call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 4000aaa8: 95 e8 20 03 restore %g0, 3, %o2 <== NOT EXECUTED 4000aaac: 01 00 00 00 nop 40025d9c <_kill_r>: struct _reent *ptr, pid_t pid, int sig ) { return kill( pid, sig ); 40025d9c: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 40025da0: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 40025da4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40025da8: 7f ff ff f8 call 40025d88 <== NOT EXECUTED 40025dac: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 40025db0: 01 00 00 00 nop 400062d4 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 400062d4: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 400062d8: 90 96 60 00 orcc %i1, 0, %o0 400062dc: 02 80 00 1d be 40006350 400062e0: 80 a6 20 02 cmp %i0, 2 rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 400062e4: 02 80 00 09 be 40006308 400062e8: 01 00 00 00 nop 400062ec: 08 80 00 0b bleu 40006318 400062f0: 80 a6 20 01 cmp %i0, 1 400062f4: 80 a6 20 03 cmp %i0, 3 <== NOT EXECUTED 400062f8: 02 80 00 14 be 40006348 <== NOT EXECUTED 400062fc: 80 a6 20 04 cmp %i0, 4 <== NOT EXECUTED 40006300: 12 80 00 08 bne 40006320 <== NOT EXECUTED 40006304: 01 00 00 00 nop <== NOT EXECUTED break; #endif #ifdef _POSIX_CPUTIME case CLOCK_PROCESS_CPUTIME: _TOD_Get_uptime(tp); 40006308: 40 00 0b 87 call 40009124 <_TOD_Get_uptime> <== NOT EXECUTED 4000630c: b0 10 20 00 clr %i0 ! 0 <== NOT EXECUTED 40006310: 81 c7 e0 08 ret <== NOT EXECUTED 40006314: 81 e8 00 00 restore <== NOT EXECUTED ) { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 40006318: 02 80 00 08 be 40006338 4000631c: 01 00 00 00 nop case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); break; #endif default: rtems_set_errno_and_return_minus_one( EINVAL ); 40006320: 40 00 29 a7 call 400109bc <__errno> <== NOT EXECUTED 40006324: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 40006328: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 4000632c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return 0; } 40006330: 81 c7 e0 08 ret <== NOT EXECUTED 40006334: 81 e8 00 00 restore <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { case CLOCK_REALTIME: _TOD_Get(tp); 40006338: 40 00 0b 62 call 400090c0 <_TOD_Get> 4000633c: b0 10 20 00 clr %i0 40006340: 81 c7 e0 08 ret 40006344: 81 e8 00 00 restore break; #endif #ifdef _POSIX_THREAD_CPUTIME case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); 40006348: 40 00 03 56 call 400070a0 <== NOT EXECUTED 4000634c: 81 e8 00 00 restore <== NOT EXECUTED clockid_t clock_id, struct timespec *tp ) { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); 40006350: 40 00 29 9b call 400109bc <__errno> <== NOT EXECUTED 40006354: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40006358: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 4000635c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40006360: 81 c7 e0 08 ret <== NOT EXECUTED 40006364: 81 e8 00 00 restore <== NOT EXECUTED 40006368 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 40006368: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 4000636c: 90 96 60 00 orcc %i1, 0, %o0 40006370: 02 80 00 26 be 40006408 40006374: 80 a6 20 02 cmp %i0, 2 rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 40006378: 02 80 00 22 be 40006400 4000637c: 80 a6 20 03 cmp %i0, 3 40006380: 02 80 00 20 be 40006400 40006384: 80 a6 20 01 cmp %i0, 1 40006388: 22 80 00 08 be,a 400063a8 4000638c: c4 02 00 00 ld [ %o0 ], %g2 case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); break; #endif default: rtems_set_errno_and_return_minus_one( EINVAL ); 40006390: 40 00 29 8b call 400109bc <__errno> 40006394: b0 10 3f ff mov -1, %i0 40006398: 82 10 20 16 mov 0x16, %g1 4000639c: c2 22 00 00 st %g1, [ %o0 ] } return 0; } 400063a0: 81 c7 e0 08 ret 400063a4: 81 e8 00 00 restore rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { case CLOCK_REALTIME: if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 400063a8: 03 08 76 b9 sethi %hi(0x21dae400), %g1 400063ac: 82 10 60 ff or %g1, 0xff, %g1 ! 21dae4ff 400063b0: 80 a0 80 01 cmp %g2, %g1 400063b4: 08 80 00 15 bleu 40006408 400063b8: 21 10 00 7a sethi %hi(0x4001e800), %l0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400063bc: c2 04 22 60 ld [ %l0 + 0x260 ], %g1 ! 4001ea60 <_Thread_Dispatch_disable_level> 400063c0: 82 00 60 01 inc %g1 400063c4: c2 24 22 60 st %g1, [ %l0 + 0x260 ] rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 400063c8: 40 00 0b 7f call 400091c4 <_TOD_Set> 400063cc: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400063d0: c2 04 22 60 ld [ %l0 + 0x260 ], %g1 400063d4: b0 10 20 00 clr %i0 400063d8: 82 00 7f ff add %g1, -1, %g1 400063dc: c2 24 22 60 st %g1, [ %l0 + 0x260 ] 400063e0: c4 04 22 60 ld [ %l0 + 0x260 ], %g2 400063e4: 80 a0 a0 00 cmp %g2, 0 400063e8: 12 80 00 0c bne 40006418 400063ec: 01 00 00 00 nop _Thread_Dispatch(); 400063f0: 40 00 13 5d call 4000b164 <_Thread_Dispatch> 400063f4: 01 00 00 00 nop 400063f8: 81 c7 e0 08 ret 400063fc: 81 e8 00 00 restore break; #endif #ifdef _POSIX_THREAD_CPUTIME case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); 40006400: 40 00 03 28 call 400070a0 <== NOT EXECUTED 40006404: 81 e8 00 00 restore <== NOT EXECUTED switch ( clock_id ) { case CLOCK_REALTIME: if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) rtems_set_errno_and_return_minus_one( EINVAL ); 40006408: 40 00 29 6d call 400109bc <__errno> <== NOT EXECUTED 4000640c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40006410: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 40006414: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40006418: 81 c7 e0 08 ret <== NOT EXECUTED 4000641c: 81 e8 00 00 restore <== NOT EXECUTED 40025ea0 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 40025ea0: 9d e3 bf 88 save %sp, -120, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 40025ea4: 7f ff ff 11 call 40025ae8 40025ea8: 01 00 00 00 nop 40025eac: 80 a2 00 18 cmp %o0, %i0 40025eb0: 12 80 00 ca bne 400261d8 40025eb4: 80 a6 60 00 cmp %i1, 0 /* * Validate the signal passed. */ if ( !sig ) 40025eb8: 02 80 00 ce be 400261f0 40025ebc: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 40025ec0: 90 06 7f ff add %i1, -1, %o0 40025ec4: 80 a2 20 1f cmp %o0, 0x1f 40025ec8: 18 80 00 ca bgu 400261f0 40025ecc: 03 10 00 b3 sethi %hi(0x4002cc00), %g1 /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 40025ed0: a5 2e 60 02 sll %i1, 2, %l2 40025ed4: ac 10 63 b8 or %g1, 0x3b8, %l6 40025ed8: a7 2e 60 04 sll %i1, 4, %l3 40025edc: 82 24 c0 12 sub %l3, %l2, %g1 40025ee0: 82 00 40 16 add %g1, %l6, %g1 40025ee4: c4 00 60 08 ld [ %g1 + 8 ], %g2 40025ee8: 80 a0 a0 01 cmp %g2, 1 40025eec: 02 80 00 4f be 40026028 40025ef0: 80 a6 60 0b cmp %i1, 0xb * 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. */ switch ( sig ) { 40025ef4: 18 80 00 0c bgu 40025f24 40025ef8: 82 10 20 01 mov 1, %g1 40025efc: 83 28 40 19 sll %g1, %i1, %g1 <== NOT EXECUTED 40025f00: 80 88 69 10 btst 0x910, %g1 <== NOT EXECUTED 40025f04: 02 80 00 08 be 40025f24 <== NOT EXECUTED 40025f08: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED case SIGFPE: case SIGILL: case SIGSEGV: return pthread_kill( pthread_self(), sig ); 40025f0c: 40 00 01 75 call 400264e0 <== NOT EXECUTED 40025f10: 01 00 00 00 nop <== NOT EXECUTED 40025f14: 40 00 01 25 call 400263a8 <== NOT EXECUTED 40025f18: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); return 0; } 40025f1c: 81 c7 e0 08 ret 40025f20: 91 e8 00 08 restore %g0, %o0, %o0 /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 40025f24: f2 27 bf ec st %i1, [ %fp + -20 ] siginfo->si_code = SI_USER; 40025f28: c2 27 bf f0 st %g1, [ %fp + -16 ] if ( !value ) { 40025f2c: 80 a6 a0 00 cmp %i2, 0 40025f30: 02 80 00 46 be 40026048 40025f34: b1 28 40 08 sll %g1, %o0, %i0 siginfo->si_value.sival_int = 0; } else { siginfo->si_value = *value; 40025f38: c2 06 80 00 ld [ %i2 ], %g1 40025f3c: c2 27 bf f4 st %g1, [ %fp + -12 ] 40025f40: 35 10 00 b2 sethi %hi(0x4002c800), %i2 40025f44: c2 06 a0 a0 ld [ %i2 + 0xa0 ], %g1 ! 4002c8a0 <_Thread_Dispatch_disable_level> 40025f48: 82 00 60 01 inc %g1 40025f4c: c2 26 a0 a0 st %g1, [ %i2 + 0xa0 ] /* * 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; 40025f50: 03 10 00 b2 sethi %hi(0x4002c800), %g1 40025f54: c6 00 61 7c ld [ %g1 + 0x17c ], %g3 ! 4002c97c <_Thread_Executing> api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 40025f58: c4 00 e1 70 ld [ %g3 + 0x170 ], %g2 40025f5c: c2 00 a0 c4 ld [ %g2 + 0xc4 ], %g1 40025f60: 80 ae 00 01 andncc %i0, %g1, %g0 40025f64: 12 80 00 1a bne 40025fcc 40025f68: 03 10 00 b4 sethi %hi(0x4002d000), %g1 goto process_it; 40025f6c: 98 10 61 44 or %g1, 0x144, %o4 ! 4002d144 <_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 ; 40025f70: 96 03 20 30 add %o4, 0x30, %o3 index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; 40025f74: c8 03 00 00 ld [ %o4 ], %g4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40025f78: 9a 03 20 04 add %o4, 4, %o5 !_Chain_Is_tail( the_chain, the_node ) ; 40025f7c: 80 a1 00 0d cmp %g4, %o5 40025f80: 02 80 00 34 be 40026050 40025f84: 86 10 00 04 mov %g4, %g3 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)) { 40025f88: c2 01 20 30 ld [ %g4 + 0x30 ], %g1 40025f8c: 80 8e 00 01 btst %i0, %g1 40025f90: 02 80 00 0b be 40025fbc 40025f94: c4 01 21 70 ld [ %g4 + 0x170 ], %g2 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 40025f98: 10 80 00 0e b 40025fd0 40025f9c: 82 10 20 01 mov 1, %g1 index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 40025fa0: 80 a1 00 0d cmp %g4, %o5 <== NOT EXECUTED 40025fa4: 02 80 00 2b be 40026050 <== NOT EXECUTED 40025fa8: 86 10 00 04 mov %g4, %g3 <== NOT EXECUTED 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)) { 40025fac: c2 00 e0 30 ld [ %g3 + 0x30 ], %g1 <== NOT EXECUTED 40025fb0: 80 8e 00 01 btst %i0, %g1 <== NOT EXECUTED 40025fb4: 12 80 00 06 bne 40025fcc <== NOT EXECUTED 40025fb8: c4 00 e1 70 ld [ %g3 + 0x170 ], %g2 <== NOT EXECUTED 40025fbc: c2 00 a0 c4 ld [ %g2 + 0xc4 ], %g1 <== NOT EXECUTED 40025fc0: 80 ae 00 01 andncc %i0, %g1, %g0 <== NOT EXECUTED 40025fc4: 22 bf ff f7 be,a 40025fa0 <== NOT EXECUTED 40025fc8: c8 01 00 00 ld [ %g4 ], %g4 <== NOT EXECUTED * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 40025fcc: 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 ) ) { 40025fd0: 90 10 00 03 mov %g3, %o0 40025fd4: 92 10 00 19 mov %i1, %o1 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 40025fd8: c2 20 e0 78 st %g1, [ %g3 + 0x78 ] /* * 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 ) ) { 40025fdc: 40 00 00 a8 call 4002627c <_POSIX_signals_Unblock_thread> 40025fe0: 94 07 bf ec add %fp, -20, %o2 40025fe4: 80 a2 20 00 cmp %o0, 0 40025fe8: 12 80 00 09 bne 4002600c 40025fec: 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 ); 40025ff0: 40 00 00 93 call 4002623c <_POSIX_signals_Set_process_signals> 40025ff4: 90 10 00 18 mov %i0, %o0 if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 40025ff8: b2 24 c0 12 sub %l3, %l2, %i1 40025ffc: c2 05 80 19 ld [ %l6 + %i1 ], %g1 40026000: 80 a0 60 02 cmp %g1, 2 40026004: 02 80 00 65 be 40026198 40026008: 11 10 00 b4 sethi %hi(0x4002d000), %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4002600c: c2 06 a0 a0 ld [ %i2 + 0xa0 ], %g1 40026010: 82 00 7f ff add %g1, -1, %g1 40026014: c2 26 a0 a0 st %g1, [ %i2 + 0xa0 ] 40026018: c4 06 a0 a0 ld [ %i2 + 0xa0 ], %g2 4002601c: 80 a0 a0 00 cmp %g2, 0 40026020: 02 80 00 05 be 40026034 40026024: 01 00 00 00 nop _Thread_Dispatch(); 40026028: 90 10 20 00 clr %o0 ! 0 _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); return 0; } 4002602c: 81 c7 e0 08 ret 40026030: 91 e8 00 08 restore %g0, %o0, %o0 40026034: 7f ff a9 0d call 40010468 <_Thread_Dispatch> 40026038: 01 00 00 00 nop 4002603c: 90 10 20 00 clr %o0 ! 0 40026040: 81 c7 e0 08 ret 40026044: 91 e8 00 08 restore %g0, %o0, %o0 siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { siginfo->si_value.sival_int = 0; 40026048: 10 bf ff be b 40025f40 4002604c: c0 27 bf f4 clr [ %fp + -12 ] index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 40026050: 98 03 20 0c add %o4, 0xc, %o4 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 40026054: 80 a3 00 0b cmp %o4, %o3 40026058: 32 bf ff c8 bne,a 40025f78 4002605c: c8 03 00 00 ld [ %o4 ], %g4 40026060: 03 10 00 b2 sethi %hi(0x4002c800), %g1 continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 40026064: 05 10 00 a8 sethi %hi(0x4002a000), %g2 40026068: ba 10 60 00 mov %g1, %i5 4002606c: b6 10 a3 40 or %g2, 0x340, %i3 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 40026070: a8 10 21 00 mov 0x100, %l4 40026074: ae 10 20 00 clr %l7 40026078: aa 10 20 02 mov 2, %l5 * 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 ) 4002607c: 39 04 00 00 sethi %hi(0x10000000), %i4 the_api++ ) { if ( the_api == OBJECTS_INTERNAL_THREADS ) continue; if ( !_Objects_Information_table[ the_api ] ) /* API not installed */ 40026080: 83 2d 60 02 sll %l5, 2, %g1 40026084: c2 07 40 01 ld [ %i5 + %g1 ], %g1 40026088: 80 a0 60 00 cmp %g1, 0 4002608c: 22 80 00 35 be,a 40026160 40026090: aa 05 60 01 inc %l5 continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 40026094: c2 00 60 04 ld [ %g1 + 4 ], %g1 if ( !the_info ) /* manager not installed */ 40026098: 80 a0 60 00 cmp %g1, 0 4002609c: 22 80 00 31 be,a 40026160 400260a0: aa 05 60 01 inc %l5 <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; 400260a4: e2 00 60 20 ld [ %g1 + 0x20 ], %l1 assert( object_table ); /* always at least 1 entry */ 400260a8: 80 a4 60 00 cmp %l1, 0 400260ac: 02 80 00 57 be 40026208 400260b0: e0 10 60 10 lduh [ %g1 + 0x10 ], %l0 for ( index = 1 ; index <= maximum ; index++ ) { 400260b4: 80 a4 20 00 cmp %l0, 0 400260b8: 22 80 00 2a be,a 40026160 400260bc: aa 05 60 01 inc %l5 400260c0: 88 10 20 01 mov 1, %g4 the_thread = (Thread_Control *) object_table[ index ]; 400260c4: 83 29 20 02 sll %g4, 2, %g1 400260c8: c4 00 40 11 ld [ %g1 + %l1 ], %g2 if ( !the_thread ) 400260cc: 80 a0 a0 00 cmp %g2, 0 400260d0: 22 80 00 20 be,a 40026150 400260d4: 88 01 20 01 inc %g4 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 400260d8: c6 00 a0 14 ld [ %g2 + 0x14 ], %g3 400260dc: 80 a0 c0 14 cmp %g3, %l4 400260e0: 38 80 00 1c bgu,a 40026150 400260e4: 88 01 20 01 inc %g4 <== NOT EXECUTED /* * If this thread is not interested, then go on to the next thread. */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 400260e8: c2 00 a1 70 ld [ %g2 + 0x170 ], %g1 if ( !api || !_POSIX_signals_Is_interested( api, mask ) ) 400260ec: 80 a0 60 00 cmp %g1, 0 400260f0: 22 80 00 18 be,a 40026150 400260f4: 88 01 20 01 inc %g4 <== NOT EXECUTED 400260f8: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 400260fc: 80 ae 00 01 andncc %i0, %g1, %g0 40026100: 22 80 00 14 be,a 40026150 40026104: 88 01 20 01 inc %g4 * 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 ) { 40026108: 80 a0 c0 14 cmp %g3, %l4 4002610c: 2a 80 00 1c bcs,a 4002617c 40026110: ae 10 00 02 mov %g2, %l7 * 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 ) ) 40026114: c2 05 e0 10 ld [ %l7 + 0x10 ], %g1 <== NOT EXECUTED 40026118: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4002611c: 22 80 00 0d be,a 40026150 <== NOT EXECUTED 40026120: 88 01 20 01 inc %g4 <== 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 ) ) { 40026124: da 00 a0 10 ld [ %g2 + 0x10 ], %o5 <== NOT EXECUTED 40026128: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED 4002612c: 22 80 00 14 be,a 4002617c <== NOT EXECUTED 40026130: ae 10 00 02 mov %g2, %l7 <== NOT EXECUTED * 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 ) 40026134: 80 88 40 1c btst %g1, %i4 <== NOT EXECUTED 40026138: 32 80 00 06 bne,a 40026150 <== NOT EXECUTED 4002613c: 88 01 20 01 inc %g4 <== 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 ) { 40026140: 80 8b 40 1c btst %o5, %i4 <== NOT EXECUTED 40026144: 32 80 00 0e bne,a 4002617c <== NOT EXECUTED 40026148: ae 10 00 02 mov %g2, %l7 <== NOT EXECUTED maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ for ( index = 1 ; index <= maximum ; index++ ) { 4002614c: 88 01 20 01 inc %g4 40026150: 80 a4 00 04 cmp %l0, %g4 40026154: 1a bf ff dd bcc 400260c8 40026158: 83 29 20 02 sll %g4, 2, %g1 interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = 2; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 4002615c: aa 05 60 01 inc %l5 interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = 2; the_api <= OBJECTS_APIS_LAST; 40026160: 80 a5 60 04 cmp %l5, 4 40026164: 18 80 00 08 bgu 40026184 40026168: 80 a5 60 01 cmp %l5, 1 the_api++ ) { if ( the_api == OBJECTS_INTERNAL_THREADS ) 4002616c: 22 bf ff c5 be,a 40026080 40026170: aa 10 20 02 mov 2, %l5 <== NOT EXECUTED continue; if ( !_Objects_Information_table[ the_api ] ) /* API not installed */ 40026174: 10 bf ff c4 b 40026084 40026178: 83 2d 60 02 sll %l5, 2, %g1 * 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 ) { 4002617c: 10 bf ff f4 b 4002614c 40026180: a8 10 00 03 mov %g3, %l4 interested_priority = the_thread->current_priority; } } } if ( interested_thread ) { 40026184: 80 a5 e0 00 cmp %l7, 0 40026188: 02 bf ff 9a be 40025ff0 4002618c: 86 10 00 17 mov %l7, %g3 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 40026190: 10 bf ff 90 b 40025fd0 40026194: 82 10 20 01 mov 1, %g1 _POSIX_signals_Set_process_signals( mask ); if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) 40026198: 7f ff 9f 97 call 4000dff4 <_Chain_Get> 4002619c: 90 12 21 38 or %o0, 0x138, %o0 _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 400261a0: 80 a2 20 00 cmp %o0, 0 400261a4: 02 80 00 20 be 40026224 400261a8: 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 ); 400261ac: 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; 400261b0: c2 22 20 08 st %g1, [ %o0 + 8 ] 400261b4: c4 07 bf f0 ld [ %fp + -16 ], %g2 400261b8: c4 22 20 0c st %g2, [ %o0 + 0xc ] 400261bc: c2 07 bf f4 ld [ %fp + -12 ], %g1 400261c0: c2 22 20 10 st %g1, [ %o0 + 0x10 ] _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 400261c4: 11 10 00 b4 sethi %hi(0x4002d000), %o0 400261c8: 90 12 21 88 or %o0, 0x188, %o0 ! 4002d188 <_POSIX_signals_Siginfo> 400261cc: 7f ff 9f 7e call 4000dfc4 <_Chain_Append> 400261d0: 90 06 40 08 add %i1, %o0, %o0 400261d4: 30 bf ff 8e b,a 4002600c /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) rtems_set_errno_and_return_minus_one( ESRCH ); 400261d8: 7f ff d0 3c call 4001a2c8 <__errno> 400261dc: 01 00 00 00 nop 400261e0: 82 10 20 03 mov 3, %g1 ! 3 400261e4: c2 22 00 00 st %g1, [ %o0 ] 400261e8: 10 bf ff 4d b 40025f1c 400261ec: 90 10 3f ff mov -1, %o0 if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 400261f0: 7f ff d0 36 call 4001a2c8 <__errno> 400261f4: 01 00 00 00 nop 400261f8: 82 10 20 16 mov 0x16, %g1 ! 16 400261fc: c2 22 00 00 st %g1, [ %o0 ] 40026200: 10 bf ff 47 b 40025f1c 40026204: 90 10 3f ff mov -1, %o0 continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 40026208: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4002620c: 92 10 20 c1 mov 0xc1, %o1 <== NOT EXECUTED 40026210: 15 10 00 a8 sethi %hi(0x4002a000), %o2 <== NOT EXECUTED 40026214: 7f ff 89 e7 call 400089b0 <__assert> <== NOT EXECUTED 40026218: 94 12 a3 88 or %o2, 0x388, %o2 ! 4002a388 <_RTEMS_version+0x70> <== NOT EXECUTED for ( index = 1 ; index <= maximum ; index++ ) { 4002621c: 10 bf ff a7 b 400260b8 <== NOT EXECUTED 40026220: 80 a4 20 00 cmp %l0, 0 <== 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 ); 40026224: 7f ff d0 29 call 4001a2c8 <__errno> <== NOT EXECUTED 40026228: 01 00 00 00 nop <== NOT EXECUTED 4002622c: 82 10 20 0b mov 0xb, %g1 ! b <== NOT EXECUTED 40026230: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40026234: 10 bf ff 3a b 40025f1c <== NOT EXECUTED 40026238: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED 40009e04 : */ int mq_close( mqd_t mqdes ) { 40009e04: 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 *) 40009e08: 21 10 00 99 sethi %hi(0x40026400), %l0 40009e0c: 92 10 00 18 mov %i0, %o1 40009e10: 94 07 bf f4 add %fp, -12, %o2 40009e14: 40 00 13 eb call 4000edc0 <_Objects_Get> 40009e18: 90 14 21 d0 or %l0, 0x1d0, %o0 POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 40009e1c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009e20: 80 a0 60 01 cmp %g1, 1 40009e24: 02 80 00 2e be 40009edc 40009e28: b0 10 00 08 mov %o0, %i0 40009e2c: 80 a0 60 01 cmp %g1, 1 40009e30: 2a 80 00 09 bcs,a 40009e54 40009e34: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 40009e38: 80 a0 60 02 cmp %g1, 2 40009e3c: 02 80 00 2e be 40009ef4 40009e40: 01 00 00 00 nop _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40009e44: 40 00 08 80 call 4000c044 <== NOT EXECUTED 40009e48: 01 00 00 00 nop <== NOT EXECUTED } 40009e4c: 81 c7 e0 08 ret <== NOT EXECUTED 40009e50: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED * being disassociated. This may result in the queue being really * deleted. */ the_mq = the_mq_fd->Queue; the_mq->open_count -= 1; 40009e54: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 _POSIX_Message_queue_Delete( the_mq ); 40009e58: 90 10 00 02 mov %g2, %o0 * being disassociated. This may result in the queue being really * deleted. */ the_mq = the_mq_fd->Queue; the_mq->open_count -= 1; 40009e5c: 82 00 7f ff add %g1, -1, %g1 _POSIX_Message_queue_Delete( the_mq ); 40009e60: 40 00 00 2c call 40009f10 <_POSIX_Message_queue_Delete> 40009e64: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40009e68: 90 14 21 d0 or %l0, 0x1d0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40009e6c: c4 06 20 08 ld [ %i0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40009e70: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40009e74: 03 00 00 3f sethi %hi(0xfc00), %g1 40009e78: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40009e7c: 82 08 80 01 and %g2, %g1, %g1 40009e80: 80 a0 40 03 cmp %g1, %g3 40009e84: 38 80 00 06 bgu,a 40009e9c 40009e88: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40009e8c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40009e90: 83 28 60 02 sll %g1, 2, %g1 40009e94: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 40009e98: c0 26 20 0c clr [ %i0 + 0xc ] 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 ); 40009e9c: 40 00 13 86 call 4000ecb4 <_Objects_Free> 40009ea0: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40009ea4: 03 10 00 98 sethi %hi(0x40026000), %g1 40009ea8: c4 00 60 00 ld [ %g1 ], %g2 40009eac: 90 10 20 00 clr %o0 40009eb0: 84 00 bf ff add %g2, -1, %g2 40009eb4: c4 20 60 00 st %g2, [ %g1 ] 40009eb8: c6 00 60 00 ld [ %g1 ], %g3 40009ebc: 80 a0 e0 00 cmp %g3, 0 40009ec0: 12 bf ff e3 bne 40009e4c 40009ec4: 01 00 00 00 nop _Thread_Dispatch(); 40009ec8: 40 00 18 aa call 40010170 <_Thread_Dispatch> 40009ecc: 01 00 00 00 nop 40009ed0: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40009ed4: 81 c7 e0 08 ret 40009ed8: 91 e8 00 08 restore %g0, %o0, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 40009edc: 40 00 18 a5 call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 40009ee0: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 40009ee4: 40 00 08 62 call 4000c06c <== NOT EXECUTED 40009ee8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40009eec: 81 c7 e0 08 ret <== NOT EXECUTED 40009ef0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 40009ef4: 40 00 31 bd call 400165e8 <__errno> 40009ef8: 01 00 00 00 nop 40009efc: 82 10 20 09 mov 9, %g1 ! 9 40009f00: c2 22 00 00 st %g1, [ %o0 ] 40009f04: 90 10 3f ff mov -1, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40009f08: 81 c7 e0 08 ret 40009f0c: 91 e8 00 08 restore %g0, %o0, %o0 40009fa0 : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 40009fa0: 9d e3 bf 90 save %sp, -112, %sp POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; CORE_message_queue_Attributes *the_mq_attr; if ( !mqstat ) 40009fa4: 80 a6 60 00 cmp %i1, 0 40009fa8: 02 80 00 36 be 4000a080 40009fac: 92 10 00 18 mov %i0, %o1 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 *) 40009fb0: 11 10 00 99 sethi %hi(0x40026400), %o0 40009fb4: 94 07 bf f4 add %fp, -12, %o2 40009fb8: 40 00 13 82 call 4000edc0 <_Objects_Get> 40009fbc: 90 12 21 d0 or %o0, 0x1d0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 40009fc0: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009fc4: 80 a0 60 01 cmp %g1, 1 40009fc8: 02 80 00 28 be 4000a068 40009fcc: 01 00 00 00 nop 40009fd0: 2a 80 00 09 bcs,a 40009ff4 40009fd4: c6 02 20 10 ld [ %o0 + 0x10 ], %g3 40009fd8: 80 a0 60 02 cmp %g1, 2 40009fdc: 02 80 00 1c be 4000a04c 40009fe0: 01 00 00 00 nop mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40009fe4: 40 00 08 18 call 4000c044 <== NOT EXECUTED 40009fe8: 01 00 00 00 nop <== NOT EXECUTED } 40009fec: 81 c7 e0 08 ret 40009ff0: 91 e8 00 08 restore %g0, %o0, %o0 * Return the old values. */ the_mq_attr = &the_mq->Message_queue.Attributes; mqstat->mq_flags = the_mq_fd->oflag; 40009ff4: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 40009ff8: c4 26 40 00 st %g2, [ %i1 ] mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 40009ffc: c2 00 e0 6c ld [ %g3 + 0x6c ], %g1 4000a000: c2 26 60 08 st %g1, [ %i1 + 8 ] mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 4000a004: c4 00 e0 64 ld [ %g3 + 0x64 ], %g2 4000a008: c4 26 60 04 st %g2, [ %i1 + 4 ] mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 4000a00c: c2 00 e0 68 ld [ %g3 + 0x68 ], %g1 4000a010: c2 26 60 0c st %g1, [ %i1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a014: 07 10 00 98 sethi %hi(0x40026000), %g3 4000a018: c2 00 e0 00 ld [ %g3 ], %g1 4000a01c: 90 10 20 00 clr %o0 4000a020: 82 00 7f ff add %g1, -1, %g1 4000a024: c2 20 e0 00 st %g1, [ %g3 ] 4000a028: c4 00 e0 00 ld [ %g3 ], %g2 4000a02c: 80 a0 a0 00 cmp %g2, 0 4000a030: 12 bf ff ef bne 40009fec 4000a034: 01 00 00 00 nop _Thread_Dispatch(); 4000a038: 40 00 18 4e call 40010170 <_Thread_Dispatch> 4000a03c: 01 00 00 00 nop 4000a040: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000a044: 81 c7 e0 08 ret 4000a048: 91 e8 00 08 restore %g0, %o0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 4000a04c: 40 00 31 67 call 400165e8 <__errno> 4000a050: 01 00 00 00 nop 4000a054: 82 10 20 09 mov 9, %g1 ! 9 4000a058: c2 22 00 00 st %g1, [ %o0 ] 4000a05c: 90 10 3f ff mov -1, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000a060: 81 c7 e0 08 ret 4000a064: 91 e8 00 08 restore %g0, %o0, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 4000a068: 40 00 18 42 call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000a06c: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000a070: 40 00 07 ff call 4000c06c <== NOT EXECUTED 4000a074: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000a078: 81 c7 e0 08 ret <== NOT EXECUTED 4000a07c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; CORE_message_queue_Attributes *the_mq_attr; if ( !mqstat ) rtems_set_errno_and_return_minus_one( EINVAL ); 4000a080: 40 00 31 5a call 400165e8 <__errno> 4000a084: 01 00 00 00 nop 4000a088: 82 10 20 16 mov 0x16, %g1 ! 16 4000a08c: c2 22 00 00 st %g1, [ %o0 ] 4000a090: 10 bf ff d7 b 40009fec 4000a094: 90 10 3f ff mov -1, %o0 4000a0bc : int mq_notify( mqd_t mqdes, const struct sigevent *notification ) { 4000a0bc: 9d e3 bf 90 save %sp, -112, %sp 4000a0c0: 11 10 00 99 sethi %hi(0x40026400), %o0 4000a0c4: 92 10 00 18 mov %i0, %o1 4000a0c8: 90 12 21 d0 or %o0, 0x1d0, %o0 4000a0cc: 40 00 13 3d call 4000edc0 <_Objects_Get> 4000a0d0: 94 07 bf f4 add %fp, -12, %o2 POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 4000a0d4: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000a0d8: 80 a0 60 01 cmp %g1, 1 4000a0dc: 02 80 00 2e be 4000a194 4000a0e0: 01 00 00 00 nop 4000a0e4: 0a 80 00 09 bcs 4000a108 4000a0e8: 80 a6 60 00 cmp %i1, 0 4000a0ec: 80 a0 60 02 cmp %g1, 2 4000a0f0: 02 80 00 2f be 4000a1ac 4000a0f4: 01 00 00 00 nop } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 4000a0f8: 40 00 07 d3 call 4000c044 <== NOT EXECUTED 4000a0fc: 01 00 00 00 nop <== NOT EXECUTED } 4000a100: 81 c7 e0 08 ret 4000a104: 91 e8 00 08 restore %g0, %o0, %o0 return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; if ( notification ) { 4000a108: 02 80 00 3e be 4000a200 4000a10c: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { 4000a110: c2 02 20 80 ld [ %o0 + 0x80 ], %g1 4000a114: 80 a0 60 00 cmp %g1, 0 4000a118: 12 80 00 2c bne 4000a1c8 4000a11c: 01 00 00 00 nop the_message_queue->notify_argument = the_argument; 4000a120: c0 22 20 84 clr [ %o0 + 0x84 ] rtems_set_errno_and_return_minus_one( EBUSY ); } _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); the_mq->notification = *notification; 4000a124: c2 06 40 00 ld [ %i1 ], %g1 4000a128: c2 22 20 94 st %g1, [ %o0 + 0x94 ] 4000a12c: c4 06 60 04 ld [ %i1 + 4 ], %g2 CORE_message_queue_Control *the_message_queue, CORE_message_queue_Notify_Handler the_handler, void *the_argument ) { the_message_queue->notify_handler = the_handler; 4000a130: 03 10 00 28 sethi %hi(0x4000a000), %g1 4000a134: c4 22 20 98 st %g2, [ %o0 + 0x98 ] 4000a138: c6 06 60 08 ld [ %i1 + 8 ], %g3 4000a13c: 82 10 60 98 or %g1, 0x98, %g1 4000a140: c6 22 20 9c st %g3, [ %o0 + 0x9c ] 4000a144: c2 22 20 80 st %g1, [ %o0 + 0x80 ] 4000a148: c2 06 60 0c ld [ %i1 + 0xc ], %g1 4000a14c: c2 22 20 a0 st %g1, [ %o0 + 0xa0 ] 4000a150: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 the_message_queue->notify_argument = the_argument; 4000a154: d0 22 20 84 st %o0, [ %o0 + 0x84 ] 4000a158: c4 22 20 a4 st %g2, [ %o0 + 0xa4 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a15c: 03 10 00 98 sethi %hi(0x40026000), %g1 4000a160: c4 00 60 00 ld [ %g1 ], %g2 4000a164: 90 10 20 00 clr %o0 4000a168: 84 00 bf ff add %g2, -1, %g2 4000a16c: c4 20 60 00 st %g2, [ %g1 ] 4000a170: c6 00 60 00 ld [ %g1 ], %g3 4000a174: 80 a0 e0 00 cmp %g3, 0 4000a178: 12 bf ff e2 bne 4000a100 4000a17c: 01 00 00 00 nop _Thread_Dispatch(); 4000a180: 40 00 17 fc call 40010170 <_Thread_Dispatch> 4000a184: 01 00 00 00 nop 4000a188: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000a18c: 81 c7 e0 08 ret 4000a190: 91 e8 00 08 restore %g0, %o0, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 4000a194: 40 00 17 f7 call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000a198: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000a19c: 40 00 07 b4 call 4000c06c <== NOT EXECUTED 4000a1a0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000a1a4: 81 c7 e0 08 ret <== NOT EXECUTED 4000a1a8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 4000a1ac: 40 00 31 0f call 400165e8 <__errno> 4000a1b0: 01 00 00 00 nop 4000a1b4: 82 10 20 09 mov 9, %g1 ! 9 4000a1b8: c2 22 00 00 st %g1, [ %o0 ] 4000a1bc: 90 10 3f ff mov -1, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000a1c0: 81 c7 e0 08 ret 4000a1c4: 91 e8 00 08 restore %g0, %o0, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a1c8: 03 10 00 98 sethi %hi(0x40026000), %g1 4000a1cc: c4 00 60 00 ld [ %g1 ], %g2 4000a1d0: 84 00 bf ff add %g2, -1, %g2 4000a1d4: c4 20 60 00 st %g2, [ %g1 ] 4000a1d8: c6 00 60 00 ld [ %g1 ], %g3 4000a1dc: 80 a0 e0 00 cmp %g3, 0 4000a1e0: 02 80 00 0b be 4000a20c 4000a1e4: 01 00 00 00 nop the_mq = the_mq_fd->Queue; if ( notification ) { if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBUSY ); 4000a1e8: 40 00 31 00 call 400165e8 <__errno> 4000a1ec: 01 00 00 00 nop 4000a1f0: 82 10 20 10 mov 0x10, %g1 ! 10 4000a1f4: c2 22 00 00 st %g1, [ %o0 ] 4000a1f8: 10 bf ff c2 b 4000a100 4000a1fc: 90 10 3f ff mov -1, %o0 4000a200: c0 22 20 84 clr [ %o0 + 0x84 ] CORE_message_queue_Control *the_message_queue, CORE_message_queue_Notify_Handler the_handler, void *the_argument ) { the_message_queue->notify_handler = the_handler; 4000a204: 10 bf ff d6 b 4000a15c 4000a208: c0 22 20 80 clr [ %o0 + 0x80 ] _Thread_Dispatch(); 4000a20c: 40 00 17 d9 call 40010170 <_Thread_Dispatch> 4000a210: 01 00 00 00 nop 4000a214: 30 bf ff f5 b,a 4000a1e8 4000a218 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 4000a218: 9d e3 bf 88 save %sp, -120, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000a21c: 21 10 00 98 sethi %hi(0x40026000), %l0 4000a220: c2 04 20 00 ld [ %l0 ], %g1 4000a224: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 4000a228: 82 00 60 01 inc %g1 4000a22c: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 4000a230: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 4000a234: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 4000a238: c2 24 20 00 st %g1, [ %l0 ] 4000a23c: a2 10 00 18 mov %i0, %l1 POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 4000a240: ba 8e 62 00 andcc %i1, 0x200, %i5 4000a244: 12 80 00 16 bne 4000a29c 4000a248: f4 07 a0 50 ld [ %fp + 0x50 ], %i2 4000a24c: 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 *) 4000a250: 39 10 00 99 sethi %hi(0x40026400), %i4 4000a254: 40 00 11 8a call 4000e87c <_Objects_Allocate> 4000a258: 90 17 21 d0 or %i4, 0x1d0, %o0 ! 400265d0 <_POSIX_Message_queue_Information_fds> 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 ) { 4000a25c: b0 92 20 00 orcc %o0, 0, %i0 4000a260: 32 80 00 1a bne,a 4000a2c8 4000a264: f2 26 20 14 st %i1, [ %i0 + 0x14 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a268: c2 04 20 00 ld [ %l0 ], %g1 4000a26c: 82 00 7f ff add %g1, -1, %g1 4000a270: c2 24 20 00 st %g1, [ %l0 ] 4000a274: c4 04 20 00 ld [ %l0 ], %g2 4000a278: 80 a0 a0 00 cmp %g2, 0 4000a27c: 02 80 00 0b be 4000a2a8 4000a280: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); 4000a284: 40 00 30 d9 call 400165e8 <__errno> <== NOT EXECUTED 4000a288: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 4000a28c: 82 10 20 17 mov 0x17, %g1 <== NOT EXECUTED 4000a290: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000a294: 81 c7 e0 08 ret <== NOT EXECUTED 4000a298: 81 e8 00 00 restore <== NOT EXECUTED _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 * ); 4000a29c: 82 07 a0 54 add %fp, 0x54, %g1 4000a2a0: 10 bf ff ec b 4000a250 4000a2a4: c2 27 bf f4 st %g1, [ %fp + -12 ] _Thread_Dispatch(); 4000a2a8: 40 00 17 b2 call 40010170 <_Thread_Dispatch> 4000a2ac: b0 10 3f ff mov -1, %i0 } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); 4000a2b0: 40 00 30 ce call 400165e8 <__errno> 4000a2b4: 01 00 00 00 nop 4000a2b8: 82 10 20 17 mov 0x17, %g1 ! 17 4000a2bc: c2 22 00 00 st %g1, [ %o0 ] 4000a2c0: 81 c7 e0 08 ret 4000a2c4: 81 e8 00 00 restore } the_mq_fd->oflag = oflag; status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 4000a2c8: 90 10 00 11 mov %l1, %o0 4000a2cc: 40 00 26 36 call 40013ba4 <_POSIX_Message_queue_Name_to_id> 4000a2d0: 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 ) { 4000a2d4: b6 92 20 00 orcc %o0, 0, %i3 4000a2d8: 02 80 00 14 be 4000a328 4000a2dc: 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) ) ) { 4000a2e0: 80 a6 e0 02 cmp %i3, 2 4000a2e4: 02 80 00 51 be 4000a428 4000a2e8: 80 a7 60 00 cmp %i5, 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 ); 4000a2ec: 90 17 21 d0 or %i4, 0x1d0, %o0 4000a2f0: 40 00 12 71 call 4000ecb4 <_Objects_Free> 4000a2f4: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a2f8: c2 04 20 00 ld [ %l0 ], %g1 4000a2fc: 82 00 7f ff add %g1, -1, %g1 4000a300: c2 24 20 00 st %g1, [ %l0 ] 4000a304: c4 04 20 00 ld [ %l0 ], %g2 4000a308: 80 a0 a0 00 cmp %g2, 0 4000a30c: 02 80 00 1a be 4000a374 4000a310: 01 00 00 00 nop _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 4000a314: 40 00 30 b5 call 400165e8 <__errno> 4000a318: b0 10 3f ff mov -1, %i0 ! ffffffff 4000a31c: f6 22 00 00 st %i3, [ %o0 ] 4000a320: 81 c7 e0 08 ret 4000a324: 81 e8 00 00 restore /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 4000a328: 80 a0 6a 00 cmp %g1, 0xa00 4000a32c: 12 80 00 18 bne 4000a38c 4000a330: d2 07 bf f0 ld [ %fp + -16 ], %o1 4000a334: 90 17 21 d0 or %i4, 0x1d0, %o0 4000a338: 40 00 12 5f call 4000ecb4 <_Objects_Free> 4000a33c: 92 10 00 18 mov %i0, %o1 4000a340: c2 04 20 00 ld [ %l0 ], %g1 4000a344: 82 00 7f ff add %g1, -1, %g1 4000a348: c2 24 20 00 st %g1, [ %l0 ] 4000a34c: c4 04 20 00 ld [ %l0 ], %g2 4000a350: 80 a0 a0 00 cmp %g2, 0 4000a354: 02 80 00 0b be 4000a380 4000a358: 01 00 00 00 nop _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 4000a35c: 40 00 30 a3 call 400165e8 <__errno> 4000a360: b0 10 3f ff mov -1, %i0 ! ffffffff 4000a364: 82 10 20 11 mov 0x11, %g1 4000a368: c2 22 00 00 st %g1, [ %o0 ] 4000a36c: 81 c7 e0 08 ret 4000a370: 81 e8 00 00 restore _Thread_Dispatch(); 4000a374: 40 00 17 7f call 40010170 <_Thread_Dispatch> 4000a378: 01 00 00 00 nop 4000a37c: 30 bf ff e6 b,a 4000a314 4000a380: 40 00 17 7c call 40010170 <_Thread_Dispatch> 4000a384: 01 00 00 00 nop 4000a388: 30 bf ff f5 b,a 4000a35c RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control *) 4000a38c: 11 10 00 99 sethi %hi(0x40026400), %o0 <== NOT EXECUTED 4000a390: 94 07 bf e8 add %fp, -24, %o2 <== NOT EXECUTED 4000a394: 40 00 12 8b call 4000edc0 <_Objects_Get> <== NOT EXECUTED 4000a398: 90 12 20 18 or %o0, 0x18, %o0 <== NOT EXECUTED * 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; 4000a39c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED /* * 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 ); 4000a3a0: d0 27 bf ec st %o0, [ %fp + -20 ] <== NOT EXECUTED the_mq->open_count += 1; 4000a3a4: 82 00 60 01 inc %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000a3a8: 88 17 21 d0 or %i4, 0x1d0, %g4 <== NOT EXECUTED 4000a3ac: c2 22 20 1c st %g1, [ %o0 + 0x1c ] <== NOT EXECUTED 4000a3b0: c6 11 20 10 lduh [ %g4 + 0x10 ], %g3 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000a3b4: c4 06 20 08 ld [ %i0 + 8 ], %g2 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000a3b8: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 4000a3bc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <== NOT EXECUTED 4000a3c0: 82 08 80 01 and %g2, %g1, %g1 <== NOT EXECUTED 4000a3c4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4000a3c8: 18 80 00 05 bgu 4000a3dc <== NOT EXECUTED 4000a3cc: d0 26 20 10 st %o0, [ %i0 + 0x10 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000a3d0: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 <== NOT EXECUTED 4000a3d4: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4000a3d8: f0 20 80 01 st %i0, [ %g2 + %g1 ] <== NOT EXECUTED if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 4000a3dc: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a3e0: c2 04 20 00 ld [ %l0 ], %g1 <== NOT EXECUTED 4000a3e4: 23 10 00 98 sethi %hi(0x40026000), %l1 <== NOT EXECUTED 4000a3e8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000a3ec: c2 24 20 00 st %g1, [ %l0 ] <== NOT EXECUTED 4000a3f0: c4 04 20 00 ld [ %l0 ], %g2 <== NOT EXECUTED 4000a3f4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000a3f8: 02 80 00 28 be 4000a498 <== NOT EXECUTED 4000a3fc: 01 00 00 00 nop <== NOT EXECUTED 4000a400: c2 04 60 00 ld [ %l1 ], %g1 <== NOT EXECUTED 4000a404: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000a408: c2 24 60 00 st %g1, [ %l1 ] <== NOT EXECUTED 4000a40c: c4 04 60 00 ld [ %l1 ], %g2 <== NOT EXECUTED 4000a410: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000a414: 02 80 00 1c be 4000a484 <== NOT EXECUTED 4000a418: 01 00 00 00 nop <== NOT EXECUTED &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); _Thread_Enable_dispatch(); return (mqd_t)the_mq_fd->Object.id; 4000a41c: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED 4000a420: 81 c7 e0 08 ret <== NOT EXECUTED 4000a424: 81 e8 00 00 restore <== NOT EXECUTED /* * 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) ) ) { 4000a428: 02 bf ff b2 be 4000a2f0 4000a42c: 90 17 21 d0 or %i4, 0x1d0, %o0 /* * 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( 4000a430: 90 10 00 11 mov %l1, %o0 4000a434: 94 10 00 1a mov %i2, %o2 4000a438: 92 10 20 01 mov 1, %o1 4000a43c: 40 00 25 42 call 40013944 <_POSIX_Message_queue_Create_support> 4000a440: 96 07 bf ec add %fp, -20, %o3 /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 4000a444: 80 a2 3f ff cmp %o0, -1 4000a448: 12 80 00 1b bne 4000a4b4 4000a44c: c4 07 bf ec ld [ %fp + -20 ], %g2 4000a450: c2 04 20 00 ld [ %l0 ], %g1 4000a454: 82 00 7f ff add %g1, -1, %g1 4000a458: c2 24 20 00 st %g1, [ %l0 ] 4000a45c: c4 04 20 00 ld [ %l0 ], %g2 4000a460: 80 a0 a0 00 cmp %g2, 0 4000a464: 02 80 00 10 be 4000a4a4 4000a468: 01 00 00 00 nop 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 ); 4000a46c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000a470: 90 17 21 d0 or %i4, 0x1d0, %o0 4000a474: 40 00 12 10 call 4000ecb4 <_Objects_Free> 4000a478: b0 10 3f ff mov -1, %i0 4000a47c: 81 c7 e0 08 ret 4000a480: 81 e8 00 00 restore _Thread_Dispatch(); 4000a484: 40 00 17 3b call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000a488: 01 00 00 00 nop <== NOT EXECUTED 4000a48c: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED 4000a490: 81 c7 e0 08 ret <== NOT EXECUTED 4000a494: 81 e8 00 00 restore <== NOT EXECUTED 4000a498: 40 00 17 36 call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000a49c: 01 00 00 00 nop <== NOT EXECUTED 4000a4a0: 30 bf ff d8 b,a 4000a400 <== NOT EXECUTED 4000a4a4: 40 00 17 33 call 40010170 <_Thread_Dispatch> 4000a4a8: 01 00 00 00 nop 4000a4ac: 10 bf ff f1 b 4000a470 4000a4b0: 92 10 00 18 mov %i0, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000a4b4: 90 17 21 d0 or %i4, 0x1d0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000a4b8: c6 06 20 08 ld [ %i0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000a4bc: c8 12 20 10 lduh [ %o0 + 0x10 ], %g4 4000a4c0: 03 00 00 3f sethi %hi(0xfc00), %g1 4000a4c4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000a4c8: 82 08 c0 01 and %g3, %g1, %g1 4000a4cc: 80 a0 40 04 cmp %g1, %g4 4000a4d0: 18 80 00 05 bgu 4000a4e4 4000a4d4: c4 26 20 10 st %g2, [ %i0 + 0x10 ] information->local_table[ index ] = the_object; 4000a4d8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000a4dc: 83 28 60 02 sll %g1, 2, %g1 4000a4e0: f0 20 80 01 st %i0, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 4000a4e4: c0 26 20 0c clr [ %i0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a4e8: c2 04 20 00 ld [ %l0 ], %g1 4000a4ec: 82 00 7f ff add %g1, -1, %g1 4000a4f0: c2 24 20 00 st %g1, [ %l0 ] 4000a4f4: c4 04 20 00 ld [ %l0 ], %g2 4000a4f8: 80 a0 a0 00 cmp %g2, 0 4000a4fc: 32 bf ff 66 bne,a 4000a294 4000a500: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED _Thread_Dispatch(); 4000a504: 40 00 17 1b call 40010170 <_Thread_Dispatch> 4000a508: 01 00 00 00 nop NULL ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; 4000a50c: f0 06 20 08 ld [ %i0 + 8 ], %i0 } 4000a510: 81 c7 e0 08 ret 4000a514: 81 e8 00 00 restore 4000a8a4 : int mq_setattr( mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat ) { 4000a8a4: 9d e3 bf 90 save %sp, -112, %sp POSIX_Message_queue_Control_fd *the_mq_fd; CORE_message_queue_Control *the_core_mq; Objects_Locations location; if ( !mqstat ) 4000a8a8: 80 a6 60 00 cmp %i1, 0 4000a8ac: 02 80 00 3a be 4000a994 4000a8b0: 92 10 00 18 mov %i0, %o1 4000a8b4: 11 10 00 99 sethi %hi(0x40026400), %o0 4000a8b8: 94 07 bf f4 add %fp, -12, %o2 4000a8bc: 40 00 11 41 call 4000edc0 <_Objects_Get> 4000a8c0: 90 12 21 d0 or %o0, 0x1d0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 4000a8c4: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000a8c8: 80 a0 60 01 cmp %g1, 1 4000a8cc: 02 80 00 2c be 4000a97c 4000a8d0: 01 00 00 00 nop 4000a8d4: 1a 80 00 1d bcc 4000a948 4000a8d8: 80 a0 60 02 cmp %g1, 2 /* * Return the old values. */ if ( omqstat ) { 4000a8dc: 80 a6 a0 00 cmp %i2, 0 4000a8e0: 02 80 00 0a be 4000a908 4000a8e4: c6 02 20 10 ld [ %o0 + 0x10 ], %g3 omqstat->mq_flags = the_mq_fd->oflag; 4000a8e8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 4000a8ec: c2 26 80 00 st %g1, [ %i2 ] omqstat->mq_msgsize = the_core_mq->maximum_message_size; 4000a8f0: c4 00 e0 6c ld [ %g3 + 0x6c ], %g2 4000a8f4: c4 26 a0 08 st %g2, [ %i2 + 8 ] omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages; 4000a8f8: c2 00 e0 64 ld [ %g3 + 0x64 ], %g1 4000a8fc: c2 26 a0 04 st %g1, [ %i2 + 4 ] omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages; 4000a900: c4 00 e0 68 ld [ %g3 + 0x68 ], %g2 4000a904: c4 26 a0 0c st %g2, [ %i2 + 0xc ] } the_mq_fd->oflag = mqstat->mq_flags; 4000a908: c2 06 40 00 ld [ %i1 ], %g1 4000a90c: c2 22 20 14 st %g1, [ %o0 + 0x14 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a910: 07 10 00 98 sethi %hi(0x40026000), %g3 4000a914: c2 00 e0 00 ld [ %g3 ], %g1 4000a918: 90 10 20 00 clr %o0 4000a91c: 82 00 7f ff add %g1, -1, %g1 4000a920: c2 20 e0 00 st %g1, [ %g3 ] 4000a924: c4 00 e0 00 ld [ %g3 ], %g2 4000a928: 80 a0 a0 00 cmp %g2, 0 4000a92c: 12 80 00 0b bne 4000a958 4000a930: 01 00 00 00 nop _Thread_Dispatch(); 4000a934: 40 00 16 0f call 40010170 <_Thread_Dispatch> 4000a938: 01 00 00 00 nop 4000a93c: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000a940: 81 c7 e0 08 ret 4000a944: 91 e8 00 08 restore %g0, %o0, %o0 if ( !mqstat ) rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 4000a948: 02 80 00 06 be 4000a960 4000a94c: 01 00 00 00 nop the_mq_fd->oflag = mqstat->mq_flags; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 4000a950: 40 00 05 bd call 4000c044 <== NOT EXECUTED 4000a954: 01 00 00 00 nop <== NOT EXECUTED } 4000a958: 81 c7 e0 08 ret 4000a95c: 91 e8 00 08 restore %g0, %o0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 4000a960: 40 00 2f 22 call 400165e8 <__errno> 4000a964: 01 00 00 00 nop 4000a968: 82 10 20 09 mov 9, %g1 ! 9 4000a96c: c2 22 00 00 st %g1, [ %o0 ] 4000a970: 90 10 3f ff mov -1, %o0 the_mq_fd->oflag = mqstat->mq_flags; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000a974: 81 c7 e0 08 ret 4000a978: 91 e8 00 08 restore %g0, %o0, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 4000a97c: 40 00 15 fd call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000a980: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000a984: 40 00 05 ba call 4000c06c <== NOT EXECUTED 4000a988: 01 00 00 00 nop <== NOT EXECUTED the_mq_fd->oflag = mqstat->mq_flags; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000a98c: 81 c7 e0 08 ret <== NOT EXECUTED 4000a990: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; CORE_message_queue_Control *the_core_mq; Objects_Locations location; if ( !mqstat ) rtems_set_errno_and_return_minus_one( EINVAL ); 4000a994: 40 00 2f 15 call 400165e8 <__errno> 4000a998: 01 00 00 00 nop 4000a99c: 82 10 20 16 mov 0x16, %g1 ! 16 4000a9a0: c2 22 00 00 st %g1, [ %o0 ] 4000a9a4: 10 bf ff ed b 4000a958 4000a9a8: 90 10 3f ff mov -1, %o0 4000a9ac : char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 4000a9ac: 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 ) ) { 4000a9b0: 92 07 bf f4 add %fp, -12, %o1 4000a9b4: 40 00 00 95 call 4000ac08 <_POSIX_Absolute_timeout_to_ticks> 4000a9b8: 90 10 00 1c mov %i4, %o0 char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 4000a9bc: 92 10 00 19 mov %i1, %o1 4000a9c0: 94 10 00 1a mov %i2, %o2 * 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 ) ) { 4000a9c4: 80 a2 20 02 cmp %o0, 2 4000a9c8: 18 80 00 09 bgu 4000a9ec 4000a9cc: 96 10 00 1b mov %i3, %o3 4000a9d0: b8 10 20 00 clr %i4 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Receive_support( 4000a9d4: da 07 bf f4 ld [ %fp + -12 ], %o5 <== NOT EXECUTED 4000a9d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000a9dc: 7f ff fe d5 call 4000a530 <_POSIX_Message_queue_Receive_support> <== NOT EXECUTED 4000a9e0: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED msg_len, msg_prio, do_wait, ticks ); } 4000a9e4: 81 c7 e0 08 ret <== NOT EXECUTED 4000a9e8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED * 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 ) ) { 4000a9ec: 80 a2 20 03 cmp %o0, 3 4000a9f0: 12 bf ff fa bne 4000a9d8 4000a9f4: da 07 bf f4 ld [ %fp + -12 ], %o5 4000a9f8: b8 10 20 01 mov 1, %i4 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Receive_support( 4000a9fc: 90 10 00 18 mov %i0, %o0 4000aa00: 7f ff fe cc call 4000a530 <_POSIX_Message_queue_Receive_support> 4000aa04: 98 10 00 1c mov %i4, %o4 msg_len, msg_prio, do_wait, ticks ); } 4000aa08: 81 c7 e0 08 ret 4000aa0c: 91 e8 00 08 restore %g0, %o0, %o0 4000aa10 : const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 4000aa10: 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 ) ) { 4000aa14: 92 07 bf f4 add %fp, -12, %o1 4000aa18: 40 00 00 7c call 4000ac08 <_POSIX_Absolute_timeout_to_ticks> 4000aa1c: 90 10 00 1c mov %i4, %o0 const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 4000aa20: 92 10 00 19 mov %i1, %o1 4000aa24: 94 10 00 1a mov %i2, %o2 * 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 ) ) { 4000aa28: 80 a2 20 02 cmp %o0, 2 4000aa2c: 18 80 00 09 bgu 4000aa50 4000aa30: 96 10 00 1b mov %i3, %o3 4000aa34: b8 10 20 00 clr %i4 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Send_support( 4000aa38: da 07 bf f4 ld [ %fp + -12 ], %o5 <== NOT EXECUTED 4000aa3c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000aa40: 7f ff ff 36 call 4000a718 <_POSIX_Message_queue_Send_support> <== NOT EXECUTED 4000aa44: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED msg_len, msg_prio, do_wait, ticks ); } 4000aa48: 81 c7 e0 08 ret <== NOT EXECUTED 4000aa4c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED * 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 ) ) { 4000aa50: 80 a2 20 03 cmp %o0, 3 4000aa54: 12 bf ff fa bne 4000aa3c 4000aa58: da 07 bf f4 ld [ %fp + -12 ], %o5 4000aa5c: b8 10 20 01 mov 1, %i4 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Send_support( 4000aa60: 90 10 00 18 mov %i0, %o0 4000aa64: 7f ff ff 2d call 4000a718 <_POSIX_Message_queue_Send_support> 4000aa68: 98 10 00 1c mov %i4, %o4 msg_len, msg_prio, do_wait, ticks ); } 4000aa6c: 81 c7 e0 08 ret 4000aa70: 91 e8 00 08 restore %g0, %o0, %o0 4000ab18 : */ int mq_unlink( const char *name ) { 4000ab18: 9d e3 bf 90 save %sp, -112, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000ab1c: 21 10 00 98 sethi %hi(0x40026000), %l0 4000ab20: c2 04 20 00 ld [ %l0 ], %g1 4000ab24: 90 10 00 18 mov %i0, %o0 4000ab28: 82 00 60 01 inc %g1 4000ab2c: c2 24 20 00 st %g1, [ %l0 ] 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 ); 4000ab30: 40 00 24 1d call 40013ba4 <_POSIX_Message_queue_Name_to_id> 4000ab34: 92 07 bf f4 add %fp, -12, %o1 if ( status != 0 ) { 4000ab38: b0 92 20 00 orcc %o0, 0, %i0 4000ab3c: 12 80 00 24 bne 4000abcc 4000ab40: 03 10 00 99 sethi %hi(0x40026400), %g1 RTEMS_INLINE_ROUTINE Objects_Control *_Objects_Get_local_object( Objects_Information *information, uint16_t index ) { if ( index > information->maximum ) 4000ab44: c4 07 bf f4 ld [ %fp + -12 ], %g2 4000ab48: 88 10 60 18 or %g1, 0x18, %g4 4000ab4c: c6 11 20 10 lduh [ %g4 + 0x10 ], %g3 4000ab50: 03 00 00 3f sethi %hi(0xfc00), %g1 4000ab54: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000ab58: 82 08 80 01 and %g2, %g1, %g1 4000ab5c: 80 a0 40 03 cmp %g1, %g3 4000ab60: 18 80 00 05 bgu 4000ab74 4000ab64: b0 10 20 00 clr %i0 4000ab68: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 4000ab6c: 83 28 60 02 sll %g1, 2, %g1 4000ab70: f0 00 80 01 ld [ %g2 + %g1 ], %i0 4000ab74: d2 06 20 0c ld [ %i0 + 0xc ], %o1 _Objects_MP_Close( &_POSIX_Message_queue_Information, the_mq_id ); } #endif the_mq->linked = FALSE; 4000ab78: c0 26 20 18 clr [ %i0 + 0x18 ] 4000ab7c: 11 10 00 98 sethi %hi(0x40026000), %o0 4000ab80: 40 00 0e 12 call 4000e3c8 <_Heap_Free> 4000ab84: 90 12 20 4c or %o0, 0x4c, %o0 ! 4002604c <_Workspace_Area> _Workspace_Free( the_mq->Object.name ); _POSIX_Message_queue_Namespace_remove( the_mq ); _POSIX_Message_queue_Delete( the_mq ); 4000ab88: 90 10 00 18 mov %i0, %o0 4000ab8c: 7f ff fc e1 call 40009f10 <_POSIX_Message_queue_Delete> 4000ab90: c0 26 20 0c clr [ %i0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000ab94: c2 04 20 00 ld [ %l0 ], %g1 4000ab98: b0 10 20 00 clr %i0 4000ab9c: 82 00 7f ff add %g1, -1, %g1 4000aba0: c2 24 20 00 st %g1, [ %l0 ] 4000aba4: c4 04 20 00 ld [ %l0 ], %g2 4000aba8: 80 a0 a0 00 cmp %g2, 0 4000abac: 02 80 00 04 be 4000abbc 4000abb0: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } 4000abb4: 81 c7 e0 08 ret <== NOT EXECUTED 4000abb8: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4000abbc: 40 00 15 6d call 40010170 <_Thread_Dispatch> 4000abc0: 01 00 00 00 nop 4000abc4: 81 c7 e0 08 ret 4000abc8: 81 e8 00 00 restore #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000abcc: c2 04 20 00 ld [ %l0 ], %g1 4000abd0: 82 00 7f ff add %g1, -1, %g1 4000abd4: c2 24 20 00 st %g1, [ %l0 ] 4000abd8: c4 04 20 00 ld [ %l0 ], %g2 4000abdc: 80 a0 a0 00 cmp %g2, 0 4000abe0: 02 80 00 07 be 4000abfc 4000abe4: 01 00 00 00 nop _Thread_Disable_dispatch(); status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); if ( status != 0 ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( status ); 4000abe8: 40 00 2e 80 call 400165e8 <__errno> 4000abec: 01 00 00 00 nop 4000abf0: f0 22 00 00 st %i0, [ %o0 ] 4000abf4: 81 c7 e0 08 ret 4000abf8: 91 e8 3f ff restore %g0, -1, %o0 _Thread_Dispatch(); 4000abfc: 40 00 15 5d call 40010170 <_Thread_Dispatch> 4000ac00: 01 00 00 00 nop 4000ac04: 30 bf ff f9 b,a 4000abe8 40015a80 : int nanosleep( const struct timespec *rqtp, struct timespec *rmtp ) { 40015a80: 9d e3 bf 98 save %sp, -104, %sp Watchdog_Interval ticks; if ( !_Timespec_Is_valid( rqtp ) ) 40015a84: 40 00 06 fc call 40017674 <_Timespec_Is_valid> 40015a88: 90 10 00 18 mov %i0, %o0 40015a8c: 80 a2 20 00 cmp %o0, 0 40015a90: 02 80 00 4d be 40015bc4 40015a94: 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 ) 40015a98: c2 06 00 00 ld [ %i0 ], %g1 40015a9c: 80 a0 60 00 cmp %g1, 0 40015aa0: 06 80 00 49 bl 40015bc4 40015aa4: 01 00 00 00 nop 40015aa8: c2 06 20 04 ld [ %i0 + 4 ], %g1 40015aac: 80 a0 60 00 cmp %g1, 0 40015ab0: 06 80 00 45 bl 40015bc4 40015ab4: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); ticks = _Timespec_To_ticks( rqtp ); 40015ab8: 40 00 07 00 call 400176b8 <_Timespec_To_ticks> 40015abc: 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 ) { 40015ac0: b0 92 20 00 orcc %o0, 0, %i0 40015ac4: 02 80 00 2d be 40015b78 40015ac8: 21 10 00 b2 sethi %hi(0x4002c800), %l0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40015acc: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 ! 4002c8a0 <_Thread_Dispatch_disable_level> 40015ad0: 82 00 60 01 inc %g1 40015ad4: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] /* * Block for the desired amount of time */ _Thread_Disable_dispatch(); _Thread_Set_state( 40015ad8: 23 10 00 b2 sethi %hi(0x4002c800), %l1 40015adc: d0 04 61 7c ld [ %l1 + 0x17c ], %o0 ! 4002c97c <_Thread_Executing> 40015ae0: 13 04 00 00 sethi %hi(0x10000000), %o1 40015ae4: 7f ff ed 87 call 40011100 <_Thread_Set_state> 40015ae8: 92 12 60 08 or %o1, 8, %o1 ! 10000008 _Thread_Executing, STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Watchdog_Initialize( 40015aec: d2 04 61 7c ld [ %l1 + 0x17c ], %o1 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40015af0: 03 10 00 40 sethi %hi(0x40010000), %g1 40015af4: c4 02 60 08 ld [ %o1 + 8 ], %g2 40015af8: 82 10 63 c4 or %g1, 0x3c4, %g1 the_watchdog->id = id; 40015afc: c4 22 60 68 st %g2, [ %o1 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40015b00: c2 22 60 64 st %g1, [ %o1 + 0x64 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40015b04: f0 22 60 54 st %i0, [ %o1 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40015b08: c0 22 60 50 clr [ %o1 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 40015b0c: c0 22 60 6c clr [ %o1 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40015b10: 11 10 00 b2 sethi %hi(0x4002c800), %o0 40015b14: 92 02 60 48 add %o1, 0x48, %o1 40015b18: 7f ff ef af call 400119d4 <_Watchdog_Insert> 40015b1c: 90 12 21 9c or %o0, 0x19c, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40015b20: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 40015b24: 82 00 7f ff add %g1, -1, %g1 40015b28: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] 40015b2c: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 40015b30: 80 a0 a0 00 cmp %g2, 0 40015b34: 02 80 00 2a be 40015bdc 40015b38: 01 00 00 00 nop _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); _Thread_Enable_dispatch(); /* calculate time remaining */ if ( rmtp ) { 40015b3c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40015b40: 02 80 00 0c be 40015b70 40015b44: c2 04 61 7c ld [ %l1 + 0x17c ], %g1 ticks -= _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; _Timespec_From_ticks( ticks, rmtp ); 40015b48: 92 10 00 19 mov %i1, %o1 _Thread_Enable_dispatch(); /* calculate time remaining */ if ( rmtp ) { ticks -= 40015b4c: c4 00 60 5c ld [ %g1 + 0x5c ], %g2 40015b50: e0 00 60 60 ld [ %g1 + 0x60 ], %l0 40015b54: a0 24 00 02 sub %l0, %g2, %l0 40015b58: a0 26 00 10 sub %i0, %l0, %l0 _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; _Timespec_From_ticks( ticks, rmtp ); 40015b5c: 40 00 06 b1 call 40017620 <_Timespec_From_ticks> 40015b60: 90 10 00 10 mov %l0, %o0 /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) 40015b64: 80 a4 20 00 cmp %l0, 0 40015b68: 12 80 00 25 bne 40015bfc 40015b6c: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINTR ); } return 0; } 40015b70: 81 c7 e0 08 ret 40015b74: 91 e8 20 00 restore %g0, 0, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40015b78: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 40015b7c: 82 00 60 01 inc %g1 40015b80: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] * consistent with the RTEMS API and yields desirable behavior. */ if ( !ticks ) { _Thread_Disable_dispatch(); _Thread_Yield_processor(); 40015b84: 7f ff ee 67 call 40011520 <_Thread_Yield_processor> 40015b88: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40015b8c: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 40015b90: 82 00 7f ff add %g1, -1, %g1 40015b94: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] 40015b98: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 40015b9c: 80 a0 a0 00 cmp %g2, 0 40015ba0: 02 80 00 13 be 40015bec 40015ba4: 01 00 00 00 nop _Thread_Enable_dispatch(); if ( rmtp ) { 40015ba8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40015bac: 02 bf ff f1 be 40015b70 40015bb0: 01 00 00 00 nop rmtp->tv_sec = 0; rmtp->tv_nsec = 0; 40015bb4: c0 26 60 04 clr [ %i1 + 4 ] if ( !ticks ) { _Thread_Disable_dispatch(); _Thread_Yield_processor(); _Thread_Enable_dispatch(); if ( rmtp ) { rmtp->tv_sec = 0; 40015bb8: c0 26 40 00 clr [ %i1 ] rmtp->tv_nsec = 0; 40015bbc: 81 c7 e0 08 ret 40015bc0: 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 ); 40015bc4: 40 00 11 c1 call 4001a2c8 <__errno> 40015bc8: b0 10 3f ff mov -1, %i0 40015bcc: 82 10 20 16 mov 0x16, %g1 40015bd0: c2 22 00 00 st %g1, [ %o0 ] 40015bd4: 81 c7 e0 08 ret 40015bd8: 81 e8 00 00 restore _Thread_Dispatch(); 40015bdc: 7f ff ea 23 call 40010468 <_Thread_Dispatch> 40015be0: 01 00 00 00 nop _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); _Thread_Enable_dispatch(); /* calculate time remaining */ if ( rmtp ) { 40015be4: 10 bf ff d7 b 40015b40 40015be8: 80 a6 60 00 cmp %i1, 0 40015bec: 7f ff ea 1f call 40010468 <_Thread_Dispatch> 40015bf0: 01 00 00 00 nop if ( !ticks ) { _Thread_Disable_dispatch(); _Thread_Yield_processor(); _Thread_Enable_dispatch(); if ( rmtp ) { 40015bf4: 10 bf ff ee b 40015bac 40015bf8: 80 a6 60 00 cmp %i1, 0 /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) rtems_set_errno_and_return_minus_one( EINTR ); 40015bfc: 40 00 11 b3 call 4001a2c8 <__errno> 40015c00: b0 10 3f ff mov -1, %i0 40015c04: 82 10 20 04 mov 4, %g1 40015c08: c2 22 00 00 st %g1, [ %o0 ] 40015c0c: 81 c7 e0 08 ret 40015c10: 81 e8 00 00 restore 40005c5c : */ int pthread_barrier_destroy( pthread_barrier_t *barrier ) { 40005c5c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 40005c60: 80 a6 20 00 cmp %i0, 0 40005c64: 02 80 00 23 be 40005cf0 40005c68: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get ( pthread_barrier_t *barrier, Objects_Locations *location ) { return (POSIX_Barrier_Control *) _Objects_Get( 40005c6c: d2 06 00 00 ld [ %i0 ], %o1 40005c70: 31 10 00 72 sethi %hi(0x4001c800), %i0 40005c74: 40 00 0d 56 call 400091cc <_Objects_Get> 40005c78: 90 16 20 c0 or %i0, 0xc0, %o0 ! 4001c8c0 <_POSIX_Barrier_Information> return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 40005c7c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005c80: 80 a0 60 00 cmp %g1, 0 40005c84: 12 80 00 14 bne 40005cd4 40005c88: 92 10 00 08 mov %o0, %o1 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) { 40005c8c: c2 02 20 58 ld [ %o0 + 0x58 ], %g1 40005c90: 80 a0 60 00 cmp %g1, 0 40005c94: 02 80 00 1a be 40005cfc 40005c98: 90 16 20 c0 or %i0, 0xc0, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005c9c: 03 10 00 71 sethi %hi(0x4001c400), %g1 40005ca0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 4001c410 <_Thread_Dispatch_disable_level> 40005ca4: 90 10 20 10 mov 0x10, %o0 40005ca8: 84 00 bf ff add %g2, -1, %g2 40005cac: c4 20 60 10 st %g2, [ %g1 + 0x10 ] 40005cb0: c6 00 60 10 ld [ %g1 + 0x10 ], %g3 40005cb4: 80 a0 e0 00 cmp %g3, 0 40005cb8: 12 80 00 0c bne 40005ce8 40005cbc: 01 00 00 00 nop _Thread_Dispatch(); 40005cc0: 40 00 12 2f call 4000a57c <_Thread_Dispatch> 40005cc4: 01 00 00 00 nop 40005cc8: 90 10 20 10 mov 0x10, %o0 ! 10 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40005ccc: 81 c7 e0 08 ret 40005cd0: 91 e8 00 08 restore %g0, %o0, %o0 if ( !barrier ) return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 40005cd4: 80 a0 60 02 cmp %g1, 2 40005cd8: 08 80 00 07 bleu 40005cf4 40005cdc: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40005ce0: 40 00 02 45 call 400065f4 <== NOT EXECUTED 40005ce4: 01 00 00 00 nop <== NOT EXECUTED } 40005ce8: 81 c7 e0 08 ret 40005cec: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40005cf0: 90 10 20 16 mov 0x16, %o0 } 40005cf4: 81 c7 e0 08 ret 40005cf8: 91 e8 00 08 restore %g0, %o0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40005cfc: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005d00: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40005d04: 05 00 00 3f sethi %hi(0xfc00), %g2 40005d08: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40005d0c: 82 08 40 02 and %g1, %g2, %g1 40005d10: 80 a0 40 03 cmp %g1, %g3 40005d14: 18 80 00 04 bgu 40005d24 40005d18: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 40005d1c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40005d20: c0 20 80 01 clr [ %g2 + %g1 ] */ RTEMS_INLINE_ROUTINE void _POSIX_Barrier_Free ( POSIX_Barrier_Control *the_barrier ) { _Objects_Free( &_POSIX_Barrier_Information, &the_barrier->Object ); 40005d24: 40 00 0c e7 call 400090c0 <_Objects_Free> 40005d28: c0 22 60 0c clr [ %o1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005d2c: 03 10 00 71 sethi %hi(0x4001c400), %g1 40005d30: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 4001c410 <_Thread_Dispatch_disable_level> 40005d34: 90 10 20 00 clr %o0 40005d38: 84 00 bf ff add %g2, -1, %g2 40005d3c: c4 20 60 10 st %g2, [ %g1 + 0x10 ] 40005d40: c6 00 60 10 ld [ %g1 + 0x10 ], %g3 40005d44: 80 a0 e0 00 cmp %g3, 0 40005d48: 12 bf ff e8 bne 40005ce8 40005d4c: 01 00 00 00 nop _Thread_Dispatch(); 40005d50: 40 00 12 0b call 4000a57c <_Thread_Dispatch> 40005d54: 01 00 00 00 nop 40005d58: 10 bf ff e4 b 40005ce8 40005d5c: 90 10 20 00 clr %o0 ! 0 40005d60 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 40005d60: 9d e3 bf 88 save %sp, -120, %sp const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 40005d64: 80 a6 20 00 cmp %i0, 0 40005d68: 02 80 00 27 be 40005e04 40005d6c: a0 10 00 19 mov %i1, %l0 return EINVAL; if ( count == 0 ) 40005d70: 80 a6 a0 00 cmp %i2, 0 40005d74: 02 80 00 24 be 40005e04 40005d78: 80 a6 60 00 cmp %i1, 0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 40005d7c: 22 80 00 25 be,a 40005e10 40005d80: 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 ) 40005d84: c2 04 00 00 ld [ %l0 ], %g1 40005d88: 80 a0 60 00 cmp %g1, 0 40005d8c: 22 80 00 1c be,a 40005dfc 40005d90: b0 10 20 16 mov 0x16, %i0 return EINVAL; switch ( the_attr->process_shared ) { 40005d94: c2 04 20 04 ld [ %l0 + 4 ], %g1 40005d98: 80 a0 60 00 cmp %g1, 0 40005d9c: 32 80 00 18 bne,a 40005dfc 40005da0: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40005da4: 33 10 00 71 sethi %hi(0x4001c400), %i1 40005da8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 ! 4001c410 <_Thread_Dispatch_disable_level> /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; the_attributes.maximum_count = count; 40005dac: f4 27 bf f4 st %i2, [ %fp + -12 ] 40005db0: 82 00 60 01 inc %g1 } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 40005db4: c0 27 bf f0 clr [ %fp + -16 ] 40005db8: c2 26 60 10 st %g1, [ %i1 + 0x10 ] * 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 *) 40005dbc: 35 10 00 72 sethi %hi(0x4001c800), %i2 40005dc0: 40 00 0b b2 call 40008c88 <_Objects_Allocate> 40005dc4: 90 16 a0 c0 or %i2, 0xc0, %o0 ! 4001c8c0 <_POSIX_Barrier_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 40005dc8: a0 92 20 00 orcc %o0, 0, %l0 40005dcc: 12 80 00 15 bne 40005e20 40005dd0: 90 04 20 10 add %l0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005dd4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 40005dd8: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 40005ddc: 82 00 7f ff add %g1, -1, %g1 40005de0: c2 26 60 10 st %g1, [ %i1 + 0x10 ] 40005de4: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 40005de8: 80 a0 a0 00 cmp %g2, 0 40005dec: 12 80 00 07 bne 40005e08 40005df0: 01 00 00 00 nop 40005df4: 40 00 11 e2 call 4000a57c <_Thread_Dispatch> 40005df8: 01 00 00 00 nop 40005dfc: 81 c7 e0 08 ret 40005e00: 81 e8 00 00 restore 40005e04: b0 10 20 16 mov 0x16, %i0 * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; } 40005e08: 81 c7 e0 08 ret 40005e0c: 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 ); 40005e10: 7f ff ff 7d call 40005c04 40005e14: 90 10 00 10 mov %l0, %o0 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 40005e18: 10 bf ff dc b 40005d88 40005e1c: c2 04 00 00 ld [ %l0 ], %g1 if ( !the_barrier ) { _Thread_Enable_dispatch(); return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 40005e20: 40 00 08 d9 call 40008184 <_CORE_barrier_Initialize> 40005e24: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005e28: 90 16 a0 c0 or %i2, 0xc0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40005e2c: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005e30: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40005e34: 03 00 00 3f sethi %hi(0xfc00), %g1 40005e38: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40005e3c: 82 08 c0 01 and %g3, %g1, %g1 40005e40: 80 a0 40 02 cmp %g1, %g2 40005e44: 38 80 00 06 bgu,a 40005e5c 40005e48: c6 26 00 00 st %g3, [ %i0 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40005e4c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40005e50: 83 28 60 02 sll %g1, 2, %g1 40005e54: e0 20 80 01 st %l0, [ %g2 + %g1 ] ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 40005e58: c6 26 00 00 st %g3, [ %i0 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 40005e5c: c0 24 20 0c clr [ %l0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005e60: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 40005e64: 10 bf ff de b 40005ddc 40005e68: b0 10 20 00 clr %i0 40005e6c : */ int pthread_barrier_wait( pthread_barrier_t *barrier ) { 40005e6c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 40005e70: 80 a6 20 00 cmp %i0, 0 40005e74: 02 80 00 24 be 40005f04 40005e78: 11 10 00 72 sethi %hi(0x4001c800), %o0 RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get ( pthread_barrier_t *barrier, Objects_Locations *location ) { return (POSIX_Barrier_Control *) _Objects_Get( 40005e7c: d2 06 00 00 ld [ %i0 ], %o1 40005e80: 94 07 bf f4 add %fp, -12, %o2 40005e84: 40 00 0c d2 call 400091cc <_Objects_Get> 40005e88: 90 12 20 c0 or %o0, 0xc0, %o0 return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 40005e8c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005e90: 80 a0 60 00 cmp %g1, 0 40005e94: 22 80 00 09 be,a 40005eb8 40005e98: d2 02 20 08 ld [ %o0 + 8 ], %o1 40005e9c: 80 a0 60 02 cmp %g1, 2 40005ea0: 08 80 00 1a bleu 40005f08 40005ea4: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40005ea8: 40 00 01 d3 call 400065f4 <== NOT EXECUTED 40005eac: 01 00 00 00 nop <== NOT EXECUTED } 40005eb0: 81 c7 e0 08 ret <== NOT EXECUTED 40005eb4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_barrier_Wait( 40005eb8: 94 10 20 01 mov 1, %o2 40005ebc: 90 02 20 10 add %o0, 0x10, %o0 40005ec0: 96 10 20 00 clr %o3 40005ec4: 40 00 08 bc call 400081b4 <_CORE_barrier_Wait> 40005ec8: 98 10 20 00 clr %o4 40005ecc: 03 10 00 71 sethi %hi(0x4001c400), %g1 40005ed0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 4001c410 <_Thread_Dispatch_disable_level> 40005ed4: 84 00 bf ff add %g2, -1, %g2 40005ed8: c4 20 60 10 st %g2, [ %g1 + 0x10 ] 40005edc: c6 00 60 10 ld [ %g1 + 0x10 ], %g3 40005ee0: 80 a0 e0 00 cmp %g3, 0 40005ee4: 02 80 00 0b be 40005f10 40005ee8: 01 00 00 00 nop TRUE, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 40005eec: 03 10 00 71 sethi %hi(0x4001c400), %g1 <== NOT EXECUTED 40005ef0: c4 00 60 ec ld [ %g1 + 0xec ], %g2 ! 4001c4ec <_Thread_Executing> 40005ef4: 40 00 20 1a call 4000df5c <_POSIX_Barrier_Translate_core_barrier_return_code> 40005ef8: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40005efc: 81 c7 e0 08 ret 40005f00: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40005f04: 90 10 20 16 mov 0x16, %o0 } 40005f08: 81 c7 e0 08 ret 40005f0c: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40005f10: 40 00 11 9b call 4000a57c <_Thread_Dispatch> 40005f14: 01 00 00 00 nop TRUE, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 40005f18: 10 bf ff f6 b 40005ef0 40005f1c: 03 10 00 71 sethi %hi(0x4001c400), %g1 40005344 : */ int pthread_cancel( pthread_t thread ) { 40005344: 9d e3 bf 90 save %sp, -112, %sp /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 40005348: 03 10 00 5f sethi %hi(0x40017c00), %g1 4000534c: c4 00 61 14 ld [ %g1 + 0x114 ], %g2 ! 40017d14 <_ISR_Nest_level> */ int pthread_cancel( pthread_t thread ) { 40005350: 92 10 00 18 mov %i0, %o1 /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 40005354: 80 a0 a0 00 cmp %g2, 0 40005358: 12 80 00 11 bne 4000539c 4000535c: 90 10 20 47 mov 0x47, %o0 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 40005360: 11 10 00 5f sethi %hi(0x40017c00), %o0 40005364: 94 07 bf f4 add %fp, -12, %o2 40005368: 40 00 0d aa call 40008a10 <_Objects_Get> 4000536c: 90 12 23 38 or %o0, 0x338, %o0 return EPROTO; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 40005370: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005374: 80 a0 60 01 cmp %g1, 1 40005378: 02 80 00 22 be 40005400 4000537c: 01 00 00 00 nop 40005380: 2a 80 00 09 bcs,a 400053a4 40005384: c6 02 21 70 ld [ %o0 + 0x170 ], %g3 40005388: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000538c: 02 80 00 04 be 4000539c <== NOT EXECUTED 40005390: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40005394: 40 00 02 d9 call 40005ef8 <== NOT EXECUTED 40005398: 01 00 00 00 nop <== NOT EXECUTED } 4000539c: 81 c7 e0 08 ret <== NOT EXECUTED 400053a0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: return POSIX_MP_NOT_IMPLEMENTED(); case OBJECTS_LOCAL: thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; thread_support->cancelation_requested = 1; 400053a4: 82 10 20 01 mov 1, %g1 if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 400053a8: c4 00 e0 cc ld [ %g3 + 0xcc ], %g2 400053ac: 80 a0 a0 00 cmp %g2, 0 400053b0: 12 80 00 06 bne 400053c8 400053b4: c2 20 e0 d4 st %g1, [ %g3 + 0xd4 ] 400053b8: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 400053bc: 80 a0 60 01 cmp %g1, 1 400053c0: 02 80 00 14 be 40005410 400053c4: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400053c8: 03 10 00 5f sethi %hi(0x40017c00), %g1 400053cc: c4 00 60 50 ld [ %g1 + 0x50 ], %g2 ! 40017c50 <_Thread_Dispatch_disable_level> 400053d0: 90 10 20 00 clr %o0 400053d4: 84 00 bf ff add %g2, -1, %g2 400053d8: c4 20 60 50 st %g2, [ %g1 + 0x50 ] 400053dc: c6 00 60 50 ld [ %g1 + 0x50 ], %g3 400053e0: 80 a0 e0 00 cmp %g3, 0 400053e4: 12 bf ff ee bne 4000539c 400053e8: 01 00 00 00 nop _Thread_Dispatch(); 400053ec: 40 00 12 75 call 40009dc0 <_Thread_Dispatch> 400053f0: 01 00 00 00 nop 400053f4: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 400053f8: 81 c7 e0 08 ret 400053fc: 91 e8 00 08 restore %g0, %o0, %o0 the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { case OBJECTS_ERROR: return EINVAL; case OBJECTS_REMOTE: return POSIX_MP_NOT_IMPLEMENTED(); 40005400: 40 00 02 c8 call 40005f20 <== NOT EXECUTED 40005404: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40005408: 81 c7 e0 08 ret <== NOT EXECUTED 4000540c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED thread_support->cancelation_requested = 1; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS ) { _POSIX_Threads_cancel_run( the_thread ); 40005410: 40 00 00 03 call 4000541c <_POSIX_Threads_cancel_run> 40005414: 01 00 00 00 nop 40005418: 30 bf ff ec b,a 400053c8 40006608 : */ int pthread_cond_destroy( pthread_cond_t *cond ) { 40006608: 9d e3 bf 90 save %sp, -112, %sp ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 4000660c: 80 a6 20 00 cmp %i0, 0 40006610: 32 80 00 05 bne,a 40006624 40006614: d2 06 00 00 ld [ %i0 ], %o1 } #endif _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40006618: 90 10 20 16 mov 0x16, %o0 } 4000661c: 81 c7 e0 08 ret 40006620: 91 e8 00 08 restore %g0, %o0, %o0 *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 40006624: 80 a2 7f ff cmp %o1, -1 40006628: 02 80 00 3d be 4000671c 4000662c: 90 10 00 18 mov %i0, %o0 /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 40006630: 21 10 00 65 sethi %hi(0x40019400), %l0 40006634: 94 07 bf f4 add %fp, -12, %o2 40006638: 40 00 10 02 call 4000a640 <_Objects_Get> 4000663c: 90 14 23 2c or %l0, 0x32c, %o0 { POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 40006640: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006644: 80 a0 60 00 cmp %g1, 0 40006648: 12 80 00 14 bne 40006698 4000664c: b0 10 00 08 mov %o0, %i0 return EINVAL; case OBJECTS_LOCAL: if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { 40006650: 40 00 17 5e call 4000c3c8 <_Thread_queue_First> 40006654: 90 02 20 18 add %o0, 0x18, %o0 40006658: 80 a2 20 00 cmp %o0, 0 4000665c: 02 80 00 15 be 400066b0 40006660: 90 14 23 2c or %l0, 0x32c, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006664: 03 10 00 64 sethi %hi(0x40019000), %g1 40006668: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 400191e0 <_Thread_Dispatch_disable_level> 4000666c: 90 10 20 10 mov 0x10, %o0 40006670: 84 00 bf ff add %g2, -1, %g2 40006674: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 40006678: c6 00 61 e0 ld [ %g1 + 0x1e0 ], %g3 4000667c: 80 a0 e0 00 cmp %g3, 0 40006680: 12 bf ff e7 bne 4000661c 40006684: 01 00 00 00 nop _Thread_Dispatch(); 40006688: 40 00 14 da call 4000b9f0 <_Thread_Dispatch> 4000668c: 01 00 00 00 nop 40006690: 10 bf ff e3 b 4000661c 40006694: 90 10 20 10 mov 0x10, %o0 ! 10 { POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 40006698: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000669c: 28 bf ff e0 bleu,a 4000661c <== NOT EXECUTED 400066a0: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED } #endif _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400066a4: 40 00 05 3f call 40007ba0 <== NOT EXECUTED 400066a8: 01 00 00 00 nop <== NOT EXECUTED 400066ac: 30 bf ff dc b,a 4000661c <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 400066b0: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400066b4: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 400066b8: 05 00 00 3f sethi %hi(0xfc00), %g2 400066bc: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 400066c0: 82 08 40 02 and %g1, %g2, %g1 400066c4: 80 a0 40 03 cmp %g1, %g3 400066c8: 38 80 00 06 bgu,a 400066e0 400066cc: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 400066d0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400066d4: 83 28 60 02 sll %g1, 2, %g1 400066d8: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 400066dc: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free ( POSIX_Condition_variables_Control *the_condition_variable ) { _Objects_Free( 400066e0: 40 00 0f 95 call 4000a534 <_Objects_Free> 400066e4: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400066e8: 03 10 00 64 sethi %hi(0x40019000), %g1 400066ec: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 400191e0 <_Thread_Dispatch_disable_level> 400066f0: 90 10 20 00 clr %o0 400066f4: 84 00 bf ff add %g2, -1, %g2 400066f8: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 400066fc: c6 00 61 e0 ld [ %g1 + 0x1e0 ], %g3 40006700: 80 a0 e0 00 cmp %g3, 0 40006704: 12 bf ff c6 bne 4000661c 40006708: 01 00 00 00 nop _Thread_Dispatch(); 4000670c: 40 00 14 b9 call 4000b9f0 <_Thread_Dispatch> 40006710: 01 00 00 00 nop 40006714: 10 bf ff c2 b 4000661c 40006718: 90 10 20 00 clr %o0 ! 0 if ( *id == PTHREAD_COND_INITIALIZER ) { /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 4000671c: 40 00 00 07 call 40006738 <== NOT EXECUTED 40006720: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 40006724: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40006728: 12 bf ff bd bne 4000661c <== NOT EXECUTED 4000672c: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 40006730: 10 bf ff c0 b 40006630 <== NOT EXECUTED 40006734: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 40006738 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 40006738: 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; 4000673c: 03 10 00 5d sethi %hi(0x40017400), %g1 int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 40006740: a6 10 00 18 mov %i0, %l3 POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 40006744: 80 a6 60 00 cmp %i1, 0 40006748: 02 80 00 03 be 40006754 4000674c: a0 10 60 64 or %g1, 0x64, %l0 40006750: a0 10 00 19 mov %i1, %l0 /* * XXX: Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 40006754: c2 04 20 04 ld [ %l0 + 4 ], %g1 40006758: 80 a0 60 01 cmp %g1, 1 4000675c: 02 80 00 3d be 40006850 40006760: 01 00 00 00 nop return POSIX_MP_NOT_IMPLEMENTED(); if ( !the_attr->is_initialized ) 40006764: c2 04 00 00 ld [ %l0 ], %g1 40006768: 80 a0 60 00 cmp %g1, 0 4000676c: 02 80 00 16 be 400067c4 40006770: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006774: 23 10 00 64 sethi %hi(0x40019000), %l1 40006778: c2 04 61 e0 ld [ %l1 + 0x1e0 ], %g1 ! 400191e0 <_Thread_Dispatch_disable_level> 4000677c: 82 00 60 01 inc %g1 40006780: c2 24 61 e0 st %g1, [ %l1 + 0x1e0 ] */ RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) 40006784: 25 10 00 65 sethi %hi(0x40019400), %l2 40006788: 40 00 0e 5d call 4000a0fc <_Objects_Allocate> 4000678c: 90 14 a3 2c or %l2, 0x32c, %o0 ! 4001972c <_POSIX_Condition_variables_Information> _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 40006790: b2 92 20 00 orcc %o0, 0, %i1 40006794: 32 80 00 0e bne,a 400067cc 40006798: c2 04 20 04 ld [ %l0 + 4 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000679c: c2 04 61 e0 ld [ %l1 + 0x1e0 ], %g1 400067a0: b0 10 20 0c mov 0xc, %i0 400067a4: 82 00 7f ff add %g1, -1, %g1 400067a8: c2 24 61 e0 st %g1, [ %l1 + 0x1e0 ] 400067ac: c4 04 61 e0 ld [ %l1 + 0x1e0 ], %g2 400067b0: 80 a0 a0 00 cmp %g2, 0 400067b4: 12 80 00 25 bne 40006848 400067b8: 01 00 00 00 nop _Thread_Dispatch(); 400067bc: 40 00 14 8d call 4000b9f0 <_Thread_Dispatch> 400067c0: 01 00 00 00 nop 400067c4: 81 c7 e0 08 ret 400067c8: 81 e8 00 00 restore the_cond->process_shared = the_attr->process_shared; the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 400067cc: 90 06 60 18 add %i1, 0x18, %o0 _Thread_Enable_dispatch(); return EAGAIN; } #endif the_cond->process_shared = the_attr->process_shared; 400067d0: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 400067d4: c0 26 60 14 clr [ %i1 + 0x14 ] /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 400067d8: 92 10 20 00 clr %o1 400067dc: 94 10 28 00 mov 0x800, %o2 400067e0: 40 00 17 24 call 4000c470 <_Thread_queue_Initialize> 400067e4: 96 10 20 74 mov 0x74, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400067e8: 90 14 a3 2c or %l2, 0x32c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 400067ec: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400067f0: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 400067f4: 03 00 00 3f sethi %hi(0xfc00), %g1 400067f8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400067fc: 82 08 c0 01 and %g3, %g1, %g1 40006800: 80 a0 40 02 cmp %g1, %g2 40006804: 38 80 00 06 bgu,a 4000681c 40006808: c6 24 c0 00 st %g3, [ %l3 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000680c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006810: 83 28 60 02 sll %g1, 2, %g1 40006814: f2 20 80 01 st %i1, [ %g2 + %g1 ] &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 40006818: c6 24 c0 00 st %g3, [ %l3 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 4000681c: c0 26 60 0c clr [ %i1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006820: c2 04 61 e0 ld [ %l1 + 0x1e0 ], %g1 40006824: b0 10 20 00 clr %i0 40006828: 82 00 7f ff add %g1, -1, %g1 4000682c: c2 24 61 e0 st %g1, [ %l1 + 0x1e0 ] 40006830: c4 04 61 e0 ld [ %l1 + 0x1e0 ], %g2 40006834: 80 a0 a0 00 cmp %g2, 0 40006838: 12 80 00 04 bne 40006848 4000683c: 01 00 00 00 nop _Thread_Dispatch(); 40006840: 40 00 14 6c call 4000b9f0 <_Thread_Dispatch> 40006844: 01 00 00 00 nop #endif _Thread_Enable_dispatch(); return 0; } 40006848: 81 c7 e0 08 ret 4000684c: 81 e8 00 00 restore /* * XXX: Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return POSIX_MP_NOT_IMPLEMENTED(); 40006850: 40 00 04 de call 40007bc8 <== NOT EXECUTED 40006854: 81 e8 00 00 restore <== NOT EXECUTED 40006858: 01 00 00 00 nop 400065b4 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 400065b4: 9d e3 bf 68 save %sp, -152, %sp Thread_Control *the_thread; POSIX_API_Control *api; int schedpolicy = SCHED_RR; struct sched_param schedparam; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 400065b8: 03 10 00 72 sethi %hi(0x4001c800), %g1 pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 400065bc: ac 10 00 18 mov %i0, %l6 Thread_Control *the_thread; POSIX_API_Control *api; int schedpolicy = SCHED_RR; struct sched_param schedparam; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 400065c0: 80 a6 60 00 cmp %i1, 0 400065c4: 02 80 00 03 be 400065d0 400065c8: a2 10 63 d8 or %g1, 0x3d8, %l1 400065cc: a2 10 00 19 mov %i1, %l1 if ( !the_attr->is_initialized ) 400065d0: c2 04 40 00 ld [ %l1 ], %g1 400065d4: 80 a0 60 00 cmp %g1, 0 400065d8: 02 80 00 10 be 40006618 400065dc: 01 00 00 00 nop /* * Core Thread Initialize insures we get the minimum amount of * stack space if it is allowed to allocate it itself. */ if ( the_attr->stackaddr && !_Stack_Is_enough( the_attr->stacksize ) ) 400065e0: c2 04 60 04 ld [ %l1 + 4 ], %g1 400065e4: 80 a0 60 00 cmp %g1, 0 400065e8: 22 80 00 07 be,a 40006604 400065ec: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 400065f0: c2 04 60 08 ld [ %l1 + 8 ], %g1 400065f4: 80 a0 6f ff cmp %g1, 0xfff 400065f8: 08 80 00 08 bleu 40006618 400065fc: 01 00 00 00 nop * 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 ) { 40006600: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 <== NOT EXECUTED 40006604: 80 a0 60 01 cmp %g1, 1 40006608: 02 80 00 34 be 400066d8 4000660c: 80 a0 60 02 cmp %g1, 2 40006610: 22 80 00 04 be,a 40006620 40006614: c4 04 60 18 ld [ %l1 + 0x18 ], %g2 40006618: 81 c7 e0 08 ret 4000661c: 91 e8 20 16 restore %g0, 0x16, %o0 schedpolicy = api->schedpolicy; schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 40006620: f2 04 60 14 ld [ %l1 + 0x14 ], %i1 schedparam = the_attr->schedparam; 40006624: c4 27 bf e0 st %g2, [ %fp + -32 ] 40006628: c2 04 60 1c ld [ %l1 + 0x1c ], %g1 4000662c: c2 27 bf e4 st %g1, [ %fp + -28 ] 40006630: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 40006634: c4 27 bf e8 st %g2, [ %fp + -24 ] 40006638: c2 04 60 24 ld [ %l1 + 0x24 ], %g1 4000663c: c2 27 bf ec st %g1, [ %fp + -20 ] 40006640: c4 04 60 28 ld [ %l1 + 0x28 ], %g2 40006644: c4 27 bf f0 st %g2, [ %fp + -16 ] 40006648: c2 04 60 2c ld [ %l1 + 0x2c ], %g1 4000664c: 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 ) 40006650: c2 04 60 0c ld [ %l1 + 0xc ], %g1 40006654: 80 a0 60 00 cmp %g1, 0 40006658: 12 80 00 1e bne 400066d0 4000665c: b0 10 20 86 mov 0x86, %i0 /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 40006660: e6 07 bf e0 ld [ %fp + -32 ], %l3 40006664: 82 04 ff ff add %l3, -1, %g1 40006668: 80 a0 60 fd cmp %g1, 0xfd 4000666c: 18 bf ff eb bgu 40006618 40006670: 80 a6 60 01 cmp %i1, 1 */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 40006674: 02 80 00 41 be 40006778 40006678: a8 10 20 00 clr %l4 4000667c: 04 80 00 41 ble 40006780 40006680: 80 a6 60 02 cmp %i1, 2 40006684: 02 80 00 26 be 4000671c 40006688: 80 a6 60 03 cmp %i1, 3 4000668c: 12 bf ff e3 bne 40006618 40006690: 01 00 00 00 nop 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 ) < 40006694: 40 00 17 62 call 4000c41c <_Timespec_To_ticks> 40006698: 90 07 bf e8 add %fp, -24, %o0 4000669c: a0 10 00 08 mov %o0, %l0 400066a0: 40 00 17 5f call 4000c41c <_Timespec_To_ticks> 400066a4: 90 07 bf f0 add %fp, -16, %o0 400066a8: 80 a4 00 08 cmp %l0, %o0 400066ac: 0a bf ff db bcs 40006618 400066b0: c2 07 bf e4 ld [ %fp + -28 ], %g1 _Timespec_To_ticks( &schedparam.ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( schedparam.ss_low_priority ) ) 400066b4: 82 00 7f ff add %g1, -1, %g1 400066b8: 80 a0 60 fd cmp %g1, 0xfd 400066bc: 18 bf ff d7 bgu 40006618 400066c0: 03 10 00 1b sethi %hi(0x40006c00), %g1 400066c4: a8 10 20 03 mov 3, %l4 400066c8: 10 80 00 17 b 40006724 400066cc: b0 10 61 40 or %g1, 0x140, %i0 *thread = the_thread->Object.id; _Thread_Enable_dispatch(); return 0; } 400066d0: 81 c7 e0 08 ret 400066d4: 81 e8 00 00 restore * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 400066d8: 03 10 00 7a sethi %hi(0x4001e800), %g1 400066dc: c4 00 63 3c ld [ %g1 + 0x33c ], %g2 ! 4001eb3c <_Thread_Executing> 400066e0: c6 00 a1 70 ld [ %g2 + 0x170 ], %g3 schedpolicy = api->schedpolicy; schedparam = api->schedparam; 400066e4: 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; 400066e8: f2 00 e0 7c ld [ %g3 + 0x7c ], %i1 schedparam = api->schedparam; 400066ec: c8 27 bf e0 st %g4, [ %fp + -32 ] 400066f0: c2 00 e0 84 ld [ %g3 + 0x84 ], %g1 400066f4: c2 27 bf e4 st %g1, [ %fp + -28 ] 400066f8: c4 00 e0 88 ld [ %g3 + 0x88 ], %g2 400066fc: c4 27 bf e8 st %g2, [ %fp + -24 ] 40006700: c2 00 e0 8c ld [ %g3 + 0x8c ], %g1 40006704: c2 27 bf ec st %g1, [ %fp + -20 ] 40006708: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 4000670c: c4 27 bf f0 st %g2, [ %fp + -16 ] 40006710: c2 00 e0 94 ld [ %g3 + 0x94 ], %g1 40006714: 10 bf ff cf b 40006650 40006718: c2 27 bf f4 st %g1, [ %fp + -12 ] */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 4000671c: a8 10 20 02 mov 2, %l4 <== NOT EXECUTED 40006720: b0 10 20 00 clr %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006724: 25 10 00 7a sethi %hi(0x4001e800), %l2 40006728: c2 04 a2 60 ld [ %l2 + 0x260 ], %g1 ! 4001ea60 <_Thread_Dispatch_disable_level> 4000672c: 82 00 60 01 inc %g1 40006730: c2 24 a2 60 st %g1, [ %l2 + 0x260 ] * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 40006734: 2b 10 00 7b sethi %hi(0x4001ec00), %l5 40006738: 40 00 0c 4e call 40009870 <_Objects_Allocate> 4000673c: 90 15 61 48 or %l5, 0x148, %o0 ! 4001ed48 <_POSIX_Threads_Information> * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 40006740: a0 92 20 00 orcc %o0, 0, %l0 40006744: 32 80 00 14 bne,a 40006794 40006748: d4 04 60 04 ld [ %l1 + 4 ], %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000674c: c2 04 a2 60 ld [ %l2 + 0x260 ], %g1 40006750: 82 00 7f ff add %g1, -1, %g1 40006754: c2 24 a2 60 st %g1, [ %l2 + 0x260 ] 40006758: c4 04 a2 60 ld [ %l2 + 0x260 ], %g2 4000675c: 80 a0 a0 00 cmp %g2, 0 40006760: 12 bf ff dc bne 400066d0 40006764: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 40006768: 40 00 12 7f call 4000b164 <_Thread_Dispatch> 4000676c: 01 00 00 00 nop 40006770: 81 c7 e0 08 ret 40006774: 81 e8 00 00 restore */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 40006778: 10 bf ff eb b 40006724 4000677c: b0 10 20 00 clr %i0 40006780: 80 a6 60 00 cmp %i1, 0 40006784: a8 10 20 01 mov 1, %l4 40006788: 02 bf ff e7 be 40006724 4000678c: b0 10 20 00 clr %i0 40006790: 30 bf ff a2 b,a 40006618 /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 40006794: d6 04 60 08 ld [ %l1 + 8 ], %o3 40006798: 9a 10 20 ff mov 0xff, %o5 4000679c: e8 23 a0 60 st %l4, [ %sp + 0x60 ] 400067a0: f0 23 a0 64 st %i0, [ %sp + 0x64 ] 400067a4: c0 23 a0 68 clr [ %sp + 0x68 ] 400067a8: c0 23 a0 6c clr [ %sp + 0x6c ] 400067ac: 9a 23 40 13 sub %o5, %l3, %o5 400067b0: a8 10 20 01 mov 1, %l4 400067b4: 90 15 61 48 or %l5, 0x148, %o0 400067b8: e8 23 a0 5c st %l4, [ %sp + 0x5c ] 400067bc: 92 10 00 10 mov %l0, %o1 400067c0: 40 00 12 d7 call 4000b31c <_Thread_Initialize> 400067c4: 98 10 20 00 clr %o4 budget_callout, 0, /* isr level */ NULL /* posix threads don't have a name */ ); if ( !status ) { 400067c8: 80 a2 20 00 cmp %o0, 0 400067cc: 12 80 00 05 bne 400067e0 400067d0: 90 15 61 48 or %l5, 0x148, %o0 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 400067d4: 40 00 0d 35 call 40009ca8 <_Objects_Free> 400067d8: 92 10 00 10 mov %l0, %o1 400067dc: 30 bf ff dc b,a 4000674c /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 400067e0: e6 04 21 70 ld [ %l0 + 0x170 ], %l3 api->Attributes = *the_attr; 400067e4: 92 10 00 11 mov %l1, %o1 400067e8: 94 10 20 38 mov 0x38, %o2 400067ec: 40 00 2a 61 call 40011170 400067f0: 90 10 00 13 mov %l3, %o0 api->detachstate = the_attr->detachstate; 400067f4: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 api->schedpolicy = schedpolicy; 400067f8: f2 24 e0 7c st %i1, [ %l3 + 0x7c ] api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; 400067fc: c2 24 e0 38 st %g1, [ %l3 + 0x38 ] api->schedpolicy = schedpolicy; api->schedparam = schedparam; 40006800: c2 07 bf e0 ld [ %fp + -32 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 40006804: 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; 40006808: c2 24 e0 80 st %g1, [ %l3 + 0x80 ] 4000680c: c2 07 bf e4 ld [ %fp + -28 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 40006810: 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; 40006814: c2 24 e0 84 st %g1, [ %l3 + 0x84 ] 40006818: c2 07 bf e8 ld [ %fp + -24 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 4000681c: 90 10 00 10 mov %l0, %o0 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 40006820: c2 24 e0 88 st %g1, [ %l3 + 0x88 ] 40006824: c2 07 bf ec ld [ %fp + -20 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 40006828: 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; 4000682c: c2 24 e0 8c st %g1, [ %l3 + 0x8c ] 40006830: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 40006834: 98 10 20 00 clr %o4 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 40006838: c2 24 e0 90 st %g1, [ %l3 + 0x90 ] 4000683c: c4 07 bf f4 ld [ %fp + -12 ], %g2 40006840: c4 24 e0 94 st %g2, [ %l3 + 0x94 ] /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 40006844: 40 00 16 39 call 4000c128 <_Thread_Start> 40006848: e8 24 20 78 st %l4, [ %l0 + 0x78 ] start_routine, arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { 4000684c: 80 a6 60 03 cmp %i1, 3 40006850: 02 80 00 12 be 40006898 40006854: a2 10 00 08 mov %o0, %l1 /* * _Thread_Start only fails if the thread was in the incorrect state */ if ( !status ) { 40006858: 80 a4 60 00 cmp %l1, 0 4000685c: 12 80 00 18 bne 400068bc 40006860: 90 15 61 48 or %l5, 0x148, %o0 40006864: 40 00 0d 11 call 40009ca8 <_Objects_Free> <== NOT EXECUTED 40006868: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000686c: c2 04 a2 60 ld [ %l2 + 0x260 ], %g1 <== NOT EXECUTED 40006870: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40006874: c2 24 a2 60 st %g1, [ %l2 + 0x260 ] <== NOT EXECUTED 40006878: c4 04 a2 60 ld [ %l2 + 0x260 ], %g2 <== NOT EXECUTED 4000687c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40006880: 12 bf ff 66 bne 40006618 <== NOT EXECUTED 40006884: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 40006888: 40 00 12 37 call 4000b164 <_Thread_Dispatch> <== NOT EXECUTED 4000688c: b0 10 20 16 mov 0x16, %i0 ! 16 <== NOT EXECUTED 40006890: 81 c7 e0 08 ret <== NOT EXECUTED 40006894: 81 e8 00 00 restore <== NOT EXECUTED arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 40006898: 40 00 16 e1 call 4000c41c <_Timespec_To_ticks> 4000689c: 90 04 e0 88 add %l3, 0x88, %o0 400068a0: 92 04 e0 9c add %l3, 0x9c, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400068a4: d0 24 e0 a8 st %o0, [ %l3 + 0xa8 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400068a8: 11 10 00 7a sethi %hi(0x4001e800), %o0 400068ac: 40 00 17 ef call 4000c868 <_Watchdog_Insert> 400068b0: 90 12 23 5c or %o0, 0x35c, %o0 ! 4001eb5c <_Watchdog_Ticks_chain> /* * _Thread_Start only fails if the thread was in the incorrect state */ if ( !status ) { 400068b4: 10 bf ff ea b 4000685c 400068b8: 80 a4 60 00 cmp %l1, 0 /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 400068bc: c2 04 20 08 ld [ %l0 + 8 ], %g1 400068c0: c2 25 80 00 st %g1, [ %l6 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400068c4: c2 04 a2 60 ld [ %l2 + 0x260 ], %g1 400068c8: b0 10 20 00 clr %i0 400068cc: 82 00 7f ff add %g1, -1, %g1 400068d0: c2 24 a2 60 st %g1, [ %l2 + 0x260 ] 400068d4: c4 04 a2 60 ld [ %l2 + 0x260 ], %g2 400068d8: 80 a0 a0 00 cmp %g2, 0 400068dc: 12 80 00 04 bne 400068ec 400068e0: 01 00 00 00 nop _Thread_Dispatch(); 400068e4: 40 00 12 20 call 4000b164 <_Thread_Dispatch> 400068e8: 01 00 00 00 nop 400068ec: 81 c7 e0 08 ret 400068f0: 81 e8 00 00 restore 40005c74 : #include int pthread_detach( pthread_t thread ) { 40005c74: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 40005c78: 11 10 00 5f sethi %hi(0x40017c00), %o0 40005c7c: 92 10 00 18 mov %i0, %o1 40005c80: 90 12 21 98 or %o0, 0x198, %o0 40005c84: 40 00 0c 94 call 40008ed4 <_Objects_Get> 40005c88: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; POSIX_API_Control *api; Objects_Locations location; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 40005c8c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005c90: 80 a0 60 00 cmp %g1, 0 40005c94: 12 80 00 0f bne 40005cd0 40005c98: 80 a0 60 02 cmp %g1, 2 case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->detachstate = PTHREAD_CREATE_DETACHED; 40005c9c: c2 02 21 70 ld [ %o0 + 0x170 ], %g1 40005ca0: c0 20 60 38 clr [ %g1 + 0x38 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005ca4: 07 10 00 5e sethi %hi(0x40017800), %g3 40005ca8: c2 00 e2 b0 ld [ %g3 + 0x2b0 ], %g1 ! 40017ab0 <_Thread_Dispatch_disable_level> 40005cac: 90 10 20 00 clr %o0 40005cb0: 82 00 7f ff add %g1, -1, %g1 40005cb4: c2 20 e2 b0 st %g1, [ %g3 + 0x2b0 ] 40005cb8: c4 00 e2 b0 ld [ %g3 + 0x2b0 ], %g2 40005cbc: 80 a0 a0 00 cmp %g2, 0 40005cc0: 02 80 00 0a be 40005ce8 40005cc4: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40005cc8: 81 c7 e0 08 ret 40005ccc: 91 e8 00 08 restore %g0, %o0, %o0 register Thread_Control *the_thread; POSIX_API_Control *api; Objects_Locations location; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 40005cd0: 08 bf ff fe bleu 40005cc8 40005cd4: 90 10 20 03 mov 3, %o0 api->detachstate = PTHREAD_CREATE_DETACHED; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40005cd8: 40 00 01 c6 call 400063f0 <== NOT EXECUTED 40005cdc: 01 00 00 00 nop <== NOT EXECUTED } 40005ce0: 81 c7 e0 08 ret <== NOT EXECUTED 40005ce4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40005ce8: 40 00 11 67 call 4000a284 <_Thread_Dispatch> 40005cec: 01 00 00 00 nop 40005cf0: 90 10 20 00 clr %o0 ! 0 40005cf4: 81 c7 e0 08 ret 40005cf8: 91 e8 00 08 restore %g0, %o0, %o0 4000e6a8 : #include void pthread_exit( void *value_ptr ) { 4000e6a8: 9d e3 bf 98 save %sp, -104, %sp Objects_Information *the_information; the_information = _Objects_Get_information( _Thread_Executing->Object.id ); 4000e6ac: 25 10 00 6b sethi %hi(0x4001ac00), %l2 4000e6b0: c2 04 a0 3c ld [ %l2 + 0x3c ], %g1 ! 4001ac3c <_Thread_Executing> 4000e6b4: c6 00 60 08 ld [ %g1 + 8 ], %g3 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 4000e6b8: 03 10 00 6a sethi %hi(0x4001a800), %g1 4000e6bc: 85 30 e0 16 srl %g3, 0x16, %g2 4000e6c0: 82 10 62 c0 or %g1, 0x2c0, %g1 4000e6c4: 84 08 a0 1c and %g2, 0x1c, %g2 4000e6c8: c8 00 40 02 ld [ %g1 + %g2 ], %g4 4000e6cc: 87 30 e0 1b srl %g3, 0x1b, %g3 4000e6d0: 87 28 e0 02 sll %g3, 2, %g3 4000e6d4: e2 01 00 03 ld [ %g4 + %g3 ], %l1 /* This should never happen if _Thread_Get() works right */ assert( the_information ); 4000e6d8: 80 a4 60 00 cmp %l1, 0 4000e6dc: 22 80 00 19 be,a 4000e740 4000e6e0: 11 10 00 64 sethi %hi(0x40019000), %o0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000e6e4: 21 10 00 6a sethi %hi(0x4001a800), %l0 4000e6e8: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> 4000e6ec: 82 00 60 01 inc %g1 4000e6f0: c2 24 23 60 st %g1, [ %l0 + 0x360 ] _Thread_Disable_dispatch(); _Thread_Executing->Wait.return_argument = value_ptr; 4000e6f4: d2 04 a0 3c ld [ %l2 + 0x3c ], %o1 _Thread_Close( the_information, _Thread_Executing ); 4000e6f8: 90 10 00 11 mov %l1, %o0 4000e6fc: 7f ff ea 48 call 4000901c <_Thread_Close> 4000e700: f0 22 60 28 st %i0, [ %o1 + 0x28 ] RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 4000e704: d2 04 a0 3c ld [ %l2 + 0x3c ], %o1 4000e708: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000e70c: 7f ff e5 57 call 40007c68 <_Objects_Free> 4000e710: 90 12 22 48 or %o0, 0x248, %o0 ! 4001ae48 <_POSIX_Threads_Information> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000e714: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 4000e718: 82 00 7f ff add %g1, -1, %g1 4000e71c: c2 24 23 60 st %g1, [ %l0 + 0x360 ] 4000e720: c4 04 23 60 ld [ %l0 + 0x360 ], %g2 4000e724: 80 a0 a0 00 cmp %g2, 0 4000e728: 02 80 00 04 be 4000e738 4000e72c: 01 00 00 00 nop 4000e730: 81 c7 e0 08 ret <== NOT EXECUTED 4000e734: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4000e738: 7f ff ea b7 call 40009214 <_Thread_Dispatch> 4000e73c: 81 e8 00 00 restore Objects_Information *the_information; the_information = _Objects_Get_information( _Thread_Executing->Object.id ); /* This should never happen if _Thread_Get() works right */ assert( the_information ); 4000e740: 15 10 00 64 sethi %hi(0x40019000), %o2 <== NOT EXECUTED 4000e744: 90 12 21 a0 or %o0, 0x1a0, %o0 <== NOT EXECUTED 4000e748: 94 12 a1 e8 or %o2, 0x1e8, %o2 <== NOT EXECUTED 4000e74c: 7f ff ce 01 call 40001f50 <__assert> <== NOT EXECUTED 4000e750: 92 10 20 25 mov 0x25, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000e754: 10 bf ff e5 b 4000e6e8 <== NOT EXECUTED 4000e758: 21 10 00 6a sethi %hi(0x4001a800), %l0 <== NOT EXECUTED 40008300 : int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { 40008300: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 40008304: 80 a6 60 00 cmp %i1, 0 40008308: 02 80 00 33 be 400083d4 4000830c: 92 10 00 18 mov %i0, %o1 40008310: 80 a6 a0 00 cmp %i2, 0 40008314: 02 80 00 30 be 400083d4 40008318: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 4000831c: 11 10 00 6c sethi %hi(0x4001b000), %o0 40008320: 40 00 0c b0 call 4000b5e0 <_Objects_Get> 40008324: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 4001b3d8 <_POSIX_Threads_Information> return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 40008328: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000832c: 80 a0 60 00 cmp %g1, 0 40008330: 22 80 00 09 be,a 40008354 40008334: c6 02 21 70 ld [ %o0 + 0x170 ], %g3 40008338: 80 a0 60 02 cmp %g1, 2 4000833c: 08 80 00 04 bleu 4000834c 40008340: 90 10 20 03 mov 3, %o0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40008344: 40 00 01 ee call 40008afc <== NOT EXECUTED 40008348: 01 00 00 00 nop <== NOT EXECUTED } 4000834c: 81 c7 e0 08 ret 40008350: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( policy ) *policy = api->schedpolicy; 40008354: c2 00 e0 7c ld [ %g3 + 0x7c ], %g1 40008358: c2 26 40 00 st %g1, [ %i1 ] if ( param ) { *param = api->schedparam; 4000835c: c4 00 e0 80 ld [ %g3 + 0x80 ], %g2 40008360: c4 26 80 00 st %g2, [ %i2 ] 40008364: c2 00 e0 84 ld [ %g3 + 0x84 ], %g1 40008368: c2 26 a0 04 st %g1, [ %i2 + 4 ] 4000836c: c4 00 e0 88 ld [ %g3 + 0x88 ], %g2 40008370: c4 26 a0 08 st %g2, [ %i2 + 8 ] 40008374: c2 00 e0 8c ld [ %g3 + 0x8c ], %g1 40008378: c2 26 a0 0c st %g1, [ %i2 + 0xc ] 4000837c: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 40008380: c4 26 a0 10 st %g2, [ %i2 + 0x10 ] 40008384: c2 00 e0 94 ld [ %g3 + 0x94 ], %g1 40008388: c2 26 a0 14 st %g1, [ %i2 + 0x14 ] param->sched_priority = 4000838c: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 40008390: 82 10 20 ff mov 0xff, %g1 40008394: 82 20 40 02 sub %g1, %g2, %g1 40008398: c2 26 80 00 st %g1, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000839c: 07 10 00 6c sethi %hi(0x4001b000), %g3 400083a0: c2 00 e0 f0 ld [ %g3 + 0xf0 ], %g1 ! 4001b0f0 <_Thread_Dispatch_disable_level> 400083a4: 90 10 20 00 clr %o0 400083a8: 82 00 7f ff add %g1, -1, %g1 400083ac: c2 20 e0 f0 st %g1, [ %g3 + 0xf0 ] 400083b0: c4 00 e0 f0 ld [ %g3 + 0xf0 ], %g2 400083b4: 80 a0 a0 00 cmp %g2, 0 400083b8: 12 bf ff e5 bne 4000834c 400083bc: 01 00 00 00 nop _Thread_Dispatch(); 400083c0: 40 00 11 74 call 4000c990 <_Thread_Dispatch> 400083c4: 01 00 00 00 nop 400083c8: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); } 400083cc: 81 c7 e0 08 ret 400083d0: 91 e8 00 08 restore %g0, %o0, %o0 { Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 400083d4: 10 bf ff de b 4000834c 400083d8: 90 10 20 16 mov 0x16, %o0 40005c60 : */ void *pthread_getspecific( pthread_key_t key ) { 40005c60: 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 *) 40005c64: 11 10 00 60 sethi %hi(0x40018000), %o0 40005c68: 92 10 00 18 mov %i0, %o1 40005c6c: 90 12 22 00 or %o0, 0x200, %o0 40005c70: 40 00 0d 4c call 400091a0 <_Objects_Get> 40005c74: 94 07 bf f4 add %fp, -12, %o2 uint32_t index; Objects_Locations location; void *key_data; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 40005c78: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005c7c: 80 a0 60 00 cmp %g1, 0 40005c80: 12 80 00 18 bne 40005ce0 40005c84: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never happen */ return NULL; case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 40005c88: 03 10 00 5f sethi %hi(0x40017c00), %g1 40005c8c: c4 00 61 dc ld [ %g1 + 0x1dc ], %g2 ! 40017ddc <_Thread_Executing> 40005c90: c6 00 a0 08 ld [ %g2 + 8 ], %g3 index = _Objects_Get_index( _Thread_Executing->Object.id ); key_data = (void *) the_key->Values[ api ][ index ]; 40005c94: 05 00 00 3f sethi %hi(0xfc00), %g2 40005c98: 83 30 e0 16 srl %g3, 0x16, %g1 40005c9c: 82 08 60 1c and %g1, 0x1c, %g1 40005ca0: 82 00 40 08 add %g1, %o0, %g1 40005ca4: c8 00 60 18 ld [ %g1 + 0x18 ], %g4 40005ca8: 84 10 a3 ff or %g2, 0x3ff, %g2 40005cac: 86 08 c0 02 and %g3, %g2, %g3 40005cb0: 87 28 e0 02 sll %g3, 2, %g3 40005cb4: f0 01 00 03 ld [ %g4 + %g3 ], %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005cb8: 05 10 00 5f sethi %hi(0x40017c00), %g2 40005cbc: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 ! 40017d00 <_Thread_Dispatch_disable_level> 40005cc0: 82 00 7f ff add %g1, -1, %g1 40005cc4: c2 20 a1 00 st %g1, [ %g2 + 0x100 ] 40005cc8: c6 00 a1 00 ld [ %g2 + 0x100 ], %g3 40005ccc: 80 a0 e0 00 cmp %g3, 0 40005cd0: 02 80 00 0a be 40005cf8 40005cd4: 01 00 00 00 nop _Thread_Enable_dispatch(); return key_data; } (void) POSIX_BOTTOM_REACHED(); return (void *)NULL; } 40005cd8: 81 c7 e0 08 ret 40005cdc: 81 e8 00 00 restore uint32_t index; Objects_Locations location; void *key_data; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 40005ce0: 08 bf ff fe bleu 40005cd8 40005ce4: b0 10 20 00 clr %i0 index = _Objects_Get_index( _Thread_Executing->Object.id ); key_data = (void *) the_key->Values[ api ][ index ]; _Thread_Enable_dispatch(); return key_data; } (void) POSIX_BOTTOM_REACHED(); 40005ce8: 40 00 02 75 call 400066bc <== NOT EXECUTED 40005cec: 01 00 00 00 nop <== NOT EXECUTED return (void *)NULL; } 40005cf0: 81 c7 e0 08 ret <== NOT EXECUTED 40005cf4: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40005cf8: 40 00 12 16 call 4000a550 <_Thread_Dispatch> 40005cfc: 01 00 00 00 nop 40005d00: 81 c7 e0 08 ret 40005d04: 81 e8 00 00 restore 400077d0 : int pthread_join( pthread_t thread, void **value_ptr ) { 400077d0: 9d e3 bf 90 save %sp, -112, %sp 400077d4: 11 10 00 69 sethi %hi(0x4001a400), %o0 400077d8: 92 10 00 18 mov %i0, %o1 400077dc: 90 12 20 d8 or %o0, 0xd8, %o0 400077e0: 40 00 0c 65 call 4000a974 <_Objects_Get> 400077e4: 94 07 bf f4 add %fp, -12, %o2 POSIX_API_Control *api; Objects_Locations location; void *return_pointer; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 400077e8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400077ec: 80 a0 60 00 cmp %g1, 0 400077f0: 12 80 00 15 bne 40007844 400077f4: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 400077f8: c6 02 21 70 ld [ %o0 + 0x170 ], %g3 if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { 400077fc: c2 00 e0 38 ld [ %g3 + 0x38 ], %g1 40007800: 80 a0 60 00 cmp %g1, 0 40007804: 12 80 00 16 bne 4000785c 40007808: 03 10 00 68 sethi %hi(0x4001a000), %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000780c: 03 10 00 68 sethi %hi(0x4001a000), %g1 40007810: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 4001a1f0 <_Thread_Dispatch_disable_level> 40007814: 90 10 20 16 mov 0x16, %o0 40007818: 84 00 bf ff add %g2, -1, %g2 4000781c: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 40007820: c6 00 61 f0 ld [ %g1 + 0x1f0 ], %g3 40007824: 80 a0 e0 00 cmp %g3, 0 40007828: 12 80 00 05 bne 4000783c 4000782c: 01 00 00 00 nop _Thread_Dispatch(); 40007830: 40 00 11 3d call 4000bd24 <_Thread_Dispatch> 40007834: 01 00 00 00 nop 40007838: 90 10 20 16 mov 0x16, %o0 ! 16 *value_ptr = return_pointer; return 0; } return POSIX_BOTTOM_REACHED(); } 4000783c: 81 c7 e0 08 ret 40007840: 91 e8 00 08 restore %g0, %o0, %o0 POSIX_API_Control *api; Objects_Locations location; void *return_pointer; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 40007844: 08 bf ff fe bleu 4000783c 40007848: 90 10 20 03 mov 3, %o0 if ( value_ptr ) *value_ptr = return_pointer; return 0; } return POSIX_BOTTOM_REACHED(); 4000784c: 40 00 01 91 call 40007e90 <== NOT EXECUTED 40007850: 01 00 00 00 nop <== NOT EXECUTED } 40007854: 81 c7 e0 08 ret <== NOT EXECUTED 40007858: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 4000785c: c4 00 62 cc ld [ %g1 + 0x2cc ], %g2 if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { _Thread_Enable_dispatch(); return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { 40007860: 80 a2 00 02 cmp %o0, %g2 40007864: 12 80 00 0f bne 400078a0 40007868: 82 07 bf f0 add %fp, -16, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000786c: 03 10 00 68 sethi %hi(0x4001a000), %g1 40007870: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 4001a1f0 <_Thread_Dispatch_disable_level> 40007874: 90 10 20 2d mov 0x2d, %o0 40007878: 84 00 bf ff add %g2, -1, %g2 4000787c: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 40007880: c6 00 61 f0 ld [ %g1 + 0x1f0 ], %g3 40007884: 80 a0 e0 00 cmp %g3, 0 40007888: 12 bf ff ed bne 4000783c 4000788c: 01 00 00 00 nop _Thread_Dispatch(); 40007890: 40 00 11 25 call 4000bd24 <_Thread_Dispatch> 40007894: 01 00 00 00 nop 40007898: 10 bf ff e9 b 4000783c 4000789c: 90 10 20 2d mov 0x2d, %o0 ! 2d /* * Put ourself on the threads join list */ _Thread_Executing->Wait.return_argument = &return_pointer; 400078a0: c2 20 a0 28 st %g1, [ %g2 + 0x28 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 400078a4: 84 10 20 01 mov 1, %g2 _Thread_queue_Enter_critical_section( &api->Join_List ); _Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT ); 400078a8: 90 00 e0 3c add %g3, 0x3c, %o0 400078ac: c4 20 e0 6c st %g2, [ %g3 + 0x6c ] 400078b0: 92 10 20 00 clr %o1 400078b4: 15 10 00 32 sethi %hi(0x4000c800), %o2 400078b8: 40 00 12 8b call 4000c2e4 <_Thread_queue_Enqueue_with_handler> 400078bc: 94 12 a0 24 or %o2, 0x24, %o2 ! 4000c824 <_Thread_queue_Timeout> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400078c0: 05 10 00 68 sethi %hi(0x4001a000), %g2 400078c4: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 4001a1f0 <_Thread_Dispatch_disable_level> 400078c8: 82 00 7f ff add %g1, -1, %g1 400078cc: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 400078d0: c6 00 a1 f0 ld [ %g2 + 0x1f0 ], %g3 400078d4: 80 a0 e0 00 cmp %g3, 0 400078d8: 12 80 00 05 bne 400078ec 400078dc: 80 a6 60 00 cmp %i1, 0 _Thread_Dispatch(); 400078e0: 40 00 11 11 call 4000bd24 <_Thread_Dispatch> 400078e4: 01 00 00 00 nop _Thread_Enable_dispatch(); if ( value_ptr ) 400078e8: 80 a6 60 00 cmp %i1, 0 400078ec: 02 bf ff d4 be 4000783c 400078f0: 90 10 20 00 clr %o0 *value_ptr = return_pointer; 400078f4: c2 07 bf f0 ld [ %fp + -16 ], %g1 400078f8: 10 bf ff d1 b 4000783c 400078fc: c2 26 40 00 st %g1, [ %i1 ] 400059d0 : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 400059d0: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400059d4: 25 10 00 5f sethi %hi(0x40017c00), %l2 400059d8: c2 04 a1 00 ld [ %l2 + 0x100 ], %g1 ! 40017d00 <_Thread_Dispatch_disable_level> 400059dc: 82 00 60 01 inc %g1 400059e0: c2 24 a1 00 st %g1, [ %l2 + 0x100 ] * _POSIX_Keys_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void ) { return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information ); 400059e4: 29 10 00 60 sethi %hi(0x40018000), %l4 400059e8: 40 00 0c 9d call 40008c5c <_Objects_Allocate> 400059ec: 90 15 22 00 or %l4, 0x200, %o0 ! 40018200 <_POSIX_Keys_Information> _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 400059f0: a0 92 20 00 orcc %o0, 0, %l0 400059f4: 32 80 00 0e bne,a 40005a2c 400059f8: f2 24 20 14 st %i1, [ %l0 + 0x14 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400059fc: c2 04 a1 00 ld [ %l2 + 0x100 ], %g1 40005a00: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 40005a04: 82 00 7f ff add %g1, -1, %g1 40005a08: c2 24 a1 00 st %g1, [ %l2 + 0x100 ] 40005a0c: c4 04 a1 00 ld [ %l2 + 0x100 ], %g2 40005a10: 80 a0 a0 00 cmp %g2, 0 40005a14: 12 80 00 3d bne 40005b08 40005a18: 01 00 00 00 nop 40005a1c: 40 00 12 cd call 4000a550 <_Thread_Dispatch> 40005a20: 01 00 00 00 nop 40005a24: 81 c7 e0 08 ret 40005a28: 81 e8 00 00 restore 40005a2c: 03 10 00 5f sethi %hi(0x40017c00), %g1 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 40005a30: 2f 10 00 5f sethi %hi(0x40017c00), %l7 40005a34: ac 10 60 60 or %g1, 0x60, %l6 _Thread_Enable_dispatch(); return EAGAIN; } the_key->destructor = destructor; 40005a38: b2 10 00 10 mov %l0, %i1 40005a3c: a6 10 20 01 mov 1, %l3 40005a40: aa 15 e1 4c or %l7, 0x14c, %l5 for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] && 40005a44: 83 2c e0 02 sll %l3, 2, %g1 40005a48: c2 00 40 16 ld [ %g1 + %l6 ], %g1 40005a4c: 80 a0 60 00 cmp %g1, 0 40005a50: 02 80 00 30 be 40005b10 40005a54: 90 10 00 15 mov %l5, %o0 40005a58: c2 00 60 04 ld [ %g1 + 4 ], %g1 40005a5c: 80 a0 60 00 cmp %g1, 0 40005a60: 22 80 00 0d be,a 40005a94 40005a64: c0 26 60 1c clr [ %i1 + 0x1c ] <== NOT EXECUTED _Objects_Information_table[ the_api ][ 1 ] ) { bytes_to_allocate = sizeof( void * ) * 40005a68: c2 10 60 10 lduh [ %g1 + 0x10 ], %g1 40005a6c: 82 00 60 01 inc %g1 40005a70: a3 28 60 02 sll %g1, 2, %l1 40005a74: 40 00 0b 1b call 400086e0 <_Heap_Allocate> 40005a78: 92 10 00 11 mov %l1, %o1 (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { 40005a7c: 82 92 20 00 orcc %o0, 0, %g1 40005a80: 02 80 00 26 be 40005b18 40005a84: 94 10 00 11 mov %l1, %o2 _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return ENOMEM; } the_key->Values[ the_api ] = table; 40005a88: c2 26 60 1c st %g1, [ %i1 + 0x1c ] memset( table, '\0', bytes_to_allocate ); 40005a8c: 40 00 2b 92 call 400108d4 40005a90: 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++ ) { 40005a94: a6 04 e0 01 inc %l3 * 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; 40005a98: 80 a4 e0 05 cmp %l3, 5 40005a9c: 12 bf ff ea bne 40005a44 40005aa0: b2 06 60 04 add %i1, 4, %i1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005aa4: 90 15 22 00 or %l4, 0x200, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40005aa8: c8 04 20 08 ld [ %l0 + 8 ], %g4 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005aac: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 } } the_key->is_active = TRUE; 40005ab0: 84 10 20 01 mov 1, %g2 40005ab4: 03 00 00 3f sethi %hi(0xfc00), %g1 40005ab8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40005abc: 82 09 00 01 and %g4, %g1, %g1 40005ac0: 80 a0 40 03 cmp %g1, %g3 40005ac4: 18 80 00 05 bgu 40005ad8 40005ac8: c4 24 20 10 st %g2, [ %l0 + 0x10 ] information->local_table[ index ] = the_object; 40005acc: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40005ad0: 83 28 60 02 sll %g1, 2, %g1 40005ad4: e0 20 80 01 st %l0, [ %g2 + %g1 ] _Objects_Open( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 40005ad8: c8 26 00 00 st %g4, [ %i0 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 40005adc: c0 24 20 0c clr [ %l0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005ae0: c2 04 a1 00 ld [ %l2 + 0x100 ], %g1 40005ae4: b0 10 20 00 clr %i0 40005ae8: 82 00 7f ff add %g1, -1, %g1 40005aec: c2 24 a1 00 st %g1, [ %l2 + 0x100 ] 40005af0: c4 04 a1 00 ld [ %l2 + 0x100 ], %g2 40005af4: 80 a0 a0 00 cmp %g2, 0 40005af8: 12 80 00 04 bne 40005b08 40005afc: 01 00 00 00 nop _Thread_Dispatch(); 40005b00: 40 00 12 94 call 4000a550 <_Thread_Dispatch> 40005b04: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } 40005b08: 81 c7 e0 08 ret 40005b0c: 81 e8 00 00 restore } the_key->Values[ the_api ] = table; memset( table, '\0', bytes_to_allocate ); } else { the_key->Values[ the_api ] = NULL; 40005b10: 10 bf ff e1 b 40005a94 40005b14: c0 26 60 1c clr [ %i1 + 0x1c ] 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; 40005b18: a6 84 ff ff addcc %l3, -1, %l3 <== NOT EXECUTED 40005b1c: 02 80 00 0d be 40005b50 <== NOT EXECUTED 40005b20: 90 15 22 00 or %l4, 0x200, %o0 <== NOT EXECUTED 40005b24: 83 2c e0 02 sll %l3, 2, %g1 <== NOT EXECUTED 40005b28: b2 15 e1 4c or %l7, 0x14c, %i1 <== NOT EXECUTED 40005b2c: 82 00 60 18 add %g1, 0x18, %g1 <== NOT EXECUTED 40005b30: a2 04 00 01 add %l0, %g1, %l1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 40005b34: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED 40005b38: 40 00 0b 1c call 400087a8 <_Heap_Free> <== NOT EXECUTED 40005b3c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40005b40: a6 84 ff ff addcc %l3, -1, %l3 <== NOT EXECUTED 40005b44: 12 bf ff fc bne 40005b34 <== NOT EXECUTED 40005b48: a2 04 7f fc add %l1, -4, %l1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 40005b4c: 90 15 22 00 or %l4, 0x200, %o0 <== NOT EXECUTED 40005b50: 40 00 0d 51 call 40009094 <_Objects_Free> <== NOT EXECUTED 40005b54: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005b58: c2 04 a1 00 ld [ %l2 + 0x100 ], %g1 <== NOT EXECUTED 40005b5c: 10 bf ff aa b 40005a04 <== NOT EXECUTED 40005b60: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED 40005b64 : */ int pthread_key_delete( pthread_key_t key ) { 40005b64: 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 *) 40005b68: 23 10 00 60 sethi %hi(0x40018000), %l1 40005b6c: 92 10 00 18 mov %i0, %o1 40005b70: 94 07 bf f4 add %fp, -12, %o2 40005b74: 40 00 0d 8b call 400091a0 <_Objects_Get> 40005b78: 90 14 62 00 or %l1, 0x200, %o0 register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 40005b7c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005b80: 80 a0 60 00 cmp %g1, 0 40005b84: 12 80 00 28 bne 40005c24 40005b88: a0 10 00 08 mov %o0, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40005b8c: c6 02 20 08 ld [ %o0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005b90: 88 14 62 00 or %l1, 0x200, %g4 40005b94: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 40005b98: 03 00 00 3f sethi %hi(0xfc00), %g1 40005b9c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40005ba0: 82 08 c0 01 and %g3, %g1, %g1 40005ba4: 80 a0 40 02 cmp %g1, %g2 40005ba8: 28 80 00 26 bleu,a 40005c40 40005bac: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 40005bb0: 03 10 00 5f sethi %hi(0x40017c00), %g1 uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 40005bb4: c0 24 20 0c clr [ %l0 + 0xc ] case OBJECTS_REMOTE: /* should never happen */ return EINVAL; case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); the_key->is_active = FALSE; 40005bb8: c0 24 20 10 clr [ %l0 + 0x10 ] 40005bbc: a4 10 61 4c or %g1, 0x14c, %l2 40005bc0: b0 10 20 00 clr %i0 for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 40005bc4: 82 04 00 18 add %l0, %i0, %g1 40005bc8: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 40005bcc: 80 a2 60 00 cmp %o1, 0 40005bd0: 02 80 00 04 be 40005be0 40005bd4: b0 06 20 04 add %i0, 4, %i0 40005bd8: 40 00 0a f4 call 400087a8 <_Heap_Free> 40005bdc: 90 10 00 12 mov %l2, %o0 _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; 40005be0: 80 a6 20 10 cmp %i0, 0x10 40005be4: 12 bf ff f9 bne 40005bc8 40005be8: 82 04 00 18 add %l0, %i0, %g1 RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 40005bec: 90 14 62 00 or %l1, 0x200, %o0 40005bf0: 40 00 0d 29 call 40009094 <_Objects_Free> 40005bf4: 92 10 00 10 mov %l0, %o1 40005bf8: 03 10 00 5f sethi %hi(0x40017c00), %g1 40005bfc: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 40017d00 <_Thread_Dispatch_disable_level> 40005c00: 90 10 20 00 clr %o0 40005c04: 84 00 bf ff add %g2, -1, %g2 40005c08: c4 20 61 00 st %g2, [ %g1 + 0x100 ] 40005c0c: c6 00 61 00 ld [ %g1 + 0x100 ], %g3 40005c10: 80 a0 e0 00 cmp %g3, 0 40005c14: 02 80 00 0e be 40005c4c 40005c18: 01 00 00 00 nop _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40005c1c: 81 c7 e0 08 ret 40005c20: 91 e8 00 08 restore %g0, %o0, %o0 register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 40005c24: 80 a0 60 02 cmp %g1, 2 40005c28: 08 bf ff fd bleu 40005c1c 40005c2c: 90 10 20 16 mov 0x16, %o0 _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40005c30: 40 00 02 a3 call 400066bc <== NOT EXECUTED 40005c34: 01 00 00 00 nop <== NOT EXECUTED } 40005c38: 81 c7 e0 08 ret <== NOT EXECUTED 40005c3c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) information->local_table[ index ] = the_object; 40005c40: 83 28 60 02 sll %g1, 2, %g1 40005c44: 10 bf ff db b 40005bb0 40005c48: c0 20 80 01 clr [ %g2 + %g1 ] _Thread_Dispatch(); 40005c4c: 40 00 12 41 call 4000a550 <_Thread_Dispatch> 40005c50: 01 00 00 00 nop 40005c54: 90 10 20 00 clr %o0 ! 0 40005c58: 81 c7 e0 08 ret 40005c5c: 91 e8 00 08 restore %g0, %o0, %o0 400263a8 : int pthread_kill( pthread_t thread, int sig ) { 400263a8: 9d e3 bf 90 save %sp, -112, %sp POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 400263ac: 80 a6 60 00 cmp %i1, 0 400263b0: 02 80 00 46 be 400264c8 400263b4: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 400263b8: a0 06 7f ff add %i1, -1, %l0 400263bc: 80 a4 20 1f cmp %l0, 0x1f 400263c0: 18 80 00 42 bgu 400264c8 400263c4: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 400263c8: 11 10 00 b2 sethi %hi(0x4002c800), %o0 400263cc: 7f ff a2 ff call 4000efc8 <_Objects_Get> 400263d0: 90 12 23 d4 or %o0, 0x3d4, %o0 ! 4002cbd4 <_POSIX_Threads_Information> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) rtems_set_errno_and_return_minus_one( ENOSYS ); */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 400263d4: c2 07 bf f4 ld [ %fp + -12 ], %g1 400263d8: 80 a0 60 00 cmp %g1, 0 400263dc: 02 80 00 0c be 4002640c 400263e0: b0 10 00 08 mov %o0, %i0 400263e4: 80 a0 60 02 cmp %g1, 2 400263e8: 18 80 00 34 bgu 400264b8 400263ec: 01 00 00 00 nop case OBJECTS_ERROR: case OBJECTS_REMOTE: rtems_set_errno_and_return_minus_one( ESRCH ); 400263f0: 7f ff cf b6 call 4001a2c8 <__errno> 400263f4: 01 00 00 00 nop 400263f8: 82 10 20 03 mov 3, %g1 ! 3 400263fc: c2 22 00 00 st %g1, [ %o0 ] 40026400: 90 10 3f ff mov -1, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40026404: 81 c7 e0 08 ret 40026408: 91 e8 00 08 restore %g0, %o0, %o0 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 4002640c: 87 2e 60 02 sll %i1, 2, %g3 40026410: 85 2e 60 04 sll %i1, 4, %g2 40026414: 03 10 00 b3 sethi %hi(0x4002cc00), %g1 40026418: 84 20 80 03 sub %g2, %g3, %g2 4002641c: 82 10 63 b8 or %g1, 0x3b8, %g1 40026420: 84 00 80 01 add %g2, %g1, %g2 40026424: c6 00 a0 08 ld [ %g2 + 8 ], %g3 40026428: 80 a0 e0 01 cmp %g3, 1 4002642c: 02 80 00 15 be 40026480 40026430: c8 02 21 70 ld [ %o0 + 0x170 ], %g4 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 40026434: c4 01 20 c8 ld [ %g4 + 0xc8 ], %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 40026438: 92 10 00 19 mov %i1, %o1 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 4002643c: b2 10 20 01 mov 1, %i1 40026440: 83 2e 40 10 sll %i1, %l0, %g1 40026444: 84 10 80 01 or %g2, %g1, %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 40026448: 94 10 20 00 clr %o2 4002644c: 7f ff ff 8c call 4002627c <_POSIX_signals_Unblock_thread> 40026450: 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 ) ) 40026454: 03 10 00 b2 sethi %hi(0x4002c800), %g1 40026458: c4 00 61 64 ld [ %g1 + 0x164 ], %g2 ! 4002c964 <_ISR_Nest_level> 4002645c: 80 a0 a0 00 cmp %g2, 0 40026460: 02 80 00 08 be 40026480 40026464: f2 26 20 78 st %i1, [ %i0 + 0x78 ] 40026468: 03 10 00 b2 sethi %hi(0x4002c800), %g1 4002646c: c4 00 61 7c ld [ %g1 + 0x17c ], %g2 ! 4002c97c <_Thread_Executing> 40026470: 80 a6 00 02 cmp %i0, %g2 40026474: 12 80 00 03 bne 40026480 40026478: 03 10 00 b2 sethi %hi(0x4002c800), %g1 _ISR_Signals_to_thread_executing = TRUE; 4002647c: f2 20 62 28 st %i1, [ %g1 + 0x228 ] ! 4002ca28 <_ISR_Signals_to_thread_executing> <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40026480: 03 10 00 b2 sethi %hi(0x4002c800), %g1 40026484: c4 00 60 a0 ld [ %g1 + 0xa0 ], %g2 ! 4002c8a0 <_Thread_Dispatch_disable_level> } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40026488: 90 10 20 00 clr %o0 4002648c: 84 00 bf ff add %g2, -1, %g2 40026490: c4 20 60 a0 st %g2, [ %g1 + 0xa0 ] 40026494: c6 00 60 a0 ld [ %g1 + 0xa0 ], %g3 40026498: 80 a0 e0 00 cmp %g3, 0 4002649c: 12 bf ff da bne 40026404 400264a0: 01 00 00 00 nop _Thread_Dispatch(); 400264a4: 7f ff a7 f1 call 40010468 <_Thread_Dispatch> 400264a8: 01 00 00 00 nop 400264ac: 90 10 20 00 clr %o0 ! 0 } 400264b0: 81 c7 e0 08 ret 400264b4: 91 e8 00 08 restore %g0, %o0, %o0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400264b8: 40 00 00 18 call 40026518 <== NOT EXECUTED 400264bc: 01 00 00 00 nop <== NOT EXECUTED } 400264c0: 81 c7 e0 08 ret <== NOT EXECUTED 400264c4: 91 e8 00 08 restore %g0, %o0, %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 ); 400264c8: 7f ff cf 80 call 4001a2c8 <__errno> 400264cc: 01 00 00 00 nop 400264d0: 82 10 20 16 mov 0x16, %g1 ! 16 400264d4: c2 22 00 00 st %g1, [ %o0 ] 400264d8: 10 bf ff cb b 40026404 400264dc: 90 10 3f ff mov -1, %o0 4000761c : */ int pthread_mutex_destroy( pthread_mutex_t *mutex ) { 4000761c: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40007620: 80 a6 20 00 cmp %i0, 0 40007624: 32 80 00 05 bne,a 40007638 40007628: d2 06 00 00 ld [ %i0 ], %o1 } #endif _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 4000762c: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED } 40007630: 81 c7 e0 08 ret 40007634: 91 e8 00 08 restore %g0, %o0, %o0 40007638: 80 a2 7f ff cmp %o1, -1 4000763c: 02 80 00 40 be 4000773c 40007640: 90 10 00 18 mov %i0, %o0 return (POSIX_Mutex_Control *) 40007644: 21 10 00 6d sethi %hi(0x4001b400), %l0 40007648: 94 07 bf f4 add %fp, -12, %o2 4000764c: 40 00 0f e5 call 4000b5e0 <_Objects_Get> 40007650: 90 14 21 54 or %l0, 0x154, %o0 { register POSIX_Mutex_Control *the_mutex; Objects_Locations location; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 40007654: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007658: 80 a0 60 00 cmp %g1, 0 4000765c: 12 80 00 13 bne 400076a8 40007660: b0 10 00 08 mov %o0, %i0 /* * XXX: There is an error for the mutex being locked * or being in use by a condition variable. */ if ( _CORE_mutex_Is_locked( &the_mutex->Mutex ) ) { 40007664: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 40007668: 80 a0 60 00 cmp %g1, 0 4000766c: 32 80 00 15 bne,a 400076c0 40007670: a0 14 21 54 or %l0, 0x154, %l0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007674: 03 10 00 6c sethi %hi(0x4001b000), %g1 40007678: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 4001b0f0 <_Thread_Dispatch_disable_level> 4000767c: 90 10 20 10 mov 0x10, %o0 40007680: 84 00 bf ff add %g2, -1, %g2 40007684: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ] 40007688: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 4000768c: 80 a0 e0 00 cmp %g3, 0 40007690: 12 bf ff e8 bne 40007630 40007694: 01 00 00 00 nop _Thread_Dispatch(); 40007698: 40 00 14 be call 4000c990 <_Thread_Dispatch> 4000769c: 01 00 00 00 nop 400076a0: 10 bf ff e4 b 40007630 400076a4: 90 10 20 10 mov 0x10, %o0 ! 10 { register POSIX_Mutex_Control *the_mutex; Objects_Locations location; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 400076a8: 80 a0 60 02 cmp %g1, 2 400076ac: 28 bf ff e1 bleu,a 40007630 400076b0: 90 10 20 16 mov 0x16, %o0 } #endif _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400076b4: 40 00 05 12 call 40008afc <== NOT EXECUTED 400076b8: 01 00 00 00 nop <== NOT EXECUTED 400076bc: 30 bf ff dd b,a 40007630 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 400076c0: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400076c4: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 400076c8: 05 00 00 3f sethi %hi(0xfc00), %g2 400076cc: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 400076d0: 82 08 40 02 and %g1, %g2, %g1 400076d4: 80 a0 40 03 cmp %g1, %g3 400076d8: 18 80 00 05 bgu 400076ec 400076dc: 94 10 20 16 mov 0x16, %o2 information->local_table[ index ] = the_object; 400076e0: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 400076e4: 83 28 60 02 sll %g1, 2, %g1 400076e8: c0 20 80 01 clr [ %g2 + %g1 ] return EBUSY; } _Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object ); _CORE_mutex_Flush( 400076ec: 90 06 20 14 add %i0, 0x14, %o0 uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 400076f0: c0 26 20 0c clr [ %i0 + 0xc ] 400076f4: 40 00 0b af call 4000a5b0 <_CORE_mutex_Flush> 400076f8: 92 10 20 00 clr %o1 RTEMS_INLINE_ROUTINE void _POSIX_Mutex_Free ( POSIX_Mutex_Control *the_mutex ) { _Objects_Free( &_POSIX_Mutex_Information, &the_mutex->Object ); 400076fc: 90 10 00 10 mov %l0, %o0 40007700: 40 00 0f 75 call 4000b4d4 <_Objects_Free> 40007704: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007708: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000770c: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 4001b0f0 <_Thread_Dispatch_disable_level> 40007710: 90 10 20 00 clr %o0 40007714: 84 00 bf ff add %g2, -1, %g2 40007718: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ] 4000771c: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 40007720: 80 a0 e0 00 cmp %g3, 0 40007724: 12 bf ff c3 bne 40007630 40007728: 01 00 00 00 nop _Thread_Dispatch(); 4000772c: 40 00 14 99 call 4000c990 <_Thread_Dispatch> 40007730: 01 00 00 00 nop 40007734: 10 bf ff bf b 40007630 40007738: 90 10 20 00 clr %o0 ! 0 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 4000773c: 40 00 00 38 call 4000781c <== NOT EXECUTED 40007740: 92 10 20 00 clr %o1 <== NOT EXECUTED 40007744: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007748: 12 bf ff ba bne 40007630 <== NOT EXECUTED 4000774c: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 40007750: 10 bf ff bd b 40007644 <== NOT EXECUTED 40007754: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 40007758 : int pthread_mutex_getprioceiling( pthread_mutex_t *mutex, int *prioceiling ) { 40007758: 9d e3 bf 90 save %sp, -112, %sp register POSIX_Mutex_Control *the_mutex; Objects_Locations location; if ( !prioceiling ) 4000775c: 80 a6 60 00 cmp %i1, 0 40007760: 02 80 00 04 be 40007770 40007764: 80 a6 20 00 cmp %i0, 0 40007768: 32 80 00 05 bne,a 4000777c 4000776c: d2 06 00 00 ld [ %i0 ], %o1 the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40007770: 90 10 20 16 mov 0x16, %o0 } 40007774: 81 c7 e0 08 ret 40007778: 91 e8 00 08 restore %g0, %o0, %o0 4000777c: 80 a2 7f ff cmp %o1, -1 40007780: 22 80 00 20 be,a 40007800 40007784: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return (POSIX_Mutex_Control *) 40007788: 11 10 00 6d sethi %hi(0x4001b400), %o0 4000778c: 94 07 bf f4 add %fp, -12, %o2 40007790: 40 00 0f 94 call 4000b5e0 <_Objects_Get> 40007794: 90 12 21 54 or %o0, 0x154, %o0 if ( !prioceiling ) return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 40007798: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000779c: 80 a0 60 00 cmp %g1, 0 400077a0: 12 80 00 13 bne 400077ec 400077a4: 80 a0 60 02 cmp %g1, 2 return POSIX_MP_NOT_IMPLEMENTED(); /* XXX feels questionable */ #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( 400077a8: c4 02 20 60 ld [ %o0 + 0x60 ], %g2 400077ac: 82 10 20 ff mov 0xff, %g1 400077b0: 82 20 40 02 sub %g1, %g2, %g1 400077b4: c2 26 40 00 st %g1, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400077b8: 07 10 00 6c sethi %hi(0x4001b000), %g3 400077bc: c2 00 e0 f0 ld [ %g3 + 0xf0 ], %g1 ! 4001b0f0 <_Thread_Dispatch_disable_level> 400077c0: 90 10 20 00 clr %o0 400077c4: 82 00 7f ff add %g1, -1, %g1 400077c8: c2 20 e0 f0 st %g1, [ %g3 + 0xf0 ] 400077cc: c4 00 e0 f0 ld [ %g3 + 0xf0 ], %g2 400077d0: 80 a0 a0 00 cmp %g2, 0 400077d4: 12 bf ff e8 bne 40007774 400077d8: 01 00 00 00 nop _Thread_Dispatch(); 400077dc: 40 00 14 6d call 4000c990 <_Thread_Dispatch> 400077e0: 01 00 00 00 nop 400077e4: 10 bf ff e4 b 40007774 400077e8: 90 10 20 00 clr %o0 ! 0 if ( !prioceiling ) return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 400077ec: 28 bf ff e2 bleu,a 40007774 400077f0: 90 10 20 16 mov 0x16, %o0 the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400077f4: 40 00 04 c2 call 40008afc <== NOT EXECUTED 400077f8: 01 00 00 00 nop <== NOT EXECUTED 400077fc: 30 bf ff de b,a 40007774 <== NOT EXECUTED Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40007800: 40 00 00 07 call 4000781c <== NOT EXECUTED 40007804: 92 10 20 00 clr %o1 <== NOT EXECUTED 40007808: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000780c: 32 bf ff da bne,a 40007774 <== NOT EXECUTED 40007810: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 40007814: 10 bf ff dd b 40007788 <== NOT EXECUTED 40007818: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 4000781c : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 4000781c: 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; 40007820: 03 10 00 64 sethi %hi(0x40019000), %g1 40007824: 80 a6 60 00 cmp %i1, 0 40007828: 02 80 00 03 be 40007834 4000782c: a0 10 63 0c or %g1, 0x30c, %l0 40007830: a0 10 00 19 mov %i1, %l0 else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 40007834: 80 a6 20 00 cmp %i0, 0 40007838: 22 80 00 2c be,a 400078e8 4000783c: b0 10 20 16 mov 0x16, %i0 return EBUSY; } } #endif if ( !the_attr->is_initialized ) 40007840: c2 04 00 00 ld [ %l0 ], %g1 40007844: 80 a0 60 00 cmp %g1, 0 40007848: 22 80 00 28 be,a 400078e8 4000784c: b0 10 20 16 mov 0x16, %i0 /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 40007850: c2 04 20 04 ld [ %l0 + 4 ], %g1 40007854: 80 a0 60 00 cmp %g1, 0 40007858: 12 80 00 2b bne 40007904 4000785c: 11 10 00 64 sethi %hi(0x40019000), %o0 /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 40007860: c2 04 20 0c ld [ %l0 + 0xc ], %g1 40007864: 80 a0 60 01 cmp %g1, 1 40007868: 02 80 00 07 be 40007884 4000786c: a4 10 20 02 mov 2, %l2 40007870: 80 a0 60 02 cmp %g1, 2 40007874: 02 80 00 22 be 400078fc 40007878: 80 a0 60 00 cmp %g1, 0 4000787c: 12 80 00 1d bne 400078f0 40007880: a4 10 20 00 clr %l2 break; default: return EINVAL; } if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 40007884: c2 04 20 08 ld [ %l0 + 8 ], %g1 40007888: 82 00 7f ff add %g1, -1, %g1 4000788c: 80 a0 60 fd cmp %g1, 0xfd 40007890: 38 80 00 16 bgu,a 400078e8 40007894: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007898: 23 10 00 6c sethi %hi(0x4001b000), %l1 4000789c: c2 04 60 f0 ld [ %l1 + 0xf0 ], %g1 ! 4001b0f0 <_Thread_Dispatch_disable_level> 400078a0: 82 00 60 01 inc %g1 400078a4: c2 24 60 f0 st %g1, [ %l1 + 0xf0 ] * _POSIX_Mutex_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void ) { return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information ); 400078a8: 27 10 00 6d sethi %hi(0x4001b400), %l3 400078ac: 40 00 0d fc call 4000b09c <_Objects_Allocate> 400078b0: 90 14 e1 54 or %l3, 0x154, %o0 ! 4001b554 <_POSIX_Mutex_Information> _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 400078b4: b2 92 20 00 orcc %o0, 0, %i1 400078b8: 32 80 00 1e bne,a 40007930 400078bc: c2 04 20 04 ld [ %l0 + 4 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400078c0: c2 04 60 f0 ld [ %l1 + 0xf0 ], %g1 400078c4: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 400078c8: 82 00 7f ff add %g1, -1, %g1 400078cc: c2 24 60 f0 st %g1, [ %l1 + 0xf0 ] 400078d0: c4 04 60 f0 ld [ %l1 + 0xf0 ], %g2 400078d4: 80 a0 a0 00 cmp %g2, 0 400078d8: 12 80 00 07 bne 400078f4 400078dc: 01 00 00 00 nop 400078e0: 40 00 14 2c call 4000c990 <_Thread_Dispatch> 400078e4: 01 00 00 00 nop 400078e8: 81 c7 e0 08 ret 400078ec: 81 e8 00 00 restore 400078f0: b0 10 20 16 mov 0x16, %i0 ); #endif _Thread_Enable_dispatch(); return 0; } 400078f4: 81 c7 e0 08 ret 400078f8: 81 e8 00 00 restore /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 400078fc: 10 bf ff e2 b 40007884 40007900: a4 10 20 03 mov 3, %l2 /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 40007904: 15 10 00 64 sethi %hi(0x40019000), %o2 <== NOT EXECUTED 40007908: 90 12 23 20 or %o0, 0x320, %o0 <== NOT EXECUTED 4000790c: 94 12 a3 68 or %o2, 0x368, %o2 <== NOT EXECUTED 40007910: 7f ff f1 bf call 4000400c <__assert> <== NOT EXECUTED 40007914: 92 10 20 64 mov 0x64, %o1 <== NOT EXECUTED /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 40007918: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED 4000791c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40007920: 12 bf ff d5 bne 40007874 <== NOT EXECUTED 40007924: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40007928: 10 bf ff d7 b 40007884 <== NOT EXECUTED 4000792c: a4 10 20 02 mov 2, %l2 <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } #endif the_mutex->process_shared = the_attr->process_shared; 40007930: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_mutex_attr = &the_mutex->Mutex.Attributes; if ( the_attr->recursive ) 40007934: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 40007938: 80 a0 a0 00 cmp %g2, 0 4000793c: 32 80 00 04 bne,a 4000794c 40007940: 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; 40007944: 82 10 20 01 mov 1, %g1 40007948: c2 26 60 54 st %g1, [ %i1 + 0x54 ] the_mutex_attr->only_owner_release = TRUE; the_mutex_attr->priority_ceiling = 4000794c: 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; 40007950: 84 10 20 01 mov 1, %g2 the_mutex_attr->priority_ceiling = 40007954: 82 10 20 ff mov 0xff, %g1 40007958: 82 20 40 03 sub %g1, %g3, %g1 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; 4000795c: c4 26 60 58 st %g2, [ %i1 + 0x58 ] the_mutex_attr->priority_ceiling = 40007960: c2 26 60 60 st %g1, [ %i1 + 0x60 ] _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 40007964: e4 26 60 5c st %l2, [ %i1 + 0x5c ] /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 40007968: 90 06 60 14 add %i1, 0x14, %o0 4000796c: 92 06 60 54 add %i1, 0x54, %o1 40007970: 40 00 0b 14 call 4000a5c0 <_CORE_mutex_Initialize> 40007974: 94 10 20 01 mov 1, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40007978: 90 14 e1 54 or %l3, 0x154, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000797c: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40007980: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40007984: 03 00 00 3f sethi %hi(0xfc00), %g1 40007988: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000798c: 82 08 c0 01 and %g3, %g1, %g1 40007990: 80 a0 40 02 cmp %g1, %g2 40007994: 38 80 00 06 bgu,a 400079ac 40007998: c6 26 00 00 st %g3, [ %i0 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000799c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400079a0: 83 28 60 02 sll %g1, 2, %g1 400079a4: f2 20 80 01 st %i1, [ %g2 + %g1 ] CORE_MUTEX_UNLOCKED ); _Objects_Open( &_POSIX_Mutex_Information, &the_mutex->Object, 0 ); *mutex = the_mutex->Object.id; 400079a8: c6 26 00 00 st %g3, [ %i0 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 400079ac: c0 26 60 0c clr [ %i1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400079b0: c2 04 60 f0 ld [ %l1 + 0xf0 ], %g1 400079b4: 10 bf ff c5 b 400078c8 400079b8: b0 10 20 00 clr %i0 40007c70 : int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { 40007c70: 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 ) 40007c74: 80 a6 a0 00 cmp %i2, 0 40007c78: 02 80 00 06 be 40007c90 40007c7c: a0 10 00 18 mov %i0, %l0 return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 40007c80: 82 06 7f ff add %i1, -1, %g1 40007c84: 80 a0 60 fd cmp %g1, 0xfd 40007c88: 08 80 00 04 bleu 40007c98 40007c8c: 01 00 00 00 nop ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40007c90: 81 c7 e0 08 ret 40007c94: 91 e8 20 16 restore %g0, 0x16, %o0 /* * Must acquire the mutex before we can change it's ceiling */ status = pthread_mutex_lock( mutex ); 40007c98: 7f ff ff 49 call 400079bc 40007c9c: 90 10 00 18 mov %i0, %o0 if ( status ) 40007ca0: b0 92 20 00 orcc %o0, 0, %i0 40007ca4: 12 80 00 24 bne 40007d34 40007ca8: 80 a4 20 00 cmp %l0, 0 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40007cac: 22 80 00 22 be,a 40007d34 40007cb0: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED 40007cb4: d2 04 00 00 ld [ %l0 ], %o1 40007cb8: 80 a2 7f ff cmp %o1, -1 40007cbc: 22 80 00 26 be,a 40007d54 40007cc0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED return (POSIX_Mutex_Control *) 40007cc4: 11 10 00 6d sethi %hi(0x4001b400), %o0 40007cc8: 94 07 bf f4 add %fp, -12, %o2 40007ccc: 40 00 0e 45 call 4000b5e0 <_Objects_Get> 40007cd0: 90 12 21 54 or %o0, 0x154, %o0 return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 40007cd4: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007cd8: 80 a0 60 00 cmp %g1, 0 40007cdc: 12 80 00 18 bne 40007d3c 40007ce0: 80 a0 60 02 cmp %g1, 2 return EINVAL; #endif case OBJECTS_ERROR: return EINVAL; /* impossible to get here */ case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 40007ce4: c6 02 20 60 ld [ %o0 + 0x60 ], %g3 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( 40007ce8: d2 02 20 08 ld [ %o0 + 8 ], %o1 return EINVAL; #endif case OBJECTS_ERROR: return EINVAL; /* impossible to get here */ case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 40007cec: 82 10 20 ff mov 0xff, %g1 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 40007cf0: 84 20 40 19 sub %g1, %i1, %g2 return EINVAL; #endif case OBJECTS_ERROR: return EINVAL; /* impossible to get here */ case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 40007cf4: 82 20 40 03 sub %g1, %g3, %g1 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 40007cf8: c4 22 20 60 st %g2, [ %o0 + 0x60 ] return EINVAL; #endif case OBJECTS_ERROR: return EINVAL; /* impossible to get here */ case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 40007cfc: c2 26 80 00 st %g1, [ %i2 ] the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( 40007d00: 94 10 20 00 clr %o2 40007d04: 40 00 0a 8c call 4000a734 <_CORE_mutex_Surrender> 40007d08: 90 02 20 14 add %o0, 0x14, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007d0c: 05 10 00 6c sethi %hi(0x4001b000), %g2 40007d10: c2 00 a0 f0 ld [ %g2 + 0xf0 ], %g1 ! 4001b0f0 <_Thread_Dispatch_disable_level> 40007d14: 82 00 7f ff add %g1, -1, %g1 40007d18: c2 20 a0 f0 st %g1, [ %g2 + 0xf0 ] 40007d1c: c6 00 a0 f0 ld [ %g2 + 0xf0 ], %g3 40007d20: 80 a0 e0 00 cmp %g3, 0 40007d24: 12 80 00 04 bne 40007d34 40007d28: 01 00 00 00 nop _Thread_Dispatch(); 40007d2c: 40 00 13 19 call 4000c990 <_Thread_Dispatch> 40007d30: 01 00 00 00 nop 40007d34: 81 c7 e0 08 ret 40007d38: 81 e8 00 00 restore status = pthread_mutex_lock( mutex ); if ( status ) return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 40007d3c: 28 bf ff fe bleu,a 40007d34 <== NOT EXECUTED 40007d40: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40007d44: 40 00 03 6e call 40008afc <== NOT EXECUTED 40007d48: 01 00 00 00 nop <== NOT EXECUTED 40007d4c: 81 c7 e0 08 ret <== NOT EXECUTED 40007d50: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40007d54: 7f ff fe b2 call 4000781c <== NOT EXECUTED 40007d58: 92 10 20 00 clr %o1 <== NOT EXECUTED 40007d5c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007d60: 32 bf ff f5 bne,a 40007d34 <== NOT EXECUTED 40007d64: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED 40007d68: 10 bf ff d7 b 40007cc4 <== NOT EXECUTED 40007d6c: d2 04 00 00 ld [ %l0 ], %o1 <== NOT EXECUTED 40007d70 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 40007d70: 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 ); 40007d74: 90 10 00 19 mov %i1, %o0 40007d78: 40 00 00 46 call 40007e90 <_POSIX_Absolute_timeout_to_ticks> 40007d7c: 92 07 bf f4 add %fp, -12, %o1 switch ( status ) { 40007d80: 80 a2 20 03 cmp %o0, 3 40007d84: 02 80 00 07 be 40007da0 40007d88: d4 07 bf f4 ld [ %fp + -12 ], %o2 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 40007d8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40007d90: 7f ff ff 11 call 400079d4 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED 40007d94: 92 10 20 00 clr %o1 <== NOT EXECUTED break; } } return lock_status; } 40007d98: 81 c7 e0 08 ret <== NOT EXECUTED 40007d9c: 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( 40007da0: 90 10 00 18 mov %i0, %o0 40007da4: 7f ff ff 0c call 400079d4 <_POSIX_Mutex_Lock_support> 40007da8: 92 10 20 01 mov 1, %o1 break; } } return lock_status; } 40007dac: 81 c7 e0 08 ret 40007db0: 91 e8 00 08 restore %g0, %o0, %o0 40007dcc : */ int pthread_mutex_unlock( pthread_mutex_t *mutex ) { 40007dcc: 9d e3 bf 90 save %sp, -112, %sp 40007dd0: 80 a6 20 00 cmp %i0, 0 40007dd4: 32 80 00 05 bne,a 40007de8 40007dd8: d2 06 00 00 ld [ %i0 ], %o1 ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); break; } return POSIX_BOTTOM_REACHED(); 40007ddc: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED } 40007de0: 81 c7 e0 08 ret 40007de4: 91 e8 00 08 restore %g0, %o0, %o0 40007de8: 80 a2 7f ff cmp %o1, -1 40007dec: 22 80 00 22 be,a 40007e74 40007df0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return (POSIX_Mutex_Control *) 40007df4: 11 10 00 6d sethi %hi(0x4001b400), %o0 40007df8: 94 07 bf f4 add %fp, -12, %o2 40007dfc: 40 00 0d f9 call 4000b5e0 <_Objects_Get> 40007e00: 90 12 21 54 or %o0, 0x154, %o0 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 40007e04: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007e08: 80 a0 60 00 cmp %g1, 0 40007e0c: 12 80 00 12 bne 40007e54 40007e10: 80 a0 60 02 cmp %g1, 2 ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_mutex_Surrender( 40007e14: d2 02 20 08 ld [ %o0 + 8 ], %o1 40007e18: 94 10 20 00 clr %o2 40007e1c: 40 00 0a 46 call 4000a734 <_CORE_mutex_Surrender> 40007e20: 90 02 20 14 add %o0, 0x14, %o0 40007e24: b0 10 00 08 mov %o0, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007e28: 03 10 00 6c sethi %hi(0x4001b000), %g1 40007e2c: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 4001b0f0 <_Thread_Dispatch_disable_level> 40007e30: 84 00 bf ff add %g2, -1, %g2 40007e34: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ] 40007e38: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 40007e3c: 80 a0 e0 00 cmp %g3, 0 40007e40: 02 80 00 0a be 40007e68 40007e44: 01 00 00 00 nop #else NULL #endif ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); 40007e48: 40 00 21 04 call 40010258 <_POSIX_Mutex_From_core_mutex_status> 40007e4c: 90 10 00 18 mov %i0, %o0 40007e50: 30 bf ff e4 b,a 40007de0 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 40007e54: 28 bf ff e3 bleu,a 40007de0 40007e58: 90 10 20 16 mov 0x16, %o0 ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); break; } return POSIX_BOTTOM_REACHED(); 40007e5c: 40 00 03 28 call 40008afc <== NOT EXECUTED 40007e60: 01 00 00 00 nop <== NOT EXECUTED 40007e64: 30 bf ff df b,a 40007de0 <== NOT EXECUTED _Thread_Dispatch(); 40007e68: 40 00 12 ca call 4000c990 <_Thread_Dispatch> 40007e6c: 01 00 00 00 nop 40007e70: 30 bf ff f6 b,a 40007e48 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40007e74: 7f ff fe 6a call 4000781c <== NOT EXECUTED 40007e78: 92 10 20 00 clr %o1 <== NOT EXECUTED 40007e7c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007e80: 32 bf ff d8 bne,a 40007de0 <== NOT EXECUTED 40007e84: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 40007e88: 10 bf ff db b 40007df4 <== NOT EXECUTED 40007e8c: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 40006e6c : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 40006e6c: 9d e3 bf 90 save %sp, -112, %sp if ( !once_control || !init_routine ) 40006e70: a0 96 20 00 orcc %i0, 0, %l0 40006e74: 02 80 00 18 be 40006ed4 40006e78: 80 a6 60 00 cmp %i1, 0 40006e7c: 02 80 00 16 be 40006ed4 40006e80: 01 00 00 00 nop return EINVAL; if ( !once_control->init_executed ) { 40006e84: c2 04 20 04 ld [ %l0 + 4 ], %g1 40006e88: 80 a0 60 00 cmp %g1, 0 40006e8c: 12 80 00 10 bne 40006ecc 40006e90: b0 10 20 00 clr %i0 rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 40006e94: b0 07 bf f4 add %fp, -12, %i0 40006e98: 90 10 21 00 mov 0x100, %o0 40006e9c: 92 10 21 00 mov 0x100, %o1 40006ea0: 40 00 05 41 call 400083a4 40006ea4: 94 10 00 18 mov %i0, %o2 if ( !once_control->init_executed ) { 40006ea8: c2 04 20 04 ld [ %l0 + 4 ], %g1 40006eac: 80 a0 60 00 cmp %g1, 0 40006eb0: 02 80 00 0b be 40006edc 40006eb4: 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); 40006eb8: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED 40006ebc: 94 10 00 18 mov %i0, %o2 40006ec0: 92 10 21 00 mov 0x100, %o1 40006ec4: 40 00 05 38 call 400083a4 40006ec8: b0 10 20 00 clr %i0 } return 0; } 40006ecc: 81 c7 e0 08 ret 40006ed0: 81 e8 00 00 restore int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) 40006ed4: 81 c7 e0 08 ret 40006ed8: 91 e8 20 16 restore %g0, 0x16, %o0 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; 40006edc: c2 24 20 04 st %g1, [ %l0 + 4 ] (*init_routine)(); 40006ee0: 9f c6 40 00 call %i1 40006ee4: c2 24 00 00 st %g1, [ %l0 ] } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 40006ee8: 10 bf ff f5 b 40006ebc 40006eec: d0 07 bf f4 ld [ %fp + -12 ], %o0 4000625c : */ int pthread_rwlock_destroy( pthread_rwlock_t *rwlock ) { 4000625c: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock = NULL; Objects_Locations location; if ( !rwlock ) 40006260: 80 a6 20 00 cmp %i0, 0 40006264: 02 80 00 24 be 400062f4 40006268: 21 10 00 76 sethi %hi(0x4001d800), %l0 RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get ( pthread_rwlock_t *RWLock, Objects_Locations *location ) { return (POSIX_RWLock_Control *) _Objects_Get( 4000626c: d2 06 00 00 ld [ %i0 ], %o1 40006270: 94 07 bf f4 add %fp, -12, %o2 40006274: 40 00 0f 95 call 4000a0c8 <_Objects_Get> 40006278: 90 14 22 6c or %l0, 0x26c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 4000627c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006280: 80 a0 60 00 cmp %g1, 0 40006284: 12 80 00 15 bne 400062d8 40006288: b0 10 00 08 mov %o0, %i0 case OBJECTS_LOCAL: /* * If there is at least one thread waiting, then do not delete it. */ if ( _Thread_queue_First( &the_rwlock->RWLock.Wait_queue ) != NULL ) { 4000628c: 40 00 17 3b call 4000bf78 <_Thread_queue_First> 40006290: 90 02 20 10 add %o0, 0x10, %o0 40006294: 80 a2 20 00 cmp %o0, 0 40006298: 02 80 00 1a be 40006300 4000629c: 90 14 22 6c or %l0, 0x26c, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400062a0: 03 10 00 75 sethi %hi(0x4001d400), %g1 400062a4: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 4001d7d0 <_Thread_Dispatch_disable_level> 400062a8: 90 10 20 10 mov 0x10, %o0 400062ac: 84 00 bf ff add %g2, -1, %g2 400062b0: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 400062b4: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 400062b8: 80 a0 e0 00 cmp %g3, 0 400062bc: 12 80 00 0c bne 400062ec 400062c0: 01 00 00 00 nop _Thread_Dispatch(); 400062c4: 40 00 14 6d call 4000b478 <_Thread_Dispatch> 400062c8: 01 00 00 00 nop 400062cc: 90 10 20 10 mov 0x10, %o0 ! 10 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 400062d0: 81 c7 e0 08 ret 400062d4: 91 e8 00 08 restore %g0, %o0, %o0 if ( !rwlock ) return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 400062d8: 80 a0 60 02 cmp %g1, 2 400062dc: 08 80 00 07 bleu 400062f8 400062e0: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400062e4: 40 00 03 c1 call 400071e8 <== NOT EXECUTED 400062e8: 01 00 00 00 nop <== NOT EXECUTED } 400062ec: 81 c7 e0 08 ret 400062f0: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400062f4: 90 10 20 16 mov 0x16, %o0 } 400062f8: 81 c7 e0 08 ret 400062fc: 91 e8 00 08 restore %g0, %o0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40006300: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006304: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40006308: 05 00 00 3f sethi %hi(0xfc00), %g2 4000630c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40006310: 82 08 40 02 and %g1, %g2, %g1 40006314: 80 a0 40 03 cmp %g1, %g3 40006318: 38 80 00 06 bgu,a 40006330 4000631c: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40006320: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006324: 83 28 60 02 sll %g1, 2, %g1 40006328: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 4000632c: c0 26 20 0c clr [ %i0 + 0xc ] */ RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free ( POSIX_RWLock_Control *the_RWLock ) { _Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object ); 40006330: 40 00 0f 23 call 40009fbc <_Objects_Free> 40006334: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006338: 03 10 00 75 sethi %hi(0x4001d400), %g1 4000633c: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 4001d7d0 <_Thread_Dispatch_disable_level> 40006340: 90 10 20 00 clr %o0 40006344: 84 00 bf ff add %g2, -1, %g2 40006348: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 4000634c: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 40006350: 80 a0 e0 00 cmp %g3, 0 40006354: 12 bf ff e6 bne 400062ec 40006358: 01 00 00 00 nop _Thread_Dispatch(); 4000635c: 40 00 14 47 call 4000b478 <_Thread_Dispatch> 40006360: 01 00 00 00 nop 40006364: 10 bf ff e2 b 400062ec 40006368: 90 10 20 00 clr %o0 ! 0 4000636c : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 4000636c: 9d e3 bf 88 save %sp, -120, %sp const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 40006370: 80 a6 20 00 cmp %i0, 0 40006374: 02 80 00 23 be 40006400 40006378: a0 10 00 19 mov %i1, %l0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 4000637c: 80 a6 60 00 cmp %i1, 0 40006380: 22 80 00 23 be,a 4000640c 40006384: 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 ) 40006388: c2 04 00 00 ld [ %l0 ], %g1 4000638c: 80 a0 60 00 cmp %g1, 0 40006390: 22 80 00 1a be,a 400063f8 40006394: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED return EINVAL; switch ( the_attr->process_shared ) { 40006398: c2 04 20 04 ld [ %l0 + 4 ], %g1 4000639c: 80 a0 60 00 cmp %g1, 0 400063a0: 32 80 00 16 bne,a 400063f8 400063a4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400063a8: 33 10 00 75 sethi %hi(0x4001d400), %i1 400063ac: c2 06 63 d0 ld [ %i1 + 0x3d0 ], %g1 ! 4001d7d0 <_Thread_Dispatch_disable_level> 400063b0: 82 00 60 01 inc %g1 400063b4: c2 26 63 d0 st %g1, [ %i1 + 0x3d0 ] * 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 *) 400063b8: 23 10 00 76 sethi %hi(0x4001d800), %l1 400063bc: 40 00 0d f2 call 40009b84 <_Objects_Allocate> 400063c0: 90 14 62 6c or %l1, 0x26c, %o0 ! 4001da6c <_POSIX_RWLock_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 400063c4: a0 92 20 00 orcc %o0, 0, %l0 400063c8: 12 80 00 15 bne 4000641c 400063cc: 90 04 20 10 add %l0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400063d0: c2 06 63 d0 ld [ %i1 + 0x3d0 ], %g1 400063d4: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 400063d8: 82 00 7f ff add %g1, -1, %g1 400063dc: c2 26 63 d0 st %g1, [ %i1 + 0x3d0 ] 400063e0: c4 06 63 d0 ld [ %i1 + 0x3d0 ], %g2 400063e4: 80 a0 a0 00 cmp %g2, 0 400063e8: 12 80 00 07 bne 40006404 400063ec: 01 00 00 00 nop 400063f0: 40 00 14 22 call 4000b478 <_Thread_Dispatch> 400063f4: 01 00 00 00 nop 400063f8: 81 c7 e0 08 ret 400063fc: 81 e8 00 00 restore 40006400: b0 10 20 16 mov 0x16, %i0 *rwlock = the_rwlock->Object.id; _Thread_Enable_dispatch(); return 0; } 40006404: 81 c7 e0 08 ret 40006408: 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 ); 4000640c: 40 00 03 4e call 40007144 <== NOT EXECUTED 40006410: 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 ) 40006414: 10 bf ff de b 4000638c <== NOT EXECUTED 40006418: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED if ( !the_rwlock ) { _Thread_Enable_dispatch(); return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 4000641c: 40 00 0b 14 call 4000906c <_CORE_RWLock_Initialize> 40006420: 92 07 bf f4 add %fp, -12, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006424: 90 14 62 6c or %l1, 0x26c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40006428: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000642c: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40006430: 03 00 00 3f sethi %hi(0xfc00), %g1 40006434: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40006438: 82 08 c0 01 and %g3, %g1, %g1 4000643c: 80 a0 40 02 cmp %g1, %g2 40006440: 38 80 00 06 bgu,a 40006458 40006444: c6 26 00 00 st %g3, [ %i0 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40006448: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000644c: 83 28 60 02 sll %g1, 2, %g1 40006450: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 40006454: c6 26 00 00 st %g3, [ %i0 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 40006458: c0 24 20 0c clr [ %l0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000645c: c2 06 63 d0 ld [ %i1 + 0x3d0 ], %g1 40006460: 10 bf ff de b 400063d8 40006464: b0 10 20 00 clr %i0 40006468 : */ int pthread_rwlock_rdlock( pthread_rwlock_t *rwlock ) { 40006468: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 4000646c: 80 a6 20 00 cmp %i0, 0 40006470: 02 80 00 24 be 40006500 40006474: 11 10 00 76 sethi %hi(0x4001d800), %o0 RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get ( pthread_rwlock_t *RWLock, Objects_Locations *location ) { return (POSIX_RWLock_Control *) _Objects_Get( 40006478: d2 06 00 00 ld [ %i0 ], %o1 4000647c: 94 07 bf f4 add %fp, -12, %o2 40006480: 40 00 0f 12 call 4000a0c8 <_Objects_Get> 40006484: 90 12 22 6c or %o0, 0x26c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 40006488: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000648c: 80 a0 60 00 cmp %g1, 0 40006490: 22 80 00 09 be,a 400064b4 40006494: d2 06 00 00 ld [ %i0 ], %o1 40006498: 80 a0 60 02 cmp %g1, 2 4000649c: 08 80 00 1a bleu 40006504 400064a0: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 400064a4: 40 00 03 51 call 400071e8 <== NOT EXECUTED 400064a8: 01 00 00 00 nop <== NOT EXECUTED } 400064ac: 81 c7 e0 08 ret <== NOT EXECUTED 400064b0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 400064b4: 90 02 20 10 add %o0, 0x10, %o0 400064b8: 94 10 20 01 mov 1, %o2 400064bc: 96 10 20 00 clr %o3 400064c0: 40 00 0a f6 call 40009098 <_CORE_RWLock_Obtain_for_reading> 400064c4: 98 10 20 00 clr %o4 400064c8: 03 10 00 75 sethi %hi(0x4001d400), %g1 400064cc: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 4001d7d0 <_Thread_Dispatch_disable_level> 400064d0: 84 00 bf ff add %g2, -1, %g2 400064d4: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 400064d8: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 400064dc: 80 a0 e0 00 cmp %g3, 0 400064e0: 02 80 00 0b be 4000650c 400064e4: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 400064e8: 03 10 00 76 sethi %hi(0x4001d800), %g1 <== NOT EXECUTED 400064ec: c4 00 60 ac ld [ %g1 + 0xac ], %g2 ! 4001d8ac <_Thread_Executing> 400064f0: 40 00 00 a1 call 40006774 <_POSIX_RWLock_Translate_core_RWLock_return_code> 400064f4: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 400064f8: 81 c7 e0 08 ret 400064fc: 91 e8 00 08 restore %g0, %o0, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40006500: 90 10 20 16 mov 0x16, %o0 } 40006504: 81 c7 e0 08 ret 40006508: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 4000650c: 40 00 13 db call 4000b478 <_Thread_Dispatch> 40006510: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 40006514: 10 bf ff f6 b 400064ec 40006518: 03 10 00 76 sethi %hi(0x4001d800), %g1 4000651c : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 4000651c: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations location; Watchdog_Interval ticks; boolean do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 40006520: 80 a6 20 00 cmp %i0, 0 40006524: 02 80 00 2b be 400065d0 40006528: 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 ); 4000652c: 40 00 22 b7 call 4000f008 <_POSIX_Absolute_timeout_to_ticks> 40006530: 92 07 bf f0 add %fp, -16, %o1 switch (status) { 40006534: 80 a2 20 02 cmp %o0, 2 40006538: 08 80 00 29 bleu 400065dc 4000653c: b2 10 00 08 mov %o0, %i1 40006540: 80 a2 20 03 cmp %o0, 3 40006544: 22 80 00 02 be,a 4000654c 40006548: a0 10 20 01 mov 1, %l0 4000654c: d2 06 00 00 ld [ %i0 ], %o1 40006550: 11 10 00 76 sethi %hi(0x4001d800), %o0 40006554: 94 07 bf f4 add %fp, -12, %o2 40006558: 40 00 0e dc call 4000a0c8 <_Objects_Get> 4000655c: 90 12 22 6c or %o0, 0x26c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 40006560: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006564: 80 a0 60 00 cmp %g1, 0 40006568: 12 80 00 27 bne 40006604 4000656c: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 40006570: d2 06 00 00 ld [ %i0 ], %o1 40006574: d6 07 bf f0 ld [ %fp + -16 ], %o3 40006578: 90 02 20 10 add %o0, 0x10, %o0 4000657c: 94 10 00 10 mov %l0, %o2 40006580: 40 00 0a c6 call 40009098 <_CORE_RWLock_Obtain_for_reading> 40006584: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006588: 03 10 00 75 sethi %hi(0x4001d400), %g1 4000658c: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 4001d7d0 <_Thread_Dispatch_disable_level> 40006590: 84 00 bf ff add %g2, -1, %g2 40006594: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 40006598: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 4000659c: 80 a0 e0 00 cmp %g3, 0 400065a0: 02 80 00 26 be 40006638 400065a4: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 400065a8: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 400065ac: 12 80 00 1e bne 40006624 400065b0: 07 10 00 76 sethi %hi(0x4001d800), %g3 400065b4: c2 00 e0 ac ld [ %g3 + 0xac ], %g1 ! 4001d8ac <_Thread_Executing> <== NOT EXECUTED 400065b8: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 <== NOT EXECUTED 400065bc: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 400065c0: 12 80 00 1a bne 40006628 <== NOT EXECUTED 400065c4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 400065c8: 12 80 00 15 bne 4000661c <== NOT EXECUTED 400065cc: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 400065d0: 90 10 20 16 mov 0x16, %o0 } 400065d4: 81 c7 e0 08 ret 400065d8: 91 e8 00 08 restore %g0, %o0, %o0 400065dc: d2 06 00 00 ld [ %i0 ], %o1 400065e0: 11 10 00 76 sethi %hi(0x4001d800), %o0 400065e4: 94 07 bf f4 add %fp, -12, %o2 400065e8: 40 00 0e b8 call 4000a0c8 <_Objects_Get> 400065ec: 90 12 22 6c or %o0, 0x26c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 400065f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400065f4: 80 a0 60 00 cmp %g1, 0 400065f8: 02 bf ff de be 40006570 400065fc: a0 10 20 00 clr %l0 40006600: 80 a0 60 02 cmp %g1, 2 40006604: 08 bf ff f4 bleu 400065d4 40006608: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 4000660c: 40 00 02 f7 call 400071e8 <== NOT EXECUTED 40006610: 01 00 00 00 nop <== NOT EXECUTED } 40006614: 81 c7 e0 08 ret <== NOT EXECUTED 40006618: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 4000661c: 08 bf ff ee bleu 400065d4 <== NOT EXECUTED 40006620: 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( 40006624: c2 00 e0 ac ld [ %g3 + 0xac ], %g1 40006628: 40 00 00 53 call 40006774 <_POSIX_RWLock_Translate_core_RWLock_return_code> 4000662c: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40006630: 81 c7 e0 08 ret 40006634: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40006638: 40 00 13 90 call 4000b478 <_Thread_Dispatch> 4000663c: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 40006640: 10 bf ff db b 400065ac 40006644: 80 a4 20 00 cmp %l0, 0 40006648 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 40006648: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations location; Watchdog_Interval ticks; boolean do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 4000664c: 80 a6 20 00 cmp %i0, 0 40006650: 02 80 00 2b be 400066fc 40006654: 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 ); 40006658: 40 00 22 6c call 4000f008 <_POSIX_Absolute_timeout_to_ticks> 4000665c: 92 07 bf f0 add %fp, -16, %o1 switch (status) { 40006660: 80 a2 20 02 cmp %o0, 2 40006664: 08 80 00 29 bleu 40006708 40006668: b2 10 00 08 mov %o0, %i1 4000666c: 80 a2 20 03 cmp %o0, 3 40006670: 22 80 00 02 be,a 40006678 40006674: a0 10 20 01 mov 1, %l0 40006678: d2 06 00 00 ld [ %i0 ], %o1 4000667c: 11 10 00 76 sethi %hi(0x4001d800), %o0 40006680: 94 07 bf f4 add %fp, -12, %o2 40006684: 40 00 0e 91 call 4000a0c8 <_Objects_Get> 40006688: 90 12 22 6c or %o0, 0x26c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 4000668c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006690: 80 a0 60 00 cmp %g1, 0 40006694: 12 80 00 27 bne 40006730 40006698: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 4000669c: d2 06 00 00 ld [ %i0 ], %o1 400066a0: d6 07 bf f0 ld [ %fp + -16 ], %o3 400066a4: 90 02 20 10 add %o0, 0x10, %o0 400066a8: 94 10 00 10 mov %l0, %o2 400066ac: 40 00 0a b0 call 4000916c <_CORE_RWLock_Obtain_for_writing> 400066b0: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400066b4: 03 10 00 75 sethi %hi(0x4001d400), %g1 400066b8: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 4001d7d0 <_Thread_Dispatch_disable_level> 400066bc: 84 00 bf ff add %g2, -1, %g2 400066c0: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 400066c4: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 400066c8: 80 a0 e0 00 cmp %g3, 0 400066cc: 02 80 00 26 be 40006764 400066d0: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 400066d4: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 400066d8: 12 80 00 1e bne 40006750 400066dc: 07 10 00 76 sethi %hi(0x4001d800), %g3 400066e0: c2 00 e0 ac ld [ %g3 + 0xac ], %g1 ! 4001d8ac <_Thread_Executing> <== NOT EXECUTED 400066e4: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 <== NOT EXECUTED 400066e8: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 400066ec: 12 80 00 1a bne 40006754 <== NOT EXECUTED 400066f0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 400066f4: 12 80 00 15 bne 40006748 <== NOT EXECUTED 400066f8: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 400066fc: 90 10 20 16 mov 0x16, %o0 } 40006700: 81 c7 e0 08 ret 40006704: 91 e8 00 08 restore %g0, %o0, %o0 40006708: d2 06 00 00 ld [ %i0 ], %o1 4000670c: 11 10 00 76 sethi %hi(0x4001d800), %o0 40006710: 94 07 bf f4 add %fp, -12, %o2 40006714: 40 00 0e 6d call 4000a0c8 <_Objects_Get> 40006718: 90 12 22 6c or %o0, 0x26c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 4000671c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006720: 80 a0 60 00 cmp %g1, 0 40006724: 02 bf ff de be 4000669c 40006728: a0 10 20 00 clr %l0 4000672c: 80 a0 60 02 cmp %g1, 2 40006730: 08 bf ff f4 bleu 40006700 40006734: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40006738: 40 00 02 ac call 400071e8 <== NOT EXECUTED 4000673c: 01 00 00 00 nop <== NOT EXECUTED } 40006740: 81 c7 e0 08 ret <== NOT EXECUTED 40006744: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 40006748: 08 bf ff ee bleu 40006700 <== NOT EXECUTED 4000674c: 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( 40006750: c2 00 e0 ac ld [ %g3 + 0xac ], %g1 40006754: 40 00 00 08 call 40006774 <_POSIX_RWLock_Translate_core_RWLock_return_code> 40006758: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 4000675c: 81 c7 e0 08 ret 40006760: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40006764: 40 00 13 45 call 4000b478 <_Thread_Dispatch> 40006768: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 4000676c: 10 bf ff db b 400066d8 40006770: 80 a4 20 00 cmp %l0, 0 400067a0 : */ int pthread_rwlock_tryrdlock( pthread_rwlock_t *rwlock ) { 400067a0: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 400067a4: 80 a6 20 00 cmp %i0, 0 400067a8: 02 80 00 24 be 40006838 400067ac: 11 10 00 76 sethi %hi(0x4001d800), %o0 400067b0: d2 06 00 00 ld [ %i0 ], %o1 400067b4: 94 07 bf f4 add %fp, -12, %o2 400067b8: 40 00 0e 44 call 4000a0c8 <_Objects_Get> 400067bc: 90 12 22 6c or %o0, 0x26c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 400067c0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400067c4: 80 a0 60 00 cmp %g1, 0 400067c8: 22 80 00 09 be,a 400067ec 400067cc: d2 06 00 00 ld [ %i0 ], %o1 400067d0: 80 a0 60 02 cmp %g1, 2 400067d4: 08 80 00 1a bleu 4000683c 400067d8: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 400067dc: 40 00 02 83 call 400071e8 <== NOT EXECUTED 400067e0: 01 00 00 00 nop <== NOT EXECUTED } 400067e4: 81 c7 e0 08 ret <== NOT EXECUTED 400067e8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 400067ec: 90 02 20 10 add %o0, 0x10, %o0 400067f0: 94 10 20 00 clr %o2 400067f4: 96 10 20 00 clr %o3 400067f8: 40 00 0a 28 call 40009098 <_CORE_RWLock_Obtain_for_reading> 400067fc: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006800: 03 10 00 75 sethi %hi(0x4001d400), %g1 40006804: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 4001d7d0 <_Thread_Dispatch_disable_level> 40006808: 84 00 bf ff add %g2, -1, %g2 4000680c: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 40006810: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 40006814: 80 a0 e0 00 cmp %g3, 0 40006818: 02 80 00 0b be 40006844 4000681c: 01 00 00 00 nop NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 40006820: 03 10 00 76 sethi %hi(0x4001d800), %g1 <== NOT EXECUTED 40006824: c4 00 60 ac ld [ %g1 + 0xac ], %g2 ! 4001d8ac <_Thread_Executing> 40006828: 7f ff ff d3 call 40006774 <_POSIX_RWLock_Translate_core_RWLock_return_code> 4000682c: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40006830: 81 c7 e0 08 ret 40006834: 91 e8 00 08 restore %g0, %o0, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40006838: 90 10 20 16 mov 0x16, %o0 } 4000683c: 81 c7 e0 08 ret 40006840: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40006844: 40 00 13 0d call 4000b478 <_Thread_Dispatch> 40006848: 01 00 00 00 nop NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 4000684c: 10 bf ff f6 b 40006824 40006850: 03 10 00 76 sethi %hi(0x4001d800), %g1 40006854 : */ int pthread_rwlock_trywrlock( pthread_rwlock_t *rwlock ) { 40006854: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 40006858: 80 a6 20 00 cmp %i0, 0 4000685c: 02 80 00 24 be 400068ec 40006860: 11 10 00 76 sethi %hi(0x4001d800), %o0 40006864: d2 06 00 00 ld [ %i0 ], %o1 40006868: 94 07 bf f4 add %fp, -12, %o2 4000686c: 40 00 0e 17 call 4000a0c8 <_Objects_Get> 40006870: 90 12 22 6c or %o0, 0x26c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 40006874: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006878: 80 a0 60 00 cmp %g1, 0 4000687c: 22 80 00 09 be,a 400068a0 40006880: d2 06 00 00 ld [ %i0 ], %o1 40006884: 80 a0 60 02 cmp %g1, 2 40006888: 08 80 00 1a bleu 400068f0 4000688c: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40006890: 40 00 02 56 call 400071e8 <== NOT EXECUTED 40006894: 01 00 00 00 nop <== NOT EXECUTED } 40006898: 81 c7 e0 08 ret <== NOT EXECUTED 4000689c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 400068a0: 90 02 20 10 add %o0, 0x10, %o0 400068a4: 94 10 20 00 clr %o2 400068a8: 96 10 20 00 clr %o3 400068ac: 40 00 0a 30 call 4000916c <_CORE_RWLock_Obtain_for_writing> 400068b0: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400068b4: 03 10 00 75 sethi %hi(0x4001d400), %g1 400068b8: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 4001d7d0 <_Thread_Dispatch_disable_level> 400068bc: 84 00 bf ff add %g2, -1, %g2 400068c0: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 400068c4: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 400068c8: 80 a0 e0 00 cmp %g3, 0 400068cc: 02 80 00 0b be 400068f8 400068d0: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 400068d4: 03 10 00 76 sethi %hi(0x4001d800), %g1 <== NOT EXECUTED 400068d8: c4 00 60 ac ld [ %g1 + 0xac ], %g2 ! 4001d8ac <_Thread_Executing> 400068dc: 7f ff ff a6 call 40006774 <_POSIX_RWLock_Translate_core_RWLock_return_code> 400068e0: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 400068e4: 81 c7 e0 08 ret 400068e8: 91 e8 00 08 restore %g0, %o0, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 400068ec: 90 10 20 16 mov 0x16, %o0 } 400068f0: 81 c7 e0 08 ret 400068f4: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 400068f8: 40 00 12 e0 call 4000b478 <_Thread_Dispatch> 400068fc: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 40006900: 10 bf ff f6 b 400068d8 40006904: 03 10 00 76 sethi %hi(0x4001d800), %g1 40006908 : */ int pthread_rwlock_unlock( pthread_rwlock_t *rwlock ) { 40006908: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; CORE_RWLock_Status status; if ( !rwlock ) 4000690c: 80 a6 20 00 cmp %i0, 0 40006910: 02 80 00 1f be 4000698c 40006914: 11 10 00 76 sethi %hi(0x4001d800), %o0 40006918: d2 06 00 00 ld [ %i0 ], %o1 4000691c: 94 07 bf f4 add %fp, -12, %o2 40006920: 40 00 0d ea call 4000a0c8 <_Objects_Get> 40006924: 90 12 22 6c or %o0, 0x26c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 40006928: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000692c: 80 a0 60 00 cmp %g1, 0 40006930: 02 80 00 08 be 40006950 40006934: 80 a0 60 02 cmp %g1, 2 40006938: 08 80 00 16 bleu 40006990 4000693c: 90 10 20 16 mov 0x16, %o0 status = _CORE_RWLock_Release( &the_rwlock->RWLock ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 40006940: 40 00 02 2a call 400071e8 <== NOT EXECUTED 40006944: 01 00 00 00 nop <== NOT EXECUTED } 40006948: 81 c7 e0 08 ret <== NOT EXECUTED 4000694c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_RWLock_Release( &the_rwlock->RWLock ); 40006950: 40 00 0a 29 call 400091f4 <_CORE_RWLock_Release> 40006954: 90 02 20 10 add %o0, 0x10, %o0 40006958: b0 10 00 08 mov %o0, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000695c: 03 10 00 75 sethi %hi(0x4001d400), %g1 40006960: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 4001d7d0 <_Thread_Dispatch_disable_level> 40006964: 84 00 bf ff add %g2, -1, %g2 40006968: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 4000696c: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 40006970: 80 a0 e0 00 cmp %g3, 0 40006974: 02 80 00 09 be 40006998 40006978: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); 4000697c: 7f ff ff 7e call 40006774 <_POSIX_RWLock_Translate_core_RWLock_return_code> 40006980: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 40006984: 81 c7 e0 08 ret 40006988: 91 e8 00 08 restore %g0, %o0, %o0 status = _CORE_RWLock_Release( &the_rwlock->RWLock ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 4000698c: 90 10 20 16 mov 0x16, %o0 } 40006990: 81 c7 e0 08 ret 40006994: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40006998: 40 00 12 b8 call 4000b478 <_Thread_Dispatch> 4000699c: 01 00 00 00 nop 400069a0: 30 bf ff f7 b,a 4000697c 400069a4 : */ int pthread_rwlock_wrlock( pthread_rwlock_t *rwlock ) { 400069a4: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 400069a8: 80 a6 20 00 cmp %i0, 0 400069ac: 02 80 00 24 be 40006a3c 400069b0: 11 10 00 76 sethi %hi(0x4001d800), %o0 400069b4: d2 06 00 00 ld [ %i0 ], %o1 400069b8: 94 07 bf f4 add %fp, -12, %o2 400069bc: 40 00 0d c3 call 4000a0c8 <_Objects_Get> 400069c0: 90 12 22 6c or %o0, 0x26c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 400069c4: c2 07 bf f4 ld [ %fp + -12 ], %g1 400069c8: 80 a0 60 00 cmp %g1, 0 400069cc: 22 80 00 09 be,a 400069f0 400069d0: d2 06 00 00 ld [ %i0 ], %o1 400069d4: 80 a0 60 02 cmp %g1, 2 400069d8: 08 80 00 1a bleu 40006a40 400069dc: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 400069e0: 40 00 02 02 call 400071e8 <== NOT EXECUTED 400069e4: 01 00 00 00 nop <== NOT EXECUTED } 400069e8: 81 c7 e0 08 ret <== NOT EXECUTED 400069ec: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 400069f0: 90 02 20 10 add %o0, 0x10, %o0 400069f4: 94 10 20 01 mov 1, %o2 400069f8: 96 10 20 00 clr %o3 400069fc: 40 00 09 dc call 4000916c <_CORE_RWLock_Obtain_for_writing> 40006a00: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006a04: 03 10 00 75 sethi %hi(0x4001d400), %g1 40006a08: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 4001d7d0 <_Thread_Dispatch_disable_level> 40006a0c: 84 00 bf ff add %g2, -1, %g2 40006a10: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 40006a14: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 40006a18: 80 a0 e0 00 cmp %g3, 0 40006a1c: 02 80 00 0b be 40006a48 40006a20: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 40006a24: 03 10 00 76 sethi %hi(0x4001d800), %g1 <== NOT EXECUTED 40006a28: c4 00 60 ac ld [ %g1 + 0xac ], %g2 ! 4001d8ac <_Thread_Executing> 40006a2c: 7f ff ff 52 call 40006774 <_POSIX_RWLock_Translate_core_RWLock_return_code> 40006a30: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40006a34: 81 c7 e0 08 ret 40006a38: 91 e8 00 08 restore %g0, %o0, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40006a3c: 90 10 20 16 mov 0x16, %o0 } 40006a40: 81 c7 e0 08 ret 40006a44: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40006a48: 40 00 12 8c call 4000b478 <_Thread_Dispatch> 40006a4c: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 40006a50: 10 bf ff f6 b 40006a28 40006a54: 03 10 00 76 sethi %hi(0x4001d800), %g1 40005c90 : int pthread_setcancelstate( int state, int *oldstate ) { 40005c90: 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() ) 40005c94: 03 10 00 5f sethi %hi(0x40017c00), %g1 40005c98: c4 00 61 14 ld [ %g1 + 0x114 ], %g2 ! 40017d14 <_ISR_Nest_level> int pthread_setcancelstate( int state, int *oldstate ) { 40005c9c: 86 10 00 18 mov %i0, %g3 * 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() ) 40005ca0: 80 a0 a0 00 cmp %g2, 0 40005ca4: 12 80 00 22 bne 40005d2c 40005ca8: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldstate ) 40005cac: 80 a6 60 00 cmp %i1, 0 40005cb0: 02 80 00 04 be 40005cc0 40005cb4: 80 a0 e0 01 cmp %g3, 1 return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 40005cb8: 08 80 00 04 bleu 40005cc8 40005cbc: 21 10 00 5f sethi %hi(0x40017c00), %l0 thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); _Thread_Enable_dispatch(); return 0; } 40005cc0: 81 c7 e0 08 ret <== NOT EXECUTED 40005cc4: 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 ]; 40005cc8: 09 10 00 5f sethi %hi(0x40017c00), %g4 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40005ccc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 40005cd0: c4 01 21 2c ld [ %g4 + 0x12c ], %g2 40005cd4: 82 00 60 01 inc %g1 40005cd8: c4 00 a1 70 ld [ %g2 + 0x170 ], %g2 40005cdc: c2 24 20 50 st %g1, [ %l0 + 0x50 ] _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 40005ce0: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 40005ce4: 80 a0 e0 00 cmp %g3, 0 return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 40005ce8: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 40005cec: 12 80 00 06 bne 40005d04 40005cf0: c6 20 a0 cc st %g3, [ %g2 + 0xcc ] 40005cf4: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 40005cf8: 80 a0 60 01 cmp %g1, 1 40005cfc: 22 80 00 0e be,a 40005d34 40005d00: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005d04: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 40005d08: b0 10 20 00 clr %i0 40005d0c: 82 00 7f ff add %g1, -1, %g1 40005d10: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 40005d14: c4 04 20 50 ld [ %l0 + 0x50 ], %g2 40005d18: 80 a0 a0 00 cmp %g2, 0 40005d1c: 12 80 00 04 bne 40005d2c 40005d20: 01 00 00 00 nop _Thread_Dispatch(); 40005d24: 40 00 10 27 call 40009dc0 <_Thread_Dispatch> 40005d28: 01 00 00 00 nop 40005d2c: 81 c7 e0 08 ret 40005d30: 81 e8 00 00 restore 40005d34: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40005d38: 02 bf ff f3 be 40005d04 <== NOT EXECUTED 40005d3c: 01 00 00 00 nop <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 40005d40: 7f ff fd b7 call 4000541c <_POSIX_Threads_cancel_run> <== NOT EXECUTED 40005d44: d0 01 21 2c ld [ %g4 + 0x12c ], %o0 <== NOT EXECUTED 40005d48: 30 bf ff ef b,a 40005d04 <== NOT EXECUTED 40005d4c : int pthread_setcanceltype( int type, int *oldtype ) { 40005d4c: 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() ) 40005d50: 03 10 00 5f sethi %hi(0x40017c00), %g1 40005d54: c4 00 61 14 ld [ %g1 + 0x114 ], %g2 ! 40017d14 <_ISR_Nest_level> int pthread_setcanceltype( int type, int *oldtype ) { 40005d58: 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() ) 40005d5c: 80 a0 a0 00 cmp %g2, 0 40005d60: 12 80 00 22 bne 40005de8 40005d64: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldtype ) 40005d68: 80 a6 60 00 cmp %i1, 0 40005d6c: 02 80 00 04 be 40005d7c 40005d70: 80 a1 20 01 cmp %g4, 1 return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 40005d74: 08 80 00 04 bleu 40005d84 40005d78: 21 10 00 5f sethi %hi(0x40017c00), %l0 thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); _Thread_Enable_dispatch(); return 0; } 40005d7c: 81 c7 e0 08 ret <== NOT EXECUTED 40005d80: 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 ]; 40005d84: 1b 10 00 5f sethi %hi(0x40017c00), %o5 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40005d88: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 40005d8c: c4 03 61 2c ld [ %o5 + 0x12c ], %g2 40005d90: 82 00 60 01 inc %g1 40005d94: c6 00 a1 70 ld [ %g2 + 0x170 ], %g3 40005d98: c2 24 20 50 st %g1, [ %l0 + 0x50 ] _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 40005d9c: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 40005da0: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_type = type; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 40005da4: c4 00 e0 cc ld [ %g3 + 0xcc ], %g2 40005da8: 80 a0 a0 00 cmp %g2, 0 40005dac: 12 80 00 05 bne 40005dc0 40005db0: c8 20 e0 d0 st %g4, [ %g3 + 0xd0 ] 40005db4: 80 a1 20 01 cmp %g4, 1 40005db8: 22 80 00 0e be,a 40005df0 40005dbc: c2 00 e0 d4 ld [ %g3 + 0xd4 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005dc0: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 40005dc4: b0 10 20 00 clr %i0 40005dc8: 82 00 7f ff add %g1, -1, %g1 40005dcc: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 40005dd0: c4 04 20 50 ld [ %l0 + 0x50 ], %g2 40005dd4: 80 a0 a0 00 cmp %g2, 0 40005dd8: 12 80 00 04 bne 40005de8 40005ddc: 01 00 00 00 nop _Thread_Dispatch(); 40005de0: 40 00 0f f8 call 40009dc0 <_Thread_Dispatch> 40005de4: 01 00 00 00 nop 40005de8: 81 c7 e0 08 ret 40005dec: 81 e8 00 00 restore 40005df0: 80 a0 60 00 cmp %g1, 0 40005df4: 02 bf ff f3 be 40005dc0 40005df8: 01 00 00 00 nop thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 40005dfc: 7f ff fd 88 call 4000541c <_POSIX_Threads_cancel_run> <== NOT EXECUTED 40005e00: d0 03 61 2c ld [ %o5 + 0x12c ], %o0 <== NOT EXECUTED 40005e04: 30 bf ff ef b,a 40005dc0 <== NOT EXECUTED 400088a0 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 400088a0: 9d e3 bf 90 save %sp, -112, %sp /* * Check all the parameters */ if ( !param ) 400088a4: 80 a6 a0 00 cmp %i2, 0 400088a8: 02 80 00 10 be 400088e8 400088ac: 90 10 20 16 mov 0x16, %o0 return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 400088b0: c2 06 80 00 ld [ %i2 ], %g1 400088b4: 82 00 7f ff add %g1, -1, %g1 400088b8: 80 a0 60 fd cmp %g1, 0xfd 400088bc: 18 80 00 0b bgu 400088e8 400088c0: 80 a6 60 01 cmp %i1, 1 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 400088c4: 02 80 00 66 be 40008a5c 400088c8: a2 10 20 00 clr %l1 400088cc: 04 80 00 66 ble 40008a64 400088d0: 80 a6 60 02 cmp %i1, 2 400088d4: 02 80 00 07 be 400088f0 400088d8: 80 a6 60 03 cmp %i1, 3 400088dc: 02 80 00 41 be 400089e0 400088e0: 01 00 00 00 nop } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400088e4: 90 10 20 16 mov 0x16, %o0 ! 16 } 400088e8: 81 c7 e0 08 ret 400088ec: 91 e8 00 08 restore %g0, %o0, %o0 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 400088f0: a2 10 20 02 mov 2, %l1 400088f4: a4 10 20 00 clr %l2 400088f8: 92 10 00 18 mov %i0, %o1 400088fc: 11 10 00 6c sethi %hi(0x4001b000), %o0 40008900: 94 07 bf f4 add %fp, -12, %o2 40008904: 40 00 0b 37 call 4000b5e0 <_Objects_Get> 40008908: 90 12 23 d8 or %o0, 0x3d8, %o0 /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 4000890c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008910: 80 a0 60 00 cmp %g1, 0 40008914: 12 80 00 4b bne 40008a40 40008918: b0 10 00 08 mov %o0, %i0 case OBJECTS_ERROR: case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 4000891c: e0 02 21 70 ld [ %o0 + 0x170 ], %l0 if ( api->schedpolicy == SCHED_SPORADIC ) 40008920: c2 04 20 7c ld [ %l0 + 0x7c ], %g1 40008924: 80 a0 60 03 cmp %g1, 3 40008928: 02 80 00 5e be 40008aa0 4000892c: 01 00 00 00 nop (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; 40008930: f2 24 20 7c st %i1, [ %l0 + 0x7c ] api->schedparam = *param; 40008934: c6 06 80 00 ld [ %i2 ], %g3 the_thread->budget_algorithm = budget_algorithm; 40008938: e2 26 20 88 st %l1, [ %i0 + 0x88 ] if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; 4000893c: c6 24 20 80 st %g3, [ %l0 + 0x80 ] 40008940: c2 06 a0 04 ld [ %i2 + 4 ], %g1 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; 40008944: e4 26 20 8c st %l2, [ %i0 + 0x8c ] if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; 40008948: c2 24 20 84 st %g1, [ %l0 + 0x84 ] 4000894c: c4 06 a0 08 ld [ %i2 + 8 ], %g2 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 40008950: 80 a6 60 00 cmp %i1, 0 if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; 40008954: c4 24 20 88 st %g2, [ %l0 + 0x88 ] 40008958: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 4000895c: c2 24 20 8c st %g1, [ %l0 + 0x8c ] 40008960: c4 06 a0 10 ld [ %i2 + 0x10 ], %g2 40008964: c4 24 20 90 st %g2, [ %l0 + 0x90 ] 40008968: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 4000896c: 06 80 00 0f bl 400089a8 40008970: c2 24 20 94 st %g1, [ %l0 + 0x94 ] 40008974: 80 a6 60 02 cmp %i1, 2 40008978: 14 80 00 41 bg 40008a7c 4000897c: 80 a6 60 03 cmp %i1, 3 40008980: 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; 40008984: 03 10 00 6c sethi %hi(0x4001b000), %g1 40008988: c4 00 60 48 ld [ %g1 + 0x48 ], %g2 ! 4001b048 <_Thread_Ticks_per_timeslice> 4000898c: 92 10 20 ff mov 0xff, %o1 the_thread->real_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 40008990: 90 10 00 18 mov %i0, %o0 40008994: 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; 40008998: c4 26 20 84 st %g2, [ %i0 + 0x84 ] the_thread->real_priority = 4000899c: d2 26 20 18 st %o1, [ %i0 + 0x18 ] _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 400089a0: 40 00 0e d8 call 4000c500 <_Thread_Change_priority> 400089a4: 94 10 20 01 mov 1, %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400089a8: 03 10 00 6c sethi %hi(0x4001b000), %g1 400089ac: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 4001b0f0 <_Thread_Dispatch_disable_level> 400089b0: 90 10 20 00 clr %o0 400089b4: 84 00 bf ff add %g2, -1, %g2 400089b8: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ] 400089bc: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 400089c0: 80 a0 e0 00 cmp %g3, 0 400089c4: 12 bf ff c9 bne 400088e8 400089c8: 01 00 00 00 nop _Thread_Dispatch(); 400089cc: 40 00 0f f1 call 4000c990 <_Thread_Dispatch> 400089d0: 01 00 00 00 nop 400089d4: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 400089d8: 81 c7 e0 08 ret 400089dc: 91 e8 00 08 restore %g0, %o0, %o0 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 ) < 400089e0: 40 00 14 80 call 4000dbe0 <_Timespec_To_ticks> 400089e4: 90 06 a0 08 add %i2, 8, %o0 400089e8: a0 10 00 08 mov %o0, %l0 400089ec: 40 00 14 7d call 4000dbe0 <_Timespec_To_ticks> 400089f0: 90 06 a0 10 add %i2, 0x10, %o0 400089f4: 80 a4 00 08 cmp %l0, %o0 400089f8: 2a bf ff bc bcs,a 400088e8 400089fc: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED _Timespec_To_ticks( ¶m->ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->ss_low_priority ) ) 40008a00: c2 06 a0 04 ld [ %i2 + 4 ], %g1 40008a04: 82 00 7f ff add %g1, -1, %g1 40008a08: 80 a0 60 fd cmp %g1, 0xfd 40008a0c: 18 bf ff b6 bgu 400088e4 40008a10: 03 10 00 21 sethi %hi(0x40008400), %g1 40008a14: 92 10 00 18 mov %i0, %o1 40008a18: a4 10 63 64 or %g1, 0x364, %l2 40008a1c: 11 10 00 6c sethi %hi(0x4001b000), %o0 40008a20: 94 07 bf f4 add %fp, -12, %o2 40008a24: 40 00 0a ef call 4000b5e0 <_Objects_Get> 40008a28: 90 12 23 d8 or %o0, 0x3d8, %o0 /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 40008a2c: c2 07 bf f4 ld [ %fp + -12 ], %g1 if ( _Timespec_To_ticks( ¶m->ss_replenish_period ) < _Timespec_To_ticks( ¶m->ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->ss_low_priority ) ) 40008a30: a2 10 20 03 mov 3, %l1 /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 40008a34: 80 a0 60 00 cmp %g1, 0 40008a38: 02 bf ff b9 be 4000891c 40008a3c: b0 10 00 08 mov %o0, %i0 40008a40: 80 a0 60 02 cmp %g1, 2 40008a44: 08 bf ff a9 bleu 400088e8 40008a48: 90 10 20 03 mov 3, %o0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40008a4c: 40 00 00 2c call 40008afc <== NOT EXECUTED 40008a50: 01 00 00 00 nop <== NOT EXECUTED } 40008a54: 81 c7 e0 08 ret <== NOT EXECUTED 40008a58: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 40008a5c: 10 bf ff a7 b 400088f8 40008a60: a4 10 20 00 clr %l2 40008a64: 80 a6 60 00 cmp %i1, 0 40008a68: a2 10 20 01 mov 1, %l1 40008a6c: 02 bf ff a3 be 400088f8 40008a70: a4 10 20 00 clr %l2 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40008a74: 10 bf ff 9d b 400088e8 40008a78: 90 10 20 16 mov 0x16, %o0 api->schedpolicy = policy; api->schedparam = *param; the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 40008a7c: 12 bf ff cb bne 400089a8 40008a80: 01 00 00 00 nop TRUE ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 40008a84: c6 24 20 98 st %g3, [ %l0 + 0x98 ] _Watchdog_Remove( &api->Sporadic_timer ); 40008a88: 40 00 15 d3 call 4000e1d4 <_Watchdog_Remove> 40008a8c: 90 04 20 9c add %l0, 0x9c, %o0 _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 40008a90: 92 10 00 18 mov %i0, %o1 40008a94: 7f ff ff 48 call 400087b4 <_POSIX_Threads_Sporadic_budget_TSR> 40008a98: 90 10 20 00 clr %o0 40008a9c: 30 bf ff c3 b,a 400089a8 return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 40008aa0: 40 00 15 cd call 4000e1d4 <_Watchdog_Remove> 40008aa4: 90 04 20 9c add %l0, 0x9c, %o0 api->schedpolicy = policy; 40008aa8: 10 bf ff a3 b 40008934 40008aac: f2 24 20 7c st %i1, [ %l0 + 0x7c ] 40005d08 : int pthread_setspecific( pthread_key_t key, const void *value ) { 40005d08: 9d e3 bf 90 save %sp, -112, %sp 40005d0c: 11 10 00 60 sethi %hi(0x40018000), %o0 40005d10: 92 10 00 18 mov %i0, %o1 40005d14: 90 12 22 00 or %o0, 0x200, %o0 40005d18: 40 00 0d 22 call 400091a0 <_Objects_Get> 40005d1c: 94 07 bf f4 add %fp, -12, %o2 uint32_t api; uint32_t index; Objects_Locations location; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 40005d20: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005d24: 80 a0 60 00 cmp %g1, 0 40005d28: 12 80 00 19 bne 40005d8c 40005d2c: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never happen */ return EINVAL; case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 40005d30: 03 10 00 5f sethi %hi(0x40017c00), %g1 40005d34: c4 00 61 dc ld [ %g1 + 0x1dc ], %g2 ! 40017ddc <_Thread_Executing> 40005d38: c6 00 a0 08 ld [ %g2 + 8 ], %g3 index = _Objects_Get_index( _Thread_Executing->Object.id ); the_key->Values[ api ][ index ] = (void *) value; 40005d3c: 05 00 00 3f sethi %hi(0xfc00), %g2 40005d40: 83 30 e0 16 srl %g3, 0x16, %g1 40005d44: 82 08 60 1c and %g1, 0x1c, %g1 40005d48: 82 00 40 08 add %g1, %o0, %g1 40005d4c: c8 00 60 18 ld [ %g1 + 0x18 ], %g4 40005d50: 84 10 a3 ff or %g2, 0x3ff, %g2 40005d54: 86 08 c0 02 and %g3, %g2, %g3 40005d58: 87 28 e0 02 sll %g3, 2, %g3 40005d5c: f2 21 00 03 st %i1, [ %g4 + %g3 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005d60: 07 10 00 5f sethi %hi(0x40017c00), %g3 40005d64: c2 00 e1 00 ld [ %g3 + 0x100 ], %g1 ! 40017d00 <_Thread_Dispatch_disable_level> 40005d68: 90 10 20 00 clr %o0 40005d6c: 82 00 7f ff add %g1, -1, %g1 40005d70: c2 20 e1 00 st %g1, [ %g3 + 0x100 ] 40005d74: c4 00 e1 00 ld [ %g3 + 0x100 ], %g2 40005d78: 80 a0 a0 00 cmp %g2, 0 40005d7c: 02 80 00 0a be 40005da4 40005d80: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40005d84: 81 c7 e0 08 ret 40005d88: 91 e8 00 08 restore %g0, %o0, %o0 uint32_t api; uint32_t index; Objects_Locations location; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 40005d8c: 08 bf ff fe bleu 40005d84 40005d90: 90 10 20 16 mov 0x16, %o0 index = _Objects_Get_index( _Thread_Executing->Object.id ); the_key->Values[ api ][ index ] = (void *) value; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40005d94: 40 00 02 4a call 400066bc <== NOT EXECUTED 40005d98: 01 00 00 00 nop <== NOT EXECUTED } 40005d9c: 81 c7 e0 08 ret <== NOT EXECUTED 40005da0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40005da4: 40 00 11 eb call 4000a550 <_Thread_Dispatch> 40005da8: 01 00 00 00 nop 40005dac: 90 10 20 00 clr %o0 ! 0 40005db0: 81 c7 e0 08 ret 40005db4: 91 e8 00 08 restore %g0, %o0, %o0 40005908 : */ int pthread_spin_destroy( pthread_spinlock_t *spinlock ) { 40005908: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; if ( !spinlock ) 4000590c: 80 a6 20 00 cmp %i0, 0 40005910: 02 80 00 23 be 4000599c 40005914: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get ( pthread_spinlock_t *spinlock, Objects_Locations *location ) { return (POSIX_Spinlock_Control *) _Objects_Get( 40005918: d2 06 00 00 ld [ %i0 ], %o1 4000591c: 31 10 00 54 sethi %hi(0x40015000), %i0 40005920: 40 00 0c 4e call 40008a58 <_Objects_Get> 40005924: 90 16 22 e4 or %i0, 0x2e4, %o0 ! 400152e4 <_POSIX_Spinlock_Information> return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 40005928: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000592c: 80 a0 60 00 cmp %g1, 0 40005930: 12 80 00 14 bne 40005980 40005934: 92 10 00 08 mov %o0, %o1 RTEMS_INLINE_ROUTINE boolean _CORE_spinlock_Is_busy( CORE_spinlock_Control *the_spinlock ) { return (the_spinlock->users != 0); 40005938: c2 02 20 18 ld [ %o0 + 0x18 ], %g1 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) { 4000593c: 80 a0 60 00 cmp %g1, 0 40005940: 02 80 00 1a be 400059a8 40005944: 90 16 22 e4 or %i0, 0x2e4, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005948: 03 10 00 53 sethi %hi(0x40014c00), %g1 4000594c: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 40014fb0 <_Thread_Dispatch_disable_level> 40005950: 90 10 20 10 mov 0x10, %o0 40005954: 84 00 bf ff add %g2, -1, %g2 40005958: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 4000595c: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 40005960: 80 a0 e0 00 cmp %g3, 0 40005964: 12 80 00 0c bne 40005994 40005968: 01 00 00 00 nop _Thread_Dispatch(); 4000596c: 40 00 11 27 call 40009e08 <_Thread_Dispatch> 40005970: 01 00 00 00 nop 40005974: 90 10 20 10 mov 0x10, %o0 ! 10 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40005978: 81 c7 e0 08 ret 4000597c: 91 e8 00 08 restore %g0, %o0, %o0 if ( !spinlock ) return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 40005980: 80 a0 60 02 cmp %g1, 2 40005984: 08 80 00 07 bleu 400059a0 40005988: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 4000598c: 40 00 00 e9 call 40005d30 <== NOT EXECUTED 40005990: 01 00 00 00 nop <== NOT EXECUTED } 40005994: 81 c7 e0 08 ret 40005998: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 4000599c: 90 10 20 16 mov 0x16, %o0 } 400059a0: 81 c7 e0 08 ret 400059a4: 91 e8 00 08 restore %g0, %o0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 400059a8: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400059ac: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 400059b0: 05 00 00 3f sethi %hi(0xfc00), %g2 400059b4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 400059b8: 82 08 40 02 and %g1, %g2, %g1 400059bc: 80 a0 40 03 cmp %g1, %g3 400059c0: 18 80 00 04 bgu 400059d0 400059c4: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 400059c8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400059cc: c0 20 80 01 clr [ %g2 + %g1 ] */ RTEMS_INLINE_ROUTINE void _POSIX_Spinlock_Free ( POSIX_Spinlock_Control *the_spinlock ) { _Objects_Free( &_POSIX_Spinlock_Information, &the_spinlock->Object ); 400059d0: 40 00 0b df call 4000894c <_Objects_Free> 400059d4: c0 22 60 0c clr [ %o1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400059d8: 03 10 00 53 sethi %hi(0x40014c00), %g1 400059dc: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 40014fb0 <_Thread_Dispatch_disable_level> 400059e0: 90 10 20 00 clr %o0 400059e4: 84 00 bf ff add %g2, -1, %g2 400059e8: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 400059ec: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 400059f0: 80 a0 e0 00 cmp %g3, 0 400059f4: 12 bf ff e8 bne 40005994 400059f8: 01 00 00 00 nop _Thread_Dispatch(); 400059fc: 40 00 11 03 call 40009e08 <_Thread_Dispatch> 40005a00: 01 00 00 00 nop 40005a04: 10 bf ff e4 b 40005994 40005a08: 90 10 20 00 clr %o0 ! 0 40005a0c : int pthread_spin_init( pthread_spinlock_t *spinlock, int pshared ) { 40005a0c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock; CORE_spinlock_Attributes attributes; if ( !spinlock ) 40005a10: 80 a6 20 00 cmp %i0, 0 40005a14: 02 80 00 1a be 40005a7c 40005a18: 80 a6 60 00 cmp %i1, 0 return EINVAL; switch ( pshared ) { 40005a1c: 32 80 00 16 bne,a 40005a74 40005a20: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40005a24: 21 10 00 53 sethi %hi(0x40014c00), %l0 40005a28: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 ! 40014fb0 <_Thread_Dispatch_disable_level> 40005a2c: 82 00 60 01 inc %g1 40005a30: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] * This function allocates a spinlock control block from * the inactive chain of free spinlock control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Allocate( void ) { return (POSIX_Spinlock_Control *) 40005a34: 23 10 00 54 sethi %hi(0x40015000), %l1 40005a38: 40 00 0a b7 call 40008514 <_Objects_Allocate> 40005a3c: 90 14 62 e4 or %l1, 0x2e4, %o0 ! 400152e4 <_POSIX_Spinlock_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_spinlock = _POSIX_Spinlock_Allocate(); if ( !the_spinlock ) { 40005a40: b2 92 20 00 orcc %o0, 0, %i1 40005a44: 12 80 00 11 bne 40005a88 40005a48: 90 06 60 10 add %i1, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005a4c: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 40005a50: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 40005a54: 82 00 7f ff add %g1, -1, %g1 40005a58: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] 40005a5c: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 40005a60: 80 a0 a0 00 cmp %g2, 0 40005a64: 12 80 00 07 bne 40005a80 40005a68: 01 00 00 00 nop 40005a6c: 40 00 10 e7 call 40009e08 <_Thread_Dispatch> 40005a70: 01 00 00 00 nop 40005a74: 81 c7 e0 08 ret 40005a78: 81 e8 00 00 restore 40005a7c: b0 10 20 16 mov 0x16, %i0 *spinlock = the_spinlock->Object.id; _Thread_Enable_dispatch(); return 0; } 40005a80: 81 c7 e0 08 ret 40005a84: 81 e8 00 00 restore if ( !the_spinlock ) { _Thread_Enable_dispatch(); return EAGAIN; } _CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes ); 40005a88: 40 00 08 76 call 40007c60 <_CORE_spinlock_Initialize> 40005a8c: 92 07 bf f4 add %fp, -12, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005a90: 90 14 62 e4 or %l1, 0x2e4, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40005a94: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005a98: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40005a9c: 03 00 00 3f sethi %hi(0xfc00), %g1 40005aa0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40005aa4: 82 08 c0 01 and %g3, %g1, %g1 40005aa8: 80 a0 40 02 cmp %g1, %g2 40005aac: 38 80 00 06 bgu,a 40005ac4 40005ab0: c6 26 00 00 st %g3, [ %i0 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40005ab4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40005ab8: 83 28 60 02 sll %g1, 2, %g1 40005abc: f2 20 80 01 st %i1, [ %g2 + %g1 ] &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 ); *spinlock = the_spinlock->Object.id; 40005ac0: c6 26 00 00 st %g3, [ %i0 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 40005ac4: c0 26 60 0c clr [ %i1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005ac8: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 40005acc: 10 bf ff e2 b 40005a54 40005ad0: b0 10 20 00 clr %i0 40005ad4 : */ int pthread_spin_lock( pthread_spinlock_t *spinlock ) { 40005ad4: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 40005ad8: 80 a6 20 00 cmp %i0, 0 40005adc: 02 80 00 21 be 40005b60 40005ae0: 11 10 00 54 sethi %hi(0x40015000), %o0 RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get ( pthread_spinlock_t *spinlock, Objects_Locations *location ) { return (POSIX_Spinlock_Control *) _Objects_Get( 40005ae4: d2 06 00 00 ld [ %i0 ], %o1 40005ae8: 94 07 bf f4 add %fp, -12, %o2 40005aec: 40 00 0b db call 40008a58 <_Objects_Get> 40005af0: 90 12 22 e4 or %o0, 0x2e4, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 40005af4: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005af8: 80 a0 60 00 cmp %g1, 0 40005afc: 02 80 00 09 be 40005b20 40005b00: 92 10 20 01 mov 1, %o1 40005b04: 80 a0 60 02 cmp %g1, 2 40005b08: 08 80 00 17 bleu 40005b64 40005b0c: 90 10 20 16 mov 0x16, %o0 case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 40005b10: 40 00 00 88 call 40005d30 <== NOT EXECUTED 40005b14: 01 00 00 00 nop <== NOT EXECUTED } 40005b18: 81 c7 e0 08 ret <== NOT EXECUTED 40005b1c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); 40005b20: 94 10 20 00 clr %o2 40005b24: 40 00 08 74 call 40007cf4 <_CORE_spinlock_Wait> 40005b28: 90 02 20 10 add %o0, 0x10, %o0 40005b2c: b0 10 00 08 mov %o0, %i0 40005b30: 03 10 00 53 sethi %hi(0x40014c00), %g1 40005b34: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 40014fb0 <_Thread_Dispatch_disable_level> 40005b38: 84 00 bf ff add %g2, -1, %g2 40005b3c: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 40005b40: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 40005b44: 80 a0 e0 00 cmp %g3, 0 40005b48: 02 80 00 09 be 40005b6c 40005b4c: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 40005b50: 40 00 00 0a call 40005b78 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 40005b54: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 40005b58: 81 c7 e0 08 ret 40005b5c: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 40005b60: 90 10 20 16 mov 0x16, %o0 } 40005b64: 81 c7 e0 08 ret 40005b68: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40005b6c: 40 00 10 a7 call 40009e08 <_Thread_Dispatch> 40005b70: 01 00 00 00 nop 40005b74: 30 bf ff f7 b,a 40005b50 40005ba4 : */ int pthread_spin_trylock( pthread_spinlock_t *spinlock ) { 40005ba4: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 40005ba8: 80 a6 20 00 cmp %i0, 0 40005bac: 02 80 00 21 be 40005c30 40005bb0: 11 10 00 54 sethi %hi(0x40015000), %o0 40005bb4: d2 06 00 00 ld [ %i0 ], %o1 40005bb8: 94 07 bf f4 add %fp, -12, %o2 40005bbc: 40 00 0b a7 call 40008a58 <_Objects_Get> 40005bc0: 90 12 22 e4 or %o0, 0x2e4, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 40005bc4: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005bc8: 80 a0 60 00 cmp %g1, 0 40005bcc: 02 80 00 09 be 40005bf0 40005bd0: 92 10 20 00 clr %o1 40005bd4: 80 a0 60 02 cmp %g1, 2 40005bd8: 08 80 00 17 bleu 40005c34 40005bdc: 90 10 20 16 mov 0x16, %o0 case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 40005be0: 40 00 00 54 call 40005d30 <== NOT EXECUTED 40005be4: 01 00 00 00 nop <== NOT EXECUTED } 40005be8: 81 c7 e0 08 ret <== NOT EXECUTED 40005bec: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); 40005bf0: 94 10 20 00 clr %o2 40005bf4: 40 00 08 40 call 40007cf4 <_CORE_spinlock_Wait> 40005bf8: 90 02 20 10 add %o0, 0x10, %o0 40005bfc: b0 10 00 08 mov %o0, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005c00: 03 10 00 53 sethi %hi(0x40014c00), %g1 40005c04: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 40014fb0 <_Thread_Dispatch_disable_level> 40005c08: 84 00 bf ff add %g2, -1, %g2 40005c0c: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 40005c10: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 40005c14: 80 a0 e0 00 cmp %g3, 0 40005c18: 02 80 00 09 be 40005c3c 40005c1c: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 40005c20: 7f ff ff d6 call 40005b78 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 40005c24: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 40005c28: 81 c7 e0 08 ret 40005c2c: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 40005c30: 90 10 20 16 mov 0x16, %o0 } 40005c34: 81 c7 e0 08 ret 40005c38: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40005c3c: 40 00 10 73 call 40009e08 <_Thread_Dispatch> 40005c40: 01 00 00 00 nop 40005c44: 30 bf ff f7 b,a 40005c20 40005c48 : */ int pthread_spin_unlock( pthread_spinlock_t *spinlock ) { 40005c48: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 40005c4c: 80 a6 20 00 cmp %i0, 0 40005c50: 02 80 00 1f be 40005ccc 40005c54: 11 10 00 54 sethi %hi(0x40015000), %o0 40005c58: d2 06 00 00 ld [ %i0 ], %o1 40005c5c: 94 07 bf f4 add %fp, -12, %o2 40005c60: 40 00 0b 7e call 40008a58 <_Objects_Get> 40005c64: 90 12 22 e4 or %o0, 0x2e4, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 40005c68: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005c6c: 80 a0 60 00 cmp %g1, 0 40005c70: 02 80 00 08 be 40005c90 40005c74: 80 a0 60 02 cmp %g1, 2 40005c78: 08 80 00 16 bleu 40005cd0 40005c7c: 90 10 20 16 mov 0x16, %o0 case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 40005c80: 40 00 00 2c call 40005d30 <== NOT EXECUTED 40005c84: 01 00 00 00 nop <== NOT EXECUTED } 40005c88: 81 c7 e0 08 ret <== NOT EXECUTED 40005c8c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); 40005c90: 40 00 07 fb call 40007c7c <_CORE_spinlock_Release> 40005c94: 90 02 20 10 add %o0, 0x10, %o0 40005c98: b0 10 00 08 mov %o0, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005c9c: 03 10 00 53 sethi %hi(0x40014c00), %g1 40005ca0: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 40014fb0 <_Thread_Dispatch_disable_level> 40005ca4: 84 00 bf ff add %g2, -1, %g2 40005ca8: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 40005cac: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 40005cb0: 80 a0 e0 00 cmp %g3, 0 40005cb4: 02 80 00 09 be 40005cd8 40005cb8: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 40005cbc: 7f ff ff af call 40005b78 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 40005cc0: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 40005cc4: 81 c7 e0 08 ret 40005cc8: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 40005ccc: 90 10 20 16 mov 0x16, %o0 } 40005cd0: 81 c7 e0 08 ret 40005cd4: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40005cd8: 40 00 10 4c call 40009e08 <_Thread_Dispatch> 40005cdc: 01 00 00 00 nop 40005ce0: 30 bf ff f7 b,a 40005cbc 40005e2c : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 40005e2c: 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() ) 40005e30: 03 10 00 5f sethi %hi(0x40017c00), %g1 40005e34: c4 00 61 14 ld [ %g1 + 0x114 ], %g2 ! 40017d14 <_ISR_Nest_level> 40005e38: 80 a0 a0 00 cmp %g2, 0 40005e3c: 12 80 00 17 bne 40005e98 40005e40: 21 10 00 5f sethi %hi(0x40017c00), %l0 return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 40005e44: 07 10 00 5f sethi %hi(0x40017c00), %g3 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40005e48: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 40005e4c: c4 00 e1 2c ld [ %g3 + 0x12c ], %g2 40005e50: 82 00 60 01 inc %g1 40005e54: c4 00 a1 70 ld [ %g2 + 0x170 ], %g2 40005e58: c2 24 20 50 st %g1, [ %l0 + 0x50 ] _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 40005e5c: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 40005e60: 80 a0 60 00 cmp %g1, 0 40005e64: 12 80 00 06 bne 40005e7c 40005e68: 01 00 00 00 nop 40005e6c: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 40005e70: 80 a0 60 00 cmp %g1, 0 40005e74: 12 80 00 0d bne 40005ea8 40005e78: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005e7c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 40005e80: 82 00 7f ff add %g1, -1, %g1 40005e84: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 40005e88: c4 04 20 50 ld [ %l0 + 0x50 ], %g2 40005e8c: 80 a0 a0 00 cmp %g2, 0 40005e90: 02 80 00 04 be 40005ea0 40005e94: 01 00 00 00 nop 40005e98: 81 c7 e0 08 ret <== NOT EXECUTED 40005e9c: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40005ea0: 40 00 0f c8 call 40009dc0 <_Thread_Dispatch> 40005ea4: 81 e8 00 00 restore thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 40005ea8: 7f ff fd 5d call 4000541c <_POSIX_Threads_cancel_run> 40005eac: d0 00 e1 2c ld [ %g3 + 0x12c ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005eb0: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 40005eb4: 82 00 7f ff add %g1, -1, %g1 40005eb8: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 40005ebc: c4 04 20 50 ld [ %l0 + 0x50 ], %g2 40005ec0: 80 a0 a0 00 cmp %g2, 0 40005ec4: 12 bf ff f5 bne 40005e98 40005ec8: 01 00 00 00 nop 40005ecc: 30 bf ff f5 b,a 40005ea0 4000624c : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 4000624c: 9d e3 bf 90 save %sp, -112, %sp Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 40006250: a4 96 20 00 orcc %i0, 0, %l2 40006254: 02 80 00 20 be 400062d4 40006258: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 4000625c: 80 a6 e0 00 cmp %i3, 0 40006260: 02 80 00 1d be 400062d4 40006264: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 40006268: 80 8e 60 10 btst 0x10, %i1 4000626c: 02 80 00 39 be 40006350 40006270: 80 a6 a0 00 cmp %i2, 0 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 40006274: 02 80 00 18 be 400062d4 40006278: b0 10 20 0a mov 0xa, %i0 if ( !id ) return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 4000627c: c0 27 bf f0 clr [ %fp + -16 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006280: 21 10 00 7c sethi %hi(0x4001f000), %l0 40006284: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 ! 4001f310 <_Thread_Dispatch_disable_level> if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 40006288: f4 27 bf f4 st %i2, [ %fp + -12 ] 4000628c: 82 00 60 01 inc %g1 40006290: c2 24 23 10 st %g1, [ %l0 + 0x310 ] * 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 ); 40006294: 23 10 00 7c sethi %hi(0x4001f000), %l1 40006298: 40 00 0a 6b call 40008c44 <_Objects_Allocate> 4000629c: 90 14 61 74 or %l1, 0x174, %o0 ! 4001f174 <_Barrier_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 400062a0: b4 92 20 00 orcc %o0, 0, %i2 400062a4: 12 80 00 0e bne 400062dc 400062a8: 90 06 a0 14 add %i2, 0x14, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400062ac: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 400062b0: b0 10 20 05 mov 5, %i0 400062b4: 82 00 7f ff add %g1, -1, %g1 400062b8: c2 24 23 10 st %g1, [ %l0 + 0x310 ] 400062bc: c4 04 23 10 ld [ %l0 + 0x310 ], %g2 400062c0: 80 a0 a0 00 cmp %g2, 0 400062c4: 12 80 00 21 bne 40006348 400062c8: 01 00 00 00 nop _Thread_Dispatch(); 400062cc: 40 00 10 d7 call 4000a628 <_Thread_Dispatch> 400062d0: 01 00 00 00 nop 400062d4: 81 c7 e0 08 ret 400062d8: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 400062dc: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 400062e0: 40 00 07 8d call 40008114 <_CORE_barrier_Initialize> 400062e4: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400062e8: 90 14 61 74 or %l1, 0x174, %o0 Objects_Name name ) { uint32_t index; index = _Objects_Get_index( the_object->id ); 400062ec: c6 06 a0 08 ld [ %i2 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400062f0: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 400062f4: 03 00 00 3f sethi %hi(0xfc00), %g1 400062f8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400062fc: 82 08 c0 01 and %g3, %g1, %g1 40006300: 80 a0 40 02 cmp %g1, %g2 40006304: 38 80 00 06 bgu,a 4000631c 40006308: e4 26 a0 0c st %l2, [ %i2 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000630c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006310: 83 28 60 02 sll %g1, 2, %g1 40006314: f4 20 80 01 st %i2, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 40006318: e4 26 a0 0c st %l2, [ %i2 + 0xc ] &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 4000631c: c6 26 c0 00 st %g3, [ %i3 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006320: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 40006324: b0 10 20 00 clr %i0 40006328: 82 00 7f ff add %g1, -1, %g1 4000632c: c2 24 23 10 st %g1, [ %l0 + 0x310 ] 40006330: c4 04 23 10 ld [ %l0 + 0x310 ], %g2 40006334: 80 a0 a0 00 cmp %g2, 0 40006338: 12 80 00 04 bne 40006348 4000633c: 01 00 00 00 nop _Thread_Dispatch(); 40006340: 40 00 10 ba call 4000a628 <_Thread_Dispatch> 40006344: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 40006348: 81 c7 e0 08 ret 4000634c: 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; 40006350: 82 10 20 01 mov 1, %g1 40006354: 10 bf ff cb b 40006280 40006358: c2 27 bf f0 st %g1, [ %fp + -16 ] 4000635c : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 4000635c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 40006360: 21 10 00 7c sethi %hi(0x4001f000), %l0 40006364: 92 10 00 18 mov %i0, %o1 40006368: 94 07 bf f4 add %fp, -12, %o2 4000636c: 40 00 0b 87 call 40009188 <_Objects_Get> 40006370: 90 14 21 74 or %l0, 0x174, %o0 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 40006374: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006378: 80 a0 60 00 cmp %g1, 0 4000637c: 12 80 00 20 bne 400063fc 40006380: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Flush( 40006384: 90 02 20 14 add %o0, 0x14, %o0 40006388: 92 10 20 00 clr %o1 4000638c: 40 00 13 1d call 4000b000 <_Thread_queue_Flush> 40006390: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006394: 90 14 21 74 or %l0, 0x174, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40006398: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000639c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 400063a0: 05 00 00 3f sethi %hi(0xfc00), %g2 400063a4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 400063a8: 82 08 40 02 and %g1, %g2, %g1 400063ac: 80 a0 40 03 cmp %g1, %g3 400063b0: 38 80 00 06 bgu,a 400063c8 400063b4: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 400063b8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400063bc: 83 28 60 02 sll %g1, 2, %g1 400063c0: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 400063c4: c0 26 20 0c clr [ %i0 + 0xc ] */ RTEMS_INLINE_ROUTINE void _Barrier_Free ( Barrier_Control *the_barrier ) { _Objects_Free( &_Barrier_Information, &the_barrier->Object ); 400063c8: 40 00 0b 2d call 4000907c <_Objects_Free> 400063cc: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400063d0: 03 10 00 7c sethi %hi(0x4001f000), %g1 400063d4: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 4001f310 <_Thread_Dispatch_disable_level> 400063d8: b0 10 20 00 clr %i0 400063dc: 84 00 bf ff add %g2, -1, %g2 400063e0: c4 20 63 10 st %g2, [ %g1 + 0x310 ] 400063e4: c6 00 63 10 ld [ %g1 + 0x310 ], %g3 400063e8: 80 a0 e0 00 cmp %g3, 0 400063ec: 02 80 00 09 be 40006410 400063f0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400063f4: 81 c7 e0 08 ret 400063f8: 81 e8 00 00 restore { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 400063fc: 80 a0 60 02 cmp %g1, 2 40006400: 08 bf ff fd bleu 400063f4 40006404: b0 10 20 04 mov 4, %i0 40006408: 81 c7 e0 08 ret <== NOT EXECUTED 4000640c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40006410: 40 00 10 86 call 4000a628 <_Thread_Dispatch> 40006414: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006418: 81 c7 e0 08 ret 4000641c: 81 e8 00 00 restore 40006458 : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 40006458: 9d e3 bf 90 save %sp, -112, %sp 4000645c: a0 10 00 18 mov %i0, %l0 Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 40006460: 80 a6 60 00 cmp %i1, 0 40006464: 02 80 00 1f be 400064e0 40006468: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 4000646c: 11 10 00 7c sethi %hi(0x4001f000), %o0 40006470: 92 10 00 10 mov %l0, %o1 40006474: 90 12 21 74 or %o0, 0x174, %o0 40006478: 40 00 0b 44 call 40009188 <_Objects_Get> 4000647c: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 40006480: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006484: 80 a0 60 00 cmp %g1, 0 40006488: 02 80 00 07 be 400064a4 4000648c: 92 10 00 10 mov %l0, %o1 40006490: 80 a0 60 02 cmp %g1, 2 40006494: 08 80 00 13 bleu 400064e0 40006498: b0 10 20 04 mov 4, %i0 4000649c: 81 c7 e0 08 ret <== NOT EXECUTED 400064a0: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL ); 400064a4: 94 10 20 00 clr %o2 400064a8: 40 00 07 27 call 40008144 <_CORE_barrier_Release> 400064ac: 90 02 20 14 add %o0, 0x14, %o0 400064b0: d0 26 40 00 st %o0, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400064b4: 03 10 00 7c sethi %hi(0x4001f000), %g1 400064b8: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 4001f310 <_Thread_Dispatch_disable_level> 400064bc: b0 10 20 00 clr %i0 400064c0: 84 00 bf ff add %g2, -1, %g2 400064c4: c4 20 63 10 st %g2, [ %g1 + 0x310 ] 400064c8: c6 00 63 10 ld [ %g1 + 0x310 ], %g3 400064cc: 80 a0 e0 00 cmp %g3, 0 400064d0: 12 80 00 04 bne 400064e0 400064d4: 01 00 00 00 nop _Thread_Dispatch(); 400064d8: 40 00 10 54 call 4000a628 <_Thread_Dispatch> 400064dc: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400064e0: 81 c7 e0 08 ret 400064e4: 81 e8 00 00 restore 400064e8 : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 400064e8: 9d e3 bf 90 save %sp, -112, %sp 400064ec: 11 10 00 7c sethi %hi(0x4001f000), %o0 400064f0: 92 10 00 18 mov %i0, %o1 400064f4: 90 12 21 74 or %o0, 0x174, %o0 400064f8: 40 00 0b 24 call 40009188 <_Objects_Get> 400064fc: 94 07 bf f4 add %fp, -12, %o2 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 40006500: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006504: 80 a0 60 00 cmp %g1, 0 40006508: 12 80 00 14 bne 40006558 4000650c: 96 10 00 19 mov %i1, %o3 case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Wait( 40006510: 90 02 20 14 add %o0, 0x14, %o0 40006514: 92 10 00 18 mov %i0, %o1 40006518: 94 10 20 01 mov 1, %o2 4000651c: 40 00 07 15 call 40008170 <_CORE_barrier_Wait> 40006520: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006524: 03 10 00 7c sethi %hi(0x4001f000), %g1 40006528: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 4001f310 <_Thread_Dispatch_disable_level> 4000652c: 84 00 bf ff add %g2, -1, %g2 40006530: c4 20 63 10 st %g2, [ %g1 + 0x310 ] 40006534: c6 00 63 10 ld [ %g1 + 0x310 ], %g3 40006538: 80 a0 e0 00 cmp %g3, 0 4000653c: 02 80 00 0d be 40006570 40006540: 03 10 00 7c sethi %hi(0x4001f000), %g1 TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 40006544: c4 00 63 ec ld [ %g1 + 0x3ec ], %g2 ! 4001f3ec <_Thread_Executing> <== NOT EXECUTED 40006548: 40 00 1f 95 call 4000e39c <_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 4000654c: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 <== NOT EXECUTED _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006550: 81 c7 e0 08 ret 40006554: 91 e8 00 08 restore %g0, %o0, %o0 { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 40006558: 80 a0 60 02 cmp %g1, 2 4000655c: 08 bf ff fd bleu 40006550 40006560: 90 10 20 04 mov 4, %o0 40006564: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006568: 81 c7 e0 08 ret <== NOT EXECUTED 4000656c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40006570: 40 00 10 2e call 4000a628 <_Thread_Dispatch> 40006574: 01 00 00 00 nop TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 40006578: 03 10 00 7c sethi %hi(0x4001f000), %g1 4000657c: c4 00 63 ec ld [ %g1 + 0x3ec ], %g2 ! 4001f3ec <_Thread_Executing> 40006580: 40 00 1f 87 call 4000e39c <_Barrier_Translate_core_barrier_return_code> 40006584: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 40006588: 30 bf ff f2 b,a 40006550 40005260 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 40005260: 9d e3 bf 60 save %sp, -160, %sp 40005264: 82 10 00 18 mov %i0, %g1 if ( !time_buffer ) 40005268: 80 a6 60 00 cmp %i1, 0 4000526c: 02 80 00 19 be 400052d0 40005270: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; switch ( option ) { 40005274: 80 a0 60 04 cmp %g1, 4 40005278: 18 80 00 16 bgu 400052d0 4000527c: b0 10 20 19 mov 0x19, %i0 40005280: 83 28 60 02 sll %g1, 2, %g1 40005284: 05 10 00 14 sethi %hi(0x40005000), %g2 40005288: 84 10 a2 4c or %g2, 0x24c, %g2 ! 4000524c 4000528c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40005290: 81 c0 c0 00 jmp %g3 40005294: 01 00 00 00 nop } case RTEMS_CLOCK_GET_TIME_VALUE: { struct timeval *time = (struct timeval *)time_buffer; if ( !_TOD_Is_set ) 40005298: 03 10 00 6a sethi %hi(0x4001a800), %g1 <== NOT EXECUTED 4000529c: c4 00 63 9c ld [ %g1 + 0x39c ], %g2 ! 4001ab9c <_TOD_Is_set> <== NOT EXECUTED 400052a0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400052a4: 12 80 00 46 bne 400053bc <== NOT EXECUTED 400052a8: 01 00 00 00 nop <== NOT EXECUTED } } return RTEMS_INTERNAL_ERROR; /* should never get here */ } 400052ac: 81 c7 e0 08 ret 400052b0: 91 e8 20 0b restore %g0, 0xb, %o0 } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick; 400052b4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400052b8: d2 00 61 3c ld [ %g1 + 0x13c ], %o1 ! 4001ad3c <_TOD_Microseconds_per_tick> 400052bc: 11 00 03 d0 sethi %hi(0xf4000), %o0 400052c0: b0 10 20 00 clr %i0 400052c4: 40 00 42 f3 call 40015e90 <.udiv> 400052c8: 90 12 22 40 or %o0, 0x240, %o0 400052cc: d0 26 40 00 st %o0, [ %i1 ] 400052d0: 81 c7 e0 08 ret 400052d4: 81 e8 00 00 restore } case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = _Watchdog_Ticks_since_boot; 400052d8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400052dc: c4 00 60 e4 ld [ %g1 + 0xe4 ], %g2 ! 4001ace4 <_Watchdog_Ticks_since_boot> 400052e0: c4 26 40 00 st %g2, [ %i1 ] 400052e4: 81 c7 e0 08 ret 400052e8: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: { rtems_interval *interval = (rtems_interval *)time_buffer; if ( !_TOD_Is_set ) 400052ec: 03 10 00 6a sethi %hi(0x4001a800), %g1 400052f0: c4 00 63 9c ld [ %g1 + 0x39c ], %g2 ! 4001ab9c <_TOD_Is_set> 400052f4: 80 a0 a0 00 cmp %g2, 0 400052f8: 02 bf ff ed be 400052ac 400052fc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 return RTEMS_NOT_DEFINED; *interval = _TOD_Seconds_since_epoch; 40005300: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 ! 4001ac18 <_TOD_Now> 40005304: c4 26 40 00 st %g2, [ %i1 ] 40005308: 81 c7 e0 08 ret 4000530c: 91 e8 20 00 restore %g0, 0, %o0 case RTEMS_CLOCK_GET_TOD: { struct tm time; struct timeval now; rtems_time_of_day *tmbuf = (rtems_time_of_day *)time_buffer; if ( !_TOD_Is_set ) 40005310: 03 10 00 6a sethi %hi(0x4001a800), %g1 40005314: c4 00 63 9c ld [ %g1 + 0x39c ], %g2 ! 4001ab9c <_TOD_Is_set> 40005318: 80 a0 a0 00 cmp %g2, 0 4000531c: 02 bf ff e4 be 400052ac 40005320: 01 00 00 00 nop ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 40005324: 7f ff f2 b4 call 40001df4 40005328: 01 00 00 00 nop 4000532c: a0 10 00 08 mov %o0, %l0 _TOD_Get( &now ); 40005330: 40 00 07 97 call 4000718c <_TOD_Get> 40005334: 90 07 bf e8 add %fp, -24, %o0 _ISR_Enable(level); 40005338: 7f ff f2 b3 call 40001e04 4000533c: 90 10 00 10 mov %l0, %o0 time->tv_sec = now.tv_sec; 40005340: c2 07 bf e8 ld [ %fp + -24 ], %g1 time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 40005344: d0 07 bf ec ld [ %fp + -20 ], %o0 _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 40005348: c2 27 bf f0 st %g1, [ %fp + -16 ] time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 4000534c: 40 00 42 d1 call 40015e90 <.udiv> 40005350: 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 ); 40005354: 92 07 bf c4 add %fp, -60, %o1 40005358: d0 27 bf f4 st %o0, [ %fp + -12 ] 4000535c: 40 00 28 74 call 4000f52c 40005360: 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; 40005364: 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; 40005368: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000536c: d2 00 61 3c ld [ %g1 + 0x13c ], %o1 ! 4001ad3c <_TOD_Microseconds_per_tick> 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; 40005370: c4 26 60 08 st %g2, [ %i1 + 8 ] tmbuf->hour = time.tm_hour; 40005374: c2 07 bf cc ld [ %fp + -52 ], %g1 tmbuf->minute = time.tm_min; 40005378: 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; 4000537c: c2 26 60 0c st %g1, [ %i1 + 0xc ] tmbuf->minute = time.tm_min; 40005380: c4 26 60 10 st %g2, [ %i1 + 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; 40005384: c2 07 bf d8 ld [ %fp + -40 ], %g1 tmbuf->month = time.tm_mon + 1; 40005388: 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; 4000538c: c6 07 bf c4 ld [ %fp + -60 ], %g3 tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 40005390: d0 07 bf f4 ld [ %fp + -12 ], %o0 /* 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; 40005394: 82 00 67 6c add %g1, 0x76c, %g1 tmbuf->month = time.tm_mon + 1; 40005398: 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; 4000539c: c6 26 60 14 st %g3, [ %i1 + 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; 400053a0: c2 26 40 00 st %g1, [ %i1 ] tmbuf->month = time.tm_mon + 1; 400053a4: c4 26 60 04 st %g2, [ %i1 + 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; 400053a8: 40 00 42 ba call 40015e90 <.udiv> 400053ac: b0 10 20 00 clr %i0 400053b0: d0 26 60 18 st %o0, [ %i1 + 0x18 ] 400053b4: 81 c7 e0 08 ret 400053b8: 81 e8 00 00 restore ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 400053bc: 7f ff f2 8e call 40001df4 <== NOT EXECUTED 400053c0: 01 00 00 00 nop <== NOT EXECUTED 400053c4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED _TOD_Get( &now ); 400053c8: 40 00 07 71 call 4000718c <_TOD_Get> <== NOT EXECUTED 400053cc: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED _ISR_Enable(level); 400053d0: 7f ff f2 8d call 40001e04 <== NOT EXECUTED 400053d4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED time->tv_sec = now.tv_sec; 400053d8: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 400053dc: d0 07 bf ec ld [ %fp + -20 ], %o0 <== NOT EXECUTED 400053e0: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 400053e4: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 400053e8: 40 00 42 aa call 40015e90 <.udiv> <== NOT EXECUTED 400053ec: b0 10 20 00 clr %i0 <== NOT EXECUTED 400053f0: d0 26 60 04 st %o0, [ %i1 + 4 ] <== NOT EXECUTED 400053f4: 81 c7 e0 08 ret <== NOT EXECUTED 400053f8: 81 e8 00 00 restore <== NOT EXECUTED 4000541c : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 4000541c: 9d e3 bf 98 save %sp, -104, %sp _TOD_Tickle_ticks(); 40005420: 40 00 07 83 call 4000722c <_TOD_Tickle_ticks> 40005424: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 40005428: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000542c: 40 00 15 41 call 4000a930 <_Watchdog_Tickle> 40005430: 90 12 20 5c or %o0, 0x5c, %o0 ! 4001ac5c <_Watchdog_Ticks_chain> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 40005434: 40 00 13 65 call 4000a1c8 <_Thread_Tickle_timeslice> 40005438: 01 00 00 00 nop * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_context_switch_necessary( void ) { return ( _Context_Switch_necessary ); 4000543c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40005440: c4 00 60 4c ld [ %g1 + 0x4c ], %g2 ! 4001ac4c <_Context_Switch_necessary> if ( _Thread_Is_context_switch_necessary() && 40005444: 80 a0 a0 00 cmp %g2, 0 40005448: 02 80 00 06 be 40005460 4000544c: 03 10 00 6a sethi %hi(0x4001a800), %g1 * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 40005450: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 4001ab60 <_Thread_Dispatch_disable_level> 40005454: 80 a0 a0 00 cmp %g2, 0 40005458: 02 80 00 04 be 40005468 4000545c: 01 00 00 00 nop _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 40005460: 81 c7 e0 08 ret 40005464: 91 e8 20 00 restore %g0, 0, %o0 _Thread_Tickle_timeslice(); if ( _Thread_Is_context_switch_necessary() && _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 40005468: 40 00 0f 6b call 40009214 <_Thread_Dispatch> <== NOT EXECUTED 4000546c: b0 10 20 00 clr %i0 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 40005470: 81 c7 e0 08 ret <== NOT EXECUTED 40005474: 81 e8 00 00 restore <== NOT EXECUTED 400056b0 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 400056b0: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 400056b4: 92 96 20 00 orcc %i0, 0, %o1 400056b8: 12 80 00 1c bne 40005728 400056bc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400056c0: 23 10 00 6a sethi %hi(0x4001a800), %l1 400056c4: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> 400056c8: 82 00 60 01 inc %g1 400056cc: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 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; 400056d0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400056d4: f0 00 60 3c ld [ %g1 + 0x3c ], %i0 ! 4001ac3c <_Thread_Executing> 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; 400056d8: c0 27 bf f4 clr [ %fp + -12 ] rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 400056dc: 7f ff f1 c6 call 40001df4 400056e0: e0 06 21 6c ld [ %i0 + 0x16c ], %l0 *the_event_set |= the_new_events; 400056e4: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 400056e8: 82 10 40 19 or %g1, %i1, %g1 400056ec: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _ISR_Enable( level ); 400056f0: 7f ff f1 c5 call 40001e04 400056f4: 01 00 00 00 nop case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; _Event_sets_Post( event_in, &api->pending_events ); _Event_Surrender( the_thread ); 400056f8: 40 00 00 2d call 400057ac <_Event_Surrender> 400056fc: 90 10 00 18 mov %i0, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005700: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40005704: b0 10 20 00 clr %i0 40005708: 82 00 7f ff add %g1, -1, %g1 4000570c: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40005710: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40005714: 80 a0 a0 00 cmp %g2, 0 40005718: 02 80 00 0a be 40005740 4000571c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40005720: 81 c7 e0 08 ret 40005724: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40005728: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 4000572c: 80 a0 a0 04 cmp %g2, 4 40005730: 08 80 00 08 bleu 40005750 40005734: 83 32 60 1b srl %o1, 0x1b, %g1 40005738: 81 c7 e0 08 ret <== NOT EXECUTED 4000573c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40005740: 40 00 0e b5 call 40009214 <_Thread_Dispatch> 40005744: 01 00 00 00 nop 40005748: 81 c7 e0 08 ret 4000574c: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40005750: 80 a0 60 01 cmp %g1, 1 40005754: 12 bf ff f3 bne 40005720 40005758: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4000575c: 83 28 a0 02 sll %g2, 2, %g1 40005760: 05 10 00 6a sethi %hi(0x4001a800), %g2 40005764: 84 10 a2 c0 or %g2, 0x2c0, %g2 ! 4001aac0 <_Objects_Information_table> 40005768: c6 00 80 01 ld [ %g2 + %g1 ], %g3 4000576c: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40005770: 80 a2 20 00 cmp %o0, 0 40005774: 02 bf ff f5 be 40005748 40005778: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4000577c: 40 00 09 7e call 40007d74 <_Objects_Get> 40005780: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40005784: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005788: b0 10 00 08 mov %o0, %i0 4000578c: 80 a0 60 00 cmp %g1, 0 40005790: 02 bf ff d3 be 400056dc 40005794: 23 10 00 6a sethi %hi(0x4001a800), %l1 40005798: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000579c: 18 bf ff e1 bgu 40005720 <== NOT EXECUTED 400057a0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 400057a4: 81 c7 e0 08 ret <== NOT EXECUTED 400057a8: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 4000daa4 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 4000daa4: 9d e3 bf 98 save %sp, -104, %sp Extension_Control *the_extension; if ( !rtems_is_name_valid( name ) ) 4000daa8: a6 96 20 00 orcc %i0, 0, %l3 4000daac: 02 80 00 16 be 4000db04 4000dab0: b0 10 20 03 mov 3, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000dab4: 23 10 00 b2 sethi %hi(0x4002c800), %l1 4000dab8: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 ! 4002c8a0 <_Thread_Dispatch_disable_level> 4000dabc: 82 00 60 01 inc %g1 4000dac0: c2 24 60 a0 st %g1, [ %l1 + 0xa0 ] * the inactive chain of free extension control blocks. */ RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void ) { return (Extension_Control *) _Objects_Allocate( &_Extension_Information ); 4000dac4: 25 10 00 b2 sethi %hi(0x4002c800), %l2 4000dac8: 40 00 03 ef call 4000ea84 <_Objects_Allocate> 4000dacc: 90 14 a3 3c or %l2, 0x33c, %o0 ! 4002cb3c <_Extension_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 4000dad0: a0 92 20 00 orcc %o0, 0, %l0 4000dad4: 12 80 00 0e bne 4000db0c 4000dad8: 90 04 20 10 add %l0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000dadc: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 <== NOT EXECUTED 4000dae0: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 4000dae4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000dae8: c2 24 60 a0 st %g1, [ %l1 + 0xa0 ] <== NOT EXECUTED 4000daec: c4 04 60 a0 ld [ %l1 + 0xa0 ], %g2 <== NOT EXECUTED 4000daf0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000daf4: 12 80 00 20 bne 4000db74 <== NOT EXECUTED 4000daf8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4000dafc: 40 00 0a 5b call 40010468 <_Thread_Dispatch> <== NOT EXECUTED 4000db00: 01 00 00 00 nop <== NOT EXECUTED 4000db04: 81 c7 e0 08 ret <== NOT EXECUTED 4000db08: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 4000db0c: 40 00 0e df call 40011688 <_User_extensions_Add_set> 4000db10: 92 10 00 19 mov %i1, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000db14: 90 14 a3 3c or %l2, 0x33c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000db18: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000db1c: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 4000db20: 03 00 00 3f sethi %hi(0xfc00), %g1 4000db24: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000db28: 82 08 c0 01 and %g3, %g1, %g1 4000db2c: 80 a0 40 02 cmp %g1, %g2 4000db30: 38 80 00 06 bgu,a 4000db48 4000db34: e6 24 20 0c st %l3, [ %l0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000db38: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000db3c: 83 28 60 02 sll %g1, 2, %g1 4000db40: e0 20 80 01 st %l0, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 4000db44: e6 24 20 0c st %l3, [ %l0 + 0xc ] &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 4000db48: c6 26 80 00 st %g3, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000db4c: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 4000db50: b0 10 20 00 clr %i0 4000db54: 82 00 7f ff add %g1, -1, %g1 4000db58: c2 24 60 a0 st %g1, [ %l1 + 0xa0 ] 4000db5c: c4 04 60 a0 ld [ %l1 + 0xa0 ], %g2 4000db60: 80 a0 a0 00 cmp %g2, 0 4000db64: 12 80 00 04 bne 4000db74 4000db68: 01 00 00 00 nop _Thread_Dispatch(); 4000db6c: 40 00 0a 3f call 40010468 <_Thread_Dispatch> 4000db70: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 4000db74: 81 c7 e0 08 ret 4000db78: 81 e8 00 00 restore 4000db7c : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 4000db7c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Get ( Objects_Id id, Objects_Locations *location ) { return (Extension_Control *) 4000db80: 21 10 00 b2 sethi %hi(0x4002c800), %l0 <== NOT EXECUTED 4000db84: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000db88: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 4000db8c: 40 00 05 0f call 4000efc8 <_Objects_Get> <== NOT EXECUTED 4000db90: 90 14 23 3c or %l0, 0x33c, %o0 <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 4000db94: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4000db98: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000db9c: 12 80 00 1e bne 4000dc14 <== NOT EXECUTED 4000dba0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never return this */ return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 4000dba4: 40 00 0e f3 call 40011770 <_User_extensions_Remove_set> <== NOT EXECUTED 4000dba8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000dbac: 90 14 23 3c or %l0, 0x33c, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000dbb0: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000dbb4: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 <== NOT EXECUTED 4000dbb8: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED 4000dbbc: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <== NOT EXECUTED 4000dbc0: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 4000dbc4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4000dbc8: 38 80 00 06 bgu,a 4000dbe0 <== NOT EXECUTED 4000dbcc: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000dbd0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 <== NOT EXECUTED 4000dbd4: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4000dbd8: c0 20 80 01 clr [ %g2 + %g1 ] <== NOT EXECUTED uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 4000dbdc: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Extension_Free ( Extension_Control *the_extension ) { _Objects_Free( &_Extension_Information, &the_extension->Object ); 4000dbe0: 40 00 04 b7 call 4000eebc <_Objects_Free> <== NOT EXECUTED 4000dbe4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000dbe8: 03 10 00 b2 sethi %hi(0x4002c800), %g1 <== NOT EXECUTED 4000dbec: c4 00 60 a0 ld [ %g1 + 0xa0 ], %g2 ! 4002c8a0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000dbf0: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000dbf4: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 4000dbf8: c4 20 60 a0 st %g2, [ %g1 + 0xa0 ] <== NOT EXECUTED 4000dbfc: c6 00 60 a0 ld [ %g1 + 0xa0 ], %g3 <== NOT EXECUTED 4000dc00: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000dc04: 02 80 00 09 be 4000dc28 <== NOT EXECUTED 4000dc08: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000dc0c: 81 c7 e0 08 ret <== NOT EXECUTED 4000dc10: 81 e8 00 00 restore <== NOT EXECUTED { Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 4000dc14: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000dc18: 08 bf ff fd bleu 4000dc0c <== NOT EXECUTED 4000dc1c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 4000dc20: 81 c7 e0 08 ret <== NOT EXECUTED 4000dc24: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000dc28: 40 00 0a 10 call 40010468 <_Thread_Dispatch> <== NOT EXECUTED 4000dc2c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000dc30: 81 c7 e0 08 ret <== NOT EXECUTED 4000dc34: 81 e8 00 00 restore <== NOT EXECUTED 40006a34 : #include const char *rtems_get_version_string(void) { return _RTEMS_version; } 40006a34: 11 10 00 66 sethi %hi(0x40019800), %o0 <== NOT EXECUTED 40006a38: 81 c3 e0 08 retl <== NOT EXECUTED 40006a3c: 90 12 20 98 or %o0, 0x98, %o0 ! 40019898 <_RTEMS_version> <== NOT EXECUTED 400067d8 : rtems_interrupt_level rtems_initialize_executive_early( rtems_configuration_table *configuration_table, rtems_cpu_table *cpu_table ) { 400067d8: 9d e3 bf 80 save %sp, -128, %sp * Dispatching and interrupts are disabled until the end of the * initialization sequence. This prevents an inadvertent context * switch before the executive is initialized. */ _ISR_Disable( bsp_level ); 400067dc: 7f ff ed 86 call 40001df4 400067e0: 01 00 00 00 nop 400067e4: a6 10 00 08 mov %o0, %l3 if ( configuration_table == NULL ) 400067e8: 80 a6 20 00 cmp %i0, 0 400067ec: 22 80 00 79 be,a 400069d0 400067f0: 90 10 20 00 clr %o0 <== NOT EXECUTED /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 400067f4: 05 10 00 6a sethi %hi(0x4001a800), %g2 RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; _System_state_Is_multiprocessing = is_multiprocessing; 400067f8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400067fc: a4 10 a3 74 or %g2, 0x374, %l2 40006800: 94 10 20 28 mov 0x28, %o2 40006804: 92 10 00 19 mov %i1, %o1 40006808: c0 20 60 68 clr [ %g1 + 0x68 ] RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; 4000680c: 29 10 00 6b sethi %hi(0x4001ac00), %l4 40006810: 90 10 00 12 mov %l2, %o0 40006814: 40 00 23 4b call 4000f540 40006818: c0 25 21 40 clr [ %l4 + 0x140 ] /* * Provided just for user convenience. */ _Configuration_Table = configuration_table; 4000681c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_NO_CPU_TABLE ); _CPU_Initialize( cpu_table, _Thread_Dispatch ); 40006820: 90 10 00 19 mov %i1, %o0 40006824: 13 10 00 24 sethi %hi(0x40009000), %o1 40006828: 92 12 62 14 or %o1, 0x214, %o1 ! 40009214 <_Thread_Dispatch> 4000682c: 40 00 11 a6 call 4000aec4 <_CPU_Initialize> 40006830: f0 20 60 20 st %i0, [ %g1 + 0x20 ] /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 40006834: 40 00 1a b8 call 4000d314 <_Debug_Manager_initialization> 40006838: a2 10 20 01 mov 1, %l1 _API_extensions_Initialization(); 4000683c: 40 00 01 03 call 40006c48 <_API_extensions_Initialization> 40006840: 01 00 00 00 nop _Thread_Dispatch_initialization(); _Workspace_Handler_initialization( 40006844: d2 06 20 04 ld [ %i0 + 4 ], %o1 40006848: d0 06 00 00 ld [ %i0 ], %o0 * This routine initializes the thread dispatching subsystem. */ RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void ) { _Thread_Dispatch_disable_level = 1; 4000684c: 03 10 00 6a sethi %hi(0x4001a800), %g1 40006850: e2 20 63 60 st %l1, [ %g1 + 0x360 ] ! 4001ab60 <_Thread_Dispatch_disable_level> 40006854: 40 00 10 6e call 4000aa0c <_Workspace_Handler_initialization> 40006858: 21 10 00 6b sethi %hi(0x4001ac00), %l0 (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 4000685c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 40006860: 40 00 0e df call 4000a3dc <_User_extensions_Handler_initialization> 40006864: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 40006868: 40 00 03 d5 call 400077bc <_ISR_Handler_initialization> 4000686c: 01 00 00 00 nop _Objects_Handler_initialization( 40006870: 90 10 20 01 mov 1, %o0 ! 1 40006874: 92 10 20 01 mov 1, %o1 40006878: 40 00 05 d8 call 40007fd8 <_Objects_Handler_initialization> 4000687c: 94 10 20 00 clr %o2 multiprocessing_table->node, multiprocessing_table->maximum_nodes, multiprocessing_table->maximum_global_objects ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 40006880: 05 10 00 6a sethi %hi(0x4001a800), %g2 /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 40006884: c0 23 a0 5c clr [ %sp + 0x5c ] multiprocessing_table->node, multiprocessing_table->maximum_nodes, multiprocessing_table->maximum_global_objects ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 40006888: 03 10 00 6a sethi %hi(0x4001a800), %g1 4000688c: 82 10 63 a0 or %g1, 0x3a0, %g1 ! 4001aba0 <_Internal_Objects> /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 40006890: 92 10 20 01 mov 1, %o1 multiprocessing_table->node, multiprocessing_table->maximum_nodes, multiprocessing_table->maximum_global_objects ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 40006894: c2 20 a2 c4 st %g1, [ %g2 + 0x2c4 ] /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 40006898: 94 10 20 02 mov 2, %o2 4000689c: 96 10 20 01 mov 1, %o3 400068a0: 98 10 20 74 mov 0x74, %o4 400068a4: 9a 10 20 00 clr %o5 400068a8: 40 00 05 5a call 40007e10 <_Objects_Initialize_information> 400068ac: 90 14 20 6c or %l0, 0x6c, %o0 _API_Mutex_Allocate( _RTEMS_Allocator_Mutex ); 400068b0: 82 10 20 02 mov 2, %g1 400068b4: e2 27 bf e8 st %l1, [ %fp + -24 ] 400068b8: c2 27 bf f0 st %g1, [ %fp + -16 ] 400068bc: c0 27 bf ec clr [ %fp + -20 ] 400068c0: c0 27 bf f4 clr [ %fp + -12 ] 400068c4: 40 00 03 db call 40007830 <_Objects_Allocate> 400068c8: 90 14 20 6c or %l0, 0x6c, %o0 400068cc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400068d0: 84 10 00 08 mov %o0, %g2 400068d4: 92 07 bf e8 add %fp, -24, %o1 400068d8: c4 20 60 34 st %g2, [ %g1 + 0x34 ] 400068dc: 90 02 20 10 add %o0, 0x10, %o0 400068e0: 40 00 01 47 call 40006dfc <_CORE_mutex_Initialize> 400068e4: 94 10 20 01 mov 1, %o2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 400068e8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 400068ec: 05 10 00 6b sethi %hi(0x4001ac00), %g2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 400068f0: c0 30 60 30 clrh [ %g1 + 0x30 ] for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 400068f4: c0 30 a0 c0 clrh [ %g2 + 0xc0 ] 400068f8: 82 10 20 02 mov 2, %g1 400068fc: 84 10 a0 c0 or %g2, 0xc0, %g2 40006900: c0 30 40 02 clrh [ %g1 + %g2 ] 40006904: 82 00 60 02 add %g1, 2, %g1 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; for ( index=0 ; index <16 ; index++ ) 40006908: 80 a0 60 20 cmp %g1, 0x20 4000690c: 32 bf ff fe bne,a 40006904 40006910: c0 30 40 02 clrh [ %g1 + %g2 ] _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 40006914: 40 00 0f be call 4000a80c <_Watchdog_Handler_initialization> 40006918: 01 00 00 00 nop _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 4000691c: 40 00 02 35 call 400071f0 <_TOD_Handler_initialization> 40006920: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _Thread_Handler_initialization( 40006924: d2 06 20 08 ld [ %i0 + 8 ], %o1 40006928: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 4000692c: 40 00 0b 01 call 40009530 <_Thread_Handler_initialization> 40006930: 94 10 20 00 clr %o2 ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 40006934: 40 00 00 a6 call 40006bcc <_RTEMS_API_Initialize> 40006938: 90 10 00 18 mov %i0, %o0 _Extension_Manager_initialization( configuration_table->maximum_extensions ); 4000693c: 40 00 00 2a call 400069e4 <_Extension_Manager_initialization> 40006940: d0 06 20 08 ld [ %i0 + 8 ], %o0 _IO_Manager_initialization( 40006944: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40006948: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 4000694c: 40 00 00 4e call 40006a84 <_IO_Manager_initialization> 40006950: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 configuration_table->number_of_device_drivers, configuration_table->maximum_drivers ); #ifdef RTEMS_POSIX_API _POSIX_API_Initialize( configuration_table ); 40006954: 40 00 00 7a call 40006b3c <_POSIX_API_Initialize> 40006958: 90 10 00 18 mov %i0, %o0 RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 4000695c: 82 10 20 01 mov 1, %g1 * * At this point all API extensions are in place. After the call to * _Thread_Create_idle() _Thread_Executing and _Thread_Heir will be set. */ _Thread_Create_idle(); 40006960: 40 00 09 d9 call 400090c4 <_Thread_Create_idle> 40006964: c2 25 21 40 st %g1, [ %l4 + 0x140 ] /* * Scheduling can properly occur now as long as we avoid dispatching. */ if ( cpu_table->pretasking_hook ) 40006968: d0 06 40 00 ld [ %i1 ], %o0 4000696c: 80 a2 20 00 cmp %o0, 0 40006970: 02 80 00 04 be 40006980 40006974: 01 00 00 00 nop (*cpu_table->pretasking_hook)(); 40006978: 9f c2 00 00 call %o0 4000697c: 01 00 00 00 nop /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 40006980: 40 00 00 d4 call 40006cd0 <_API_extensions_Run_predriver> 40006984: 01 00 00 00 nop if ( _CPU_Table.predriver_hook ) 40006988: c2 04 a0 04 ld [ %l2 + 4 ], %g1 4000698c: 80 a0 60 00 cmp %g1, 0 40006990: 02 80 00 04 be 400069a0 40006994: 01 00 00 00 nop (*_CPU_Table.predriver_hook)(); 40006998: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000699c: 01 00 00 00 nop <== NOT EXECUTED * Initialize all the device drivers and initialize the MPCI layer. * * NOTE: The MPCI may be build upon a device driver. */ _IO_Initialize_all_drivers(); 400069a0: 40 00 00 28 call 40006a40 <_IO_Initialize_all_drivers> 400069a4: 01 00 00 00 nop * Run the APIs and BSPs postdriver hooks. * * The API extensions are supposed to create user initialization tasks. */ _API_extensions_Run_postdriver(); 400069a8: 40 00 00 af call 40006c64 <_API_extensions_Run_postdriver> 400069ac: 01 00 00 00 nop if ( _CPU_Table.postdriver_hook ) 400069b0: c4 04 a0 08 ld [ %l2 + 8 ], %g2 400069b4: 80 a0 a0 00 cmp %g2, 0 400069b8: 02 80 00 04 be 400069c8 400069bc: 01 00 00 00 nop (*_CPU_Table.postdriver_hook)(); 400069c0: 9f c0 80 00 call %g2 400069c4: 01 00 00 00 nop return bsp_level; } 400069c8: 81 c7 e0 08 ret 400069cc: 91 e8 00 13 restore %g0, %l3, %o0 */ _ISR_Disable( bsp_level ); if ( configuration_table == NULL ) _Internal_error_Occurred( 400069d0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400069d4: 40 00 03 6a call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 400069d8: 94 10 20 00 clr %o2 <== NOT EXECUTED /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 400069dc: 10 bf ff 87 b 400067f8 <== NOT EXECUTED 400069e0: 05 10 00 6a sethi %hi(0x4001a800), %g2 <== NOT EXECUTED 40007b48 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 40007b48: 9d e3 bf 98 save %sp, -104, %sp /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 40007b4c: 80 a6 60 00 cmp %i1, 0 40007b50: 02 80 00 3e be 40007c48 40007b54: 90 10 00 18 mov %i0, %o0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 40007b58: 80 a6 a0 00 cmp %i2, 0 40007b5c: 02 80 00 3b be 40007c48 40007b60: 01 00 00 00 nop return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 40007b64: c2 06 40 00 ld [ %i1 ], %g1 40007b68: 80 a0 60 00 cmp %g1, 0 40007b6c: 22 80 00 34 be,a 40007c3c 40007b70: c2 06 60 04 ld [ %i1 + 4 ], %g1 return RTEMS_INVALID_ADDRESS; *registered_major = 0; 40007b74: c0 26 80 00 clr [ %i2 ] /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 40007b78: 03 10 00 7c sethi %hi(0x4001f000), %g1 40007b7c: c6 00 61 6c ld [ %g1 + 0x16c ], %g3 ! 4001f16c <_IO_Number_of_drivers> 40007b80: 80 a0 c0 08 cmp %g3, %o0 40007b84: 08 80 00 43 bleu 40007c90 40007b88: b0 10 20 0a mov 0xa, %i0 /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 40007b8c: 80 a2 20 00 cmp %o0, 0 40007b90: 12 80 00 1f bne 40007c0c 40007b94: 03 10 00 7c sethi %hi(0x4001f000), %g1 boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 40007b98: 90 80 ff ff addcc %g3, -1, %o0 40007b9c: 02 80 00 26 be 40007c34 40007ba0: c8 00 61 70 ld [ %g1 + 0x170 ], %g4 if ( !_IO_Driver_address_table[major].initialization_entry && 40007ba4: 85 28 e0 05 sll %g3, 5, %g2 40007ba8: 83 28 e0 03 sll %g3, 3, %g1 40007bac: 84 20 80 01 sub %g2, %g1, %g2 40007bb0: 84 00 bf e8 add %g2, -24, %g2 40007bb4: 10 80 00 04 b 40007bc4 40007bb8: 84 00 80 04 add %g2, %g4, %g2 * in use. */ if ( major == 0 ) { boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 40007bbc: 02 80 00 1e be 40007c34 40007bc0: 84 00 bf e8 add %g2, -24, %g2 if ( !_IO_Driver_address_table[major].initialization_entry && 40007bc4: c2 00 80 00 ld [ %g2 ], %g1 40007bc8: 80 a0 60 00 cmp %g1, 0 40007bcc: 32 bf ff fc bne,a 40007bbc 40007bd0: 90 82 3f ff addcc %o0, -1, %o0 40007bd4: c2 00 a0 04 ld [ %g2 + 4 ], %g1 40007bd8: 80 a0 60 00 cmp %g1, 0 40007bdc: 32 bf ff f8 bne,a 40007bbc 40007be0: 90 82 3f ff addcc %o0, -1, %o0 <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 40007be4: 85 2a 20 03 sll %o0, 3, %g2 40007be8: 83 2a 20 05 sll %o0, 5, %g1 40007bec: 82 20 40 02 sub %g1, %g2, %g1 40007bf0: 88 01 00 01 add %g4, %g1, %g4 40007bf4: c2 01 20 04 ld [ %g4 + 4 ], %g1 40007bf8: 80 a0 60 00 cmp %g1, 0 40007bfc: 22 80 00 15 be,a 40007c50 40007c00: c2 06 40 00 ld [ %i1 ], %g1 _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 40007c04: 81 c7 e0 08 ret <== NOT EXECUTED 40007c08: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 40007c0c: c8 00 61 70 ld [ %g1 + 0x170 ], %g4 40007c10: 85 2a 20 03 sll %o0, 3, %g2 40007c14: 83 2a 20 05 sll %o0, 5, %g1 40007c18: 82 20 40 02 sub %g1, %g2, %g1 40007c1c: c6 00 40 04 ld [ %g1 + %g4 ], %g3 40007c20: 80 a0 e0 00 cmp %g3, 0 40007c24: 02 bf ff f4 be 40007bf4 40007c28: 88 00 40 04 add %g1, %g4, %g4 _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 40007c2c: 81 c7 e0 08 ret 40007c30: 91 e8 20 0c restore %g0, 0xc, %o0 40007c34: 81 c7 e0 08 ret 40007c38: 91 e8 20 05 restore %g0, 5, %o0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 40007c3c: 80 a0 60 00 cmp %g1, 0 40007c40: 32 bf ff ce bne,a 40007b78 40007c44: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 40007c48: 81 c7 e0 08 ret 40007c4c: 91 e8 20 09 restore %g0, 9, %o0 _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; *registered_major = major; 40007c50: d0 26 80 00 st %o0, [ %i2 ] 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; 40007c54: c2 21 00 00 st %g1, [ %g4 ] 40007c58: c4 06 60 04 ld [ %i1 + 4 ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40007c5c: 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; 40007c60: c4 21 20 04 st %g2, [ %g4 + 4 ] 40007c64: c2 06 60 08 ld [ %i1 + 8 ], %g1 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40007c68: 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; 40007c6c: c2 21 20 08 st %g1, [ %g4 + 8 ] 40007c70: c4 06 60 0c ld [ %i1 + 0xc ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40007c74: b0 10 20 00 clr %i0 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; 40007c78: c4 21 20 0c st %g2, [ %g4 + 0xc ] 40007c7c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 40007c80: c2 21 20 10 st %g1, [ %g4 + 0x10 ] 40007c84: c4 06 60 14 ld [ %i1 + 0x14 ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40007c88: 7f ff ff 30 call 40007948 40007c8c: c4 21 20 14 st %g2, [ %g4 + 0x14 ] 40007c90: 81 c7 e0 08 ret 40007c94: 81 e8 00 00 restore 40009230 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 40009230: 9d e3 bf 98 save %sp, -104, %sp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 40009234: 80 a6 20 00 cmp %i0, 0 40009238: 02 80 00 23 be 400092c4 4000923c: 03 10 00 9d sethi %hi(0x40027400), %g1 return; 40009240: a4 10 63 f4 or %g1, 0x3f4, %l2 ! 400277f4 <_Objects_Information_table+0x4> 40009244: 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 ] ) 40009248: c2 04 80 00 ld [ %l2 ], %g1 4000924c: 80 a0 60 00 cmp %g1, 0 40009250: 22 80 00 1a be,a 400092b8 40009254: a4 04 a0 04 add %l2, 4, %l2 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 40009258: e2 00 60 04 ld [ %g1 + 4 ], %l1 if ( information ) { 4000925c: 80 a4 60 00 cmp %l1, 0 40009260: 22 80 00 16 be,a 400092b8 40009264: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 40009268: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 4000926c: 86 90 60 00 orcc %g1, 0, %g3 40009270: 22 80 00 12 be,a 400092b8 40009274: a4 04 a0 04 add %l2, 4, %l2 40009278: a0 10 20 01 mov 1, %l0 the_thread = (Thread_Control *)information->local_table[ i ]; 4000927c: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 40009280: 83 2c 20 02 sll %l0, 2, %g1 40009284: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( !the_thread ) 40009288: 80 a2 20 00 cmp %o0, 0 4000928c: 02 80 00 05 be 400092a0 40009290: a0 04 20 01 inc %l0 continue; (*routine)(the_thread); 40009294: 9f c6 00 00 call %i0 40009298: 01 00 00 00 nop 4000929c: 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++ ) { 400092a0: 83 28 e0 10 sll %g3, 0x10, %g1 400092a4: 83 30 60 10 srl %g1, 0x10, %g1 400092a8: 80 a0 40 10 cmp %g1, %l0 400092ac: 3a bf ff f5 bcc,a 40009280 400092b0: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 400092b4: a4 04 a0 04 add %l2, 4, %l2 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 400092b8: 80 a4 80 13 cmp %l2, %l3 400092bc: 32 bf ff e4 bne,a 4000924c 400092c0: c2 04 80 00 ld [ %l2 ], %g1 400092c4: 81 c7 e0 08 ret 400092c8: 81 e8 00 00 restore 4000ef8c : Objects_Id id, void *buffer, size_t size, uint32_t *count ) { 4000ef8c: 9d e3 bf 90 save %sp, -112, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status core_status; if ( !buffer ) 4000ef90: 80 a6 60 00 cmp %i1, 0 4000ef94: 02 80 00 28 be 4000f034 4000ef98: 80 a6 e0 00 cmp %i3, 0 return RTEMS_INVALID_ADDRESS; if ( !count ) 4000ef9c: 02 80 00 26 be 4000f034 4000efa0: 92 10 00 18 mov %i0, %o1 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 4000efa4: 11 10 00 d5 sethi %hi(0x40035400), %o0 4000efa8: 90 12 22 70 or %o0, 0x270, %o0 ! 40035670 <_Message_queue_Information> 4000efac: 40 00 19 84 call 400155bc <_Objects_Get> 4000efb0: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 4000efb4: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000efb8: 80 a0 60 00 cmp %g1, 0 4000efbc: 02 80 00 08 be 4000efdc 4000efc0: 9a 10 00 1b mov %i3, %o5 4000efc4: 80 a0 60 02 cmp %g1, 2 4000efc8: 08 80 00 03 bleu 4000efd4 4000efcc: 90 10 20 04 mov 4, %o0 4000efd0: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code( core_status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000efd4: 81 c7 e0 08 ret 4000efd8: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 4000efdc: 92 10 00 19 mov %i1, %o1 4000efe0: 94 10 00 1a mov %i2, %o2 4000efe4: 96 10 00 18 mov %i0, %o3 4000efe8: 98 10 20 00 clr %o4 4000efec: 40 00 13 f8 call 40013fcc <_CORE_message_queue_Broadcast> 4000eff0: 90 02 20 14 add %o0, 0x14, %o0 4000eff4: b6 10 00 08 mov %o0, %i3 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000eff8: 03 10 00 d3 sethi %hi(0x40034c00), %g1 4000effc: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 4000f000: 84 00 bf ff add %g2, -1, %g2 4000f004: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 4000f008: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 4000f00c: 80 a0 e0 00 cmp %g3, 0 4000f010: 02 80 00 06 be 4000f028 4000f014: 01 00 00 00 nop #endif count ); _Thread_Enable_dispatch(); return 4000f018: 40 00 01 35 call 4000f4ec <_Message_queue_Translate_core_message_queue_return_code> 4000f01c: 90 10 00 1b mov %i3, %o0 _Message_queue_Translate_core_message_queue_return_code( core_status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f020: 81 c7 e0 08 ret 4000f024: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 4000f028: 40 00 1e 8d call 40016a5c <_Thread_Dispatch> 4000f02c: 01 00 00 00 nop 4000f030: 30 bf ff fa b,a 4000f018 #endif count ); _Thread_Enable_dispatch(); return 4000f034: 10 bf ff e8 b 4000efd4 <== NOT EXECUTED 4000f038: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED 4000f03c : uint32_t count, uint32_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 4000f03c: 9d e3 bf 90 save %sp, -112, %sp CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) boolean is_global; #endif if ( !rtems_is_name_valid( name ) ) 4000f040: a4 96 20 00 orcc %i0, 0, %l2 4000f044: 02 80 00 1f be 4000f0c0 4000f048: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 4000f04c: 80 a7 20 00 cmp %i4, 0 4000f050: 02 80 00 1c be 4000f0c0 4000f054: 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 ) 4000f058: 80 a6 60 00 cmp %i1, 0 4000f05c: 02 80 00 19 be 4000f0c0 4000f060: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 4000f064: 80 a6 a0 00 cmp %i2, 0 4000f068: 02 80 00 16 be 4000f0c0 4000f06c: b0 10 20 08 mov 8, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000f070: 23 10 00 d3 sethi %hi(0x40034c00), %l1 4000f074: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 4000f078: 82 00 60 01 inc %g1 4000f07c: c2 24 60 80 st %g1, [ %l1 + 0x80 ] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate( count, max_message_size ); 4000f080: 90 10 00 19 mov %i1, %o0 4000f084: 40 00 2f 2a call 4001ad2c <_Message_queue_Allocate> 4000f088: 92 10 00 1a mov %i2, %o1 if ( !the_message_queue ) { 4000f08c: a0 92 20 00 orcc %o0, 0, %l0 4000f090: 12 80 00 0e bne 4000f0c8 4000f094: 80 8e e0 04 btst 4, %i3 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f098: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 4000f09c: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 4000f0a0: 82 00 7f ff add %g1, -1, %g1 4000f0a4: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 4000f0a8: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 4000f0ac: 80 a0 a0 00 cmp %g2, 0 4000f0b0: 12 80 00 33 bne 4000f17c 4000f0b4: 01 00 00 00 nop 4000f0b8: 40 00 1e 69 call 40016a5c <_Thread_Dispatch> 4000f0bc: 01 00 00 00 nop 4000f0c0: 81 c7 e0 08 ret 4000f0c4: 81 e8 00 00 restore } #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) 4000f0c8: 12 80 00 11 bne 4000f10c 4000f0cc: f6 24 20 10 st %i3, [ %l0 + 0x10 ] the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 4000f0d0: c0 27 bf f4 clr [ %fp + -12 ] if ( ! _CORE_message_queue_Initialize( 4000f0d4: 94 10 00 19 mov %i1, %o2 4000f0d8: 96 10 00 1a mov %i2, %o3 4000f0dc: 90 04 20 14 add %l0, 0x14, %o0 4000f0e0: 40 00 14 08 call 40014100 <_CORE_message_queue_Initialize> 4000f0e4: 92 07 bf f4 add %fp, -12, %o1 4000f0e8: 80 a2 20 00 cmp %o0, 0 4000f0ec: 12 80 00 0b bne 4000f118 4000f0f0: 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 ); 4000f0f4: 11 10 00 d5 sethi %hi(0x40035400), %o0 <== NOT EXECUTED 4000f0f8: 40 00 18 da call 40015460 <_Objects_Free> <== NOT EXECUTED 4000f0fc: 90 12 22 70 or %o0, 0x270, %o0 ! 40035670 <_Message_queue_Information> <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f100: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 4000f104: 10 bf ff e7 b 4000f0a0 <== NOT EXECUTED 4000f108: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 4000f10c: 82 10 20 01 mov 1, %g1 4000f110: 10 bf ff f1 b 4000f0d4 4000f114: c2 27 bf f4 st %g1, [ %fp + -12 ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f118: 03 10 00 d5 sethi %hi(0x40035400), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000f11c: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f120: 88 10 62 70 or %g1, 0x270, %g4 4000f124: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 4000f128: 03 00 00 3f sethi %hi(0xfc00), %g1 4000f12c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000f130: 82 08 c0 01 and %g3, %g1, %g1 4000f134: 80 a0 40 02 cmp %g1, %g2 4000f138: 38 80 00 06 bgu,a 4000f150 4000f13c: e4 24 20 0c st %l2, [ %l0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000f140: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 4000f144: 83 28 60 02 sll %g1, 2, %g1 4000f148: e0 20 80 01 st %l0, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 4000f14c: e4 24 20 0c st %l2, [ %l0 + 0xc ] &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 4000f150: c6 27 00 00 st %g3, [ %i4 ] 4000f154: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 4000f158: b0 10 20 00 clr %i0 4000f15c: 82 00 7f ff add %g1, -1, %g1 4000f160: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 4000f164: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 4000f168: 80 a0 a0 00 cmp %g2, 0 4000f16c: 12 80 00 04 bne 4000f17c 4000f170: 01 00 00 00 nop _Thread_Dispatch(); 4000f174: 40 00 1e 3a call 40016a5c <_Thread_Dispatch> 4000f178: 01 00 00 00 nop ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 4000f17c: 81 c7 e0 08 ret 4000f180: 81 e8 00 00 restore 400162b8 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 400162b8: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 400162bc: 21 10 00 b4 sethi %hi(0x4002d000), %l0 400162c0: 92 10 00 18 mov %i0, %o1 400162c4: 94 07 bf f4 add %fp, -12, %o2 400162c8: 7f ff e3 40 call 4000efc8 <_Objects_Get> 400162cc: 90 14 23 0c or %l0, 0x30c, %o0 register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 400162d0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400162d4: 80 a0 60 00 cmp %g1, 0 400162d8: 12 80 00 20 bne 40016358 400162dc: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400162e0: a0 14 23 0c or %l0, 0x30c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 400162e4: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400162e8: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 400162ec: 05 00 00 3f sethi %hi(0xfc00), %g2 400162f0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 400162f4: 82 08 40 02 and %g1, %g2, %g1 400162f8: 80 a0 40 03 cmp %g1, %g3 400162fc: 18 80 00 05 bgu 40016310 40016300: 94 10 20 05 mov 5, %o2 information->local_table[ index ] = the_object; 40016304: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 40016308: 83 28 60 02 sll %g1, 2, %g1 4001630c: c0 20 80 01 clr [ %g2 + %g1 ] case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, &the_message_queue->Object ); _CORE_message_queue_Close( 40016310: 90 06 20 14 add %i0, 0x14, %o0 uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 40016314: c0 26 20 0c clr [ %i0 + 0xc ] 40016318: 40 00 01 c0 call 40016a18 <_CORE_message_queue_Close> 4001631c: 92 10 20 00 clr %o1 RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 40016320: 90 10 00 10 mov %l0, %o0 40016324: 7f ff e2 e6 call 4000eebc <_Objects_Free> 40016328: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001632c: 03 10 00 b2 sethi %hi(0x4002c800), %g1 40016330: c4 00 60 a0 ld [ %g1 + 0xa0 ], %g2 ! 4002c8a0 <_Thread_Dispatch_disable_level> 40016334: b0 10 20 00 clr %i0 40016338: 84 00 bf ff add %g2, -1, %g2 4001633c: c4 20 60 a0 st %g2, [ %g1 + 0xa0 ] 40016340: c6 00 60 a0 ld [ %g1 + 0xa0 ], %g3 40016344: 80 a0 e0 00 cmp %g3, 0 40016348: 02 80 00 09 be 4001636c 4001634c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40016350: 81 c7 e0 08 ret 40016354: 81 e8 00 00 restore { register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 40016358: 80 a0 60 02 cmp %g1, 2 4001635c: 08 bf ff fd bleu 40016350 40016360: b0 10 20 04 mov 4, %i0 40016364: 81 c7 e0 08 ret <== NOT EXECUTED 40016368: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4001636c: 7f ff e8 3f call 40010468 <_Thread_Dispatch> 40016370: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40016374: 81 c7 e0 08 ret 40016378: 81 e8 00 00 restore 4000f248 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 4000f248: 9d e3 bf 90 save %sp, -112, %sp 4000f24c: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 4000f250: 80 a6 60 00 cmp %i1, 0 4000f254: 02 80 00 1c be 4000f2c4 4000f258: 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 *) 4000f25c: 11 10 00 d5 sethi %hi(0x40035400), %o0 4000f260: 94 07 bf f4 add %fp, -12, %o2 4000f264: 40 00 18 d6 call 400155bc <_Objects_Get> 4000f268: 90 12 22 70 or %o0, 0x270, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 4000f26c: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f270: 80 a0 60 00 cmp %g1, 0 4000f274: 02 80 00 06 be 4000f28c 4000f278: 80 a0 60 02 cmp %g1, 2 4000f27c: 08 80 00 12 bleu 4000f2c4 4000f280: b0 10 20 04 mov 4, %i0 4000f284: 81 c7 e0 08 ret <== NOT EXECUTED 4000f288: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: *count = _CORE_message_queue_Flush( &the_message_queue->message_queue ); 4000f28c: 40 00 13 7d call 40014080 <_CORE_message_queue_Flush> 4000f290: 90 02 20 14 add %o0, 0x14, %o0 4000f294: d0 26 40 00 st %o0, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f298: 03 10 00 d3 sethi %hi(0x40034c00), %g1 4000f29c: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 4000f2a0: b0 10 20 00 clr %i0 4000f2a4: 84 00 bf ff add %g2, -1, %g2 4000f2a8: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 4000f2ac: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 4000f2b0: 80 a0 e0 00 cmp %g3, 0 4000f2b4: 12 80 00 04 bne 4000f2c4 4000f2b8: 01 00 00 00 nop _Thread_Dispatch(); 4000f2bc: 40 00 1d e8 call 40016a5c <_Thread_Dispatch> 4000f2c0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f2c4: 81 c7 e0 08 ret 4000f2c8: 81 e8 00 00 restore 4000f2cc : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 4000f2cc: 9d e3 bf 90 save %sp, -112, %sp 4000f2d0: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 4000f2d4: 80 a6 60 00 cmp %i1, 0 4000f2d8: 02 80 00 1b be 4000f344 4000f2dc: b0 10 20 09 mov 9, %i0 4000f2e0: 11 10 00 d5 sethi %hi(0x40035400), %o0 4000f2e4: 94 07 bf f4 add %fp, -12, %o2 4000f2e8: 40 00 18 b5 call 400155bc <_Objects_Get> 4000f2ec: 90 12 22 70 or %o0, 0x270, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 4000f2f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f2f4: 80 a0 60 00 cmp %g1, 0 4000f2f8: 22 80 00 07 be,a 4000f314 4000f2fc: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 4000f300: 80 a0 60 02 cmp %g1, 2 4000f304: 08 80 00 10 bleu 4000f344 4000f308: b0 10 20 04 mov 4, %i0 4000f30c: 81 c7 e0 08 ret <== NOT EXECUTED 4000f310: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 4000f314: c2 26 40 00 st %g1, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f318: 07 10 00 d3 sethi %hi(0x40034c00), %g3 4000f31c: c2 00 e0 80 ld [ %g3 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 4000f320: b0 10 20 00 clr %i0 4000f324: 82 00 7f ff add %g1, -1, %g1 4000f328: c2 20 e0 80 st %g1, [ %g3 + 0x80 ] 4000f32c: c4 00 e0 80 ld [ %g3 + 0x80 ], %g2 4000f330: 80 a0 a0 00 cmp %g2, 0 4000f334: 12 80 00 04 bne 4000f344 4000f338: 01 00 00 00 nop _Thread_Dispatch(); 4000f33c: 40 00 1d c8 call 40016a5c <_Thread_Dispatch> 4000f340: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f344: 81 c7 e0 08 ret 4000f348: 81 e8 00 00 restore 400163b0 : void *buffer, size_t *size, uint32_t option_set, rtems_interval timeout ) { 400163b0: 9d e3 bf 90 save %sp, -112, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; boolean wait; if ( !buffer ) 400163b4: 80 a6 60 00 cmp %i1, 0 400163b8: 02 80 00 2b be 40016464 400163bc: 92 10 00 18 mov %i0, %o1 return RTEMS_INVALID_ADDRESS; if ( !size ) 400163c0: 80 a6 a0 00 cmp %i2, 0 400163c4: 02 80 00 28 be 40016464 400163c8: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 400163cc: 11 10 00 b4 sethi %hi(0x4002d000), %o0 400163d0: 7f ff e2 fe call 4000efc8 <_Objects_Get> 400163d4: 90 12 23 0c or %o0, 0x30c, %o0 ! 4002d30c <_Message_queue_Information> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 400163d8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400163dc: 80 a0 60 00 cmp %g1, 0 400163e0: 22 80 00 08 be,a 40016400 400163e4: d2 02 20 08 ld [ %o0 + 8 ], %o1 400163e8: 80 a0 60 02 cmp %g1, 2 400163ec: 08 80 00 03 bleu 400163f8 400163f0: 90 10 20 04 mov 4, %o0 400163f4: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400163f8: 81 c7 e0 08 ret 400163fc: 91 e8 00 08 restore %g0, %o0, %o0 40016400: 98 0e e0 01 and %i3, 1, %o4 if ( _Options_Is_no_wait( option_set ) ) wait = FALSE; else wait = TRUE; _CORE_message_queue_Seize( 40016404: 94 10 00 19 mov %i1, %o2 40016408: 96 10 00 1a mov %i2, %o3 4001640c: 98 1b 20 01 xor %o4, 1, %o4 40016410: 9a 10 00 1c mov %i4, %o5 40016414: 40 00 01 a7 call 40016ab0 <_CORE_message_queue_Seize> 40016418: 90 02 20 14 add %o0, 0x14, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001641c: 05 10 00 b2 sethi %hi(0x4002c800), %g2 40016420: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 ! 4002c8a0 <_Thread_Dispatch_disable_level> 40016424: 82 00 7f ff add %g1, -1, %g1 40016428: c2 20 a0 a0 st %g1, [ %g2 + 0xa0 ] 4001642c: c6 00 a0 a0 ld [ %g2 + 0xa0 ], %g3 40016430: 80 a0 e0 00 cmp %g3, 0 40016434: 02 80 00 08 be 40016454 40016438: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 4001643c: 03 10 00 b2 sethi %hi(0x4002c800), %g1 <== NOT EXECUTED 40016440: c4 00 61 7c ld [ %g1 + 0x17c ], %g2 ! 4002c97c <_Thread_Executing> 40016444: 40 00 00 36 call 4001651c <_Message_queue_Translate_core_message_queue_return_code> 40016448: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001644c: 81 c7 e0 08 ret 40016450: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40016454: 7f ff e8 05 call 40010468 <_Thread_Dispatch> 40016458: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 4001645c: 10 bf ff f9 b 40016440 40016460: 03 10 00 b2 sethi %hi(0x4002c800), %g1 40016464: 10 bf ff e5 b 400163f8 <== NOT EXECUTED 40016468: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED 4001646c : rtems_status_code rtems_message_queue_send( Objects_Id id, void *buffer, size_t size ) { 4001646c: 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 ) 40016470: 80 a6 60 00 cmp %i1, 0 40016474: 02 80 00 20 be 400164f4 40016478: 90 10 20 09 mov 9, %o0 4001647c: 11 10 00 b4 sethi %hi(0x4002d000), %o0 40016480: 92 10 00 18 mov %i0, %o1 40016484: 90 12 23 0c or %o0, 0x30c, %o0 40016488: 7f ff e2 d0 call 4000efc8 <_Objects_Get> 4001648c: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 40016490: c2 07 bf f4 ld [ %fp + -12 ], %g1 40016494: 80 a0 60 00 cmp %g1, 0 40016498: 12 80 00 19 bne 400164fc 4001649c: 80 a0 60 02 cmp %g1, 2 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 400164a0: 94 10 00 1a mov %i2, %o2 400164a4: c0 23 a0 5c clr [ %sp + 0x5c ] 400164a8: c0 23 a0 60 clr [ %sp + 0x60 ] 400164ac: 92 10 00 19 mov %i1, %o1 400164b0: 96 10 00 18 mov %i0, %o3 400164b4: 98 10 20 00 clr %o4 400164b8: 90 02 20 14 add %o0, 0x14, %o0 400164bc: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5 400164c0: 40 00 01 c3 call 40016bcc <_CORE_message_queue_Submit> 400164c4: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff 400164c8: b4 10 00 08 mov %o0, %i2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400164cc: 05 10 00 b2 sethi %hi(0x4002c800), %g2 400164d0: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 ! 4002c8a0 <_Thread_Dispatch_disable_level> 400164d4: 82 00 7f ff add %g1, -1, %g1 400164d8: c2 20 a0 a0 st %g1, [ %g2 + 0xa0 ] 400164dc: c6 00 a0 a0 ld [ %g2 + 0xa0 ], %g3 400164e0: 80 a0 e0 00 cmp %g3, 0 400164e4: 02 80 00 0b be 40016510 400164e8: 01 00 00 00 nop /* * 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); 400164ec: 40 00 00 0c call 4001651c <_Message_queue_Translate_core_message_queue_return_code> 400164f0: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400164f4: 81 c7 e0 08 ret 400164f8: 91 e8 00 08 restore %g0, %o0, %o0 if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 400164fc: 08 bf ff fe bleu 400164f4 40016500: 90 10 20 04 mov 4, %o0 40016504: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code(status); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40016508: 81 c7 e0 08 ret <== NOT EXECUTED 4001650c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40016510: 7f ff e7 d6 call 40010468 <_Thread_Dispatch> 40016514: 01 00 00 00 nop 40016518: 30 bf ff f5 b,a 400164ec 4000888c : rtems_status_code rtems_message_queue_urgent( Objects_Id id, void *buffer, size_t size ) { 4000888c: 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 ) 40008890: 80 a6 60 00 cmp %i1, 0 40008894: 02 80 00 1f be 40008910 40008898: 90 10 20 09 mov 9, %o0 4000889c: 11 10 00 8d sethi %hi(0x40023400), %o0 400088a0: 92 10 00 18 mov %i0, %o1 400088a4: 90 12 21 98 or %o0, 0x198, %o0 400088a8: 40 00 0a 47 call 4000b1c4 <_Objects_Get> 400088ac: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 400088b0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400088b4: 80 a0 60 00 cmp %g1, 0 400088b8: 12 80 00 18 bne 40008918 400088bc: 80 a0 60 02 cmp %g1, 2 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 400088c0: 94 10 00 1a mov %i2, %o2 400088c4: c0 23 a0 5c clr [ %sp + 0x5c ] 400088c8: c0 23 a0 60 clr [ %sp + 0x60 ] 400088cc: 92 10 00 19 mov %i1, %o1 400088d0: 96 10 00 18 mov %i0, %o3 400088d4: 98 10 20 00 clr %o4 400088d8: 1b 20 00 00 sethi %hi(0x80000000), %o5 400088dc: 40 00 06 0e call 4000a114 <_CORE_message_queue_Submit> 400088e0: 90 02 20 14 add %o0, 0x14, %o0 400088e4: b4 10 00 08 mov %o0, %i2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400088e8: 03 10 00 8a sethi %hi(0x40022800), %g1 400088ec: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 40022bb0 <_Thread_Dispatch_disable_level> 400088f0: 84 00 bf ff add %g2, -1, %g2 400088f4: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 400088f8: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 400088fc: 80 a0 e0 00 cmp %g3, 0 40008900: 02 80 00 0b be 4000892c 40008904: 01 00 00 00 nop /* * 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); 40008908: 7f ff ff d7 call 40008864 <_Message_queue_Translate_core_message_queue_return_code> 4000890c: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008910: 81 c7 e0 08 ret 40008914: 91 e8 00 08 restore %g0, %o0, %o0 if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 40008918: 08 bf ff fe bleu 40008910 <== NOT EXECUTED 4000891c: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED 40008920: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code(status); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008924: 81 c7 e0 08 ret <== NOT EXECUTED 40008928: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000892c: 40 00 0f 4e call 4000c664 <_Thread_Dispatch> 40008930: 01 00 00 00 nop 40008934: 30 bf ff f5 b,a 40008908 4000f514 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 4000f514: 9d e3 bf 98 save %sp, -104, %sp register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 4000f518: a8 96 20 00 orcc %i0, 0, %l4 4000f51c: 02 80 00 29 be 4000f5c0 4000f520: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 4000f524: 80 a6 60 00 cmp %i1, 0 4000f528: 02 80 00 11 be 4000f56c 4000f52c: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 4000f530: 02 80 00 0f be 4000f56c 4000f534: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 4000f538: 12 80 00 04 bne 4000f548 4000f53c: 80 a6 e0 00 cmp %i3, 0 ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 4000f540: 81 c7 e0 08 ret 4000f544: 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 || 4000f548: 02 80 00 1e be 4000f5c0 4000f54c: b0 10 20 08 mov 8, %i0 4000f550: 80 a6 80 1b cmp %i2, %i3 4000f554: 0a 80 00 1b bcs 4000f5c0 4000f558: 80 8e e0 07 btst 7, %i3 4000f55c: 12 80 00 19 bne 4000f5c0 4000f560: 80 8e 60 07 btst 7, %i1 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 4000f564: 02 80 00 04 be 4000f574 4000f568: 25 10 00 d3 sethi %hi(0x40034c00), %l2 4000f56c: 81 c7 e0 08 ret 4000f570: 91 e8 20 09 restore %g0, 9, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000f574: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 4000f578: 82 00 60 01 inc %g1 4000f57c: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 4000f580: 27 10 00 d2 sethi %hi(0x40034800), %l3 4000f584: 40 00 16 a9 call 40015028 <_Objects_Allocate> 4000f588: 90 14 e2 00 or %l3, 0x200, %o0 ! 40034a00 <_Partition_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 4000f58c: a2 92 20 00 orcc %o0, 0, %l1 4000f590: 12 80 00 0e bne 4000f5c8 4000f594: 92 10 00 1b mov %i3, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f598: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 4000f59c: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 4000f5a0: 82 00 7f ff add %g1, -1, %g1 4000f5a4: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] 4000f5a8: c4 04 a0 80 ld [ %l2 + 0x80 ], %g2 4000f5ac: 80 a0 a0 00 cmp %g2, 0 4000f5b0: 12 80 00 04 bne 4000f5c0 4000f5b4: 01 00 00 00 nop 4000f5b8: 40 00 1d 29 call 40016a5c <_Thread_Dispatch> 4000f5bc: 01 00 00 00 nop 4000f5c0: 81 c7 e0 08 ret 4000f5c4: 81 e8 00 00 restore #endif the_partition->starting_address = starting_address; the_partition->length = length; the_partition->buffer_size = buffer_size; the_partition->attribute_set = attribute_set; 4000f5c8: f8 24 60 1c st %i4, [ %l1 + 0x1c ] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 4000f5cc: f2 24 60 10 st %i1, [ %l1 + 0x10 ] the_partition->length = length; 4000f5d0: f4 24 60 14 st %i2, [ %l1 + 0x14 ] the_partition->buffer_size = buffer_size; 4000f5d4: f6 24 60 18 st %i3, [ %l1 + 0x18 ] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 4000f5d8: c0 24 60 20 clr [ %l1 + 0x20 ] _Chain_Initialize( &the_partition->Memory, starting_address, 4000f5dc: 40 00 58 44 call 400256ec <.udiv> 4000f5e0: 90 10 00 1a mov %i2, %o0 4000f5e4: a0 04 60 24 add %l1, 0x24, %l0 4000f5e8: 94 10 00 08 mov %o0, %o2 4000f5ec: 92 10 00 19 mov %i1, %o1 4000f5f0: 90 10 00 10 mov %l0, %o0 4000f5f4: 40 00 12 5e call 40013f6c <_Chain_Initialize> 4000f5f8: 96 10 00 1b mov %i3, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f5fc: 90 14 e2 00 or %l3, 0x200, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000f600: c6 04 60 08 ld [ %l1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f604: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 4000f608: 03 00 00 3f sethi %hi(0xfc00), %g1 4000f60c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000f610: 82 08 c0 01 and %g3, %g1, %g1 4000f614: 80 a0 40 02 cmp %g1, %g2 4000f618: 38 80 00 06 bgu,a 4000f630 4000f61c: e8 24 60 0c st %l4, [ %l1 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000f620: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000f624: 83 28 60 02 sll %g1, 2, %g1 4000f628: e2 20 80 01 st %l1, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 4000f62c: e8 24 60 0c st %l4, [ %l1 + 0xc ] &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 4000f630: c6 27 40 00 st %g3, [ %i5 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f634: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 4000f638: 10 bf ff da b 4000f5a0 4000f63c: b0 10 20 00 clr %i0 4000f640 : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 4000f640: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 4000f644: 92 10 00 18 mov %i0, %o1 4000f648: 94 07 bf f4 add %fp, -12, %o2 4000f64c: 31 10 00 d2 sethi %hi(0x40034800), %i0 4000f650: 40 00 17 db call 400155bc <_Objects_Get> 4000f654: 90 16 22 00 or %i0, 0x200, %o0 ! 40034a00 <_Partition_Information> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000f658: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f65c: 80 a0 60 00 cmp %g1, 0 4000f660: 12 80 00 13 bne 4000f6ac 4000f664: 92 10 00 08 mov %o0, %o1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 4000f668: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 4000f66c: 80 a0 60 00 cmp %g1, 0 4000f670: 02 80 00 14 be 4000f6c0 4000f674: 90 16 22 00 or %i0, 0x200, %o0 4000f678: 03 10 00 d3 sethi %hi(0x40034c00), %g1 4000f67c: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 4000f680: b0 10 20 0c mov 0xc, %i0 4000f684: 84 00 bf ff add %g2, -1, %g2 4000f688: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 4000f68c: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 4000f690: 80 a0 e0 00 cmp %g3, 0 4000f694: 12 80 00 22 bne 4000f71c 4000f698: 01 00 00 00 nop _Thread_Dispatch(); 4000f69c: 40 00 1c f0 call 40016a5c <_Thread_Dispatch> 4000f6a0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f6a4: 81 c7 e0 08 ret 4000f6a8: 81 e8 00 00 restore { register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000f6ac: 80 a0 60 02 cmp %g1, 2 4000f6b0: 08 bf ff fd bleu 4000f6a4 4000f6b4: b0 10 20 04 mov 4, %i0 4000f6b8: 81 c7 e0 08 ret <== NOT EXECUTED 4000f6bc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000f6c0: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f6c4: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4000f6c8: 05 00 00 3f sethi %hi(0xfc00), %g2 4000f6cc: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000f6d0: 82 08 40 02 and %g1, %g2, %g1 4000f6d4: 80 a0 40 03 cmp %g1, %g3 4000f6d8: 18 80 00 04 bgu 4000f6e8 4000f6dc: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 4000f6e0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000f6e4: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Partition_Free ( Partition_Control *the_partition ) { _Objects_Free( &_Partition_Information, &the_partition->Object ); 4000f6e8: 40 00 17 5e call 40015460 <_Objects_Free> 4000f6ec: c0 22 60 0c clr [ %o1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f6f0: 03 10 00 d3 sethi %hi(0x40034c00), %g1 4000f6f4: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 4000f6f8: b0 10 20 00 clr %i0 4000f6fc: 84 00 bf ff add %g2, -1, %g2 4000f700: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 4000f704: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 4000f708: 80 a0 e0 00 cmp %g3, 0 4000f70c: 12 80 00 04 bne 4000f71c 4000f710: 01 00 00 00 nop _Thread_Dispatch(); 4000f714: 40 00 1c d2 call 40016a5c <_Thread_Dispatch> 4000f718: 01 00 00 00 nop 4000f71c: 81 c7 e0 08 ret 4000f720: 81 e8 00 00 restore 4000f724 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 4000f724: 9d e3 bf 90 save %sp, -112, %sp 4000f728: 92 10 00 18 mov %i0, %o1 register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 4000f72c: 80 a6 60 00 cmp %i1, 0 4000f730: 02 80 00 1a be 4000f798 4000f734: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 4000f738: 11 10 00 d2 sethi %hi(0x40034800), %o0 4000f73c: 94 07 bf f4 add %fp, -12, %o2 4000f740: 40 00 17 9f call 400155bc <_Objects_Get> 4000f744: 90 12 22 00 or %o0, 0x200, %o0 return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000f748: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f74c: 80 a0 60 00 cmp %g1, 0 4000f750: 12 80 00 14 bne 4000f7a0 4000f754: b0 10 00 08 mov %o0, %i0 RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 4000f758: 40 00 11 f2 call 40013f20 <_Chain_Get> 4000f75c: 90 02 20 24 add %o0, 0x24, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 4000f760: a0 92 20 00 orcc %o0, 0, %l0 4000f764: 32 80 00 14 bne,a 4000f7b4 4000f768: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f76c: 03 10 00 d3 sethi %hi(0x40034c00), %g1 4000f770: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 4000f774: b0 10 20 0d mov 0xd, %i0 4000f778: 84 00 bf ff add %g2, -1, %g2 4000f77c: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 4000f780: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 4000f784: 80 a0 e0 00 cmp %g3, 0 4000f788: 12 80 00 04 bne 4000f798 4000f78c: 01 00 00 00 nop _Thread_Dispatch(); 4000f790: 40 00 1c b3 call 40016a5c <_Thread_Dispatch> 4000f794: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_UNSATISFIED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f798: 81 c7 e0 08 ret 4000f79c: 81 e8 00 00 restore if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000f7a0: 80 a0 60 02 cmp %g1, 2 4000f7a4: 08 bf ff fd bleu 4000f798 4000f7a8: b0 10 20 04 mov 4, %i0 4000f7ac: 81 c7 e0 08 ret <== NOT EXECUTED 4000f7b0: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { the_partition->number_of_used_blocks += 1; 4000f7b4: 82 00 60 01 inc %g1 4000f7b8: c2 26 20 20 st %g1, [ %i0 + 0x20 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f7bc: 05 10 00 d3 sethi %hi(0x40034c00), %g2 4000f7c0: c2 00 a0 80 ld [ %g2 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 4000f7c4: 82 00 7f ff add %g1, -1, %g1 4000f7c8: c2 20 a0 80 st %g1, [ %g2 + 0x80 ] 4000f7cc: c6 00 a0 80 ld [ %g2 + 0x80 ], %g3 4000f7d0: 80 a0 e0 00 cmp %g3, 0 4000f7d4: 02 80 00 05 be 4000f7e8 4000f7d8: 01 00 00 00 nop _Thread_Enable_dispatch(); *buffer = the_buffer; 4000f7dc: e0 26 40 00 st %l0, [ %i1 ] <== NOT EXECUTED 4000f7e0: 81 c7 e0 08 ret 4000f7e4: 91 e8 20 00 restore %g0, 0, %o0 _Thread_Dispatch(); 4000f7e8: 40 00 1c 9d call 40016a5c <_Thread_Dispatch> 4000f7ec: 01 00 00 00 nop 4000f7f0: 10 bf ff fc b 4000f7e0 4000f7f4: e0 26 40 00 st %l0, [ %i1 ] 4000f82c : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 4000f82c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 4000f830: 11 10 00 d2 sethi %hi(0x40034800), %o0 4000f834: 92 10 00 18 mov %i0, %o1 4000f838: 90 12 22 00 or %o0, 0x200, %o0 4000f83c: 40 00 17 60 call 400155bc <_Objects_Get> 4000f840: 94 07 bf f4 add %fp, -12, %o2 register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000f844: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f848: 80 a0 60 00 cmp %g1, 0 4000f84c: 12 80 00 12 bne 4000f894 4000f850: b0 10 00 08 mov %o0, %i0 ) { void *starting; void *ending; starting = the_partition->starting_address; 4000f854: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( 4000f858: 80 a0 80 19 cmp %g2, %i1 4000f85c: 28 80 00 13 bleu,a 4000f8a8 4000f860: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f864: 03 10 00 d3 sethi %hi(0x40034c00), %g1 4000f868: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 4000f86c: 84 00 bf ff add %g2, -1, %g2 4000f870: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 4000f874: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 4000f878: 80 a0 e0 00 cmp %g3, 0 4000f87c: 12 80 00 27 bne 4000f918 4000f880: 01 00 00 00 nop _Thread_Dispatch(); 4000f884: 40 00 1c 76 call 40016a5c <_Thread_Dispatch> 4000f888: b0 10 20 09 mov 9, %i0 ! 9 4000f88c: 81 c7 e0 08 ret 4000f890: 81 e8 00 00 restore 4000f894: 80 a0 60 02 cmp %g1, 2 4000f898: 08 bf ff fd bleu 4000f88c 4000f89c: b0 10 20 04 mov 4, %i0 4000f8a0: 81 c7 e0 08 ret <== NOT EXECUTED 4000f8a4: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 4000f8a8: 82 00 80 01 add %g2, %g1, %g1 4000f8ac: 80 a0 40 19 cmp %g1, %i1 4000f8b0: 0a bf ff ed bcs 4000f864 4000f8b4: 01 00 00 00 nop 4000f8b8: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 4000f8bc: 40 00 58 38 call 4002599c <.urem> 4000f8c0: 90 26 40 02 sub %i1, %g2, %o0 4000f8c4: 80 a2 20 00 cmp %o0, 0 4000f8c8: 12 bf ff e7 bne 4000f864 4000f8cc: 92 10 00 19 mov %i1, %o1 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 4000f8d0: 40 00 11 88 call 40013ef0 <_Chain_Append> 4000f8d4: 90 06 20 24 add %i0, 0x24, %o0 return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 4000f8d8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 4000f8dc: 82 00 7f ff add %g1, -1, %g1 4000f8e0: c2 26 20 20 st %g1, [ %i0 + 0x20 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f8e4: 07 10 00 d3 sethi %hi(0x40034c00), %g3 4000f8e8: c2 00 e0 80 ld [ %g3 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 4000f8ec: b0 10 20 00 clr %i0 4000f8f0: 82 00 7f ff add %g1, -1, %g1 4000f8f4: c2 20 e0 80 st %g1, [ %g3 + 0x80 ] 4000f8f8: c4 00 e0 80 ld [ %g3 + 0x80 ], %g2 4000f8fc: 80 a0 a0 00 cmp %g2, 0 4000f900: 12 80 00 04 bne 4000f910 4000f904: 01 00 00 00 nop _Thread_Dispatch(); 4000f908: 40 00 1c 55 call 40016a5c <_Thread_Dispatch> 4000f90c: 01 00 00 00 nop 4000f910: 81 c7 e0 08 ret 4000f914: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f918: 81 c7 e0 08 ret <== NOT EXECUTED 4000f91c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED 4000e798 : */ rtems_status_code rtems_port_delete( Objects_Id id ) { 4000e798: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Get ( Objects_Id id, Objects_Locations *location ) { return (Dual_ported_memory_Control *) 4000e79c: 92 10 00 18 mov %i0, %o1 4000e7a0: 94 07 bf f4 add %fp, -12, %o2 4000e7a4: 31 10 00 d2 sethi %hi(0x40034800), %i0 4000e7a8: 40 00 1b 85 call 400155bc <_Objects_Get> 4000e7ac: 90 16 21 b4 or %i0, 0x1b4, %o0 ! 400349b4 <_Dual_ported_memory_Information> register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 4000e7b0: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000e7b4: 80 a0 60 00 cmp %g1, 0 4000e7b8: 12 80 00 1a bne 4000e820 4000e7bc: 92 10 00 08 mov %o0, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000e7c0: 90 16 21 b4 or %i0, 0x1b4, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000e7c4: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000e7c8: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4000e7cc: 05 00 00 3f sethi %hi(0xfc00), %g2 4000e7d0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000e7d4: 82 08 40 02 and %g1, %g2, %g1 4000e7d8: 80 a0 40 03 cmp %g1, %g3 4000e7dc: 18 80 00 04 bgu 4000e7ec 4000e7e0: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 4000e7e4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000e7e8: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Dual_ported_memory_Free ( Dual_ported_memory_Control *the_port ) { _Objects_Free( &_Dual_ported_memory_Information, &the_port->Object ); 4000e7ec: 40 00 1b 1d call 40015460 <_Objects_Free> 4000e7f0: c0 22 60 0c clr [ %o1 + 0xc ] 4000e7f4: 03 10 00 d3 sethi %hi(0x40034c00), %g1 4000e7f8: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 4000e7fc: b0 10 20 00 clr %i0 4000e800: 84 00 bf ff add %g2, -1, %g2 4000e804: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 4000e808: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 4000e80c: 80 a0 e0 00 cmp %g3, 0 4000e810: 02 80 00 0a be 4000e838 4000e814: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000e818: 81 c7 e0 08 ret <== NOT EXECUTED 4000e81c: 81 e8 00 00 restore <== NOT EXECUTED { register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 4000e820: 82 18 60 02 xor %g1, 2, %g1 4000e824: 80 a0 00 01 cmp %g0, %g1 4000e828: 84 60 20 00 subx %g0, 0, %g2 4000e82c: b0 08 a0 15 and %g2, 0x15, %i0 4000e830: 81 c7 e0 08 ret 4000e834: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 4000e838: 40 00 20 89 call 40016a5c <_Thread_Dispatch> 4000e83c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000e840: 81 c7 e0 08 ret 4000e844: 81 e8 00 00 restore 4000fb34 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 4000fb34: 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 *) 4000fb38: 21 10 00 d2 sethi %hi(0x40034800), %l0 4000fb3c: 92 10 00 18 mov %i0, %o1 4000fb40: 94 07 bf f4 add %fp, -12, %o2 4000fb44: 40 00 16 9e call 400155bc <_Objects_Get> 4000fb48: 90 14 22 4c or %l0, 0x24c, %o0 Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000fb4c: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000fb50: 80 a0 60 00 cmp %g1, 0 4000fb54: 12 80 00 20 bne 4000fbd4 4000fb58: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000fb5c: a0 14 22 4c or %l0, 0x24c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000fb60: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000fb64: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 4000fb68: 05 00 00 3f sethi %hi(0xfc00), %g2 4000fb6c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000fb70: 82 08 40 02 and %g1, %g2, %g1 4000fb74: 80 a0 40 03 cmp %g1, %g3 4000fb78: 38 80 00 06 bgu,a 4000fb90 4000fb7c: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000fb80: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 4000fb84: 83 28 60 02 sll %g1, 2, %g1 4000fb88: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 4000fb8c: c0 26 20 0c clr [ %i0 + 0xc ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _Objects_Close( &_Rate_monotonic_Information, &the_period->Object ); (void) _Watchdog_Remove( &the_period->Timer ); 4000fb90: 40 00 22 7b call 4001857c <_Watchdog_Remove> 4000fb94: 90 06 20 10 add %i0, 0x10, %o0 RTEMS_INLINE_ROUTINE void _Rate_monotonic_Free ( Rate_monotonic_Control *the_period ) { _Objects_Free( &_Rate_monotonic_Information, &the_period->Object ); 4000fb98: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_INACTIVE; 4000fb9c: c0 26 20 38 clr [ %i0 + 0x38 ] 4000fba0: 40 00 16 30 call 40015460 <_Objects_Free> 4000fba4: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000fba8: 03 10 00 d3 sethi %hi(0x40034c00), %g1 4000fbac: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 4000fbb0: b0 10 20 00 clr %i0 4000fbb4: 84 00 bf ff add %g2, -1, %g2 4000fbb8: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 4000fbbc: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 4000fbc0: 80 a0 e0 00 cmp %g3, 0 4000fbc4: 02 80 00 0a be 4000fbec 4000fbc8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000fbcc: 81 c7 e0 08 ret <== NOT EXECUTED 4000fbd0: 81 e8 00 00 restore <== NOT EXECUTED { Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000fbd4: 82 18 60 02 xor %g1, 2, %g1 4000fbd8: 80 a0 00 01 cmp %g0, %g1 4000fbdc: 84 60 20 00 subx %g0, 0, %g2 4000fbe0: b0 08 a0 15 and %g2, 0x15, %i0 4000fbe4: 81 c7 e0 08 ret 4000fbe8: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 4000fbec: 40 00 1b 9c call 40016a5c <_Thread_Dispatch> 4000fbf0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000fbf4: 81 c7 e0 08 ret 4000fbf8: 81 e8 00 00 restore 4000edb0 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 4000edb0: 9d e3 bf 90 save %sp, -112, %sp 4000edb4: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 4000edb8: 80 a6 60 00 cmp %i1, 0 4000edbc: 02 80 00 17 be 4000ee18 4000edc0: b0 10 20 09 mov 9, %i0 4000edc4: 11 10 00 7e sethi %hi(0x4001f800), %o0 4000edc8: 94 07 bf f4 add %fp, -12, %o2 4000edcc: 7f ff ea dc call 4000993c <_Objects_Get> 4000edd0: 90 12 21 48 or %o0, 0x148, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000edd4: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000edd8: 80 a0 60 00 cmp %g1, 0 4000eddc: 12 80 00 11 bne 4000ee20 4000ede0: 92 10 00 08 mov %o0, %o1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: *statistics = the_period->Statistics; 4000ede4: 90 10 00 19 mov %i1, %o0 4000ede8: 92 02 60 54 add %o1, 0x54, %o1 4000edec: 40 00 09 2b call 40011298 4000edf0: 94 10 20 38 mov 0x38, %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000edf4: 03 10 00 7e sethi %hi(0x4001f800), %g1 4000edf8: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 4001fae0 <_Thread_Dispatch_disable_level> 4000edfc: b0 10 20 00 clr %i0 4000ee00: 84 00 bf ff add %g2, -1, %g2 4000ee04: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ] 4000ee08: c6 00 62 e0 ld [ %g1 + 0x2e0 ], %g3 4000ee0c: 80 a0 e0 00 cmp %g3, 0 4000ee10: 02 80 00 0a be 4000ee38 4000ee14: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000ee18: 81 c7 e0 08 ret <== NOT EXECUTED 4000ee1c: 81 e8 00 00 restore <== NOT EXECUTED if ( !statistics ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000ee20: 82 18 60 02 xor %g1, 2, %g1 4000ee24: 80 a0 00 01 cmp %g0, %g1 4000ee28: 84 60 20 00 subx %g0, 0, %g2 4000ee2c: b0 08 a0 15 and %g2, 0x15, %i0 4000ee30: 81 c7 e0 08 ret 4000ee34: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 4000ee38: 7f ff ef e9 call 4000addc <_Thread_Dispatch> 4000ee3c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000ee40: 81 c7 e0 08 ret 4000ee44: 81 e8 00 00 restore 4000ee48 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 4000ee48: 9d e3 bf 88 save %sp, -120, %sp 4000ee4c: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 4000ee50: 80 a6 60 00 cmp %i1, 0 4000ee54: 02 80 00 21 be 4000eed8 4000ee58: b0 10 20 09 mov 9, %i0 4000ee5c: 11 10 00 7e sethi %hi(0x4001f800), %o0 4000ee60: 94 07 bf f4 add %fp, -12, %o2 4000ee64: 7f ff ea b6 call 4000993c <_Objects_Get> 4000ee68: 90 12 21 48 or %o0, 0x148, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000ee6c: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000ee70: 80 a0 60 00 cmp %g1, 0 4000ee74: 12 80 00 1b bne 4000eee0 4000ee78: b0 10 00 08 mov %o0, %i0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 4000ee7c: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 4000ee80: 80 a0 60 00 cmp %g1, 0 4000ee84: 02 80 00 03 be 4000ee90 4000ee88: 84 10 20 00 clr %g2 4000ee8c: c4 00 60 08 ld [ %g1 + 8 ], %g2 status->state = the_period->state; 4000ee90: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 4000ee94: c4 26 40 00 st %g2, [ %i1 ] status->state = the_period->state; if ( status->state == RATE_MONOTONIC_INACTIVE ) { 4000ee98: 80 a0 60 00 cmp %g1, 0 4000ee9c: 12 80 00 1b bne 4000ef08 4000eea0: c2 26 60 04 st %g1, [ %i1 + 4 ] #else status->ticks_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; 4000eea4: c0 26 60 14 clr [ %i1 + 0x14 ] <== NOT EXECUTED 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; 4000eea8: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 4000eeac: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED #else status->ticks_since_last_period = 0; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS status->executed_since_last_period.tv_sec = 0; 4000eeb0: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000eeb4: 03 10 00 7e sethi %hi(0x4001f800), %g1 4000eeb8: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 4001fae0 <_Thread_Dispatch_disable_level> 4000eebc: b0 10 20 00 clr %i0 4000eec0: 84 00 bf ff add %g2, -1, %g2 4000eec4: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ] 4000eec8: c6 00 62 e0 ld [ %g1 + 0x2e0 ], %g3 4000eecc: 80 a0 e0 00 cmp %g3, 0 4000eed0: 02 80 00 0a be 4000eef8 4000eed4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000eed8: 81 c7 e0 08 ret <== NOT EXECUTED 4000eedc: 81 e8 00 00 restore <== NOT EXECUTED if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000eee0: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 4000eee4: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 4000eee8: 84 60 20 00 subx %g0, 0, %g2 <== NOT EXECUTED 4000eeec: b0 08 a0 15 and %g2, 0x15, %i0 <== NOT EXECUTED 4000eef0: 81 c7 e0 08 ret <== NOT EXECUTED 4000eef4: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000eef8: 7f ff ef b9 call 4000addc <_Thread_Dispatch> 4000eefc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000ef00: 81 c7 e0 08 ret 4000ef04: 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 ); 4000ef08: a0 07 bf ec add %fp, -20, %l0 4000ef0c: 7f ff e7 3e call 40008c04 <_TOD_Get_uptime> 4000ef10: 90 10 00 10 mov %l0, %o0 #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 4000ef14: 90 06 20 44 add %i0, 0x44, %o0 4000ef18: 92 10 00 10 mov %l0, %o1 4000ef1c: 7f ff f4 6b call 4000c0c8 <_Timespec_Subtract> 4000ef20: 94 06 60 08 add %i1, 8, %o2 status->ticks_since_last_period = _Watchdog_Ticks_since_boot - the_period->time_at_period; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Subtract( 4000ef24: 92 10 00 10 mov %l0, %o1 4000ef28: 94 06 60 10 add %i1, 0x10, %o2 4000ef2c: 11 10 00 7e sethi %hi(0x4001f800), %o0 4000ef30: 7f ff f4 66 call 4000c0c8 <_Timespec_Subtract> 4000ef34: 90 12 23 c4 or %o0, 0x3c4, %o0 ! 4001fbc4 <_Thread_Time_of_last_context_switch> 4000ef38: 30 bf ff df b,a 4000eeb4 40006bd0 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 40006bd0: 9d e3 bf 80 save %sp, -128, %sp RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get ( Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) 40006bd4: 11 10 00 7e sethi %hi(0x4001f800), %o0 40006bd8: 92 10 00 18 mov %i0, %o1 40006bdc: 90 12 21 48 or %o0, 0x148, %o0 40006be0: 40 00 0b 57 call 4000993c <_Objects_Get> 40006be4: 94 07 bf f4 add %fp, -12, %o2 rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 40006be8: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006bec: 80 a0 60 00 cmp %g1, 0 40006bf0: 12 80 00 15 bne 40006c44 40006bf4: a2 10 00 08 mov %o0, %l1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 40006bf8: 25 10 00 7e sethi %hi(0x4001f800), %l2 40006bfc: c4 02 20 50 ld [ %o0 + 0x50 ], %g2 40006c00: c2 04 a3 bc ld [ %l2 + 0x3bc ], %g1 40006c04: 80 a0 80 01 cmp %g2, %g1 40006c08: 02 80 00 14 be 40006c58 40006c0c: 80 a6 60 00 cmp %i1, 0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006c10: 03 10 00 7e sethi %hi(0x4001f800), %g1 40006c14: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 4001fae0 <_Thread_Dispatch_disable_level> 40006c18: b0 10 20 17 mov 0x17, %i0 _Thread_Dispatch(); 40006c1c: 84 00 bf ff add %g2, -1, %g2 40006c20: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ] 40006c24: c6 00 62 e0 ld [ %g1 + 0x2e0 ], %g3 40006c28: 80 a0 e0 00 cmp %g3, 0 40006c2c: 12 80 00 66 bne 40006dc4 40006c30: 01 00 00 00 nop 40006c34: 40 00 10 6a call 4000addc <_Thread_Dispatch> 40006c38: 01 00 00 00 nop 40006c3c: 81 c7 e0 08 ret 40006c40: 81 e8 00 00 restore rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 40006c44: 80 a0 60 02 cmp %g1, 2 40006c48: 02 bf ff fd be 40006c3c 40006c4c: b0 10 20 04 mov 4, %i0 break; } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006c50: 81 c7 e0 08 ret <== NOT EXECUTED 40006c54: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 40006c58: 22 80 00 73 be,a 40006e24 40006c5c: d0 02 20 38 ld [ %o0 + 0x38 ], %o0 } _Thread_Enable_dispatch(); return( return_value ); } _ISR_Disable( level ); 40006c60: 7f ff ef 57 call 400029bc 40006c64: 01 00 00 00 nop 40006c68: a0 10 00 08 mov %o0, %l0 switch ( the_period->state ) { 40006c6c: e6 04 60 38 ld [ %l1 + 0x38 ], %l3 40006c70: 80 a4 e0 02 cmp %l3, 2 40006c74: 02 80 00 34 be 40006d44 40006c78: 80 a4 e0 04 cmp %l3, 4 40006c7c: 02 80 00 54 be 40006dcc 40006c80: 80 a4 e0 00 cmp %l3, 0 40006c84: 32 bf ff ee bne,a 40006c3c 40006c88: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED /* * No need to update statistics -- there are not a period active */ _ISR_Enable( level ); 40006c8c: 7f ff ef 50 call 400029cc 40006c90: a0 07 bf ec add %fp, -20, %l0 #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) _TOD_Get_uptime( &uptime ); 40006c94: 40 00 07 dc call 40008c04 <_TOD_Get_uptime> 40006c98: 90 10 00 10 mov %l0, %o0 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS /* * Since the statistics didn't update the starting time, * we do it here. */ the_period->time_at_period = uptime; 40006c9c: c2 07 bf ec ld [ %fp + -20 ], %g1 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40006ca0: c6 04 a3 bc ld [ %l2 + 0x3bc ], %g3 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS /* * Since the statistics didn't update the starting time, * we do it here. */ the_period->time_at_period = uptime; 40006ca4: c2 24 60 44 st %g1, [ %l1 + 0x44 ] 40006ca8: c2 07 bf f0 ld [ %fp + -16 ], %g1 the_period->owner_executed_at_period = _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40006cac: 92 10 00 10 mov %l0, %o1 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS /* * Since the statistics didn't update the starting time, * we do it here. */ the_period->time_at_period = uptime; 40006cb0: c2 24 60 48 st %g1, [ %l1 + 0x48 ] #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40006cb4: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40006cb8: a0 07 bf e4 add %fp, -28, %l0 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40006cbc: c4 24 60 3c st %g2, [ %l1 + 0x3c ] 40006cc0: c2 00 e0 94 ld [ %g3 + 0x94 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40006cc4: 94 10 00 10 mov %l0, %o2 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40006cc8: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40006ccc: 11 10 00 7e sethi %hi(0x4001f800), %o0 40006cd0: 40 00 14 fe call 4000c0c8 <_Timespec_Subtract> 40006cd4: 90 12 23 c4 or %o0, 0x3c4, %o0 ! 4001fbc4 <_Thread_Time_of_last_context_switch> /* The thread had executed before the last context switch also. * * the_period->owner_executed_at_period += ran */ _Timespec_Add_to( &the_period->owner_executed_at_period, &ran ); 40006cd8: 92 10 00 10 mov %l0, %o1 40006cdc: 40 00 14 98 call 4000bf3c <_Timespec_Add_to> 40006ce0: 90 04 60 3c add %l1, 0x3c, %o0 #else the_period->owner_ticks_executed_at_period = _Thread_Executing->ticks_executed; #endif the_period->state = RATE_MONOTONIC_ACTIVE; 40006ce4: 84 10 20 02 mov 2, %g2 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40006ce8: 03 10 00 1c sethi %hi(0x40007000), %g1 40006cec: 82 10 61 f8 or %g1, 0x1f8, %g1 ! 400071f8 <_Rate_monotonic_Timeout> the_watchdog->id = id; 40006cf0: f0 24 60 30 st %i0, [ %l1 + 0x30 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40006cf4: f2 24 60 1c st %i1, [ %l1 + 0x1c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40006cf8: c0 24 60 18 clr [ %l1 + 0x18 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 40006cfc: c0 24 60 34 clr [ %l1 + 0x34 ] _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 40006d00: f2 24 60 4c st %i1, [ %l1 + 0x4c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40006d04: 92 04 60 10 add %l1, 0x10, %o1 #else the_period->owner_ticks_executed_at_period = _Thread_Executing->ticks_executed; #endif the_period->state = RATE_MONOTONIC_ACTIVE; 40006d08: c4 24 60 38 st %g2, [ %l1 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40006d0c: c2 24 60 2c st %g1, [ %l1 + 0x2c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40006d10: 11 10 00 7e sethi %hi(0x4001f800), %o0 40006d14: 40 00 15 b8 call 4000c3f4 <_Watchdog_Insert> 40006d18: 90 12 23 dc or %o0, 0x3dc, %o0 ! 4001fbdc <_Watchdog_Ticks_chain> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006d1c: 05 10 00 7e sethi %hi(0x4001f800), %g2 40006d20: c2 00 a2 e0 ld [ %g2 + 0x2e0 ], %g1 ! 4001fae0 <_Thread_Dispatch_disable_level> 40006d24: 82 00 7f ff add %g1, -1, %g1 40006d28: c2 20 a2 e0 st %g1, [ %g2 + 0x2e0 ] 40006d2c: c6 00 a2 e0 ld [ %g2 + 0x2e0 ], %g3 40006d30: 80 a0 e0 00 cmp %g3, 0 40006d34: 02 80 00 22 be 40006dbc 40006d38: 01 00 00 00 nop _Thread_Dispatch(); 40006d3c: 81 c7 e0 08 ret <== NOT EXECUTED 40006d40: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 40006d44: 7f ff ff 43 call 40006a50 <_Rate_monotonic_Update_statistics> 40006d48: 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; 40006d4c: 82 10 20 01 mov 1, %g1 the_period->next_length = length; 40006d50: 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; 40006d54: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; _ISR_Enable( level ); 40006d58: 7f ff ef 1d call 400029cc 40006d5c: 90 10 00 10 mov %l0, %o0 _Thread_Executing->Wait.id = the_period->Object.id; 40006d60: c2 04 a3 bc ld [ %l2 + 0x3bc ], %g1 40006d64: c4 04 60 08 ld [ %l1 + 8 ], %g2 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 40006d68: 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; 40006d6c: c4 20 60 20 st %g2, [ %g1 + 0x20 ] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 40006d70: 40 00 13 41 call 4000ba74 <_Thread_Set_state> 40006d74: 13 00 00 10 sethi %hi(0x4000), %o1 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 40006d78: 7f ff ef 11 call 400029bc 40006d7c: 01 00 00 00 nop local_state = the_period->state; 40006d80: e0 04 60 38 ld [ %l1 + 0x38 ], %l0 the_period->state = RATE_MONOTONIC_ACTIVE; 40006d84: e6 24 60 38 st %l3, [ %l1 + 0x38 ] _ISR_Enable( level ); 40006d88: 7f ff ef 11 call 400029cc 40006d8c: 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 ) 40006d90: 80 a4 20 03 cmp %l0, 3 40006d94: 02 80 00 32 be 40006e5c 40006d98: d0 04 a3 bc ld [ %l2 + 0x3bc ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006d9c: 03 10 00 7e sethi %hi(0x4001f800), %g1 40006da0: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 4001fae0 <_Thread_Dispatch_disable_level> 40006da4: 84 00 bf ff add %g2, -1, %g2 40006da8: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ] 40006dac: c6 00 62 e0 ld [ %g1 + 0x2e0 ], %g3 40006db0: 80 a0 e0 00 cmp %g3, 0 40006db4: 12 bf ff e2 bne 40006d3c 40006db8: 01 00 00 00 nop _Thread_Dispatch(); 40006dbc: 40 00 10 08 call 4000addc <_Thread_Dispatch> 40006dc0: b0 10 20 00 clr %i0 ! 0 40006dc4: 81 c7 e0 08 ret 40006dc8: 81 e8 00 00 restore case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 40006dcc: 7f ff ff 21 call 40006a50 <_Rate_monotonic_Update_statistics> 40006dd0: 90 10 00 11 mov %l1, %o0 _ISR_Enable( level ); 40006dd4: 7f ff ee fe call 400029cc 40006dd8: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 40006ddc: 82 10 20 02 mov 2, %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40006de0: f2 24 60 1c st %i1, [ %l1 + 0x1c ] the_period->next_length = length; 40006de4: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40006de8: 92 04 60 10 add %l1, 0x10, %o1 */ _Rate_monotonic_Update_statistics( the_period ); _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 40006dec: c2 24 60 38 st %g1, [ %l1 + 0x38 ] 40006df0: 11 10 00 7e sethi %hi(0x4001f800), %o0 40006df4: 40 00 15 80 call 4000c3f4 <_Watchdog_Insert> 40006df8: 90 12 23 dc or %o0, 0x3dc, %o0 ! 4001fbdc <_Watchdog_Ticks_chain> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006dfc: 07 10 00 7e sethi %hi(0x4001f800), %g3 40006e00: c2 00 e2 e0 ld [ %g3 + 0x2e0 ], %g1 ! 4001fae0 <_Thread_Dispatch_disable_level> 40006e04: b0 10 20 06 mov 6, %i0 40006e08: 82 00 7f ff add %g1, -1, %g1 40006e0c: c2 20 e2 e0 st %g1, [ %g3 + 0x2e0 ] 40006e10: c4 00 e2 e0 ld [ %g3 + 0x2e0 ], %g2 40006e14: 80 a0 a0 00 cmp %g2, 0 40006e18: 02 bf ff 87 be 40006c34 40006e1c: 01 00 00 00 nop 40006e20: 30 bf ff e9 b,a 40006dc4 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 40006e24: 80 a2 20 02 cmp %o0, 2 40006e28: 02 80 00 09 be 40006e4c 40006e2c: b0 10 20 00 clr %i0 40006e30: 80 a2 20 04 cmp %o0, 4 40006e34: 02 80 00 06 be 40006e4c 40006e38: b0 10 20 06 mov 6, %i0 40006e3c: 80 a2 20 00 cmp %o0, 0 40006e40: 02 80 00 03 be 40006e4c 40006e44: b0 10 20 0b mov 0xb, %i0 40006e48: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 40006e4c: 03 10 00 7e sethi %hi(0x4001f800), %g1 40006e50: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 4001fae0 <_Thread_Dispatch_disable_level> 40006e54: 10 bf ff 73 b 40006c20 40006e58: 84 00 bf ff add %g2, -1, %g2 * 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 ); 40006e5c: 40 00 0f 2b call 4000ab08 <_Thread_Clear_state> <== NOT EXECUTED 40006e60: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED 40006e64: 30 bf ff ce b,a 40006d9c <== NOT EXECUTED 40006e68 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 40006e68: 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 ) 40006e6c: 80 a6 60 00 cmp %i1, 0 40006e70: 02 80 00 4e be 40006fa8 40006e74: 90 10 00 18 mov %i0, %o0 return; (*print)( context, "Period information by period\n" ); 40006e78: 13 10 00 74 sethi %hi(0x4001d000), %o1 40006e7c: 9f c6 40 00 call %i1 40006e80: 92 12 60 48 or %o1, 0x48, %o1 ! 4001d048 #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 40006e84: 90 10 00 18 mov %i0, %o0 40006e88: 13 10 00 74 sethi %hi(0x4001d000), %o1 40006e8c: 9f c6 40 00 call %i1 40006e90: 92 12 60 68 or %o1, 0x68, %o1 ! 4001d068 #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 40006e94: 90 10 00 18 mov %i0, %o0 40006e98: 13 10 00 74 sethi %hi(0x4001d000), %o1 40006e9c: 9f c6 40 00 call %i1 40006ea0: 92 12 60 90 or %o1, 0x90, %o1 ! 4001d090 Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 40006ea4: 90 10 00 18 mov %i0, %o0 40006ea8: 13 10 00 74 sethi %hi(0x4001d000), %o1 40006eac: 9f c6 40 00 call %i1 40006eb0: 92 12 60 b8 or %o1, 0xb8, %o1 ! 4001d0b8 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 40006eb4: 90 10 00 18 mov %i0, %o0 40006eb8: 13 10 00 74 sethi %hi(0x4001d000), %o1 40006ebc: 9f c6 40 00 call %i1 40006ec0: 92 12 61 08 or %o1, 0x108, %o1 ! 4001d108 /* * 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 ; 40006ec4: 03 10 00 7e sethi %hi(0x4001f800), %g1 40006ec8: a6 10 61 48 or %g1, 0x148, %l3 ! 4001f948 <_Rate_monotonic_Information> 40006ecc: e4 04 e0 08 ld [ %l3 + 8 ], %l2 id <= _Rate_monotonic_Information.maximum_id ; 40006ed0: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 40006ed4: 80 a4 80 01 cmp %l2, %g1 40006ed8: 18 80 00 34 bgu 40006fa8 40006edc: 03 10 00 74 sethi %hi(0x4001d000), %g1 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 40006ee0: 05 10 00 74 sethi %hi(0x4001d000), %g2 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 40006ee4: b6 10 61 58 or %g1, 0x158, %i3 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 40006ee8: b8 10 a0 88 or %g2, 0x88, %i4 40006eec: 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 ); 40006ef0: aa 07 bf d0 add %fp, -48, %l5 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 40006ef4: ba 07 bf b0 add %fp, -80, %i5 40006ef8: ac 07 bf e8 add %fp, -24, %l6 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 40006efc: b4 07 bf c8 add %fp, -56, %i2 40006f00: 10 80 00 06 b 40006f18 40006f04: ae 07 bf f3 add %fp, -13, %l7 * 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++ ) { 40006f08: 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 ; 40006f0c: 80 a0 40 12 cmp %g1, %l2 40006f10: 0a 80 00 26 bcs 40006fa8 40006f14: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 40006f18: 90 10 00 12 mov %l2, %o0 40006f1c: 40 00 1f a5 call 4000edb0 40006f20: 92 10 00 14 mov %l4, %o1 if ( status != RTEMS_SUCCESSFUL ) 40006f24: 80 a2 20 00 cmp %o0, 0 40006f28: 32 bf ff f8 bne,a 40006f08 40006f2c: 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 ); 40006f30: 92 10 00 15 mov %l5, %o1 40006f34: 40 00 1f c5 call 4000ee48 40006f38: 90 10 00 12 mov %l2, %o0 if ( status != RTEMS_SUCCESSFUL ) 40006f3c: 80 a2 20 00 cmp %o0, 0 40006f40: 32 bf ff f2 bne,a 40006f08 40006f44: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 <== NOT EXECUTED continue; name[ 0 ] = '\0'; if ( the_status.owner ) { 40006f48: d0 07 bf d0 ld [ %fp + -48 ], %o0 /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); if ( status != RTEMS_SUCCESSFUL ) continue; name[ 0 ] = '\0'; 40006f4c: c0 2f bf f3 clrb [ %fp + -13 ] if ( the_status.owner ) { 40006f50: 80 a2 20 00 cmp %o0, 0 40006f54: 12 80 00 4b bne 40007080 40006f58: a0 10 00 17 mov %l7, %l0 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 40006f5c: d8 1f bf 98 ldd [ %fp + -104 ], %o4 <== NOT EXECUTED 40006f60: 94 10 00 12 mov %l2, %o2 40006f64: 92 10 00 1b mov %i3, %o1 40006f68: 96 10 00 10 mov %l0, %o3 40006f6c: 9f c6 40 00 call %i1 40006f70: 90 10 00 18 mov %i0, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 40006f74: c2 07 bf 98 ld [ %fp + -104 ], %g1 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 40006f78: 94 10 00 16 mov %l6, %o2 40006f7c: 90 10 00 1d mov %i5, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 40006f80: 80 a0 60 00 cmp %g1, 0 40006f84: 12 80 00 0b bne 40006fb0 40006f88: 92 10 00 1c mov %i4, %o1 (*print)( context, "\n" ); 40006f8c: 9f c6 40 00 call %i1 40006f90: 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 ; 40006f94: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 id++ ) { 40006f98: 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 ; 40006f9c: 80 a0 40 12 cmp %g1, %l2 40006fa0: 1a bf ff df bcc 40006f1c 40006fa4: 90 10 00 12 mov %l2, %o0 40006fa8: 81 c7 e0 08 ret 40006fac: 81 e8 00 00 restore */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 40006fb0: 40 00 13 fd call 4000bfa4 <_Timespec_Divide_by_integer> 40006fb4: 92 10 00 01 mov %g1, %o1 &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 40006fb8: d0 07 bf a4 ld [ %fp + -92 ], %o0 40006fbc: 40 00 49 c8 call 400196dc <.div> 40006fc0: 92 10 23 e8 mov 0x3e8, %o1 40006fc4: a2 10 00 08 mov %o0, %l1 40006fc8: d0 07 bf ac ld [ %fp + -84 ], %o0 40006fcc: 40 00 49 c4 call 400196dc <.div> 40006fd0: 92 10 23 e8 mov 0x3e8, %o1 40006fd4: c2 07 bf e8 ld [ %fp + -24 ], %g1 40006fd8: a0 10 00 08 mov %o0, %l0 40006fdc: d0 07 bf ec ld [ %fp + -20 ], %o0 40006fe0: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 40006fe4: 40 00 49 be call 400196dc <.div> 40006fe8: 92 10 23 e8 mov 0x3e8, %o1 40006fec: d8 07 bf a8 ld [ %fp + -88 ], %o4 40006ff0: d4 07 bf a0 ld [ %fp + -96 ], %o2 40006ff4: 96 10 00 11 mov %l1, %o3 40006ff8: 9a 10 00 10 mov %l0, %o5 40006ffc: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 40007000: 13 10 00 74 sethi %hi(0x4001d000), %o1 40007004: 90 10 00 18 mov %i0, %o0 40007008: 9f c6 40 00 call %i1 4000700c: 92 12 61 70 or %o1, 0x170, %o1 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 40007010: d2 07 bf 98 ld [ %fp + -104 ], %o1 40007014: 94 10 00 16 mov %l6, %o2 40007018: 40 00 13 e3 call 4000bfa4 <_Timespec_Divide_by_integer> 4000701c: 90 10 00 1a mov %i2, %o0 &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 40007020: d0 07 bf bc ld [ %fp + -68 ], %o0 40007024: 40 00 49 ae call 400196dc <.div> 40007028: 92 10 23 e8 mov 0x3e8, %o1 4000702c: a2 10 00 08 mov %o0, %l1 40007030: d0 07 bf c4 ld [ %fp + -60 ], %o0 40007034: 40 00 49 aa call 400196dc <.div> 40007038: 92 10 23 e8 mov 0x3e8, %o1 4000703c: c2 07 bf e8 ld [ %fp + -24 ], %g1 40007040: a0 10 00 08 mov %o0, %l0 40007044: d0 07 bf ec ld [ %fp + -20 ], %o0 40007048: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 4000704c: 40 00 49 a4 call 400196dc <.div> 40007050: 92 10 23 e8 mov 0x3e8, %o1 40007054: d4 07 bf b8 ld [ %fp + -72 ], %o2 40007058: d8 07 bf c0 ld [ %fp + -64 ], %o4 4000705c: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 40007060: 96 10 00 11 mov %l1, %o3 40007064: 9a 10 00 10 mov %l0, %o5 40007068: 90 10 00 18 mov %i0, %o0 4000706c: 13 10 00 74 sethi %hi(0x4001d000), %o1 40007070: 9f c6 40 00 call %i1 40007074: 92 12 61 90 or %o1, 0x190, %o1 ! 4001d190 /* * 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 ; 40007078: 10 bf ff a4 b 40006f08 4000707c: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 continue; name[ 0 ] = '\0'; if ( the_status.owner ) { rtems_object_get_name( the_status.owner, sizeof(name), name ); 40007080: 92 10 20 05 mov 5, %o1 40007084: 40 00 00 8f call 400072c0 40007088: 94 10 00 17 mov %l7, %o2 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 4000708c: 10 bf ff b5 b 40006f60 40007090: d8 1f bf 98 ldd [ %fp + -104 ], %o4 400070b0 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 400070b0: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400070b4: 25 10 00 7e sethi %hi(0x4001f800), %l2 400070b8: c2 04 a2 e0 ld [ %l2 + 0x2e0 ], %g1 ! 4001fae0 <_Thread_Dispatch_disable_level> 400070bc: 82 00 60 01 inc %g1 400070c0: c2 24 a2 e0 st %g1, [ %l2 + 0x2e0 ] /* * 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 ; 400070c4: 03 10 00 7e sethi %hi(0x4001f800), %g1 400070c8: a2 10 61 48 or %g1, 0x148, %l1 ! 4001f948 <_Rate_monotonic_Information> 400070cc: e0 04 60 08 ld [ %l1 + 8 ], %l0 id <= _Rate_monotonic_Information.maximum_id ; 400070d0: c2 04 60 0c ld [ %l1 + 0xc ], %g1 400070d4: 80 a4 00 01 cmp %l0, %g1 400070d8: 18 80 00 09 bgu 400070fc 400070dc: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 400070e0: 40 00 00 13 call 4000712c 400070e4: 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 ; 400070e8: c2 04 60 0c ld [ %l1 + 0xc ], %g1 id++ ) { 400070ec: 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 ; 400070f0: 80 a0 40 10 cmp %g1, %l0 400070f4: 1a bf ff fb bcc 400070e0 400070f8: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400070fc: c2 04 a2 e0 ld [ %l2 + 0x2e0 ], %g1 40007100: 82 00 7f ff add %g1, -1, %g1 40007104: c2 24 a2 e0 st %g1, [ %l2 + 0x2e0 ] 40007108: c4 04 a2 e0 ld [ %l2 + 0x2e0 ], %g2 4000710c: 80 a0 a0 00 cmp %g2, 0 40007110: 02 80 00 04 be 40007120 40007114: 01 00 00 00 nop 40007118: 81 c7 e0 08 ret <== NOT EXECUTED 4000711c: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40007120: 40 00 0f 2f call 4000addc <_Thread_Dispatch> 40007124: 81 e8 00 00 restore 40007128: 01 00 00 00 nop 40010114 : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 40010114: 9d e3 bf 98 save %sp, -104, %sp Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 40010118: a8 96 20 00 orcc %i0, 0, %l4 4001011c: 02 80 00 58 be 4001027c 40010120: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 40010124: 80 a6 60 00 cmp %i1, 0 40010128: 02 80 00 06 be 40010140 4001012c: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 40010130: 02 80 00 04 be 40010140 40010134: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 40010138: 02 80 00 04 be 40010148 4001013c: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40010140: 81 c7 e0 08 ret 40010144: 91 e8 20 09 restore %g0, 9, %o0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 40010148: 7f ff ea 73 call 4000ab14 4001014c: 01 00 00 00 nop 40010150: a2 10 00 08 mov %o0, %l1 40010154: 25 10 00 d3 sethi %hi(0x40034c00), %l2 40010158: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 4001015c: 80 a0 60 00 cmp %g1, 0 40010160: 02 80 00 0b be 4001018c 40010164: 03 10 00 d3 sethi %hi(0x40034c00), %g1 40010168: 03 10 00 d3 sethi %hi(0x40034c00), %g1 <== NOT EXECUTED 4001016c: c4 00 62 60 ld [ %g1 + 0x260 ], %g2 ! 40034e60 <_System_state_Current> <== NOT EXECUTED 40010170: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40010174: 08 80 00 05 bleu 40010188 <== NOT EXECUTED 40010178: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001017c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010180: 40 00 13 7d call 40014f74 <_Internal_error_Occurred> <== NOT EXECUTED 40010184: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40010188: 03 10 00 d3 sethi %hi(0x40034c00), %g1 <== NOT EXECUTED 4001018c: 27 10 00 d3 sethi %hi(0x40034c00), %l3 40010190: c6 00 61 5c ld [ %g1 + 0x15c ], %g3 40010194: e0 04 e1 54 ld [ %l3 + 0x154 ], %l0 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40010198: c0 20 e0 34 clr [ %g3 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 4001019c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 400101a0: 80 a0 60 00 cmp %g1, 0 400101a4: 22 80 00 12 be,a 400101ec 400101a8: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 400101ac: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400101b0: c2 00 e0 08 ld [ %g3 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 400101b4: c4 04 20 58 ld [ %l0 + 0x58 ], %g2 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; the_mutex->nest_count = 1; 400101b8: 88 10 20 01 mov 1, %g4 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; 400101bc: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 400101c0: c6 24 20 6c st %g3, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400101c4: 80 a0 a0 02 cmp %g2, 2 400101c8: 12 80 00 2f bne 40010284 400101cc: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400101d0: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 400101d4: 82 00 60 01 inc %g1 400101d8: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 400101dc: 7f ff ea 52 call 4000ab24 400101e0: 90 10 00 11 mov %l1, %o0 * the inactive chain of free region control blocks. */ RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void ) { return (Region_Control *) _Objects_Allocate( &_Region_Information ); 400101e4: 10 80 00 0f b 40010220 400101e8: 23 10 00 d2 sethi %hi(0x40034800), %l1 /* * 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 ) ) { 400101ec: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 400101f0: 32 80 00 48 bne,a 40010310 <== NOT EXECUTED 400101f4: c4 04 20 08 ld [ %l0 + 8 ], %g2 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400101f8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400101fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40010200: 12 80 00 41 bne 40010304 <== NOT EXECUTED 40010204: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40010208: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 4001020c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010210: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40010214: 7f ff ea 44 call 4000ab24 <== NOT EXECUTED 40010218: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 4001021c: 23 10 00 d2 sethi %hi(0x40034800), %l1 <== NOT EXECUTED 40010220: 40 00 13 82 call 40015028 <_Objects_Allocate> 40010224: 90 14 62 98 or %l1, 0x298, %o0 ! 40034a98 <_Region_Information> the_region = _Region_Allocate(); if ( !the_region ) { 40010228: a0 92 20 00 orcc %o0, 0, %l0 4001022c: 32 80 00 4e bne,a 40010364 40010230: 90 04 20 68 add %l0, 0x68, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010234: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 40010238: 82 00 60 01 inc %g1 4001023c: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] _RTEMS_Unlock_allocator(); 40010240: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 40010244: 94 10 20 00 clr %o2 40010248: d2 02 20 08 ld [ %o0 + 8 ], %o1 4001024c: 40 00 10 d1 call 40014590 <_CORE_mutex_Surrender> 40010250: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010254: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 40010258: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 4001025c: 82 00 7f ff add %g1, -1, %g1 40010260: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] 40010264: c4 04 a0 80 ld [ %l2 + 0x80 ], %g2 40010268: 80 a0 a0 00 cmp %g2, 0 4001026c: 12 80 00 04 bne 4001027c 40010270: 01 00 00 00 nop 40010274: 40 00 19 fa call 40016a5c <_Thread_Dispatch> 40010278: 01 00 00 00 nop 4001027c: 81 c7 e0 08 ret 40010280: 81 e8 00 00 restore if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40010284: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 40010288: 12 bf ff d5 bne 400101dc <== NOT EXECUTED 4001028c: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40010290: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 40010294: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40010298: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001029c: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 400102a0: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED current = executing->current_priority; if ( current == ceiling ) { 400102a4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 400102a8: 02 80 00 4e be 400103e0 <== NOT EXECUTED 400102ac: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 400102b0: 1a 80 00 42 bcc 400103b8 <== NOT EXECUTED 400102b4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400102b8: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 <== NOT EXECUTED 400102bc: 82 00 60 01 inc %g1 <== NOT EXECUTED 400102c0: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 400102c4: 7f ff ea 18 call 4000ab24 <== NOT EXECUTED 400102c8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 400102cc: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 400102d0: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 400102d4: 40 00 18 be call 400165cc <_Thread_Change_priority> <== NOT EXECUTED 400102d8: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400102dc: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 <== NOT EXECUTED 400102e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400102e4: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] <== NOT EXECUTED 400102e8: c4 04 a0 80 ld [ %l2 + 0x80 ], %g2 <== NOT EXECUTED 400102ec: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400102f0: 12 bf ff cc bne 40010220 <== NOT EXECUTED 400102f4: 23 10 00 d2 sethi %hi(0x40034800), %l1 <== NOT EXECUTED _Thread_Dispatch(); 400102f8: 40 00 19 d9 call 40016a5c <_Thread_Dispatch> <== NOT EXECUTED 400102fc: 01 00 00 00 nop <== NOT EXECUTED 40010300: 30 bf ff c8 b,a 40010220 <== NOT EXECUTED * 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 ) { 40010304: 02 80 00 13 be 40010350 <== NOT EXECUTED 40010308: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 4001030c: c4 04 20 08 ld [ %l0 + 8 ], %g2 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010310: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 <== NOT EXECUTED 40010314: c4 20 e0 20 st %g2, [ %g3 + 0x20 ] <== NOT EXECUTED 40010318: 82 00 60 01 inc %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 4001031c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 40010320: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] <== NOT EXECUTED 40010324: c4 24 20 40 st %g2, [ %l0 + 0x40 ] <== NOT EXECUTED 40010328: 82 04 20 10 add %l0, 0x10, %g1 <== NOT EXECUTED 4001032c: c2 20 e0 44 st %g1, [ %g3 + 0x44 ] <== NOT EXECUTED 40010330: 7f ff e9 fd call 4000ab24 <== NOT EXECUTED 40010334: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40010338: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 <== NOT EXECUTED 4001033c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010340: 40 00 10 70 call 40014500 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40010344: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40010348: 10 bf ff b6 b 40010220 <== NOT EXECUTED 4001034c: 23 10 00 d2 sethi %hi(0x40034800), %l1 <== NOT EXECUTED 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; 40010350: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40010354: 7f ff e9 f4 call 4000ab24 <== NOT EXECUTED 40010358: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 4001035c: 10 bf ff b1 b 40010220 <== NOT EXECUTED 40010360: 23 10 00 d2 sethi %hi(0x40034800), %l1 <== NOT EXECUTED if ( !the_region ) { _RTEMS_Unlock_allocator(); return RTEMS_TOO_MANY; } the_region->maximum_segment_size = 40010364: 92 10 00 19 mov %i1, %o1 40010368: 94 10 00 1a mov %i2, %o2 4001036c: 40 00 12 b5 call 40014e40 <_Heap_Initialize> 40010370: 96 10 00 1b mov %i3, %o3 _Heap_Initialize(&the_region->Memory, starting_address, length, page_size); if ( !the_region->maximum_segment_size ) { 40010374: 80 a2 20 00 cmp %o0, 0 40010378: 12 80 00 1e bne 400103f0 4001037c: d0 24 20 5c st %o0, [ %l0 + 0x5c ] RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 40010380: 90 14 62 98 or %l1, 0x298, %o0 40010384: 40 00 14 37 call 40015460 <_Objects_Free> 40010388: 92 10 00 10 mov %l0, %o1 4001038c: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 40010390: 82 00 60 01 inc %g1 40010394: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 40010398: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 4001039c: 94 10 20 00 clr %o2 400103a0: d2 02 20 08 ld [ %o0 + 8 ], %o1 400103a4: 40 00 10 7b call 40014590 <_CORE_mutex_Surrender> 400103a8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400103ac: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 400103b0: 10 bf ff ab b 4001025c 400103b4: b0 10 20 08 mov 8, %i0 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 400103b8: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400103bc: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 400103c0: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 400103c4: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 400103c8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400103cc: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400103d0: 7f ff e9 d5 call 4000ab24 <== NOT EXECUTED 400103d4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED * the inactive chain of free region control blocks. */ RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void ) { return (Region_Control *) _Objects_Allocate( &_Region_Information ); 400103d8: 10 bf ff 92 b 40010220 <== NOT EXECUTED 400103dc: 23 10 00 d2 sethi %hi(0x40034800), %l1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 400103e0: 7f ff e9 d1 call 4000ab24 <== NOT EXECUTED 400103e4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400103e8: 10 bf ff 8e b 40010220 <== NOT EXECUTED 400103ec: 23 10 00 d2 sethi %hi(0x40034800), %l1 <== NOT EXECUTED the_region->length = length; the_region->page_size = page_size; the_region->attribute_set = attribute_set; the_region->number_of_used_blocks = 0; _Thread_queue_Initialize( 400103f0: 90 04 20 10 add %l0, 0x10, %o0 _Region_Free( the_region ); _RTEMS_Unlock_allocator(); return RTEMS_INVALID_SIZE; } the_region->starting_address = starting_address; 400103f4: f2 24 20 50 st %i1, [ %l0 + 0x50 ] the_region->length = length; 400103f8: f4 24 20 54 st %i2, [ %l0 + 0x54 ] the_region->page_size = page_size; 400103fc: f6 24 20 58 st %i3, [ %l0 + 0x58 ] the_region->attribute_set = attribute_set; 40010400: f8 24 20 60 st %i4, [ %l0 + 0x60 ] the_region->number_of_used_blocks = 0; 40010404: c0 24 20 64 clr [ %l0 + 0x64 ] _Thread_queue_Initialize( 40010408: 93 37 20 02 srl %i4, 2, %o1 4001040c: 94 10 20 40 mov 0x40, %o2 40010410: 92 0a 60 01 and %o1, 1, %o1 40010414: 40 00 1c 10 call 40017454 <_Thread_queue_Initialize> 40010418: 96 10 20 06 mov 6, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4001041c: 90 14 62 98 or %l1, 0x298, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40010420: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40010424: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40010428: 03 00 00 3f sethi %hi(0xfc00), %g1 4001042c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40010430: 82 08 c0 01 and %g3, %g1, %g1 40010434: 80 a0 40 02 cmp %g1, %g2 40010438: 38 80 00 06 bgu,a 40010450 4001043c: c6 27 40 00 st %g3, [ %i5 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40010440: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40010444: 83 28 60 02 sll %g1, 2, %g1 40010448: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 4001044c: c6 27 40 00 st %g3, [ %i5 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010450: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 40010454: e8 24 20 0c st %l4, [ %l0 + 0xc ] 40010458: 82 00 60 01 inc %g1 4001045c: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] _RTEMS_Unlock_allocator(); 40010460: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 40010464: 94 10 20 00 clr %o2 40010468: d2 02 20 08 ld [ %o0 + 8 ], %o1 4001046c: 40 00 10 49 call 40014590 <_CORE_mutex_Surrender> 40010470: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010474: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 40010478: 10 bf ff 79 b 4001025c 4001047c: b0 10 20 00 clr %i0 40010480 : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 40010480: 9d e3 bf 90 save %sp, -112, %sp register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 40010484: 7f ff e9 a4 call 4000ab14 40010488: 01 00 00 00 nop 4001048c: a2 10 00 08 mov %o0, %l1 40010490: 25 10 00 d3 sethi %hi(0x40034c00), %l2 40010494: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 40010498: 80 a0 60 00 cmp %g1, 0 4001049c: 02 80 00 0b be 400104c8 400104a0: 27 10 00 d3 sethi %hi(0x40034c00), %l3 400104a4: 03 10 00 d3 sethi %hi(0x40034c00), %g1 <== NOT EXECUTED 400104a8: c4 00 62 60 ld [ %g1 + 0x260 ], %g2 ! 40034e60 <_System_state_Current> <== NOT EXECUTED 400104ac: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 400104b0: 08 80 00 06 bleu 400104c8 <== NOT EXECUTED 400104b4: 90 10 20 00 clr %o0 <== NOT EXECUTED 400104b8: 92 10 20 00 clr %o1 <== NOT EXECUTED 400104bc: 40 00 12 ae call 40014f74 <_Internal_error_Occurred> <== NOT EXECUTED 400104c0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400104c4: 27 10 00 d3 sethi %hi(0x40034c00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400104c8: 09 10 00 d3 sethi %hi(0x40034c00), %g4 400104cc: e0 04 e1 54 ld [ %l3 + 0x154 ], %l0 400104d0: c4 01 21 5c ld [ %g4 + 0x15c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 400104d4: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 400104d8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 400104dc: 80 a0 60 00 cmp %g1, 0 400104e0: 22 80 00 36 be,a 400105b8 400104e4: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 400104e8: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400104ec: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 400104f0: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; the_mutex->nest_count = 1; 400104f4: 88 10 20 01 mov 1, %g4 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; 400104f8: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 400104fc: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40010500: 80 a0 e0 02 cmp %g3, 2 40010504: 12 80 00 56 bne 4001065c 40010508: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4001050c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010510: 80 a0 e0 03 cmp %g3, 3 the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40010514: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010518: 02 80 00 7c be 40010708 4001051c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 40010520: 7f ff e9 81 call 4000ab24 40010524: 90 10 00 11 mov %l1, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 40010528: 92 10 00 18 mov %i0, %o1 4001052c: 21 10 00 d2 sethi %hi(0x40034800), %l0 40010530: 94 07 bf f4 add %fp, -12, %o2 40010534: 40 00 14 0e call 4001556c <_Objects_Get_no_protection> 40010538: 90 14 22 98 or %l0, 0x298, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 4001053c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40010540: 80 a0 60 01 cmp %g1, 1 40010544: 02 80 00 33 be 40010610 40010548: 92 10 00 08 mov %o0, %o1 4001054c: 80 a0 60 01 cmp %g1, 1 40010550: 1a 80 00 5f bcc 400106cc 40010554: 80 a0 60 02 cmp %g1, 2 _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks == 0 ) { 40010558: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 4001055c: 80 a0 60 00 cmp %g1, 0 40010560: 22 80 00 99 be,a 400107c4 40010564: 90 14 22 98 or %l0, 0x298, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010568: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 4001056c: 82 00 60 01 inc %g1 40010570: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } _RTEMS_Unlock_allocator(); 40010574: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 40010578: 94 10 20 00 clr %o2 4001057c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010580: 40 00 10 04 call 40014590 <_CORE_mutex_Surrender> 40010584: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010588: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 4001058c: b0 10 20 0c mov 0xc, %i0 40010590: 82 00 7f ff add %g1, -1, %g1 40010594: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] 40010598: c4 04 a0 80 ld [ %l2 + 0x80 ], %g2 4001059c: 80 a0 a0 00 cmp %g2, 0 400105a0: 12 80 00 49 bne 400106c4 400105a4: 01 00 00 00 nop _Thread_Dispatch(); 400105a8: 40 00 19 2d call 40016a5c <_Thread_Dispatch> 400105ac: 01 00 00 00 nop 400105b0: 81 c7 e0 08 ret 400105b4: 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 ) ) { 400105b8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400105bc: 12 80 00 30 bne 4001067c <== NOT EXECUTED 400105c0: c6 04 e1 54 ld [ %l3 + 0x154 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400105c4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400105c8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400105cc: 22 80 00 6a be,a 40010774 <== NOT EXECUTED 400105d0: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 400105d4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400105d8: 12 80 00 29 bne 4001067c <== NOT EXECUTED 400105dc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 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; 400105e0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400105e4: 7f ff e9 50 call 4000ab24 <== NOT EXECUTED 400105e8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400105ec: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 400105f0: 21 10 00 d2 sethi %hi(0x40034800), %l0 <== NOT EXECUTED 400105f4: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 400105f8: 40 00 13 dd call 4001556c <_Objects_Get_no_protection> <== NOT EXECUTED 400105fc: 90 14 22 98 or %l0, 0x298, %o0 <== NOT EXECUTED register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 40010600: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 40010604: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40010608: 12 bf ff d2 bne 40010550 <== NOT EXECUTED 4001060c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010610: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 <== NOT EXECUTED 40010614: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010618: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 4001061c: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 <== NOT EXECUTED 40010620: 94 10 20 00 clr %o2 <== NOT EXECUTED 40010624: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40010628: 40 00 0f da call 40014590 <_CORE_mutex_Surrender> <== NOT EXECUTED 4001062c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010630: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 <== NOT EXECUTED 40010634: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010638: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] <== NOT EXECUTED 4001063c: c4 04 a0 80 ld [ %l2 + 0x80 ], %g2 <== NOT EXECUTED 40010640: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40010644: 12 80 00 24 bne 400106d4 <== NOT EXECUTED 40010648: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4001064c: 40 00 19 04 call 40016a5c <_Thread_Dispatch> <== NOT EXECUTED 40010650: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 40010654: 81 c7 e0 08 ret <== NOT EXECUTED 40010658: 81 e8 00 00 restore <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4001065c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40010660: 12 bf ff b0 bne 40010520 <== NOT EXECUTED 40010664: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40010668: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4001066c: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010670: 02 80 00 26 be 40010708 <== NOT EXECUTED 40010674: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40010678: 30 bf ff aa b,a 40010520 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001067c: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 <== NOT EXECUTED ) { register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 40010680: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40010684: c8 01 21 5c ld [ %g4 + 0x15c ], %g4 <== NOT EXECUTED 40010688: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001068c: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40010690: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] <== NOT EXECUTED 40010694: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40010698: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4001069c: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 400106a0: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 400106a4: 7f ff e9 20 call 4000ab24 <== NOT EXECUTED 400106a8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400106ac: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 <== NOT EXECUTED 400106b0: 92 10 20 00 clr %o1 <== NOT EXECUTED 400106b4: 40 00 0f 93 call 40014500 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 400106b8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 400106bc: 10 bf ff 9c b 4001052c <== NOT EXECUTED 400106c0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _RTEMS_Unlock_allocator(); return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400106c4: 81 c7 e0 08 ret <== NOT EXECUTED 400106c8: 81 e8 00 00 restore <== NOT EXECUTED register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 400106cc: 02 80 00 04 be 400106dc 400106d0: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 400106d4: 81 c7 e0 08 ret <== NOT EXECUTED 400106d8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400106dc: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 400106e0: 82 00 60 01 inc %g1 400106e4: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 400106e8: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 400106ec: 94 10 20 00 clr %o2 400106f0: d2 02 20 08 ld [ %o0 + 8 ], %o1 400106f4: 40 00 0f a7 call 40014590 <_CORE_mutex_Surrender> 400106f8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400106fc: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 40010700: 10 bf ff a4 b 40010590 40010704: b0 10 20 04 mov 4, %i0 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40010708: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 4001070c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40010710: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40010714: 02 80 00 28 be 400107b4 <== NOT EXECUTED 40010718: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 4001071c: 1a 80 00 1c bcc 4001078c <== NOT EXECUTED 40010720: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010724: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 <== NOT EXECUTED 40010728: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001072c: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40010730: 7f ff e8 fd call 4000ab24 <== NOT EXECUTED 40010734: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 40010738: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 4001073c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40010740: 40 00 17 a3 call 400165cc <_Thread_Change_priority> <== NOT EXECUTED 40010744: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010748: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 <== NOT EXECUTED 4001074c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010750: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] <== NOT EXECUTED 40010754: c4 04 a0 80 ld [ %l2 + 0x80 ], %g2 <== NOT EXECUTED 40010758: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001075c: 32 bf ff 74 bne,a 4001052c <== NOT EXECUTED 40010760: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _Thread_Dispatch(); 40010764: 40 00 18 be call 40016a5c <_Thread_Dispatch> <== NOT EXECUTED 40010768: 01 00 00 00 nop <== NOT EXECUTED 4001076c: 10 bf ff 70 b 4001052c <== NOT EXECUTED 40010770: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED * 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++; 40010774: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010778: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 4001077c: 7f ff e8 ea call 4000ab24 <== NOT EXECUTED 40010780: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40010784: 10 bf ff 6a b 4001052c <== NOT EXECUTED 40010788: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 4001078c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40010790: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40010794: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40010798: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4001079c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400107a0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400107a4: 7f ff e8 e0 call 4000ab24 <== NOT EXECUTED 400107a8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400107ac: 10 bf ff 60 b 4001052c <== NOT EXECUTED 400107b0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 400107b4: 7f ff e8 dc call 4000ab24 <== NOT EXECUTED 400107b8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400107bc: 10 bf ff 5c b 4001052c <== NOT EXECUTED 400107c0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 400107c4: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400107c8: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 400107cc: 05 00 00 3f sethi %hi(0xfc00), %g2 400107d0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 400107d4: 82 08 40 02 and %g1, %g2, %g1 400107d8: 80 a0 40 03 cmp %g1, %g3 400107dc: 18 80 00 05 bgu 400107f0 400107e0: 01 00 00 00 nop information->local_table[ index ] = the_object; 400107e4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400107e8: 83 28 60 02 sll %g1, 2, %g1 400107ec: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 400107f0: 40 00 13 1c call 40015460 <_Objects_Free> 400107f4: c0 22 60 0c clr [ %o1 + 0xc ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400107f8: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 400107fc: 82 00 60 01 inc %g1 40010800: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks == 0 ) { _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 40010804: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 40010808: 94 10 20 00 clr %o2 4001080c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010810: 40 00 0f 60 call 40014590 <_CORE_mutex_Surrender> 40010814: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010818: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 4001081c: 10 bf ff 5d b 40010590 40010820: b0 10 20 00 clr %i0 40010824 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 40010824: 9d e3 bf 90 save %sp, -112, %sp 40010828: a8 10 00 18 mov %i0, %l4 Objects_Locations location; uint32_t amount_extended; Heap_Extend_status heap_status; rtems_status_code status; if ( !starting_address ) 4001082c: 80 a6 60 00 cmp %i1, 0 40010830: 02 80 00 59 be 40010994 40010834: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 40010838: 7f ff e8 b7 call 4000ab14 4001083c: 01 00 00 00 nop 40010840: a4 10 00 08 mov %o0, %l2 40010844: 23 10 00 d3 sethi %hi(0x40034c00), %l1 40010848: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 4001084c: 80 a0 60 00 cmp %g1, 0 40010850: 02 80 00 0b be 4001087c 40010854: 27 10 00 d3 sethi %hi(0x40034c00), %l3 40010858: 03 10 00 d3 sethi %hi(0x40034c00), %g1 <== NOT EXECUTED 4001085c: c4 00 62 60 ld [ %g1 + 0x260 ], %g2 ! 40034e60 <_System_state_Current> <== NOT EXECUTED 40010860: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40010864: 08 80 00 06 bleu 4001087c <== NOT EXECUTED 40010868: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001086c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010870: 40 00 11 c1 call 40014f74 <_Internal_error_Occurred> <== NOT EXECUTED 40010874: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40010878: 27 10 00 d3 sethi %hi(0x40034c00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 4001087c: 09 10 00 d3 sethi %hi(0x40034c00), %g4 40010880: e0 04 e1 54 ld [ %l3 + 0x154 ], %l0 40010884: c4 01 21 5c ld [ %g4 + 0x15c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40010888: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 4001088c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40010890: 80 a0 60 00 cmp %g1, 0 40010894: 22 80 00 42 be,a 4001099c 40010898: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 4001089c: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400108a0: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 400108a4: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; the_mutex->nest_count = 1; 400108a8: 88 10 20 01 mov 1, %g4 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; 400108ac: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 400108b0: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400108b4: 80 a0 e0 02 cmp %g3, 2 400108b8: 02 80 00 61 be 40010a3c 400108bc: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 400108c0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 400108c4: 22 80 00 60 be,a 40010a44 <== NOT EXECUTED 400108c8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 400108cc: 7f ff e8 96 call 4000ab24 400108d0: 90 10 00 12 mov %l2, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 400108d4: 92 10 00 14 mov %l4, %o1 400108d8: 11 10 00 d2 sethi %hi(0x40034800), %o0 400108dc: 94 07 bf f4 add %fp, -12, %o2 400108e0: 40 00 13 23 call 4001556c <_Objects_Get_no_protection> 400108e4: 90 12 22 98 or %o0, 0x298, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 400108e8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400108ec: 80 a0 60 01 cmp %g1, 1 400108f0: 02 80 00 40 be 400109f0 400108f4: a0 10 00 08 mov %o0, %l0 400108f8: 80 a0 60 01 cmp %g1, 1 400108fc: 1a 80 00 70 bcc 40010abc 40010900: 80 a0 60 02 cmp %g1, 2 _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: heap_status = _Heap_Extend( 40010904: 92 10 00 19 mov %i1, %o1 40010908: 94 10 00 1a mov %i2, %o2 4001090c: 90 02 20 68 add %o0, 0x68, %o0 40010910: 96 07 bf f0 add %fp, -16, %o3 40010914: 40 00 10 65 call 40014aa8 <_Heap_Extend> 40010918: b0 10 20 09 mov 9, %i0 starting_address, length, &amount_extended ); switch ( heap_status ) { 4001091c: 80 a2 20 01 cmp %o0, 1 40010920: 02 80 00 0c be 40010950 40010924: 01 00 00 00 nop 40010928: 1a 80 00 8e bcc 40010b60 4001092c: 82 1a 20 02 xor %o0, 2, %g1 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 40010930: c6 07 bf f0 ld [ %fp + -16 ], %g3 40010934: c4 04 20 54 ld [ %l0 + 0x54 ], %g2 the_region->maximum_segment_size += amount_extended; 40010938: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 4001093c: 84 00 80 03 add %g2, %g3, %g2 the_region->maximum_segment_size += amount_extended; 40010940: 82 00 40 03 add %g1, %g3, %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 40010944: c4 24 20 54 st %g2, [ %l0 + 0x54 ] the_region->maximum_segment_size += amount_extended; 40010948: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 4001094c: b0 10 20 00 clr %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010950: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010954: 82 00 60 01 inc %g1 40010958: c2 24 60 80 st %g1, [ %l1 + 0x80 ] break; case HEAP_EXTEND_NOT_IMPLEMENTED: status = RTEMS_NOT_IMPLEMENTED; break; } _RTEMS_Unlock_allocator(); 4001095c: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 40010960: 94 10 20 00 clr %o2 40010964: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010968: 40 00 0f 0a call 40014590 <_CORE_mutex_Surrender> 4001096c: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010970: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010974: 82 00 7f ff add %g1, -1, %g1 40010978: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 4001097c: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 40010980: 80 a0 a0 00 cmp %g2, 0 40010984: 12 80 00 2c bne 40010a34 40010988: 01 00 00 00 nop _Thread_Dispatch(); 4001098c: 40 00 18 34 call 40016a5c <_Thread_Dispatch> 40010990: 01 00 00 00 nop 40010994: 81 c7 e0 08 ret 40010998: 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 ) ) { 4001099c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400109a0: 12 80 00 4d bne 40010ad4 <== NOT EXECUTED 400109a4: c6 04 e1 54 ld [ %l3 + 0x154 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400109a8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400109ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400109b0: 12 80 00 47 bne 40010acc <== NOT EXECUTED 400109b4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 400109b8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 400109bc: 82 00 60 01 inc %g1 <== NOT EXECUTED 400109c0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400109c4: 7f ff e8 58 call 4000ab24 <== NOT EXECUTED 400109c8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400109cc: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 400109d0: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED 400109d4: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 400109d8: 40 00 12 e5 call 4001556c <_Objects_Get_no_protection> <== NOT EXECUTED 400109dc: 90 12 22 98 or %o0, 0x298, %o0 <== NOT EXECUTED status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 400109e0: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 400109e4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400109e8: 12 bf ff c5 bne 400108fc <== NOT EXECUTED 400109ec: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400109f0: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 400109f4: 82 00 60 01 inc %g1 <== NOT EXECUTED 400109f8: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 400109fc: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 <== NOT EXECUTED 40010a00: 94 10 20 00 clr %o2 <== NOT EXECUTED 40010a04: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40010a08: 40 00 0e e2 call 40014590 <_CORE_mutex_Surrender> <== NOT EXECUTED 40010a0c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010a10: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 40010a14: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010a18: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED 40010a1c: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 <== NOT EXECUTED 40010a20: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40010a24: 12 80 00 28 bne 40010ac4 <== NOT EXECUTED 40010a28: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 40010a2c: 40 00 18 0c call 40016a5c <_Thread_Dispatch> <== NOT EXECUTED 40010a30: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 40010a34: 81 c7 e0 08 ret <== NOT EXECUTED 40010a38: 81 e8 00 00 restore <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40010a3c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010a40: 80 a0 e0 03 cmp %g3, 3 the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40010a44: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010a48: 12 bf ff a1 bne 400108cc 40010a4c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40010a50: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40010a54: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40010a58: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40010a5c: 02 80 00 50 be 40010b9c <== NOT EXECUTED 40010a60: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40010a64: 1a 80 00 44 bcc 40010b74 <== NOT EXECUTED 40010a68: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010a6c: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 40010a70: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010a74: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40010a78: 7f ff e8 2b call 4000ab24 <== NOT EXECUTED 40010a7c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40010a80: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40010a84: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40010a88: 40 00 16 d1 call 400165cc <_Thread_Change_priority> <== NOT EXECUTED 40010a8c: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010a90: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 40010a94: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010a98: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED 40010a9c: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 <== NOT EXECUTED 40010aa0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40010aa4: 32 bf ff 8d bne,a 400108d8 <== NOT EXECUTED 40010aa8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED _Thread_Dispatch(); 40010aac: 40 00 17 ec call 40016a5c <_Thread_Dispatch> <== NOT EXECUTED 40010ab0: 01 00 00 00 nop <== NOT EXECUTED 40010ab4: 10 bf ff 89 b 400108d8 <== NOT EXECUTED 40010ab8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 40010abc: 02 80 00 18 be 40010b1c 40010ac0: 01 00 00 00 nop 40010ac4: 81 c7 e0 08 ret <== NOT EXECUTED 40010ac8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * 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 ) { 40010acc: 02 80 00 1f be 40010b48 <== NOT EXECUTED 40010ad0: c6 04 e1 54 ld [ %l3 + 0x154 ], %g3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010ad4: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED if ( !starting_address ) return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 40010ad8: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40010adc: c8 01 21 5c ld [ %g4 + 0x15c ], %g4 <== NOT EXECUTED 40010ae0: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010ae4: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40010ae8: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED 40010aec: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40010af0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40010af4: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40010af8: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40010afc: 7f ff e8 0a call 4000ab24 <== NOT EXECUTED 40010b00: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010b04: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 <== NOT EXECUTED 40010b08: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010b0c: 40 00 0e 7d call 40014500 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40010b10: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40010b14: 10 bf ff 71 b 400108d8 <== NOT EXECUTED 40010b18: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 40010b1c: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010b20: 82 00 60 01 inc %g1 40010b24: c2 24 60 80 st %g1, [ %l1 + 0x80 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40010b28: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 40010b2c: 94 10 20 00 clr %o2 40010b30: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010b34: 40 00 0e 97 call 40014590 <_CORE_mutex_Surrender> 40010b38: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010b3c: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010b40: 10 bf ff 8d b 40010974 40010b44: b0 10 20 04 mov 4, %i0 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; 40010b48: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40010b4c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40010b50: 7f ff e7 f5 call 4000ab24 <== NOT EXECUTED 40010b54: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010b58: 10 bf ff 60 b 400108d8 <== NOT EXECUTED 40010b5c: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 40010b60: 80 a0 00 01 cmp %g0, %g1 40010b64: 84 60 20 00 subx %g0, 0, %g2 40010b68: b0 08 bf e8 and %g2, -24, %i0 40010b6c: 10 bf ff 79 b 40010950 40010b70: b0 06 20 18 add %i0, 0x18, %i0 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40010b74: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40010b78: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40010b7c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40010b80: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40010b84: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010b88: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40010b8c: 7f ff e7 e6 call 4000ab24 <== NOT EXECUTED 40010b90: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010b94: 10 bf ff 51 b 400108d8 <== NOT EXECUTED 40010b98: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40010b9c: 7f ff e7 e2 call 4000ab24 <== NOT EXECUTED 40010ba0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010ba4: 10 bf ff 4d b 400108d8 <== NOT EXECUTED 40010ba8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 40010bac : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 40010bac: 9d e3 bf 90 save %sp, -112, %sp 40010bb0: aa 10 00 18 mov %i0, %l5 register Region_Control *the_region; Objects_Locations location; Thread_Control *executing; void *the_segment; if ( !segment ) 40010bb4: 80 a7 20 00 cmp %i4, 0 40010bb8: 02 80 00 4e be 40010cf0 40010bbc: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; *segment = NULL; if ( size == 0 ) 40010bc0: 80 a6 60 00 cmp %i1, 0 40010bc4: 02 80 00 c8 be 40010ee4 40010bc8: c0 27 00 00 clr [ %i4 ] return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 40010bcc: 7f ff e7 d2 call 4000ab14 40010bd0: 01 00 00 00 nop 40010bd4: a4 10 00 08 mov %o0, %l2 40010bd8: 23 10 00 d3 sethi %hi(0x40034c00), %l1 40010bdc: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 40010be0: 80 a0 60 00 cmp %g1, 0 40010be4: 02 80 00 0b be 40010c10 40010be8: 29 10 00 d3 sethi %hi(0x40034c00), %l4 40010bec: 03 10 00 d3 sethi %hi(0x40034c00), %g1 <== NOT EXECUTED 40010bf0: c4 00 62 60 ld [ %g1 + 0x260 ], %g2 ! 40034e60 <_System_state_Current> <== NOT EXECUTED 40010bf4: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40010bf8: 08 80 00 06 bleu 40010c10 <== NOT EXECUTED 40010bfc: 90 10 20 00 clr %o0 <== NOT EXECUTED 40010c00: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010c04: 40 00 10 dc call 40014f74 <_Internal_error_Occurred> <== NOT EXECUTED 40010c08: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40010c0c: 29 10 00 d3 sethi %hi(0x40034c00), %l4 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40010c10: 27 10 00 d3 sethi %hi(0x40034c00), %l3 40010c14: e0 05 21 54 ld [ %l4 + 0x154 ], %l0 40010c18: c4 04 e1 5c ld [ %l3 + 0x15c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40010c1c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40010c20: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40010c24: 80 a0 60 00 cmp %g1, 0 40010c28: 22 80 00 34 be,a 40010cf8 40010c2c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40010c30: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40010c34: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 40010c38: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; the_mutex->nest_count = 1; 40010c3c: 88 10 20 01 mov 1, %g4 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; 40010c40: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 40010c44: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40010c48: 80 a0 e0 02 cmp %g3, 2 40010c4c: 02 80 00 54 be 40010d9c 40010c50: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 40010c54: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40010c58: 22 80 00 53 be,a 40010da4 <== NOT EXECUTED 40010c5c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 40010c60: 7f ff e7 b1 call 4000ab24 40010c64: 90 10 00 12 mov %l2, %o0 executing = _Thread_Executing; 40010c68: f0 04 e1 5c ld [ %l3 + 0x15c ], %i0 40010c6c: 11 10 00 d2 sethi %hi(0x40034800), %o0 40010c70: 92 10 00 15 mov %l5, %o1 40010c74: 90 12 22 98 or %o0, 0x298, %o0 40010c78: 40 00 12 3d call 4001556c <_Objects_Get_no_protection> 40010c7c: 94 07 bf f4 add %fp, -12, %o2 the_region = _Region_Get( id, &location ); switch ( location ) { 40010c80: c2 07 bf f4 ld [ %fp + -12 ], %g1 40010c84: 80 a0 60 01 cmp %g1, 1 40010c88: 02 80 00 32 be 40010d50 40010c8c: a0 10 00 08 mov %o0, %l0 40010c90: 80 a0 60 01 cmp %g1, 1 40010c94: 1a 80 00 62 bcc 40010e1c 40010c98: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) { 40010c9c: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 40010ca0: 80 a6 40 01 cmp %i1, %g1 40010ca4: 28 80 00 a0 bleu,a 40010f24 40010ca8: 90 02 20 68 add %o0, 0x68, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010cac: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010cb0: 82 00 60 01 inc %g1 40010cb4: c2 24 60 80 st %g1, [ %l1 + 0x80 ] _RTEMS_Unlock_allocator(); 40010cb8: d0 05 21 54 ld [ %l4 + 0x154 ], %o0 40010cbc: 94 10 20 00 clr %o2 40010cc0: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010cc4: 40 00 0e 33 call 40014590 <_CORE_mutex_Surrender> 40010cc8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010ccc: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010cd0: 82 00 7f ff add %g1, -1, %g1 40010cd4: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 40010cd8: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 40010cdc: 80 a0 a0 00 cmp %g2, 0 40010ce0: 12 80 00 81 bne 40010ee4 40010ce4: 01 00 00 00 nop _Thread_Dispatch(); 40010ce8: 40 00 17 5d call 40016a5c <_Thread_Dispatch> 40010cec: b0 10 20 08 mov 8, %i0 ! 8 40010cf0: 81 c7 e0 08 ret 40010cf4: 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 ) ) { 40010cf8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40010cfc: 12 80 00 4e bne 40010e34 <== NOT EXECUTED 40010d00: c6 05 21 54 ld [ %l4 + 0x154 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40010d04: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40010d08: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40010d0c: 12 80 00 48 bne 40010e2c <== NOT EXECUTED 40010d10: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40010d14: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40010d18: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010d1c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40010d20: 7f ff e7 81 call 4000ab24 <== NOT EXECUTED 40010d24: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010d28: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40010d2c: f0 04 e1 5c ld [ %l3 + 0x15c ], %i0 <== NOT EXECUTED 40010d30: 90 12 22 98 or %o0, 0x298, %o0 <== NOT EXECUTED 40010d34: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED 40010d38: 40 00 12 0d call 4001556c <_Objects_Get_no_protection> <== NOT EXECUTED 40010d3c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 40010d40: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 40010d44: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40010d48: 12 bf ff d3 bne 40010c94 <== NOT EXECUTED 40010d4c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010d50: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 40010d54: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010d58: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 40010d5c: d0 05 21 54 ld [ %l4 + 0x154 ], %o0 <== NOT EXECUTED 40010d60: 94 10 20 00 clr %o2 <== NOT EXECUTED 40010d64: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40010d68: 40 00 0e 0a call 40014590 <_CORE_mutex_Surrender> <== NOT EXECUTED 40010d6c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010d70: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 40010d74: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010d78: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED 40010d7c: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 <== NOT EXECUTED 40010d80: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40010d84: 12 80 00 28 bne 40010e24 <== NOT EXECUTED 40010d88: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 40010d8c: 40 00 17 34 call 40016a5c <_Thread_Dispatch> <== NOT EXECUTED 40010d90: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 40010d94: 81 c7 e0 08 ret <== NOT EXECUTED 40010d98: 81 e8 00 00 restore <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40010d9c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010da0: 80 a0 e0 03 cmp %g3, 3 the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40010da4: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010da8: 12 bf ff ae bne 40010c60 40010dac: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40010db0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40010db4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40010db8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40010dbc: 02 80 00 56 be 40010f14 <== NOT EXECUTED 40010dc0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40010dc4: 1a 80 00 4a bcc 40010eec <== NOT EXECUTED 40010dc8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010dcc: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 40010dd0: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010dd4: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40010dd8: 7f ff e7 53 call 4000ab24 <== NOT EXECUTED 40010ddc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40010de0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40010de4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40010de8: 40 00 15 f9 call 400165cc <_Thread_Change_priority> <== NOT EXECUTED 40010dec: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010df0: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 40010df4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010df8: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED 40010dfc: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 <== NOT EXECUTED 40010e00: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40010e04: 32 bf ff 9a bne,a 40010c6c <== NOT EXECUTED 40010e08: f0 04 e1 5c ld [ %l3 + 0x15c ], %i0 <== NOT EXECUTED _Thread_Dispatch(); 40010e0c: 40 00 17 14 call 40016a5c <_Thread_Dispatch> <== NOT EXECUTED 40010e10: 01 00 00 00 nop <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40010e14: 10 bf ff 96 b 40010c6c <== NOT EXECUTED 40010e18: f0 04 e1 5c ld [ %l3 + 0x15c ], %i0 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 40010e1c: 02 80 00 18 be 40010e7c 40010e20: 01 00 00 00 nop _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 40010e24: 81 c7 e0 08 ret <== NOT EXECUTED 40010e28: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * 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 ) { 40010e2c: 02 80 00 28 be 40010ecc <== NOT EXECUTED 40010e30: c6 05 21 54 ld [ %l4 + 0x154 ], %g3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010e34: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 40010e38: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40010e3c: c8 04 e1 5c ld [ %l3 + 0x15c ], %g4 <== NOT EXECUTED 40010e40: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010e44: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40010e48: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED 40010e4c: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40010e50: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40010e54: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40010e58: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40010e5c: 7f ff e7 32 call 4000ab24 <== NOT EXECUTED 40010e60: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010e64: d0 05 21 54 ld [ %l4 + 0x154 ], %o0 <== NOT EXECUTED 40010e68: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010e6c: 40 00 0d a5 call 40014500 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40010e70: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED executing = _Thread_Executing; 40010e74: 10 bf ff 7e b 40010c6c <== NOT EXECUTED 40010e78: f0 04 e1 5c ld [ %l3 + 0x15c ], %i0 <== NOT EXECUTED 40010e7c: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010e80: 82 00 60 01 inc %g1 40010e84: c2 24 60 80 st %g1, [ %l1 + 0x80 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40010e88: d0 05 21 54 ld [ %l4 + 0x154 ], %o0 40010e8c: 94 10 20 00 clr %o2 40010e90: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010e94: 40 00 0d bf call 40014590 <_CORE_mutex_Surrender> 40010e98: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010e9c: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010ea0: b0 10 20 04 mov 4, %i0 _Thread_Dispatch(); 40010ea4: 82 00 7f ff add %g1, -1, %g1 40010ea8: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 40010eac: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 40010eb0: 80 a0 a0 00 cmp %g2, 0 40010eb4: 12 80 00 6d bne 40011068 40010eb8: 01 00 00 00 nop 40010ebc: 40 00 16 e8 call 40016a5c <_Thread_Dispatch> 40010ec0: 01 00 00 00 nop 40010ec4: 81 c7 e0 08 ret 40010ec8: 81 e8 00 00 restore 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; 40010ecc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40010ed0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40010ed4: 7f ff e7 14 call 4000ab24 <== NOT EXECUTED 40010ed8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40010edc: 10 bf ff 64 b 40010c6c <== NOT EXECUTED 40010ee0: f0 04 e1 5c ld [ %l3 + 0x15c ], %i0 <== NOT EXECUTED _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 40010ee4: 81 c7 e0 08 ret <== NOT EXECUTED 40010ee8: 91 e8 20 08 restore %g0, 8, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40010eec: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40010ef0: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40010ef4: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40010ef8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40010efc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010f00: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40010f04: 7f ff e7 08 call 4000ab24 <== NOT EXECUTED 40010f08: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40010f0c: 10 bf ff 58 b 40010c6c <== NOT EXECUTED 40010f10: f0 04 e1 5c ld [ %l3 + 0x15c ], %i0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40010f14: 7f ff e7 04 call 4000ab24 <== NOT EXECUTED 40010f18: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010f1c: 10 bf ff 54 b 40010c6c <== NOT EXECUTED 40010f20: f0 04 e1 5c ld [ %l3 + 0x15c ], %i0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 40010f24: 40 00 0e af call 400149e0 <_Heap_Allocate> 40010f28: 92 10 00 19 mov %i1, %o1 the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 40010f2c: a4 92 20 00 orcc %o0, 0, %l2 40010f30: 02 80 00 17 be 40010f8c 40010f34: 80 8e a0 01 btst 1, %i2 the_region->number_of_used_blocks += 1; 40010f38: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010f3c: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 40010f40: 82 00 60 01 inc %g1 40010f44: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 40010f48: 84 00 a0 01 inc %g2 40010f4c: c4 24 60 80 st %g2, [ %l1 + 0x80 ] _RTEMS_Unlock_allocator(); 40010f50: d0 05 21 54 ld [ %l4 + 0x154 ], %o0 40010f54: 94 10 20 00 clr %o2 40010f58: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010f5c: 40 00 0d 8d call 40014590 <_CORE_mutex_Surrender> 40010f60: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010f64: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010f68: 82 00 7f ff add %g1, -1, %g1 40010f6c: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 40010f70: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 40010f74: 80 a0 a0 00 cmp %g2, 0 40010f78: 02 80 00 12 be 40010fc0 40010f7c: 01 00 00 00 nop *segment = the_segment; 40010f80: e4 27 00 00 st %l2, [ %i4 ] <== NOT EXECUTED 40010f84: 81 c7 e0 08 ret 40010f88: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; } if ( _Options_Is_no_wait( option_set ) ) { 40010f8c: 02 80 00 11 be 40010fd0 40010f90: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010f94: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010f98: 82 00 60 01 inc %g1 40010f9c: c2 24 60 80 st %g1, [ %l1 + 0x80 ] _RTEMS_Unlock_allocator(); 40010fa0: d0 05 21 54 ld [ %l4 + 0x154 ], %o0 40010fa4: 94 10 20 00 clr %o2 40010fa8: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010fac: 40 00 0d 79 call 40014590 <_CORE_mutex_Surrender> 40010fb0: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010fb4: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010fb8: 10 bf ff bb b 40010ea4 40010fbc: b0 10 20 0d mov 0xd, %i0 _Thread_Dispatch(); 40010fc0: 40 00 16 a7 call 40016a5c <_Thread_Dispatch> 40010fc4: 01 00 00 00 nop _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { the_region->number_of_used_blocks += 1; _RTEMS_Unlock_allocator(); *segment = the_segment; 40010fc8: 10 bf ff ef b 40010f84 40010fcc: e4 27 00 00 st %l2, [ %i4 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010fd0: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010fd4: 25 10 00 d3 sethi %hi(0x40034c00), %l2 40010fd8: 82 00 60 01 inc %g1 40010fdc: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 40010fe0: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40010fe4: 82 00 60 01 inc %g1 40010fe8: c2 24 60 80 st %g1, [ %l1 + 0x80 ] * 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(); 40010fec: d0 05 21 54 ld [ %l4 + 0x154 ], %o0 40010ff0: 94 10 20 00 clr %o2 40010ff4: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010ff8: 40 00 0d 66 call 40014590 <_CORE_mutex_Surrender> 40010ffc: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011000: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40011004: 82 00 7f ff add %g1, -1, %g1 40011008: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 4001100c: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 40011010: 80 a0 a0 00 cmp %g2, 0 40011014: 02 80 00 17 be 40011070 40011018: 01 00 00 00 nop 4001101c: 82 10 20 01 mov 1, %g1 ! 1 executing->Wait.queue = &the_region->Wait_queue; 40011020: 90 04 20 10 add %l0, 0x10, %o0 executing->Wait.id = id; 40011024: ea 26 20 20 st %l5, [ %i0 + 0x20 ] executing->Wait.count = size; 40011028: f2 26 20 24 st %i1, [ %i0 + 0x24 ] executing->Wait.return_argument = segment; 4001102c: f8 26 20 28 st %i4, [ %i0 + 0x28 ] _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 40011030: 92 10 00 1b mov %i3, %o1 * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; 40011034: d0 26 20 44 st %o0, [ %i0 + 0x44 ] 40011038: c2 24 20 40 st %g1, [ %l0 + 0x40 ] 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 ); 4001103c: 15 10 00 5d sethi %hi(0x40017400), %o2 40011040: 40 00 17 f7 call 4001701c <_Thread_queue_Enqueue_with_handler> 40011044: 94 12 a1 5c or %o2, 0x15c, %o2 ! 4001755c <_Thread_queue_Timeout> 40011048: c2 04 a0 80 ld [ %l2 + 0x80 ], %g1 4001104c: 82 00 7f ff add %g1, -1, %g1 40011050: c2 24 a0 80 st %g1, [ %l2 + 0x80 ] 40011054: c4 04 a0 80 ld [ %l2 + 0x80 ], %g2 40011058: 80 a0 a0 00 cmp %g2, 0 4001105c: 02 80 00 09 be 40011080 40011060: 01 00 00 00 nop _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 40011064: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 <== NOT EXECUTED 40011068: 81 c7 e0 08 ret <== NOT EXECUTED 4001106c: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40011070: 40 00 16 7b call 40016a5c <_Thread_Dispatch> <== NOT EXECUTED 40011074: 01 00 00 00 nop <== NOT EXECUTED 40011078: 10 bf ff ea b 40011020 <== NOT EXECUTED 4001107c: 82 10 20 01 mov 1, %g1 ! 1 <== NOT EXECUTED 40011080: 40 00 16 77 call 40016a5c <_Thread_Dispatch> 40011084: 01 00 00 00 nop 40011088: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 4001108c: 81 c7 e0 08 ret 40011090: 81 e8 00 00 restore 400110cc : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 400110cc: 9d e3 bf 90 save %sp, -112, %sp #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 400110d0: 7f ff e6 91 call 4000ab14 400110d4: 01 00 00 00 nop 400110d8: a4 10 00 08 mov %o0, %l2 400110dc: 23 10 00 d3 sethi %hi(0x40034c00), %l1 400110e0: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 400110e4: 80 a0 60 00 cmp %g1, 0 400110e8: 02 80 00 0b be 40011114 400110ec: 27 10 00 d3 sethi %hi(0x40034c00), %l3 400110f0: 03 10 00 d3 sethi %hi(0x40034c00), %g1 <== NOT EXECUTED 400110f4: c4 00 62 60 ld [ %g1 + 0x260 ], %g2 ! 40034e60 <_System_state_Current> <== NOT EXECUTED 400110f8: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 400110fc: 08 80 00 06 bleu 40011114 <== NOT EXECUTED 40011100: 90 10 20 00 clr %o0 <== NOT EXECUTED 40011104: 92 10 20 00 clr %o1 <== NOT EXECUTED 40011108: 40 00 0f 9b call 40014f74 <_Internal_error_Occurred> <== NOT EXECUTED 4001110c: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40011110: 27 10 00 d3 sethi %hi(0x40034c00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40011114: 09 10 00 d3 sethi %hi(0x40034c00), %g4 40011118: e0 04 e1 54 ld [ %l3 + 0x154 ], %l0 4001111c: c4 01 21 5c ld [ %g4 + 0x15c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40011120: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40011124: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40011128: 80 a0 60 00 cmp %g1, 0 4001112c: 22 80 00 38 be,a 4001120c 40011130: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40011134: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40011138: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 4001113c: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; the_mutex->nest_count = 1; 40011140: 88 10 20 01 mov 1, %g4 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; 40011144: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 40011148: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4001114c: 80 a0 e0 02 cmp %g3, 2 40011150: 12 80 00 58 bne 400112b0 40011154: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40011158: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4001115c: 80 a0 e0 03 cmp %g3, 3 the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40011160: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40011164: 02 80 00 7c be 40011354 40011168: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 4001116c: 7f ff e6 6e call 4000ab24 40011170: 90 10 00 12 mov %l2, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 40011174: 92 10 00 18 mov %i0, %o1 40011178: 11 10 00 d2 sethi %hi(0x40034800), %o0 4001117c: 94 07 bf f4 add %fp, -12, %o2 40011180: 40 00 10 fb call 4001556c <_Objects_Get_no_protection> 40011184: 90 12 22 98 or %o0, 0x298, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 40011188: c2 07 bf f4 ld [ %fp + -12 ], %g1 4001118c: 80 a0 60 01 cmp %g1, 1 40011190: 02 80 00 35 be 40011264 40011194: a0 10 00 08 mov %o0, %l0 40011198: 80 a0 60 01 cmp %g1, 1 4001119c: 1a 80 00 5f bcc 40011318 400111a0: 80 a0 60 02 cmp %g1, 2 RTEMS_INLINE_ROUTINE boolean _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 400111a4: 92 10 00 19 mov %i1, %o1 400111a8: 40 00 0e 73 call 40014b74 <_Heap_Free> 400111ac: 90 02 20 68 add %o0, 0x68, %o0 status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) { 400111b0: 80 a2 20 00 cmp %o0, 0 400111b4: 32 80 00 97 bne,a 40011410 400111b8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400111bc: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 400111c0: 82 00 60 01 inc %g1 400111c4: c2 24 60 80 st %g1, [ %l1 + 0x80 ] _RTEMS_Unlock_allocator(); 400111c8: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 400111cc: 94 10 20 00 clr %o2 400111d0: d2 02 20 08 ld [ %o0 + 8 ], %o1 400111d4: 40 00 0c ef call 40014590 <_CORE_mutex_Surrender> 400111d8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400111dc: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 400111e0: b0 10 20 09 mov 9, %i0 400111e4: 82 00 7f ff add %g1, -1, %g1 400111e8: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 400111ec: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 400111f0: 80 a0 a0 00 cmp %g2, 0 400111f4: 12 80 00 8c bne 40011424 400111f8: 01 00 00 00 nop _Thread_Dispatch(); 400111fc: 40 00 16 18 call 40016a5c <_Thread_Dispatch> 40011200: 01 00 00 00 nop 40011204: 81 c7 e0 08 ret 40011208: 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 ) ) { 4001120c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40011210: 12 80 00 30 bne 400112d0 <== NOT EXECUTED 40011214: c6 04 e1 54 ld [ %l3 + 0x154 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40011218: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 4001121c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40011220: 22 80 00 68 be,a 400113c0 <== NOT EXECUTED 40011224: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40011228: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001122c: 12 80 00 29 bne 400112d0 <== NOT EXECUTED 40011230: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 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; 40011234: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40011238: 7f ff e6 3b call 4000ab24 <== NOT EXECUTED 4001123c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 40011240: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 40011244: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED 40011248: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 4001124c: 40 00 10 c8 call 4001556c <_Objects_Get_no_protection> <== NOT EXECUTED 40011250: 90 12 22 98 or %o0, 0x298, %o0 <== NOT EXECUTED #endif int status; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 40011254: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 40011258: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001125c: 12 bf ff d0 bne 4001119c <== NOT EXECUTED 40011260: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011264: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 40011268: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001126c: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 40011270: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 <== NOT EXECUTED 40011274: 94 10 20 00 clr %o2 <== NOT EXECUTED 40011278: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 4001127c: 40 00 0c c5 call 40014590 <_CORE_mutex_Surrender> <== NOT EXECUTED 40011280: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011284: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 40011288: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001128c: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED 40011290: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 <== NOT EXECUTED 40011294: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40011298: 12 80 00 22 bne 40011320 <== NOT EXECUTED 4001129c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 400112a0: 40 00 15 ef call 40016a5c <_Thread_Dispatch> <== NOT EXECUTED 400112a4: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 400112a8: 81 c7 e0 08 ret <== NOT EXECUTED 400112ac: 81 e8 00 00 restore <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400112b0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 400112b4: 12 bf ff ae bne 4001116c <== NOT EXECUTED 400112b8: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400112bc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400112c0: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400112c4: 02 80 00 24 be 40011354 <== NOT EXECUTED 400112c8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 400112cc: 30 bf ff a8 b,a 4001116c <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400112d0: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 400112d4: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 400112d8: c8 01 21 5c ld [ %g4 + 0x15c ], %g4 <== NOT EXECUTED 400112dc: 82 00 60 01 inc %g1 <== NOT EXECUTED 400112e0: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 400112e4: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED 400112e8: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 400112ec: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 400112f0: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 400112f4: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 400112f8: 7f ff e6 0b call 4000ab24 <== NOT EXECUTED 400112fc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40011300: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 <== NOT EXECUTED 40011304: 92 10 20 00 clr %o1 <== NOT EXECUTED 40011308: 40 00 0c 7e call 40014500 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 4001130c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40011310: 10 bf ff 9a b 40011178 <== NOT EXECUTED 40011314: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 40011318: 02 80 00 04 be 40011328 4001131c: 01 00 00 00 nop the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator internally */ return RTEMS_SUCCESSFUL; 40011320: 81 c7 e0 08 ret <== NOT EXECUTED 40011324: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 40011328: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 4001132c: 82 00 60 01 inc %g1 40011330: c2 24 60 80 st %g1, [ %l1 + 0x80 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40011334: d0 04 e1 54 ld [ %l3 + 0x154 ], %o0 40011338: 94 10 20 00 clr %o2 4001133c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011340: 40 00 0c 94 call 40014590 <_CORE_mutex_Surrender> 40011344: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011348: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 4001134c: 10 bf ff a6 b 400111e4 40011350: b0 10 20 04 mov 4, %i0 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40011354: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40011358: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 4001135c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40011360: 02 80 00 28 be 40011400 <== NOT EXECUTED 40011364: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40011368: 1a 80 00 1c bcc 400113d8 <== NOT EXECUTED 4001136c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011370: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 40011374: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011378: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 4001137c: 7f ff e5 ea call 4000ab24 <== NOT EXECUTED 40011380: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40011384: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40011388: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 4001138c: 40 00 14 90 call 400165cc <_Thread_Change_priority> <== NOT EXECUTED 40011390: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011394: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED 40011398: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001139c: c2 24 60 80 st %g1, [ %l1 + 0x80 ] <== NOT EXECUTED 400113a0: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 <== NOT EXECUTED 400113a4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400113a8: 32 bf ff 74 bne,a 40011178 <== NOT EXECUTED 400113ac: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _Thread_Dispatch(); 400113b0: 40 00 15 ab call 40016a5c <_Thread_Dispatch> <== NOT EXECUTED 400113b4: 01 00 00 00 nop <== NOT EXECUTED 400113b8: 10 bf ff 70 b 40011178 <== NOT EXECUTED 400113bc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED * 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++; 400113c0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400113c4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400113c8: 7f ff e5 d7 call 4000ab24 <== NOT EXECUTED 400113cc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400113d0: 10 bf ff 6a b 40011178 <== NOT EXECUTED 400113d4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 400113d8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400113dc: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 400113e0: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 400113e4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400113e8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400113ec: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400113f0: 7f ff e5 cd call 4000ab24 <== NOT EXECUTED 400113f4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400113f8: 10 bf ff 60 b 40011178 <== NOT EXECUTED 400113fc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40011400: 7f ff e5 c9 call 4000ab24 <== NOT EXECUTED 40011404: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40011408: 10 bf ff 5c b 40011178 <== NOT EXECUTED 4001140c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator internally */ 40011410: 90 10 00 10 mov %l0, %o0 if ( !status ) { _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 40011414: 82 00 7f ff add %g1, -1, %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 40011418: b0 10 20 00 clr %i0 4001141c: 40 00 26 71 call 4001ade0 <_Region_Process_queue> 40011420: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 40011424: 81 c7 e0 08 ret 40011428: 81 e8 00 00 restore 40005a48 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 40005a48: 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 ) ) 40005a4c: aa 96 20 00 orcc %i0, 0, %l5 40005a50: 02 80 00 12 be 40005a98 40005a54: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 40005a58: 80 a7 20 00 cmp %i4, 0 40005a5c: 02 80 00 0f be 40005a98 40005a60: b0 10 20 09 mov 9, %i0 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 40005a64: a4 8e a0 40 andcc %i2, 0x40, %l2 40005a68: 12 80 00 0e bne 40005aa0 40005a6c: a0 0e a0 30 and %i2, 0x30, %l0 40005a70: 80 8e a0 80 btst 0x80, %i2 40005a74: 12 80 00 0c bne 40005aa4 40005a78: 80 a4 20 10 cmp %l0, 0x10 RTEMS_INLINE_ROUTINE boolean _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 40005a7c: 80 a0 00 10 cmp %g0, %l0 40005a80: a2 60 3f ff subx %g0, -1, %l1 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 ) ) 40005a84: 80 a4 60 00 cmp %l1, 0 40005a88: 12 80 00 17 bne 40005ae4 40005a8c: 80 a6 60 01 cmp %i1, 1 40005a90: 08 80 00 15 bleu 40005ae4 40005a94: b0 10 20 0a mov 0xa, %i0 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 40005a98: 81 c7 e0 08 ret 40005a9c: 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 ) || 40005aa0: 80 a4 20 10 cmp %l0, 0x10 40005aa4: 12 80 00 0b bne 40005ad0 40005aa8: 80 a4 20 20 cmp %l0, 0x20 40005aac: 80 8e a0 04 btst 4, %i2 40005ab0: 02 80 00 06 be 40005ac8 40005ab4: 80 a4 a0 00 cmp %l2, 0 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 40005ab8: 02 bf ff f1 be 40005a7c 40005abc: 80 8e a0 80 btst 0x80, %i2 40005ac0: 02 bf ff f0 be 40005a80 40005ac4: 80 a0 00 10 cmp %g0, %l0 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 40005ac8: 81 c7 e0 08 ret 40005acc: 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 ) || 40005ad0: 12 bf ff fe bne 40005ac8 40005ad4: 80 8e a0 04 btst 4, %i2 40005ad8: 12 bf ff f8 bne 40005ab8 40005adc: 80 a4 a0 00 cmp %l2, 0 40005ae0: 30 bf ff fa b,a 40005ac8 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40005ae4: 29 10 00 6a sethi %hi(0x4001a800), %l4 40005ae8: c2 05 23 60 ld [ %l4 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> 40005aec: 82 00 60 01 inc %g1 40005af0: c2 25 23 60 st %g1, [ %l4 + 0x360 ] * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 40005af4: 31 10 00 6a sethi %hi(0x4001a800), %i0 40005af8: 40 00 07 4e call 40007830 <_Objects_Allocate> 40005afc: 90 16 22 14 or %i0, 0x214, %o0 ! 4001aa14 <_Semaphore_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 40005b00: a6 92 20 00 orcc %o0, 0, %l3 40005b04: 12 80 00 0e bne 40005b3c 40005b08: 80 a4 60 00 cmp %l1, 0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005b0c: c2 05 23 60 ld [ %l4 + 0x360 ], %g1 40005b10: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 40005b14: 82 00 7f ff add %g1, -1, %g1 40005b18: c2 25 23 60 st %g1, [ %l4 + 0x360 ] 40005b1c: c4 05 23 60 ld [ %l4 + 0x360 ], %g2 40005b20: 80 a0 a0 00 cmp %g2, 0 40005b24: 12 80 00 04 bne 40005b34 40005b28: 01 00 00 00 nop 40005b2c: 40 00 0d ba call 40009214 <_Thread_Dispatch> 40005b30: 01 00 00 00 nop 40005b34: 81 c7 e0 08 ret 40005b38: 81 e8 00 00 restore * 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 ) ) { 40005b3c: 12 80 00 1e bne 40005bb4 40005b40: f4 24 e0 10 st %i2, [ %l3 + 0x10 ] CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 40005b44: 80 a4 a0 00 cmp %l2, 0 40005b48: 02 80 00 39 be 40005c2c 40005b4c: 80 8e a0 80 btst 0x80, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 40005b50: 82 10 20 02 mov 2, %g1 40005b54: 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 ) ) { 40005b58: 80 a4 20 10 cmp %l0, 0x10 40005b5c: 12 80 00 39 bne 40005c40 40005b60: 82 10 20 02 mov 2, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 40005b64: c2 07 bf e8 ld [ %fp + -24 ], %g1 40005b68: 80 a0 60 01 cmp %g1, 1 40005b6c: 18 80 00 3d bgu 40005c60 40005b70: c0 27 bf e0 clr [ %fp + -32 ] case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; 40005b74: c0 27 bf e4 clr [ %fp + -28 ] the_mutex_attributes.only_owner_release = FALSE; } the_mutex_attributes.priority_ceiling = priority_ceiling; mutex_status = _CORE_mutex_Initialize( 40005b78: 82 1e 60 01 xor %i1, 1, %g1 40005b7c: 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; 40005b80: f6 27 bf ec st %i3, [ %fp + -20 ] mutex_status = _CORE_mutex_Initialize( 40005b84: 94 60 3f ff subx %g0, -1, %o2 40005b88: 90 04 e0 14 add %l3, 0x14, %o0 40005b8c: 40 00 04 9c call 40006dfc <_CORE_mutex_Initialize> 40005b90: 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 ) { 40005b94: 80 a2 20 06 cmp %o0, 6 40005b98: 12 80 00 14 bne 40005be8 40005b9c: 90 16 22 14 or %i0, 0x214, %o0 RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 40005ba0: 40 00 08 32 call 40007c68 <_Objects_Free> <== NOT EXECUTED 40005ba4: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005ba8: c2 05 23 60 ld [ %l4 + 0x360 ], %g1 <== NOT EXECUTED 40005bac: 10 bf ff da b 40005b14 <== NOT EXECUTED 40005bb0: b0 10 20 13 mov 0x13, %i0 <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) 40005bb4: 80 8e a0 04 btst 4, %i2 40005bb8: 22 80 00 04 be,a 40005bc8 40005bbc: c0 27 bf f4 clr [ %fp + -12 ] the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 40005bc0: 82 10 20 01 mov 1, %g1 40005bc4: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 40005bc8: 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; 40005bcc: c0 27 bf e0 clr [ %fp + -32 ] the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 40005bd0: c0 27 bf ec clr [ %fp + -20 ] _CORE_semaphore_Initialize( 40005bd4: 94 10 00 19 mov %i1, %o2 /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 40005bd8: 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( 40005bdc: 90 04 e0 14 add %l3, 0x14, %o0 40005be0: 40 00 05 44 call 400070f0 <_CORE_semaphore_Initialize> 40005be4: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005be8: 90 16 22 14 or %i0, 0x214, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40005bec: c6 04 e0 08 ld [ %l3 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005bf0: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40005bf4: 03 00 00 3f sethi %hi(0xfc00), %g1 40005bf8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40005bfc: 82 08 c0 01 and %g3, %g1, %g1 40005c00: 80 a0 40 02 cmp %g1, %g2 40005c04: 38 80 00 06 bgu,a 40005c1c 40005c08: ea 24 e0 0c st %l5, [ %l3 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40005c0c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40005c10: 83 28 60 02 sll %g1, 2, %g1 40005c14: e6 20 80 01 st %l3, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 40005c18: ea 24 e0 0c st %l5, [ %l3 + 0xc ] &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 40005c1c: c6 27 00 00 st %g3, [ %i4 ] 40005c20: c2 05 23 60 ld [ %l4 + 0x360 ], %g1 40005c24: 10 bf ff bc b 40005b14 40005c28: b0 10 20 00 clr %i0 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 ) ) 40005c2c: 02 80 00 08 be 40005c4c 40005c30: 80 8e a0 04 btst 4, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 40005c34: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 40005c38: 10 bf ff c8 b 40005b58 <== NOT EXECUTED 40005c3c: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED 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; 40005c40: c0 27 bf e4 clr [ %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; 40005c44: 10 bf ff cd b 40005b78 40005c48: c2 27 bf e0 st %g1, [ %fp + -32 ] 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 ) ) 40005c4c: 22 bf ff c3 be,a 40005b58 40005c50: c0 27 bf e8 clr [ %fp + -24 ] the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 40005c54: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40005c58: 10 bf ff c0 b 40005b58 <== NOT EXECUTED 40005c5c: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 40005c60: 80 a0 60 03 cmp %g1, 3 40005c64: 18 bf ff c6 bgu 40005b7c 40005c68: 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; 40005c6c: 82 10 20 01 mov 1, %g1 40005c70: 10 bf ff c2 b 40005b78 40005c74: c2 27 bf e4 st %g1, [ %fp + -28 ] 40005c78 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 40005c78: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 40005c7c: 21 10 00 6a sethi %hi(0x4001a800), %l0 40005c80: 92 10 00 18 mov %i0, %o1 40005c84: 94 07 bf f4 add %fp, -12, %o2 40005c88: 40 00 08 3b call 40007d74 <_Objects_Get> 40005c8c: 90 14 22 14 or %l0, 0x214, %o0 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 40005c90: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005c94: 80 a0 60 00 cmp %g1, 0 40005c98: 12 80 00 19 bne 40005cfc 40005c9c: b0 10 00 08 mov %o0, %i0 40005ca0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 40005ca4: 84 88 60 30 andcc %g1, 0x30, %g2 40005ca8: 22 80 00 1a be,a 40005d10 40005cac: 90 02 20 14 add %o0, 0x14, %o0 if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 40005cb0: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 40005cb4: 80 a0 60 00 cmp %g1, 0 40005cb8: 12 80 00 35 bne 40005d8c 40005cbc: 80 a0 a0 20 cmp %g2, 0x20 40005cc0: 02 80 00 34 be 40005d90 40005cc4: 90 06 20 14 add %i0, 0x14, %o0 40005cc8: 03 10 00 6a sethi %hi(0x4001a800), %g1 40005ccc: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 4001ab60 <_Thread_Dispatch_disable_level> 40005cd0: b0 10 20 0c mov 0xc, %i0 40005cd4: 84 00 bf ff add %g2, -1, %g2 40005cd8: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 40005cdc: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 40005ce0: 80 a0 e0 00 cmp %g3, 0 40005ce4: 12 80 00 28 bne 40005d84 40005ce8: 01 00 00 00 nop _Thread_Dispatch(); 40005cec: 40 00 0d 4a call 40009214 <_Thread_Dispatch> 40005cf0: 01 00 00 00 nop 40005cf4: 81 c7 e0 08 ret 40005cf8: 81 e8 00 00 restore { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 40005cfc: 80 a0 60 02 cmp %g1, 2 40005d00: 08 bf ff fd bleu 40005cf4 40005d04: b0 10 20 04 mov 4, %i0 40005d08: 81 c7 e0 08 ret <== NOT EXECUTED 40005d0c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 40005d10: 92 10 20 00 clr %o1 40005d14: 40 00 04 f3 call 400070e0 <_CORE_semaphore_Flush> 40005d18: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005d1c: 90 14 22 14 or %l0, 0x214, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40005d20: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005d24: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40005d28: 05 00 00 3f sethi %hi(0xfc00), %g2 40005d2c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40005d30: 82 08 40 02 and %g1, %g2, %g1 40005d34: 80 a0 40 03 cmp %g1, %g3 40005d38: 38 80 00 06 bgu,a 40005d50 40005d3c: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40005d40: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40005d44: 83 28 60 02 sll %g1, 2, %g1 40005d48: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 40005d4c: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 40005d50: 40 00 07 c6 call 40007c68 <_Objects_Free> 40005d54: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005d58: 03 10 00 6a sethi %hi(0x4001a800), %g1 40005d5c: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 4001ab60 <_Thread_Dispatch_disable_level> 40005d60: b0 10 20 00 clr %i0 40005d64: 84 00 bf ff add %g2, -1, %g2 40005d68: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 40005d6c: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 40005d70: 80 a0 e0 00 cmp %g3, 0 40005d74: 12 80 00 04 bne 40005d84 40005d78: 01 00 00 00 nop _Thread_Dispatch(); 40005d7c: 40 00 0d 26 call 40009214 <_Thread_Dispatch> 40005d80: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40005d84: 81 c7 e0 08 ret 40005d88: 81 e8 00 00 restore !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 40005d8c: 90 06 20 14 add %i0, 0x14, %o0 40005d90: 92 10 20 00 clr %o1 40005d94: 40 00 04 16 call 40006dec <_CORE_mutex_Flush> 40005d98: 94 10 20 04 mov 4, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005d9c: 10 bf ff e1 b 40005d20 40005da0: 90 14 22 14 or %l0, 0x214, %o0 40006244 : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 40006244: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 40006248: 11 10 00 73 sethi %hi(0x4001cc00), %o0 4000624c: 92 10 00 18 mov %i0, %o1 40006250: 90 12 20 7c or %o0, 0x7c, %o0 40006254: 40 00 08 9b call 400084c0 <_Objects_Get> 40006258: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 4000625c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006260: 80 a0 60 00 cmp %g1, 0 40006264: 12 80 00 16 bne 400062bc 40006268: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 4000626c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40006270: 80 88 60 30 btst 0x30, %g1 40006274: 12 80 00 16 bne 400062cc 40006278: 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( 4000627c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40006280: 40 00 05 6b call 4000782c <_CORE_semaphore_Flush> <== NOT EXECUTED 40006284: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006288: 03 10 00 73 sethi %hi(0x4001cc00), %g1 4000628c: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 4001cdd0 <_Thread_Dispatch_disable_level> 40006290: b0 10 20 00 clr %i0 40006294: 84 00 bf ff add %g2, -1, %g2 40006298: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ] 4000629c: c6 00 61 d0 ld [ %g1 + 0x1d0 ], %g3 400062a0: 80 a0 e0 00 cmp %g3, 0 400062a4: 12 80 00 04 bne 400062b4 400062a8: 01 00 00 00 nop _Thread_Dispatch(); 400062ac: 40 00 0d 71 call 40009870 <_Thread_Dispatch> 400062b0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400062b4: 81 c7 e0 08 ret 400062b8: 81 e8 00 00 restore { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 400062bc: 08 bf ff fe bleu 400062b4 <== NOT EXECUTED 400062c0: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 400062c4: 81 c7 e0 08 ret <== NOT EXECUTED 400062c8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Flush( 400062cc: 92 10 20 00 clr %o1 400062d0: 40 00 04 9a call 40007538 <_CORE_mutex_Flush> 400062d4: 94 10 20 01 mov 1, %o2 400062d8: 30 bf ff ec b,a 40006288 40005da4 : rtems_status_code rtems_semaphore_obtain( rtems_id id, uint32_t option_set, rtems_interval timeout ) { 40005da4: 9d e3 bf 90 save %sp, -112, %sp Objects_Id id, Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) 40005da8: 11 10 00 6a sethi %hi(0x4001a800), %o0 40005dac: 92 10 00 18 mov %i0, %o1 40005db0: 90 12 22 14 or %o0, 0x214, %o0 40005db4: 94 07 bf f4 add %fp, -12, %o2 40005db8: 40 00 07 d1 call 40007cfc <_Objects_Get_isr_disable> 40005dbc: 96 07 bf f0 add %fp, -16, %o3 register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 40005dc0: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005dc4: 80 a0 60 00 cmp %g1, 0 40005dc8: 12 80 00 19 bne 40005e2c 40005dcc: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 40005dd0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40005dd4: 80 88 60 30 btst 0x30, %g1 40005dd8: 12 80 00 1b bne 40005e44 40005ddc: 23 10 00 6a sethi %hi(0x4001a800), %l1 Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40005de0: 27 10 00 6b sethi %hi(0x4001ac00), %l3 40005de4: e4 04 e0 3c ld [ %l3 + 0x3c ], %l2 ! 4001ac3c <_Thread_Executing> Watchdog_Interval timeout, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 40005de8: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 40005dec: c0 24 a0 34 clr [ %l2 + 0x34 ] if ( the_semaphore->count != 0 ) { 40005df0: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 40005df4: 80 a0 60 00 cmp %g1, 0 40005df8: 12 80 00 8f bne 40006034 40005dfc: 80 8e 60 01 btst 1, %i1 the_semaphore->count -= 1; _ISR_Enable( level ); return; } if ( !wait ) { 40005e00: 02 80 00 73 be 40005fcc 40005e04: 01 00 00 00 nop _ISR_Enable( level ); 40005e08: 7f ff ef ff call 40001e04 40005e0c: 01 00 00 00 nop executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 40005e10: 82 10 20 01 mov 1, %g1 ! 1 40005e14: c2 24 a0 34 st %g1, [ %l2 + 0x34 ] id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 40005e18: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 40005e1c: 40 00 00 f4 call 400061ec <_Semaphore_Translate_core_semaphore_return_code> 40005e20: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40005e24: 81 c7 e0 08 ret 40005e28: 91 e8 00 08 restore %g0, %o0, %o0 register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 40005e2c: 80 a0 60 02 cmp %g1, 2 40005e30: 08 bf ff fd bleu 40005e24 40005e34: 90 10 20 04 mov 4, %o0 40005e38: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Semaphore_Translate_core_semaphore_return_code( _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40005e3c: 81 c7 e0 08 ret <== NOT EXECUTED 40005e40: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 40005e44: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40005e48: 80 a0 60 00 cmp %g1, 0 40005e4c: 02 80 00 0e be 40005e84 40005e50: 27 10 00 6b sethi %hi(0x4001ac00), %l3 40005e54: 80 8e 60 01 btst 1, %i1 40005e58: 12 80 00 0c bne 40005e88 40005e5c: c6 04 e0 3c ld [ %l3 + 0x3c ], %g3 40005e60: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40005e64: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 4001ad40 <_System_state_Current> 40005e68: 80 a0 a0 01 cmp %g2, 1 40005e6c: 08 80 00 07 bleu 40005e88 40005e70: 90 10 20 00 clr %o0 40005e74: 92 10 20 00 clr %o1 <== NOT EXECUTED 40005e78: 40 00 06 41 call 4000777c <_Internal_error_Occurred> <== NOT EXECUTED 40005e7c: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40005e80: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED 40005e84: c6 04 e0 3c ld [ %l3 + 0x3c ], %g3 ! 4001ac3c <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 40005e88: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40005e8c: c0 20 e0 34 clr [ %g3 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40005e90: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 40005e94: 80 a0 60 00 cmp %g1, 0 40005e98: 22 80 00 37 be,a 40005f74 40005e9c: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 40005ea0: c0 24 20 64 clr [ %l0 + 0x64 ] the_mutex->holder = executing; 40005ea4: c6 24 20 70 st %g3, [ %l0 + 0x70 ] the_mutex->holder_id = executing->Object.id; 40005ea8: c2 00 e0 08 ld [ %g3 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 40005eac: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 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; the_mutex->nest_count = 1; 40005eb0: 88 10 20 01 mov 1, %g4 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; 40005eb4: c2 24 20 74 st %g1, [ %l0 + 0x74 ] the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40005eb8: 80 a0 a0 02 cmp %g2, 2 40005ebc: 12 80 00 24 bne 40005f4c 40005ec0: c8 24 20 68 st %g4, [ %l0 + 0x68 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40005ec4: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 40005ec8: 82 00 60 01 inc %g1 40005ecc: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40005ed0: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 40005ed4: 80 a0 a0 03 cmp %g2, 3 40005ed8: 12 80 00 20 bne 40005f58 40005edc: 01 00 00 00 nop */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40005ee0: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 <== NOT EXECUTED current = executing->current_priority; 40005ee4: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40005ee8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40005eec: 02 80 00 79 be 400060d0 <== NOT EXECUTED 40005ef0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40005ef4: 1a 80 00 6d bcc 400060a8 <== NOT EXECUTED 40005ef8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40005efc: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40005f00: 82 00 60 01 inc %g1 <== NOT EXECUTED 40005f04: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40005f08: 7f ff ef bf call 40001e04 <== NOT EXECUTED 40005f0c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Change_priority( 40005f10: d2 04 20 60 ld [ %l0 + 0x60 ], %o1 <== NOT EXECUTED 40005f14: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 <== NOT EXECUTED 40005f18: 40 00 0b 9b call 40008d84 <_Thread_Change_priority> <== NOT EXECUTED 40005f1c: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40005f20: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40005f24: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40005f28: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40005f2c: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 40005f30: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40005f34: 32 80 00 0c bne,a 40005f64 <== NOT EXECUTED 40005f38: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 40005f3c: 40 00 0c b6 call 40009214 <_Thread_Dispatch> <== NOT EXECUTED 40005f40: 01 00 00 00 nop <== NOT EXECUTED id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 40005f44: 10 80 00 08 b 40005f64 <== NOT EXECUTED 40005f48: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40005f4c: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 40005f50: 22 bf ff de be,a 40005ec8 <== NOT EXECUTED 40005f54: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 40005f58: 7f ff ef ab call 40001e04 40005f5c: 01 00 00 00 nop 40005f60: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 40005f64: 40 00 00 98 call 400061c4 <_Semaphore_Translate_core_mutex_return_code> 40005f68: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 return _Semaphore_Translate_core_semaphore_return_code( _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40005f6c: 81 c7 e0 08 ret 40005f70: 91 e8 00 08 restore %g0, %o0, %o0 /* * 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 ) ) { 40005f74: 80 a0 40 03 cmp %g1, %g3 40005f78: 12 80 00 0d bne 40005fac 40005f7c: 80 8e 60 01 btst 1, %i1 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40005f80: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 40005f84: 80 a0 60 00 cmp %g1, 0 40005f88: 12 80 00 40 bne 40006088 40005f8c: 80 a0 60 01 cmp %g1, 1 case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40005f90: c2 04 20 68 ld [ %l0 + 0x68 ], %g1 40005f94: 82 00 60 01 inc %g1 40005f98: c2 24 20 68 st %g1, [ %l0 + 0x68 ] _ISR_Enable( level ); 40005f9c: 7f ff ef 9a call 40001e04 40005fa0: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 40005fa4: 10 bf ff f0 b 40005f64 40005fa8: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 40005fac: 02 80 00 28 be 4000604c 40005fb0: c6 04 e0 3c ld [ %l3 + 0x3c ], %g3 40005fb4: 7f ff ef 94 call 40001e04 40005fb8: d0 07 bf f0 ld [ %fp + -16 ], %o0 40005fbc: c4 04 e0 3c ld [ %l3 + 0x3c ], %g2 40005fc0: 82 10 20 01 mov 1, %g1 40005fc4: 10 bf ff e7 b 40005f60 40005fc8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40005fcc: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40005fd0: 82 00 60 01 inc %g1 40005fd4: c2 24 63 60 st %g1, [ %l1 + 0x360 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 40005fd8: 82 10 20 01 mov 1, %g1 40005fdc: c2 24 20 44 st %g1, [ %l0 + 0x44 ] } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; 40005fe0: f0 24 a0 20 st %i0, [ %l2 + 0x20 ] return; } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 40005fe4: a0 04 20 14 add %l0, 0x14, %l0 40005fe8: e0 24 a0 44 st %l0, [ %l2 + 0x44 ] executing->Wait.id = id; _ISR_Enable( level ); 40005fec: 7f ff ef 86 call 40001e04 40005ff0: 01 00 00 00 nop _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 40005ff4: 90 10 00 10 mov %l0, %o0 40005ff8: 92 10 00 1a mov %i2, %o1 40005ffc: 15 10 00 27 sethi %hi(0x40009c00), %o2 40006000: 40 00 0d f5 call 400097d4 <_Thread_queue_Enqueue_with_handler> 40006004: 94 12 a1 14 or %o2, 0x114, %o2 ! 40009d14 <_Thread_queue_Timeout> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006008: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 4000600c: 82 00 7f ff add %g1, -1, %g1 40006010: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40006014: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40006018: 80 a0 a0 00 cmp %g2, 0 4000601c: 32 bf ff 80 bne,a 40005e1c 40006020: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 40006024: 40 00 0c 7c call 40009214 <_Thread_Dispatch> 40006028: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 4000602c: 10 bf ff 7c b 40005e1c 40006030: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; 40006034: 82 00 7f ff add %g1, -1, %g1 40006038: c2 24 20 5c st %g1, [ %l0 + 0x5c ] _ISR_Enable( level ); 4000603c: 7f ff ef 72 call 40001e04 40006040: 01 00 00 00 nop 40006044: 10 bf ff 76 b 40005e1c 40006048: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000604c: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40006050: 82 10 20 01 mov 1, %g1 40006054: c2 24 20 44 st %g1, [ %l0 + 0x44 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 40006058: f0 20 e0 20 st %i0, [ %g3 + 0x20 ] 4000605c: 84 00 a0 01 inc %g2 40006060: a0 04 20 14 add %l0, 0x14, %l0 40006064: c4 24 63 60 st %g2, [ %l1 + 0x360 ] 40006068: e0 20 e0 44 st %l0, [ %g3 + 0x44 ] 4000606c: 7f ff ef 66 call 40001e04 40006070: d0 07 bf f0 ld [ %fp + -16 ], %o0 40006074: 90 10 00 10 mov %l0, %o0 40006078: 40 00 03 9a call 40006ee0 <_CORE_mutex_Seize_interrupt_blocking> 4000607c: 92 10 00 1a mov %i2, %o1 id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 40006080: 10 bf ff b9 b 40005f64 40006084: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 * 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 ) { 40006088: 12 bf ff c9 bne 40005fac 4000608c: 80 8e 60 01 btst 1, %i1 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; 40006090: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40006094: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40006098: 7f ff ef 5b call 40001e04 <== NOT EXECUTED 4000609c: 01 00 00 00 nop <== NOT EXECUTED 400060a0: 10 bf ff b1 b 40005f64 <== NOT EXECUTED 400060a4: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 400060a8: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400060ac: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 400060b0: c0 24 20 68 clr [ %l0 + 0x68 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 400060b4: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 400060b8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400060bc: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400060c0: 7f ff ef 51 call 40001e04 <== NOT EXECUTED 400060c4: 01 00 00 00 nop <== NOT EXECUTED 400060c8: 10 bf ff a7 b 40005f64 <== NOT EXECUTED 400060cc: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 400060d0: 7f ff ef 4d call 40001e04 <== NOT EXECUTED 400060d4: 01 00 00 00 nop <== NOT EXECUTED 400060d8: 10 bf ff a3 b 40005f64 <== NOT EXECUTED 400060dc: c2 04 e0 3c ld [ %l3 + 0x3c ], %g1 <== NOT EXECUTED 400060e0 : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 400060e0: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 400060e4: 11 10 00 6a sethi %hi(0x4001a800), %o0 400060e8: 92 10 00 18 mov %i0, %o1 400060ec: 90 12 22 14 or %o0, 0x214, %o0 400060f0: 40 00 07 21 call 40007d74 <_Objects_Get> 400060f4: 94 07 bf f4 add %fp, -12, %o2 Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 400060f8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400060fc: 80 a0 60 00 cmp %g1, 0 40006100: 12 80 00 16 bne 40006158 40006104: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 40006108: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 4000610c: 80 88 60 30 btst 0x30, %g1 40006110: 02 80 00 17 be 4000616c 40006114: 92 10 00 18 mov %i0, %o1 mutex_status = _CORE_mutex_Surrender( 40006118: 94 10 20 00 clr %o2 4000611c: 40 00 03 95 call 40006f70 <_CORE_mutex_Surrender> 40006120: 90 02 20 14 add %o0, 0x14, %o0 40006124: b0 10 00 08 mov %o0, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006128: 03 10 00 6a sethi %hi(0x4001a800), %g1 4000612c: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 4001ab60 <_Thread_Dispatch_disable_level> 40006130: 84 00 bf ff add %g2, -1, %g2 40006134: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 40006138: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 4000613c: 80 a0 e0 00 cmp %g3, 0 40006140: 02 80 00 1e be 400061b8 40006144: 01 00 00 00 nop &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 40006148: 40 00 00 1f call 400061c4 <_Semaphore_Translate_core_mutex_return_code> 4000614c: 90 10 00 18 mov %i0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006150: 81 c7 e0 08 ret 40006154: 91 e8 00 08 restore %g0, %o0, %o0 Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 40006158: 08 bf ff fe bleu 40006150 4000615c: 90 10 20 04 mov 4, %o0 40006160: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006164: 81 c7 e0 08 ret <== NOT EXECUTED 40006168: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 4000616c: 94 10 20 00 clr %o2 40006170: 40 00 03 ef call 4000712c <_CORE_semaphore_Surrender> 40006174: 90 02 20 14 add %o0, 0x14, %o0 40006178: b0 10 00 08 mov %o0, %i0 4000617c: 03 10 00 6a sethi %hi(0x4001a800), %g1 40006180: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 4001ab60 <_Thread_Dispatch_disable_level> 40006184: 84 00 bf ff add %g2, -1, %g2 40006188: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 4000618c: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 40006190: 80 a0 e0 00 cmp %g3, 0 40006194: 02 80 00 06 be 400061ac 40006198: 01 00 00 00 nop &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return 4000619c: 40 00 00 14 call 400061ec <_Semaphore_Translate_core_semaphore_return_code> 400061a0: 90 10 00 18 mov %i0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400061a4: 81 c7 e0 08 ret 400061a8: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 400061ac: 40 00 0c 1a call 40009214 <_Thread_Dispatch> 400061b0: 01 00 00 00 nop 400061b4: 30 bf ff fa b,a 4000619c 400061b8: 40 00 0c 17 call 40009214 <_Thread_Dispatch> 400061bc: 01 00 00 00 nop 400061c0: 30 bf ff e2 b,a 40006148 400184f0 : */ void rtems_shutdown_executive( uint32_t result ) { 400184f0: 9d e3 bf 98 save %sp, -104, %sp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 400184f4: 33 10 00 6b sethi %hi(0x4001ac00), %i1 400184f8: c2 06 61 40 ld [ %i1 + 0x140 ], %g1 ! 4001ad40 <_System_state_Current> 400184fc: 80 a0 60 04 cmp %g1, 4 40018500: 02 80 00 0c be 40018530 40018504: 11 10 00 66 sethi %hi(0x40019800), %o0 #if defined(__USE_INIT_FINI__) extern void _fini( void ); atexit( _fini ); 40018508: 7f ff da 31 call 4000edcc 4001850c: 90 12 20 dc or %o0, 0xdc, %o0 ! 400198dc <_fini> * routine which initialized the system. */ RTEMS_INLINE_ROUTINE void _Thread_Stop_multitasking( void ) { _Context_Switch( &_Thread_Executing->Registers, &_Thread_BSP_context ); 40018510: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40018514: f0 00 60 3c ld [ %g1 + 0x3c ], %i0 ! 4001ac3c <_Thread_Executing> 40018518: 84 10 20 04 mov 4, %g2 4001851c: b0 06 20 e0 add %i0, 0xe0, %i0 40018520: c4 26 61 40 st %g2, [ %i1 + 0x140 ] 40018524: 33 10 00 6a sethi %hi(0x4001a800), %i1 40018528: 7f ff c9 62 call 4000aab0 <_CPU_Context_switch> 4001852c: 93 ee 62 d8 restore %i1, 0x2d8, %o1 40018530: 81 c7 e0 08 ret <== NOT EXECUTED 40018534: 81 e8 00 00 restore <== NOT EXECUTED 40011c2c : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 40011c2c: 9d e3 bf 90 save %sp, -112, %sp 40011c30: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 40011c34: 80 a6 60 00 cmp %i1, 0 40011c38: 02 80 00 1b be 40011ca4 40011c3c: b0 10 20 0a mov 0xa, %i0 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 40011c40: 80 a2 60 00 cmp %o1, 0 40011c44: 12 80 00 1a bne 40011cac 40011c48: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011c4c: 23 10 00 d3 sethi %hi(0x40034c00), %l1 40011c50: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 40011c54: 82 00 60 01 inc %g1 40011c58: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 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; 40011c5c: 03 10 00 d3 sethi %hi(0x40034c00), %g1 40011c60: e0 00 61 5c ld [ %g1 + 0x15c ], %l0 ! 40034d5c <_Thread_Executing> 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; 40011c64: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 40011c68: f0 04 21 6c ld [ %l0 + 0x16c ], %i0 asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 40011c6c: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 40011c70: 80 a0 60 00 cmp %g1, 0 40011c74: 32 80 00 2c bne,a 40011d24 40011c78: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011c7c: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40011c80: b0 10 20 0b mov 0xb, %i0 40011c84: 82 00 7f ff add %g1, -1, %g1 40011c88: c2 24 60 80 st %g1, [ %l1 + 0x80 ] 40011c8c: c4 04 60 80 ld [ %l1 + 0x80 ], %g2 40011c90: 80 a0 a0 00 cmp %g2, 0 40011c94: 12 80 00 0b bne 40011cc0 40011c98: 01 00 00 00 nop _Thread_Dispatch(); 40011c9c: 40 00 13 70 call 40016a5c <_Thread_Dispatch> 40011ca0: 01 00 00 00 nop 40011ca4: 81 c7 e0 08 ret 40011ca8: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40011cac: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 40011cb0: 80 a0 a0 04 cmp %g2, 4 40011cb4: 08 80 00 05 bleu 40011cc8 40011cb8: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40011cbc: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40011cc0: 81 c7 e0 08 ret 40011cc4: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40011cc8: 80 a0 60 01 cmp %g1, 1 40011ccc: 12 bf ff f6 bne 40011ca4 40011cd0: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40011cd4: 83 28 a0 02 sll %g2, 2, %g1 40011cd8: 05 10 00 d2 sethi %hi(0x40034800), %g2 40011cdc: 84 10 a3 e0 or %g2, 0x3e0, %g2 ! 40034be0 <_Objects_Information_table> 40011ce0: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40011ce4: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40011ce8: 80 a2 20 00 cmp %o0, 0 40011cec: 02 bf ff f5 be 40011cc0 40011cf0: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40011cf4: 40 00 0e 32 call 400155bc <_Objects_Get> 40011cf8: 94 07 bf f4 add %fp, -12, %o2 if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40011cfc: c2 07 bf f4 ld [ %fp + -12 ], %g1 40011d00: a0 10 00 08 mov %o0, %l0 40011d04: 80 a0 60 00 cmp %g1, 0 40011d08: 02 bf ff d8 be 40011c68 40011d0c: 23 10 00 d3 sethi %hi(0x40034c00), %l1 40011d10: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40011d14: 18 bf ff e4 bgu 40011ca4 <== NOT EXECUTED 40011d18: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40011d1c: 81 c7 e0 08 ret <== NOT EXECUTED 40011d20: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { if ( asr->is_enabled ) { 40011d24: 80 a0 60 00 cmp %g1, 0 40011d28: 02 80 00 19 be 40011d8c 40011d2c: 01 00 00 00 nop rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 40011d30: 7f ff e3 79 call 4000ab14 40011d34: 01 00 00 00 nop *signal_set |= signals; 40011d38: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 40011d3c: 82 10 40 19 or %g1, %i1, %g1 40011d40: c2 26 20 54 st %g1, [ %i0 + 0x54 ] _ISR_Enable( _level ); 40011d44: 7f ff e3 78 call 4000ab24 40011d48: 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 ) ) 40011d4c: 03 10 00 d3 sethi %hi(0x40034c00), %g1 40011d50: c4 00 61 44 ld [ %g1 + 0x144 ], %g2 ! 40034d44 <_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; 40011d54: 86 10 20 01 mov 1, %g3 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 40011d58: 80 a0 a0 00 cmp %g2, 0 40011d5c: 02 80 00 09 be 40011d80 40011d60: c6 24 20 78 st %g3, [ %l0 + 0x78 ] 40011d64: 03 10 00 d3 sethi %hi(0x40034c00), %g1 <== NOT EXECUTED 40011d68: c4 00 61 5c ld [ %g1 + 0x15c ], %g2 ! 40034d5c <_Thread_Executing> <== NOT EXECUTED 40011d6c: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 40011d70: 12 80 00 04 bne 40011d80 <== NOT EXECUTED 40011d74: 01 00 00 00 nop <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 40011d78: 03 10 00 d3 sethi %hi(0x40034c00), %g1 <== NOT EXECUTED 40011d7c: c6 20 62 08 st %g3, [ %g1 + 0x208 ] ! 40034e08 <_ISR_Signals_to_thread_executing> <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011d80: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 40011d84: 10 bf ff c0 b 40011c84 40011d88: b0 10 20 00 clr %i0 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 40011d8c: 7f ff e3 62 call 4000ab14 40011d90: 01 00 00 00 nop *signal_set |= signals; 40011d94: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 40011d98: 82 10 40 19 or %g1, %i1, %g1 40011d9c: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _ISR_Enable( _level ); 40011da0: 7f ff e3 61 call 4000ab24 40011da4: 01 00 00 00 nop 40011da8: 30 bf ff f6 b,a 40011d80 40006380 : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 40006380: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 40006384: 92 96 20 00 orcc %i0, 0, %o1 40006388: 12 80 00 20 bne 40006408 4000638c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006390: 21 10 00 6a sethi %hi(0x4001a800), %l0 40006394: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> 40006398: 82 00 60 01 inc %g1 4000639c: c2 24 23 60 st %g1, [ %l0 + 0x360 ] 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; 400063a0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400063a4: f0 00 60 3c ld [ %g1 + 0x3c ], %i0 ! 4001ac3c <_Thread_Executing> 400063a8: 07 10 00 6a sethi %hi(0x4001a800), %g3 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; 400063ac: c0 27 bf f4 clr [ %fp + -12 ] 400063b0: a2 10 e2 c0 or %g3, 0x2c0, %l1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_information = _Objects_Get_information( the_thread->Object.id ); 400063b4: c2 06 20 08 ld [ %i0 + 8 ], %g1 400063b8: 85 30 60 16 srl %g1, 0x16, %g2 400063bc: 84 08 a0 1c and %g2, 0x1c, %g2 400063c0: c6 04 40 02 ld [ %l1 + %g2 ], %g3 400063c4: 83 30 60 1b srl %g1, 0x1b, %g1 400063c8: 83 28 60 02 sll %g1, 2, %g1 400063cc: d0 00 c0 01 ld [ %g3 + %g1 ], %o0 if ( !the_information ) { 400063d0: 80 a2 20 00 cmp %o0, 0 400063d4: 12 80 00 13 bne 40006420 400063d8: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400063dc: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 <== NOT EXECUTED 400063e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400063e4: c2 24 23 60 st %g1, [ %l0 + 0x360 ] <== NOT EXECUTED 400063e8: c4 04 23 60 ld [ %l0 + 0x360 ], %g2 <== NOT EXECUTED 400063ec: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400063f0: 12 80 00 04 bne 40006400 <== NOT EXECUTED 400063f4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Dispatch(); 400063f8: 40 00 0b 87 call 40009214 <_Thread_Dispatch> <== NOT EXECUTED 400063fc: 01 00 00 00 nop <== NOT EXECUTED 40006400: 81 c7 e0 08 ret 40006404: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40006408: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 4000640c: 80 a0 a0 04 cmp %g2, 4 40006410: 08 80 00 1b bleu 4000647c 40006414: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006418: 81 c7 e0 08 ret <== NOT EXECUTED 4000641c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INVALID_ID; /* This should never happen if _Thread_Get() works right */ } _Thread_Close( the_information, the_thread ); 40006420: 40 00 0a ff call 4000901c <_Thread_Close> 40006424: 92 10 00 18 mov %i0, %o1 40006428: c4 06 20 08 ld [ %i0 + 8 ], %g2 4000642c: 92 10 00 18 mov %i0, %o1 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 40006430: 83 30 a0 16 srl %g2, 0x16, %g1 40006434: 82 08 60 1c and %g1, 0x1c, %g1 40006438: c6 04 40 01 ld [ %l1 + %g1 ], %g3 4000643c: 85 30 a0 1b srl %g2, 0x1b, %g2 40006440: 85 28 a0 02 sll %g2, 2, %g2 40006444: 40 00 06 09 call 40007c68 <_Objects_Free> 40006448: d0 00 c0 02 ld [ %g3 + %g2 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000644c: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 40006450: b0 10 20 00 clr %i0 40006454: 82 00 7f ff add %g1, -1, %g1 40006458: c2 24 23 60 st %g1, [ %l0 + 0x360 ] 4000645c: c4 04 23 60 ld [ %l0 + 0x360 ], %g2 40006460: 80 a0 a0 00 cmp %g2, 0 40006464: 12 80 00 04 bne 40006474 40006468: 01 00 00 00 nop _Thread_Dispatch(); 4000646c: 40 00 0b 6a call 40009214 <_Thread_Dispatch> 40006470: 01 00 00 00 nop 40006474: 81 c7 e0 08 ret 40006478: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4000647c: 80 a0 60 01 cmp %g1, 1 40006480: 12 bf ff e0 bne 40006400 40006484: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40006488: 85 28 a0 02 sll %g2, 2, %g2 4000648c: 07 10 00 6a sethi %hi(0x4001a800), %g3 40006490: a2 10 e2 c0 or %g3, 0x2c0, %l1 ! 4001aac0 <_Objects_Information_table> 40006494: c2 04 40 02 ld [ %l1 + %g2 ], %g1 40006498: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 4000649c: 80 a2 20 00 cmp %o0, 0 400064a0: 02 bf ff f5 be 40006474 400064a4: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 400064a8: 40 00 06 33 call 40007d74 <_Objects_Get> 400064ac: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; the_thread = _Thread_Get( id, &location ); switch ( location ) { 400064b0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400064b4: b0 10 00 08 mov %o0, %i0 400064b8: 80 a0 60 00 cmp %g1, 0 400064bc: 02 bf ff be be 400063b4 400064c0: 21 10 00 6a sethi %hi(0x4001a800), %l0 400064c4: 80 a0 60 02 cmp %g1, 2 400064c8: 18 bf ff ce bgu 40006400 400064cc: b0 10 20 19 mov 0x19, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 400064d0: 81 c7 e0 08 ret 400064d4: 91 e8 20 04 restore %g0, 4, %o0 40007c8c : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 40007c8c: 9d e3 bf 90 save %sp, -112, %sp 40007c90: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !note ) 40007c94: 80 a6 a0 00 cmp %i2, 0 40007c98: 02 80 00 3b be 40007d84 40007c9c: 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 ) 40007ca0: 80 a6 60 0f cmp %i1, 0xf 40007ca4: 18 80 00 38 bgu 40007d84 40007ca8: b0 10 20 0a mov 0xa, %i0 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 40007cac: 80 a2 60 00 cmp %o1, 0 40007cb0: 12 80 00 09 bne 40007cd4 40007cb4: 07 10 00 81 sethi %hi(0x40020400), %g3 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 40007cb8: c2 00 e1 9c ld [ %g3 + 0x19c ], %g1 ! 4002059c <_Thread_Executing> 40007cbc: 87 2e 60 02 sll %i1, 2, %g3 40007cc0: c4 00 61 6c ld [ %g1 + 0x16c ], %g2 40007cc4: c2 00 80 03 ld [ %g2 + %g3 ], %g1 40007cc8: c2 26 80 00 st %g1, [ %i2 ] 40007ccc: 81 c7 e0 08 ret 40007cd0: 91 e8 20 00 restore %g0, 0, %o0 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 40007cd4: c2 00 e1 9c ld [ %g3 + 0x19c ], %g1 40007cd8: c4 00 60 08 ld [ %g1 + 8 ], %g2 40007cdc: 80 a2 40 02 cmp %o1, %g2 40007ce0: 22 bf ff f8 be,a 40007cc0 40007ce4: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40007ce8: 83 32 60 18 srl %o1, 0x18, %g1 40007cec: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 40007cf0: 80 a0 a0 04 cmp %g2, 4 40007cf4: 08 80 00 04 bleu 40007d04 40007cf8: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007cfc: 81 c7 e0 08 ret <== NOT EXECUTED 40007d00: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40007d04: 80 a0 60 01 cmp %g1, 1 40007d08: 12 80 00 1f bne 40007d84 40007d0c: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007d10: 83 28 a0 02 sll %g2, 2, %g1 40007d14: 05 10 00 81 sethi %hi(0x40020400), %g2 40007d18: 84 10 a0 20 or %g2, 0x20, %g2 ! 40020420 <_Objects_Information_table> 40007d1c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40007d20: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40007d24: 80 a2 20 00 cmp %o0, 0 40007d28: 02 80 00 17 be 40007d84 40007d2c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007d30: 40 00 07 79 call 40009b14 <_Objects_Get> 40007d34: 94 07 bf f4 add %fp, -12, %o2 *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007d38: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007d3c: 80 a0 60 00 cmp %g1, 0 40007d40: 12 80 00 13 bne 40007d8c 40007d44: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 40007d48: c6 02 21 6c ld [ %o0 + 0x16c ], %g3 40007d4c: 83 2e 60 02 sll %i1, 2, %g1 40007d50: c4 00 c0 01 ld [ %g3 + %g1 ], %g2 40007d54: c4 26 80 00 st %g2, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007d58: 07 10 00 81 sethi %hi(0x40020400), %g3 40007d5c: c2 00 e0 c0 ld [ %g3 + 0xc0 ], %g1 ! 400204c0 <_Thread_Dispatch_disable_level> 40007d60: b0 10 20 00 clr %i0 40007d64: 82 00 7f ff add %g1, -1, %g1 40007d68: c2 20 e0 c0 st %g1, [ %g3 + 0xc0 ] 40007d6c: c4 00 e0 c0 ld [ %g3 + 0xc0 ], %g2 40007d70: 80 a0 a0 00 cmp %g2, 0 40007d74: 12 80 00 04 bne 40007d84 40007d78: 01 00 00 00 nop _Thread_Dispatch(); 40007d7c: 40 00 0c 52 call 4000aec4 <_Thread_Dispatch> 40007d80: 01 00 00 00 nop 40007d84: 81 c7 e0 08 ret 40007d88: 81 e8 00 00 restore *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007d8c: 18 bf ff fe bgu 40007d84 <== NOT EXECUTED 40007d90: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 40007d94: 81 c7 e0 08 ret <== NOT EXECUTED 40007d98: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40006b68 : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 40006b68: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 40006b6c: 92 96 20 00 orcc %i0, 0, %o1 40006b70: 12 80 00 19 bne 40006bd4 40006b74: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006b78: 05 10 00 78 sethi %hi(0x4001e000), %g2 <== NOT EXECUTED 40006b7c: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 ! 4001e350 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40006b80: 82 00 60 01 inc %g1 <== NOT EXECUTED 40006b84: c2 20 a3 50 st %g1, [ %g2 + 0x350 ] <== NOT EXECUTED 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; 40006b88: 03 10 00 79 sethi %hi(0x4001e400), %g1 <== NOT EXECUTED 40006b8c: d0 00 60 2c ld [ %g1 + 0x2c ], %o0 ! 4001e42c <_Thread_Executing> <== NOT EXECUTED 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; 40006b90: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 40006b94: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40006b98: 80 88 60 02 btst 2, %g1 40006b9c: 02 80 00 15 be 40006bf0 40006ba0: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006ba4: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 40006ba8: b0 10 20 0f mov 0xf, %i0 40006bac: 82 00 7f ff add %g1, -1, %g1 40006bb0: c2 20 a3 50 st %g1, [ %g2 + 0x350 ] 40006bb4: c4 00 a3 50 ld [ %g2 + 0x350 ], %g2 40006bb8: 80 a0 a0 00 cmp %g2, 0 40006bbc: 12 80 00 0b bne 40006be8 40006bc0: 01 00 00 00 nop _Thread_Dispatch(); 40006bc4: 40 00 0b 74 call 40009994 <_Thread_Dispatch> 40006bc8: 01 00 00 00 nop 40006bcc: 81 c7 e0 08 ret 40006bd0: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40006bd4: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 40006bd8: 80 a0 a0 04 cmp %g2, 4 40006bdc: 08 80 00 08 bleu 40006bfc 40006be0: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40006be4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006be8: 81 c7 e0 08 ret <== NOT EXECUTED 40006bec: 81 e8 00 00 restore <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006bf0: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 40006bf4: 10 bf ff ee b 40006bac 40006bf8: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40006bfc: 80 a0 60 01 cmp %g1, 1 40006c00: 12 bf ff f3 bne 40006bcc 40006c04: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40006c08: 83 28 a0 02 sll %g2, 2, %g1 40006c0c: 05 10 00 78 sethi %hi(0x4001e000), %g2 40006c10: 84 10 a2 b0 or %g2, 0x2b0, %g2 ! 4001e2b0 <_Objects_Information_table> 40006c14: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40006c18: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40006c1c: 80 a2 20 00 cmp %o0, 0 40006c20: 02 bf ff f2 be 40006be8 40006c24: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40006c28: 40 00 06 6f call 400085e4 <_Objects_Get> 40006c2c: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40006c30: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006c34: 80 a0 60 00 cmp %g1, 0 40006c38: 02 bf ff d7 be 40006b94 40006c3c: 05 10 00 78 sethi %hi(0x4001e000), %g2 40006c40: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40006c44: 18 bf ff e2 bgu 40006bcc <== NOT EXECUTED 40006c48: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40006c4c: 81 c7 e0 08 ret <== NOT EXECUTED 40006c50: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40007144 : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 40007144: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 40007148: 92 96 20 00 orcc %i0, 0, %o1 4000714c: 12 80 00 1b bne 400071b8 40007150: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007154: 21 10 00 7a sethi %hi(0x4001e800), %l0 40007158: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 ! 4001e810 <_Thread_Dispatch_disable_level> 4000715c: 82 00 60 01 inc %g1 40007160: c2 24 20 10 st %g1, [ %l0 + 0x10 ] 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; 40007164: 03 10 00 7a sethi %hi(0x4001e800), %g1 40007168: d0 00 60 ec ld [ %g1 + 0xec ], %o0 ! 4001e8ec <_Thread_Executing> 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; 4000716c: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 40007170: 94 10 00 19 mov %i1, %o2 40007174: 40 00 0e 4b call 4000aaa0 <_Thread_Restart> 40007178: 92 10 20 00 clr %o1 4000717c: 80 a2 20 00 cmp %o0, 0 40007180: 12 80 00 15 bne 400071d4 40007184: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007188: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 4000718c: b0 10 20 0e mov 0xe, %i0 40007190: 82 00 7f ff add %g1, -1, %g1 40007194: c2 24 20 10 st %g1, [ %l0 + 0x10 ] 40007198: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 4000719c: 80 a0 a0 00 cmp %g2, 0 400071a0: 12 80 00 0b bne 400071cc 400071a4: 01 00 00 00 nop _Thread_Dispatch(); 400071a8: 40 00 0b 48 call 40009ec8 <_Thread_Dispatch> 400071ac: 01 00 00 00 nop 400071b0: 81 c7 e0 08 ret 400071b4: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 400071b8: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 400071bc: 80 a0 a0 04 cmp %g2, 4 400071c0: 08 80 00 08 bleu 400071e0 400071c4: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 400071c8: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400071cc: 81 c7 e0 08 ret <== NOT EXECUTED 400071d0: 81 e8 00 00 restore <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400071d4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 400071d8: 10 bf ff ee b 40007190 400071dc: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 400071e0: 80 a0 60 01 cmp %g1, 1 400071e4: 12 bf ff f3 bne 400071b0 400071e8: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400071ec: 83 28 a0 02 sll %g2, 2, %g1 400071f0: 05 10 00 79 sethi %hi(0x4001e400), %g2 400071f4: 84 10 a3 70 or %g2, 0x370, %g2 ! 4001e770 <_Objects_Information_table> 400071f8: c6 00 80 01 ld [ %g2 + %g1 ], %g3 400071fc: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40007200: 80 a2 20 00 cmp %o0, 0 40007204: 02 bf ff f2 be 400071cc 40007208: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4000720c: 40 00 06 43 call 40008b18 <_Objects_Get> 40007210: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007214: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007218: 80 a0 60 00 cmp %g1, 0 4000721c: 02 bf ff d5 be 40007170 40007220: 21 10 00 7a sethi %hi(0x4001e800), %l0 40007224: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40007228: 18 bf ff e2 bgu 400071b0 <== NOT EXECUTED 4000722c: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40007230: 81 c7 e0 08 ret <== NOT EXECUTED 40007234: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40007c00 : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 40007c00: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 40007c04: 92 96 20 00 orcc %i0, 0, %o1 40007c08: 12 80 00 19 bne 40007c6c 40007c0c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007c10: 21 10 00 9e sethi %hi(0x40027800), %l0 40007c14: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 ! 40027890 <_Thread_Dispatch_disable_level> 40007c18: 82 00 60 01 inc %g1 40007c1c: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 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; 40007c20: 03 10 00 9e sethi %hi(0x40027800), %g1 40007c24: d0 00 61 6c ld [ %g1 + 0x16c ], %o0 ! 4002796c <_Thread_Executing> 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; 40007c28: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 40007c2c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40007c30: 80 88 60 02 btst 2, %g1 40007c34: 12 80 00 2b bne 40007ce0 40007c38: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007c3c: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 40007c40: b0 10 20 0e mov 0xe, %i0 40007c44: 82 00 7f ff add %g1, -1, %g1 40007c48: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 40007c4c: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 40007c50: 80 a0 a0 00 cmp %g2, 0 40007c54: 12 80 00 0b bne 40007c80 40007c58: 01 00 00 00 nop _Thread_Dispatch(); 40007c5c: 40 00 0c 2d call 4000ad10 <_Thread_Dispatch> 40007c60: 01 00 00 00 nop 40007c64: 81 c7 e0 08 ret 40007c68: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40007c6c: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 40007c70: 80 a0 a0 04 cmp %g2, 4 40007c74: 08 80 00 05 bleu 40007c88 40007c78: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40007c7c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007c80: 81 c7 e0 08 ret 40007c84: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40007c88: 80 a0 60 01 cmp %g1, 1 40007c8c: 12 bf ff f6 bne 40007c64 40007c90: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007c94: 83 28 a0 02 sll %g2, 2, %g1 40007c98: 05 10 00 9d sethi %hi(0x40027400), %g2 40007c9c: 84 10 a3 f0 or %g2, 0x3f0, %g2 ! 400277f0 <_Objects_Information_table> 40007ca0: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40007ca4: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40007ca8: 80 a2 20 00 cmp %o0, 0 40007cac: 02 bf ff f5 be 40007c80 40007cb0: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007cb4: 40 00 07 2b call 40009960 <_Objects_Get> 40007cb8: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007cbc: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007cc0: 80 a0 60 00 cmp %g1, 0 40007cc4: 02 bf ff da be 40007c2c 40007cc8: 21 10 00 9e sethi %hi(0x40027800), %l0 40007ccc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40007cd0: 18 bf ff e5 bgu 40007c64 <== NOT EXECUTED 40007cd4: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40007cd8: 81 c7 e0 08 ret <== NOT EXECUTED 40007cdc: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { _Thread_Resume( the_thread, TRUE ); 40007ce0: 40 00 0f 18 call 4000b940 <_Thread_Resume> 40007ce4: 92 10 20 01 mov 1, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007ce8: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 40007cec: 10 bf ff d6 b 40007c44 40007cf0: b0 10 20 00 clr %i0 40007f6c : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 40007f6c: 9d e3 bf 90 save %sp, -112, %sp 40007f70: 92 10 00 18 mov %i0, %o1 /* * 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 ) 40007f74: 80 a6 60 0f cmp %i1, 0xf 40007f78: 18 80 00 36 bgu 40008050 40007f7c: b0 10 20 0a mov 0xa, %i0 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 40007f80: 80 a2 60 00 cmp %o1, 0 40007f84: 12 80 00 08 bne 40007fa4 40007f88: 07 10 00 81 sethi %hi(0x40020400), %g3 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 40007f8c: c2 00 e1 9c ld [ %g3 + 0x19c ], %g1 ! 4002059c <_Thread_Executing> <== NOT EXECUTED 40007f90: c4 00 61 6c ld [ %g1 + 0x16c ], %g2 <== NOT EXECUTED 40007f94: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED 40007f98: f4 20 80 03 st %i2, [ %g2 + %g3 ] <== NOT EXECUTED 40007f9c: 81 c7 e0 08 ret <== NOT EXECUTED 40007fa0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 40007fa4: c2 00 e1 9c ld [ %g3 + 0x19c ], %g1 40007fa8: c4 00 60 08 ld [ %g1 + 8 ], %g2 40007fac: 80 a2 40 02 cmp %o1, %g2 40007fb0: 22 bf ff f9 be,a 40007f94 40007fb4: c4 00 61 6c ld [ %g1 + 0x16c ], %g2 <== NOT EXECUTED 40007fb8: 83 32 60 18 srl %o1, 0x18, %g1 40007fbc: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 40007fc0: 80 a0 a0 04 cmp %g2, 4 40007fc4: 08 80 00 04 bleu 40007fd4 40007fc8: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007fcc: 81 c7 e0 08 ret <== NOT EXECUTED 40007fd0: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40007fd4: 80 a0 60 01 cmp %g1, 1 40007fd8: 12 80 00 1e bne 40008050 40007fdc: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007fe0: 83 28 a0 02 sll %g2, 2, %g1 40007fe4: 05 10 00 81 sethi %hi(0x40020400), %g2 40007fe8: 84 10 a0 20 or %g2, 0x20, %g2 ! 40020420 <_Objects_Information_table> 40007fec: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40007ff0: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40007ff4: 80 a2 20 00 cmp %o0, 0 40007ff8: 02 80 00 16 be 40008050 40007ffc: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40008000: 40 00 06 c5 call 40009b14 <_Objects_Get> 40008004: 94 07 bf f4 add %fp, -12, %o2 api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40008008: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000800c: 80 a0 60 00 cmp %g1, 0 40008010: 12 80 00 12 bne 40008058 40008014: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 40008018: c4 02 21 6c ld [ %o0 + 0x16c ], %g2 4000801c: 83 2e 60 02 sll %i1, 2, %g1 40008020: f4 20 80 01 st %i2, [ %g2 + %g1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008024: 07 10 00 81 sethi %hi(0x40020400), %g3 40008028: c2 00 e0 c0 ld [ %g3 + 0xc0 ], %g1 ! 400204c0 <_Thread_Dispatch_disable_level> 4000802c: b0 10 20 00 clr %i0 40008030: 82 00 7f ff add %g1, -1, %g1 40008034: c2 20 e0 c0 st %g1, [ %g3 + 0xc0 ] 40008038: c4 00 e0 c0 ld [ %g3 + 0xc0 ], %g2 4000803c: 80 a0 a0 00 cmp %g2, 0 40008040: 12 80 00 04 bne 40008050 40008044: 01 00 00 00 nop _Thread_Dispatch(); 40008048: 40 00 0b 9f call 4000aec4 <_Thread_Dispatch> 4000804c: 01 00 00 00 nop 40008050: 81 c7 e0 08 ret 40008054: 81 e8 00 00 restore api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40008058: 18 bf ff fe bgu 40008050 <== NOT EXECUTED 4000805c: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 40008060: 81 c7 e0 08 ret <== NOT EXECUTED 40008064: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 4000d554 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 4000d554: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 4000d558: 80 a6 60 00 cmp %i1, 0 4000d55c: 02 80 00 06 be 4000d574 4000d560: 92 10 00 18 mov %i0, %o1 4000d564: 82 06 7f ff add %i1, -1, %g1 4000d568: 80 a0 60 fe cmp %g1, 0xfe 4000d56c: 18 80 00 26 bgu 4000d604 4000d570: b0 10 20 13 mov 0x13, %i0 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 4000d574: 80 a6 a0 00 cmp %i2, 0 4000d578: 02 80 00 23 be 4000d604 4000d57c: b0 10 20 09 mov 9, %i0 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 4000d580: 80 a2 60 00 cmp %o1, 0 4000d584: 12 80 00 22 bne 4000d60c 4000d588: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000d58c: 21 10 00 b2 sethi %hi(0x4002c800), %l0 4000d590: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 ! 4002c8a0 <_Thread_Dispatch_disable_level> 4000d594: 82 00 60 01 inc %g1 4000d598: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] 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; 4000d59c: 03 10 00 b2 sethi %hi(0x4002c800), %g1 4000d5a0: d0 00 61 7c ld [ %g1 + 0x17c ], %o0 ! 4002c97c <_Thread_Executing> 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; 4000d5a4: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: /* XXX convert from core priority */ *old_priority = the_thread->current_priority; 4000d5a8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 4000d5ac: 80 a6 60 00 cmp %i1, 0 4000d5b0: 02 80 00 0d be 4000d5e4 4000d5b4: c2 26 80 00 st %g1, [ %i2 ] the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 4000d5b8: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 4000d5bc: 80 a0 60 00 cmp %g1, 0 4000d5c0: 02 80 00 06 be 4000d5d8 4000d5c4: f2 22 20 18 st %i1, [ %o0 + 0x18 ] 4000d5c8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 4000d5cc: 80 a6 40 01 cmp %i1, %g1 4000d5d0: 1a 80 00 05 bcc 4000d5e4 4000d5d4: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 4000d5d8: 92 10 00 19 mov %i1, %o1 4000d5dc: 40 00 0a 7f call 4000ffd8 <_Thread_Change_priority> 4000d5e0: 94 10 20 00 clr %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000d5e4: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 4000d5e8: b0 10 20 00 clr %i0 4000d5ec: 82 00 7f ff add %g1, -1, %g1 4000d5f0: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] 4000d5f4: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 4000d5f8: 80 a0 a0 00 cmp %g2, 0 4000d5fc: 02 80 00 0a be 4000d624 4000d600: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000d604: 81 c7 e0 08 ret 4000d608: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 4000d60c: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 4000d610: 80 a0 a0 04 cmp %g2, 4 4000d614: 08 80 00 08 bleu 4000d634 4000d618: 83 32 60 1b srl %o1, 0x1b, %g1 4000d61c: 81 c7 e0 08 ret <== NOT EXECUTED 4000d620: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4000d624: 40 00 0b 91 call 40010468 <_Thread_Dispatch> 4000d628: 01 00 00 00 nop 4000d62c: 81 c7 e0 08 ret 4000d630: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4000d634: 80 a0 60 01 cmp %g1, 1 4000d638: 12 bf ff f3 bne 4000d604 4000d63c: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4000d640: 83 28 a0 02 sll %g2, 2, %g1 4000d644: 05 10 00 b2 sethi %hi(0x4002c800), %g2 4000d648: 84 10 a0 00 mov %g2, %g2 ! 4002c800 <_Objects_Information_table> 4000d64c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 4000d650: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 4000d654: 80 a2 20 00 cmp %o0, 0 4000d658: 02 bf ff f5 be 4000d62c 4000d65c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4000d660: 40 00 06 5a call 4000efc8 <_Objects_Get> 4000d664: 94 07 bf f4 add %fp, -12, %o2 if ( !old_priority ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000d668: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000d66c: 80 a0 60 00 cmp %g1, 0 4000d670: 02 bf ff ce be 4000d5a8 4000d674: 21 10 00 b2 sethi %hi(0x4002c800), %l0 4000d678: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000d67c: 18 bf ff e2 bgu 4000d604 <== NOT EXECUTED 4000d680: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4000d684: 81 c7 e0 08 ret <== NOT EXECUTED 4000d688: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40006614 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 40006614: 9d e3 bf 90 save %sp, -112, %sp 40006618: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 4000661c: 80 a6 60 00 cmp %i1, 0 40006620: 02 80 00 1e be 40006698 40006624: b0 10 20 09 mov 9, %i0 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 40006628: 80 a2 60 00 cmp %o1, 0 4000662c: 12 80 00 1d bne 400066a0 40006630: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006634: 21 10 00 6a sethi %hi(0x4001a800), %l0 40006638: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 ! 4001ab60 <_Thread_Dispatch_disable_level> 4000663c: 82 00 60 01 inc %g1 40006640: c2 24 23 60 st %g1, [ %l0 + 0x360 ] 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; 40006644: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006648: d0 00 60 3c ld [ %g1 + 0x3c ], %o0 ! 4001ac3c <_Thread_Executing> 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; 4000664c: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Start( 40006650: 94 10 00 19 mov %i1, %o2 40006654: 98 10 00 1a mov %i2, %o4 40006658: 92 10 20 00 clr %o1 4000665c: 40 00 0e c9 call 4000a180 <_Thread_Start> 40006660: 96 10 20 00 clr %o3 40006664: 80 a2 20 00 cmp %o0, 0 40006668: 12 80 00 2b bne 40006714 4000666c: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006670: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 40006674: b0 10 20 0e mov 0xe, %i0 40006678: 82 00 7f ff add %g1, -1, %g1 4000667c: c2 24 23 60 st %g1, [ %l0 + 0x360 ] 40006680: c4 04 23 60 ld [ %l0 + 0x360 ], %g2 40006684: 80 a0 a0 00 cmp %g2, 0 40006688: 12 80 00 0b bne 400066b4 4000668c: 01 00 00 00 nop _Thread_Dispatch(); 40006690: 40 00 0a e1 call 40009214 <_Thread_Dispatch> 40006694: 01 00 00 00 nop 40006698: 81 c7 e0 08 ret 4000669c: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 400066a0: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 400066a4: 80 a0 a0 04 cmp %g2, 4 400066a8: 08 80 00 05 bleu 400066bc 400066ac: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 400066b0: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400066b4: 81 c7 e0 08 ret 400066b8: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 400066bc: 80 a0 60 01 cmp %g1, 1 400066c0: 12 bf ff f6 bne 40006698 400066c4: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400066c8: 83 28 a0 02 sll %g2, 2, %g1 400066cc: 05 10 00 6a sethi %hi(0x4001a800), %g2 400066d0: 84 10 a2 c0 or %g2, 0x2c0, %g2 ! 4001aac0 <_Objects_Information_table> 400066d4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 400066d8: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 400066dc: 80 a2 20 00 cmp %o0, 0 400066e0: 02 bf ff f5 be 400066b4 400066e4: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 400066e8: 40 00 05 a3 call 40007d74 <_Objects_Get> 400066ec: 94 07 bf f4 add %fp, -12, %o2 if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 400066f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400066f4: 80 a0 60 00 cmp %g1, 0 400066f8: 02 bf ff d6 be 40006650 400066fc: 21 10 00 6a sethi %hi(0x4001a800), %l0 40006700: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40006704: 18 bf ff e5 bgu 40006698 <== NOT EXECUTED 40006708: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4000670c: 81 c7 e0 08 ret <== NOT EXECUTED 40006710: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006714: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 40006718: 10 bf ff d8 b 40006678 4000671c: b0 10 20 00 clr %i0 40007e00 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 40007e00: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 40007e04: 92 96 20 00 orcc %i0, 0, %o1 40007e08: 12 80 00 19 bne 40007e6c 40007e0c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007e10: 21 10 00 9e sethi %hi(0x40027800), %l0 40007e14: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 ! 40027890 <_Thread_Dispatch_disable_level> 40007e18: 82 00 60 01 inc %g1 40007e1c: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 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; 40007e20: 03 10 00 9e sethi %hi(0x40027800), %g1 40007e24: d0 00 61 6c ld [ %g1 + 0x16c ], %o0 ! 4002796c <_Thread_Executing> 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; 40007e28: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 40007e2c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40007e30: 80 88 60 02 btst 2, %g1 40007e34: 02 80 00 2b be 40007ee0 40007e38: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007e3c: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 40007e40: b0 10 20 0f mov 0xf, %i0 40007e44: 82 00 7f ff add %g1, -1, %g1 40007e48: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 40007e4c: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 40007e50: 80 a0 a0 00 cmp %g2, 0 40007e54: 12 80 00 0b bne 40007e80 40007e58: 01 00 00 00 nop _Thread_Dispatch(); 40007e5c: 40 00 0b ad call 4000ad10 <_Thread_Dispatch> 40007e60: 01 00 00 00 nop 40007e64: 81 c7 e0 08 ret 40007e68: 81 e8 00 00 restore 40007e6c: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 40007e70: 80 a0 a0 04 cmp %g2, 4 40007e74: 08 80 00 05 bleu 40007e88 40007e78: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40007e7c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007e80: 81 c7 e0 08 ret <== NOT EXECUTED 40007e84: 81 e8 00 00 restore <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40007e88: 80 a0 60 01 cmp %g1, 1 40007e8c: 12 bf ff f6 bne 40007e64 40007e90: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007e94: 83 28 a0 02 sll %g2, 2, %g1 40007e98: 05 10 00 9d sethi %hi(0x40027400), %g2 40007e9c: 84 10 a3 f0 or %g2, 0x3f0, %g2 ! 400277f0 <_Objects_Information_table> 40007ea0: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40007ea4: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40007ea8: 80 a2 20 00 cmp %o0, 0 40007eac: 02 bf ff f5 be 40007e80 40007eb0: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007eb4: 40 00 06 ab call 40009960 <_Objects_Get> 40007eb8: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007ebc: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007ec0: 80 a0 60 00 cmp %g1, 0 40007ec4: 02 bf ff da be 40007e2c 40007ec8: 21 10 00 9e sethi %hi(0x40027800), %l0 40007ecc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40007ed0: 18 bf ff e5 bgu 40007e64 <== NOT EXECUTED 40007ed4: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40007ed8: 81 c7 e0 08 ret <== NOT EXECUTED 40007edc: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Suspend( the_thread ); 40007ee0: 40 00 0f d7 call 4000be3c <_Thread_Suspend> 40007ee4: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007ee8: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 40007eec: 10 bf ff d6 b 40007e44 40007ef0: b0 10 20 00 clr %i0 4001ac7c : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 4001ac7c: 9d e3 bf 90 save %sp, -112, %sp 4001ac80: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 4001ac84: 80 a6 60 00 cmp %i1, 0 4001ac88: 02 80 00 22 be 4001ad10 4001ac8c: b0 10 20 09 mov 9, %i0 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 4001ac90: 80 a2 60 00 cmp %o1, 0 4001ac94: 12 80 00 21 bne 4001ad18 4001ac98: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001ac9c: 21 10 00 fa sethi %hi(0x4003e800), %l0 4001aca0: c2 04 21 d0 ld [ %l0 + 0x1d0 ], %g1 ! 4003e9d0 <_Thread_Dispatch_disable_level> 4001aca4: 82 00 60 01 inc %g1 4001aca8: c2 24 21 d0 st %g1, [ %l0 + 0x1d0 ] 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; 4001acac: 03 10 00 fa sethi %hi(0x4003e800), %g1 4001acb0: f0 00 62 ac ld [ %g1 + 0x2ac ], %i0 ! 4003eaac <_Thread_Executing> 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; 4001acb4: c0 27 bf f4 clr [ %fp + -12 ] /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 4001acb8: c4 06 21 7c ld [ %i0 + 0x17c ], %g2 while (tvp) { 4001acbc: 80 a0 a0 00 cmp %g2, 0 4001acc0: 32 80 00 08 bne,a 4001ace0 4001acc4: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 4001acc8: 10 80 00 1a b 4001ad30 4001accc: 11 10 00 fa sethi %hi(0x4003e800), %o0 4001acd0: 84 90 60 00 orcc %g1, 0, %g2 <== NOT EXECUTED 4001acd4: 02 80 00 17 be 4001ad30 <== NOT EXECUTED 4001acd8: 11 10 00 fa sethi %hi(0x4003e800), %o0 <== NOT EXECUTED if (tvp->ptr == ptr) { 4001acdc: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 4001ace0: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 4001ace4: 32 bf ff fb bne,a 4001acd0 <== NOT EXECUTED 4001ace8: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED tvp->dtor = dtor; 4001acec: f4 20 a0 10 st %i2, [ %g2 + 0x10 ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001acf0: c2 04 21 d0 ld [ %l0 + 0x1d0 ], %g1 _Thread_Dispatch(); 4001acf4: b0 10 20 00 clr %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001acf8: 82 00 7f ff add %g1, -1, %g1 4001acfc: c2 24 21 d0 st %g1, [ %l0 + 0x1d0 ] 4001ad00: c4 04 21 d0 ld [ %l0 + 0x1d0 ], %g2 4001ad04: 80 a0 a0 00 cmp %g2, 0 4001ad08: 02 80 00 1c be 4001ad78 4001ad0c: 01 00 00 00 nop the_thread->task_variables = new; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001ad10: 81 c7 e0 08 ret <== NOT EXECUTED 4001ad14: 81 e8 00 00 restore <== NOT EXECUTED 4001ad18: 84 08 60 07 and %g1, 7, %g2 <== NOT EXECUTED tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 4001ad1c: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 4001ad20: 08 80 00 21 bleu 4001ada4 <== NOT EXECUTED 4001ad24: 83 32 60 1b srl %o1, 0x1b, %g1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4001ad28: 81 c7 e0 08 ret <== NOT EXECUTED 4001ad2c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 4001ad30: 92 10 20 14 mov 0x14, %o1 4001ad34: 7f ff bf 93 call 4000ab80 <_Heap_Allocate> 4001ad38: 90 12 22 1c or %o0, 0x21c, %o0 * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 4001ad3c: 80 a2 20 00 cmp %o0, 0 4001ad40: 32 80 00 12 bne,a 4001ad88 4001ad44: c4 06 21 7c ld [ %i0 + 0x17c ], %g2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001ad48: c2 04 21 d0 ld [ %l0 + 0x1d0 ], %g1 <== NOT EXECUTED 4001ad4c: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED 4001ad50: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001ad54: c2 24 21 d0 st %g1, [ %l0 + 0x1d0 ] <== NOT EXECUTED 4001ad58: c4 04 21 d0 ld [ %l0 + 0x1d0 ], %g2 <== NOT EXECUTED 4001ad5c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001ad60: 12 80 00 08 bne 4001ad80 <== NOT EXECUTED 4001ad64: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4001ad68: 7f ff c7 ba call 4000cc50 <_Thread_Dispatch> <== NOT EXECUTED 4001ad6c: 01 00 00 00 nop <== NOT EXECUTED 4001ad70: 81 c7 e0 08 ret <== NOT EXECUTED 4001ad74: 81 e8 00 00 restore <== NOT EXECUTED 4001ad78: 7f ff c7 b6 call 4000cc50 <_Thread_Dispatch> 4001ad7c: b0 10 20 00 clr %i0 4001ad80: 81 c7 e0 08 ret 4001ad84: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 4001ad88: 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; 4001ad8c: d0 26 21 7c st %o0, [ %i0 + 0x17c ] _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 4001ad90: c2 22 20 08 st %g1, [ %o0 + 8 ] new->ptr = ptr; 4001ad94: f2 22 20 04 st %i1, [ %o0 + 4 ] new->dtor = dtor; 4001ad98: f4 22 20 10 st %i2, [ %o0 + 0x10 ] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 4001ad9c: 10 bf ff d5 b 4001acf0 4001ada0: c4 22 00 00 st %g2, [ %o0 ] *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4001ada4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001ada8: 12 bf ff e0 bne 4001ad28 <== NOT EXECUTED 4001adac: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4001adb0: 05 10 00 fa sethi %hi(0x4003e800), %g2 <== NOT EXECUTED 4001adb4: 84 10 a1 30 or %g2, 0x130, %g2 ! 4003e930 <_Objects_Information_table> <== NOT EXECUTED 4001adb8: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 4001adbc: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 4001adc0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001adc4: 02 bf ff d9 be 4001ad28 <== NOT EXECUTED 4001adc8: 01 00 00 00 nop <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4001adcc: 7f ff c2 1d call 4000b640 <_Objects_Get> <== NOT EXECUTED 4001add0: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 4001add4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4001add8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 4001addc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001ade0: 02 bf ff b6 be 4001acb8 <== NOT EXECUTED 4001ade4: 21 10 00 fa sethi %hi(0x4003e800), %l0 <== NOT EXECUTED 4001ade8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4001adec: 18 bf ff c9 bgu 4001ad10 <== NOT EXECUTED 4001adf0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 4001adf4: 30 bf ff cd b,a 4001ad28 <== NOT EXECUTED 4001adf8 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 4001adf8: 9d e3 bf 90 save %sp, -112, %sp Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 4001adfc: 80 a6 60 00 cmp %i1, 0 4001ae00: 02 80 00 50 be 4001af40 4001ae04: 92 10 00 18 mov %i0, %o1 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 4001ae08: 80 a6 20 00 cmp %i0, 0 4001ae0c: 12 80 00 26 bne 4001aea4 4001ae10: 83 36 20 18 srl %i0, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001ae14: 21 10 00 fa sethi %hi(0x4003e800), %l0 4001ae18: c2 04 21 d0 ld [ %l0 + 0x1d0 ], %g1 ! 4003e9d0 <_Thread_Dispatch_disable_level> 4001ae1c: 82 00 60 01 inc %g1 4001ae20: c2 24 21 d0 st %g1, [ %l0 + 0x1d0 ] 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; 4001ae24: 03 10 00 fa sethi %hi(0x4003e800), %g1 4001ae28: d0 00 62 ac ld [ %g1 + 0x2ac ], %o0 ! 4003eaac <_Thread_Executing> 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; 4001ae2c: c0 27 bf f4 clr [ %fp + -12 ] default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; 4001ae30: c6 02 21 7c ld [ %o0 + 0x17c ], %g3 while (tvp) { 4001ae34: 80 a0 e0 00 cmp %g3, 0 4001ae38: 02 80 00 10 be 4001ae78 4001ae3c: 01 00 00 00 nop if (tvp->ptr == ptr) { 4001ae40: c2 00 e0 04 ld [ %g3 + 4 ], %g1 4001ae44: 80 a0 40 19 cmp %g1, %i1 4001ae48: 32 80 00 09 bne,a 4001ae6c 4001ae4c: c4 00 c0 00 ld [ %g3 ], %g2 <== NOT EXECUTED if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 4001ae50: 10 80 00 5b b 4001afbc 4001ae54: c2 00 c0 00 ld [ %g3 ], %g1 return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 4001ae58: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 4001ae5c: 02 80 00 18 be 4001aebc <== NOT EXECUTED 4001ae60: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4001ae64: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED _Workspace_Free(tvp); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 4001ae68: c4 00 c0 00 ld [ %g3 ], %g2 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 4001ae6c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001ae70: 32 bf ff fa bne,a 4001ae58 <== NOT EXECUTED 4001ae74: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001ae78: c2 04 21 d0 ld [ %l0 + 0x1d0 ], %g1 <== NOT EXECUTED 4001ae7c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001ae80: c2 24 21 d0 st %g1, [ %l0 + 0x1d0 ] <== NOT EXECUTED 4001ae84: c4 04 21 d0 ld [ %l0 + 0x1d0 ], %g2 <== NOT EXECUTED 4001ae88: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001ae8c: 12 80 00 2d bne 4001af40 <== NOT EXECUTED 4001ae90: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4001ae94: 7f ff c7 6f call 4000cc50 <_Thread_Dispatch> <== NOT EXECUTED 4001ae98: b0 10 20 09 mov 9, %i0 ! 9 <== NOT EXECUTED 4001ae9c: 81 c7 e0 08 ret <== NOT EXECUTED 4001aea0: 81 e8 00 00 restore <== NOT EXECUTED 4001aea4: 84 08 60 07 and %g1, 7, %g2 <== NOT EXECUTED tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 4001aea8: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 4001aeac: 08 80 00 2e bleu 4001af64 <== NOT EXECUTED 4001aeb0: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001aeb4: 81 c7 e0 08 ret <== NOT EXECUTED 4001aeb8: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 4001aebc: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED 4001aec0: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(the_thread)) { 4001aec4: 03 10 00 fa sethi %hi(0x4003e800), %g1 4001aec8: c4 00 62 ac ld [ %g1 + 0x2ac ], %g2 ! 4003eaac <_Thread_Executing> 4001aecc: 80 a2 00 02 cmp %o0, %g2 4001aed0: 32 80 00 1e bne,a 4001af48 4001aed4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED if (tvp->dtor) 4001aed8: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 4001aedc: 80 a0 a0 00 cmp %g2, 0 4001aee0: 22 80 00 06 be,a 4001aef8 4001aee4: c4 06 20 04 ld [ %i0 + 4 ], %g2 (*tvp->dtor)(*tvp->ptr); 4001aee8: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 4001aeec: 9f c0 80 00 call %g2 <== NOT EXECUTED 4001aef0: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 4001aef4: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED 4001aef8: c2 06 20 08 ld [ %i0 + 8 ], %g1 4001aefc: c2 20 80 00 st %g1, [ %g2 ] RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4001af00: 92 10 00 18 mov %i0, %o1 4001af04: 11 10 00 fa sethi %hi(0x4003e800), %o0 4001af08: 7f ff bf 50 call 4000ac48 <_Heap_Free> 4001af0c: 90 12 22 1c or %o0, 0x21c, %o0 ! 4003ea1c <_Workspace_Area> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001af10: c2 04 21 d0 ld [ %l0 + 0x1d0 ], %g1 4001af14: b0 10 20 00 clr %i0 4001af18: 82 00 7f ff add %g1, -1, %g1 4001af1c: c2 24 21 d0 st %g1, [ %l0 + 0x1d0 ] 4001af20: c4 04 21 d0 ld [ %l0 + 0x1d0 ], %g2 4001af24: 80 a0 a0 00 cmp %g2, 0 4001af28: 12 80 00 04 bne 4001af38 4001af2c: 01 00 00 00 nop _Thread_Dispatch(); 4001af30: 7f ff c7 48 call 4000cc50 <_Thread_Dispatch> 4001af34: 01 00 00 00 nop 4001af38: 81 c7 e0 08 ret 4001af3c: 81 e8 00 00 restore 4001af40: 81 c7 e0 08 ret <== NOT EXECUTED 4001af44: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED } else { if (tvp->dtor) 4001af48: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001af4c: 22 bf ff ee be,a 4001af04 <== NOT EXECUTED 4001af50: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 4001af54: 9f c0 40 00 call %g1 <== NOT EXECUTED 4001af58: d0 06 20 0c ld [ %i0 + 0xc ], %o0 <== NOT EXECUTED 4001af5c: 10 bf ff ea b 4001af04 <== NOT EXECUTED 4001af60: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4001af64: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001af68: 32 bf ff cd bne,a 4001ae9c <== NOT EXECUTED 4001af6c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4001af70: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 4001af74: 05 10 00 fa sethi %hi(0x4003e800), %g2 <== NOT EXECUTED 4001af78: 84 10 a1 30 or %g2, 0x130, %g2 ! 4003e930 <_Objects_Information_table> <== NOT EXECUTED 4001af7c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 4001af80: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 4001af84: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001af88: 22 bf ff c5 be,a 4001ae9c <== NOT EXECUTED 4001af8c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4001af90: 7f ff c1 ac call 4000b640 <_Objects_Get> <== NOT EXECUTED 4001af94: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 4001af98: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4001af9c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001afa0: 02 bf ff a4 be 4001ae30 <== NOT EXECUTED 4001afa4: 21 10 00 fa sethi %hi(0x4003e800), %l0 <== NOT EXECUTED 4001afa8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4001afac: 18 bf ff bc bgu 4001ae9c <== NOT EXECUTED 4001afb0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4001afb4: 81 c7 e0 08 ret <== NOT EXECUTED 4001afb8: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 4001afbc: b0 10 00 03 mov %g3, %i0 4001afc0: 10 bf ff c1 b 4001aec4 4001afc4: c2 22 21 7c st %g1, [ %o0 + 0x17c ] 4001afc8 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 4001afc8: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 4001afcc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4001afd0: 02 80 00 3b be 4001b0bc <== NOT EXECUTED 4001afd4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 4001afd8: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 4001afdc: 02 80 00 38 be 4001b0bc <== NOT EXECUTED 4001afe0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 4001afe4: 12 80 00 21 bne 4001b068 <== NOT EXECUTED 4001afe8: 83 36 20 18 srl %i0, 0x18, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001afec: 05 10 00 fa sethi %hi(0x4003e800), %g2 <== NOT EXECUTED 4001aff0: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4003e9d0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4001aff4: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001aff8: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED 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; 4001affc: 03 10 00 fa sethi %hi(0x4003e800), %g1 <== NOT EXECUTED 4001b000: d0 00 62 ac ld [ %g1 + 0x2ac ], %o0 ! 4003eaac <_Thread_Executing> <== NOT EXECUTED 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; 4001b004: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 4001b008: d0 02 21 7c ld [ %o0 + 0x17c ], %o0 <== NOT EXECUTED while (tvp) { 4001b00c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b010: 32 80 00 07 bne,a 4001b02c <== NOT EXECUTED 4001b014: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4001b018: 30 80 00 1a b,a 4001b080 <== NOT EXECUTED 4001b01c: 90 90 60 00 orcc %g1, 0, %o0 <== NOT EXECUTED 4001b020: 02 80 00 18 be 4001b080 <== NOT EXECUTED 4001b024: 01 00 00 00 nop <== NOT EXECUTED if (tvp->ptr == ptr) { 4001b028: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4001b02c: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 4001b030: 32 bf ff fb bne,a 4001b01c <== NOT EXECUTED 4001b034: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 4001b038: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED 4001b03c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001b040: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 <== NOT EXECUTED 4001b044: b0 10 20 00 clr %i0 <== NOT EXECUTED 4001b048: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001b04c: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED 4001b050: c4 00 a1 d0 ld [ %g2 + 0x1d0 ], %g2 <== NOT EXECUTED 4001b054: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001b058: 02 80 00 15 be 4001b0ac <== NOT EXECUTED 4001b05c: 01 00 00 00 nop <== NOT EXECUTED } _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001b060: 81 c7 e0 08 ret <== NOT EXECUTED 4001b064: 81 e8 00 00 restore <== NOT EXECUTED 4001b068: 84 08 60 07 and %g1, 7, %g2 <== NOT EXECUTED tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 4001b06c: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 4001b070: 08 80 00 15 bleu 4001b0c4 <== NOT EXECUTED 4001b074: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED 4001b078: 81 c7 e0 08 ret <== NOT EXECUTED 4001b07c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001b080: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 <== NOT EXECUTED 4001b084: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001b088: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED 4001b08c: c4 00 a1 d0 ld [ %g2 + 0x1d0 ], %g2 <== NOT EXECUTED 4001b090: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001b094: 12 80 00 0a bne 4001b0bc <== NOT EXECUTED 4001b098: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4001b09c: 7f ff c6 ed call 4000cc50 <_Thread_Dispatch> <== NOT EXECUTED 4001b0a0: b0 10 20 09 mov 9, %i0 ! 9 <== NOT EXECUTED 4001b0a4: 81 c7 e0 08 ret <== NOT EXECUTED 4001b0a8: 81 e8 00 00 restore <== NOT EXECUTED 4001b0ac: 7f ff c6 e9 call 4000cc50 <_Thread_Dispatch> <== NOT EXECUTED 4001b0b0: 01 00 00 00 nop <== NOT EXECUTED 4001b0b4: 81 c7 e0 08 ret <== NOT EXECUTED 4001b0b8: 81 e8 00 00 restore <== NOT EXECUTED 4001b0bc: 81 c7 e0 08 ret <== NOT EXECUTED 4001b0c0: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4001b0c4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001b0c8: 32 bf ff e6 bne,a 4001b060 <== NOT EXECUTED 4001b0cc: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4001b0d0: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 4001b0d4: 05 10 00 fa sethi %hi(0x4003e800), %g2 <== NOT EXECUTED 4001b0d8: 84 10 a1 30 or %g2, 0x130, %g2 ! 4003e930 <_Objects_Information_table> <== NOT EXECUTED 4001b0dc: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 4001b0e0: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 4001b0e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b0e8: 22 bf ff de be,a 4001b060 <== NOT EXECUTED 4001b0ec: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4001b0f0: 7f ff c1 54 call 4000b640 <_Objects_Get> <== NOT EXECUTED 4001b0f4: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 4001b0f8: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4001b0fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001b100: 02 bf ff c2 be 4001b008 <== NOT EXECUTED 4001b104: 05 10 00 fa sethi %hi(0x4003e800), %g2 <== NOT EXECUTED 4001b108: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4001b10c: 18 bf ff d5 bgu 4001b060 <== NOT EXECUTED 4001b110: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4001b114: 81 c7 e0 08 ret <== NOT EXECUTED 4001b118: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40012a64 : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 40012a64: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40012a68: 11 10 00 d5 sethi %hi(0x40035400), %o0 40012a6c: 92 10 00 18 mov %i0, %o1 40012a70: 90 12 22 bc or %o0, 0x2bc, %o0 40012a74: 40 00 0a d2 call 400155bc <_Objects_Get> 40012a78: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012a7c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40012a80: 80 a0 60 00 cmp %g1, 0 40012a84: 12 80 00 11 bne 40012ac8 40012a88: 82 18 60 02 xor %g1, 2, %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 40012a8c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 40012a90: 80 a0 60 04 cmp %g1, 4 40012a94: 12 80 00 16 bne 40012aec 40012a98: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012a9c: 03 10 00 d3 sethi %hi(0x40034c00), %g1 <== NOT EXECUTED 40012aa0: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40012aa4: b0 10 20 00 clr %i0 <== NOT EXECUTED 40012aa8: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 40012aac: c4 20 60 80 st %g2, [ %g1 + 0x80 ] <== NOT EXECUTED 40012ab0: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 <== NOT EXECUTED 40012ab4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40012ab8: 02 80 00 09 be 40012adc <== NOT EXECUTED 40012abc: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012ac0: 81 c7 e0 08 ret <== NOT EXECUTED 40012ac4: 81 e8 00 00 restore <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012ac8: 80 a0 00 01 cmp %g0, %g1 40012acc: 84 60 20 00 subx %g0, 0, %g2 40012ad0: b0 08 a0 15 and %g2, 0x15, %i0 40012ad4: 81 c7 e0 08 ret 40012ad8: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 40012adc: 40 00 0f e0 call 40016a5c <_Thread_Dispatch> 40012ae0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012ae4: 81 c7 e0 08 ret 40012ae8: 81 e8 00 00 restore case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) (void) _Watchdog_Remove( &the_timer->Ticker ); 40012aec: 40 00 16 a4 call 4001857c <_Watchdog_Remove> 40012af0: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012af4: 03 10 00 d3 sethi %hi(0x40034c00), %g1 40012af8: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 40012afc: b0 10 20 00 clr %i0 40012b00: 84 00 bf ff add %g2, -1, %g2 40012b04: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 40012b08: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 40012b0c: 80 a0 e0 00 cmp %g3, 0 40012b10: 12 bf ff f5 bne 40012ae4 40012b14: 01 00 00 00 nop 40012b18: 30 bf ff f1 b,a 40012adc 40012c08 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 40012c08: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40012c0c: 21 10 00 d5 sethi %hi(0x40035400), %l0 40012c10: 92 10 00 18 mov %i0, %o1 40012c14: 94 07 bf f4 add %fp, -12, %o2 40012c18: 40 00 0a 69 call 400155bc <_Objects_Get> 40012c1c: 90 14 22 bc or %l0, 0x2bc, %o0 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012c20: c2 07 bf f4 ld [ %fp + -12 ], %g1 40012c24: 80 a0 60 00 cmp %g1, 0 40012c28: 12 80 00 1f bne 40012ca4 40012c2c: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40012c30: a0 14 22 bc or %l0, 0x2bc, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40012c34: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40012c38: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 40012c3c: 05 00 00 3f sethi %hi(0xfc00), %g2 40012c40: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40012c44: 82 08 40 02 and %g1, %g2, %g1 40012c48: 80 a0 40 03 cmp %g1, %g3 40012c4c: 38 80 00 06 bgu,a 40012c64 40012c50: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40012c54: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 40012c58: 83 28 60 02 sll %g1, 2, %g1 40012c5c: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 40012c60: c0 26 20 0c clr [ %i0 + 0xc ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _Objects_Close( &_Timer_Information, &the_timer->Object ); (void) _Watchdog_Remove( &the_timer->Ticker ); 40012c64: 40 00 16 46 call 4001857c <_Watchdog_Remove> 40012c68: 90 06 20 10 add %i0, 0x10, %o0 RTEMS_INLINE_ROUTINE void _Timer_Free ( Timer_Control *the_timer ) { _Objects_Free( &_Timer_Information, &the_timer->Object ); 40012c6c: 90 10 00 10 mov %l0, %o0 40012c70: 40 00 09 fc call 40015460 <_Objects_Free> 40012c74: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012c78: 03 10 00 d3 sethi %hi(0x40034c00), %g1 40012c7c: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 40012c80: b0 10 20 00 clr %i0 40012c84: 84 00 bf ff add %g2, -1, %g2 40012c88: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 40012c8c: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 40012c90: 80 a0 e0 00 cmp %g3, 0 40012c94: 02 80 00 0a be 40012cbc 40012c98: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012c9c: 81 c7 e0 08 ret <== NOT EXECUTED 40012ca0: 81 e8 00 00 restore <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012ca4: 82 18 60 02 xor %g1, 2, %g1 40012ca8: 80 a0 00 01 cmp %g0, %g1 40012cac: 84 60 20 00 subx %g0, 0, %g2 40012cb0: b0 08 a0 15 and %g2, 0x15, %i0 40012cb4: 81 c7 e0 08 ret 40012cb8: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 40012cbc: 40 00 0f 68 call 40016a5c <_Thread_Dispatch> 40012cc0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012cc4: 81 c7 e0 08 ret 40012cc8: 81 e8 00 00 restore 40012ccc : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 40012ccc: 9d e3 bf 90 save %sp, -112, %sp 40012cd0: a4 10 00 18 mov %i0, %l2 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 40012cd4: 80 a6 60 00 cmp %i1, 0 40012cd8: 02 80 00 3e be 40012dd0 40012cdc: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( !routine ) 40012ce0: 80 a6 a0 00 cmp %i2, 0 40012ce4: 02 80 00 3b be 40012dd0 40012ce8: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40012cec: 11 10 00 d5 sethi %hi(0x40035400), %o0 40012cf0: 92 10 00 12 mov %l2, %o1 40012cf4: 90 12 22 bc or %o0, 0x2bc, %o0 40012cf8: 40 00 0a 31 call 400155bc <_Objects_Get> 40012cfc: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012d00: c2 07 bf f4 ld [ %fp + -12 ], %g1 40012d04: 80 a0 60 00 cmp %g1, 0 40012d08: 12 80 00 17 bne 40012d64 40012d0c: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 40012d10: a2 02 20 10 add %o0, 0x10, %l1 40012d14: 40 00 16 1a call 4001857c <_Watchdog_Remove> 40012d18: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 40012d1c: 7f ff df 7e call 4000ab14 40012d20: 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 ) { 40012d24: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 40012d28: 80 a0 60 00 cmp %g1, 0 40012d2c: 22 80 00 14 be,a 40012d7c 40012d30: f4 24 20 2c st %i2, [ %l0 + 0x2c ] _ISR_Enable( level ); 40012d34: 7f ff df 7c call 4000ab24 <== NOT EXECUTED 40012d38: 01 00 00 00 nop <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012d3c: 03 10 00 d3 sethi %hi(0x40034c00), %g1 <== NOT EXECUTED 40012d40: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40012d44: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 40012d48: c4 20 60 80 st %g2, [ %g1 + 0x80 ] <== NOT EXECUTED 40012d4c: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 <== NOT EXECUTED 40012d50: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40012d54: 02 80 00 1d be 40012dc8 <== NOT EXECUTED 40012d58: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012d5c: 81 c7 e0 08 ret <== NOT EXECUTED 40012d60: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012d64: 82 18 60 02 xor %g1, 2, %g1 40012d68: 80 a0 00 01 cmp %g0, %g1 40012d6c: 84 60 20 00 subx %g0, 0, %g2 40012d70: b0 08 a0 15 and %g2, 0x15, %i0 40012d74: 81 c7 e0 08 ret 40012d78: 91 ee 20 04 restore %i0, 4, %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 40012d7c: e4 24 20 30 st %l2, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 40012d80: 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; 40012d84: c0 24 20 38 clr [ %l0 + 0x38 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40012d88: c0 24 20 18 clr [ %l0 + 0x18 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 40012d8c: 7f ff df 66 call 4000ab24 40012d90: 01 00 00 00 nop ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40012d94: 92 10 00 11 mov %l1, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40012d98: f2 24 20 1c st %i1, [ %l0 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40012d9c: 11 10 00 d3 sethi %hi(0x40034c00), %o0 40012da0: 40 00 15 8d call 400183d4 <_Watchdog_Insert> 40012da4: 90 12 21 7c or %o0, 0x17c, %o0 ! 40034d7c <_Watchdog_Ticks_chain> 40012da8: 05 10 00 d3 sethi %hi(0x40034c00), %g2 40012dac: c2 00 a0 80 ld [ %g2 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 40012db0: 82 00 7f ff add %g1, -1, %g1 40012db4: c2 20 a0 80 st %g1, [ %g2 + 0x80 ] 40012db8: c6 00 a0 80 ld [ %g2 + 0x80 ], %g3 40012dbc: 80 a0 e0 00 cmp %g3, 0 40012dc0: 32 80 00 04 bne,a 40012dd0 40012dc4: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Dispatch(); 40012dc8: 40 00 0f 25 call 40016a5c <_Thread_Dispatch> 40012dcc: b0 10 20 00 clr %i0 40012dd0: 81 c7 e0 08 ret 40012dd4: 81 e8 00 00 restore 40008614 : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 40008614: 9d e3 bf 90 save %sp, -112, %sp 40008618: 92 10 00 18 mov %i0, %o1 Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 4000861c: 80 a6 60 00 cmp %i1, 0 40008620: 02 80 00 1b be 4000868c 40008624: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40008628: 11 10 00 82 sethi %hi(0x40020800), %o0 4000862c: 94 07 bf f4 add %fp, -12, %o2 40008630: 40 00 07 b6 call 4000a508 <_Objects_Get> 40008634: 90 12 23 54 or %o0, 0x354, %o0 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40008638: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000863c: 80 a0 60 00 cmp %g1, 0 40008640: 12 80 00 15 bne 40008694 40008644: 82 18 60 02 xor %g1, 2, %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; the_info->initial = the_timer->Ticker.initial; 40008648: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 4000864c: c6 02 20 38 ld [ %o0 + 0x38 ], %g3 the_info->initial = the_timer->Ticker.initial; 40008650: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->start_time = the_timer->Ticker.start_time; 40008654: c4 02 20 24 ld [ %o0 + 0x24 ], %g2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 40008658: c6 26 40 00 st %g3, [ %i1 ] the_info->initial = the_timer->Ticker.initial; the_info->start_time = the_timer->Ticker.start_time; 4000865c: c4 26 60 08 st %g2, [ %i1 + 8 ] the_info->stop_time = the_timer->Ticker.stop_time; 40008660: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 40008664: c2 26 60 0c st %g1, [ %i1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008668: 07 10 00 83 sethi %hi(0x40020c00), %g3 4000866c: c2 00 e1 40 ld [ %g3 + 0x140 ], %g1 ! 40020d40 <_Thread_Dispatch_disable_level> 40008670: b0 10 20 00 clr %i0 40008674: 82 00 7f ff add %g1, -1, %g1 40008678: c2 20 e1 40 st %g1, [ %g3 + 0x140 ] 4000867c: c4 00 e1 40 ld [ %g3 + 0x140 ], %g2 40008680: 80 a0 a0 00 cmp %g2, 0 40008684: 02 80 00 09 be 400086a8 40008688: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000868c: 81 c7 e0 08 ret <== NOT EXECUTED 40008690: 81 e8 00 00 restore <== NOT EXECUTED if ( !the_info ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40008694: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 40008698: 84 60 20 00 subx %g0, 0, %g2 <== NOT EXECUTED 4000869c: b0 08 a0 15 and %g2, 0x15, %i0 <== NOT EXECUTED 400086a0: 81 c7 e0 08 ret <== NOT EXECUTED 400086a4: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED _Thread_Dispatch(); 400086a8: 40 00 0c c0 call 4000b9a8 <_Thread_Dispatch> 400086ac: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400086b0: 81 c7 e0 08 ret 400086b4: 81 e8 00 00 restore 40013530 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 40013530: 9d e3 bf 90 save %sp, -112, %sp /* * Make sure the requested priority is valid. */ _priority = priority; if ( priority == RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 40013534: 92 10 20 00 clr %o1 40013538: 80 a6 3f ff cmp %i0, -1 4001353c: 02 80 00 07 be 40013558 40013540: 94 10 00 19 mov %i1, %o2 _priority = 0; else if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) 40013544: 82 06 3f ff add %i0, -1, %g1 40013548: 80 a0 60 fe cmp %g1, 0xfe 4001354c: 18 80 00 16 bgu 400135a4 40013550: a2 10 20 13 mov 0x13, %l1 40013554: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40013558: 21 10 00 d3 sethi %hi(0x40034c00), %l0 4001355c: c2 04 20 80 ld [ %l0 + 0x80 ], %g1 ! 40034c80 <_Thread_Dispatch_disable_level> 40013560: 82 00 60 01 inc %g1 40013564: c2 24 20 80 st %g1, [ %l0 + 0x80 ] * Just to make sure the test versus create/start operation are atomic. */ _Thread_Disable_dispatch(); if ( _Timer_Server ) { 40013568: 33 10 00 d5 sethi %hi(0x40035400), %i1 4001356c: c2 06 63 08 ld [ %i1 + 0x308 ], %g1 ! 40035708 <_Timer_Server> 40013570: 80 a0 60 00 cmp %g1, 0 40013574: 02 80 00 0e be 400135ac 40013578: 19 00 00 20 sethi %hi(0x8000), %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001357c: c2 04 20 80 ld [ %l0 + 0x80 ], %g1 <== NOT EXECUTED 40013580: a2 10 20 0e mov 0xe, %l1 <== NOT EXECUTED _Thread_Dispatch(); 40013584: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40013588: c2 24 20 80 st %g1, [ %l0 + 0x80 ] 4001358c: c4 04 20 80 ld [ %l0 + 0x80 ], %g2 40013590: 80 a0 a0 00 cmp %g2, 0 40013594: 12 80 00 04 bne 400135a4 40013598: 01 00 00 00 nop 4001359c: 40 00 0d 30 call 40016a5c <_Thread_Dispatch> 400135a0: 01 00 00 00 nop _Watchdog_Initialize( &_Timer_Server->Timer, _Thread_Delay_ended, id, NULL ); _Watchdog_Initialize( &_Timer_Seconds_timer, _Thread_Delay_ended, id, NULL ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 400135a4: 81 c7 e0 08 ret 400135a8: 91 e8 00 11 restore %g0, %l1, %o0 * 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( 400135ac: 11 15 12 53 sethi %hi(0x54494c00), %o0 400135b0: 98 16 80 0c or %i2, %o4, %o4 400135b4: 90 12 21 45 or %o0, 0x145, %o0 400135b8: 96 10 21 00 mov 0x100, %o3 400135bc: 7f ff f9 fc call 40011dac 400135c0: 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) { 400135c4: a2 92 20 00 orcc %o0, 0, %l1 400135c8: 02 80 00 05 be 400135dc 400135cc: d0 07 bf f4 ld [ %fp + -12 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400135d0: c2 04 20 80 ld [ %l0 + 0x80 ], %g1 400135d4: 10 bf ff ed b 40013588 400135d8: 82 00 7f ff add %g1, -1, %g1 _Thread_Enable_dispatch(); return status; } status = rtems_task_start( 400135dc: 13 10 00 4c sethi %hi(0x40013000), %o1 400135e0: 94 10 20 00 clr %o2 400135e4: 7f ff fc 3d call 400126d8 400135e8: 92 12 63 dc or %o1, 0x3dc, %o1 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 400135ec: a2 92 20 00 orcc %o0, 0, %l1 400135f0: 12 bf ff f8 bne 400135d0 400135f4: c8 07 bf f4 ld [ %fp + -12 ], %g4 RTEMS_INLINE_ROUTINE Objects_Control *_Objects_Get_local_object( Objects_Information *information, uint16_t index ) { if ( index > information->maximum ) 400135f8: 03 10 00 d2 sethi %hi(0x40034800), %g1 400135fc: 9a 10 63 30 or %g1, 0x330, %o5 ! 40034b30 <_RTEMS_tasks_Information> 40013600: c4 13 60 10 lduh [ %o5 + 0x10 ], %g2 40013604: 03 00 00 3f sethi %hi(0xfc00), %g1 40013608: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4001360c: 86 09 00 01 and %g4, %g1, %g3 40013610: 80 a0 c0 02 cmp %g3, %g2 40013614: 18 80 00 05 bgu 40013628 40013618: 82 10 20 00 clr %g1 4001361c: c4 03 60 20 ld [ %o5 + 0x20 ], %g2 40013620: 83 28 e0 02 sll %g3, 2, %g1 40013624: c2 00 80 01 ld [ %g2 + %g1 ], %g1 ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 40013628: c0 20 60 6c clr [ %g1 + 0x6c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4001362c: c0 20 60 50 clr [ %g1 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; 40013630: c8 20 60 68 st %g4, [ %g1 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40013634: 07 10 00 5a sethi %hi(0x40016800), %g3 * * 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( 40013638: c2 26 63 08 st %g1, [ %i1 + 0x308 ] 4001363c: 86 10 e1 b8 or %g3, 0x1b8, %g3 40013640: c6 20 60 64 st %g3, [ %g1 + 0x64 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40013644: 03 10 00 d2 sethi %hi(0x40034800), %g1 40013648: 82 10 63 80 or %g1, 0x380, %g1 ! 40034b80 <_Timer_Ticks_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 4001364c: c2 20 7f fc st %g1, [ %g1 + -4 ] 40013650: 82 00 7f fc add %g1, -4, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40013654: 05 10 00 d2 sethi %hi(0x40034800), %g2 Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40013658: c2 20 60 08 st %g1, [ %g1 + 8 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4001365c: 84 10 a3 94 or %g2, 0x394, %g2 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 40013660: 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); 40013664: c4 20 bf fc st %g2, [ %g2 + -4 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40013668: 03 10 00 d2 sethi %hi(0x40034800), %g1 4001366c: 84 00 bf fc add %g2, -4, %g2 40013670: 82 10 63 9c or %g1, 0x39c, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40013674: 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; 40013678: c0 20 a0 04 clr [ %g2 + 4 ] the_watchdog->routine = routine; 4001367c: c6 20 60 1c st %g3, [ %g1 + 0x1c ] the_watchdog->id = id; 40013680: c8 20 60 20 st %g4, [ %g1 + 0x20 ] the_watchdog->user_data = user_data; 40013684: c0 20 60 24 clr [ %g1 + 0x24 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40013688: 10 bf ff d2 b 400135d0 4001368c: c0 20 60 08 clr [ %g1 + 8 ] 40012f24 : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 40012f24: 9d e3 bf 90 save %sp, -112, %sp 40012f28: 11 10 00 d5 sethi %hi(0x40035400), %o0 40012f2c: 92 10 00 18 mov %i0, %o1 40012f30: 90 12 22 bc or %o0, 0x2bc, %o0 40012f34: 40 00 09 a2 call 400155bc <_Objects_Get> 40012f38: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012f3c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40012f40: 80 a0 60 00 cmp %g1, 0 40012f44: 12 80 00 18 bne 40012fa4 40012f48: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 40012f4c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 40012f50: 80 a0 60 01 cmp %g1, 1 40012f54: 22 80 00 2f be,a 40013010 40012f58: 31 10 00 d5 sethi %hi(0x40035400), %i0 40012f5c: 2a 80 00 18 bcs,a 40012fbc 40012f60: a0 02 20 10 add %o0, 0x10, %l0 40012f64: 80 a0 60 04 cmp %g1, 4 40012f68: 18 80 00 1b bgu 40012fd4 40012f6c: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012f70: 03 10 00 d3 sethi %hi(0x40034c00), %g1 40012f74: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 40012f78: b0 10 20 0b mov 0xb, %i0 40012f7c: 84 00 bf ff add %g2, -1, %g2 40012f80: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 40012f84: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 40012f88: 80 a0 e0 00 cmp %g3, 0 40012f8c: 12 80 00 1f bne 40013008 40012f90: 01 00 00 00 nop _Thread_Dispatch(); 40012f94: 40 00 0e b2 call 40016a5c <_Thread_Dispatch> 40012f98: 01 00 00 00 nop 40012f9c: 81 c7 e0 08 ret 40012fa0: 81 e8 00 00 restore { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012fa4: 82 18 60 02 xor %g1, 2, %g1 40012fa8: 80 a0 00 01 cmp %g0, %g1 40012fac: 84 60 20 00 subx %g0, 0, %g2 40012fb0: b0 08 a0 15 and %g2, 0x15, %i0 40012fb4: 81 c7 e0 08 ret 40012fb8: 91 ee 20 04 restore %i0, 4, %o0 return RTEMS_INVALID_ID; case OBJECTS_LOCAL: switch ( the_timer->the_class ) { case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); 40012fbc: 40 00 15 70 call 4001857c <_Watchdog_Remove> 40012fc0: 90 10 00 10 mov %l0, %o0 _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 40012fc4: 11 10 00 d3 sethi %hi(0x40034c00), %o0 40012fc8: 92 10 00 10 mov %l0, %o1 40012fcc: 40 00 15 02 call 400183d4 <_Watchdog_Insert> 40012fd0: 90 12 21 7c or %o0, 0x17c, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012fd4: 03 10 00 d3 sethi %hi(0x40034c00), %g1 40012fd8: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> 40012fdc: b0 10 20 00 clr %i0 40012fe0: 84 00 bf ff add %g2, -1, %g2 40012fe4: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 40012fe8: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 40012fec: 80 a0 e0 00 cmp %g3, 0 40012ff0: 02 80 00 04 be 40013000 40012ff4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012ff8: 81 c7 e0 08 ret <== NOT EXECUTED 40012ffc: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40013000: 40 00 0e 97 call 40016a5c <_Thread_Dispatch> 40013004: 01 00 00 00 nop 40013008: 81 c7 e0 08 ret 4001300c: 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: _Timer_Server_stop_ticks_timer(); 40013010: d0 06 23 08 ld [ %i0 + 0x308 ], %o0 _Watchdog_Remove( &the_timer->Ticker ); 40013014: a2 04 20 10 add %l0, 0x10, %l1 case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: _Timer_Server_stop_ticks_timer(); 40013018: 40 00 15 59 call 4001857c <_Watchdog_Remove> 4001301c: 90 02 20 48 add %o0, 0x48, %o0 _Watchdog_Remove( &the_timer->Ticker ); 40013020: 40 00 15 57 call 4001857c <_Watchdog_Remove> 40013024: 90 10 00 11 mov %l1, %o0 _Timer_Server_process_ticks_chain(); 40013028: 40 00 00 dc call 40013398 <_Timer_Server_process_ticks_chain> 4001302c: 21 10 00 d2 sethi %hi(0x40034800), %l0 _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 40013030: 92 10 00 11 mov %l1, %o1 40013034: 40 00 14 e8 call 400183d4 <_Watchdog_Insert> 40013038: 90 14 23 7c or %l0, 0x37c, %o0 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 4001303c: c4 04 23 7c ld [ %l0 + 0x37c ], %g2 40013040: a0 14 23 7c or %l0, 0x37c, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40013044: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 40013048: 80 a0 80 10 cmp %g2, %l0 4001304c: 02 bf ff e2 be 40012fd4 40013050: c2 06 23 08 ld [ %i0 + 0x308 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40013054: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40013058: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4001305c: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40013060: 11 10 00 d3 sethi %hi(0x40034c00), %o0 40013064: 40 00 14 dc call 400183d4 <_Watchdog_Insert> 40013068: 90 12 21 7c or %o0, 0x17c, %o0 ! 40034d7c <_Watchdog_Ticks_chain> 4001306c: 30 bf ff da b,a 40012fd4 40013070 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 40013070: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 40013074: 23 10 00 d5 sethi %hi(0x40035400), %l1 40013078: c2 04 63 08 ld [ %l1 + 0x308 ], %g1 ! 40035708 <_Timer_Server> Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 4001307c: a6 10 00 18 mov %i0, %l3 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 40013080: 80 a0 60 00 cmp %g1, 0 40013084: 02 80 00 3b be 40013170 40013088: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; if ( !routine ) 4001308c: 80 a6 a0 00 cmp %i2, 0 40013090: 02 80 00 38 be 40013170 40013094: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 40013098: 80 a6 60 00 cmp %i1, 0 4001309c: 02 80 00 35 be 40013170 400130a0: b0 10 20 0a mov 0xa, %i0 400130a4: 11 10 00 d5 sethi %hi(0x40035400), %o0 400130a8: 92 10 00 13 mov %l3, %o1 400130ac: 90 12 22 bc or %o0, 0x2bc, %o0 400130b0: 40 00 09 43 call 400155bc <_Objects_Get> 400130b4: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 400130b8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400130bc: 80 a0 60 00 cmp %g1, 0 400130c0: 12 80 00 30 bne 40013180 400130c4: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 400130c8: a4 02 20 10 add %o0, 0x10, %l2 400130cc: 40 00 15 2c call 4001857c <_Watchdog_Remove> 400130d0: 90 10 00 12 mov %l2, %o0 _ISR_Disable( level ); 400130d4: 7f ff de 90 call 4000ab14 400130d8: 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 ) { 400130dc: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 400130e0: 80 a0 60 00 cmp %g1, 0 400130e4: 12 80 00 2d bne 40013198 400130e8: 82 10 20 01 mov 1, %g1 * 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; 400130ec: f2 24 20 1c st %i1, [ %l0 + 0x1c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 400130f0: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 400130f4: e6 24 20 30 st %l3, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 400130f8: f6 24 20 34 st %i3, [ %l0 + 0x34 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 400130fc: 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; 40013100: 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 ); 40013104: 7f ff de 88 call 4000ab24 40013108: 21 10 00 d2 sethi %hi(0x40034800), %l0 _Timer_Server_stop_ticks_timer(); 4001310c: d0 04 63 08 ld [ %l1 + 0x308 ], %o0 40013110: 40 00 15 1b call 4001857c <_Watchdog_Remove> 40013114: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_process_ticks_chain(); 40013118: 40 00 00 a0 call 40013398 <_Timer_Server_process_ticks_chain> 4001311c: 01 00 00 00 nop _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 40013120: 90 14 23 7c or %l0, 0x37c, %o0 40013124: 40 00 14 ac call 400183d4 <_Watchdog_Insert> 40013128: 92 10 00 12 mov %l2, %o1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 4001312c: c4 04 23 7c ld [ %l0 + 0x37c ], %g2 40013130: a0 14 23 7c or %l0, 0x37c, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40013134: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 40013138: 80 a0 80 10 cmp %g2, %l0 4001313c: 12 80 00 1a bne 400131a4 40013140: c2 04 63 08 ld [ %l1 + 0x308 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40013144: 03 10 00 d3 sethi %hi(0x40034c00), %g1 40013148: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 40034c80 <_Thread_Dispatch_disable_level> _Thread_Dispatch(); 4001314c: b0 10 20 00 clr %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40013150: 84 00 bf ff add %g2, -1, %g2 40013154: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 40013158: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 4001315c: 80 a0 e0 00 cmp %g3, 0 40013160: 12 80 00 06 bne 40013178 40013164: 01 00 00 00 nop _Thread_Dispatch(); 40013168: 40 00 0e 3d call 40016a5c <_Thread_Dispatch> 4001316c: b0 10 20 00 clr %i0 ! 0 40013170: 81 c7 e0 08 ret 40013174: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40013178: 81 c7 e0 08 ret <== NOT EXECUTED 4001317c: 81 e8 00 00 restore <== NOT EXECUTED if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40013180: 82 18 60 02 xor %g1, 2, %g1 40013184: 80 a0 00 01 cmp %g0, %g1 40013188: 84 60 20 00 subx %g0, 0, %g2 4001318c: b0 08 a0 15 and %g2, 0x15, %i0 40013190: 81 c7 e0 08 ret 40013194: 91 ee 20 04 restore %i0, 4, %o0 * 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 ); 40013198: 7f ff de 63 call 4000ab24 <== NOT EXECUTED 4001319c: 01 00 00 00 nop <== NOT EXECUTED 400131a0: 30 bf ff e9 b,a 40013144 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400131a4: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400131a8: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400131ac: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400131b0: 11 10 00 d3 sethi %hi(0x40034c00), %o0 400131b4: 40 00 14 88 call 400183d4 <_Watchdog_Insert> 400131b8: 90 12 21 7c or %o0, 0x17c, %o0 ! 40034d7c <_Watchdog_Ticks_chain> 400131bc: 30 bf ff e2 b,a 40013144 40006f70 : */ int sched_get_priority_max( int policy ) { 40006f70: 9d e3 bf 98 save %sp, -104, %sp switch ( policy ) { 40006f74: 80 a6 20 03 cmp %i0, 3 40006f78: 08 80 00 06 bleu 40006f90 40006f7c: b0 10 20 fe mov 0xfe, %i0 case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 40006f80: 40 00 26 8f call 400109bc <__errno> <== NOT EXECUTED 40006f84: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40006f88: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 40006f8c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 40006f90: 81 c7 e0 08 ret 40006f94: 81 e8 00 00 restore 40006fd0 : int sched_getparam( pid_t pid, const struct sched_param *param ) { 40006fd0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 40006fd4: 40 00 26 7a call 400109bc <__errno> <== NOT EXECUTED 40006fd8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40006fdc: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 40006fe0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 40006fe4: 81 c7 e0 08 ret <== NOT EXECUTED 40006fe8: 81 e8 00 00 restore <== NOT EXECUTED 40006f98 : */ int sched_getscheduler( pid_t pid ) { 40006f98: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 40006f9c: 40 00 26 88 call 400109bc <__errno> <== NOT EXECUTED 40006fa0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40006fa4: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 40006fa8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 40006fac: 81 c7 e0 08 ret <== NOT EXECUTED 40006fb0: 81 e8 00 00 restore <== NOT EXECUTED 40007008 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 40007008: 9d e3 bf 98 save %sp, -104, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 4000700c: 80 a6 20 00 cmp %i0, 0 40007010: 12 80 00 0a bne 40007038 40007014: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); if ( !interval ) 40007018: 02 80 00 13 be 40007064 4000701c: 03 10 00 7a sethi %hi(0x4001e800), %g1 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 40007020: d0 00 61 b8 ld [ %g1 + 0x1b8 ], %o0 ! 4001e9b8 <_Thread_Ticks_per_timeslice> 40007024: 92 10 00 19 mov %i1, %o1 40007028: 40 00 14 c1 call 4000c32c <_Timespec_From_ticks> 4000702c: b0 10 20 00 clr %i0 return 0; } 40007030: 81 c7 e0 08 ret 40007034: 81 e8 00 00 restore { /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 40007038: 7f ff f0 2a call 400030e0 4000703c: 01 00 00 00 nop 40007040: 80 a2 00 18 cmp %o0, %i0 40007044: 02 bf ff f5 be 40007018 40007048: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 4000704c: 40 00 26 5c call 400109bc <__errno> <== NOT EXECUTED 40007050: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40007054: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 40007058: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000705c: 81 c7 e0 08 ret <== NOT EXECUTED 40007060: 81 e8 00 00 restore <== NOT EXECUTED if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 40007064: 40 00 26 56 call 400109bc <__errno> <== NOT EXECUTED 40007068: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 4000706c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 40007070: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40007074: 81 c7 e0 08 ret <== NOT EXECUTED 40007078: 81 e8 00 00 restore <== NOT EXECUTED 40006fec : int sched_setparam( pid_t pid, const struct sched_param *param ) { 40006fec: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 40006ff0: 40 00 26 73 call 400109bc <__errno> <== NOT EXECUTED 40006ff4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40006ff8: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 40006ffc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 40007000: 81 c7 e0 08 ret <== NOT EXECUTED 40007004: 81 e8 00 00 restore <== NOT EXECUTED 40006fb4 : int sched_setscheduler( pid_t pid, int policy, const struct sched_param *param ) { 40006fb4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 40006fb8: 40 00 26 81 call 400109bc <__errno> <== NOT EXECUTED 40006fbc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40006fc0: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 40006fc4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 40006fc8: 81 c7 e0 08 ret <== NOT EXECUTED 40006fcc: 81 e8 00 00 restore <== NOT EXECUTED 40006e90 : */ int sem_close( sem_t *sem ) { 40006e90: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get ( sem_t *id, Objects_Locations *location ) { return (POSIX_Semaphore_Control *) 40006e94: d2 06 00 00 ld [ %i0 ], %o1 40006e98: 11 10 00 81 sethi %hi(0x40020400), %o0 40006e9c: 94 07 bf f4 add %fp, -12, %o2 40006ea0: 40 00 0c 44 call 40009fb0 <_Objects_Get> 40006ea4: 90 12 23 30 or %o0, 0x330, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 40006ea8: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006eac: 80 a0 60 01 cmp %g1, 1 40006eb0: 02 80 00 1c be 40006f20 40006eb4: 01 00 00 00 nop 40006eb8: 2a 80 00 09 bcs,a 40006edc 40006ebc: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 40006ec0: 80 a0 60 02 cmp %g1, 2 40006ec4: 02 80 00 1d be 40006f38 40006ec8: 01 00 00 00 nop the_semaphore->open_count -= 1; _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40006ecc: 40 00 01 aa call 40007574 <== NOT EXECUTED 40006ed0: 01 00 00 00 nop <== NOT EXECUTED } 40006ed4: 81 c7 e0 08 ret <== NOT EXECUTED 40006ed8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: _Thread_Dispatch(); return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: the_semaphore->open_count -= 1; 40006edc: 82 00 7f ff add %g1, -1, %g1 _POSIX_Semaphore_Delete( the_semaphore ); 40006ee0: 40 00 21 b4 call 4000f5b0 <_POSIX_Semaphore_Delete> 40006ee4: c2 22 20 1c st %g1, [ %o0 + 0x1c ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006ee8: 07 10 00 80 sethi %hi(0x40020000), %g3 40006eec: c2 00 e3 b0 ld [ %g3 + 0x3b0 ], %g1 ! 400203b0 <_Thread_Dispatch_disable_level> 40006ef0: 90 10 20 00 clr %o0 40006ef4: 82 00 7f ff add %g1, -1, %g1 40006ef8: c2 20 e3 b0 st %g1, [ %g3 + 0x3b0 ] 40006efc: c4 00 e3 b0 ld [ %g3 + 0x3b0 ], %g2 40006f00: 80 a0 a0 00 cmp %g2, 0 40006f04: 12 bf ff f4 bne 40006ed4 40006f08: 01 00 00 00 nop _Thread_Dispatch(); 40006f0c: 40 00 11 15 call 4000b360 <_Thread_Dispatch> 40006f10: 01 00 00 00 nop 40006f14: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40006f18: 81 c7 e0 08 ret 40006f1c: 91 e8 00 08 restore %g0, %o0, %o0 the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 40006f20: 40 00 11 10 call 4000b360 <_Thread_Dispatch> <== NOT EXECUTED 40006f24: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 40006f28: 40 00 01 9d call 4000759c <== NOT EXECUTED 40006f2c: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40006f30: 81 c7 e0 08 ret <== NOT EXECUTED 40006f34: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 40006f38: 40 00 2a 78 call 40011918 <__errno> 40006f3c: 01 00 00 00 nop 40006f40: 82 10 20 16 mov 0x16, %g1 ! 16 40006f44: c2 22 00 00 st %g1, [ %o0 ] 40006f48: 90 10 3f ff mov -1, %o0 _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40006f4c: 81 c7 e0 08 ret 40006f50: 91 e8 00 08 restore %g0, %o0, %o0 40006f54 : */ int sem_destroy( sem_t *sem ) { 40006f54: 9d e3 bf 90 save %sp, -112, %sp 40006f58: d2 06 00 00 ld [ %i0 ], %o1 40006f5c: 11 10 00 81 sethi %hi(0x40020400), %o0 40006f60: 94 07 bf f4 add %fp, -12, %o2 40006f64: 40 00 0c 13 call 40009fb0 <_Objects_Get> 40006f68: 90 12 23 30 or %o0, 0x330, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 40006f6c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006f70: 80 a0 60 01 cmp %g1, 1 40006f74: 02 80 00 2f be 40007030 40006f78: 01 00 00 00 nop 40006f7c: 2a 80 00 09 bcs,a 40006fa0 40006f80: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40006f84: 80 a0 60 02 cmp %g1, 2 40006f88: 02 80 00 23 be 40007014 40006f8c: 01 00 00 00 nop _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40006f90: 40 00 01 79 call 40007574 <== NOT EXECUTED 40006f94: 01 00 00 00 nop <== NOT EXECUTED } 40006f98: 81 c7 e0 08 ret <== NOT EXECUTED 40006f9c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { 40006fa0: 80 a0 60 01 cmp %g1, 1 40006fa4: 02 80 00 12 be 40006fec 40006fa8: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } _POSIX_Semaphore_Delete( the_semaphore ); 40006fac: 40 00 21 81 call 4000f5b0 <_POSIX_Semaphore_Delete> 40006fb0: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006fb4: 03 10 00 80 sethi %hi(0x40020000), %g1 40006fb8: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 400203b0 <_Thread_Dispatch_disable_level> 40006fbc: 90 10 20 00 clr %o0 40006fc0: 84 00 bf ff add %g2, -1, %g2 40006fc4: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 40006fc8: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 40006fcc: 80 a0 e0 00 cmp %g3, 0 40006fd0: 12 bf ff f2 bne 40006f98 40006fd4: 01 00 00 00 nop _Thread_Dispatch(); 40006fd8: 40 00 10 e2 call 4000b360 <_Thread_Dispatch> 40006fdc: 01 00 00 00 nop 40006fe0: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40006fe4: 81 c7 e0 08 ret 40006fe8: 91 e8 00 08 restore %g0, %o0, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006fec: 03 10 00 80 sethi %hi(0x40020000), %g1 <== NOT EXECUTED 40006ff0: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 400203b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40006ff4: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 40006ff8: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] <== NOT EXECUTED 40006ffc: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 <== NOT EXECUTED 40007000: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40007004: 12 80 00 04 bne 40007014 <== NOT EXECUTED 40007008: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4000700c: 40 00 10 d5 call 4000b360 <_Thread_Dispatch> <== NOT EXECUTED 40007010: 01 00 00 00 nop <== NOT EXECUTED * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); 40007014: 40 00 2a 41 call 40011918 <__errno> 40007018: 01 00 00 00 nop 4000701c: 82 10 20 16 mov 0x16, %g1 ! 16 40007020: c2 22 00 00 st %g1, [ %o0 ] 40007024: 90 10 3f ff mov -1, %o0 _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40007028: 81 c7 e0 08 ret 4000702c: 91 e8 00 08 restore %g0, %o0, %o0 the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 40007030: 40 00 10 cc call 4000b360 <_Thread_Dispatch> <== NOT EXECUTED 40007034: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 40007038: 40 00 01 59 call 4000759c <== NOT EXECUTED 4000703c: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40007040: 81 c7 e0 08 ret <== NOT EXECUTED 40007044: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 40007048 : int sem_getvalue( sem_t *sem, int *sval ) { 40007048: 9d e3 bf 90 save %sp, -112, %sp 4000704c: d2 06 00 00 ld [ %i0 ], %o1 40007050: 11 10 00 81 sethi %hi(0x40020400), %o0 40007054: 94 07 bf f4 add %fp, -12, %o2 40007058: 40 00 0b d6 call 40009fb0 <_Objects_Get> 4000705c: 90 12 23 30 or %o0, 0x330, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 40007060: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007064: 80 a0 60 01 cmp %g1, 1 40007068: 02 80 00 1a be 400070d0 4000706c: 01 00 00 00 nop 40007070: 2a 80 00 09 bcs,a 40007094 40007074: c2 02 20 68 ld [ %o0 + 0x68 ], %g1 40007078: 80 a0 60 02 cmp %g1, 2 4000707c: 02 80 00 1b be 400070e8 40007080: 01 00 00 00 nop case OBJECTS_LOCAL: *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40007084: 40 00 01 3c call 40007574 <== NOT EXECUTED 40007088: 01 00 00 00 nop <== NOT EXECUTED } 4000708c: 81 c7 e0 08 ret <== NOT EXECUTED 40007090: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: _Thread_Dispatch(); return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); 40007094: c2 26 40 00 st %g1, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007098: 07 10 00 80 sethi %hi(0x40020000), %g3 4000709c: c2 00 e3 b0 ld [ %g3 + 0x3b0 ], %g1 ! 400203b0 <_Thread_Dispatch_disable_level> 400070a0: 90 10 20 00 clr %o0 400070a4: 82 00 7f ff add %g1, -1, %g1 400070a8: c2 20 e3 b0 st %g1, [ %g3 + 0x3b0 ] 400070ac: c4 00 e3 b0 ld [ %g3 + 0x3b0 ], %g2 400070b0: 80 a0 a0 00 cmp %g2, 0 400070b4: 12 bf ff f6 bne 4000708c 400070b8: 01 00 00 00 nop _Thread_Dispatch(); 400070bc: 40 00 10 a9 call 4000b360 <_Thread_Dispatch> 400070c0: 01 00 00 00 nop 400070c4: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 400070c8: 81 c7 e0 08 ret 400070cc: 91 e8 00 08 restore %g0, %o0, %o0 the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 400070d0: 40 00 10 a4 call 4000b360 <_Thread_Dispatch> <== NOT EXECUTED 400070d4: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 400070d8: 40 00 01 31 call 4000759c <== NOT EXECUTED 400070dc: 01 00 00 00 nop <== NOT EXECUTED *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 400070e0: 81 c7 e0 08 ret <== NOT EXECUTED 400070e4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 400070e8: 40 00 2a 0c call 40011918 <__errno> 400070ec: 01 00 00 00 nop 400070f0: 82 10 20 16 mov 0x16, %g1 ! 16 400070f4: c2 22 00 00 st %g1, [ %o0 ] 400070f8: 90 10 3f ff mov -1, %o0 *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 400070fc: 81 c7 e0 08 ret 40007100: 91 e8 00 08 restore %g0, %o0, %o0 40007104 : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 40007104: 9d e3 bf 90 save %sp, -112, %sp 40007108: 92 10 00 19 mov %i1, %o1 int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 4000710c: 80 a6 20 00 cmp %i0, 0 40007110: 02 80 00 0c be 40007140 40007114: 94 10 00 1a mov %i2, %o2 rtems_set_errno_and_return_minus_one( EINVAL ); status = _POSIX_Semaphore_Create_support( 40007118: 90 10 20 00 clr %o0 4000711c: 40 00 20 b4 call 4000f3ec <_POSIX_Semaphore_Create_support> 40007120: 96 07 bf f4 add %fp, -12, %o3 pshared, value, &the_semaphore ); if ( status != -1 ) 40007124: 80 a2 3f ff cmp %o0, -1 40007128: 02 80 00 04 be 40007138 4000712c: c2 07 bf f4 ld [ %fp + -12 ], %g1 *sem = the_semaphore->Object.id; 40007130: c4 00 60 08 ld [ %g1 + 8 ], %g2 40007134: c4 26 00 00 st %g2, [ %i0 ] return status; } 40007138: 81 c7 e0 08 ret 4000713c: 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 ); 40007140: 40 00 29 f6 call 40011918 <__errno> <== NOT EXECUTED 40007144: 01 00 00 00 nop <== NOT EXECUTED 40007148: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 4000714c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40007150: 10 bf ff fa b 40007138 <== NOT EXECUTED 40007154: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED 40007158 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 40007158: 9d e3 bf 88 save %sp, -120, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000715c: 21 10 00 80 sethi %hi(0x40020000), %l0 40007160: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 ! 400203b0 <_Thread_Dispatch_disable_level> 40007164: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 40007168: 82 00 60 01 inc %g1 4000716c: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 40007170: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 40007174: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 40007178: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 4000717c: b8 8e 62 00 andcc %i1, 0x200, %i4 40007180: 12 80 00 42 bne 40007288 40007184: f6 07 a0 50 ld [ %fp + 0x50 ], %i3 40007188: b6 10 20 00 clr %i3 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 ); 4000718c: 90 10 00 18 mov %i0, %o0 40007190: 40 00 21 25 call 4000f624 <_POSIX_Semaphore_Name_to_id> 40007194: 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 ) { 40007198: ba 92 20 00 orcc %o0, 0, %i5 4000719c: 02 80 00 11 be 400071e0 400071a0: 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) ) ) { 400071a4: 80 a7 60 02 cmp %i5, 2 400071a8: 02 80 00 3b be 40007294 400071ac: 80 a7 20 00 cmp %i4, 0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400071b0: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 400071b4: 82 00 7f ff add %g1, -1, %g1 400071b8: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] 400071bc: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 400071c0: 80 a0 a0 00 cmp %g2, 0 400071c4: 02 80 00 52 be 4000730c 400071c8: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 400071cc: 40 00 29 d3 call 40011918 <__errno> <== NOT EXECUTED 400071d0: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 400071d4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED 400071d8: 81 c7 e0 08 ret <== NOT EXECUTED 400071dc: 81 e8 00 00 restore <== NOT EXECUTED /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 400071e0: 80 a0 6a 00 cmp %g1, 0xa00 400071e4: 02 80 00 1c be 40007254 400071e8: d2 07 bf f0 ld [ %fp + -16 ], %o1 400071ec: 94 07 bf e8 add %fp, -24, %o2 400071f0: 11 10 00 81 sethi %hi(0x40020400), %o0 400071f4: 40 00 0b 6f call 40009fb0 <_Objects_Get> 400071f8: 90 12 23 30 or %o0, 0x330, %o0 ! 40020730 <_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; 400071fc: c2 02 20 1c ld [ %o0 + 0x1c ], %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 ); 40007200: d0 27 bf ec st %o0, [ %fp + -20 ] the_semaphore->open_count += 1; 40007204: 82 00 60 01 inc %g1 40007208: c2 22 20 1c st %g1, [ %o0 + 0x1c ] 4000720c: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 40007210: 3b 10 00 80 sethi %hi(0x40020000), %i5 40007214: 82 00 7f ff add %g1, -1, %g1 40007218: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] 4000721c: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 40007220: 80 a0 a0 00 cmp %g2, 0 40007224: 02 80 00 34 be 400072f4 40007228: 01 00 00 00 nop 4000722c: c2 07 63 b0 ld [ %i5 + 0x3b0 ], %g1 40007230: 82 00 7f ff add %g1, -1, %g1 40007234: c2 27 63 b0 st %g1, [ %i5 + 0x3b0 ] 40007238: c4 07 63 b0 ld [ %i5 + 0x3b0 ], %g2 4000723c: 80 a0 a0 00 cmp %g2, 0 40007240: 02 80 00 29 be 400072e4 40007244: 01 00 00 00 nop _Thread_Enable_dispatch(); _Thread_Enable_dispatch(); id = &the_semaphore->Object.id; return (sem_t *)id; 40007248: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED 4000724c: 81 c7 e0 08 ret 40007250: 91 e8 60 08 restore %g1, 8, %o0 40007254: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 40007258: 82 00 7f ff add %g1, -1, %g1 4000725c: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] 40007260: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 40007264: 80 a0 a0 00 cmp %g2, 0 40007268: 02 80 00 26 be 40007300 4000726c: 01 00 00 00 nop * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 40007270: 40 00 29 aa call 40011918 <__errno> 40007274: b0 10 3f ff mov -1, %i0 ! ffffffff 40007278: 82 10 20 11 mov 0x11, %g1 4000727c: c2 22 00 00 st %g1, [ %o0 ] 40007280: 81 c7 e0 08 ret 40007284: 81 e8 00 00 restore _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 ); 40007288: 82 07 a0 54 add %fp, 0x54, %g1 4000728c: 10 bf ff c0 b 4000718c 40007290: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * 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) ) ) { 40007294: 02 bf ff c7 be 400071b0 40007298: 90 10 00 18 mov %i0, %o0 /* * 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( 4000729c: 94 10 00 1b mov %i3, %o2 400072a0: 92 10 20 00 clr %o1 400072a4: 40 00 20 52 call 4000f3ec <_POSIX_Semaphore_Create_support> 400072a8: 96 07 bf ec add %fp, -20, %o3 400072ac: ba 10 00 08 mov %o0, %i5 400072b0: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 400072b4: 82 00 7f ff add %g1, -1, %g1 400072b8: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] 400072bc: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 400072c0: 80 a0 a0 00 cmp %g2, 0 400072c4: 02 80 00 19 be 40007328 400072c8: 01 00 00 00 nop * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 400072cc: 80 a7 7f ff cmp %i5, -1 <== NOT EXECUTED 400072d0: 02 bf ff c2 be 400071d8 400072d4: b0 10 3f ff mov -1, %i0 return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; 400072d8: c2 07 bf ec ld [ %fp + -20 ], %g1 } 400072dc: 81 c7 e0 08 ret 400072e0: 91 e8 60 08 restore %g1, 8, %o0 _Thread_Dispatch(); 400072e4: 40 00 10 1f call 4000b360 <_Thread_Dispatch> 400072e8: 01 00 00 00 nop the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); the_semaphore->open_count += 1; _Thread_Enable_dispatch(); _Thread_Enable_dispatch(); id = &the_semaphore->Object.id; return (sem_t *)id; 400072ec: 10 bf ff d8 b 4000724c 400072f0: c2 07 bf ec ld [ %fp + -20 ], %g1 400072f4: 40 00 10 1b call 4000b360 <_Thread_Dispatch> <== NOT EXECUTED 400072f8: 01 00 00 00 nop <== NOT EXECUTED 400072fc: 30 bf ff cc b,a 4000722c <== NOT EXECUTED 40007300: 40 00 10 18 call 4000b360 <_Thread_Dispatch> 40007304: 01 00 00 00 nop 40007308: 30 bf ff da b,a 40007270 4000730c: 40 00 10 15 call 4000b360 <_Thread_Dispatch> 40007310: b0 10 3f ff mov -1, %i0 * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 40007314: 40 00 29 81 call 40011918 <__errno> 40007318: 01 00 00 00 nop 4000731c: fa 22 00 00 st %i5, [ %o0 ] 40007320: 81 c7 e0 08 ret 40007324: 81 e8 00 00 restore 40007328: 40 00 10 0e call 4000b360 <_Thread_Dispatch> 4000732c: 01 00 00 00 nop * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 40007330: 10 bf ff e8 b 400072d0 40007334: 80 a7 7f ff cmp %i5, -1 40007338 : */ int sem_post( sem_t *sem ) { 40007338: 9d e3 bf 90 save %sp, -112, %sp 4000733c: d2 06 00 00 ld [ %i0 ], %o1 40007340: 11 10 00 81 sethi %hi(0x40020400), %o0 40007344: 94 07 bf f4 add %fp, -12, %o2 40007348: 40 00 0b 1a call 40009fb0 <_Objects_Get> 4000734c: 90 12 23 30 or %o0, 0x330, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 40007350: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007354: 80 a0 60 01 cmp %g1, 1 40007358: 02 80 00 1c be 400073c8 4000735c: 01 00 00 00 nop 40007360: 2a 80 00 09 bcs,a 40007384 40007364: d2 02 20 08 ld [ %o0 + 8 ], %o1 40007368: 80 a0 60 02 cmp %g1, 2 4000736c: 02 80 00 1d be 400073e0 40007370: 01 00 00 00 nop #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40007374: 40 00 00 80 call 40007574 <== NOT EXECUTED 40007378: 01 00 00 00 nop <== NOT EXECUTED } 4000737c: 81 c7 e0 08 ret <== NOT EXECUTED 40007380: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: _Thread_Dispatch(); return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: _CORE_semaphore_Surrender( 40007384: 94 10 20 00 clr %o2 40007388: 40 00 07 f8 call 40009368 <_CORE_semaphore_Surrender> 4000738c: 90 02 20 20 add %o0, 0x20, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007390: 03 10 00 80 sethi %hi(0x40020000), %g1 40007394: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 400203b0 <_Thread_Dispatch_disable_level> 40007398: 90 10 20 00 clr %o0 4000739c: 84 00 bf ff add %g2, -1, %g2 400073a0: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 400073a4: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 400073a8: 80 a0 e0 00 cmp %g3, 0 400073ac: 12 bf ff f4 bne 4000737c 400073b0: 01 00 00 00 nop _Thread_Dispatch(); 400073b4: 40 00 0f eb call 4000b360 <_Thread_Dispatch> 400073b8: 01 00 00 00 nop 400073bc: 90 10 20 00 clr %o0 ! 0 ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 400073c0: 81 c7 e0 08 ret 400073c4: 91 e8 00 08 restore %g0, %o0, %o0 the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 400073c8: 40 00 0f e6 call 4000b360 <_Thread_Dispatch> <== NOT EXECUTED 400073cc: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 400073d0: 40 00 00 73 call 4000759c <== NOT EXECUTED 400073d4: 01 00 00 00 nop <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 400073d8: 81 c7 e0 08 ret <== NOT EXECUTED 400073dc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 400073e0: 40 00 29 4e call 40011918 <__errno> 400073e4: 01 00 00 00 nop 400073e8: 82 10 20 16 mov 0x16, %g1 ! 16 400073ec: c2 22 00 00 st %g1, [ %o0 ] 400073f0: 90 10 3f ff mov -1, %o0 ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 400073f4: 81 c7 e0 08 ret 400073f8: 91 e8 00 08 restore %g0, %o0, %o0 400073fc : int sem_timedwait( sem_t *sem, const struct timespec *abstime ) { 400073fc: 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 ); 40007400: 90 10 00 19 mov %i1, %o0 40007404: 40 00 1d 87 call 4000ea20 <_POSIX_Absolute_timeout_to_ticks> 40007408: 92 07 bf f4 add %fp, -12, %o1 switch ( status ) { 4000740c: 80 a2 20 02 cmp %o0, 2 40007410: 18 80 00 07 bgu 4000742c 40007414: 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 ); 40007418: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000741c: 40 00 20 a1 call 4000f6a0 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED 40007420: 92 10 20 00 clr %o1 <== NOT EXECUTED break; } } return lock_status; } 40007424: 81 c7 e0 08 ret <== NOT EXECUTED 40007428: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 4000742c: 90 10 00 18 mov %i0, %o0 40007430: 40 00 20 9c call 4000f6a0 <_POSIX_Semaphore_Wait_support> 40007434: 92 10 20 01 mov 1, %o1 break; } } return lock_status; } 40007438: 81 c7 e0 08 ret 4000743c: 91 e8 00 08 restore %g0, %o0, %o0 40007458 : */ int sem_unlink( const char *name ) { 40007458: 9d e3 bf 90 save %sp, -112, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000745c: 21 10 00 80 sethi %hi(0x40020000), %l0 40007460: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 ! 400203b0 <_Thread_Dispatch_disable_level> 40007464: 90 10 00 18 mov %i0, %o0 40007468: 82 00 60 01 inc %g1 4000746c: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] register POSIX_Semaphore_Control *the_semaphore; sem_t the_semaphore_id; _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 40007470: 40 00 20 6d call 4000f624 <_POSIX_Semaphore_Name_to_id> 40007474: 92 07 bf f4 add %fp, -12, %o1 if ( status != 0 ) { 40007478: b0 92 20 00 orcc %o0, 0, %i0 4000747c: 12 80 00 1f bne 400074f8 40007480: 03 10 00 81 sethi %hi(0x40020400), %g1 RTEMS_INLINE_ROUTINE Objects_Control *_Objects_Get_local_object( Objects_Information *information, uint16_t index ) { if ( index > information->maximum ) 40007484: c4 07 bf f4 ld [ %fp + -12 ], %g2 40007488: 88 10 63 30 or %g1, 0x330, %g4 4000748c: c6 11 20 10 lduh [ %g4 + 0x10 ], %g3 40007490: 03 00 00 3f sethi %hi(0xfc00), %g1 40007494: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40007498: 82 08 80 01 and %g2, %g1, %g1 4000749c: 80 a0 40 03 cmp %g1, %g3 400074a0: 18 80 00 05 bgu 400074b4 400074a4: 90 10 20 00 clr %o0 400074a8: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 400074ac: 83 28 60 02 sll %g1, 2, %g1 400074b0: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( the_semaphore->process_shared == PTHREAD_PROCESS_SHARED ) { _Objects_MP_Close( &_POSIX_Semaphore_Information, the_semaphore_id ); } #endif the_semaphore->linked = FALSE; 400074b4: c0 22 20 18 clr [ %o0 + 0x18 ] _POSIX_Semaphore_Namespace_remove( the_semaphore ); _POSIX_Semaphore_Delete( the_semaphore ); 400074b8: 40 00 20 3e call 4000f5b0 <_POSIX_Semaphore_Delete> 400074bc: c0 22 20 0c clr [ %o0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400074c0: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 400074c4: b0 10 20 00 clr %i0 400074c8: 82 00 7f ff add %g1, -1, %g1 400074cc: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] 400074d0: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 400074d4: 80 a0 a0 00 cmp %g2, 0 400074d8: 02 80 00 04 be 400074e8 400074dc: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } 400074e0: 81 c7 e0 08 ret <== NOT EXECUTED 400074e4: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 400074e8: 40 00 0f 9e call 4000b360 <_Thread_Dispatch> 400074ec: 01 00 00 00 nop 400074f0: 81 c7 e0 08 ret 400074f4: 81 e8 00 00 restore #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400074f8: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 400074fc: 82 00 7f ff add %g1, -1, %g1 40007500: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] 40007504: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 40007508: 80 a0 a0 00 cmp %g2, 0 4000750c: 02 80 00 07 be 40007528 40007510: 01 00 00 00 nop _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); if ( status != 0 ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( status ); 40007514: 40 00 29 01 call 40011918 <__errno> 40007518: 01 00 00 00 nop 4000751c: f0 22 00 00 st %i0, [ %o0 ] 40007520: 81 c7 e0 08 ret 40007524: 91 e8 3f ff restore %g0, -1, %o0 _Thread_Dispatch(); 40007528: 40 00 0f 8e call 4000b360 <_Thread_Dispatch> 4000752c: 01 00 00 00 nop 40007530: 30 bf ff f9 b,a 40007514 40006470 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 40006470: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; if ( oact ) 40006474: 80 a6 a0 00 cmp %i2, 0 40006478: 02 80 00 0d be 400064ac 4000647c: 87 2e 20 02 sll %i0, 2, %g3 *oact = _POSIX_signals_Vectors[ sig ]; 40006480: 05 10 00 78 sethi %hi(0x4001e000), %g2 <== NOT EXECUTED 40006484: 83 2e 20 04 sll %i0, 4, %g1 <== NOT EXECUTED 40006488: 84 10 a2 e4 or %g2, 0x2e4, %g2 <== NOT EXECUTED 4000648c: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 40006490: c8 00 80 01 ld [ %g2 + %g1 ], %g4 <== NOT EXECUTED 40006494: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED 40006498: c8 26 80 00 st %g4, [ %i2 ] <== NOT EXECUTED 4000649c: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED 400064a0: c4 26 a0 04 st %g2, [ %i2 + 4 ] <== NOT EXECUTED 400064a4: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED 400064a8: c6 26 a0 08 st %g3, [ %i2 + 8 ] <== NOT EXECUTED if ( !sig ) 400064ac: 80 a6 20 00 cmp %i0, 0 400064b0: 02 80 00 33 be 4000657c 400064b4: b4 06 3f ff add %i0, -1, %i2 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 400064b8: 80 a6 a0 1f cmp %i2, 0x1f 400064bc: 18 80 00 30 bgu 4000657c 400064c0: 80 a6 20 09 cmp %i0, 9 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 400064c4: 02 80 00 2e be 4000657c 400064c8: 80 a6 60 00 cmp %i1, 0 /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 400064cc: 02 80 00 1a be 40006534 400064d0: 82 10 20 00 clr %g1 /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); 400064d4: 7f ff ef ca call 400023fc 400064d8: 01 00 00 00 nop 400064dc: a0 10 00 08 mov %o0, %l0 if ( act->sa_handler == SIG_DFL ) { 400064e0: c2 06 60 08 ld [ %i1 + 8 ], %g1 400064e4: 80 a0 60 00 cmp %g1, 0 400064e8: 02 80 00 15 be 4000653c 400064ec: 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) ); 400064f0: 40 00 1e a9 call 4000df94 <_POSIX_signals_Clear_process_signals> 400064f4: 91 2a 00 1a sll %o0, %i2, %o0 _POSIX_signals_Vectors[ sig ] = *act; 400064f8: da 06 40 00 ld [ %i1 ], %o5 400064fc: 85 2e 20 02 sll %i0, 2, %g2 40006500: 83 2e 20 04 sll %i0, 4, %g1 40006504: 07 10 00 78 sethi %hi(0x4001e000), %g3 40006508: 82 20 40 02 sub %g1, %g2, %g1 4000650c: 86 10 e2 e4 or %g3, 0x2e4, %g3 40006510: da 20 c0 01 st %o5, [ %g3 + %g1 ] 40006514: c8 06 60 04 ld [ %i1 + 4 ], %g4 40006518: 82 00 40 03 add %g1, %g3, %g1 4000651c: c8 20 60 04 st %g4, [ %g1 + 4 ] 40006520: c4 06 60 08 ld [ %i1 + 8 ], %g2 40006524: c4 20 60 08 st %g2, [ %g1 + 8 ] } _ISR_Enable( level ); 40006528: 7f ff ef b9 call 4000240c 4000652c: 90 10 00 10 mov %l0, %o0 40006530: 82 10 20 00 clr %g1 * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; } 40006534: 81 c7 e0 08 ret 40006538: 91 e8 00 01 restore %g0, %g1, %o0 * 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 ]; 4000653c: 85 2e 20 02 sll %i0, 2, %g2 <== NOT EXECUTED 40006540: 87 2e 20 04 sll %i0, 4, %g3 <== NOT EXECUTED 40006544: 03 10 00 74 sethi %hi(0x4001d000), %g1 <== NOT EXECUTED 40006548: 86 20 c0 02 sub %g3, %g2, %g3 <== NOT EXECUTED 4000654c: 82 10 60 dc or %g1, 0xdc, %g1 <== NOT EXECUTED 40006550: c8 00 40 03 ld [ %g1 + %g3 ], %g4 <== NOT EXECUTED 40006554: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED 40006558: da 00 60 08 ld [ %g1 + 8 ], %o5 <== NOT EXECUTED 4000655c: d8 00 60 04 ld [ %g1 + 4 ], %o4 <== NOT EXECUTED 40006560: 05 10 00 78 sethi %hi(0x4001e000), %g2 <== NOT EXECUTED 40006564: 84 10 a2 e4 or %g2, 0x2e4, %g2 ! 4001e2e4 <_POSIX_signals_Vectors> <== NOT EXECUTED 40006568: c8 20 80 03 st %g4, [ %g2 + %g3 ] <== NOT EXECUTED 4000656c: 86 00 c0 02 add %g3, %g2, %g3 <== NOT EXECUTED 40006570: da 20 e0 08 st %o5, [ %g3 + 8 ] <== NOT EXECUTED 40006574: 10 bf ff ed b 40006528 <== NOT EXECUTED 40006578: d8 20 e0 04 st %o4, [ %g3 + 4 ] <== NOT EXECUTED * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) rtems_set_errno_and_return_minus_one( EINVAL ); 4000657c: 40 00 27 17 call 400101d8 <__errno> 40006580: 01 00 00 00 nop 40006584: 82 10 20 16 mov 0x16, %g1 ! 16 40006588: c2 22 00 00 st %g1, [ %o0 ] 4000658c: 10 bf ff ea b 40006534 40006590: 82 10 3f ff mov -1, %g1 40006918 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 40006918: 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 ) { 4000691c: 80 a6 a0 00 cmp %i2, 0 40006920: 02 80 00 0c be 40006950 40006924: a6 10 20 00 clr %l3 if ( !_Timespec_Is_valid( timeout ) ) 40006928: 40 00 14 a3 call 4000bbb4 <_Timespec_Is_valid> 4000692c: 90 10 00 1a mov %i2, %o0 40006930: 80 a2 20 00 cmp %o0, 0 40006934: 02 80 00 76 be 40006b0c 40006938: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 4000693c: 40 00 14 c5 call 4000bc50 <_Timespec_To_ticks> 40006940: 90 10 00 1a mov %i2, %o0 if ( !interval ) 40006944: a6 92 20 00 orcc %o0, 0, %l3 40006948: 02 80 00 71 be 40006b0c 4000694c: 01 00 00 00 nop /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 40006950: 80 a6 60 00 cmp %i1, 0 40006954: 02 80 00 03 be 40006960 40006958: a4 07 bf ec add %fp, -20, %l2 4000695c: a4 10 00 19 mov %i1, %l2 the_thread = _Thread_Executing; 40006960: 29 10 00 79 sethi %hi(0x4001e400), %l4 40006964: f4 05 22 0c ld [ %l4 + 0x20c ], %i2 ! 4001e60c <_Thread_Executing> * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 40006968: 7f ff ef 6c call 40002718 4000696c: f2 06 a1 70 ld [ %i2 + 0x170 ], %i1 40006970: a0 10 00 08 mov %o0, %l0 if ( *set & api->signals_pending ) { 40006974: c4 06 00 00 ld [ %i0 ], %g2 40006978: c2 06 60 c8 ld [ %i1 + 0xc8 ], %g1 4000697c: 80 88 80 01 btst %g2, %g1 40006980: 12 80 00 42 bne 40006a88 40006984: 01 00 00 00 nop return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 40006988: 03 10 00 7b sethi %hi(0x4001ec00), %g1 4000698c: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 4001ed90 <_POSIX_signals_Pending> 40006990: 80 88 80 01 btst %g2, %g1 40006994: 12 80 00 2c bne 40006a44 40006998: 23 10 00 79 sethi %hi(0x4001e400), %l1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000699c: c2 04 61 30 ld [ %l1 + 0x130 ], %g1 ! 4001e530 <_Thread_Dispatch_disable_level> the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 400069a0: 84 10 3f ff mov -1, %g2 400069a4: 82 00 60 01 inc %g1 400069a8: c4 24 80 00 st %g2, [ %l2 ] 400069ac: c2 24 61 30 st %g1, [ %l1 + 0x130 ] _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; the_thread->Wait.return_code = EINTR; 400069b0: 82 10 20 04 mov 4, %g1 400069b4: c2 26 a0 34 st %g1, [ %i2 + 0x34 ] the_thread->Wait.option = *set; 400069b8: 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_QUEUE_NOTHING_HAPPENED; 400069bc: 82 10 20 01 mov 1, %g1 the_thread->Wait.return_argument = the_info; 400069c0: e4 26 a0 28 st %l2, [ %i2 + 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; 400069c4: c4 26 a0 30 st %g2, [ %i2 + 0x30 ] } the_info->si_signo = -1; _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 400069c8: 21 10 00 7b sethi %hi(0x4001ec00), %l0 400069cc: a0 14 21 50 or %l0, 0x150, %l0 ! 4001ed50 <_POSIX_signals_Wait_queue> 400069d0: e0 26 a0 44 st %l0, [ %i2 + 0x44 ] 400069d4: 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 ); 400069d8: 7f ff ef 54 call 40002728 400069dc: 01 00 00 00 nop _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 400069e0: 90 10 00 10 mov %l0, %o0 400069e4: 92 10 00 13 mov %l3, %o1 400069e8: 15 10 00 2d sethi %hi(0x4000b400), %o2 400069ec: 40 00 11 86 call 4000b004 <_Thread_queue_Enqueue_with_handler> 400069f0: 94 12 a1 44 or %o2, 0x144, %o2 ! 4000b544 <_Thread_queue_Timeout> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400069f4: c2 04 61 30 ld [ %l1 + 0x130 ], %g1 400069f8: 82 00 7f ff add %g1, -1, %g1 400069fc: c2 24 61 30 st %g1, [ %l1 + 0x130 ] 40006a00: c4 04 61 30 ld [ %l1 + 0x130 ], %g2 40006a04: 80 a0 a0 00 cmp %g2, 0 40006a08: 02 80 00 31 be 40006acc 40006a0c: 94 10 00 12 mov %l2, %o2 /* * 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 ); 40006a10: d2 04 80 00 ld [ %l2 ], %o1 <== NOT EXECUTED 40006a14: 96 10 20 00 clr %o3 <== NOT EXECUTED 40006a18: 98 10 20 00 clr %o4 <== NOT EXECUTED 40006a1c: 40 00 1f 62 call 4000e7a4 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 40006a20: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED errno = _Thread_Executing->Wait.return_code; 40006a24: 40 00 27 c4 call 40010934 <__errno> <== NOT EXECUTED 40006a28: 01 00 00 00 nop <== NOT EXECUTED 40006a2c: c2 05 22 0c ld [ %l4 + 0x20c ], %g1 <== NOT EXECUTED 40006a30: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 <== NOT EXECUTED 40006a34: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED return the_info->si_signo; 40006a38: f0 04 80 00 ld [ %l2 ], %i0 <== NOT EXECUTED } 40006a3c: 81 c7 e0 08 ret <== NOT EXECUTED 40006a40: 81 e8 00 00 restore <== NOT EXECUTED } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 40006a44: 7f ff ff 9a call 400068ac <_POSIX_signals_Get_highest> 40006a48: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( api, signo, the_info, TRUE, FALSE ); 40006a4c: 94 10 00 12 mov %l2, %o2 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 40006a50: b0 10 00 08 mov %o0, %i0 _POSIX_signals_Clear_signals( api, signo, the_info, TRUE, FALSE ); 40006a54: 96 10 20 01 mov 1, %o3 40006a58: 90 10 00 19 mov %i1, %o0 40006a5c: 92 10 00 18 mov %i0, %o1 40006a60: 40 00 1f 51 call 4000e7a4 <_POSIX_signals_Clear_signals> 40006a64: 98 10 20 00 clr %o4 _ISR_Enable( level ); 40006a68: 7f ff ef 30 call 40002728 40006a6c: 90 10 00 10 mov %l0, %o0 the_info->si_signo = signo; the_info->si_code = SI_USER; 40006a70: 82 10 20 01 mov 1, %g1 the_info->si_value.sival_int = 0; 40006a74: c0 24 a0 08 clr [ %l2 + 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; 40006a78: f0 24 80 00 st %i0, [ %l2 ] the_info->si_code = SI_USER; 40006a7c: c2 24 a0 04 st %g1, [ %l2 + 4 ] 40006a80: 81 c7 e0 08 ret 40006a84: 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 ); 40006a88: 7f ff ff 89 call 400068ac <_POSIX_signals_Get_highest> 40006a8c: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( 40006a90: 94 10 00 12 mov %l2, %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 ); 40006a94: 92 10 00 08 mov %o0, %o1 _POSIX_signals_Clear_signals( 40006a98: 96 10 20 00 clr %o3 40006a9c: 90 10 00 19 mov %i1, %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 ); 40006aa0: d2 24 80 00 st %o1, [ %l2 ] _POSIX_signals_Clear_signals( 40006aa4: 40 00 1f 40 call 4000e7a4 <_POSIX_signals_Clear_signals> 40006aa8: 98 10 20 00 clr %o4 the_info->si_signo, the_info, FALSE, FALSE ); _ISR_Enable( level ); 40006aac: 7f ff ef 1f call 40002728 40006ab0: 90 10 00 10 mov %l0, %o0 the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; return the_info->si_signo; 40006ab4: f0 04 80 00 ld [ %l2 ], %i0 FALSE, FALSE ); _ISR_Enable( level ); the_info->si_code = SI_USER; 40006ab8: 82 10 20 01 mov 1, %g1 the_info->si_value.sival_int = 0; 40006abc: c0 24 a0 08 clr [ %l2 + 8 ] FALSE, FALSE ); _ISR_Enable( level ); the_info->si_code = SI_USER; 40006ac0: c2 24 a0 04 st %g1, [ %l2 + 4 ] 40006ac4: 81 c7 e0 08 ret 40006ac8: 81 e8 00 00 restore _Thread_Dispatch(); 40006acc: 40 00 0f de call 4000aa44 <_Thread_Dispatch> 40006ad0: 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 ); 40006ad4: d2 04 80 00 ld [ %l2 ], %o1 40006ad8: 94 10 00 12 mov %l2, %o2 40006adc: 96 10 20 00 clr %o3 40006ae0: 98 10 20 00 clr %o4 40006ae4: 40 00 1f 30 call 4000e7a4 <_POSIX_signals_Clear_signals> 40006ae8: 90 10 00 19 mov %i1, %o0 errno = _Thread_Executing->Wait.return_code; 40006aec: 40 00 27 92 call 40010934 <__errno> 40006af0: 01 00 00 00 nop 40006af4: c2 05 22 0c ld [ %l4 + 0x20c ], %g1 40006af8: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 40006afc: c4 22 00 00 st %g2, [ %o0 ] return the_info->si_signo; 40006b00: f0 04 80 00 ld [ %l2 ], %i0 } 40006b04: 81 c7 e0 08 ret 40006b08: 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 ); 40006b0c: 40 00 27 8a call 40010934 <__errno> 40006b10: b0 10 3f ff mov -1, %i0 40006b14: 82 10 20 16 mov 0x16, %g1 40006b18: c2 22 00 00 st %g1, [ %o0 ] 40006b1c: 81 c7 e0 08 ret 40006b20: 81 e8 00 00 restore 4000885c : int sigwait( const sigset_t *set, int *sig ) { 4000885c: 9d e3 bf 98 save %sp, -104, %sp int status; status = sigtimedwait( set, NULL, NULL ); 40008860: 92 10 20 00 clr %o1 40008864: 90 10 00 18 mov %i0, %o0 40008868: 7f ff ff 75 call 4000863c 4000886c: 94 10 20 00 clr %o2 if ( status != -1 ) { 40008870: 80 a2 3f ff cmp %o0, -1 40008874: 02 80 00 07 be 40008890 40008878: 80 a6 60 00 cmp %i1, 0 if ( sig ) 4000887c: 02 80 00 03 be 40008888 40008880: b0 10 20 00 clr %i0 *sig = status; 40008884: d0 26 40 00 st %o0, [ %i1 ] 40008888: 81 c7 e0 08 ret 4000888c: 81 e8 00 00 restore return 0; } return errno; 40008890: 40 00 27 c5 call 400127a4 <__errno> <== NOT EXECUTED 40008894: 01 00 00 00 nop <== NOT EXECUTED 40008898: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED } 4000889c: 81 c7 e0 08 ret <== NOT EXECUTED 400088a0: 81 e8 00 00 restore <== NOT EXECUTED 4000b930 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 4000b930: 9d e3 bf 98 save %sp, -104, %sp POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 4000b934: 80 a6 20 01 cmp %i0, 1 4000b938: 12 80 00 4a bne 4000ba60 4000b93c: 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) { 4000b940: 02 80 00 0e be 4000b978 4000b944: 21 10 00 98 sethi %hi(0x40026000), %l0 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 4000b948: c2 06 40 00 ld [ %i1 ], %g1 4000b94c: 82 00 7f ff add %g1, -1, %g1 4000b950: 80 a0 60 01 cmp %g1, 1 4000b954: 18 80 00 43 bgu 4000ba60 4000b958: 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 ) 4000b95c: c2 06 60 04 ld [ %i1 + 4 ], %g1 4000b960: 80 a0 60 00 cmp %g1, 0 4000b964: 02 80 00 3f be 4000ba60 4000b968: 82 00 7f ff add %g1, -1, %g1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 4000b96c: 80 a0 60 1f cmp %g1, 0x1f 4000b970: 18 80 00 3c bgu 4000ba60 4000b974: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000b978: c2 04 20 00 ld [ %l0 ], %g1 4000b97c: 82 00 60 01 inc %g1 4000b980: c2 24 20 00 st %g1, [ %l0 ] * 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 ); 4000b984: 31 10 00 98 sethi %hi(0x40026000), %i0 4000b988: 40 00 0b bd call 4000e87c <_Objects_Allocate> 4000b98c: 90 16 23 cc or %i0, 0x3cc, %o0 ! 400263cc <_POSIX_Timer_Information> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 4000b990: 80 a2 20 00 cmp %o0, 0 4000b994: 02 80 00 39 be 4000ba78 4000b998: 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; 4000b99c: 05 10 00 98 sethi %hi(0x40026000), %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; 4000b9a0: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ] ptimer->thread_id = _Thread_Executing->Object.id; 4000b9a4: c6 00 a0 dc ld [ %g2 + 0xdc ], %g3 if ( evp != NULL ) { 4000b9a8: 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; 4000b9ac: c2 00 e0 08 ld [ %g3 + 8 ], %g1 if ( evp != NULL ) { 4000b9b0: 02 80 00 08 be 4000b9d0 4000b9b4: 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; 4000b9b8: 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; 4000b9bc: c4 06 40 00 ld [ %i1 ], %g2 ptimer->inf.sigev_signo = evp->sigev_signo; 4000b9c0: 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; 4000b9c4: c4 22 20 40 st %g2, [ %o0 + 0x40 ] ptimer->inf.sigev_signo = evp->sigev_signo; 4000b9c8: c6 22 20 44 st %g3, [ %o0 + 0x44 ] ptimer->inf.sigev_value = evp->sigev_value; 4000b9cc: c2 22 20 48 st %g1, [ %o0 + 0x48 ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000b9d0: 88 16 23 cc or %i0, 0x3cc, %g4 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000b9d4: c6 02 20 08 ld [ %o0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000b9d8: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 } ptimer->overrun = 0; 4000b9dc: c0 22 20 68 clr [ %o0 + 0x68 ] ptimer->timer_data.it_value.tv_sec = 0; 4000b9e0: c0 22 20 5c clr [ %o0 + 0x5c ] ptimer->timer_data.it_value.tv_nsec = 0; 4000b9e4: c0 22 20 60 clr [ %o0 + 0x60 ] ptimer->timer_data.it_interval.tv_sec = 0; 4000b9e8: c0 22 20 54 clr [ %o0 + 0x54 ] ptimer->timer_data.it_interval.tv_nsec = 0; 4000b9ec: c0 22 20 58 clr [ %o0 + 0x58 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4000b9f0: c0 22 20 18 clr [ %o0 + 0x18 ] the_watchdog->routine = routine; 4000b9f4: c0 22 20 2c clr [ %o0 + 0x2c ] the_watchdog->id = id; 4000b9f8: c0 22 20 30 clr [ %o0 + 0x30 ] 4000b9fc: 03 00 00 3f sethi %hi(0xfc00), %g1 4000ba00: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000ba04: 82 08 c0 01 and %g3, %g1, %g1 4000ba08: 80 a0 40 02 cmp %g1, %g2 4000ba0c: 18 80 00 05 bgu 4000ba20 4000ba10: c0 22 20 34 clr [ %o0 + 0x34 ] information->local_table[ index ] = the_object; 4000ba14: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 4000ba18: 83 28 60 02 sll %g1, 2, %g1 4000ba1c: d0 20 80 01 st %o0, [ %g2 + %g1 ] _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open(&_POSIX_Timer_Information, &ptimer->Object, (Objects_Name) 0); *timerid = ptimer->Object.id; 4000ba20: c6 26 80 00 st %g3, [ %i2 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 4000ba24: c0 22 20 0c clr [ %o0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000ba28: c2 04 20 00 ld [ %l0 ], %g1 4000ba2c: b0 10 20 00 clr %i0 4000ba30: 82 00 7f ff add %g1, -1, %g1 4000ba34: c2 24 20 00 st %g1, [ %l0 ] 4000ba38: c4 04 20 00 ld [ %l0 ], %g2 4000ba3c: 80 a0 a0 00 cmp %g2, 0 4000ba40: 02 80 00 04 be 4000ba50 4000ba44: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } 4000ba48: 81 c7 e0 08 ret <== NOT EXECUTED 4000ba4c: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4000ba50: 40 00 11 c8 call 40010170 <_Thread_Dispatch> 4000ba54: 01 00 00 00 nop 4000ba58: 81 c7 e0 08 ret 4000ba5c: 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 ); 4000ba60: 40 00 2a e2 call 400165e8 <__errno> <== NOT EXECUTED 4000ba64: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 4000ba68: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 4000ba6c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000ba70: 81 c7 e0 08 ret <== NOT EXECUTED 4000ba74: 81 e8 00 00 restore <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000ba78: c2 04 20 00 ld [ %l0 ], %g1 <== NOT EXECUTED 4000ba7c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000ba80: c2 24 20 00 st %g1, [ %l0 ] <== NOT EXECUTED 4000ba84: c4 04 20 00 ld [ %l0 ], %g2 <== NOT EXECUTED 4000ba88: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000ba8c: 02 80 00 08 be 4000baac <== NOT EXECUTED 4000ba90: 01 00 00 00 nop <== NOT EXECUTED * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EAGAIN ); 4000ba94: 40 00 2a d5 call 400165e8 <__errno> <== NOT EXECUTED 4000ba98: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 4000ba9c: 82 10 20 0b mov 0xb, %g1 <== NOT EXECUTED 4000baa0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000baa4: 81 c7 e0 08 ret <== NOT EXECUTED 4000baa8: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4000baac: 40 00 11 b1 call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000bab0: 01 00 00 00 nop <== NOT EXECUTED 4000bab4: 30 bf ff f8 b,a 4000ba94 <== NOT EXECUTED 4000b858 : */ int timer_delete( timer_t timerid ) { 4000b858: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED 4000b85c: 21 10 00 98 sethi %hi(0x40026000), %l0 <== NOT EXECUTED 4000b860: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000b864: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 4000b868: 40 00 0d 56 call 4000edc0 <_Objects_Get> <== NOT EXECUTED 4000b86c: 90 14 23 cc or %l0, 0x3cc, %o0 <== NOT EXECUTED */ POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 4000b870: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4000b874: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000b878: 12 80 00 21 bne 4000b8fc <== NOT EXECUTED 4000b87c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000b880: a0 14 23 cc or %l0, 0x3cc, %l0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000b884: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000b888: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 <== NOT EXECUTED 4000b88c: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED 4000b890: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <== NOT EXECUTED 4000b894: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 4000b898: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4000b89c: 38 80 00 06 bgu,a 4000b8b4 <== NOT EXECUTED 4000b8a0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 4000b8a4: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED 4000b8a8: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4000b8ac: c0 20 80 01 clr [ %g2 + %g1 ] <== NOT EXECUTED case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Timer_Information, &ptimer->Object ); ptimer->state = POSIX_TIMER_STATE_FREE; 4000b8b0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 4000b8b4: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED 4000b8b8: c2 2e 20 3c stb %g1, [ %i0 + 0x3c ] <== NOT EXECUTED (void) _Watchdog_Remove( &ptimer->Timer ); 4000b8bc: 40 00 18 0d call 400118f0 <_Watchdog_Remove> <== NOT EXECUTED 4000b8c0: 90 06 20 10 add %i0, 0x10, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free ( POSIX_Timer_Control *the_timer ) { _Objects_Free( &_POSIX_Timer_Information, &the_timer->Object ); 4000b8c4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 4000b8c8: 40 00 0c fb call 4000ecb4 <_Objects_Free> <== NOT EXECUTED 4000b8cc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000b8d0: 07 10 00 98 sethi %hi(0x40026000), %g3 <== NOT EXECUTED 4000b8d4: c2 00 e0 00 ld [ %g3 ], %g1 <== NOT EXECUTED 4000b8d8: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000b8dc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000b8e0: c2 20 e0 00 st %g1, [ %g3 ] <== NOT EXECUTED 4000b8e4: c4 00 e0 00 ld [ %g3 ], %g2 <== NOT EXECUTED 4000b8e8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000b8ec: 02 80 00 0d be 4000b920 <== NOT EXECUTED 4000b8f0: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); return 0; } return -1; /* unreached - only to remove warnings */ } 4000b8f4: 81 c7 e0 08 ret <== NOT EXECUTED 4000b8f8: 81 e8 00 00 restore <== NOT EXECUTED */ POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 4000b8fc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000b900: 18 bf ff fd bgu 4000b8f4 <== NOT EXECUTED 4000b904: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED _Thread_Dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); #endif case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 4000b908: 40 00 2b 38 call 400165e8 <__errno> <== NOT EXECUTED 4000b90c: 01 00 00 00 nop <== NOT EXECUTED 4000b910: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 4000b914: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000b918: 81 c7 e0 08 ret <== NOT EXECUTED 4000b91c: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4000b920: 40 00 12 14 call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000b924: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); return 0; } return -1; /* unreached - only to remove warnings */ } 4000b928: 81 c7 e0 08 ret <== NOT EXECUTED 4000b92c: 81 e8 00 00 restore <== NOT EXECUTED 4000b7d0 : */ int timer_getoverrun( timer_t timerid ) { 4000b7d0: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED 4000b7d4: 11 10 00 98 sethi %hi(0x40026000), %o0 <== NOT EXECUTED 4000b7d8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000b7dc: 90 12 23 cc or %o0, 0x3cc, %o0 <== NOT EXECUTED 4000b7e0: 40 00 0d 78 call 4000edc0 <_Objects_Get> <== NOT EXECUTED 4000b7e4: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED int overrun; POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 4000b7e8: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4000b7ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000b7f0: 12 80 00 0e bne 4000b828 <== NOT EXECUTED 4000b7f4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: overrun = ptimer->overrun; 4000b7f8: f0 02 20 68 ld [ %o0 + 0x68 ], %i0 <== NOT EXECUTED ptimer->overrun = 0; 4000b7fc: c0 22 20 68 clr [ %o0 + 0x68 ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000b800: 03 10 00 98 sethi %hi(0x40026000), %g1 <== NOT EXECUTED 4000b804: c4 00 60 00 ld [ %g1 ], %g2 <== NOT EXECUTED 4000b808: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 4000b80c: c4 20 60 00 st %g2, [ %g1 ] <== NOT EXECUTED 4000b810: c6 00 60 00 ld [ %g1 ], %g3 <== NOT EXECUTED 4000b814: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000b818: 02 80 00 0c be 4000b848 <== NOT EXECUTED 4000b81c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return overrun; } return -1; /* unreached - only to remove warnings */ } 4000b820: 81 c7 e0 08 ret <== NOT EXECUTED 4000b824: 81 e8 00 00 restore <== NOT EXECUTED int overrun; POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 4000b828: 18 bf ff fe bgu 4000b820 <== NOT EXECUTED 4000b82c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED _Thread_Dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); #endif case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 4000b830: 40 00 2b 6e call 400165e8 <__errno> <== NOT EXECUTED 4000b834: 01 00 00 00 nop <== NOT EXECUTED 4000b838: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 4000b83c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000b840: 81 c7 e0 08 ret <== NOT EXECUTED 4000b844: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4000b848: 40 00 12 4a call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000b84c: 01 00 00 00 nop <== NOT EXECUTED ptimer->overrun = 0; _Thread_Enable_dispatch(); return overrun; } return -1; /* unreached - only to remove warnings */ } 4000b850: 81 c7 e0 08 ret <== NOT EXECUTED 4000b854: 81 e8 00 00 restore <== NOT EXECUTED 4000b71c : int timer_gettime( timer_t timerid, struct itimerspec *value ) { 4000b71c: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED POSIX_Timer_Control *ptimer; Objects_Locations location; struct timespec current_time; /* Reads the current time */ _TOD_Get( ¤t_time ); 4000b720: a0 07 bf ec add %fp, -20, %l0 <== NOT EXECUTED 4000b724: 40 00 0a 94 call 4000e174 <_TOD_Get> <== NOT EXECUTED 4000b728: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED int timer_gettime( timer_t timerid, struct itimerspec *value ) { 4000b72c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Timer_Control *) 4000b730: 11 10 00 98 sethi %hi(0x40026000), %o0 <== NOT EXECUTED 4000b734: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 4000b738: 40 00 0d a2 call 4000edc0 <_Objects_Get> <== NOT EXECUTED 4000b73c: 90 12 23 cc or %o0, 0x3cc, %o0 <== NOT EXECUTED /* Reads the current time */ _TOD_Get( ¤t_time ); ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 4000b740: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4000b744: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000b748: 12 80 00 15 bne 4000b79c <== NOT EXECUTED 4000b74c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ _Timespec_Subtract( 4000b750: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 4000b754: 90 02 20 5c add %o0, 0x5c, %o0 <== NOT EXECUTED 4000b758: 40 00 17 04 call 40011368 <_Timespec_Subtract> <== NOT EXECUTED 4000b75c: 94 06 60 08 add %i1, 8, %o2 <== NOT EXECUTED &ptimer->timer_data.it_value, ¤t_time, &value->it_value ); value->it_interval = ptimer->timer_data.it_interval; 4000b760: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 4000b764: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED 4000b768: c4 06 20 58 ld [ %i0 + 0x58 ], %g2 <== NOT EXECUTED 4000b76c: c4 26 60 04 st %g2, [ %i1 + 4 ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000b770: 07 10 00 98 sethi %hi(0x40026000), %g3 <== NOT EXECUTED 4000b774: c2 00 e0 00 ld [ %g3 ], %g1 <== NOT EXECUTED 4000b778: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000b77c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000b780: c2 20 e0 00 st %g1, [ %g3 ] <== NOT EXECUTED 4000b784: c4 00 e0 00 ld [ %g3 ], %g2 <== NOT EXECUTED 4000b788: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000b78c: 02 80 00 0d be 4000b7c0 <== NOT EXECUTED 4000b790: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return -1; /* unreached - only to remove warnings */ } 4000b794: 81 c7 e0 08 ret <== NOT EXECUTED 4000b798: 81 e8 00 00 restore <== NOT EXECUTED /* Reads the current time */ _TOD_Get( ¤t_time ); ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 4000b79c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000b7a0: 18 bf ff fd bgu 4000b794 <== NOT EXECUTED 4000b7a4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED _Thread_Dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); #endif case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 4000b7a8: 40 00 2b 90 call 400165e8 <__errno> <== NOT EXECUTED 4000b7ac: 01 00 00 00 nop <== NOT EXECUTED 4000b7b0: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 4000b7b4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000b7b8: 81 c7 e0 08 ret <== NOT EXECUTED 4000b7bc: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4000b7c0: 40 00 12 6c call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000b7c4: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return -1; /* unreached - only to remove warnings */ } 4000b7c8: 81 c7 e0 08 ret <== NOT EXECUTED 4000b7cc: 81 e8 00 00 restore <== NOT EXECUTED 4000bab8 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 4000bab8: 9d e3 bf 90 save %sp, -112, %sp POSIX_Timer_Control *ptimer; Objects_Locations location; boolean activated; if ( value == NULL ) { 4000babc: 80 a6 a0 00 cmp %i2, 0 4000bac0: 02 80 00 29 be 4000bb64 4000bac4: 92 10 00 18 mov %i0, %o1 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 ) || 4000bac8: c4 06 a0 0c ld [ %i2 + 0xc ], %g2 4000bacc: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 4000bad0: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 4000bad4: 80 a0 80 01 cmp %g2, %g1 4000bad8: 18 80 00 23 bgu 4000bb64 4000badc: 80 a6 60 04 cmp %i1, 4 rtems_set_errno_and_return_minus_one( EINVAL ); } /* XXX check for seconds in the past */ if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 4000bae0: 02 80 00 04 be 4000baf0 4000bae4: 80 a6 60 00 cmp %i1, 0 4000bae8: 12 80 00 1f bne 4000bb64 4000baec: 01 00 00 00 nop RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Timer_Control *) 4000baf0: 11 10 00 98 sethi %hi(0x40026000), %o0 4000baf4: 94 07 bf f4 add %fp, -12, %o2 4000baf8: 40 00 0c b2 call 4000edc0 <_Objects_Get> 4000bafc: 90 12 23 cc or %o0, 0x3cc, %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 ) { 4000bb00: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000bb04: a0 10 00 08 mov %o0, %l0 4000bb08: 80 a0 60 00 cmp %g1, 0 4000bb0c: 12 80 00 1a bne 4000bb74 4000bb10: b0 10 3f ff mov -1, %i0 case OBJECTS_ERROR: return -1; case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( value->it_value.tv_sec == 0 && value->it_value.tv_nsec == 0 ) { 4000bb14: c2 06 a0 08 ld [ %i2 + 8 ], %g1 4000bb18: 80 a0 60 00 cmp %g1, 0 4000bb1c: 12 80 00 06 bne 4000bb34 4000bb20: 80 a6 60 00 cmp %i1, 0 4000bb24: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 <== NOT EXECUTED 4000bb28: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bb2c: 02 80 00 5d be 4000bca0 <== NOT EXECUTED 4000bb30: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* absolute or relative? */ switch (flags) { 4000bb34: 02 80 00 42 be 4000bc3c 4000bb38: 80 a6 60 04 cmp %i1, 4 4000bb3c: 22 80 00 10 be,a 4000bb7c <== NOT EXECUTED 4000bb40: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000bb44: 03 10 00 98 sethi %hi(0x40026000), %g1 <== NOT EXECUTED 4000bb48: c4 00 60 00 ld [ %g1 ], %g2 <== NOT EXECUTED 4000bb4c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 4000bb50: c4 20 60 00 st %g2, [ %g1 ] <== NOT EXECUTED 4000bb54: c6 00 60 00 ld [ %g1 ], %g3 <== NOT EXECUTED 4000bb58: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000bb5c: 02 80 00 6d be 4000bd10 <== NOT EXECUTED 4000bb60: 01 00 00 00 nop <== NOT EXECUTED _TOD_Get( &ptimer->time ); _Thread_Enable_dispatch(); return 0; } _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); 4000bb64: 40 00 2a a1 call 400165e8 <__errno> <== NOT EXECUTED 4000bb68: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 4000bb6c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 4000bb70: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000bb74: 81 c7 e0 08 ret <== NOT EXECUTED 4000bb78: 81 e8 00 00 restore <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000bb7c: 05 10 00 98 sethi %hi(0x40026000), %g2 <== NOT EXECUTED void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 4000bb80: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000bb84: c6 00 a0 b8 ld [ %g2 + 0xb8 ], %g3 <== NOT EXECUTED 4000bb88: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4000bb8c: c0 24 20 18 clr [ %l0 + 0x18 ] <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000bb90: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 4000bb94: c2 24 20 1c st %g1, [ %l0 + 0x1c ] <== NOT EXECUTED Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 4000bb98: 03 10 00 2d sethi %hi(0x4000b400), %g1 <== NOT EXECUTED 4000bb9c: 82 10 62 94 or %g1, 0x294, %g1 ! 4000b694 <_POSIX_Timer_TSR> <== NOT EXECUTED the_watchdog->id = id; the_watchdog->user_data = user_data; 4000bba0: e0 24 20 34 st %l0, [ %l0 + 0x34 ] <== NOT EXECUTED Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 4000bba4: c2 24 20 2c st %g1, [ %l0 + 0x2c ] <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 4000bba8: 11 10 00 98 sethi %hi(0x40026000), %o0 <== NOT EXECUTED 4000bbac: 92 04 20 10 add %l0, 0x10, %o1 <== NOT EXECUTED 4000bbb0: 40 00 16 e6 call 40011748 <_Watchdog_Insert> <== NOT EXECUTED 4000bbb4: 90 12 20 f0 or %o0, 0xf0, %o0 <== NOT EXECUTED &ptimer->Timer, value->it_value.tv_sec - _TOD_Seconds_since_epoch ); /* Returns the old ones in "ovalue" */ if ( ovalue ) 4000bbb8: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 4000bbbc: 22 80 00 0b be,a 4000bbe8 <== NOT EXECUTED 4000bbc0: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED } /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) *ovalue = ptimer->timer_data; 4000bbc4: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 <== NOT EXECUTED 4000bbc8: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED 4000bbcc: c4 04 20 58 ld [ %l0 + 0x58 ], %g2 <== NOT EXECUTED 4000bbd0: c4 26 e0 04 st %g2, [ %i3 + 4 ] <== NOT EXECUTED 4000bbd4: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED 4000bbd8: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED 4000bbdc: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 <== NOT EXECUTED 4000bbe0: c4 26 e0 0c st %g2, [ %i3 + 0xc ] <== NOT EXECUTED ptimer->timer_data = *value; 4000bbe4: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; _TOD_Get( &ptimer->time ); 4000bbe8: 90 04 20 6c add %l0, 0x6c, %o0 /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) *ovalue = ptimer->timer_data; ptimer->timer_data = *value; 4000bbec: c4 24 20 54 st %g2, [ %l0 + 0x54 ] 4000bbf0: c2 06 a0 04 ld [ %i2 + 4 ], %g1 4000bbf4: c2 24 20 58 st %g1, [ %l0 + 0x58 ] 4000bbf8: c4 06 a0 08 ld [ %i2 + 8 ], %g2 /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 4000bbfc: 82 10 20 03 mov 3, %g1 /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) *ovalue = ptimer->timer_data; ptimer->timer_data = *value; 4000bc00: c4 24 20 5c st %g2, [ %l0 + 0x5c ] 4000bc04: c6 06 a0 0c ld [ %i2 + 0xc ], %g3 /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 4000bc08: c2 2c 20 3c stb %g1, [ %l0 + 0x3c ] _TOD_Get( &ptimer->time ); 4000bc0c: 40 00 09 5a call 4000e174 <_TOD_Get> 4000bc10: c6 24 20 60 st %g3, [ %l0 + 0x60 ] 4000bc14: 05 10 00 98 sethi %hi(0x40026000), %g2 4000bc18: c2 00 a0 00 ld [ %g2 ], %g1 4000bc1c: 82 00 7f ff add %g1, -1, %g1 4000bc20: c2 20 a0 00 st %g1, [ %g2 ] 4000bc24: c6 00 a0 00 ld [ %g2 ], %g3 4000bc28: 80 a0 e0 00 cmp %g3, 0 4000bc2c: 02 80 00 19 be 4000bc90 4000bc30: 01 00 00 00 nop } _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } return -1; /* unreached - only to remove warnings */ } 4000bc34: 81 c7 e0 08 ret <== NOT EXECUTED 4000bc38: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED break; /* The fire time is relative: use "rtems_time_fire_after" */ case POSIX_TIMER_RELATIVE: /* First, convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_value ); 4000bc3c: 40 00 15 e1 call 400113c0 <_Timespec_To_ticks> 4000bc40: 90 06 a0 08 add %i2, 8, %o0 activated = _Watchdog_Insert_ticks_helper( 4000bc44: d4 04 20 08 ld [ %l0 + 8 ], %o2 break; /* The fire time is relative: use "rtems_time_fire_after" */ case POSIX_TIMER_RELATIVE: /* First, convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_value ); 4000bc48: 92 10 00 08 mov %o0, %o1 4000bc4c: d0 24 20 64 st %o0, [ %l0 + 0x64 ] activated = _Watchdog_Insert_ticks_helper( 4000bc50: 17 10 00 2d sethi %hi(0x4000b400), %o3 4000bc54: 90 04 20 10 add %l0, 0x10, %o0 4000bc58: 96 12 e2 94 or %o3, 0x294, %o3 4000bc5c: 7f ff fe 73 call 4000b628 <_Watchdog_Insert_ticks_helper> 4000bc60: 98 10 00 10 mov %l0, %o4 ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 4000bc64: 80 a2 20 00 cmp %o0, 0 4000bc68: 12 80 00 26 bne 4000bd00 4000bc6c: 80 a6 e0 00 cmp %i3, 0 4000bc70: 03 10 00 98 sethi %hi(0x40026000), %g1 <== NOT EXECUTED 4000bc74: c4 00 60 00 ld [ %g1 ], %g2 <== NOT EXECUTED 4000bc78: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 4000bc7c: c4 20 60 00 st %g2, [ %g1 ] <== NOT EXECUTED 4000bc80: c6 00 60 00 ld [ %g1 ], %g3 <== NOT EXECUTED 4000bc84: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000bc88: 32 bf ff bb bne,a 4000bb74 <== NOT EXECUTED 4000bc8c: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Dispatch(); 4000bc90: 40 00 11 38 call 40010170 <_Thread_Dispatch> 4000bc94: b0 10 20 00 clr %i0 4000bc98: 81 c7 e0 08 ret 4000bc9c: 81 e8 00 00 restore case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( value->it_value.tv_sec == 0 && value->it_value.tv_nsec == 0 ) { /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 4000bca0: 40 00 17 14 call 400118f0 <_Watchdog_Remove> <== NOT EXECUTED 4000bca4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED /* The old data of the timer are returned */ if ( ovalue ) 4000bca8: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 4000bcac: 22 80 00 0b be,a 4000bcd8 <== NOT EXECUTED 4000bcb0: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED *ovalue = ptimer->timer_data; 4000bcb4: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 <== NOT EXECUTED 4000bcb8: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED 4000bcbc: c4 04 20 58 ld [ %l0 + 0x58 ], %g2 <== NOT EXECUTED 4000bcc0: c4 26 e0 04 st %g2, [ %i3 + 4 ] <== NOT EXECUTED 4000bcc4: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED 4000bcc8: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED 4000bccc: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 <== NOT EXECUTED 4000bcd0: c4 26 e0 0c st %g2, [ %i3 + 0xc ] <== NOT EXECUTED /* The new data are set */ ptimer->timer_data = *value; 4000bcd4: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 4000bcd8: c2 24 20 54 st %g1, [ %l0 + 0x54 ] <== NOT EXECUTED 4000bcdc: c4 06 a0 04 ld [ %i2 + 4 ], %g2 <== NOT EXECUTED 4000bce0: c4 24 20 58 st %g2, [ %l0 + 0x58 ] <== NOT EXECUTED 4000bce4: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED 4000bce8: c2 24 20 5c st %g1, [ %l0 + 0x5c ] <== NOT EXECUTED 4000bcec: c4 06 a0 0c ld [ %i2 + 0xc ], %g2 <== NOT EXECUTED /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 4000bcf0: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED (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 = *value; 4000bcf4: c4 24 20 60 st %g2, [ %l0 + 0x60 ] <== NOT EXECUTED /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 4000bcf8: 10 bf ff c7 b 4000bc14 <== NOT EXECUTED 4000bcfc: c2 2c 20 3c stb %g1, [ %l0 + 0x3c ] <== NOT EXECUTED return 0; } /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) 4000bd00: 32 bf ff b2 bne,a 4000bbc8 4000bd04: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 <== NOT EXECUTED *ovalue = ptimer->timer_data; ptimer->timer_data = *value; 4000bd08: 10 bf ff b8 b 4000bbe8 4000bd0c: c4 06 80 00 ld [ %i2 ], %g2 4000bd10: 40 00 11 18 call 40010170 <_Thread_Dispatch> <== NOT EXECUTED 4000bd14: 01 00 00 00 nop <== NOT EXECUTED 4000bd18: 30 bf ff 93 b,a 4000bb64 <== NOT EXECUTED 4000bf6c : int usleep( useconds_t useconds ) { 4000bf6c: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED struct timespec tp; struct timespec tm; unsigned remaining; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 4000bf70: 21 00 03 d0 sethi %hi(0xf4000), %l0 <== NOT EXECUTED 4000bf74: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000bf78: 7f ff d6 1f call 400017f4 <.udiv> <== NOT EXECUTED 4000bf7c: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 4000bf80: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED { struct timespec tp; struct timespec tm; unsigned remaining; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 4000bf84: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 4000bf88: 40 00 5e af call 40023a44 <.urem> <== NOT EXECUTED 4000bf8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000bf90: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED 4000bf94: 83 2a 20 07 sll %o0, 7, %g1 <== NOT EXECUTED 4000bf98: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 4000bf9c: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 4000bfa0: 83 28 60 03 sll %g1, 3, %g1 <== NOT EXECUTED nanosleep( &tp, &tm ); 4000bfa4: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED struct timespec tp; struct timespec tm; unsigned remaining; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 4000bfa8: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED nanosleep( &tp, &tm ); 4000bfac: 40 00 26 b5 call 40015a80 <== NOT EXECUTED 4000bfb0: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED remaining = tm.tv_sec * TOD_MICROSECONDS_PER_SECOND; 4000bfb4: c4 07 bf e8 ld [ %fp + -24 ], %g2 <== NOT EXECUTED 4000bfb8: d0 07 bf ec ld [ %fp + -20 ], %o0 <== NOT EXECUTED 4000bfbc: 87 28 a0 03 sll %g2, 3, %g3 <== NOT EXECUTED 4000bfc0: 83 28 a0 08 sll %g2, 8, %g1 <== NOT EXECUTED 4000bfc4: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 4000bfc8: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED 4000bfcc: b1 28 60 06 sll %g1, 6, %i0 <== NOT EXECUTED 4000bfd0: b0 26 00 01 sub %i0, %g1, %i0 <== NOT EXECUTED 4000bfd4: 7f ff d6 0a call 400017fc <.div> <== NOT EXECUTED 4000bfd8: b0 06 00 02 add %i0, %g2, %i0 <== NOT EXECUTED 4000bfdc: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED remaining += tm.tv_nsec / 1000; return remaining; /* seconds remaining */ } 4000bfe0: 81 c7 e0 08 ret <== NOT EXECUTED 4000bfe4: 91 ea 00 18 restore %o0, %i0, %o0 <== NOT EXECUTED