400237ac : assert( 0 ); return 0; } int POSIX_BOTTOM_REACHED() { 400237ac: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 400237b0: 92 10 20 22 mov 0x22, %o1 <== NOT EXECUTED 400237b4: 11 10 00 9d sethi %hi(0x40027400), %o0 <== NOT EXECUTED 400237b8: 15 10 00 8f sethi %hi(0x40023c00), %o2 <== NOT EXECUTED 400237bc: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED 400237c0: 94 12 a0 28 or %o2, 0x28, %o2 <== NOT EXECUTED 400237c4: 7f ff 8d 90 call 40006e04 <__assert> <== NOT EXECUTED 400237c8: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 400237cc: 81 c7 e0 08 ret <== NOT EXECUTED 400237d0: 81 e8 00 00 restore <== NOT EXECUTED 400237d4 : */ #include int POSIX_MP_NOT_IMPLEMENTED() { 400237d4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 400237d8: 92 10 20 1c mov 0x1c, %o1 <== NOT EXECUTED 400237dc: 11 10 00 9d sethi %hi(0x40027400), %o0 <== NOT EXECUTED 400237e0: 15 10 00 8f sethi %hi(0x40023c00), %o2 <== NOT EXECUTED 400237e4: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED 400237e8: 94 12 a0 28 or %o2, 0x28, %o2 <== NOT EXECUTED 400237ec: 7f ff 8d 86 call 40006e04 <__assert> <== NOT EXECUTED 400237f0: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 400237f4: 81 c7 e0 08 ret <== NOT EXECUTED 400237f8: 81 e8 00 00 restore <== NOT EXECUTED 40023784 : assert( 0 ); return 0; } int POSIX_NOT_IMPLEMENTED() { 40023784: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 40023788: 92 10 20 28 mov 0x28, %o1 <== NOT EXECUTED 4002378c: 11 10 00 9d sethi %hi(0x40027400), %o0 <== NOT EXECUTED 40023790: 15 10 00 8f sethi %hi(0x40023c00), %o2 <== NOT EXECUTED 40023794: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED 40023798: 94 12 a0 28 or %o2, 0x28, %o2 <== NOT EXECUTED 4002379c: 7f ff 8d 9a call 40006e04 <__assert> <== NOT EXECUTED 400237a0: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 400237a4: 81 c7 e0 08 ret <== NOT EXECUTED 400237a8: 81 e8 00 00 restore <== NOT EXECUTED 400075cc <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 400075cc: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 400075d0: 03 10 00 6c sethi %hi(0x4001b000), %g1 400075d4: e0 00 60 60 ld [ %g1 + 0x60 ], %l0 ! 4001b060 <_API_extensions_List> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 400075d8: 03 10 00 6c sethi %hi(0x4001b000), %g1 400075dc: 10 80 00 08 b 400075fc <_API_extensions_Run_postdriver+0x30> 400075e0: a2 10 60 64 or %g1, 0x64, %l1 ! 4001b064 <_API_extensions_List+0x4> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 400075e4: 80 a0 60 00 cmp %g1, 0 400075e8: 22 80 00 05 be,a 400075fc <_API_extensions_Run_postdriver+0x30> 400075ec: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postdriver_hook)(); 400075f0: 9f c0 40 00 call %g1 400075f4: 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 ) { 400075f8: 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 ) ; 400075fc: 80 a4 00 11 cmp %l0, %l1 40007600: 32 bf ff f9 bne,a 400075e4 <_API_extensions_Run_postdriver+0x18> 40007604: c2 04 20 0c ld [ %l0 + 0xc ], %g1 the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 40007608: 81 c7 e0 08 ret 4000760c: 81 e8 00 00 restore 40007670 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 40007670: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 40007674: 03 10 00 6c sethi %hi(0x4001b000), %g1 40007678: e0 00 60 60 ld [ %g1 + 0x60 ], %l0 ! 4001b060 <_API_extensions_List> the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); 4000767c: 23 10 00 6b sethi %hi(0x4001ac00), %l1 40007680: 03 10 00 6c sethi %hi(0x4001b000), %g1 40007684: 10 80 00 08 b 400076a4 <_API_extensions_Run_postswitch+0x34> 40007688: a4 10 60 64 or %g1, 0x64, %l2 ! 4001b064 <_API_extensions_List+0x4> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 4000768c: 80 a0 60 00 cmp %g1, 0 40007690: 22 80 00 05 be,a 400076a4 <_API_extensions_Run_postswitch+0x34> 40007694: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 40007698: 9f c0 40 00 call %g1 4000769c: d0 04 62 ac ld [ %l1 + 0x2ac ], %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 ) { 400076a0: 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 ) ; 400076a4: 80 a4 00 12 cmp %l0, %l2 400076a8: 32 bf ff f9 bne,a 4000768c <_API_extensions_Run_postswitch+0x1c> 400076ac: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); } } 400076b0: 81 c7 e0 08 ret 400076b4: 81 e8 00 00 restore 4000762c <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 4000762c: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 40007630: 03 10 00 6c sethi %hi(0x4001b000), %g1 40007634: e0 00 60 60 ld [ %g1 + 0x60 ], %l0 ! 4001b060 <_API_extensions_List> 40007638: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000763c: 10 80 00 08 b 4000765c <_API_extensions_Run_predriver+0x30> 40007640: a2 10 60 64 or %g1, 0x64, %l1 ! 4001b064 <_API_extensions_List+0x4> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 40007644: 80 a0 60 00 cmp %g1, 0 40007648: 22 80 00 05 be,a 4000765c <_API_extensions_Run_predriver+0x30> 4000764c: e0 04 00 00 ld [ %l0 ], %l0 (*the_extension->predriver_hook)(); 40007650: 9f c0 40 00 call %g1 <== NOT EXECUTED 40007654: 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 ) { 40007658: 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 ) ; 4000765c: 80 a4 00 11 cmp %l0, %l1 40007660: 32 bf ff f9 bne,a 40007644 <_API_extensions_Run_predriver+0x18> 40007664: c2 04 20 08 ld [ %l0 + 8 ], %g1 the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 40007668: 81 c7 e0 08 ret 4000766c: 81 e8 00 00 restore 40009948 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 40009948: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing = _Thread_Executing; 4000994c: 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 ); 40009950: 7f ff e5 0a call 40002d78 40009954: e0 00 61 ac ld [ %g1 + 0x1ac ], %l0 ! 4001d9ac <_Thread_Executing> 40009958: 84 10 00 08 mov %o0, %g2 switch ( the_rwlock->current_state ) { 4000995c: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 40009960: 80 a0 60 01 cmp %g1, 1 40009964: 22 80 00 0e be,a 4000999c <_CORE_RWLock_Release+0x54> 40009968: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 4000996c: 0a 80 00 06 bcs 40009984 <_CORE_RWLock_Release+0x3c> 40009970: 80 a0 60 02 cmp %g1, 2 40009974: 32 80 00 13 bne,a 400099c0 <_CORE_RWLock_Release+0x78> 40009978: c0 26 20 44 clr [ %i0 + 0x44 ] <== NOT EXECUTED 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; 4000997c: 10 80 00 10 b 400099bc <_CORE_RWLock_Release+0x74> 40009980: c0 24 20 34 clr [ %l0 + 0x34 ] */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { case CORE_RWLOCK_UNLOCKED: _ISR_Enable( level ); 40009984: 7f ff e5 01 call 40002d88 <== NOT EXECUTED 40009988: b0 10 20 00 clr %i0 <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 4000998c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40009990: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED 40009994: 81 c7 e0 08 ret <== NOT EXECUTED 40009998: 81 e8 00 00 restore <== NOT EXECUTED return CORE_RWLOCK_SUCCESSFUL; case CORE_RWLOCK_LOCKED_FOR_READING: the_rwlock->number_of_readers -= 1; 4000999c: 82 00 7f ff add %g1, -1, %g1 if ( the_rwlock->number_of_readers != 0 ) { 400099a0: 80 a0 60 00 cmp %g1, 0 400099a4: 02 80 00 05 be 400099b8 <_CORE_RWLock_Release+0x70> 400099a8: c2 26 20 48 st %g1, [ %i0 + 0x48 ] /* must be unlocked again */ _ISR_Enable( level ); 400099ac: 7f ff e4 f7 call 40002d88 400099b0: b0 10 20 00 clr %i0 400099b4: 30 80 00 25 b,a 40009a48 <_CORE_RWLock_Release+0x100> 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; 400099b8: 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; 400099bc: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 400099c0: 7f ff e4 f2 call 40002d88 400099c4: 90 10 00 02 mov %g2, %o0 next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 400099c8: 40 00 09 36 call 4000bea0 <_Thread_queue_Dequeue> 400099cc: 90 10 00 18 mov %i0, %o0 if ( next ) { 400099d0: 80 a2 20 00 cmp %o0, 0 400099d4: 22 80 00 1d be,a 40009a48 <_CORE_RWLock_Release+0x100> 400099d8: b0 10 20 00 clr %i0 if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 400099dc: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 400099e0: 80 a0 60 01 cmp %g1, 1 400099e4: 32 80 00 05 bne,a 400099f8 <_CORE_RWLock_Release+0xb0> 400099e8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 400099ec: 82 10 20 02 mov 2, %g1 400099f0: 10 80 00 15 b 40009a44 <_CORE_RWLock_Release+0xfc> 400099f4: c2 26 20 44 st %g1, [ %i0 + 0x44 ] /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 400099f8: 84 10 20 01 mov 1, %g2 } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 400099fc: 82 00 60 01 inc %g1 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 40009a00: c4 26 20 44 st %g2, [ %i0 + 0x44 ] } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 40009a04: 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 ); 40009a08: 40 00 0a ba call 4000c4f0 <_Thread_queue_First> 40009a0c: 90 10 00 18 mov %i0, %o0 if ( !next || 40009a10: 80 a2 20 00 cmp %o0, 0 40009a14: 22 80 00 0d be,a 40009a48 <_CORE_RWLock_Release+0x100> 40009a18: b0 10 20 00 clr %i0 40009a1c: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 40009a20: 80 a0 60 01 cmp %g1, 1 40009a24: 02 80 00 08 be 40009a44 <_CORE_RWLock_Release+0xfc> 40009a28: 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; 40009a2c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 40009a30: 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; 40009a34: 82 00 60 01 inc %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 40009a38: 40 00 0a 41 call 4000c33c <_Thread_queue_Extract> 40009a3c: c2 26 20 48 st %g1, [ %i0 + 0x48 ] 40009a40: 30 bf ff f2 b,a 40009a08 <_CORE_RWLock_Release+0xc0> } } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 40009a44: b0 10 20 00 clr %i0 40009a48: 81 c7 e0 08 ret 40009a4c: 81 e8 00 00 restore 40009a50 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 40009a50: 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 ) ) { 40009a54: 92 96 20 00 orcc %i0, 0, %o1 40009a58: 12 80 00 0a bne 40009a80 <_CORE_RWLock_Timeout+0x30> 40009a5c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009a60: 03 10 00 76 sethi %hi(0x4001d800), %g1 <== NOT EXECUTED 40009a64: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 4001d8d0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009a68: 84 00 a0 01 inc %g2 <== NOT EXECUTED 40009a6c: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] <== 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; 40009a70: 03 10 00 76 sethi %hi(0x4001d800), %g1 <== NOT EXECUTED 40009a74: d2 00 61 ac ld [ %g1 + 0x1ac ], %o1 ! 4001d9ac <_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; 40009a78: 10 80 00 18 b 40009ad8 <_CORE_RWLock_Timeout+0x88> <== NOT EXECUTED 40009a7c: c0 27 bf f4 clr [ %fp + -12 ] <== 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); 40009a80: 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 ) { 40009a84: 80 a0 a0 04 cmp %g2, 4 40009a88: 18 80 00 0e bgu 40009ac0 <_CORE_RWLock_Timeout+0x70> 40009a8c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40009a90: 83 32 60 1b srl %o1, 0x1b, %g1 40009a94: 80 a0 60 01 cmp %g1, 1 40009a98: 12 80 00 0a bne 40009ac0 <_CORE_RWLock_Timeout+0x70> 40009a9c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40009aa0: 83 28 a0 02 sll %g2, 2, %g1 40009aa4: 05 10 00 76 sethi %hi(0x4001d800), %g2 40009aa8: 84 10 a0 30 or %g2, 0x30, %g2 ! 4001d830 <_Objects_Information_table> 40009aac: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40009ab0: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 40009ab4: 80 a2 20 00 cmp %o0, 0 40009ab8: 12 80 00 05 bne 40009acc <_CORE_RWLock_Timeout+0x7c> 40009abc: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 40009ac0: 92 10 20 00 clr %o1 <== NOT EXECUTED 40009ac4: 10 80 00 05 b 40009ad8 <_CORE_RWLock_Timeout+0x88> <== NOT EXECUTED 40009ac8: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40009acc: 40 00 03 46 call 4000a7e4 <_Objects_Get> 40009ad0: 94 07 bf f4 add %fp, -12, %o2 40009ad4: 92 10 00 08 mov %o0, %o1 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40009ad8: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009adc: 80 a0 60 00 cmp %g1, 0 40009ae0: 12 80 00 18 bne 40009b40 <_CORE_RWLock_Timeout+0xf0> 40009ae4: 01 00 00 00 nop */ static inline void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 40009ae8: c4 02 60 44 ld [ %o1 + 0x44 ], %g2 * 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 && 40009aec: c6 00 a0 30 ld [ %g2 + 0x30 ], %g3 40009af0: 80 a0 e0 00 cmp %g3, 0 40009af4: 02 80 00 0b be 40009b20 <_CORE_RWLock_Timeout+0xd0> 40009af8: 03 10 00 76 sethi %hi(0x4001d800), %g1 40009afc: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1 ! 4001d9ac <_Thread_Executing> <== NOT EXECUTED 40009b00: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED 40009b04: 32 80 00 08 bne,a 40009b24 <_CORE_RWLock_Timeout+0xd4> <== NOT EXECUTED 40009b08: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 40009b0c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40009b10: 02 80 00 08 be 40009b30 <_CORE_RWLock_Timeout+0xe0> <== NOT EXECUTED 40009b14: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 40009b18: 10 80 00 06 b 40009b30 <_CORE_RWLock_Timeout+0xe0> <== NOT EXECUTED 40009b1c: c2 20 a0 30 st %g1, [ %g2 + 0x30 ] <== NOT EXECUTED } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 40009b20: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 40009b24: d0 02 60 44 ld [ %o1 + 0x44 ], %o0 40009b28: 40 00 0a 05 call 4000c33c <_Thread_queue_Extract> 40009b2c: 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; 40009b30: 05 10 00 76 sethi %hi(0x4001d800), %g2 40009b34: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 ! 4001d8d0 <_Thread_Dispatch_disable_level> 40009b38: 82 00 7f ff add %g1, -1, %g1 40009b3c: c2 20 a0 d0 st %g1, [ %g2 + 0xd0 ] 40009b40: 81 c7 e0 08 ret 40009b44: 81 e8 00 00 restore 40014378 <_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 ) { 40014378: 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 ) { 4001437c: 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 ) { 40014380: 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 ) { 40014384: 80 a6 80 01 cmp %i2, %g1 40014388: 18 80 00 17 bgu 400143e4 <_CORE_message_queue_Broadcast+0x6c> 4001438c: 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 ) { 40014390: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1 40014394: 80 a0 60 00 cmp %g1, 0 40014398: 02 80 00 0a be 400143c0 <_CORE_message_queue_Broadcast+0x48> 4001439c: a2 10 20 00 clr %l1 *count = 0; 400143a0: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED 400143a4: 81 c7 e0 08 ret <== NOT EXECUTED 400143a8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 400143ac: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 400143b0: 40 00 22 be call 4001cea8 400143b4: a2 04 60 01 inc %l1 buffer, waitp->return_argument, size ); *(uint32_t *)the_thread->Wait.return_argument_1 = size; 400143b8: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 400143bc: 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))) { 400143c0: 40 00 0b 3f call 400170bc <_Thread_queue_Dequeue> 400143c4: 90 10 00 12 mov %l2, %o0 400143c8: 92 10 00 19 mov %i1, %o1 400143cc: a0 10 00 08 mov %o0, %l0 400143d0: 80 a2 20 00 cmp %o0, 0 400143d4: 12 bf ff f6 bne 400143ac <_CORE_message_queue_Broadcast+0x34> 400143d8: 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; 400143dc: e2 27 40 00 st %l1, [ %i5 ] 400143e0: b0 10 20 00 clr %i0 return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 400143e4: 81 c7 e0 08 ret 400143e8: 81 e8 00 00 restore 40014664 <_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 ) { 40014664: 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; 40014668: 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; 4001466c: 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; 40014670: 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; 40014674: c0 26 20 60 clr [ %i0 + 0x60 ] the_message_queue->notify_argument = the_argument; 40014678: 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)) { 4001467c: 80 8e e0 03 btst 3, %i3 40014680: 02 80 00 07 be 4001469c <_CORE_message_queue_Initialize+0x38> 40014684: a0 10 00 1b mov %i3, %l0 allocated_message_size += sizeof(uint32_t); 40014688: 82 06 e0 04 add %i3, 4, %g1 allocated_message_size &= ~(sizeof(uint32_t) - 1); 4001468c: a0 08 7f fc and %g1, -4, %l0 } if (allocated_message_size < maximum_message_size) 40014690: 80 a4 00 1b cmp %l0, %i3 40014694: 0a 80 00 24 bcs 40014724 <_CORE_message_queue_Initialize+0xc0> 40014698: 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 * 4001469c: b6 04 20 14 add %l0, 0x14, %i3 400146a0: 92 10 00 1a mov %i2, %o1 400146a4: 40 00 2a 67 call 4001f040 <.umul> 400146a8: 90 10 00 1b mov %i3, %o0 (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 400146ac: 80 a2 00 10 cmp %o0, %l0 400146b0: 0a 80 00 1d bcs 40014724 <_CORE_message_queue_Initialize+0xc0> 400146b4: 92 10 00 08 mov %o0, %o1 400146b8: 11 10 00 97 sethi %hi(0x40025c00), %o0 400146bc: 7f ff e7 da call 4000e624 <_Heap_Allocate> 400146c0: 90 12 20 8c or %o0, 0x8c, %o0 ! 40025c8c <_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) 400146c4: 80 a2 20 00 cmp %o0, 0 400146c8: 02 80 00 17 be 40014724 <_CORE_message_queue_Initialize+0xc0> 400146cc: d0 26 20 5c st %o0, [ %i0 + 0x5c ] /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 400146d0: 92 10 00 08 mov %o0, %o1 400146d4: 94 10 00 1a mov %i2, %o2 400146d8: 90 06 20 68 add %i0, 0x68, %o0 400146dc: 7f ff ff 88 call 400144fc <_Chain_Initialize> 400146e0: 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( 400146e4: c2 06 40 00 ld [ %i1 ], %g1 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 400146e8: c0 26 20 54 clr [ %i0 + 0x54 ] 400146ec: 82 18 60 01 xor %g1, 1, %g1 400146f0: 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); 400146f4: 82 06 20 54 add %i0, 0x54, %g1 400146f8: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 400146fc: 82 06 20 50 add %i0, 0x50, %g1 40014700: 90 10 00 18 mov %i0, %o0 40014704: c2 26 20 58 st %g1, [ %i0 + 0x58 ] 40014708: 92 60 3f ff subx %g0, -1, %o1 4001470c: 94 10 20 80 mov 0x80, %o2 40014710: 96 10 20 06 mov 6, %o3 40014714: 7f ff f1 64 call 40010ca4 <_Thread_queue_Initialize> 40014718: b0 10 20 01 mov 1, %i0 4001471c: 81 c7 e0 08 ret 40014720: 81 e8 00 00 restore STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return TRUE; } 40014724: 81 c7 e0 08 ret <== NOT EXECUTED 40014728: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 400141f0 <_CORE_message_queue_Seize>: void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 400141f0: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; Thread_Control *the_thread; executing = _Thread_Executing; 400141f4: 03 10 00 a7 sethi %hi(0x40029c00), %g1 400141f8: e2 00 61 3c ld [ %g1 + 0x13c ], %l1 ! 40029d3c <_Thread_Executing> void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 400141fc: a0 10 00 18 mov %i0, %l0 Thread_Control *executing; Thread_Control *the_thread; executing = _Thread_Executing; executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; _ISR_Disable( level ); 40014200: 7f ff b9 1d call 40002674 40014204: c0 24 60 34 clr [ %l1 + 0x34 ] 40014208: 86 10 00 08 mov %o0, %g3 if ( the_message_queue->number_of_pending_messages != 0 ) { 4001420c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 40014210: 80 a0 60 00 cmp %g1, 0 40014214: 02 80 00 2a be 400142bc <_CORE_message_queue_Seize+0xcc> 40014218: 80 a7 20 00 cmp %i4, 0 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 4001421c: f2 06 20 50 ld [ %i0 + 0x50 ], %i1 the_message_queue->number_of_pending_messages -= 1; 40014220: 82 00 7f ff add %g1, -1, %g1 40014224: c2 26 20 48 st %g1, [ %i0 + 0x48 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 40014228: 82 06 20 54 add %i0, 0x54, %g1 4001422c: 80 a6 40 01 cmp %i1, %g1 40014230: 32 80 00 04 bne,a 40014240 <_CORE_message_queue_Seize+0x50> 40014234: c2 06 40 00 ld [ %i1 ], %g1 40014238: 10 80 00 05 b 4001424c <_CORE_message_queue_Seize+0x5c> <== NOT EXECUTED 4001423c: b2 10 20 00 clr %i1 <== NOT EXECUTED Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; new_first->previous = _Chain_Head(the_chain); 40014240: 84 06 20 50 add %i0, 0x50, %g2 Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; 40014244: c2 26 20 50 st %g1, [ %i0 + 0x50 ] new_first->previous = _Chain_Head(the_chain); 40014248: c4 20 60 04 st %g2, [ %g1 + 4 ] the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); 4001424c: 7f ff b9 0e call 40002684 40014250: 90 10 00 03 mov %g3, %o0 *size = the_message->Contents.size; 40014254: d4 06 60 0c ld [ %i1 + 0xc ], %o2 _Thread_Executing->Wait.count = the_message->priority; 40014258: 03 10 00 a7 sethi %hi(0x40029c00), %g1 the_message_queue->number_of_pending_messages -= 1; the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); *size = the_message->Contents.size; 4001425c: d4 26 c0 00 st %o2, [ %i3 ] _Thread_Executing->Wait.count = the_message->priority; 40014260: c4 00 61 3c ld [ %g1 + 0x13c ], %g2 40014264: c2 06 60 08 ld [ %i1 + 8 ], %g1 _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size); 40014268: 92 10 00 1a mov %i2, %o1 the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); *size = the_message->Contents.size; _Thread_Executing->Wait.count = the_message->priority; 4001426c: c2 20 a0 24 st %g1, [ %g2 + 0x24 ] _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size); 40014270: a2 06 60 10 add %i1, 0x10, %l1 40014274: 7f ff ff d8 call 400141d4 <_CORE_message_queue_Copy_buffer> 40014278: 90 10 00 11 mov %l1, %o0 * * NOTE: If we note that the queue was not full before this receive, * then we can avoid this dequeue. */ the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 4001427c: 7f ff e9 03 call 4000e688 <_Thread_queue_Dequeue> 40014280: 90 10 00 10 mov %l0, %o0 if ( !the_thread ) { 40014284: 82 92 20 00 orcc %o0, 0, %g1 40014288: 32 80 00 04 bne,a 40014298 <_CORE_message_queue_Seize+0xa8> 4001428c: d4 00 60 30 ld [ %g1 + 0x30 ], %o2 RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer ( CORE_message_queue_Control *the_message_queue, CORE_message_queue_Buffer_control *the_message ) { _Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node ); 40014290: 7f ff df 21 call 4000bf14 <_Chain_Append> 40014294: 91 ec 20 68 restore %l0, 0x68, %o0 * waiting task. */ the_message->priority = the_thread->Wait.count; the_message->Contents.size = (uint32_t)the_thread->Wait.option; _CORE_message_queue_Copy_buffer( 40014298: d0 00 60 28 ld [ %g1 + 0x28 ], %o0 * There was a thread waiting to send a message. This code * puts the messages in the message queue on behalf of the * waiting task. */ the_message->priority = the_thread->Wait.count; 4001429c: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 the_message->Contents.size = (uint32_t)the_thread->Wait.option; 400142a0: d4 26 60 0c st %o2, [ %i1 + 0xc ] * There was a thread waiting to send a message. This code * puts the messages in the message queue on behalf of the * waiting task. */ the_message->priority = the_thread->Wait.count; 400142a4: c2 26 60 08 st %g1, [ %i1 + 8 ] the_message->Contents.size = (uint32_t)the_thread->Wait.option; _CORE_message_queue_Copy_buffer( 400142a8: 7f ff ff cb call 400141d4 <_CORE_message_queue_Copy_buffer> 400142ac: 92 10 00 11 mov %l1, %o1 the_thread->Wait.return_argument, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 400142b0: f4 06 60 08 ld [ %i1 + 8 ], %i2 400142b4: 40 00 0c 18 call 40017314 <_CORE_message_queue_Insert_message> 400142b8: 91 e8 00 10 restore %g0, %l0, %o0 the_message->priority ); return; } if ( !wait ) { 400142bc: 12 80 00 08 bne 400142dc <_CORE_message_queue_Seize+0xec> 400142c0: 82 10 20 01 mov 1, %g1 _ISR_Enable( level ); 400142c4: 7f ff b8 f0 call 40002684 400142c8: 01 00 00 00 nop executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 400142cc: 82 10 20 04 mov 4, %g1 ! 4 400142d0: c2 24 60 34 st %g1, [ %l1 + 0x34 ] executing->Wait.return_argument_1 = (void *)size; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 400142d4: 81 c7 e0 08 ret 400142d8: 81 e8 00 00 restore _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.return_argument_1 = (void *)size; 400142dc: f6 24 60 2c st %i3, [ %l1 + 0x2c ] executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; return; } _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 400142e0: f0 24 60 44 st %i0, [ %l1 + 0x44 ] executing->Wait.id = id; 400142e4: f2 24 60 20 st %i1, [ %l1 + 0x20 ] executing->Wait.return_argument = buffer; 400142e8: f4 24 60 28 st %i2, [ %l1 + 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; 400142ec: c2 26 20 30 st %g1, [ %i0 + 0x30 ] executing->Wait.return_argument_1 = (void *)size; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 400142f0: 7f ff b8 e5 call 40002684 400142f4: 35 10 00 3b sethi %hi(0x4000ec00), %i2 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 400142f8: b2 10 00 1d mov %i5, %i1 400142fc: 7f ff e9 51 call 4000e840 <_Thread_queue_Enqueue_with_handler> 40014300: 95 ee a0 d8 restore %i2, 0xd8, %o2 40014304: 01 00 00 00 nop 40014324 <_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 ) { 40014324: 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 ) { 40014328: 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 ) { 4001432c: 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 ) { 40014330: 80 a6 80 01 cmp %i2, %g1 40014334: 18 80 00 3f bgu 40014430 <_CORE_message_queue_Submit+0x10c> 40014338: 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 ) { 4001433c: c2 04 60 48 ld [ %l1 + 0x48 ], %g1 40014340: 80 a0 60 00 cmp %g1, 0 40014344: 32 80 00 0f bne,a 40014380 <_CORE_message_queue_Submit+0x5c> 40014348: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 4001434c: 7f ff e8 cf call 4000e688 <_Thread_queue_Dequeue> 40014350: 90 10 00 11 mov %l1, %o0 if ( the_thread ) { 40014354: a0 92 20 00 orcc %o0, 0, %l0 40014358: 02 80 00 09 be 4001437c <_CORE_message_queue_Submit+0x58> 4001435c: 90 10 00 19 mov %i1, %o0 _CORE_message_queue_Copy_buffer( 40014360: d2 04 20 28 ld [ %l0 + 0x28 ], %o1 40014364: 7f ff ff e9 call 40014308 <_CORE_message_queue_Copy_buffer> 40014368: 94 10 00 1a mov %i2, %o2 buffer, the_thread->Wait.return_argument, size ); *(size_t *)the_thread->Wait.return_argument_1 = size; 4001436c: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 the_thread->Wait.count = submit_type; 40014370: 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; 40014374: 10 80 00 15 b 400143c8 <_CORE_message_queue_Submit+0xa4> 40014378: f4 20 40 00 st %i2, [ %g1 ] /* * 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 < 4001437c: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 40014380: c2 04 60 44 ld [ %l1 + 0x44 ], %g1 40014384: 80 a0 80 01 cmp %g2, %g1 40014388: 1a 80 00 12 bcc 400143d0 <_CORE_message_queue_Submit+0xac> 4001438c: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 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 *) 40014390: 7f ff de ed call 4000bf44 <_Chain_Get> 40014394: 90 04 60 68 add %l1, 0x68, %o0 /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 40014398: a0 92 20 00 orcc %o0, 0, %l0 4001439c: 02 80 00 27 be 40014438 <_CORE_message_queue_Submit+0x114> 400143a0: 90 10 00 19 mov %i1, %o0 return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; } _CORE_message_queue_Copy_buffer( 400143a4: 92 04 20 10 add %l0, 0x10, %o1 400143a8: 7f ff ff d8 call 40014308 <_CORE_message_queue_Copy_buffer> 400143ac: 94 10 00 1a mov %i2, %o2 size ); the_message->Contents.size = size; the_message->priority = submit_type; _CORE_message_queue_Insert_message( 400143b0: 90 10 00 11 mov %l1, %o0 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 400143b4: f4 24 20 0c st %i2, [ %l0 + 0xc ] the_message->priority = submit_type; 400143b8: fa 24 20 08 st %i5, [ %l0 + 8 ] _CORE_message_queue_Insert_message( 400143bc: 92 10 00 10 mov %l0, %o1 400143c0: 40 00 0b d5 call 40017314 <_CORE_message_queue_Insert_message> 400143c4: 94 10 00 1d mov %i5, %o2 400143c8: 81 c7 e0 08 ret 400143cc: 91 e8 20 00 restore %g0, 0, %o0 * 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 ) { 400143d0: 80 a0 60 00 cmp %g1, 0 400143d4: 02 80 00 17 be 40014430 <_CORE_message_queue_Submit+0x10c> 400143d8: 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() ) { 400143dc: 03 10 00 a7 sethi %hi(0x40029c00), %g1 400143e0: c2 00 61 24 ld [ %g1 + 0x124 ], %g1 ! 40029d24 <_ISR_Nest_level> 400143e4: 80 a0 60 00 cmp %g1, 0 400143e8: 12 80 00 14 bne 40014438 <_CORE_message_queue_Submit+0x114> 400143ec: 03 10 00 a7 sethi %hi(0x40029c00), %g1 */ { Thread_Control *executing = _Thread_Executing; _ISR_Disable( level ); 400143f0: 7f ff b8 a1 call 40002674 400143f4: e0 00 61 3c ld [ %g1 + 0x13c ], %l0 ! 40029d3c <_Thread_Executing> 400143f8: 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; 400143fc: 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; 40014400: f6 24 20 20 st %i3, [ %l0 + 0x20 ] executing->Wait.return_argument = buffer; 40014404: f2 24 20 28 st %i1, [ %l0 + 0x28 ] executing->Wait.option = size; 40014408: 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; 4001440c: e2 24 20 44 st %l1, [ %l0 + 0x44 ] 40014410: 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 ); 40014414: 7f ff b8 9c call 40002684 40014418: b0 10 20 07 mov 7, %i0 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 4001441c: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 40014420: 90 10 00 11 mov %l1, %o0 40014424: 15 10 00 3b sethi %hi(0x4000ec00), %o2 40014428: 7f ff e9 06 call 4000e840 <_Thread_queue_Enqueue_with_handler> 4001442c: 94 12 a0 d8 or %o2, 0xd8, %o2 ! 4000ecd8 <_Thread_queue_Timeout> 40014430: 81 c7 e0 08 ret 40014434: 81 e8 00 00 restore } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 40014438: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED } 4001443c: 81 c7 e0 08 ret <== NOT EXECUTED 40014440: 81 e8 00 00 restore <== NOT EXECUTED 400077f0 <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 400077f0: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 400077f4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 400077f8: 80 a0 60 02 cmp %g1, 2 Watchdog_Interval timeout ) { Thread_Control *executing; executing = _Thread_Executing; 400077fc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 40007800: 12 80 00 0a bne 40007828 <_CORE_mutex_Seize_interrupt_blocking+0x38> 40007804: d2 00 62 ac ld [ %g1 + 0x2ac ], %o1 ! 4001aeac <_Thread_Executing> if ( the_mutex->holder->current_priority > executing->current_priority ) { 40007808: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 4000780c: d2 02 60 14 ld [ %o1 + 0x14 ], %o1 40007810: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40007814: 80 a0 40 09 cmp %g1, %o1 40007818: 28 80 00 05 bleu,a 4000782c <_CORE_mutex_Seize_interrupt_blocking+0x3c> 4000781c: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_Change_priority( 40007820: 40 00 07 47 call 4000953c <_Thread_Change_priority> 40007824: 94 10 20 00 clr %o2 FALSE ); } } the_mutex->blocked_count++; 40007828: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 4000782c: 90 10 00 18 mov %i0, %o0 FALSE ); } } the_mutex->blocked_count++; 40007830: 82 00 60 01 inc %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 40007834: 92 10 00 19 mov %i1, %o1 FALSE ); } } the_mutex->blocked_count++; 40007838: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 4000783c: 15 10 00 29 sethi %hi(0x4000a400), %o2 40007840: 40 00 09 d3 call 40009f8c <_Thread_queue_Enqueue_with_handler> 40007844: 94 12 a0 24 or %o2, 0x24, %o2 ! 4000a424 <_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 ) 40007848: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000784c: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 40007850: 82 00 7f ff add %g1, -1, %g1 40007854: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] 40007858: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 4000785c: 80 a0 60 00 cmp %g1, 0 40007860: 12 80 00 04 bne 40007870 <_CORE_mutex_Seize_interrupt_blocking+0x80> 40007864: 01 00 00 00 nop _Thread_Dispatch(); 40007868: 40 00 08 61 call 400099ec <_Thread_Dispatch> 4000786c: 81 e8 00 00 restore 40007870: 81 c7 e0 08 ret <== NOT EXECUTED 40007874: 81 e8 00 00 restore <== NOT EXECUTED 40007878 <_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 ) { 40007878: 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 ) { 4000787c: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 40007880: 80 a0 60 00 cmp %g1, 0 40007884: 02 80 00 07 be 400078a0 <_CORE_mutex_Surrender+0x28> 40007888: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 if ( !_Thread_Is_executing( holder ) ) 4000788c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40007890: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 4001aeac <_Thread_Executing> 40007894: 80 a2 00 01 cmp %o0, %g1 40007898: 12 80 00 51 bne 400079dc <_CORE_mutex_Surrender+0x164> 4000789c: 84 10 20 03 mov 3, %g2 return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 400078a0: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 400078a4: 80 a0 60 00 cmp %g1, 0 400078a8: 02 80 00 4c be 400079d8 <_CORE_mutex_Surrender+0x160> 400078ac: 82 00 7f ff add %g1, -1, %g1 return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; if ( the_mutex->nest_count != 0 ) { 400078b0: 80 a0 60 00 cmp %g1, 0 400078b4: 02 80 00 09 be 400078d8 <_CORE_mutex_Surrender+0x60> 400078b8: c2 26 20 54 st %g1, [ %i0 + 0x54 ] switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400078bc: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 400078c0: 80 a0 60 00 cmp %g1, 0 400078c4: 02 80 00 46 be 400079dc <_CORE_mutex_Surrender+0x164> 400078c8: 84 10 20 00 clr %g2 400078cc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400078d0: 02 80 00 43 be 400079dc <_CORE_mutex_Surrender+0x164> <== NOT EXECUTED 400078d4: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 400078d8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400078dc: 80 a0 60 02 cmp %g1, 2 400078e0: 22 80 00 06 be,a 400078f8 <_CORE_mutex_Surrender+0x80> 400078e4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 400078e8: 80 a0 60 03 cmp %g1, 3 400078ec: 32 80 00 07 bne,a 40007908 <_CORE_mutex_Surrender+0x90> 400078f0: c0 26 20 5c clr [ %i0 + 0x5c ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; 400078f4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 400078f8: 82 00 7f ff add %g1, -1, %g1 400078fc: c2 22 20 1c st %g1, [ %o0 + 0x1c ] 40007900: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 the_mutex->holder = NULL; 40007904: c0 26 20 5c clr [ %i0 + 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 ) || 40007908: 80 a0 60 02 cmp %g1, 2 4000790c: 02 80 00 05 be 40007920 <_CORE_mutex_Surrender+0xa8> 40007910: c0 26 20 60 clr [ %i0 + 0x60 ] 40007914: 80 a0 60 03 cmp %g1, 3 40007918: 12 80 00 0d bne 4000794c <_CORE_mutex_Surrender+0xd4> 4000791c: 01 00 00 00 nop _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( holder->resource_count == 0 && 40007920: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 40007924: 80 a0 60 00 cmp %g1, 0 40007928: 12 80 00 09 bne 4000794c <_CORE_mutex_Surrender+0xd4> 4000792c: 01 00 00 00 nop 40007930: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 40007934: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40007938: 80 a2 40 01 cmp %o1, %g1 4000793c: 02 80 00 04 be 4000794c <_CORE_mutex_Surrender+0xd4> 40007940: 01 00 00 00 nop holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 40007944: 40 00 06 fe call 4000953c <_Thread_Change_priority> 40007948: 94 10 20 01 mov 1, %o2 ! 1 /* * 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 ) ) ) { 4000794c: 40 00 09 22 call 40009dd4 <_Thread_queue_Dequeue> 40007950: 90 10 00 18 mov %i0, %o0 40007954: 86 92 20 00 orcc %o0, 0, %g3 40007958: 02 80 00 1f be 400079d4 <_CORE_mutex_Surrender+0x15c> 4000795c: 82 10 20 01 mov 1, %g1 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 40007960: c2 00 e0 08 ld [ %g3 + 8 ], %g1 the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 40007964: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 40007968: c2 26 20 60 st %g1, [ %i0 + 0x60 ] } else #endif { the_mutex->holder = the_thread; 4000796c: c6 26 20 5c st %g3, [ %i0 + 0x5c ] the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; 40007970: 82 10 20 01 mov 1, %g1 switch ( the_mutex->Attributes.discipline ) { 40007974: 80 a0 a0 02 cmp %g2, 2 40007978: 02 80 00 07 be 40007994 <_CORE_mutex_Surrender+0x11c> 4000797c: c2 26 20 54 st %g1, [ %i0 + 0x54 ] 40007980: 80 a0 a0 03 cmp %g2, 3 40007984: 12 80 00 16 bne 400079dc <_CORE_mutex_Surrender+0x164> 40007988: 84 10 20 00 clr %g2 break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; 4000798c: 10 80 00 07 b 400079a8 <_CORE_mutex_Surrender+0x130> 40007990: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 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++; 40007994: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 40007998: 84 10 20 00 clr %g2 4000799c: 82 00 60 01 inc %g1 400079a0: 10 80 00 0f b 400079dc <_CORE_mutex_Surrender+0x164> 400079a4: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; if (the_mutex->Attributes.priority_ceiling < 400079a8: 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++; 400079ac: 82 00 60 01 inc %g1 400079b0: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if (the_mutex->Attributes.priority_ceiling < 400079b4: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 400079b8: 80 a2 40 02 cmp %o1, %g2 400079bc: 3a 80 00 08 bcc,a 400079dc <_CORE_mutex_Surrender+0x164> 400079c0: 84 10 20 00 clr %g2 <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 400079c4: 40 00 06 de call 4000953c <_Thread_Change_priority> 400079c8: 94 10 20 00 clr %o2 } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 400079cc: 10 80 00 04 b 400079dc <_CORE_mutex_Surrender+0x164> 400079d0: 84 10 20 00 clr %g2 400079d4: c2 26 20 50 st %g1, [ %i0 + 0x50 ] 400079d8: 84 10 20 00 clr %g2 return CORE_MUTEX_STATUS_SUCCESSFUL; } 400079dc: 81 c7 e0 08 ret 400079e0: 91 e8 00 02 restore %g0, %g2, %o0 40008560 <_CORE_spinlock_Release>: */ CORE_spinlock_Status _CORE_spinlock_Release( CORE_spinlock_Control *the_spinlock ) { 40008560: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 40008564: 7f ff e7 fc call 40002554 40008568: 01 00 00 00 nop /* * It must locked before it can be unlocked. */ if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 4000856c: c2 06 20 04 ld [ %i0 + 4 ], %g1 40008570: 80 a0 60 00 cmp %g1, 0 40008574: 12 80 00 06 bne 4000858c <_CORE_spinlock_Release+0x2c> 40008578: 03 10 00 54 sethi %hi(0x40015000), %g1 _ISR_Enable( level ); 4000857c: 7f ff e7 fa call 40002564 40008580: b0 10 20 06 mov 6, %i0 40008584: 81 c7 e0 08 ret 40008588: 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 ) { 4000858c: c2 00 62 7c ld [ %g1 + 0x27c ], %g1 40008590: c4 06 20 0c ld [ %i0 + 0xc ], %g2 40008594: c2 00 60 08 ld [ %g1 + 8 ], %g1 40008598: 80 a0 80 01 cmp %g2, %g1 4000859c: 02 80 00 06 be 400085b4 <_CORE_spinlock_Release+0x54> 400085a0: 01 00 00 00 nop _ISR_Enable( level ); 400085a4: 7f ff e7 f0 call 40002564 <== NOT EXECUTED 400085a8: b0 10 20 02 mov 2, %i0 ! 2 <== NOT EXECUTED 400085ac: 81 c7 e0 08 ret <== NOT EXECUTED 400085b0: 81 e8 00 00 restore <== NOT EXECUTED } /* * Let it be unlocked. */ the_spinlock->users -= 1; 400085b4: c2 06 20 08 ld [ %i0 + 8 ], %g1 400085b8: 82 00 7f ff add %g1, -1, %g1 400085bc: c2 26 20 08 st %g1, [ %i0 + 8 ] the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; 400085c0: c0 26 20 04 clr [ %i0 + 4 ] the_spinlock->holder = 0; 400085c4: c0 26 20 0c clr [ %i0 + 0xc ] _ISR_Enable( level ); 400085c8: 7f ff e7 e7 call 40002564 400085cc: b0 10 20 00 clr %i0 return CORE_SPINLOCK_SUCCESSFUL; } 400085d0: 81 c7 e0 08 ret 400085d4: 81 e8 00 00 restore 400085d8 <_CORE_spinlock_Wait>: CORE_spinlock_Status _CORE_spinlock_Wait( CORE_spinlock_Control *the_spinlock, boolean wait, Watchdog_Interval timeout ) { 400085d8: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; 400085dc: 03 10 00 54 sethi %hi(0x40015000), %g1 400085e0: c2 00 63 24 ld [ %g1 + 0x324 ], %g1 ! 40015324 <_Watchdog_Ticks_since_boot> _ISR_Disable( level ); 400085e4: 7f ff e7 dc call 40002554 400085e8: a2 06 80 01 add %i2, %g1, %l1 400085ec: 86 10 00 08 mov %o0, %g3 if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 400085f0: c2 06 20 04 ld [ %i0 + 4 ], %g1 400085f4: 80 a0 60 01 cmp %g1, 1 400085f8: 12 80 00 0c bne 40008628 <_CORE_spinlock_Wait+0x50> 400085fc: 03 10 00 54 sethi %hi(0x40015000), %g1 40008600: c2 00 62 7c ld [ %g1 + 0x27c ], %g1 ! 4001527c <_Thread_Executing> 40008604: c4 06 20 0c ld [ %i0 + 0xc ], %g2 40008608: c2 00 60 08 ld [ %g1 + 8 ], %g1 4000860c: 80 a0 80 01 cmp %g2, %g1 40008610: 12 80 00 06 bne 40008628 <_CORE_spinlock_Wait+0x50> 40008614: 01 00 00 00 nop (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); 40008618: 7f ff e7 d3 call 40002564 4000861c: b0 10 20 01 mov 1, %i0 ! 1 40008620: 81 c7 e0 08 ret 40008624: 81 e8 00 00 restore return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 40008628: c2 06 20 08 ld [ %i0 + 8 ], %g1 } /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { 4000862c: 25 10 00 54 sethi %hi(0x40015000), %l2 if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 40008630: 82 00 60 01 inc %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008634: 21 10 00 54 sethi %hi(0x40015000), %l0 40008638: c2 26 20 08 st %g1, [ %i0 + 8 ] for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 4000863c: c2 06 20 04 ld [ %i0 + 4 ], %g1 40008640: 80 a0 60 00 cmp %g1, 0 40008644: 12 80 00 0d bne 40008678 <_CORE_spinlock_Wait+0xa0> 40008648: 80 a6 60 00 cmp %i1, 0 the_spinlock->lock = CORE_SPINLOCK_LOCKED; the_spinlock->holder = _Thread_Executing->Object.id; 4000864c: 03 10 00 54 sethi %hi(0x40015000), %g1 40008650: c4 00 62 7c ld [ %g1 + 0x27c ], %g2 ! 4001527c <_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; 40008654: 82 10 20 01 mov 1, %g1 40008658: c2 26 20 04 st %g1, [ %i0 + 4 ] the_spinlock->holder = _Thread_Executing->Object.id; 4000865c: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40008660: c2 26 20 0c st %g1, [ %i0 + 0xc ] _ISR_Enable( level ); 40008664: b0 10 20 00 clr %i0 40008668: 7f ff e7 bf call 40002564 4000866c: 90 10 00 03 mov %g3, %o0 40008670: 81 c7 e0 08 ret 40008674: 81 e8 00 00 restore } /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { 40008678: 12 80 00 0a bne 400086a0 <_CORE_spinlock_Wait+0xc8> 4000867c: 80 a6 a0 00 cmp %i2, 0 the_spinlock->users -= 1; 40008680: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 40008684: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008688: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 4000868c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 40008690: 7f ff e7 b5 call 40002564 <== NOT EXECUTED 40008694: 90 10 00 03 mov %g3, %o0 <== NOT EXECUTED 40008698: 81 c7 e0 08 ret <== NOT EXECUTED 4000869c: 81 e8 00 00 restore <== NOT EXECUTED } /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { 400086a0: 02 80 00 0e be 400086d8 <_CORE_spinlock_Wait+0x100> 400086a4: 01 00 00 00 nop 400086a8: c2 04 a3 24 ld [ %l2 + 0x324 ], %g1 <== NOT EXECUTED 400086ac: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 400086b0: 18 80 00 0a bgu 400086d8 <_CORE_spinlock_Wait+0x100> <== NOT EXECUTED 400086b4: 01 00 00 00 nop <== NOT EXECUTED the_spinlock->users -= 1; 400086b8: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 400086bc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400086c0: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 400086c4: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED 400086c8: 7f ff e7 a7 call 40002564 <== NOT EXECUTED 400086cc: 90 10 00 03 mov %g3, %o0 <== NOT EXECUTED 400086d0: 81 c7 e0 08 ret <== NOT EXECUTED 400086d4: 81 e8 00 00 restore <== NOT EXECUTED * * A spinlock cannot be deleted while it is being used so we are * safe from deletion. */ _ISR_Enable( level ); 400086d8: 7f ff e7 a3 call 40002564 400086dc: 90 10 00 03 mov %g3, %o0 400086e0: c2 04 21 a0 ld [ %l0 + 0x1a0 ], %g1 400086e4: 82 00 7f ff add %g1, -1, %g1 400086e8: c2 24 21 a0 st %g1, [ %l0 + 0x1a0 ] 400086ec: c2 04 21 a0 ld [ %l0 + 0x1a0 ], %g1 400086f0: 80 a0 60 00 cmp %g1, 0 400086f4: 12 80 00 04 bne 40008704 <_CORE_spinlock_Wait+0x12c> 400086f8: 01 00 00 00 nop _Thread_Dispatch(); 400086fc: 40 00 07 a4 call 4000a58c <_Thread_Dispatch> 40008700: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008704: c2 04 21 a0 ld [ %l0 + 0x1a0 ], %g1 40008708: 82 00 60 01 inc %g1 4000870c: c2 24 21 a0 st %g1, [ %l0 + 0x1a0 ] /* Another thread could get dispatched here */ /* Reenter the critical sections so we can attempt the lock again. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 40008710: 7f ff e7 91 call 40002554 40008714: 01 00 00 00 nop 40008718: 86 10 00 08 mov %o0, %g3 4000871c: 30 bf ff c8 b,a 4000863c <_CORE_spinlock_Wait+0x64> 4000d6cc <_Debug_Is_enabled>: */ boolean _Debug_Is_enabled( rtems_debug_control level ) { 4000d6cc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000d6d0: c2 00 62 b0 ld [ %g1 + 0x2b0 ], %g1 ! 4001aeb0 <_Debug_Level> <== NOT EXECUTED 4000d6d4: 90 0a 00 01 and %o0, %g1, %o0 <== NOT EXECUTED return (_Debug_Level & level) ? TRUE : FALSE; } 4000d6d8: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 4000d6dc: 81 c3 e0 08 retl <== NOT EXECUTED 4000d6e0: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED 40005f1c <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 40005f1c: 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; 40005f20: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40005f24: e0 00 62 ac ld [ %g1 + 0x2ac ], %l0 ! 4001aeac <_Thread_Executing> executing->Wait.return_code = RTEMS_SUCCESSFUL; 40005f28: c0 24 20 34 clr [ %l0 + 0x34 ] api = executing->API_Extensions[ THREAD_API_RTEMS ]; _ISR_Disable( level ); 40005f2c: 7f ff ef e8 call 40001ecc 40005f30: e4 04 21 6c ld [ %l0 + 0x16c ], %l2 40005f34: 84 10 00 08 mov %o0, %g2 pending_events = api->pending_events; 40005f38: c2 04 a0 40 ld [ %l2 + 0x40 ], %g1 seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 40005f3c: a2 8e 00 01 andcc %i0, %g1, %l1 40005f40: 02 80 00 0e be 40005f78 <_Event_Seize+0x5c> 40005f44: 80 8e 60 01 btst 1, %i1 40005f48: 80 a4 40 18 cmp %l1, %i0 40005f4c: 02 80 00 04 be 40005f5c <_Event_Seize+0x40> 40005f50: 80 8e 60 02 btst 2, %i1 40005f54: 02 80 00 09 be 40005f78 <_Event_Seize+0x5c> 40005f58: 80 8e 60 01 btst 1, %i1 (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 40005f5c: 82 28 40 11 andn %g1, %l1, %g1 40005f60: c2 24 a0 40 st %g1, [ %l2 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 40005f64: 7f ff ef de call 40001edc 40005f68: 01 00 00 00 nop 40005f6c: e2 26 c0 00 st %l1, [ %i3 ] 40005f70: 81 c7 e0 08 ret 40005f74: 81 e8 00 00 restore *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 40005f78: 22 80 00 09 be,a 40005f9c <_Event_Seize+0x80> 40005f7c: 23 10 00 6d sethi %hi(0x4001b400), %l1 _ISR_Enable( level ); 40005f80: 7f ff ef d7 call 40001edc 40005f84: 90 10 00 02 mov %g2, %o0 executing->Wait.return_code = RTEMS_UNSATISFIED; 40005f88: 82 10 20 0d mov 0xd, %g1 40005f8c: c2 24 20 34 st %g1, [ %l0 + 0x34 ] *event_out = seized_events; 40005f90: e2 26 c0 00 st %l1, [ %i3 ] 40005f94: 81 c7 e0 08 ret 40005f98: 81 e8 00 00 restore return; } _Event_Sync_state = EVENT_SYNC_NOTHING_HAPPENED; 40005f9c: 82 10 20 01 mov 1, %g1 executing->Wait.option = (uint32_t ) option_set; 40005fa0: f2 24 20 30 st %i1, [ %l0 + 0x30 ] executing->Wait.count = (uint32_t ) event_in; 40005fa4: f0 24 20 24 st %i0, [ %l0 + 0x24 ] executing->Wait.return_argument = event_out; 40005fa8: 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; 40005fac: c2 24 63 b4 st %g1, [ %l1 + 0x3b4 ] executing->Wait.option = (uint32_t ) option_set; executing->Wait.count = (uint32_t ) event_in; executing->Wait.return_argument = event_out; _ISR_Enable( level ); 40005fb0: 7f ff ef cb call 40001edc 40005fb4: 90 10 00 02 mov %g2, %o0 if ( ticks ) { 40005fb8: 80 a6 a0 00 cmp %i2, 0 40005fbc: 02 80 00 0f be 40005ff8 <_Event_Seize+0xdc> 40005fc0: 90 10 00 10 mov %l0, %o0 _Watchdog_Initialize( 40005fc4: c2 04 20 08 ld [ %l0 + 8 ], %g1 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40005fc8: 11 10 00 6b sethi %hi(0x4001ac00), %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 40005fcc: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40005fd0: 03 10 00 18 sethi %hi(0x40006000), %g1 40005fd4: 82 10 62 a4 or %g1, 0x2a4, %g1 ! 400062a4 <_Event_Timeout> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40005fd8: f4 24 20 54 st %i2, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40005fdc: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 40005fe0: c0 24 20 6c clr [ %l0 + 0x6c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40005fe4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40005fe8: 90 12 22 cc or %o0, 0x2cc, %o0 40005fec: 40 00 13 5d call 4000ad60 <_Watchdog_Insert> 40005ff0: 92 04 20 48 add %l0, 0x48, %o1 NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 40005ff4: 90 10 00 10 mov %l0, %o0 40005ff8: 40 00 11 63 call 4000a584 <_Thread_Set_state> 40005ffc: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 40006000: 7f ff ef b3 call 40001ecc 40006004: 01 00 00 00 nop 40006008: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 4000600c: c4 04 63 b4 ld [ %l1 + 0x3b4 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 40006010: c0 24 63 b4 clr [ %l1 + 0x3b4 ] switch ( sync_state ) { 40006014: 80 a0 a0 02 cmp %g2, 2 40006018: 02 80 00 08 be 40006038 <_Event_Seize+0x11c> 4000601c: 80 a0 a0 03 cmp %g2, 3 40006020: 02 80 00 09 be 40006044 <_Event_Seize+0x128> 40006024: 80 a0 a0 01 cmp %g2, 1 40006028: 12 80 00 15 bne 4000607c <_Event_Seize+0x160> 4000602c: 01 00 00 00 nop * enter the synchronization states above. */ return; case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); 40006030: 7f ff ef ab call 40001edc 40006034: 81 e8 00 00 restore return; case EVENT_SYNC_TIMEOUT: executing->Wait.return_code = RTEMS_TIMEOUT; 40006038: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 4000603c: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40006040: 30 80 00 0b b,a 4000606c <_Event_Seize+0x150> <== NOT EXECUTED _Thread_Unblock( executing ); return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { 40006044: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40006048: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000604c: 12 80 00 08 bne 4000606c <_Event_Seize+0x150> <== NOT EXECUTED 40006050: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 40006054: c4 24 20 50 st %g2, [ %l0 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); 40006058: 7f ff ef a1 call 40001edc <== NOT EXECUTED 4000605c: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED (void) _Watchdog_Remove( &executing->Timer ); 40006060: 40 00 13 98 call 4000aec0 <_Watchdog_Remove> <== NOT EXECUTED 40006064: 90 04 20 48 add %l0, 0x48, %o0 <== NOT EXECUTED 40006068: 30 80 00 03 b,a 40006074 <_Event_Seize+0x158> <== NOT EXECUTED } else _ISR_Enable( level ); 4000606c: 7f ff ef 9c call 40001edc <== NOT EXECUTED 40006070: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED _Thread_Unblock( executing ); 40006074: 7f ff ff a4 call 40005f04 <_Thread_Unblock> <== NOT EXECUTED 40006078: 81 e8 00 00 restore <== NOT EXECUTED 4000607c: 81 c7 e0 08 ret <== NOT EXECUTED 40006080: 81 e8 00 00 restore <== NOT EXECUTED 4000619c <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 4000619c: 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 ]; 400061a0: e2 06 21 6c ld [ %i0 + 0x16c ], %l1 option_set = (rtems_option) the_thread->Wait.option; 400061a4: e6 06 20 30 ld [ %i0 + 0x30 ], %l3 _ISR_Disable( level ); 400061a8: 7f ff ef 49 call 40001ecc 400061ac: a0 10 00 18 mov %i0, %l0 400061b0: a4 10 00 08 mov %o0, %l2 pending_events = api->pending_events; 400061b4: c8 04 60 40 ld [ %l1 + 0x40 ], %g4 event_condition = (rtems_event_set) the_thread->Wait.count; 400061b8: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { 400061bc: 86 88 80 04 andcc %g2, %g4, %g3 400061c0: 02 80 00 36 be 40006298 <_Event_Surrender+0xfc> 400061c4: 01 00 00 00 nop if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 400061c8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 400061cc: 80 88 61 00 btst 0x100, %g1 400061d0: 02 80 00 1e be 40006248 <_Event_Surrender+0xac> 400061d4: 1b 10 00 6d sethi %hi(0x4001b400), %o5 if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 400061d8: 80 a0 c0 02 cmp %g3, %g2 400061dc: 02 80 00 04 be 400061ec <_Event_Surrender+0x50> 400061e0: 80 8c e0 02 btst 2, %l3 400061e4: 02 80 00 19 be 40006248 <_Event_Surrender+0xac> 400061e8: 01 00 00 00 nop api->pending_events = 400061ec: 82 29 00 03 andn %g4, %g3, %g1 400061f0: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 400061f4: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 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 = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 400061f8: c0 24 20 24 clr [ %l0 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 400061fc: c6 20 40 00 st %g3, [ %g1 ] _ISR_Flash( level ); 40006200: 7f ff ef 37 call 40001edc 40006204: 01 00 00 00 nop 40006208: 7f ff ef 31 call 40001ecc 4000620c: 01 00 00 00 nop if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 40006210: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 40006214: 80 a0 60 02 cmp %g1, 2 40006218: 02 80 00 05 be 4000622c <_Event_Surrender+0x90> 4000621c: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 40006220: 7f ff ef 2f call 40001edc 40006224: 90 10 00 12 mov %l2, %o0 40006228: 30 80 00 06 b,a 40006240 <_Event_Surrender+0xa4> 4000622c: c2 24 20 50 st %g1, [ %l0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 40006230: 7f ff ef 2b call 40001edc 40006234: 90 10 00 12 mov %l2, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 40006238: 40 00 13 22 call 4000aec0 <_Watchdog_Remove> 4000623c: 90 04 20 48 add %l0, 0x48, %o0 _Thread_Unblock( the_thread ); 40006240: 7f ff ff d1 call 40006184 <_Thread_Unblock> 40006244: 81 e8 00 00 restore } return; } } switch ( _Event_Sync_state ) { 40006248: c2 03 63 b4 ld [ %o5 + 0x3b4 ], %g1 <== NOT EXECUTED 4000624c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40006250: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40006254: 18 80 00 11 bgu 40006298 <_Event_Surrender+0xfc> <== NOT EXECUTED 40006258: 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 ) ) 4000625c: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 4001aeac <_Thread_Executing> <== NOT EXECUTED 40006260: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 40006264: 12 80 00 0d bne 40006298 <_Event_Surrender+0xfc> <== NOT EXECUTED 40006268: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 4000626c: 02 80 00 04 be 4000627c <_Event_Surrender+0xe0> <== NOT EXECUTED 40006270: 80 8c e0 02 btst 2, %l3 <== NOT EXECUTED 40006274: 02 80 00 09 be 40006298 <_Event_Surrender+0xfc> <== NOT EXECUTED 40006278: 01 00 00 00 nop <== NOT EXECUTED api->pending_events = 4000627c: 82 29 00 03 andn %g4, %g3, %g1 <== NOT EXECUTED 40006280: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 40006284: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED break; 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; 40006288: c0 24 20 24 clr [ %l0 + 0x24 ] <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 4000628c: c6 20 40 00 st %g3, [ %g1 ] <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_SATISFIED; 40006290: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 40006294: c2 23 63 b4 st %g1, [ %o5 + 0x3b4 ] <== NOT EXECUTED } break; } } _ISR_Enable( level ); 40006298: 7f ff ef 11 call 40001edc 4000629c: 91 e8 00 12 restore %g0, %l2, %o0 400062a0: 01 00 00 00 nop 400062a4 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 400062a4: 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 ) ) { 400062a8: 92 96 20 00 orcc %i0, 0, %o1 400062ac: 12 80 00 0a bne 400062d4 <_Event_Timeout+0x30> 400062b0: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400062b4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 400062b8: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400062bc: 84 00 a0 01 inc %g2 <== NOT EXECUTED 400062c0: c4 20 61 d0 st %g2, [ %g1 + 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; 400062c4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 400062c8: f0 00 62 ac ld [ %g1 + 0x2ac ], %i0 ! 4001aeac <_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; 400062cc: 10 80 00 18 b 4000632c <_Event_Timeout+0x88> <== NOT EXECUTED 400062d0: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 400062d4: 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 ) { 400062d8: 80 a0 a0 04 cmp %g2, 4 400062dc: 18 80 00 0e bgu 40006314 <_Event_Timeout+0x70> 400062e0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 400062e4: 83 32 60 1b srl %o1, 0x1b, %g1 400062e8: 80 a0 60 01 cmp %g1, 1 400062ec: 12 80 00 0a bne 40006314 <_Event_Timeout+0x70> 400062f0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400062f4: 83 28 a0 02 sll %g2, 2, %g1 400062f8: 05 10 00 6b sethi %hi(0x4001ac00), %g2 400062fc: 84 10 a1 30 or %g2, 0x130, %g2 ! 4001ad30 <_Objects_Information_table> 40006300: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40006304: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 40006308: 80 a2 20 00 cmp %o0, 0 4000630c: 12 80 00 05 bne 40006320 <_Event_Timeout+0x7c> 40006310: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 40006314: b0 10 20 00 clr %i0 <== NOT EXECUTED 40006318: 10 80 00 05 b 4000632c <_Event_Timeout+0x88> <== NOT EXECUTED 4000631c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40006320: 40 00 08 bf call 4000861c <_Objects_Get> 40006324: 94 07 bf f4 add %fp, -12, %o2 40006328: b0 10 00 08 mov %o0, %i0 Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000632c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006330: 80 a0 60 00 cmp %g1, 0 40006334: 12 80 00 27 bne 400063d0 <_Event_Timeout+0x12c> 40006338: 01 00 00 00 nop * 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 ); 4000633c: 7f ff ee e4 call 40001ecc 40006340: 01 00 00 00 nop 40006344: 86 10 00 08 mov %o0, %g3 if ( the_thread->Wait.count ) { /* verify thread is waiting */ 40006348: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 4000634c: 80 a0 60 00 cmp %g1, 0 40006350: 02 80 00 1a be 400063b8 <_Event_Timeout+0x114> 40006354: 05 10 00 6d sethi %hi(0x4001b400), %g2 the_thread->Wait.count = 0; if ( _Event_Sync_state != EVENT_SYNC_SYNCHRONIZED && 40006358: c2 00 a3 b4 ld [ %g2 + 0x3b4 ], %g1 ! 4001b7b4 <_Event_Sync_state> 4000635c: 80 a0 60 00 cmp %g1, 0 40006360: 02 80 00 0d be 40006394 <_Event_Timeout+0xf0> 40006364: c0 26 20 24 clr [ %i0 + 0x24 ] 40006368: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000636c: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 4001aeac <_Thread_Executing> <== NOT EXECUTED 40006370: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 40006374: 12 80 00 09 bne 40006398 <_Event_Timeout+0xf4> <== NOT EXECUTED 40006378: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { 4000637c: c2 00 a3 b4 ld [ %g2 + 0x3b4 ], %g1 <== NOT EXECUTED 40006380: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 40006384: 02 80 00 03 be 40006390 <_Event_Timeout+0xec> <== NOT EXECUTED 40006388: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_TIMEOUT; 4000638c: c2 20 a3 b4 st %g1, [ %g2 + 0x3b4 ] <== NOT EXECUTED } _ISR_Enable( level ); 40006390: 30 80 00 0a b,a 400063b8 <_Event_Timeout+0x114> <== NOT EXECUTED } else { the_thread->Wait.return_code = RTEMS_TIMEOUT; 40006394: 82 10 20 06 mov 6, %g1 40006398: c2 26 20 34 st %g1, [ %i0 + 0x34 ] _ISR_Enable( level ); 4000639c: 7f ff ee d0 call 40001edc 400063a0: 90 10 00 03 mov %g3, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 400063a4: 90 10 00 18 mov %i0, %o0 400063a8: 13 04 00 ff sethi %hi(0x1003fc00), %o1 400063ac: 40 00 0c d6 call 40009704 <_Thread_Clear_state> 400063b0: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 400063b4: 30 80 00 03 b,a 400063c0 <_Event_Timeout+0x11c> _Thread_Unblock( the_thread ); } } else { _ISR_Enable( level ); 400063b8: 7f ff ee c9 call 40001edc <== NOT EXECUTED 400063bc: 01 00 00 00 nop <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 400063c0: 05 10 00 6b sethi %hi(0x4001ac00), %g2 400063c4: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 400063c8: 82 00 7f ff add %g1, -1, %g1 400063cc: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] 400063d0: 81 c7 e0 08 ret 400063d4: 81 e8 00 00 restore 40019da4 <_Heap_Get_free_information>: */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 40019da4: 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; 40019da8: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED info->largest = 0; 40019dac: c0 22 60 04 clr [ %o1 + 4 ] <== NOT EXECUTED info->total = 0; 40019db0: 10 80 00 0e b 40019de8 <_Heap_Get_free_information+0x44> <== NOT EXECUTED 40019db4: c0 22 60 08 clr [ %o1 + 8 ] <== 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++; 40019db8: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED info->total += the_size; 40019dbc: c4 02 60 08 ld [ %o1 + 8 ], %g2 <== NOT EXECUTED if ( info->largest < the_size ) 40019dc0: c8 02 60 04 ld [ %o1 + 4 ], %g4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 40019dc4: 86 08 ff fe and %g3, -2, %g3 <== 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++; 40019dc8: 82 00 60 01 inc %g1 <== NOT EXECUTED info->total += the_size; 40019dcc: 84 00 80 03 add %g2, %g3, %g2 <== 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++; 40019dd0: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED info->total += the_size; if ( info->largest < the_size ) 40019dd4: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED 40019dd8: 1a 80 00 03 bcc 40019de4 <_Heap_Get_free_information+0x40> <== NOT EXECUTED 40019ddc: c4 22 60 08 st %g2, [ %o1 + 8 ] <== NOT EXECUTED info->largest = the_size; 40019de0: c6 22 60 04 st %g3, [ %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) 40019de4: 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; 40019de8: 80 a3 40 08 cmp %o5, %o0 <== NOT EXECUTED 40019dec: 32 bf ff f3 bne,a 40019db8 <_Heap_Get_free_information+0x14> <== NOT EXECUTED 40019df0: c6 03 60 04 ld [ %o5 + 4 ], %g3 <== NOT EXECUTED info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 40019df4: 81 c3 e0 08 retl <== NOT EXECUTED 40019df8: 01 00 00 00 nop 40007f30 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 40007f30: 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) 40007f34: 80 a6 e0 00 cmp %i3, 0 40007f38: 12 80 00 05 bne 40007f4c <_Heap_Initialize+0x1c> 40007f3c: f6 27 a0 50 st %i3, [ %fp + 0x50 ] page_size = CPU_ALIGNMENT; 40007f40: 82 10 20 08 mov 8, %g1 <== NOT EXECUTED 40007f44: 10 80 00 05 b 40007f58 <_Heap_Initialize+0x28> <== NOT EXECUTED 40007f48: c2 27 a0 50 st %g1, [ %fp + 0x50 ] <== NOT EXECUTED else _Heap_Align_up( &page_size, CPU_ALIGNMENT ); 40007f4c: 90 07 a0 50 add %fp, 0x50, %o0 40007f50: 7f ff ff b0 call 40007e10 <_Heap_Align_up> 40007f54: 92 10 20 08 mov 8, %o1 /* 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; _Heap_Align_up_uptr ( &aligned_start, page_size ); 40007f58: e0 07 a0 50 ld [ %fp + 0x50 ], %l0 /* 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; 40007f5c: a4 06 60 08 add %i1, 8, %l2 uint32_t alignment ) { _H_uptr_t v = *value; uint32_t a = alignment; _H_uptr_t r = v % a; 40007f60: 92 10 00 10 mov %l0, %o1 40007f64: 40 00 38 eb call 40016310 <.urem> 40007f68: 90 10 00 12 mov %l2, %o0 *value = r ? v - r + a : v; 40007f6c: 80 a2 20 00 cmp %o0, 0 40007f70: 02 80 00 05 be 40007f84 <_Heap_Initialize+0x54> 40007f74: 82 10 20 10 mov 0x10, %g1 40007f78: 82 04 80 10 add %l2, %l0, %g1 40007f7c: a4 20 40 08 sub %g1, %o0, %l2 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; /* Calculate 'min_block_size'. It's HEAP_MIN_BLOCK_SIZE aligned up to the nearest multiple of 'page_size'. */ the_heap->min_block_size = HEAP_MIN_BLOCK_SIZE; 40007f80: 82 10 20 10 mov 0x10, %g1 _Heap_Align_up ( &the_heap->min_block_size, page_size ); 40007f84: 92 10 00 10 mov %l0, %o1 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; /* Calculate 'min_block_size'. It's HEAP_MIN_BLOCK_SIZE aligned up to the nearest multiple of 'page_size'. */ the_heap->min_block_size = HEAP_MIN_BLOCK_SIZE; 40007f88: c2 26 20 14 st %g1, [ %i0 + 0x14 ] _Heap_Align_up ( &the_heap->min_block_size, page_size ); 40007f8c: 7f ff ff a1 call 40007e10 <_Heap_Align_up> 40007f90: 90 06 20 14 add %i0, 0x14, %o0 (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; _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 40007f94: b6 04 bf f8 add %l2, -8, %i3 /* 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); 40007f98: 82 26 c0 19 sub %i3, %i1, %g1 40007f9c: 82 00 60 08 add %g1, 8, %g1 if ( size < overhead ) 40007fa0: 80 a6 80 01 cmp %i2, %g1 40007fa4: 0a 80 00 2b bcs 40008050 <_Heap_Initialize+0x120> 40007fa8: e2 07 a0 50 ld [ %fp + 0x50 ], %l1 return 0; /* Too small area for the heap */ the_size = size - overhead; 40007fac: a0 26 80 01 sub %i2, %g1, %l0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 40007fb0: 92 10 00 11 mov %l1, %o1 40007fb4: 40 00 38 d7 call 40016310 <.urem> 40007fb8: 90 10 00 10 mov %l0, %o0 _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 40007fbc: a0 a4 00 08 subcc %l0, %o0, %l0 40007fc0: 02 80 00 24 be 40008050 <_Heap_Initialize+0x120> 40007fc4: 07 10 00 6a sethi %hi(0x4001a800), %g3 return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 40007fc8: e2 26 20 10 st %l1, [ %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; 40007fcc: e2 24 bf f8 st %l1, [ %l2 + -8 ] the_block->size = the_size | HEAP_PREV_USED; 40007fd0: 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++; 40007fd4: c4 00 e3 ac ld [ %g3 + 0x3ac ], %g2 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; 40007fd8: c2 26 e0 04 st %g1, [ %i3 + 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 */ 40007fdc: e0 26 c0 10 st %l0, [ %i3 + %l0 ] RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 40007fe0: 88 06 c0 10 add %i3, %l0, %g4 the_block->size = page_size; 40007fe4: e2 21 20 04 st %l1, [ %g4 + 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 ); 40007fe8: f0 26 e0 08 st %i0, [ %i3 + 8 ] the_block->prev = _Heap_Head( the_heap ); 40007fec: f0 26 e0 0c st %i0, [ %i3 + 0xc ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 40007ff0: c4 26 20 28 st %g2, [ %i0 + 0x28 ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 40007ff4: 82 10 20 01 mov 1, %g1 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; 40007ff8: f4 26 20 2c st %i2, [ %i0 + 0x2c ] stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; stats->max_free_blocks = 1; 40007ffc: c2 26 20 3c st %g1, [ %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; 40008000: c2 26 20 38 st %g1, [ %i0 + 0x38 ] 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; stats->free_size = the_size; 40008004: e0 26 20 30 st %l0, [ %i0 + 0x30 ] stats->min_free_size = the_size; 40008008: e0 26 20 34 st %l0, [ %i0 + 0x34 ] stats->free_blocks = 1; stats->max_free_blocks = 1; stats->used_blocks = 0; 4000800c: c0 26 20 40 clr [ %i0 + 0x40 ] stats->max_search = 0; 40008010: c0 26 20 44 clr [ %i0 + 0x44 ] stats->allocs = 0; 40008014: c0 26 20 48 clr [ %i0 + 0x48 ] stats->searches = 0; 40008018: c0 26 20 4c clr [ %i0 + 0x4c ] stats->frees = 0; 4000801c: c0 26 20 50 clr [ %i0 + 0x50 ] stats->resizes = 0; 40008020: c0 26 20 54 clr [ %i0 + 0x54 ] 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; 40008024: 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++; 40008028: 84 00 a0 01 inc %g2 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; 4000802c: 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; 40008030: 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; 40008034: f6 26 20 08 st %i3, [ %i0 + 8 ] _Heap_Tail(the_heap)->prev = the_block; 40008038: f6 26 20 0c st %i3, [ %i0 + 0xc ] the_heap->start = the_block; 4000803c: f6 26 20 20 st %i3, [ %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 */ 40008040: c8 26 20 24 st %g4, [ %i0 + 0x24 ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 40008044: c4 20 e3 ac st %g2, [ %g3 + 0x3ac ] return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 40008048: 81 c7 e0 08 ret 4000804c: 91 ec 3f fc restore %l0, -4, %o0 } 40008050: 81 c7 e0 08 ret 40008054: 91 e8 20 00 restore %g0, 0, %o0 4000d8cc <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 4000d8cc: 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; 4000d8d0: 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; 4000d8d4: ea 06 20 14 ld [ %i0 + 0x14 ], %l5 <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; *old_mem_size = 0; 4000d8d8: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED *avail_mem_size = 0; 4000d8dc: 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); 4000d8e0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4000d8e4: 40 00 22 8b call 40016310 <.urem> <== NOT EXECUTED 4000d8e8: 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 ); 4000d8ec: 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); 4000d8f0: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 4000d8f4: 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)) 4000d8f8: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED 4000d8fc: 0a 80 00 78 bcs 4000dadc <_Heap_Resize_block+0x210> <== NOT EXECUTED 4000d900: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 <== NOT EXECUTED 4000d904: 80 a4 80 02 cmp %l2, %g2 <== NOT EXECUTED 4000d908: 38 80 00 78 bgu,a 4000dae8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 4000d90c: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 4000d910: 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); 4000d914: ae 08 ff fe and %g3, -2, %l7 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 4000d918: a2 04 80 17 add %l2, %l7, %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) || 4000d91c: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 4000d920: 2a 80 00 72 bcs,a 4000dae8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 4000d924: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 4000d928: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 4000d92c: 38 80 00 6f bgu,a 4000dae8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 4000d930: 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); 4000d934: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED 4000d938: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 4000d93c: 02 80 00 68 be 4000dadc <_Heap_Resize_block+0x210> <== NOT EXECUTED 4000d940: a8 08 7f fe and %g1, -2, %l4 <== 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) || 4000d944: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 4000d948: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED 4000d94c: 02 80 00 04 be 4000d95c <_Heap_Resize_block+0x90> <== NOT EXECUTED 4000d950: ba 04 40 14 add %l1, %l4, %i5 <== NOT EXECUTED 4000d954: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED 4000d958: 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) 4000d95c: 82 24 40 19 sub %l1, %i1, %g1 <== NOT EXECUTED 4000d960: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 4000d964: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED if (size > old_user_size) { 4000d968: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED 4000d96c: 08 80 00 1f bleu 4000d9e8 <_Heap_Resize_block+0x11c> <== NOT EXECUTED 4000d970: 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 */ 4000d974: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 4000d978: 12 80 00 5b bne 4000dae4 <_Heap_Resize_block+0x218> <== NOT EXECUTED 4000d97c: 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; 4000d980: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 4000d984: 40 00 22 63 call 40016310 <.urem> <== NOT EXECUTED 4000d988: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED *value = r ? v - r + a : v; 4000d98c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000d990: 02 80 00 05 be 4000d9a4 <_Heap_Resize_block+0xd8> <== NOT EXECUTED 4000d994: 80 a4 00 15 cmp %l0, %l5 <== NOT EXECUTED 4000d998: 82 04 00 13 add %l0, %l3, %g1 <== NOT EXECUTED 4000d99c: a0 20 40 08 sub %g1, %o0, %l0 <== NOT EXECUTED 4000d9a0: 80 a4 00 15 cmp %l0, %l5 <== NOT EXECUTED 4000d9a4: 1a 80 00 03 bcc 4000d9b0 <_Heap_Resize_block+0xe4> <== NOT EXECUTED 4000d9a8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 4000d9ac: 90 10 00 15 mov %l5, %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) 4000d9b0: 80 a2 00 14 cmp %o0, %l4 <== NOT EXECUTED 4000d9b4: 38 80 00 4d bgu,a 4000dae8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 4000d9b8: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 4000d9bc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4000d9c0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 4000d9c4: 7f ff e9 31 call 40007e88 <_Heap_Block_allocate> <== NOT EXECUTED 4000d9c8: 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; 4000d9cc: 90 02 00 17 add %o0, %l7, %o0 <== NOT EXECUTED 4000d9d0: 90 12 00 1b or %o0, %i3, %o0 <== NOT EXECUTED 4000d9d4: d0 24 a0 04 st %o0, [ %l2 + 4 ] <== NOT EXECUTED --stats->used_blocks; 4000d9d8: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED 4000d9dc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000d9e0: 10 80 00 3a b 4000dac8 <_Heap_Resize_block+0x1fc> <== NOT EXECUTED 4000d9e4: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 4000d9e8: a0 20 40 1a sub %g1, %i2, %l0 <== NOT EXECUTED uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 4000d9ec: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 4000d9f0: 40 00 22 48 call 40016310 <.urem> <== NOT EXECUTED 4000d9f4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 4000d9f8: a0 a4 00 08 subcc %l0, %o0, %l0 <== NOT EXECUTED 4000d9fc: 22 80 00 34 be,a 4000dacc <_Heap_Resize_block+0x200> <== NOT EXECUTED 4000da00: 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; 4000da04: 84 25 c0 10 sub %l7, %l0, %g2 <== NOT EXECUTED if (new_block_size < min_block_size) { 4000da08: 80 a0 80 15 cmp %g2, %l5 <== NOT EXECUTED 4000da0c: 1a 80 00 08 bcc 4000da2c <_Heap_Resize_block+0x160> <== NOT EXECUTED 4000da10: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 4000da14: 82 25 40 02 sub %l5, %g2, %g1 <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 4000da18: a0 a4 00 01 subcc %l0, %g1, %l0 <== NOT EXECUTED 4000da1c: 22 80 00 2c be,a 4000dacc <_Heap_Resize_block+0x200> <== NOT EXECUTED 4000da20: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 4000da24: 84 00 80 01 add %g2, %g1, %g2 <== 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) { 4000da28: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 4000da2c: 12 80 00 15 bne 4000da80 <_Heap_Resize_block+0x1b4> <== NOT EXECUTED 4000da30: 80 a4 00 15 cmp %l0, %l5 <== 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; 4000da34: 82 10 80 1b or %g2, %i3, %g1 <== 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; 4000da38: 86 04 00 14 add %l0, %l4, %g3 <== NOT EXECUTED _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 4000da3c: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED new_next_block->size = new_next_block_size | HEAP_PREV_USED; 4000da40: 82 10 e0 01 or %g3, 1, %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 4000da44: 84 04 80 02 add %l2, %g2, %g2 <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; 4000da48: c6 27 40 00 st %g3, [ %i5 ] <== NOT EXECUTED Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; 4000da4c: da 04 60 0c ld [ %l1 + 0xc ], %o5 <== NOT EXECUTED Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; 4000da50: c8 04 60 08 ld [ %l1 + 8 ], %g4 <== 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; 4000da54: c2 20 a0 04 st %g1, [ %g2 + 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; 4000da58: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED Heap_Block *prev = block->prev; block = new_block; block->next = next; 4000da5c: c8 20 a0 08 st %g4, [ %g2 + 8 ] <== NOT EXECUTED 4000da60: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED block->prev = prev; 4000da64: da 20 a0 0c st %o5, [ %g2 + 0xc ] <== NOT EXECUTED 4000da68: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 4000da6c: 86 00 ff fc add %g3, -4, %g3 <== NOT EXECUTED next->prev = prev->next = block; 4000da70: c4 21 20 0c st %g2, [ %g4 + 0xc ] <== NOT EXECUTED 4000da74: c4 23 60 08 st %g2, [ %o5 + 8 ] <== NOT EXECUTED 4000da78: 10 80 00 14 b 4000dac8 <_Heap_Resize_block+0x1fc> <== NOT EXECUTED 4000da7c: c6 27 00 00 st %g3, [ %i4 ] <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 4000da80: 2a 80 00 13 bcs,a 4000dacc <_Heap_Resize_block+0x200> <== NOT EXECUTED 4000da84: 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; 4000da88: 82 10 80 1b or %g2, %i3, %g1 <== NOT EXECUTED 4000da8c: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 4000da90: 82 14 20 01 or %l0, 1, %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 4000da94: 92 04 80 02 add %l2, %g2, %o1 <== NOT EXECUTED 4000da98: c2 22 60 04 st %g1, [ %o1 + 4 ] <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 4000da9c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000daa0: 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 */ 4000daa4: 82 00 60 01 inc %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000daa8: 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 */ 4000daac: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000dab0: c4 26 20 50 st %g2, [ %i0 + 0x50 ] <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 4000dab4: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 4000dab8: 7f ff e8 64 call 40007c48 <_Heap_Free> <== NOT EXECUTED 4000dabc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 4000dac0: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED 4000dac4: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED } } } ++stats->resizes; 4000dac8: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 4000dacc: 84 10 20 00 clr %g2 <== NOT EXECUTED 4000dad0: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000dad4: 10 80 00 05 b 4000dae8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 4000dad8: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; 4000dadc: 10 80 00 03 b 4000dae8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 4000dae0: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 4000dae4: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED } 4000dae8: 81 c7 e0 08 ret <== NOT EXECUTED 4000daec: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED 4000daf0 <_Heap_Size_of_user_area>: boolean _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 4000daf0: 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( 4000daf4: e2 06 20 20 ld [ %i0 + 0x20 ], %l1 <== NOT EXECUTED 4000daf8: 80 a6 40 11 cmp %i1, %l1 <== NOT EXECUTED 4000dafc: 0a 80 00 1f bcs 4000db78 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 4000db00: e0 06 20 24 ld [ %i0 + 0x24 ], %l0 <== NOT EXECUTED 4000db04: 80 a6 40 10 cmp %i1, %l0 <== NOT EXECUTED 4000db08: 18 80 00 1c bgu 4000db78 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 4000db0c: 01 00 00 00 nop <== 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); 4000db10: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 <== NOT EXECUTED 4000db14: 40 00 21 ff call 40016310 <.urem> <== NOT EXECUTED 4000db18: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4000db1c: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 4000db20: 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 ) ) 4000db24: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 4000db28: 0a 80 00 14 bcs 4000db78 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 4000db2c: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 4000db30: 18 80 00 12 bgu 4000db78 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 4000db34: 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 ); 4000db38: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4000db3c: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 4000db40: 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 ( 4000db44: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 4000db48: 0a 80 00 0c bcs 4000db78 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 4000db4c: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 4000db50: 18 80 00 0a bgu 4000db78 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 4000db54: 01 00 00 00 nop <== NOT EXECUTED 4000db58: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4000db5c: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 4000db60: 02 80 00 06 be 4000db78 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 4000db64: 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 ) 4000db68: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED 4000db6c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 4000db70: 81 c7 e0 08 ret <== NOT EXECUTED 4000db74: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); } 4000db78: 81 c7 e0 08 ret <== NOT EXECUTED 4000db7c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 4000741c <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 4000741c: 9d e3 bf 98 save %sp, -104, %sp 40007420: 23 10 00 6e sethi %hi(0x4001b800), %l1 /* * 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 ) 40007424: 80 a6 80 19 cmp %i2, %i1 40007428: 18 80 00 06 bgu 40007440 <_IO_Manager_initialization+0x24> 4000742c: 25 10 00 6e sethi %hi(0x4001b800), %l2 * 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; 40007430: f0 24 60 08 st %i0, [ %l1 + 8 ] _IO_Number_of_drivers = number_of_drivers; 40007434: f2 24 a0 04 st %i1, [ %l2 + 4 ] 40007438: 81 c7 e0 08 ret 4000743c: 81 e8 00 00 restore /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 40007440: 83 2e a0 03 sll %i2, 3, %g1 <== NOT EXECUTED 40007444: a1 2e a0 05 sll %i2, 5, %l0 <== NOT EXECUTED 40007448: a0 24 00 01 sub %l0, %g1, %l0 <== NOT EXECUTED 4000744c: 40 00 0e f0 call 4000b00c <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 40007450: 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; memset( 40007454: 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; 40007458: f4 24 a0 04 st %i2, [ %l2 + 4 ] <== 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 *) 4000745c: d0 24 60 08 st %o0, [ %l1 + 8 ] <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 40007460: 40 00 20 d9 call 4000f7c4 <== NOT EXECUTED 40007464: 92 10 20 00 clr %o1 <== NOT EXECUTED _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; 40007468: e2 04 60 08 ld [ %l1 + 8 ], %l1 <== NOT EXECUTED 4000746c: b4 10 20 00 clr %i2 <== NOT EXECUTED 40007470: 10 80 00 07 b 4000748c <_IO_Manager_initialization+0x70> <== NOT EXECUTED 40007474: a0 10 20 00 clr %l0 <== NOT EXECUTED 40007478: 92 04 00 18 add %l0, %i0, %o1 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 4000747c: b4 06 a0 01 inc %i2 <== NOT EXECUTED 40007480: a0 04 20 18 add %l0, 0x18, %l0 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40007484: 40 00 20 a3 call 4000f710 <== NOT EXECUTED 40007488: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 4000748c: 80 a6 80 19 cmp %i2, %i1 <== NOT EXECUTED 40007490: 12 bf ff fa bne 40007478 <_IO_Manager_initialization+0x5c> <== NOT EXECUTED 40007494: 90 04 00 11 add %l0, %l1, %o0 <== NOT EXECUTED 40007498: 81 c7 e0 08 ret <== NOT EXECUTED 4000749c: 81 e8 00 00 restore <== NOT EXECUTED 40008098 <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 40008098: 9d e3 bf 98 save %sp, -104, %sp _ISR_Signals_to_thread_executing = FALSE; 4000809c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400080a0: c0 20 63 58 clr [ %g1 + 0x358 ] ! 4001af58 <_ISR_Signals_to_thread_executing> _ISR_Nest_level = 0; 400080a4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 400080a8: 90 10 24 00 mov 0x400, %o0 void _ISR_Handler_initialization( void ) { _ISR_Signals_to_thread_executing = FALSE; _ISR_Nest_level = 0; 400080ac: c0 20 62 94 clr [ %g1 + 0x294 ] _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 400080b0: 40 00 0b d7 call 4000b00c <_Workspace_Allocate_or_fatal_error> 400080b4: 01 00 00 00 nop _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 400080b8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400080bc: a0 10 61 e4 or %g1, 0x1e4, %l0 ! 4001ade4 <_CPU_Table> 400080c0: 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( 400080c4: 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 ) 400080c8: 80 a0 af ff cmp %g2, 0xfff 400080cc: 18 80 00 06 bgu 400080e4 <_ISR_Handler_initialization+0x4c> 400080d0: d0 20 62 74 st %o0, [ %g1 + 0x274 ] _Internal_error_Occurred( 400080d4: 90 10 20 00 clr %o0 <== NOT EXECUTED 400080d8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400080dc: 7f ff ff df call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 400080e0: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 400080e4: 40 00 0b ca call 4000b00c <_Workspace_Allocate_or_fatal_error> 400080e8: d0 04 20 18 ld [ %l0 + 0x18 ], %o0 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 400080ec: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 400080f0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 400080f4: 84 02 00 02 add %o0, %g2, %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 400080f8: d0 20 61 e0 st %o0, [ %g1 + 0x1e0 ] _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 400080fc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008100: c4 20 61 2c st %g2, [ %g1 + 0x12c ] ! 4001ad2c <_CPU_Interrupt_stack_high> #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 40008104: 81 c7 e0 08 ret 40008108: 81 e8 00 00 restore 40017444 <_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; 40017444: 10 80 00 05 b 40017458 <_Objects_Copy_name_raw+0x14> <== NOT EXECUTED 40017448: 95 32 a0 02 srl %o2, 2, %o2 <== NOT EXECUTED while ( tmp_length-- ) *destination_p++ = *source_p++; 4001744c: 90 02 20 04 add %o0, 4, %o0 <== NOT EXECUTED 40017450: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED 40017454: 92 02 60 04 add %o1, 4, %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-- ) 40017458: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED 4001745c: 80 a2 bf ff cmp %o2, -1 <== NOT EXECUTED 40017460: 32 bf ff fb bne,a 4001744c <_Objects_Copy_name_raw+0x8> <== NOT EXECUTED 40017464: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED *destination_p++ = *source_p++; } 40017468: 81 c3 e0 08 retl <== NOT EXECUTED 4001746c: 01 00 00 00 nop 400081e8 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 400081e8: 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; 400081ec: 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 ) 400081f0: e0 16 20 10 lduh [ %i0 + 0x10 ], %l0 400081f4: 03 00 00 3f sethi %hi(0xfc00), %g1 400081f8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400081fc: a2 08 80 01 and %g2, %g1, %l1 40008200: 80 a4 00 11 cmp %l0, %l1 40008204: 3a 80 00 06 bcc,a 4000821c <_Objects_Extend_information+0x34> 40008208: e4 06 20 18 ld [ %i0 + 0x18 ], %l2 4000820c: ac 10 00 11 mov %l1, %l6 40008210: 90 10 20 00 clr %o0 40008214: 10 80 00 12 b 4000825c <_Objects_Extend_information+0x74> 40008218: b8 10 20 00 clr %i4 block_count = 0; else { block_count = information->maximum / information->allocation_size; 4000821c: 90 10 00 10 mov %l0, %o0 40008220: 92 10 00 12 mov %l2, %o1 40008224: 40 00 37 8f call 40016060 <.udiv> 40008228: ac 10 00 11 mov %l1, %l6 4000822c: 10 80 00 09 b 40008250 <_Objects_Extend_information+0x68> 40008230: b8 10 20 00 clr %i4 for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 40008234: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 40008238: c2 00 40 02 ld [ %g1 + %g2 ], %g1 4000823c: 80 a0 60 00 cmp %g1, 0 40008240: 02 80 00 08 be 40008260 <_Objects_Extend_information+0x78> 40008244: 80 a5 80 10 cmp %l6, %l0 break; else index_base += information->allocation_size; 40008248: ac 05 80 12 add %l6, %l2, %l6 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 4000824c: b8 07 20 01 inc %i4 40008250: 80 a7 00 08 cmp %i4, %o0 40008254: 12 bf ff f8 bne 40008234 <_Objects_Extend_information+0x4c> 40008258: 85 2f 20 02 sll %i4, 2, %g2 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 4000825c: 80 a5 80 10 cmp %l6, %l0 40008260: 2a 80 00 63 bcs,a 400083ec <_Objects_Extend_information+0x204> 40008264: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 40008268: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 4000826c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 40008270: ae 04 00 01 add %l0, %g1, %l7 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 40008274: 80 a0 a0 00 cmp %g2, 0 /* * Up the block count and maximum */ block_count++; 40008278: a0 02 20 01 add %o0, 1, %l0 4000827c: 82 05 c0 11 add %l7, %l1, %g1 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 40008280: 02 80 00 0b be 400082ac <_Objects_Extend_information+0xc4> 40008284: 91 2c 20 01 sll %l0, 1, %o0 object_blocks = (void**) 40008288: 90 02 00 10 add %o0, %l0, %o0 4000828c: 90 00 40 08 add %g1, %o0, %o0 40008290: 7f ff ff cf call 400081cc <_Workspace_Allocate> 40008294: 91 2a 20 02 sll %o0, 2, %o0 block_count * (sizeof(void *) + sizeof(uint32_t ) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 40008298: a4 92 20 00 orcc %o0, 0, %l2 4000829c: 32 80 00 0a bne,a 400082c4 <_Objects_Extend_information+0xdc> 400082a0: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 400082a4: 81 c7 e0 08 ret <== NOT EXECUTED 400082a8: 81 e8 00 00 restore <== NOT EXECUTED return; } else { object_blocks = (void**) 400082ac: 90 02 00 10 add %o0, %l0, %o0 400082b0: 90 00 40 08 add %g1, %o0, %o0 400082b4: 40 00 0b 56 call 4000b00c <_Workspace_Allocate_or_fatal_error> 400082b8: 91 2a 20 02 sll %o0, 2, %o0 400082bc: a4 10 00 08 mov %o0, %l2 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 400082c0: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 /* * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; 400082c4: ba 04 3f ff add %l0, -1, %i5 if ( information->maximum > minimum_index ) { 400082c8: 80 a0 40 11 cmp %g1, %l1 400082cc: 84 10 20 00 clr %g2 400082d0: 83 2c 20 02 sll %l0, 2, %g1 /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 400082d4: a8 04 80 01 add %l2, %g1, %l4 object_blocks, block_count * sizeof(void*) ); name_table = (Objects_Name *) _Addresses_Add_offset( 400082d8: aa 05 00 01 add %l4, %g1, %l5 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 400082dc: 08 80 00 19 bleu 40008340 <_Objects_Extend_information+0x158> 400082e0: a6 05 40 01 add %l5, %g1, %l3 /* * 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, 400082e4: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 400082e8: a1 2f 60 02 sll %i5, 2, %l0 400082ec: 90 10 00 12 mov %l2, %o0 400082f0: 40 00 1d 08 call 4000f710 400082f4: 94 10 00 10 mov %l0, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 400082f8: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 400082fc: 94 10 00 10 mov %l0, %o2 40008300: 40 00 1d 04 call 4000f710 40008304: 90 10 00 14 mov %l4, %o0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, 40008308: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 4000830c: 94 10 00 10 mov %l0, %o2 40008310: 40 00 1d 00 call 4000f710 40008314: 90 10 00 15 mov %l5, %o0 information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 40008318: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 4000831c: d2 06 20 20 ld [ %i0 + 0x20 ], %o1 40008320: 94 02 80 11 add %o2, %l1, %o2 40008324: 90 10 00 13 mov %l3, %o0 40008328: 40 00 1c fa call 4000f710 4000832c: 95 2a a0 02 sll %o2, 2, %o2 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 40008330: 10 80 00 08 b 40008350 <_Objects_Extend_information+0x168> 40008334: 83 2f 60 02 sll %i5, 2, %g1 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 40008338: 84 00 a0 01 inc %g2 local_table[ index ] = NULL; 4000833c: c0 20 40 13 clr [ %g1 + %l3 ] else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 40008340: 80 a0 80 11 cmp %g2, %l1 40008344: 32 bf ff fd bne,a 40008338 <_Objects_Extend_information+0x150> 40008348: 83 28 a0 02 sll %g2, 2, %g1 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 4000834c: 83 2f 60 02 sll %i5, 2, %g1 inactive_per_block[block_count] = 0; 40008350: c0 25 00 01 clr [ %l4 + %g1 ] /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 40008354: c0 24 80 01 clr [ %l2 + %g1 ] inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); 40008358: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; name_table[block_count] = NULL; 4000835c: c0 25 40 01 clr [ %l5 + %g1 ] for ( index=index_base ; index < ( information->allocation_size + index_base ); 40008360: 83 2d a0 02 sll %l6, 2, %g1 40008364: 86 05 80 02 add %l6, %g2, %g3 40008368: 84 04 c0 01 add %l3, %g1, %g2 4000836c: 10 80 00 04 b 4000837c <_Objects_Extend_information+0x194> 40008370: 82 10 00 16 mov %l6, %g1 index++ ) { local_table[ index ] = NULL; 40008374: c0 20 bf fc clr [ %g2 + -4 ] inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 40008378: 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 ); 4000837c: 80 a0 40 03 cmp %g1, %g3 40008380: 0a bf ff fd bcs 40008374 <_Objects_Extend_information+0x18c> 40008384: 84 00 a0 04 add %g2, 4, %g2 index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 40008388: 7f ff e6 d1 call 40001ecc 4000838c: 01 00 00 00 nop 40008390: a0 10 00 08 mov %o0, %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( 40008394: d0 06 00 00 ld [ %i0 ], %o0 40008398: d2 16 20 04 lduh [ %i0 + 4 ], %o1 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; 4000839c: e8 26 20 38 st %l4, [ %i0 + 0x38 ] information->name_table = name_table; 400083a0: ea 26 20 24 st %l5, [ %i0 + 0x24 ] information->local_table = local_table; 400083a4: e6 26 20 20 st %l3, [ %i0 + 0x20 ] information->maximum = maximum; 400083a8: ee 36 20 10 sth %l7, [ %i0 + 0x10 ] information->maximum_id = _Objects_Build_id( 400083ac: 97 2d e0 10 sll %l7, 0x10, %o3 local_table[ index ] = NULL; } _ISR_Disable( level ); old_tables = information->object_blocks; 400083b0: e2 06 20 3c ld [ %i0 + 0x3c ], %l1 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( 400083b4: 97 32 e0 10 srl %o3, 0x10, %o3 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; 400083b8: e4 26 20 3c st %l2, [ %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( 400083bc: 7f ff ff 7d call 400081b0 <_Objects_Build_id> 400083c0: 94 10 20 01 mov 1, %o2 400083c4: d0 26 20 0c st %o0, [ %i0 + 0xc ] information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 400083c8: 7f ff e6 c5 call 40001edc 400083cc: 90 10 00 10 mov %l0, %o0 if ( old_tables ) 400083d0: 80 a4 60 00 cmp %l1, 0 400083d4: 02 80 00 05 be 400083e8 <_Objects_Extend_information+0x200> 400083d8: 11 10 00 6b sethi %hi(0x4001ac00), %o0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 400083dc: 92 10 00 11 mov %l1, %o1 400083e0: 7f ff fe 1a call 40007c48 <_Heap_Free> 400083e4: 90 12 22 1c or %o0, 0x21c, %o0 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 400083e8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 400083ec: e2 06 20 3c ld [ %i0 + 0x3c ], %l1 400083f0: 80 a0 60 00 cmp %g1, 0 400083f4: a1 2f 20 02 sll %i4, 2, %l0 400083f8: d0 16 20 44 lduh [ %i0 + 0x44 ], %o0 400083fc: 02 80 00 11 be 40008440 <_Objects_Extend_information+0x258> 40008400: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 information->object_blocks[ block ] = 40008404: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40008408: 91 2a 20 10 sll %o0, 0x10, %o0 4000840c: 91 32 20 10 srl %o0, 0x10, %o0 40008410: 40 00 36 da call 40015f78 <.umul> 40008414: 90 02 00 01 add %o0, %g1, %o0 40008418: 7f ff ff 6d call 400081cc <_Workspace_Allocate> 4000841c: 01 00 00 00 nop _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 40008420: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { information->object_blocks[ block ] = 40008424: d0 24 00 11 st %o0, [ %l0 + %l1 ] _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 40008428: c2 00 40 10 ld [ %g1 + %l0 ], %g1 4000842c: 80 a0 60 00 cmp %g1, 0 40008430: 32 80 00 0d bne,a 40008464 <_Objects_Extend_information+0x27c> 40008434: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40008438: 81 c7 e0 08 ret <== NOT EXECUTED 4000843c: 81 e8 00 00 restore <== NOT EXECUTED return; } else { information->object_blocks[ block ] = 40008440: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40008444: 91 2a 20 10 sll %o0, 0x10, %o0 40008448: 91 32 20 10 srl %o0, 0x10, %o0 4000844c: 40 00 36 cb call 40015f78 <.umul> 40008450: 90 02 00 01 add %o0, %g1, %o0 40008454: 40 00 0a ee call 4000b00c <_Workspace_Allocate_or_fatal_error> 40008458: 01 00 00 00 nop 4000845c: d0 24 00 11 st %o0, [ %l0 + %l1 ] 40008460: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40008464: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 40008468: 40 00 36 c4 call 40015f78 <.umul> 4000846c: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); } name_area = (Objects_Name *) _Addresses_Add_offset( 40008470: a7 2f 20 02 sll %i4, 2, %l3 information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 40008474: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 40008478: c2 04 00 13 ld [ %l0 + %l3 ], %g1 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 4000847c: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 40008480: a2 02 00 01 add %o0, %g1, %l1 40008484: d6 06 20 1c ld [ %i0 + 0x1c ], %o3 name_area = (Objects_Name *) _Addresses_Add_offset( information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 40008488: e2 20 80 13 st %l1, [ %g2 + %l3 ] /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 4000848c: d2 04 00 13 ld [ %l0 + %l3 ], %o1 40008490: 90 07 bf ec add %fp, -20, %o0 40008494: a4 10 00 16 mov %l6, %l2 * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 40008498: aa 10 00 08 mov %o0, %l5 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 4000849c: 40 00 14 b4 call 4000d76c <_Chain_Initialize> 400084a0: a8 06 20 28 add %i0, 0x28, %l4 400084a4: 30 80 00 0c b,a 400084d4 <_Objects_Extend_information+0x2ec> index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 400084a8: d2 16 20 04 lduh [ %i0 + 4 ], %o1 400084ac: d0 06 00 00 ld [ %i0 ], %o0 400084b0: 7f ff ff 40 call 400081b0 <_Objects_Build_id> 400084b4: a4 04 a0 01 inc %l2 400084b8: c2 16 20 44 lduh [ %i0 + 0x44 ], %g1 400084bc: d0 24 20 08 st %o0, [ %l0 + 8 ] information->the_class, _Objects_Local_node, index ); the_object->name = (void *) name_area; 400084c0: e2 24 20 0c st %l1, [ %l0 + 0xc ] name_area = _Addresses_Add_offset( name_area, information->name_length ); _Chain_Append( &information->Inactive, &the_object->Node ); 400084c4: 92 10 00 10 mov %l0, %o1 400084c8: a2 04 40 01 add %l1, %g1, %l1 400084cc: 7f ff fc 7b call 400076b8 <_Chain_Append> 400084d0: 90 10 00 14 mov %l4, %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 ) { 400084d4: 7f ff fc 85 call 400076e8 <_Chain_Get> 400084d8: 90 10 00 15 mov %l5, %o0 the_object->id = _Objects_Build_id( 400084dc: 96 10 00 12 mov %l2, %o3 * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 400084e0: a0 10 00 08 mov %o0, %l0 400084e4: 80 a2 20 00 cmp %o0, 0 400084e8: 12 bf ff f0 bne 400084a8 <_Objects_Extend_information+0x2c0> 400084ec: 94 10 20 01 mov 1, %o2 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 400084f0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 400084f4: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 information->inactive += information->allocation_size; 400084f8: c6 16 20 34 lduh [ %i0 + 0x34 ], %g3 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 400084fc: c2 20 80 13 st %g1, [ %g2 + %l3 ] information->inactive += information->allocation_size; 40008500: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40008504: 82 00 40 03 add %g1, %g3, %g1 40008508: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 4000850c: 81 c7 e0 08 ret 40008510: 81 e8 00 00 restore 4000a070 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 4000a070: 9d e3 bf 88 save %sp, -120, %sp 4000a074: 92 10 00 18 mov %i0, %o1 uint32_t i; char lname[5]; Objects_Control *the_object; Objects_Locations location; if ( length == 0 ) 4000a078: 80 a6 60 00 cmp %i1, 0 4000a07c: 02 80 00 43 be 4000a188 <_Objects_Get_name_as_string+0x118> 4000a080: b0 10 00 1a mov %i2, %i0 return NULL; if ( name == NULL ) 4000a084: 80 a6 a0 00 cmp %i2, 0 4000a088: 02 80 00 3e be 4000a180 <_Objects_Get_name_as_string+0x110> 4000a08c: 85 32 60 16 srl %o1, 0x16, %g2 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 4000a090: 03 10 00 9e sethi %hi(0x40027800), %g1 4000a094: 84 08 a0 1c and %g2, 0x1c, %g2 4000a098: 82 10 61 50 or %g1, 0x150, %g1 4000a09c: c4 00 40 02 ld [ %g1 + %g2 ], %g2 4000a0a0: 83 32 60 1b srl %o1, 0x1b, %g1 4000a0a4: 83 28 60 02 sll %g1, 2, %g1 4000a0a8: e0 00 80 01 ld [ %g2 + %g1 ], %l0 return NULL; information = _Objects_Get_information( id ); if ( !information ) 4000a0ac: 80 a4 20 00 cmp %l0, 0 4000a0b0: 22 80 00 34 be,a 4000a180 <_Objects_Get_name_as_string+0x110> 4000a0b4: b0 10 20 00 clr %i0 <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, id, &location ); 4000a0b8: 90 10 00 10 mov %l0, %o0 4000a0bc: 40 00 00 36 call 4000a194 <_Objects_Get> 4000a0c0: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 4000a0c4: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000a0c8: 80 a0 60 00 cmp %g1, 0 4000a0cc: 32 80 00 2d bne,a 4000a180 <_Objects_Get_name_as_string+0x110> 4000a0d0: b0 10 20 00 clr %i0 <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 4000a0d4: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 4000a0d8: 80 a0 60 00 cmp %g1, 0 4000a0dc: 12 80 00 0b bne 4000a108 <_Objects_Get_name_as_string+0x98> 4000a0e0: d0 02 20 0c ld [ %o0 + 0xc ], %o0 s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; 4000a0e4: 83 32 20 18 srl %o0, 0x18, %g1 4000a0e8: c2 2f bf ef stb %g1, [ %fp + -17 ] lname[ 1 ] = (u32_name >> 16) & 0xff; 4000a0ec: 83 32 20 10 srl %o0, 0x10, %g1 lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; 4000a0f0: d0 2f bf f2 stb %o0, [ %fp + -14 ] 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; 4000a0f4: c2 2f bf f0 stb %g1, [ %fp + -16 ] lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 4000a0f8: c0 2f bf f3 clrb [ %fp + -13 ] } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 4000a0fc: 83 32 20 08 srl %o0, 8, %g1 lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 4000a100: 90 07 bf ef add %fp, -17, %o0 } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 4000a104: c2 2f bf f1 stb %g1, [ %fp + -15 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 4000a108: 84 10 00 18 mov %i0, %g2 4000a10c: 88 10 20 01 mov 1, %g4 s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { *d = (!isprint(*s)) ? '*' : *s; 4000a110: 10 80 00 09 b 4000a134 <_Objects_Get_name_as_string+0xc4> 4000a114: 19 10 00 7c sethi %hi(0x4001f000), %o4 4000a118: c2 03 22 20 ld [ %o4 + 0x220 ], %g1 ! 4001f220 <__ctype_ptr> 4000a11c: c2 48 40 03 ldsb [ %g1 + %g3 ], %g1 4000a120: 80 88 60 97 btst 0x97, %g1 4000a124: 22 80 00 02 be,a 4000a12c <_Objects_Get_name_as_string+0xbc> 4000a128: 9a 10 20 2a mov 0x2a, %o5 <== NOT EXECUTED 4000a12c: da 28 80 00 stb %o5, [ %g2 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { 4000a130: 84 00 a0 01 inc %g2 4000a134: 80 a1 00 19 cmp %g4, %i1 4000a138: 02 80 00 07 be 4000a154 <_Objects_Get_name_as_string+0xe4> 4000a13c: 82 02 00 04 add %o0, %g4, %g1 4000a140: c6 48 7f ff ldsb [ %g1 + -1 ], %g3 4000a144: 88 01 20 01 inc %g4 4000a148: 80 a0 e0 00 cmp %g3, 0 4000a14c: 12 bf ff f3 bne 4000a118 <_Objects_Get_name_as_string+0xa8> 4000a150: da 08 7f ff ldub [ %g1 + -1 ], %o5 *d = (!isprint(*s)) ? '*' : *s; } *d = '\0'; 4000a154: c0 28 80 00 clrb [ %g2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a158: 03 10 00 9e sethi %hi(0x40027800), %g1 4000a15c: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 400279f0 <_Thread_Dispatch_disable_level> 4000a160: 84 00 bf ff add %g2, -1, %g2 4000a164: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 4000a168: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 4000a16c: 80 a0 60 00 cmp %g1, 0 4000a170: 12 80 00 07 bne 4000a18c <_Objects_Get_name_as_string+0x11c> 4000a174: 01 00 00 00 nop _Thread_Dispatch(); 4000a178: 40 00 04 bc call 4000b468 <_Thread_Dispatch> 4000a17c: 01 00 00 00 nop 4000a180: 81 c7 e0 08 ret 4000a184: 81 e8 00 00 restore 4000a188: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 4000a18c: 81 c7 e0 08 ret <== NOT EXECUTED 4000a190: 81 e8 00 00 restore <== NOT EXECUTED 40017470 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 40017470: 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) 40017474: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 40017478: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <== NOT EXECUTED 4001747c: 80 8e 40 01 btst %i1, %g1 <== NOT EXECUTED 40017480: 22 80 00 02 be,a 40017488 <_Objects_Get_next+0x18> <== NOT EXECUTED 40017484: 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) 40017488: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 4001748c: a0 10 63 ff or %g1, 0x3ff, %l0 ! ffff <== NOT EXECUTED 40017490: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED 40017494: 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); 40017498: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001749c: 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) 400174a0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400174a4: 18 80 00 0a bgu 400174cc <_Objects_Get_next+0x5c> <== NOT EXECUTED 400174a8: 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); 400174ac: 7f ff d6 73 call 4000ce78 <_Objects_Get> <== NOT EXECUTED 400174b0: b2 06 60 01 inc %i1 <== NOT EXECUTED next_id++; } while (*location_p != OBJECTS_LOCAL); 400174b4: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 400174b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400174bc: 32 bf ff f6 bne,a 40017494 <_Objects_Get_next+0x24> <== NOT EXECUTED 400174c0: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED *next_id_p = next_id; 400174c4: 10 80 00 07 b 400174e0 <_Objects_Get_next+0x70> <== NOT EXECUTED 400174c8: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 400174cc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 400174d0: 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; 400174d4: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 400174d8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED 400174dc: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED return 0; } 400174e0: 81 c7 e0 08 ret <== NOT EXECUTED 400174e4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 400158b4 <_Objects_Get_no_protection>: ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 400158b4: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->maximum >= index ) { 400158b8: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 400158bc: 92 22 40 01 sub %o1, %g1, %o1 400158c0: 82 02 60 01 add %o1, 1, %g1 if ( information->maximum >= index ) { 400158c4: 80 a0 80 01 cmp %g2, %g1 400158c8: 0a 80 00 0b bcs 400158f4 <_Objects_Get_no_protection+0x40> 400158cc: 83 28 60 02 sll %g1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 400158d0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400158d4: d0 00 80 01 ld [ %g2 + %g1 ], %o0 400158d8: 80 a2 20 00 cmp %o0, 0 400158dc: 02 80 00 04 be 400158ec <_Objects_Get_no_protection+0x38> 400158e0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_LOCAL; 400158e4: 81 c3 e0 08 retl 400158e8: c0 22 80 00 clr [ %o2 ] return the_object; } *location = OBJECTS_ERROR; 400158ec: 81 c3 e0 08 retl <== NOT EXECUTED 400158f0: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED return NULL; } *location = OBJECTS_ERROR; 400158f4: 82 10 20 02 mov 2, %g1 400158f8: 90 10 20 00 clr %o0 /* * Not supported for multiprocessing */ return NULL; } 400158fc: 81 c3 e0 08 retl 40015900: c2 22 80 00 st %g1, [ %o2 ] 40008880 <_Objects_Handler_initialization>: uint32_t node, uint32_t maximum_nodes, uint32_t maximum_global_objects ) { if ( node < 1 || node > maximum_nodes ) 40008880: 80 a2 20 00 cmp %o0, 0 40008884: 22 80 00 05 be,a 40008898 <_Objects_Handler_initialization+0x18> 40008888: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000888c: 80 a2 00 09 cmp %o0, %o1 40008890: 08 80 00 07 bleu 400088ac <_Objects_Handler_initialization+0x2c> 40008894: 90 10 20 00 clr %o0 _Internal_error_Occurred( 40008898: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 4000889c: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED 400088a0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 400088a4: 7f ff fd ed call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 400088a8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 400088ac: 81 c3 e0 08 retl 400088b0: 01 00 00 00 nop 40009cc4 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 40009cc4: 9d e3 bf 90 save %sp, -112, %sp 40009cc8: 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 ) 40009ccc: 80 a6 60 00 cmp %i1, 0 40009cd0: 02 80 00 26 be 40009d68 <_Objects_Id_to_name+0xa4> 40009cd4: 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); 40009cd8: 83 32 60 18 srl %o1, 0x18, %g1 40009cdc: 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 ) 40009ce0: 80 a0 60 04 cmp %g1, 4 40009ce4: 18 80 00 23 bgu 40009d70 <_Objects_Id_to_name+0xac> 40009ce8: 85 28 60 02 sll %g1, 2, %g2 return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( id ); information = _Objects_Information_table[ the_api ][ the_class ]; 40009cec: 03 10 00 7e sethi %hi(0x4001f800), %g1 40009cf0: 82 10 60 60 or %g1, 0x60, %g1 ! 4001f860 <_Objects_Information_table> 40009cf4: c4 00 40 02 ld [ %g1 + %g2 ], %g2 40009cf8: 83 32 60 1b srl %o1, 0x1b, %g1 40009cfc: 83 28 60 02 sll %g1, 2, %g1 40009d00: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( !information ) 40009d04: 80 a2 20 00 cmp %o0, 0 40009d08: 02 80 00 18 be 40009d68 <_Objects_Id_to_name+0xa4> 40009d0c: b0 10 20 03 mov 3, %i0 return OBJECTS_INVALID_ID; if ( information->is_string ) 40009d10: c2 02 20 40 ld [ %o0 + 0x40 ], %g1 40009d14: 80 a0 60 00 cmp %g1, 0 40009d18: 12 80 00 17 bne 40009d74 <_Objects_Id_to_name+0xb0> 40009d1c: 01 00 00 00 nop return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, id, &ignored_location ); 40009d20: 7f ff ff c4 call 40009c30 <_Objects_Get> 40009d24: 94 07 bf f4 add %fp, -12, %o2 if ( !the_object ) 40009d28: 80 a2 20 00 cmp %o0, 0 40009d2c: 02 80 00 0f be 40009d68 <_Objects_Id_to_name+0xa4> 40009d30: b0 10 20 03 mov 3, %i0 return OBJECTS_INVALID_ID; *name = the_object->name; 40009d34: c2 02 20 0c ld [ %o0 + 0xc ], %g1 40009d38: 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 ) 40009d3c: 05 10 00 7e sethi %hi(0x4001f800), %g2 40009d40: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 ! 4001f900 <_Thread_Dispatch_disable_level> 40009d44: b0 10 20 00 clr %i0 40009d48: 82 00 7f ff add %g1, -1, %g1 40009d4c: c2 20 a1 00 st %g1, [ %g2 + 0x100 ] 40009d50: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 40009d54: 80 a0 60 00 cmp %g1, 0 40009d58: 12 80 00 07 bne 40009d74 <_Objects_Id_to_name+0xb0> 40009d5c: 01 00 00 00 nop _Thread_Dispatch(); 40009d60: 40 00 04 d6 call 4000b0b8 <_Thread_Dispatch> 40009d64: 01 00 00 00 nop 40009d68: 81 c7 e0 08 ret 40009d6c: 81 e8 00 00 restore 40009d70: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 40009d74: 81 c7 e0 08 ret <== NOT EXECUTED 40009d78: 81 e8 00 00 restore <== NOT EXECUTED 40008784 <_Objects_Name_to_id>: Objects_Information *information, Objects_Name name, uint32_t node, Objects_Id *id ) { 40008784: 9d e3 bf 98 save %sp, -104, %sp 40008788: 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 ) 4000878c: 80 a6 e0 00 cmp %i3, 0 40008790: 02 80 00 3a be 40008878 <_Objects_Name_to_id+0xf4> 40008794: b0 10 20 02 mov 2, %i0 return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 40008798: 80 a6 60 00 cmp %i1, 0 4000879c: 02 80 00 2d be 40008850 <_Objects_Name_to_id+0xcc> 400087a0: 01 00 00 00 nop return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 400087a4: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 400087a8: 80 a0 60 00 cmp %g1, 0 400087ac: 02 80 00 29 be 40008850 <_Objects_Name_to_id+0xcc> 400087b0: 80 a6 a0 00 cmp %i2, 0 400087b4: 22 80 00 2a be,a 4000885c <_Objects_Name_to_id+0xd8> 400087b8: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 400087bc: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 400087c0: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff 400087c4: 80 a6 80 01 cmp %i2, %g1 400087c8: 02 80 00 24 be 40008858 <_Objects_Name_to_id+0xd4> 400087cc: 80 a6 a0 01 cmp %i2, 1 400087d0: 22 80 00 23 be,a 4000885c <_Objects_Name_to_id+0xd8> 400087d4: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 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++ ) { 400087d8: 81 c7 e0 08 ret 400087dc: 91 e8 20 01 restore %g0, 1, %o0 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 400087e0: a4 10 63 90 or %g1, 0x390, %l2 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 ) ) { 400087e4: 83 28 a0 10 sll %g2, 0x10, %g1 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 400087e8: 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 ) ) { 400087ec: 10 80 00 15 b 40008840 <_Objects_Name_to_id+0xbc> 400087f0: 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 ]; 400087f4: c2 04 60 20 ld [ %l1 + 0x20 ], %g1 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++ ) { 400087f8: a0 04 20 01 inc %l0 the_object = information->local_table[ index ]; 400087fc: f4 00 40 02 ld [ %g1 + %g2 ], %i2 if ( !the_object || !the_object->name ) 40008800: 80 a6 a0 00 cmp %i2, 0 40008804: 02 80 00 0f be 40008840 <_Objects_Name_to_id+0xbc> 40008808: 90 10 00 19 mov %i1, %o0 4000880c: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 40008810: 80 a2 60 00 cmp %o1, 0 40008814: 02 80 00 0b be 40008840 <_Objects_Name_to_id+0xbc> 40008818: 94 10 00 18 mov %i0, %o2 continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 4000881c: 9f c4 80 00 call %l2 40008820: 01 00 00 00 nop 40008824: 80 a2 20 00 cmp %o0, 0 40008828: 22 80 00 07 be,a 40008844 <_Objects_Name_to_id+0xc0> 4000882c: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 *id = the_object->id; 40008830: c2 06 a0 08 ld [ %i2 + 8 ], %g1 40008834: c2 26 c0 00 st %g1, [ %i3 ] 40008838: 81 c7 e0 08 ret 4000883c: 91 e8 20 00 restore %g0, 0, %o0 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++ ) { 40008840: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 40008844: 80 a4 00 01 cmp %l0, %g1 40008848: 08 bf ff eb bleu 400087f4 <_Objects_Name_to_id+0x70> 4000884c: 85 2c 20 02 sll %l0, 2, %g2 40008850: 81 c7 e0 08 ret 40008854: 91 e8 20 01 restore %g0, 1, %o0 search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; 40008858: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 _Objects_Is_local_node( node ) )) search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; 4000885c: c4 14 60 44 lduh [ %l1 + 0x44 ], %g2 if ( information->is_string ) compare_them = _Objects_Compare_name_string; 40008860: 80 a0 60 00 cmp %g1, 0 40008864: 03 10 00 36 sethi %hi(0x4000d800), %g1 40008868: 02 bf ff df be 400087e4 <_Objects_Name_to_id+0x60> 4000886c: a4 10 63 80 or %g1, 0x380, %l2 ! 4000db80 <_Objects_Compare_name_raw> if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40008870: 10 bf ff dc b 400087e0 <_Objects_Name_to_id+0x5c> 40008874: 03 10 00 36 sethi %hi(0x4000d800), %g1 return ( _Objects_MP_Global_name_search( information, name, node, id ) ); #else return OBJECTS_INVALID_NAME; #endif } 40008878: 81 c7 e0 08 ret <== NOT EXECUTED 4000887c: 81 e8 00 00 restore <== NOT EXECUTED 400088b4 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 400088b4: 9d e3 bf 98 save %sp, -104, %sp 400088b8: 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; 400088bc: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 400088c0: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0 400088c4: 03 00 00 3f sethi %hi(0xfc00), %g1 400088c8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400088cc: 92 10 00 10 mov %l0, %o1 400088d0: a2 08 80 01 and %g2, %g1, %l1 400088d4: 40 00 35 e3 call 40016060 <.udiv> 400088d8: 90 22 00 11 sub %o0, %l1, %o0 400088dc: 86 10 20 00 clr %g3 400088e0: 10 80 00 33 b 400089ac <_Objects_Shrink_information+0xf8> 400088e4: a4 10 20 00 clr %l2 for ( block = 0; block < block_count; block++ ) { 400088e8: 86 00 e0 01 inc %g3 if ( information->inactive_per_block[ block ] == information->allocation_size ) { 400088ec: c2 00 40 12 ld [ %g1 + %l2 ], %g1 400088f0: 80 a0 40 10 cmp %g1, %l0 400088f4: 12 80 00 2c bne 400089a4 <_Objects_Shrink_information+0xf0> 400088f8: 84 04 a0 04 add %l2, 4, %g2 /* * 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; 400088fc: e0 06 20 28 ld [ %i0 + 0x28 ], %l0 40008900: 03 00 00 3f sethi %hi(0xfc00), %g1 40008904: a6 10 63 ff or %g1, 0x3ff, %l3 ! ffff 40008908: c2 04 20 08 ld [ %l0 + 8 ], %g1 4000890c: 84 08 40 13 and %g1, %l3, %g2 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 40008910: 80 a0 80 11 cmp %g2, %l1 40008914: 2a 80 00 0c bcs,a 40008944 <_Objects_Shrink_information+0x90> 40008918: e0 04 00 00 ld [ %l0 ], %l0 4000891c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40008920: 82 04 40 01 add %l1, %g1, %g1 40008924: 80 a0 80 01 cmp %g2, %g1 40008928: 1a 80 00 06 bcc 40008940 <_Objects_Shrink_information+0x8c> 4000892c: 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 ); 40008930: 40 00 13 85 call 4000d744 <_Chain_Extract> 40008934: e0 04 00 00 ld [ %l0 ], %l0 } else { the_object = (Objects_Control *) the_object->Node.next; } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 40008938: 10 80 00 04 b 40008948 <_Objects_Shrink_information+0x94> 4000893c: 80 a4 20 00 cmp %l0, 0 the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 40008940: e0 04 00 00 ld [ %l0 ], %l0 } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 40008944: 80 a4 20 00 cmp %l0, 0 40008948: 22 80 00 07 be,a 40008964 <_Objects_Shrink_information+0xb0> 4000894c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED 40008950: c2 04 00 00 ld [ %l0 ], %g1 40008954: 80 a0 60 00 cmp %g1, 0 40008958: 32 bf ff ed bne,a 4000890c <_Objects_Shrink_information+0x58> 4000895c: c2 04 20 08 ld [ %l0 + 8 ], %g1 40008960: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 40008964: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40008968: d2 00 40 12 ld [ %g1 + %l2 ], %o1 4000896c: 7f ff fc b7 call 40007c48 <_Heap_Free> 40008970: 90 12 22 1c or %o0, 0x21c, %o0 */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 40008974: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 40008978: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 4000897c: c0 20 40 12 clr [ %g1 + %l2 ] * 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; 40008980: c8 06 20 3c ld [ %i0 + 0x3c ], %g4 information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 40008984: c2 16 20 34 lduh [ %i0 + 0x34 ], %g1 40008988: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 4000898c: c0 20 c0 12 clr [ %g3 + %l2 ] information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 40008990: 82 20 40 02 sub %g1, %g2, %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; 40008994: c0 21 00 12 clr [ %g4 + %l2 ] information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 40008998: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 4000899c: 81 c7 e0 08 ret 400089a0: 81 e8 00 00 restore return; } index_base += information->allocation_size; 400089a4: 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++ ) { 400089a8: a4 10 00 02 mov %g2, %l2 400089ac: 80 a0 c0 08 cmp %g3, %o0 400089b0: 32 bf ff ce bne,a 400088e8 <_Objects_Shrink_information+0x34> 400089b4: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 400089b8: 81 c7 e0 08 ret 400089bc: 81 e8 00 00 restore 400074a0 <_POSIX_API_Initialize>: void _POSIX_API_Initialize( rtems_configuration_table *configuration_table ) { 400074a0: 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; 400074a4: f0 06 20 30 ld [ %i0 + 0x30 ], %i0 if ( !api_configuration ) 400074a8: 80 a6 20 00 cmp %i0, 0 400074ac: 32 80 00 05 bne,a 400074c0 <_POSIX_API_Initialize+0x20> 400074b0: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 400074b4: 03 10 00 6a sethi %hi(0x4001a800), %g1 <== NOT EXECUTED 400074b8: b0 10 63 78 or %g1, 0x378, %i0 ! 4001ab78 <_POSIX_Default_configuration> <== NOT EXECUTED api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; _POSIX_signals_Manager_Initialization( 400074bc: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED api_configuration = configuration_table->POSIX_api_configuration; if ( !api_configuration ) api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; 400074c0: 05 10 00 6b sethi %hi(0x4001ac00), %g2 400074c4: 03 10 00 6c sethi %hi(0x4001b000), %g1 400074c8: 82 10 63 68 or %g1, 0x368, %g1 ! 4001b368 <_POSIX_Objects> _POSIX_signals_Manager_Initialization( 400074cc: 40 00 16 22 call 4000cd54 <_POSIX_signals_Manager_Initialization> 400074d0: c2 20 a1 3c st %g1, [ %g2 + 0x13c ] api_configuration->maximum_queued_signals ); _POSIX_Threads_Manager_initialization( 400074d4: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 400074d8: d4 06 20 30 ld [ %i0 + 0x30 ], %o2 400074dc: 40 00 16 92 call 4000cf24 <_POSIX_Threads_Manager_initialization> 400074e0: 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( 400074e4: 40 00 15 ca call 4000cc0c <_POSIX_Condition_variables_Manager_initialization> 400074e8: d0 06 20 08 ld [ %i0 + 8 ], %o0 api_configuration->maximum_condition_variables ); _POSIX_Key_Manager_initialization( api_configuration->maximum_keys ); 400074ec: 40 00 15 d4 call 4000cc3c <_POSIX_Key_Manager_initialization> 400074f0: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _POSIX_Mutex_Manager_initialization( 400074f4: 40 00 15 f4 call 4000ccc4 <_POSIX_Mutex_Manager_initialization> 400074f8: d0 06 20 04 ld [ %i0 + 4 ], %o0 api_configuration->maximum_mutexes ); _POSIX_Message_queue_Manager_initialization( 400074fc: 40 00 15 dc call 4000cc6c <_POSIX_Message_queue_Manager_initialization> 40007500: d0 06 20 18 ld [ %i0 + 0x18 ], %o0 api_configuration->maximum_message_queues ); _POSIX_Semaphore_Manager_initialization( 40007504: 40 00 17 45 call 4000d218 <_POSIX_Semaphore_Manager_initialization> 40007508: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 api_configuration->maximum_semaphores ); _POSIX_Timer_Manager_initialization( api_configuration->maximum_timers ); 4000750c: 40 00 17 36 call 4000d1e4 <_POSIX_Timer_Manager_initialization> 40007510: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); 40007514: 40 00 15 f8 call 4000ccf4 <_POSIX_Barrier_Manager_initialization> 40007518: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); 4000751c: 40 00 16 02 call 4000cd24 <_POSIX_RWLock_Manager_initialization> 40007520: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 40007524: f0 06 20 28 ld [ %i0 + 0x28 ], %i0 40007528: 40 00 16 69 call 4000cecc <_POSIX_Spinlock_Manager_initialization> 4000752c: 81 e8 00 00 restore 40007530: 01 00 00 00 nop 4000e1dc <_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 ) 4000e1dc: 80 a2 20 03 cmp %o0, 3 4000e1e0: 08 80 00 05 bleu 4000e1f4 <_POSIX_Barrier_Translate_core_barrier_return_code+0x18> 4000e1e4: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_Barrier_Return_codes[the_barrier_status]; return POSIX_BOTTOM_REACHED(); 4000e1e8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 4000e1ec: 7f ff e3 29 call 40006e90 <== NOT EXECUTED 4000e1f0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED } 4000e1f4: 03 10 00 6a sethi %hi(0x4001a800), %g1 4000e1f8: 82 10 60 58 or %g1, 0x58, %g1 ! 4001a858 <_POSIX_Barrier_Return_codes> 4000e1fc: 81 c3 e0 08 retl 4000e200: d0 00 40 02 ld [ %g1 + %g2 ], %o0 4000720c <_POSIX_Condition_variables_Signal_support>: int _POSIX_Condition_variables_Signal_support( pthread_cond_t *cond, boolean is_broadcast ) { 4000720c: 9d e3 bf 90 save %sp, -112, %sp ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 40007210: 80 a6 20 00 cmp %i0, 0 40007214: 02 80 00 0d be 40007248 <_POSIX_Condition_variables_Signal_support+0x3c> 40007218: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 4000721c: c2 06 00 00 ld [ %i0 ], %g1 40007220: 80 a0 7f ff cmp %g1, -1 40007224: 32 80 00 0c bne,a 40007254 <_POSIX_Condition_variables_Signal_support+0x48> 40007228: d2 06 00 00 ld [ %i0 ], %o1 /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 4000722c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40007230: 7f ff ff ba call 40007118 <== NOT EXECUTED 40007234: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 40007238: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000723c: 22 80 00 06 be,a 40007254 <_POSIX_Condition_variables_Signal_support+0x48> <== NOT EXECUTED 40007240: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; 40007244: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40007248: a0 10 20 00 clr %l0 4000724c: 10 80 00 07 b 40007268 <_POSIX_Condition_variables_Signal_support+0x5c> 40007250: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 40007254: 11 10 00 66 sethi %hi(0x40019800), %o0 40007258: 94 07 bf f4 add %fp, -12, %o2 4000725c: 40 00 0e b9 call 4000ad40 <_Objects_Get> 40007260: 90 12 20 2c or %o0, 0x2c, %o0 40007264: a0 10 00 08 mov %o0, %l0 register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; Thread_Control *the_thread; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 40007268: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000726c: 80 a0 60 00 cmp %g1, 0 40007270: 02 80 00 06 be 40007288 <_POSIX_Condition_variables_Signal_support+0x7c> 40007274: b0 04 20 18 add %l0, 0x18, %i0 40007278: 80 a0 60 02 cmp %g1, 2 4000727c: 08 80 00 1c bleu 400072ec <_POSIX_Condition_variables_Signal_support+0xe0> 40007280: 90 10 20 16 mov 0x16, %o0 40007284: 30 80 00 18 b,a 400072e4 <_POSIX_Condition_variables_Signal_support+0xd8> <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); 40007288: 40 00 14 5d call 4000c3fc <_Thread_queue_Dequeue> 4000728c: 90 10 00 18 mov %i0, %o0 if ( !the_thread ) 40007290: 80 a2 20 00 cmp %o0, 0 40007294: 22 80 00 02 be,a 4000729c <_POSIX_Condition_variables_Signal_support+0x90> 40007298: c0 24 20 14 clr [ %l0 + 0x14 ] the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; } while ( is_broadcast && the_thread ); 4000729c: 80 a6 60 00 cmp %i1, 0 400072a0: 02 80 00 04 be 400072b0 <_POSIX_Condition_variables_Signal_support+0xa4> 400072a4: 80 a2 20 00 cmp %o0, 0 400072a8: 12 bf ff f8 bne 40007288 <_POSIX_Condition_variables_Signal_support+0x7c> 400072ac: 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 ) 400072b0: 03 10 00 64 sethi %hi(0x40019000), %g1 400072b4: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 400192e0 <_Thread_Dispatch_disable_level> 400072b8: 90 10 20 00 clr %o0 400072bc: 84 00 bf ff add %g2, -1, %g2 400072c0: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ] 400072c4: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 400072c8: 80 a0 60 00 cmp %g1, 0 400072cc: 12 80 00 08 bne 400072ec <_POSIX_Condition_variables_Signal_support+0xe0> 400072d0: 01 00 00 00 nop _Thread_Dispatch(); 400072d4: 40 00 13 50 call 4000c014 <_Thread_Dispatch> 400072d8: 01 00 00 00 nop 400072dc: 10 80 00 04 b 400072ec <_POSIX_Condition_variables_Signal_support+0xe0> 400072e0: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400072e4: 40 00 04 47 call 40008400 <== NOT EXECUTED 400072e8: 01 00 00 00 nop <== NOT EXECUTED } 400072ec: 81 c7 e0 08 ret 400072f0: 91 e8 00 08 restore %g0, %o0, %o0 4000738c <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, boolean already_timedout ) { 4000738c: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40007390: 80 a6 60 00 cmp %i1, 0 40007394: 22 80 00 40 be,a 40007494 <_POSIX_Condition_variables_Wait_support+0x108> 40007398: b0 10 20 16 mov 0x16, %i0 4000739c: c2 06 40 00 ld [ %i1 ], %g1 400073a0: 80 a0 7f ff cmp %g1, -1 400073a4: 32 80 00 09 bne,a 400073c8 <_POSIX_Condition_variables_Wait_support+0x3c> 400073a8: d2 06 40 00 ld [ %i1 ], %o1 400073ac: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 400073b0: 40 00 00 c2 call 400076b8 <== NOT EXECUTED 400073b4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400073b8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400073bc: 32 80 00 36 bne,a 40007494 <_POSIX_Condition_variables_Wait_support+0x108> <== NOT EXECUTED 400073c0: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED return (POSIX_Mutex_Control *) 400073c4: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED 400073c8: 11 10 00 65 sethi %hi(0x40019400), %o0 400073cc: 94 07 bf f4 add %fp, -12, %o2 400073d0: 40 00 0e 5c call 4000ad40 <_Objects_Get> 400073d4: 90 12 23 44 or %o0, 0x344, %o0 register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 400073d8: 80 a2 20 00 cmp %o0, 0 400073dc: 22 80 00 2e be,a 40007494 <_POSIX_Condition_variables_Wait_support+0x108> 400073e0: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 400073e4: 05 10 00 64 sethi %hi(0x40019000), %g2 400073e8: c2 00 a2 e0 ld [ %g2 + 0x2e0 ], %g1 ! 400192e0 <_Thread_Dispatch_disable_level> ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 400073ec: 80 a6 20 00 cmp %i0, 0 400073f0: 82 00 7f ff add %g1, -1, %g1 400073f4: c2 20 a2 e0 st %g1, [ %g2 + 0x2e0 ] 400073f8: 02 80 00 0d be 4000742c <_POSIX_Condition_variables_Wait_support+0xa0> 400073fc: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 40007400: c2 06 00 00 ld [ %i0 ], %g1 40007404: 80 a0 7f ff cmp %g1, -1 40007408: 32 80 00 0c bne,a 40007438 <_POSIX_Condition_variables_Wait_support+0xac> 4000740c: d2 06 00 00 ld [ %i0 ], %o1 /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 40007410: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40007414: 7f ff ff 41 call 40007118 <== NOT EXECUTED 40007418: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 4000741c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007420: 22 80 00 06 be,a 40007438 <_POSIX_Condition_variables_Wait_support+0xac> <== NOT EXECUTED 40007424: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; 40007428: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 4000742c: a2 10 20 00 clr %l1 40007430: 10 80 00 07 b 4000744c <_POSIX_Condition_variables_Wait_support+0xc0> 40007434: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 40007438: 11 10 00 66 sethi %hi(0x40019800), %o0 4000743c: 94 07 bf f4 add %fp, -12, %o2 40007440: 40 00 0e 40 call 4000ad40 <_Objects_Get> 40007444: 90 12 20 2c or %o0, 0x2c, %o0 40007448: a2 10 00 08 mov %o0, %l1 } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 4000744c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007450: 80 a0 60 00 cmp %g1, 0 40007454: 22 80 00 07 be,a 40007470 <_POSIX_Condition_variables_Wait_support+0xe4> 40007458: c4 04 60 14 ld [ %l1 + 0x14 ], %g2 4000745c: 80 a0 60 02 cmp %g1, 2 40007460: 18 80 00 36 bgu 40007538 <_POSIX_Condition_variables_Wait_support+0x1ac> 40007464: 01 00 00 00 nop if ( mutex_status ) return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); 40007468: 81 c7 e0 08 ret 4000746c: 91 e8 20 16 restore %g0, 0x16, %o0 #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { 40007470: 80 a0 a0 00 cmp %g2, 0 40007474: 02 80 00 0a be 4000749c <_POSIX_Condition_variables_Wait_support+0x110> 40007478: 01 00 00 00 nop 4000747c: c2 06 40 00 ld [ %i1 ], %g1 40007480: 80 a0 80 01 cmp %g2, %g1 40007484: 02 80 00 06 be 4000749c <_POSIX_Condition_variables_Wait_support+0x110> 40007488: 01 00 00 00 nop _Thread_Enable_dispatch(); 4000748c: 7f ff ff b3 call 40007358 <_Thread_Enable_dispatch> <== NOT EXECUTED 40007490: b0 10 20 16 mov 0x16, %i0 ! 16 <== NOT EXECUTED 40007494: 81 c7 e0 08 ret 40007498: 81 e8 00 00 restore return EINVAL; } (void) pthread_mutex_unlock( mutex ); 4000749c: 40 00 01 95 call 40007af0 400074a0: 90 10 00 19 mov %i1, %o0 _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 400074a4: 80 a6 e0 00 cmp %i3, 0 400074a8: 12 80 00 1b bne 40007514 <_POSIX_Condition_variables_Wait_support+0x188> 400074ac: 21 10 00 64 sethi %hi(0x40019000), %l0 the_cond->Mutex = *mutex; 400074b0: c2 06 40 00 ld [ %i1 ], %g1 400074b4: c2 24 60 14 st %g1, [ %l1 + 0x14 ] _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 400074b8: c2 04 23 bc ld [ %l0 + 0x3bc ], %g1 _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; 400074bc: c6 06 00 00 ld [ %i0 ], %g3 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; 400074c0: 84 04 60 18 add %l1, 0x18, %g2 _Thread_Executing->Wait.id = *cond; 400074c4: c6 20 60 20 st %g3, [ %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; 400074c8: c4 20 60 44 st %g2, [ %g1 + 0x44 ] _Thread_Executing->Wait.id = *cond; _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 400074cc: 92 10 00 1a mov %i2, %o1 400074d0: 90 10 00 02 mov %g2, %o0 if ( !already_timedout ) { the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 400074d4: c0 20 60 34 clr [ %g1 + 0x34 ] _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 400074d8: 15 10 00 32 sethi %hi(0x4000c800), %o2 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 400074dc: 82 10 20 01 mov 1, %g1 400074e0: 94 12 a2 d4 or %o2, 0x2d4, %o2 400074e4: 40 00 14 34 call 4000c5b4 <_Thread_queue_Enqueue_with_handler> 400074e8: c2 24 60 48 st %g1, [ %l1 + 0x48 ] _Thread_Enable_dispatch(); 400074ec: 7f ff ff 9b call 40007358 <_Thread_Enable_dispatch> 400074f0: 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; 400074f4: c2 04 23 bc ld [ %l0 + 0x3bc ], %g1 400074f8: f0 00 60 34 ld [ %g1 + 0x34 ], %i0 if ( status && status != ETIMEDOUT ) 400074fc: 80 a6 20 00 cmp %i0, 0 40007500: 02 80 00 07 be 4000751c <_POSIX_Condition_variables_Wait_support+0x190> 40007504: 80 a6 20 74 cmp %i0, 0x74 40007508: 12 80 00 0f bne 40007544 <_POSIX_Condition_variables_Wait_support+0x1b8> 4000750c: 01 00 00 00 nop 40007510: 30 80 00 03 b,a 4000751c <_POSIX_Condition_variables_Wait_support+0x190> return status; } else { _Thread_Enable_dispatch(); 40007514: 7f ff ff 91 call 40007358 <_Thread_Enable_dispatch> 40007518: b0 10 20 74 mov 0x74, %i0 /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 4000751c: 40 00 00 c7 call 40007838 40007520: 90 10 00 19 mov %i1, %o0 if ( mutex_status ) 40007524: 80 a2 20 00 cmp %o0, 0 40007528: 02 80 00 07 be 40007544 <_POSIX_Condition_variables_Wait_support+0x1b8> 4000752c: 01 00 00 00 nop return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); 40007530: 81 c7 e0 08 ret 40007534: 91 e8 20 16 restore %g0, 0x16, %o0 40007538: 40 00 03 b2 call 40008400 <== NOT EXECUTED 4000753c: 01 00 00 00 nop <== NOT EXECUTED 40007540: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED } 40007544: 81 c7 e0 08 ret 40007548: 81 e8 00 00 restore 4000e674 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 4000e674: 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 ); 4000e678: 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 ]; 4000e67c: 05 00 00 3f sethi %hi(0xfc00), %g2 4000e680: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000e684: 84 08 40 02 and %g1, %g2, %g2 */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 4000e688: 83 30 60 16 srl %g1, 0x16, %g1 4000e68c: a7 28 a0 02 sll %g2, 2, %l3 4000e690: a8 08 60 1c and %g1, 0x1c, %l4 4000e694: a4 10 20 00 clr %l2 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 4000e698: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000e69c: aa 10 62 d0 or %g1, 0x2d0, %l5 ! 4001b2d0 <_POSIX_Keys_Information> 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 ]; 4000e6a0: a0 10 20 01 mov 1, %l0 4000e6a4: 10 80 00 1b b 4000e710 <_POSIX_Keys_Run_destructors+0x9c> 4000e6a8: a2 10 20 01 mov 1, %l1 are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { the_key = (POSIX_Keys_Control *) 4000e6ac: c2 05 60 20 ld [ %l5 + 0x20 ], %g1 4000e6b0: c4 00 40 02 ld [ %g1 + %g2 ], %g2 _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { 4000e6b4: 80 a0 a0 00 cmp %g2, 0 4000e6b8: 02 80 00 16 be 4000e710 <_POSIX_Keys_Run_destructors+0x9c> 4000e6bc: a0 04 20 01 inc %l0 4000e6c0: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 4000e6c4: 80 a0 60 00 cmp %g1, 0 4000e6c8: 02 80 00 12 be 4000e710 <_POSIX_Keys_Run_destructors+0x9c> 4000e6cc: b0 05 00 02 add %l4, %g2, %i0 4000e6d0: c4 00 a0 14 ld [ %g2 + 0x14 ], %g2 4000e6d4: 80 a0 a0 00 cmp %g2, 0 4000e6d8: 22 80 00 0f be,a 4000e714 <_POSIX_Keys_Run_destructors+0xa0> 4000e6dc: c2 15 60 10 lduh [ %l5 + 0x10 ], %g1 <== NOT EXECUTED value = the_key->Values[ thread_api ][ thread_index ]; 4000e6e0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 4000e6e4: c2 00 40 13 ld [ %g1 + %l3 ], %g1 if ( value ) { 4000e6e8: 90 90 60 00 orcc %g1, 0, %o0 4000e6ec: 22 80 00 0a be,a 4000e714 <_POSIX_Keys_Run_destructors+0xa0> 4000e6f0: c2 15 60 10 lduh [ %l5 + 0x10 ], %g1 <== NOT EXECUTED (*the_key->destructor)( value ); 4000e6f4: 9f c0 80 00 call %g2 4000e6f8: 01 00 00 00 nop if ( the_key->Values[ thread_api ][ thread_index ] ) 4000e6fc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 4000e700: c2 00 40 13 ld [ %g1 + %l3 ], %g1 4000e704: 80 a0 00 01 cmp %g0, %g1 4000e708: 82 40 3f ff addx %g0, -1, %g1 4000e70c: a2 0c 40 01 and %l1, %g1, %l1 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 4000e710: c2 15 60 10 lduh [ %l5 + 0x10 ], %g1 4000e714: 80 a4 00 01 cmp %l0, %g1 4000e718: 08 bf ff e5 bleu 4000e6ac <_POSIX_Keys_Run_destructors+0x38> 4000e71c: 85 2c 20 02 sll %l0, 2, %g2 are_all_null = FALSE; } } } if ( are_all_null == TRUE ) 4000e720: 80 a4 60 01 cmp %l1, 1 4000e724: 02 80 00 05 be 4000e738 <_POSIX_Keys_Run_destructors+0xc4> 4000e728: a4 04 a0 01 inc %l2 * 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 ) 4000e72c: 80 a4 a0 04 cmp %l2, 4 4000e730: 12 bf ff dd bne 4000e6a4 <_POSIX_Keys_Run_destructors+0x30> 4000e734: a0 10 20 01 mov 1, %l0 4000e738: 81 c7 e0 08 ret 4000e73c: 81 e8 00 00 restore 400137e8 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 400137e8: 9d e3 bf 88 save %sp, -120, %sp CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 400137ec: 92 10 20 ff mov 0xff, %o1 400137f0: 40 00 11 a9 call 40017e94 400137f4: 90 10 00 18 mov %i0, %o0 const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 400137f8: a8 10 00 18 mov %i0, %l4 CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 400137fc: a0 10 00 08 mov %o0, %l0 const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 40013800: 92 10 00 1a mov %i2, %o1 struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); if ( n > NAME_MAX ) 40013804: 80 a2 20 ff cmp %o0, 0xff 40013808: 18 80 00 62 bgu 40013990 <_POSIX_Message_queue_Create_support+0x1a8> 4001380c: b0 10 20 5b mov 0x5b, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40013810: 05 10 00 97 sethi %hi(0x40025c00), %g2 40013814: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 ! 40025c40 <_Thread_Dispatch_disable_level> 40013818: 82 00 60 01 inc %g1 4001381c: c2 20 a0 40 st %g1, [ %g2 + 0x40 ] * 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 ) { 40013820: a4 10 20 10 mov 0x10, %l2 40013824: 80 a6 a0 00 cmp %i2, 0 40013828: 02 80 00 14 be 40013878 <_POSIX_Message_queue_Create_support+0x90> 4001382c: a2 10 20 0a mov 0xa, %l1 attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 40013830: c2 06 a0 04 ld [ %i2 + 4 ], %g1 40013834: 80 a0 60 00 cmp %g1, 0 40013838: 04 80 00 06 ble 40013850 <_POSIX_Message_queue_Create_support+0x68> 4001383c: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 40013840: c2 06 a0 08 ld [ %i2 + 8 ], %g1 40013844: 80 a0 60 00 cmp %g1, 0 40013848: 34 80 00 08 bg,a 40013868 <_POSIX_Message_queue_Create_support+0x80> 4001384c: 90 07 bf e8 add %fp, -24, %o0 _Thread_Enable_dispatch(); 40013850: 7f ff ff d9 call 400137b4 <_Thread_Enable_dispatch> 40013854: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); 40013858: 40 00 0a 46 call 40016170 <__errno> 4001385c: 01 00 00 00 nop 40013860: 10 80 00 3a b 40013948 <_POSIX_Message_queue_Create_support+0x160> 40013864: 82 10 20 16 mov 0x16, %g1 ! 16 } attr = *attr_ptr; 40013868: 40 00 0c 28 call 40016908 4001386c: 94 10 20 10 mov 0x10, %o2 40013870: e4 07 bf f0 ld [ %fp + -16 ], %l2 40013874: e2 07 bf ec ld [ %fp + -20 ], %l1 */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void ) { return (POSIX_Message_queue_Control *) 40013878: 27 10 00 98 sethi %hi(0x40026000), %l3 4001387c: 7f ff ec c2 call 4000eb84 <_Objects_Allocate> 40013880: 90 14 e0 58 or %l3, 0x58, %o0 ! 40026058 <_POSIX_Message_queue_Information> rtems_set_errno_and_return_minus_one( ENFILE ); } #endif the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 40013884: b4 92 20 00 orcc %o0, 0, %i2 40013888: 32 80 00 08 bne,a 400138a8 <_POSIX_Message_queue_Create_support+0xc0> 4001388c: 82 10 20 01 mov 1, %g1 _Thread_Enable_dispatch(); 40013890: 7f ff ff c9 call 400137b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 40013894: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENFILE ); 40013898: 40 00 0a 36 call 40016170 <__errno> <== NOT EXECUTED 4001389c: 01 00 00 00 nop <== NOT EXECUTED 400138a0: 10 80 00 2a b 40013948 <_POSIX_Message_queue_Create_support+0x160> <== NOT EXECUTED 400138a4: 82 10 20 17 mov 0x17, %g1 ! 17 <== NOT EXECUTED } the_mq->process_shared = pshared; 400138a8: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] 400138ac: 92 10 00 10 mov %l0, %o1 the_mq->named = TRUE; the_mq->open_count = 1; the_mq->linked = TRUE; 400138b0: c2 26 a0 18 st %g1, [ %i2 + 0x18 ] _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; the_mq->named = TRUE; 400138b4: c2 26 a0 14 st %g1, [ %i2 + 0x14 ] the_mq->open_count = 1; 400138b8: c2 26 a0 1c st %g1, [ %i2 + 0x1c ] 400138bc: 21 10 00 97 sethi %hi(0x40025c00), %l0 400138c0: 7f ff eb 59 call 4000e624 <_Heap_Allocate> 400138c4: 90 14 20 8c or %l0, 0x8c, %o0 ! 40025c8c <_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) { 400138c8: b2 92 20 00 orcc %o0, 0, %i1 400138cc: 12 80 00 0a bne 400138f4 <_POSIX_Message_queue_Create_support+0x10c> 400138d0: 01 00 00 00 nop _POSIX_Message_queue_Free( the_mq ); 400138d4: 7f ff ff b1 call 40013798 <_POSIX_Message_queue_Free> <== NOT EXECUTED 400138d8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); 400138dc: 7f ff ff b6 call 400137b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 400138e0: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 400138e4: 40 00 0a 23 call 40016170 <__errno> <== NOT EXECUTED 400138e8: 01 00 00 00 nop <== NOT EXECUTED 400138ec: 10 80 00 17 b 40013948 <_POSIX_Message_queue_Create_support+0x160> <== NOT EXECUTED 400138f0: 82 10 20 0c mov 0xc, %g1 ! c <== NOT EXECUTED } strcpy( name, name_arg ); 400138f4: 40 00 0f 03 call 40017500 400138f8: 92 10 00 14 mov %l4, %o1 */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 400138fc: 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; 40013900: c0 26 a0 60 clr [ %i2 + 0x60 ] if ( ! _CORE_message_queue_Initialize( 40013904: 96 10 00 12 mov %l2, %o3 40013908: 90 06 a0 20 add %i2, 0x20, %o0 4001390c: 40 00 03 56 call 40014664 <_CORE_message_queue_Initialize> 40013910: 92 06 a0 60 add %i2, 0x60, %o1 40013914: 80 a2 20 00 cmp %o0, 0 40013918: 12 80 00 0f bne 40013954 <_POSIX_Message_queue_Create_support+0x16c> 4001391c: 90 14 e0 58 or %l3, 0x58, %o0 #if 0 && defined(RTEMS_MULTIPROCESSING) if ( pshared == PTHREAD_PROCESS_SHARED ) _Objects_MP_Close( &_POSIX_Message_queue_Information, the_mq->Object.id ); #endif _POSIX_Message_queue_Free( the_mq ); 40013920: 7f ff ff 9e call 40013798 <_POSIX_Message_queue_Free> <== NOT EXECUTED 40013924: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 40013928: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001392c: 7f ff eb 65 call 4000e6c0 <_Heap_Free> <== NOT EXECUTED 40013930: 90 14 20 8c or %l0, 0x8c, %o0 <== NOT EXECUTED _Workspace_Free(name); _Thread_Enable_dispatch(); 40013934: 7f ff ff a0 call 400137b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 40013938: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 4001393c: 40 00 0a 0d call 40016170 <__errno> <== NOT EXECUTED 40013940: 01 00 00 00 nop <== NOT EXECUTED 40013944: 82 10 20 1c mov 0x1c, %g1 ! 1c <== NOT EXECUTED 40013948: c2 22 00 00 st %g1, [ %o0 ] 4001394c: 81 c7 e0 08 ret 40013950: 91 e8 3f ff restore %g0, -1, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40013954: c2 06 a0 08 ld [ %i2 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40013958: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4001395c: 05 00 00 3f sethi %hi(0xfc00), %g2 40013960: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40013964: 82 08 40 02 and %g1, %g2, %g1 40013968: 80 a0 40 03 cmp %g1, %g3 4001396c: 38 80 00 06 bgu,a 40013984 <_POSIX_Message_queue_Create_support+0x19c> 40013970: f4 26 c0 00 st %i2, [ %i3 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40013974: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40013978: 83 28 60 02 sll %g1, 2, %g1 4001397c: f4 20 80 01 st %i2, [ %g2 + %g1 ] &_POSIX_Message_queue_Information, &the_mq->Object, (char *) name ); *message_queue = the_mq; 40013980: f4 26 c0 00 st %i2, [ %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; 40013984: f2 26 a0 0c st %i1, [ %i2 + 0xc ] (char *) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 40013988: 7f ff ff 8b call 400137b4 <_Thread_Enable_dispatch> 4001398c: b0 10 20 00 clr %i0 return 0; } 40013990: 81 c7 e0 08 ret 40013994: 81 e8 00 00 restore 4000a7d0 <_POSIX_Message_queue_Delete>: */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq ) { 4000a7d0: 9d e3 bf 98 save %sp, -104, %sp if ( !the_mq->linked && !the_mq->open_count ) { 4000a7d4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 4000a7d8: 80 a0 60 00 cmp %g1, 0 4000a7dc: 12 80 00 1f bne 4000a858 <_POSIX_Message_queue_Delete+0x88> 4000a7e0: b2 10 00 18 mov %i0, %i1 4000a7e4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 4000a7e8: 80 a0 60 00 cmp %g1, 0 4000a7ec: 12 80 00 1b bne 4000a858 <_POSIX_Message_queue_Delete+0x88> 4000a7f0: 01 00 00 00 nop /* the name memory may have been freed by unlink. */ if ( the_mq->Object.name ) 4000a7f4: d2 06 20 0c ld [ %i0 + 0xc ], %o1 4000a7f8: 80 a2 60 00 cmp %o1, 0 4000a7fc: 02 80 00 04 be 4000a80c <_POSIX_Message_queue_Delete+0x3c> 4000a800: 11 10 00 97 sethi %hi(0x40025c00), %o0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4000a804: 40 00 0f af call 4000e6c0 <_Heap_Free> <== NOT EXECUTED 4000a808: 90 12 20 8c or %o0, 0x8c, %o0 ! 40025c8c <_Workspace_Area> <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000a80c: 03 10 00 98 sethi %hi(0x40026000), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000a810: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000a814: b0 10 60 58 or %g1, 0x58, %i0 4000a818: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 4000a81c: 03 00 00 3f sethi %hi(0xfc00), %g1 4000a820: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000a824: 82 08 c0 01 and %g3, %g1, %g1 4000a828: 80 a0 40 02 cmp %g1, %g2 4000a82c: 18 80 00 05 bgu 4000a840 <_POSIX_Message_queue_Delete+0x70> 4000a830: 90 06 60 20 add %i1, 0x20, %o0 information->local_table[ index ] = the_object; 4000a834: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 4000a838: 83 28 60 02 sll %g1, 2, %g1 4000a83c: 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( 4000a840: 92 10 20 00 clr %o1 4000a844: 94 10 20 05 mov 5, %o2 4000a848: 40 00 0d 7b call 4000de34 <_CORE_message_queue_Close> 4000a84c: 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 ); 4000a850: 40 00 11 cf call 4000ef8c <_Objects_Free> 4000a854: 81 e8 00 00 restore 4000a858: 81 c7 e0 08 ret 4000a85c: 81 e8 00 00 restore 40013798 <_POSIX_Message_queue_Free>: */ RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free ( POSIX_Message_queue_Control *the_mq ) { 40013798: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object ); 4001379c: 11 10 00 98 sethi %hi(0x40026000), %o0 <== NOT EXECUTED 400137a0: 90 12 20 58 or %o0, 0x58, %o0 ! 40026058 <_POSIX_Message_queue_Information> <== NOT EXECUTED 400137a4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 400137a8: 7f ff ed f9 call 4000ef8c <_Objects_Free> <== NOT EXECUTED 400137ac: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 400137b0: 01 00 00 00 nop 4000ad00 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, boolean wait, Watchdog_Interval timeout ) { 4000ad00: 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 *) 4000ad04: 11 10 00 98 sethi %hi(0x40026000), %o0 4000ad08: 94 07 bf f4 add %fp, -12, %o2 4000ad0c: 90 12 22 10 or %o0, 0x210, %o0 4000ad10: 40 00 10 e1 call 4000f094 <_Objects_Get> 4000ad14: 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 ) { 4000ad18: c2 07 bf f4 ld [ %fp + -12 ], %g1 size_t msg_len, unsigned int *msg_prio, boolean wait, Watchdog_Interval timeout ) { 4000ad1c: 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 ) { 4000ad20: 80 a0 60 01 cmp %g1, 1 4000ad24: 02 80 00 09 be 4000ad48 <_POSIX_Message_queue_Receive_support+0x48> 4000ad28: 9a 10 00 1d mov %i5, %o5 4000ad2c: 80 a0 60 01 cmp %g1, 1 4000ad30: 2a 80 00 0c bcs,a 4000ad60 <_POSIX_Message_queue_Receive_support+0x60> 4000ad34: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 4000ad38: 80 a0 60 02 cmp %g1, 2 4000ad3c: 12 80 00 3f bne 4000ae38 <_POSIX_Message_queue_Receive_support+0x138> 4000ad40: 01 00 00 00 nop 4000ad44: 30 80 00 0d b,a 4000ad78 <_POSIX_Message_queue_Receive_support+0x78> case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 4000ad48: 40 00 15 88 call 40010368 <_Thread_Dispatch> <== NOT EXECUTED 4000ad4c: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000ad50: 40 00 05 c9 call 4000c474 <== NOT EXECUTED 4000ad54: 01 00 00 00 nop <== NOT EXECUTED _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); } 4000ad58: 81 c7 e0 08 ret <== NOT EXECUTED 4000ad5c: 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: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 4000ad60: 82 08 a0 03 and %g2, 3, %g1 4000ad64: 80 a0 60 01 cmp %g1, 1 4000ad68: 32 80 00 0a bne,a 4000ad90 <_POSIX_Message_queue_Receive_support+0x90> 4000ad6c: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 _Thread_Enable_dispatch(); 4000ad70: 7f ff ff d7 call 4000accc <_Thread_Enable_dispatch> 4000ad74: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EBADF ); 4000ad78: 40 00 2c fe call 40016170 <__errno> 4000ad7c: 01 00 00 00 nop 4000ad80: 82 10 20 09 mov 9, %g1 ! 9 4000ad84: c2 22 00 00 st %g1, [ %o0 ] 4000ad88: 10 80 00 2e b 4000ae40 <_POSIX_Message_queue_Receive_support+0x140> 4000ad8c: 90 10 3f ff mov -1, %o0 } the_mq = the_mq_fd->Queue; if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 4000ad90: c2 02 20 6c ld [ %o0 + 0x6c ], %g1 4000ad94: 80 a6 80 01 cmp %i2, %g1 4000ad98: 1a 80 00 08 bcc 4000adb8 <_POSIX_Message_queue_Receive_support+0xb8> 4000ad9c: 80 a7 20 00 cmp %i4, 0 _Thread_Enable_dispatch(); 4000ada0: 7f ff ff cb call 4000accc <_Thread_Enable_dispatch> 4000ada4: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EMSGSIZE ); 4000ada8: 40 00 2c f2 call 40016170 <__errno> 4000adac: 01 00 00 00 nop 4000adb0: 10 bf ff f5 b 4000ad84 <_POSIX_Message_queue_Receive_support+0x84> 4000adb4: 82 10 20 7a mov 0x7a, %g1 ! 7a length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 4000adb8: 02 80 00 05 be 4000adcc <_POSIX_Message_queue_Receive_support+0xcc> 4000adbc: 98 10 20 00 clr %o4 do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 4000adc0: 83 30 a0 0e srl %g2, 0xe, %g1 4000adc4: 82 18 60 01 xor %g1, 1, %g1 4000adc8: 98 08 60 01 and %g1, 1, %o4 /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 4000adcc: 82 10 3f ff mov -1, %g1 do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 4000add0: 90 02 20 20 add %o0, 0x20, %o0 4000add4: 92 10 00 18 mov %i0, %o1 4000add8: 96 07 bf f0 add %fp, -16, %o3 4000addc: 40 00 0c 43 call 4000dee8 <_CORE_message_queue_Seize> 4000ade0: c2 27 bf f0 st %g1, [ %fp + -16 ] &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 4000ade4: 7f ff ff ba call 4000accc <_Thread_Enable_dispatch> 4000ade8: 3b 10 00 97 sethi %hi(0x40025c00), %i5 *msg_prio = 4000adec: c4 07 61 1c ld [ %i5 + 0x11c ], %g2 ! 40025d1c <_Thread_Executing> 4000adf0: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 4000adf4: c6 00 a0 34 ld [ %g2 + 0x34 ], %g3 do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 4000adf8: 85 38 60 1f sra %g1, 0x1f, %g2 4000adfc: 82 18 80 01 xor %g2, %g1, %g1 4000ae00: 82 20 40 02 sub %g1, %g2, %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 4000ae04: 80 a0 e0 00 cmp %g3, 0 4000ae08: 12 80 00 04 bne 4000ae18 <_POSIX_Message_queue_Receive_support+0x118> 4000ae0c: c2 26 c0 00 st %g1, [ %i3 ] return length_out; 4000ae10: 10 80 00 0c b 4000ae40 <_POSIX_Message_queue_Receive_support+0x140> 4000ae14: d0 07 bf f0 ld [ %fp + -16 ], %o0 rtems_set_errno_and_return_minus_one( 4000ae18: 40 00 2c d6 call 40016170 <__errno> 4000ae1c: 01 00 00 00 nop 4000ae20: c2 07 61 1c ld [ %i5 + 0x11c ], %g1 4000ae24: a0 10 00 08 mov %o0, %l0 4000ae28: 40 00 00 d2 call 4000b170 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 4000ae2c: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 4000ae30: 10 bf ff d6 b 4000ad88 <_POSIX_Message_queue_Receive_support+0x88> 4000ae34: d0 24 00 00 st %o0, [ %l0 ] _POSIX_Message_queue_Translate_core_message_queue_return_code( _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); 4000ae38: 40 00 05 85 call 4000c44c <== NOT EXECUTED 4000ae3c: 01 00 00 00 nop <== NOT EXECUTED } 4000ae40: b0 10 00 08 mov %o0, %i0 4000ae44: 81 c7 e0 08 ret 4000ae48: 81 e8 00 00 restore 4000ae98 <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, boolean wait, Watchdog_Interval timeout ) { 4000ae98: 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 ) 4000ae9c: 80 a6 e0 20 cmp %i3, 0x20 4000aea0: 28 80 00 06 bleu,a 4000aeb8 <_POSIX_Message_queue_Send_support+0x20> 4000aea4: 11 10 00 98 sethi %hi(0x40026000), %o0 rtems_set_errno_and_return_minus_one( EINVAL ); 4000aea8: 40 00 2c b2 call 40016170 <__errno> 4000aeac: 01 00 00 00 nop 4000aeb0: 10 80 00 12 b 4000aef8 <_POSIX_Message_queue_Send_support+0x60> 4000aeb4: 82 10 20 16 mov 0x16, %g1 ! 16 4000aeb8: 92 10 00 18 mov %i0, %o1 4000aebc: 90 12 22 10 or %o0, 0x210, %o0 4000aec0: 40 00 10 75 call 4000f094 <_Objects_Get> 4000aec4: 94 07 bf f4 add %fp, -12, %o2 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 4000aec8: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000aecc: 80 a0 60 01 cmp %g1, 1 4000aed0: 02 80 00 0d be 4000af04 <_POSIX_Message_queue_Send_support+0x6c> 4000aed4: 01 00 00 00 nop 4000aed8: 2a 80 00 11 bcs,a 4000af1c <_POSIX_Message_queue_Send_support+0x84> 4000aedc: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 4000aee0: 80 a0 60 02 cmp %g1, 2 4000aee4: 12 80 00 35 bne 4000afb8 <_POSIX_Message_queue_Send_support+0x120> 4000aee8: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 4000aeec: 40 00 2c a1 call 40016170 <__errno> 4000aef0: 01 00 00 00 nop 4000aef4: 82 10 20 09 mov 9, %g1 ! 9 4000aef8: c2 22 00 00 st %g1, [ %o0 ] 4000aefc: 10 80 00 31 b 4000afc0 <_POSIX_Message_queue_Send_support+0x128> 4000af00: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 4000af04: 40 00 15 19 call 40010368 <_Thread_Dispatch> <== NOT EXECUTED 4000af08: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000af0c: 40 00 05 5a call 4000c474 <== NOT EXECUTED 4000af10: 01 00 00 00 nop <== NOT EXECUTED msg_status ) ); } return POSIX_BOTTOM_REACHED(); } 4000af14: 81 c7 e0 08 ret <== NOT EXECUTED 4000af18: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _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 ) { 4000af1c: 80 88 a0 03 btst 3, %g2 4000af20: 12 80 00 05 bne 4000af34 <_POSIX_Message_queue_Send_support+0x9c> 4000af24: 80 a7 20 00 cmp %i4, 0 _Thread_Enable_dispatch(); 4000af28: 7f ff ff cf call 4000ae64 <_Thread_Enable_dispatch> 4000af2c: 01 00 00 00 nop 4000af30: 30 bf ff ef b,a 4000aeec <_POSIX_Message_queue_Send_support+0x54> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 4000af34: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 4000af38: 02 80 00 05 be 4000af4c <_POSIX_Message_queue_Send_support+0xb4> 4000af3c: 82 10 20 00 clr %g1 do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 4000af40: 83 30 a0 0e srl %g2, 0xe, %g1 4000af44: 82 18 60 01 xor %g1, 1, %g1 4000af48: 82 08 60 01 and %g1, 1, %g1 do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 4000af4c: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 4000af50: fa 23 a0 60 st %i5, [ %sp + 0x60 ] 4000af54: 92 10 00 19 mov %i1, %o1 4000af58: 94 10 00 1a mov %i2, %o2 4000af5c: 96 10 00 18 mov %i0, %o3 4000af60: 9a 20 00 1b neg %i3, %o5 4000af64: 98 10 20 00 clr %o4 4000af68: 40 00 0c 2d call 4000e01c <_CORE_message_queue_Submit> 4000af6c: 90 02 20 20 add %o0, 0x20, %o0 _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout /* no timeout */ ); _Thread_Enable_dispatch(); 4000af70: 7f ff ff bd call 4000ae64 <_Thread_Enable_dispatch> 4000af74: ba 10 00 08 mov %o0, %i5 * after it wakes up. The returned status is correct for * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) 4000af78: 80 a7 60 07 cmp %i5, 7 4000af7c: 12 80 00 06 bne 4000af94 <_POSIX_Message_queue_Send_support+0xfc> 4000af80: 80 a7 60 00 cmp %i5, 0 msg_status = _Thread_Executing->Wait.return_code; 4000af84: 03 10 00 97 sethi %hi(0x40025c00), %g1 4000af88: c2 00 61 1c ld [ %g1 + 0x11c ], %g1 ! 40025d1c <_Thread_Executing> 4000af8c: fa 00 60 34 ld [ %g1 + 0x34 ], %i5 if ( !msg_status ) 4000af90: 80 a7 60 00 cmp %i5, 0 4000af94: 02 80 00 0b be 4000afc0 <_POSIX_Message_queue_Send_support+0x128> 4000af98: 90 10 20 00 clr %o0 return msg_status; rtems_set_errno_and_return_minus_one( 4000af9c: 40 00 2c 75 call 40016170 <__errno> 4000afa0: 01 00 00 00 nop 4000afa4: a0 10 00 08 mov %o0, %l0 4000afa8: 40 00 00 72 call 4000b170 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 4000afac: 90 10 00 1d mov %i5, %o0 4000afb0: 10 bf ff d3 b 4000aefc <_POSIX_Message_queue_Send_support+0x64> 4000afb4: d0 24 00 00 st %o0, [ %l0 ] _POSIX_Message_queue_Translate_core_message_queue_return_code( msg_status ) ); } return POSIX_BOTTOM_REACHED(); 4000afb8: 40 00 05 25 call 4000c44c <== NOT EXECUTED 4000afbc: 01 00 00 00 nop <== NOT EXECUTED } 4000afc0: b0 10 00 08 mov %o0, %i0 4000afc4: 81 c7 e0 08 ret 4000afc8: 81 e8 00 00 restore 4000b170 <_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 ) { 4000b170: 9d e3 bf 98 save %sp, -104, %sp switch ( the_message_queue_status ) { 4000b174: 80 a6 20 03 cmp %i0, 3 4000b178: 02 80 00 1c be 4000b1e8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x78> 4000b17c: 94 10 00 18 mov %i0, %o2 4000b180: 80 a6 20 03 cmp %i0, 3 4000b184: 18 80 00 0a bgu 4000b1ac <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x3c> 4000b188: 80 a6 20 05 cmp %i0, 5 4000b18c: 80 a6 20 01 cmp %i0, 1 4000b190: 02 80 00 1e be 4000b208 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x98> 4000b194: b0 10 20 7a mov 0x7a, %i0 4000b198: 80 a2 a0 01 cmp %o2, 1 4000b19c: 38 80 00 1b bgu,a 4000b208 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x98> 4000b1a0: b0 10 20 0b mov 0xb, %i0 4000b1a4: 81 c7 e0 08 ret <== NOT EXECUTED 4000b1a8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 4000b1ac: 02 80 00 11 be 4000b1f0 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x80> 4000b1b0: 80 a6 20 05 cmp %i0, 5 4000b1b4: 2a 80 00 15 bcs,a 4000b208 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x98> 4000b1b8: b0 10 20 0b mov 0xb, %i0 4000b1bc: 80 a6 20 06 cmp %i0, 6 4000b1c0: 02 80 00 08 be 4000b1e0 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x70> 4000b1c4: 03 00 44 44 sethi %hi(0x1111000), %g1 4000b1c8: 82 10 61 11 or %g1, 0x111, %g1 ! 1111111 <== NOT EXECUTED 4000b1cc: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 4000b1d0: 12 80 00 0a bne 4000b1f8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x88> <== NOT EXECUTED 4000b1d4: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED 4000b1d8: 81 c7 e0 08 ret <== NOT EXECUTED 4000b1dc: 91 e8 20 58 restore %g0, 0x58, %o0 <== NOT EXECUTED 4000b1e0: 81 c7 e0 08 ret 4000b1e4: 91 e8 20 74 restore %g0, 0x74, %o0 /* * Bad message size */ case CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE: return EMSGSIZE; 4000b1e8: 81 c7 e0 08 ret <== NOT EXECUTED 4000b1ec: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED /* * Out of message buffers to queue pending message */ case CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED: return ENOMEM; 4000b1f0: 81 c7 e0 08 ret 4000b1f4: 91 e8 20 09 restore %g0, 9, %o0 * RTEMS POSIX API implementation does not support multiprocessing. */ case THREAD_STATUS_PROXY_BLOCKING: return ENOSYS; } _Internal_error_Occurred( 4000b1f8: 40 00 0e 36 call 4000ead0 <_Internal_error_Occurred> <== NOT EXECUTED 4000b1fc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED INTERNAL_ERROR_POSIX_API, TRUE, the_message_queue_status ); return POSIX_BOTTOM_REACHED(); 4000b200: 40 00 04 93 call 4000c44c <== NOT EXECUTED 4000b204: 81 e8 00 00 restore <== NOT EXECUTED } 4000b208: 81 c7 e0 08 ret 4000b20c: 81 e8 00 00 restore 400103b8 <_POSIX_Mutex_From_core_mutex_status>: */ int _POSIX_Mutex_From_core_mutex_status( CORE_mutex_Status status ) { 400103b8: 9d e3 bf 98 save %sp, -104, %sp switch ( status ) { 400103bc: 80 a6 20 06 cmp %i0, 6 400103c0: 18 80 00 14 bgu 40010410 <_POSIX_Mutex_From_core_mutex_status+0x58> 400103c4: 92 10 20 32 mov 0x32, %o1 400103c8: 83 2e 20 02 sll %i0, 2, %g1 400103cc: 05 10 00 40 sethi %hi(0x40010000), %g2 400103d0: 84 10 a3 9c or %g2, 0x39c, %g2 ! 4001039c <_POSIX_Message_queue_Manager_initialization+0x58> 400103d4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 400103d8: 81 c0 40 00 jmp %g1 400103dc: 01 00 00 00 nop 400103e0: 81 c7 e0 08 ret 400103e4: 91 e8 20 74 restore %g0, 0x74, %o0 400103e8: 81 c7 e0 08 ret 400103ec: 91 e8 20 16 restore %g0, 0x16, %o0 400103f0: 81 c7 e0 08 ret 400103f4: 91 e8 20 00 restore %g0, 0, %o0 case CORE_MUTEX_STATUS_SUCCESSFUL: return 0; 400103f8: 81 c7 e0 08 ret 400103fc: 91 e8 20 10 restore %g0, 0x10, %o0 case CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT: return EBUSY; 40010400: 81 c7 e0 08 ret 40010404: 91 e8 20 2d restore %g0, 0x2d, %o0 case CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED: return EDEADLK; 40010408: 81 c7 e0 08 ret 4001040c: 91 e8 20 01 restore %g0, 1, %o0 case CORE_MUTEX_STATUS_CEILING_VIOLATED: return EINVAL; default: break; } assert( 0 ); 40010410: 11 10 00 65 sethi %hi(0x40019400), %o0 <== NOT EXECUTED 40010414: 15 10 00 5e sethi %hi(0x40017800), %o2 <== NOT EXECUTED 40010418: 90 12 21 78 or %o0, 0x178, %o0 <== NOT EXECUTED 4001041c: 94 12 a3 f0 or %o2, 0x3f0, %o2 <== NOT EXECUTED 40010420: 7f ff d2 18 call 40004c80 <__assert> <== NOT EXECUTED 40010424: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 40010428: 81 c7 e0 08 ret <== NOT EXECUTED 4001042c: 81 e8 00 00 restore <== NOT EXECUTED 40008290 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, boolean blocking, Watchdog_Interval timeout ) { 40008290: 9d e3 bf 90 save %sp, -112, %sp ISR_Level *level ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40008294: 80 a6 20 00 cmp %i0, 0 40008298: 32 80 00 05 bne,a 400082ac <_POSIX_Mutex_Lock_support+0x1c> 4000829c: c2 06 00 00 ld [ %i0 ], %g1 400082a0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 400082a4: 10 80 00 15 b 400082f8 <_POSIX_Mutex_Lock_support+0x68> <== NOT EXECUTED 400082a8: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED 400082ac: 80 a0 7f ff cmp %g1, -1 400082b0: 32 80 00 0c bne,a 400082e0 <_POSIX_Mutex_Lock_support+0x50> 400082b4: d2 06 00 00 ld [ %i0 ], %o1 400082b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400082bc: 7f ff ff 8f call 400080f8 <== NOT EXECUTED 400082c0: 92 10 20 00 clr %o1 <== NOT EXECUTED 400082c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400082c8: 22 80 00 06 be,a 400082e0 <_POSIX_Mutex_Lock_support+0x50> <== NOT EXECUTED 400082cc: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 400082d0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 400082d4: b0 10 20 00 clr %i0 <== NOT EXECUTED 400082d8: 10 80 00 08 b 400082f8 <_POSIX_Mutex_Lock_support+0x68> <== NOT EXECUTED 400082dc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 400082e0: 11 10 00 6d sethi %hi(0x4001b400), %o0 400082e4: 94 07 bf f4 add %fp, -12, %o2 400082e8: 90 12 21 24 or %o0, 0x124, %o0 400082ec: 40 00 0e 1e call 4000bb64 <_Objects_Get_isr_disable> 400082f0: 96 07 bf f0 add %fp, -16, %o3 400082f4: b0 10 00 08 mov %o0, %i0 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); switch ( location ) { 400082f8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400082fc: 80 a0 60 00 cmp %g1, 0 40008300: 22 80 00 06 be,a 40008318 <_POSIX_Mutex_Lock_support+0x88> 40008304: 03 10 00 6c sethi %hi(0x4001b000), %g1 40008308: 80 a0 60 02 cmp %g1, 2 4000830c: 08 80 00 86 bleu 40008524 <_POSIX_Mutex_Lock_support+0x294> 40008310: 90 10 20 16 mov 0x16, %o0 40008314: 30 80 00 82 b,a 4000851c <_POSIX_Mutex_Lock_support+0x28c> <== NOT EXECUTED ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 40008318: c2 00 60 c0 ld [ %g1 + 0xc0 ], %g1 4000831c: 80 a0 60 00 cmp %g1, 0 40008320: 02 80 00 0e be 40008358 <_POSIX_Mutex_Lock_support+0xc8> 40008324: 03 10 00 6c sethi %hi(0x4001b000), %g1 40008328: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4000832c: 02 80 00 0c be 4000835c <_POSIX_Mutex_Lock_support+0xcc> <== NOT EXECUTED 40008330: c4 00 61 9c ld [ %g1 + 0x19c ], %g2 <== NOT EXECUTED 40008334: 03 10 00 6c sethi %hi(0x4001b000), %g1 <== NOT EXECUTED 40008338: c2 00 62 a0 ld [ %g1 + 0x2a0 ], %g1 ! 4001b2a0 <_System_state_Current> <== NOT EXECUTED 4000833c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40008340: 08 80 00 05 bleu 40008354 <_POSIX_Mutex_Lock_support+0xc4> <== NOT EXECUTED 40008344: 90 10 20 00 clr %o0 <== NOT EXECUTED 40008348: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000834c: 40 00 0c b3 call 4000b618 <_Internal_error_Occurred> <== NOT EXECUTED 40008350: 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; 40008354: 03 10 00 6c sethi %hi(0x4001b000), %g1 <== NOT EXECUTED 40008358: c4 00 61 9c ld [ %g1 + 0x19c ], %g2 ! 4001b19c <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 4000835c: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40008360: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40008364: c2 06 20 64 ld [ %i0 + 0x64 ], %g1 40008368: 80 a0 60 00 cmp %g1, 0 4000836c: 22 80 00 3a be,a 40008454 <_POSIX_Mutex_Lock_support+0x1c4> 40008370: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 40008374: c0 26 20 64 clr [ %i0 + 0x64 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40008378: 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; 4000837c: c6 06 20 5c ld [ %i0 + 0x5c ], %g3 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; 40008380: c2 26 20 74 st %g1, [ %i0 + 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; 40008384: c4 26 20 70 st %g2, [ %i0 + 0x70 ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 40008388: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4000838c: 80 a0 e0 02 cmp %g3, 2 40008390: 02 80 00 05 be 400083a4 <_POSIX_Mutex_Lock_support+0x114> 40008394: c2 26 20 68 st %g1, [ %i0 + 0x68 ] 40008398: 80 a0 e0 03 cmp %g3, 3 4000839c: 32 80 00 06 bne,a 400083b4 <_POSIX_Mutex_Lock_support+0x124> 400083a0: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400083a4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 400083a8: 82 00 60 01 inc %g1 400083ac: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400083b0: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 400083b4: 80 a0 60 03 cmp %g1, 3 400083b8: 22 80 00 03 be,a 400083c4 <_POSIX_Mutex_Lock_support+0x134> 400083bc: c6 06 20 60 ld [ %i0 + 0x60 ], %g3 _ISR_Enable( level ); 400083c0: 30 80 00 35 b,a 40008494 <_POSIX_Mutex_Lock_support+0x204> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 400083c4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 if ( current == ceiling ) { 400083c8: 80 a0 40 03 cmp %g1, %g3 400083cc: 12 80 00 03 bne 400083d8 <_POSIX_Mutex_Lock_support+0x148> 400083d0: 01 00 00 00 nop _ISR_Enable( level ); 400083d4: 30 80 00 30 b,a 40008494 <_POSIX_Mutex_Lock_support+0x204> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 400083d8: 08 80 00 17 bleu 40008434 <_POSIX_Mutex_Lock_support+0x1a4> 400083dc: 82 10 20 06 mov 6, %g1 400083e0: 21 10 00 6c sethi %hi(0x4001b000), %l0 400083e4: c2 04 20 c0 ld [ %l0 + 0xc0 ], %g1 ! 4001b0c0 <_Thread_Dispatch_disable_level> 400083e8: 82 00 60 01 inc %g1 400083ec: c2 24 20 c0 st %g1, [ %l0 + 0xc0 ] _Thread_Disable_dispatch(); _ISR_Enable( level ); 400083f0: 7f ff ee 86 call 40003e08 400083f4: 01 00 00 00 nop _Thread_Change_priority( 400083f8: d2 06 20 60 ld [ %i0 + 0x60 ], %o1 400083fc: d0 06 20 70 ld [ %i0 + 0x70 ], %o0 40008400: 40 00 11 80 call 4000ca00 <_Thread_Change_priority> 40008404: 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 ) 40008408: c2 04 20 c0 ld [ %l0 + 0xc0 ], %g1 4000840c: 82 00 7f ff add %g1, -1, %g1 40008410: c2 24 20 c0 st %g1, [ %l0 + 0xc0 ] 40008414: c2 04 20 c0 ld [ %l0 + 0xc0 ], %g1 40008418: 80 a0 60 00 cmp %g1, 0 4000841c: 32 80 00 3b bne,a 40008508 <_POSIX_Mutex_Lock_support+0x278> 40008420: 03 10 00 6c sethi %hi(0x4001b000), %g1 <== NOT EXECUTED _Thread_Dispatch(); 40008424: 40 00 12 a3 call 4000ceb0 <_Thread_Dispatch> 40008428: 01 00 00 00 nop the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 4000842c: 10 80 00 37 b 40008508 <_POSIX_Mutex_Lock_support+0x278> 40008430: 03 10 00 6c sethi %hi(0x4001b000), %g1 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40008434: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008438: 82 10 20 01 mov 1, %g1 the_mutex->nest_count = 0; /* undo locking above */ 4000843c: c0 26 20 68 clr [ %i0 + 0x68 ] _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008440: c2 26 20 64 st %g1, [ %i0 + 0x64 ] the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 40008444: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 40008448: 82 00 7f ff add %g1, -1, %g1 4000844c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 40008450: 30 80 00 11 b,a 40008494 <_POSIX_Mutex_Lock_support+0x204> /* * 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 ) ) { 40008454: 80 a0 40 02 cmp %g1, %g2 40008458: 12 80 00 13 bne 400084a4 <_POSIX_Mutex_Lock_support+0x214> 4000845c: 80 a6 60 00 cmp %i1, 0 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40008460: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 40008464: 80 a0 60 00 cmp %g1, 0 40008468: 22 80 00 07 be,a 40008484 <_POSIX_Mutex_Lock_support+0x1f4> 4000846c: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED 40008470: 80 a0 60 01 cmp %g1, 1 40008474: 12 80 00 0c bne 400084a4 <_POSIX_Mutex_Lock_support+0x214> 40008478: 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; 4000847c: 10 80 00 05 b 40008490 <_POSIX_Mutex_Lock_support+0x200> 40008480: 82 10 20 02 mov 2, %g1 * 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++; 40008484: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008488: c2 26 20 68 st %g1, [ %i0 + 0x68 ] <== NOT EXECUTED _ISR_Enable( level ); 4000848c: 30 80 00 02 b,a 40008494 <_POSIX_Mutex_Lock_support+0x204> <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40008490: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] _ISR_Enable( level ); 40008494: 7f ff ee 5d call 40003e08 40008498: 01 00 00 00 nop 4000849c: 10 80 00 1b b 40008508 <_POSIX_Mutex_Lock_support+0x278> 400084a0: 03 10 00 6c sethi %hi(0x4001b000), %g1 ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 400084a4: 12 80 00 08 bne 400084c4 <_POSIX_Mutex_Lock_support+0x234> 400084a8: 21 10 00 6c sethi %hi(0x4001b000), %l0 400084ac: 7f ff ee 57 call 40003e08 400084b0: d0 07 bf f0 ld [ %fp + -16 ], %o0 400084b4: c4 04 21 9c ld [ %l0 + 0x19c ], %g2 400084b8: 82 10 20 01 mov 1, %g1 400084bc: 10 80 00 12 b 40008504 <_POSIX_Mutex_Lock_support+0x274> 400084c0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] 400084c4: c8 04 21 9c ld [ %l0 + 0x19c ], %g4 400084c8: c6 06 20 08 ld [ %i0 + 8 ], %g3 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400084cc: 05 10 00 6c sethi %hi(0x4001b000), %g2 400084d0: c2 00 a0 c0 ld [ %g2 + 0xc0 ], %g1 ! 4001b0c0 <_Thread_Dispatch_disable_level> 400084d4: c6 21 20 20 st %g3, [ %g4 + 0x20 ] 400084d8: 82 00 60 01 inc %g1 400084dc: a0 06 20 14 add %i0, 0x14, %l0 400084e0: c2 20 a0 c0 st %g1, [ %g2 + 0xc0 ] 400084e4: e0 21 20 44 st %l0, [ %g4 + 0x44 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 400084e8: 82 10 20 01 mov 1, %g1 400084ec: c2 26 20 44 st %g1, [ %i0 + 0x44 ] 400084f0: 7f ff ee 46 call 40003e08 400084f4: d0 07 bf f0 ld [ %fp + -16 ], %o0 400084f8: 90 10 00 10 mov %l0, %o0 400084fc: 40 00 09 ff call 4000acf8 <_CORE_mutex_Seize_interrupt_blocking> 40008500: 92 10 00 1a mov %i2, %o1 the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 40008504: 03 10 00 6c sethi %hi(0x4001b000), %g1 40008508: c2 00 61 9c ld [ %g1 + 0x19c ], %g1 ! 4001b19c <_Thread_Executing> 4000850c: 40 00 1f ab call 400103b8 <_POSIX_Mutex_From_core_mutex_status> 40008510: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_mutex_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40008514: 81 c7 e0 08 ret 40008518: 91 e8 00 08 restore %g0, %o0, %o0 ); return _POSIX_Mutex_From_core_mutex_status( (CORE_mutex_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 4000851c: 40 00 03 4b call 40009248 <== NOT EXECUTED 40008520: 01 00 00 00 nop <== NOT EXECUTED } 40008524: b0 10 00 08 mov %o0, %i0 40008528: 81 c7 e0 08 ret 4000852c: 81 e8 00 00 restore 400070bc <_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 ) 400070bc: 80 a2 20 03 cmp %o0, 3 400070c0: 08 80 00 05 bleu 400070d4 <_POSIX_RWLock_Translate_core_RWLock_return_code+0x18> 400070c4: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_RWLock_Return_codes[the_rwlock_status]; return POSIX_BOTTOM_REACHED(); 400070c8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 400070cc: 40 00 02 68 call 40007a6c <== NOT EXECUTED 400070d0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED } 400070d4: 03 10 00 6e sethi %hi(0x4001b800), %g1 400070d8: 82 10 61 4c or %g1, 0x14c, %g1 ! 4001b94c <_POSIX_RWLock_Return_codes> 400070dc: 81 c3 e0 08 retl 400070e0: d0 00 40 02 ld [ %g1 + %g2 ], %o0 4000f480 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 4000f480: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000f484: 03 10 00 80 sethi %hi(0x40020000), %g1 4000f488: c4 00 62 30 ld [ %g1 + 0x230 ], %g2 ! 40020230 <_Thread_Dispatch_disable_level> 4000f48c: 84 00 a0 01 inc %g2 4000f490: c4 20 62 30 st %g2, [ %g1 + 0x230 ] char *name_p = (char *)name; _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { 4000f494: 80 a6 60 00 cmp %i1, 0 4000f498: 02 80 00 08 be 4000f4b8 <_POSIX_Semaphore_Create_support+0x38> 4000f49c: 80 a6 20 00 cmp %i0, 0 _Thread_Enable_dispatch(); 4000f4a0: 7f ff ff eb call 4000f44c <_Thread_Enable_dispatch> 4000f4a4: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSYS ); 4000f4a8: 40 00 08 93 call 400116f4 <__errno> 4000f4ac: 01 00 00 00 nop 4000f4b0: 10 80 00 19 b 4000f514 <_POSIX_Semaphore_Create_support+0x94> 4000f4b4: 82 10 20 58 mov 0x58, %g1 ! 58 } if ( name ) { 4000f4b8: 02 80 00 0d be 4000f4ec <_POSIX_Semaphore_Create_support+0x6c> 4000f4bc: 11 10 00 81 sethi %hi(0x40020400), %o0 if( strlen(name) > PATH_MAX ) { 4000f4c0: 40 00 0f 05 call 400130d4 4000f4c4: 90 10 00 18 mov %i0, %o0 4000f4c8: 80 a2 20 ff cmp %o0, 0xff 4000f4cc: 28 80 00 08 bleu,a 4000f4ec <_POSIX_Semaphore_Create_support+0x6c> 4000f4d0: 11 10 00 81 sethi %hi(0x40020400), %o0 _Thread_Enable_dispatch(); 4000f4d4: 7f ff ff de call 4000f44c <_Thread_Enable_dispatch> <== NOT EXECUTED 4000f4d8: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 4000f4dc: 40 00 08 86 call 400116f4 <__errno> <== NOT EXECUTED 4000f4e0: 01 00 00 00 nop <== NOT EXECUTED 4000f4e4: 10 80 00 0c b 4000f514 <_POSIX_Semaphore_Create_support+0x94> <== NOT EXECUTED 4000f4e8: 82 10 20 5b mov 0x5b, %g1 ! 5b <== NOT EXECUTED * _POSIX_Semaphore_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void ) { return (POSIX_Semaphore_Control *) 4000f4ec: 7f ff ea d8 call 4000a04c <_Objects_Allocate> 4000f4f0: 90 12 21 b0 or %o0, 0x1b0, %o0 } } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 4000f4f4: b2 92 20 00 orcc %o0, 0, %i1 4000f4f8: 12 80 00 0a bne 4000f520 <_POSIX_Semaphore_Create_support+0xa0> 4000f4fc: 80 a6 20 00 cmp %i0, 0 _Thread_Enable_dispatch(); 4000f500: 7f ff ff d3 call 4000f44c <_Thread_Enable_dispatch> 4000f504: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSPC ); 4000f508: 40 00 08 7b call 400116f4 <__errno> 4000f50c: 01 00 00 00 nop 4000f510: 82 10 20 1c mov 0x1c, %g1 ! 1c 4000f514: c2 22 00 00 st %g1, [ %o0 ] 4000f518: 81 c7 e0 08 ret 4000f51c: 91 e8 3f ff restore %g0, -1, %o0 } #endif the_semaphore->process_shared = pshared; if ( name ) { 4000f520: 02 80 00 07 be 4000f53c <_POSIX_Semaphore_Create_support+0xbc> 4000f524: c0 26 60 10 clr [ %i1 + 0x10 ] the_semaphore->named = TRUE; 4000f528: 82 10 20 01 mov 1, %g1 the_semaphore->open_count = 1; the_semaphore->linked = TRUE; 4000f52c: c2 26 60 18 st %g1, [ %i1 + 0x18 ] #endif the_semaphore->process_shared = pshared; if ( name ) { the_semaphore->named = TRUE; 4000f530: c2 26 60 14 st %g1, [ %i1 + 0x14 ] the_semaphore->open_count = 1; 4000f534: 10 80 00 05 b 4000f548 <_POSIX_Semaphore_Create_support+0xc8> 4000f538: c2 26 60 1c st %g1, [ %i1 + 0x1c ] the_semaphore->linked = TRUE; } else { the_semaphore->named = FALSE; 4000f53c: c0 26 60 14 clr [ %i1 + 0x14 ] the_semaphore->open_count = 0; 4000f540: c0 26 60 1c clr [ %i1 + 0x1c ] the_semaphore->linked = FALSE; 4000f544: c0 26 60 18 clr [ %i1 + 0x18 ] /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 4000f548: 82 10 3f ff mov -1, %g1 * 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; 4000f54c: c0 26 60 64 clr [ %i1 + 0x64 ] /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 4000f550: c2 26 60 60 st %g1, [ %i1 + 0x60 ] _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 4000f554: 94 10 00 1a mov %i2, %o2 4000f558: 90 06 60 20 add %i1, 0x20, %o0 4000f55c: 7f ff e8 f6 call 40009934 <_CORE_semaphore_Initialize> 4000f560: 92 06 60 60 add %i1, 0x60, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f564: 03 10 00 81 sethi %hi(0x40020400), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000f568: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f56c: 88 10 61 b0 or %g1, 0x1b0, %g4 4000f570: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 4000f574: 03 00 00 3f sethi %hi(0xfc00), %g1 4000f578: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000f57c: 82 08 c0 01 and %g3, %g1, %g1 4000f580: 80 a0 40 02 cmp %g1, %g2 4000f584: 38 80 00 06 bgu,a 4000f59c <_POSIX_Semaphore_Create_support+0x11c> 4000f588: f0 26 60 0c st %i0, [ %i1 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000f58c: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 4000f590: 83 28 60 02 sll %g1, 2, %g1 4000f594: f2 20 80 01 st %i1, [ %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; 4000f598: f0 26 60 0c st %i0, [ %i1 + 0xc ] * Make the semaphore available for use. */ _Objects_Open(&_POSIX_Semaphore_Information, &the_semaphore->Object, name_p); *the_sem = the_semaphore; 4000f59c: f2 26 c0 00 st %i1, [ %i3 ] name_p, 0 /* proxy id - Not used */ ); #endif _Thread_Enable_dispatch(); 4000f5a0: 7f ff ff ab call 4000f44c <_Thread_Enable_dispatch> 4000f5a4: b0 10 20 00 clr %i0 return 0; } 4000f5a8: 81 c7 e0 08 ret 4000f5ac: 81 e8 00 00 restore 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 eb ab call 4000a55c <_Objects_Get> 4000f6b4: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 400205b0 <_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 09 be 4000f6e8 <_POSIX_Semaphore_Wait_support+0x48> 4000f6c8: 96 10 00 1a mov %i2, %o3 4000f6cc: 80 a0 60 01 cmp %g1, 1 4000f6d0: 2a 80 00 0c bcs,a 4000f700 <_POSIX_Semaphore_Wait_support+0x60> 4000f6d4: d2 02 20 08 ld [ %o0 + 8 ], %o1 4000f6d8: 80 a0 60 02 cmp %g1, 2 4000f6dc: 12 80 00 29 bne 4000f780 <_POSIX_Semaphore_Wait_support+0xe0> 4000f6e0: 01 00 00 00 nop 4000f6e4: 30 80 00 03 b,a 4000f6f0 <_POSIX_Semaphore_Wait_support+0x50> case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 4000f6e8: 7f ff f0 52 call 4000b830 <_Thread_Dispatch> <== NOT EXECUTED 4000f6ec: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 4000f6f0: 40 00 08 01 call 400116f4 <__errno> 4000f6f4: 01 00 00 00 nop 4000f6f8: 10 80 00 1f b 4000f774 <_POSIX_Semaphore_Wait_support+0xd4> 4000f6fc: 82 10 20 16 mov 0x16, %g1 ! 16 case OBJECTS_LOCAL: _CORE_semaphore_Seize( 4000f700: 40 00 01 78 call 4000fce0 <_CORE_semaphore_Seize> 4000f704: 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 ) 4000f708: 03 10 00 80 sethi %hi(0x40020000), %g1 4000f70c: c4 00 62 30 ld [ %g1 + 0x230 ], %g2 ! 40020230 <_Thread_Dispatch_disable_level> 4000f710: 84 00 bf ff add %g2, -1, %g2 4000f714: c4 20 62 30 st %g2, [ %g1 + 0x230 ] 4000f718: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 4000f71c: 80 a0 60 00 cmp %g1, 0 4000f720: 12 80 00 05 bne 4000f734 <_POSIX_Semaphore_Wait_support+0x94> 4000f724: 03 10 00 80 sethi %hi(0x40020000), %g1 _Thread_Dispatch(); 4000f728: 7f ff f0 42 call 4000b830 <_Thread_Dispatch> 4000f72c: 01 00 00 00 nop the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); switch ( _Thread_Executing->Wait.return_code ) { 4000f730: 03 10 00 80 sethi %hi(0x40020000), %g1 4000f734: c2 00 63 0c ld [ %g1 + 0x30c ], %g1 ! 4002030c <_Thread_Executing> 4000f738: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 4000f73c: 80 a0 60 02 cmp %g1, 2 4000f740: 02 80 00 06 be 4000f758 <_POSIX_Semaphore_Wait_support+0xb8> 4000f744: 80 a0 60 03 cmp %g1, 3 4000f748: 02 80 00 08 be 4000f768 <_POSIX_Semaphore_Wait_support+0xc8> 4000f74c: 80 a0 60 01 cmp %g1, 1 4000f750: 12 80 00 0c bne 4000f780 <_POSIX_Semaphore_Wait_support+0xe0> 4000f754: 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 ); 4000f758: 40 00 07 e7 call 400116f4 <__errno> 4000f75c: 01 00 00 00 nop 4000f760: 10 80 00 05 b 4000f774 <_POSIX_Semaphore_Wait_support+0xd4> 4000f764: 82 10 20 0b mov 0xb, %g1 ! b case CORE_SEMAPHORE_TIMEOUT: rtems_set_errno_and_return_minus_one( ETIMEDOUT ); 4000f768: 40 00 07 e3 call 400116f4 <__errno> 4000f76c: 01 00 00 00 nop 4000f770: 82 10 20 74 mov 0x74, %g1 ! 74 4000f774: c2 22 00 00 st %g1, [ %o0 ] 4000f778: 81 c7 e0 08 ret 4000f77c: 91 e8 3f ff restore %g0, -1, %o0 */ break; } } return 0; } 4000f780: 81 c7 e0 08 ret 4000f784: 91 e8 20 00 restore %g0, 0, %o0 40006588 <_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 ) 40006588: 80 a2 20 06 cmp %o0, 6 4000658c: 08 80 00 05 bleu 400065a0 <_POSIX_Spinlock_Translate_core_spinlock_return_code+0x18> 40006590: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_Spinlock_Return_codes[the_spinlock_status]; return POSIX_BOTTOM_REACHED(); 40006594: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40006598: 40 00 00 6d call 4000674c <== NOT EXECUTED 4000659c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED } 400065a0: 03 10 00 4d sethi %hi(0x40013400), %g1 400065a4: 82 10 61 cc or %g1, 0x1cc, %g1 ! 400135cc <_POSIX_Spinlock_Return_codes> 400065a8: 81 c3 e0 08 retl 400065ac: d0 00 40 02 ld [ %g1 + %g2 ], %o0 4000cfdc <_POSIX_Threads_Create_extension>: boolean _POSIX_Threads_Create_extension( Thread_Control *executing, Thread_Control *created ) { 4000cfdc: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 4000cfe0: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000cfe4: 92 10 20 e4 mov 0xe4, %o1 4000cfe8: 90 12 22 1c or %o0, 0x21c, %o0 4000cfec: 7f ff ea f0 call 40007bac <_Heap_Allocate> 4000cff0: b0 10 20 00 clr %i0 POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); if ( !api ) 4000cff4: a2 92 20 00 orcc %o0, 0, %l1 4000cff8: 02 80 00 39 be 4000d0dc <_POSIX_Threads_Create_extension+0x100> 4000cffc: 94 10 20 38 mov 0x38, %o2 return FALSE; created->API_Extensions[ THREAD_API_POSIX ] = api; 4000d000: e2 26 61 70 st %l1, [ %i1 + 0x170 ] /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; 4000d004: 21 10 00 64 sethi %hi(0x40019000), %l0 4000d008: a0 14 20 e8 or %l0, 0xe8, %l0 ! 400190e8 <_POSIX_Threads_Default_attributes> 4000d00c: 40 00 09 c1 call 4000f710 4000d010: 92 10 00 10 mov %l0, %o1 api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 4000d014: c2 04 20 34 ld [ %l0 + 0x34 ], %g1 api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 4000d018: c4 04 20 14 ld [ %l0 + 0x14 ], %g2 created->API_Extensions[ THREAD_API_POSIX ] = api; /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 4000d01c: c2 24 60 38 st %g1, [ %l1 + 0x38 ] api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 4000d020: c4 24 60 7c st %g2, [ %l1 + 0x7c ] api->schedparam = _POSIX_Threads_Default_attributes.schedparam; 4000d024: 92 04 20 18 add %l0, 0x18, %o1 4000d028: 90 04 60 80 add %l1, 0x80, %o0 4000d02c: 40 00 09 b9 call 4000f710 4000d030: 94 10 20 18 mov 0x18, %o2 api->schedparam.sched_priority = 4000d034: c4 06 60 14 ld [ %i1 + 0x14 ], %g2 4000d038: 82 10 20 ff mov 0xff, %g1 4000d03c: 82 20 40 02 sub %g1, %g2, %g1 * If the thread is not a posix thread, then all posix signals are blocked * by default. */ /* XXX use signal constants */ api->signals_pending = 0; 4000d040: c0 24 60 c8 clr [ %l1 + 0xc8 ] /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; api->detachstate = _POSIX_Threads_Default_attributes.detachstate; api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; api->schedparam = _POSIX_Threads_Default_attributes.schedparam; api->schedparam.sched_priority = 4000d044: c2 24 60 80 st %g1, [ %l1 + 0x80 ] * by default. */ /* XXX use signal constants */ api->signals_pending = 0; if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 4000d048: c6 06 60 08 ld [ %i1 + 8 ], %g3 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 4000d04c: 82 04 60 dc add %l1, 0xdc, %g1 _POSIX_Priority_From_core( created->current_priority ); /* * POSIX 1003.1 1996, 18.2.2.2 */ api->cancelation_requested = 0; 4000d050: c0 24 60 d4 clr [ %l1 + 0xd4 ] 4000d054: c2 24 60 d8 st %g1, [ %l1 + 0xd8 ] api->cancelability_state = PTHREAD_CANCEL_ENABLE; 4000d058: c0 24 60 cc clr [ %l1 + 0xcc ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4000d05c: 82 04 60 d8 add %l1, 0xd8, %g1 api->cancelability_type = PTHREAD_CANCEL_DEFERRED; 4000d060: c0 24 60 d0 clr [ %l1 + 0xd0 ] 4000d064: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] * by default. */ /* XXX use signal constants */ api->signals_pending = 0; if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 4000d068: 83 30 e0 18 srl %g3, 0x18, %g1 4000d06c: 82 08 60 07 and %g1, 7, %g1 4000d070: 80 a0 60 03 cmp %g1, 3 4000d074: 12 80 00 0b bne 4000d0a0 <_POSIX_Threads_Create_extension+0xc4> 4000d078: c0 24 60 dc clr [ %l1 + 0xdc ] 4000d07c: 83 30 e0 1b srl %g3, 0x1b, %g1 4000d080: 80 a0 60 01 cmp %g1, 1 4000d084: 32 80 00 08 bne,a 4000d0a4 <_POSIX_Threads_Create_extension+0xc8> 4000d088: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED _Objects_Get_class( created->Object.id ) == 1 ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; 4000d08c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000d090: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 4001aeac <_Thread_Executing> 4000d094: c2 00 61 70 ld [ %g1 + 0x170 ], %g1 4000d098: 10 80 00 03 b 4000d0a4 <_POSIX_Threads_Create_extension+0xc8> 4000d09c: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 } else { api->signals_blocked = 0xffffffff; 4000d0a0: 82 10 3f ff mov -1, %g1 4000d0a4: c2 24 60 c4 st %g1, [ %l1 + 0xc4 ] } _Thread_queue_Initialize( 4000d0a8: 90 04 60 3c add %l1, 0x3c, %o0 4000d0ac: 92 10 20 00 clr %o1 4000d0b0: 15 00 00 04 sethi %hi(0x1000), %o2 4000d0b4: 7f ff f4 9d call 4000a328 <_Thread_queue_Initialize> 4000d0b8: 96 10 20 00 clr %o3 THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_JOIN_AT_EXIT, 0 ); _Watchdog_Initialize( 4000d0bc: c2 06 60 08 ld [ %i1 + 8 ], %g1 ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 4000d0c0: f2 24 60 c0 st %i1, [ %l1 + 0xc0 ] void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 4000d0c4: c2 24 60 bc st %g1, [ %l1 + 0xbc ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4000d0c8: c0 24 60 a4 clr [ %l1 + 0xa4 ] the_watchdog->routine = routine; 4000d0cc: 03 10 00 34 sethi %hi(0x4000d000), %g1 the_watchdog->id = id; the_watchdog->user_data = user_data; 4000d0d0: b0 10 20 01 mov 1, %i0 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 4000d0d4: 82 10 61 34 or %g1, 0x134, %g1 4000d0d8: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] created->Object.id, created ); return TRUE; } 4000d0dc: 81 c7 e0 08 ret 4000d0e0: 81 e8 00 00 restore 40007264 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body( void ) { 40007264: 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; 40007268: 03 10 00 7b sethi %hi(0x4001ec00), %g1 4000726c: e0 00 63 ec ld [ %g1 + 0x3ec ], %l0 ! 4001efec <_POSIX_Threads_User_initialization_threads> maximum = _POSIX_Threads_Number_of_initialization_threads; 40007270: 03 10 00 7c sethi %hi(0x4001f000), %g1 if ( !user_threads || maximum == 0 ) 40007274: 80 a4 20 00 cmp %l0, 0 40007278: 02 80 00 3b be 40007364 <_POSIX_Threads_Initialize_user_threads_body+0x100> 4000727c: ec 00 60 bc ld [ %g1 + 0xbc ], %l6 40007280: 80 a5 a0 00 cmp %l6, 0 40007284: 02 80 00 38 be 40007364 <_POSIX_Threads_Initialize_user_threads_body+0x100> 40007288: 03 10 00 72 sethi %hi(0x4001c800), %g1 return; 4000728c: aa 10 20 00 clr %l5 * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { status = pthread_attr_init( &attr ); assert( !status ); 40007290: a8 10 62 b0 or %g1, 0x2b0, %l4 user_threads = _POSIX_Threads_User_initialization_threads; maximum = _POSIX_Threads_Number_of_initialization_threads; if ( !user_threads || maximum == 0 ) return; 40007294: a4 10 20 00 clr %l2 * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { status = pthread_attr_init( &attr ); assert( !status ); 40007298: 03 10 00 6f sethi %hi(0x4001bc00), %g1 * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { status = pthread_attr_init( &attr ); 4000729c: a2 07 bf bc add %fp, -68, %l1 assert( !status ); 400072a0: a6 10 62 c8 or %g1, 0x2c8, %l3 assert( !status ); status = pthread_attr_setstacksize( &attr, user_threads[ index ].stack_size); assert( !status ); status = pthread_create( 400072a4: 10 80 00 2d b 40007358 <_POSIX_Threads_Initialize_user_threads_body+0xf4> 400072a8: ae 07 bf f4 add %fp, -12, %l7 * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { status = pthread_attr_init( &attr ); 400072ac: 40 00 1f 11 call 4000eef0 400072b0: aa 05 60 01 inc %l5 assert( !status ); 400072b4: 80 a2 20 00 cmp %o0, 0 400072b8: 02 80 00 07 be 400072d4 <_POSIX_Threads_Initialize_user_threads_body+0x70> 400072bc: 92 10 20 02 mov 2, %o1 400072c0: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 400072c4: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 400072c8: 7f ff f2 3f call 40003bc4 <__assert> <== NOT EXECUTED 400072cc: 92 10 20 47 mov 0x47, %o1 <== NOT EXECUTED status = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 400072d0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 400072d4: 40 00 1f 12 call 4000ef1c 400072d8: 90 10 00 11 mov %l1, %o0 assert( !status ); 400072dc: 80 a2 20 00 cmp %o0, 0 400072e0: 02 80 00 07 be 400072fc <_POSIX_Threads_Initialize_user_threads_body+0x98> 400072e4: 82 04 00 12 add %l0, %l2, %g1 400072e8: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 400072ec: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 400072f0: 7f ff f2 35 call 40003bc4 <__assert> <== NOT EXECUTED 400072f4: 92 10 20 4a mov 0x4a, %o1 <== NOT EXECUTED status = pthread_attr_setstacksize( &attr, user_threads[ index ].stack_size); 400072f8: 82 04 00 12 add %l0, %l2, %g1 <== NOT EXECUTED 400072fc: d2 00 60 04 ld [ %g1 + 4 ], %o1 40007300: 40 00 1f 17 call 4000ef5c 40007304: 90 10 00 11 mov %l1, %o0 assert( !status ); 40007308: 80 a2 20 00 cmp %o0, 0 4000730c: 22 80 00 07 be,a 40007328 <_POSIX_Threads_Initialize_user_threads_body+0xc4> 40007310: d4 04 80 10 ld [ %l2 + %l0 ], %o2 40007314: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 40007318: 92 10 20 4d mov 0x4d, %o1 <== NOT EXECUTED 4000731c: 7f ff f2 2a call 40003bc4 <__assert> <== NOT EXECUTED 40007320: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED status = pthread_create( 40007324: d4 04 80 10 ld [ %l2 + %l0 ], %o2 <== NOT EXECUTED 40007328: 92 10 00 11 mov %l1, %o1 4000732c: 96 10 20 00 clr %o3 40007330: 90 10 00 17 mov %l7, %o0 40007334: 7f ff fe fe call 40006f2c 40007338: a4 04 a0 08 add %l2, 8, %l2 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); assert( !status ); 4000733c: 80 a2 20 00 cmp %o0, 0 40007340: 02 80 00 07 be 4000735c <_POSIX_Threads_Initialize_user_threads_body+0xf8> 40007344: 80 a5 40 16 cmp %l5, %l6 40007348: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 4000734c: 92 10 20 55 mov 0x55, %o1 <== NOT EXECUTED 40007350: 7f ff f2 1d call 40003bc4 <__assert> <== NOT EXECUTED 40007354: 94 10 00 13 mov %l3, %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++ ) { 40007358: 80 a5 40 16 cmp %l5, %l6 4000735c: 12 bf ff d4 bne 400072ac <_POSIX_Threads_Initialize_user_threads_body+0x48> 40007360: 90 10 00 11 mov %l1, %o0 40007364: 81 c7 e0 08 ret 40007368: 81 e8 00 00 restore 4000d134 <_POSIX_Threads_Sporadic_budget_TSR>: void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id, void *argument ) { 4000d134: 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 ]; 4000d138: f0 06 61 70 ld [ %i1 + 0x170 ], %i0 ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); 4000d13c: 40 00 03 d2 call 4000e084 <_Timespec_To_ticks> 4000d140: 90 06 20 90 add %i0, 0x90, %o0 if ( !ticks ) 4000d144: 80 a2 20 00 cmp %o0, 0 4000d148: 22 80 00 02 be,a 4000d150 <_POSIX_Threads_Sporadic_budget_TSR+0x1c> 4000d14c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 4000d150: 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 || 4000d154: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 4000d158: 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; 4000d15c: d0 26 60 84 st %o0, [ %i1 + 0x84 ] 4000d160: 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 || 4000d164: 80 a0 e0 00 cmp %g3, 0 4000d168: 02 80 00 06 be 4000d180 <_POSIX_Threads_Sporadic_budget_TSR+0x4c> 4000d16c: d2 26 60 18 st %o1, [ %i1 + 0x18 ] 4000d170: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 4000d174: 80 a0 40 09 cmp %g1, %o1 4000d178: 08 80 00 05 bleu 4000d18c <_POSIX_Threads_Sporadic_budget_TSR+0x58> 4000d17c: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 4000d180: 90 10 00 19 mov %i1, %o0 4000d184: 7f ff f0 ee call 4000953c <_Thread_Change_priority> 4000d188: 94 10 20 01 mov 1, %o2 ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 4000d18c: 40 00 03 be call 4000e084 <_Timespec_To_ticks> 4000d190: 90 06 20 88 add %i0, 0x88, %o0 if ( !ticks ) 4000d194: 80 a2 20 00 cmp %o0, 0 4000d198: 22 80 00 02 be,a 4000d1a0 <_POSIX_Threads_Sporadic_budget_TSR+0x6c> 4000d19c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000d1a0: d0 26 20 a8 st %o0, [ %i0 + 0xa8 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4000d1a4: b2 06 20 9c add %i0, 0x9c, %i1 4000d1a8: 31 10 00 6b sethi %hi(0x4001ac00), %i0 4000d1ac: 7f ff f6 ed call 4000ad60 <_Watchdog_Insert> 4000d1b0: 91 ee 22 cc restore %i0, 0x2cc, %o0 4000d1b4: 01 00 00 00 nop 4000d0e4 <_POSIX_Threads_Sporadic_budget_callout>: ) { POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 4000d0e4: c2 02 21 70 ld [ %o0 + 0x170 ], %g1 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 || 4000d0e8: c6 02 20 1c ld [ %o0 + 0x1c ], %g3 RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (255 - priority); 4000d0ec: c4 00 60 84 ld [ %g1 + 0x84 ], %g2 * 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 */ 4000d0f0: 82 10 3f ff mov -1, %g1 4000d0f4: c2 22 20 84 st %g1, [ %o0 + 0x84 ] 4000d0f8: 82 10 20 ff mov 0xff, %g1 4000d0fc: 92 20 40 02 sub %g1, %g2, %o1 new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 4000d100: 80 a0 e0 00 cmp %g3, 0 4000d104: 02 80 00 06 be 4000d11c <_POSIX_Threads_Sporadic_budget_callout+0x38> 4000d108: d2 22 20 18 st %o1, [ %o0 + 0x18 ] 4000d10c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED 4000d110: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED 4000d114: 08 80 00 06 bleu 4000d12c <_POSIX_Threads_Sporadic_budget_callout+0x48> <== NOT EXECUTED 4000d118: 01 00 00 00 nop <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 4000d11c: 94 10 20 01 mov 1, %o2 ! 1 4000d120: 82 13 c0 00 mov %o7, %g1 4000d124: 7f ff f1 06 call 4000953c <_Thread_Change_priority> 4000d128: 9e 10 40 00 mov %g1, %o7 4000d12c: 81 c3 e0 08 retl <== NOT EXECUTED 4000d130: 01 00 00 00 nop 40005e4c <_POSIX_Threads_cancel_run>: */ void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 40005e4c: 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 ]; 40005e50: f2 06 21 70 ld [ %i0 + 0x170 ], %i1 handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 40005e54: 82 10 20 01 mov 1, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40005e58: a2 06 60 dc add %i1, 0xdc, %l1 40005e5c: c2 26 60 cc st %g1, [ %i1 + 0xcc ] RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 40005e60: 03 10 00 5f sethi %hi(0x40017c00), %g1 40005e64: 10 80 00 11 b 40005ea8 <_POSIX_Threads_cancel_run+0x5c> 40005e68: a4 10 62 1c or %g1, 0x21c, %l2 ! 40017e1c <_Workspace_Area> while ( !_Chain_Is_empty( handler_stack ) ) { _ISR_Disable( level ); 40005e6c: 7f ff f0 56 call 40001fc4 <== NOT EXECUTED 40005e70: 01 00 00 00 nop <== NOT EXECUTED handler = (POSIX_Cancel_Handler_control *) 40005e74: e0 04 60 04 ld [ %l1 + 4 ], %l0 <== NOT EXECUTED ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 40005e78: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED previous = the_node->previous; 40005e7c: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 40005e80: 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; 40005e84: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 40005e88: 7f ff f0 53 call 40001fd4 <== NOT EXECUTED 40005e8c: 01 00 00 00 nop <== NOT EXECUTED (*handler->routine)( handler->arg ); 40005e90: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 40005e94: 9f c0 40 00 call %g1 <== NOT EXECUTED 40005e98: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED 40005e9c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40005ea0: 40 00 0a 4a call 400087c8 <_Heap_Free> <== NOT EXECUTED 40005ea4: 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 ) ) { 40005ea8: c2 06 60 d8 ld [ %i1 + 0xd8 ], %g1 40005eac: 80 a0 40 11 cmp %g1, %l1 40005eb0: 12 bf ff ef bne 40005e6c <_POSIX_Threads_cancel_run+0x20> 40005eb4: 03 10 00 5f sethi %hi(0x40017c00), %g1 } /* Now we can delete the thread */ the_thread->Wait.return_argument = PTHREAD_CANCELED; _Thread_Close( 40005eb8: c6 06 20 08 ld [ %i0 + 8 ], %g3 40005ebc: 85 30 e0 16 srl %g3, 0x16, %g2 40005ec0: 82 10 61 30 or %g1, 0x130, %g1 40005ec4: 84 08 a0 1c and %g2, 0x1c, %g2 40005ec8: c2 00 40 02 ld [ %g1 + %g2 ], %g1 40005ecc: 87 30 e0 1b srl %g3, 0x1b, %g3 40005ed0: 87 28 e0 02 sll %g3, 2, %g3 40005ed4: d0 00 40 03 ld [ %g1 + %g3 ], %o0 40005ed8: 92 10 00 18 mov %i0, %o1 _Workspace_Free( handler ); } /* Now we can delete the thread */ the_thread->Wait.return_argument = PTHREAD_CANCELED; 40005edc: 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 ); 40005ee0: b2 10 00 18 mov %i0, %i1 40005ee4: c2 26 20 28 st %g1, [ %i0 + 0x28 ] _Thread_Close( 40005ee8: 40 00 10 dd call 4000a25c <_Thread_Close> 40005eec: 31 10 00 60 sethi %hi(0x40018000), %i0 40005ef0: 40 00 0c 69 call 40009094 <_Objects_Free> 40005ef4: 91 ee 20 b8 restore %i0, 0xb8, %o0 40005ef8: 01 00 00 00 nop 4000bfc0 <_POSIX_Timer_TSR>: * Description: This is the operation that is ran when a timer expires * ***************************************************************************/ void _POSIX_Timer_TSR(Objects_Id timer, void *data) { 4000bfc0: 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; 4000bfc4: c2 06 60 68 ld [ %i1 + 0x68 ], %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 4000bfc8: 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; 4000bfcc: 82 00 60 01 inc %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 4000bfd0: 80 a0 a0 00 cmp %g2, 0 4000bfd4: 12 80 00 06 bne 4000bfec <_POSIX_Timer_TSR+0x2c> 4000bfd8: c2 26 60 68 st %g1, [ %i1 + 0x68 ] 4000bfdc: c2 06 60 58 ld [ %i1 + 0x58 ], %g1 <== NOT EXECUTED 4000bfe0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bfe4: 02 80 00 0f be 4000c020 <_POSIX_Timer_TSR+0x60> <== NOT EXECUTED 4000bfe8: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED ( 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( 4000bfec: d2 06 60 64 ld [ %i1 + 0x64 ], %o1 4000bff0: d4 06 60 08 ld [ %i1 + 8 ], %o2 4000bff4: 90 06 60 10 add %i1, 0x10, %o0 4000bff8: 17 10 00 2f sethi %hi(0x4000bc00), %o3 4000bffc: 98 10 00 19 mov %i1, %o4 4000c000: 7f ff ff 68 call 4000bda0 <_Watchdog_Insert_ticks_helper> 4000c004: 96 12 e3 c0 or %o3, 0x3c0, %o3 ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 4000c008: 80 a2 20 00 cmp %o0, 0 4000c00c: 02 80 00 0a be 4000c034 <_POSIX_Timer_TSR+0x74> 4000c010: 01 00 00 00 nop return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 4000c014: 40 00 09 21 call 4000e498 <_TOD_Get> 4000c018: 90 06 60 6c add %i1, 0x6c, %o0 4000c01c: 82 10 20 03 mov 3, %g1 /* * 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 ) ) { 4000c020: d0 06 60 38 ld [ %i1 + 0x38 ], %o0 4000c024: d2 06 60 44 ld [ %i1 + 0x44 ], %o1 4000c028: 40 00 1f 9e call 40013ea0 4000c02c: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 4000c030: c0 26 60 68 clr [ %i1 + 0x68 ] 4000c034: 81 c7 e0 08 ret 4000c038: 81 e8 00 00 restore 4000cebc <_POSIX_signals_Abnormal_termination_handler>: /*** PROCESS WIDE STUFF ****/ sigset_t _POSIX_signals_Pending; void _POSIX_signals_Abnormal_termination_handler( int signo ) { 4000cebc: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED exit( 1 ); 4000cec0: 40 00 08 42 call 4000efc8 <== NOT EXECUTED 4000cec4: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 4000cec8: 01 00 00 00 nop 4000e740 <_POSIX_signals_Check_signal>: boolean _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, boolean is_global ) { 4000e740: 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, 4000e744: 98 10 20 01 mov 1, %o4 4000e748: 96 10 00 1a mov %i2, %o3 4000e74c: a6 07 bf ec add %fp, -20, %l3 4000e750: 90 10 00 18 mov %i0, %o0 4000e754: 92 10 00 19 mov %i1, %o1 4000e758: 40 00 00 2e call 4000e810 <_POSIX_signals_Clear_signals> 4000e75c: 94 10 00 13 mov %l3, %o2 4000e760: 80 a2 20 00 cmp %o0, 0 4000e764: 02 80 00 29 be 4000e808 <_POSIX_signals_Check_signal+0xc8> 4000e768: 03 10 00 6d sethi %hi(0x4001b400), %g1 /* * Since we made a union of these, only one test is necessary but this is * safer. */ assert( _POSIX_signals_Vectors[ signo ].sa_handler || 4000e76c: a4 10 60 64 or %g1, 0x64, %l2 ! 4001b464 <_POSIX_signals_Vectors> 4000e770: 83 2e 60 04 sll %i1, 4, %g1 4000e774: 85 2e 60 02 sll %i1, 2, %g2 4000e778: a2 20 40 02 sub %g1, %g2, %l1 4000e77c: b4 04 40 12 add %l1, %l2, %i2 4000e780: c2 06 a0 08 ld [ %i2 + 8 ], %g1 4000e784: 80 a0 60 00 cmp %g1, 0 4000e788: 12 80 00 0a bne 4000e7b0 <_POSIX_signals_Check_signal+0x70> 4000e78c: 80 a0 60 01 cmp %g1, 1 4000e790: 11 10 00 64 sethi %hi(0x40019000), %o0 <== NOT EXECUTED 4000e794: 15 10 00 64 sethi %hi(0x40019000), %o2 <== NOT EXECUTED 4000e798: 90 12 22 10 or %o0, 0x210, %o0 <== NOT EXECUTED 4000e79c: 94 12 a2 60 or %o2, 0x260, %o2 <== NOT EXECUTED 4000e7a0: 7f ff d1 6d call 40002d54 <__assert> <== NOT EXECUTED 4000e7a4: 92 10 20 33 mov 0x33, %o1 <== NOT EXECUTED /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 4000e7a8: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED 4000e7ac: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000e7b0: 02 80 00 16 be 4000e808 <_POSIX_signals_Check_signal+0xc8> 4000e7b4: 01 00 00 00 nop /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 4000e7b8: e0 06 20 c4 ld [ %i0 + 0xc4 ], %l0 api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 4000e7bc: c2 06 a0 04 ld [ %i2 + 4 ], %g1 /* Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 4000e7c0: c4 04 80 11 ld [ %l2 + %l1 ], %g2 /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 4000e7c4: 82 10 40 10 or %g1, %l0, %g1 /* Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 4000e7c8: 80 a0 a0 02 cmp %g2, 2 4000e7cc: 12 80 00 09 bne 4000e7f0 <_POSIX_signals_Check_signal+0xb0> 4000e7d0: c2 26 20 c4 st %g1, [ %i0 + 0xc4 ] case SA_SIGINFO: /* * * assert( is_global ); */ (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 4000e7d4: c2 06 a0 08 ld [ %i2 + 8 ], %g1 4000e7d8: 90 10 00 19 mov %i1, %o0 4000e7dc: 92 10 00 13 mov %l3, %o1 4000e7e0: 9f c0 40 00 call %g1 4000e7e4: 94 10 20 00 clr %o2 /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 4000e7e8: 10 80 00 06 b 4000e800 <_POSIX_signals_Check_signal+0xc0> 4000e7ec: e0 26 20 c4 st %l0, [ %i0 + 0xc4 ] &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 4000e7f0: c2 06 a0 08 ld [ %i2 + 8 ], %g1 4000e7f4: 9f c0 40 00 call %g1 4000e7f8: 90 10 00 19 mov %i1, %o0 /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 4000e7fc: e0 26 20 c4 st %l0, [ %i0 + 0xc4 ] 4000e800: 81 c7 e0 08 ret 4000e804: 91 e8 20 01 restore %g0, 1, %o0 return TRUE; } 4000e808: 81 c7 e0 08 ret 4000e80c: 91 e8 20 00 restore %g0, 0, %o0 4000e810 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, boolean is_global, boolean check_blocked ) { 4000e810: 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 ); 4000e814: 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 ) 4000e818: 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 ); 4000e81c: 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 ) 4000e820: b8 10 3f ff mov -1, %i4 4000e824: 02 80 00 04 be 4000e834 <_POSIX_signals_Clear_signals+0x24> 4000e828: a1 28 40 02 sll %g1, %g2, %l0 signals_blocked = ~api->signals_blocked; 4000e82c: c2 06 20 c4 ld [ %i0 + 0xc4 ], %g1 4000e830: 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 ); 4000e834: 7f ff cd a6 call 40001ecc 4000e838: 01 00 00 00 nop 4000e83c: a2 10 00 08 mov %o0, %l1 if ( is_global ) { 4000e840: 80 a6 e0 00 cmp %i3, 0 4000e844: 22 80 00 35 be,a 4000e918 <_POSIX_signals_Clear_signals+0x108> 4000e848: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0 if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 4000e84c: 03 10 00 6d sethi %hi(0x4001b400), %g1 4000e850: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 4001b630 <_POSIX_signals_Pending> 4000e854: 82 0c 00 01 and %l0, %g1, %g1 4000e858: 80 88 40 1c btst %g1, %i4 4000e85c: 02 80 00 36 be 4000e934 <_POSIX_signals_Clear_signals+0x124> 4000e860: 83 2e 60 02 sll %i1, 2, %g1 if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 4000e864: 85 2e 60 04 sll %i1, 4, %g2 4000e868: 84 20 80 01 sub %g2, %g1, %g2 4000e86c: 03 10 00 6d sethi %hi(0x4001b400), %g1 4000e870: 82 10 60 64 or %g1, 0x64, %g1 ! 4001b464 <_POSIX_signals_Vectors> 4000e874: c2 00 40 02 ld [ %g1 + %g2 ], %g1 4000e878: 80 a0 60 02 cmp %g1, 2 4000e87c: 12 80 00 23 bne 4000e908 <_POSIX_signals_Clear_signals+0xf8> 4000e880: 03 10 00 6d sethi %hi(0x4001b400), %g1 psiginfo = (POSIX_signals_Siginfo_node *) 4000e884: 88 10 62 34 or %g1, 0x234, %g4 ! 4001b634 <_POSIX_signals_Siginfo> */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 4000e888: f8 00 80 04 ld [ %g2 + %g4 ], %i4 4000e88c: 86 00 80 04 add %g2, %g4, %g3 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4000e890: 9a 00 e0 04 add %g3, 4, %o5 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 4000e894: 80 a7 00 0d cmp %i4, %o5 4000e898: 32 80 00 04 bne,a 4000e8a8 <_POSIX_signals_Clear_signals+0x98> 4000e89c: c2 07 00 00 ld [ %i4 ], %g1 4000e8a0: 10 80 00 04 b 4000e8b0 <_POSIX_signals_Clear_signals+0xa0> <== NOT EXECUTED 4000e8a4: b8 10 20 00 clr %i4 <== NOT EXECUTED Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; 4000e8a8: c2 20 80 04 st %g1, [ %g2 + %g4 ] new_first->previous = _Chain_Head(the_chain); 4000e8ac: c6 20 60 04 st %g3, [ %g1 + 4 ] _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 4000e8b0: c2 00 c0 00 ld [ %g3 ], %g1 4000e8b4: 80 a0 40 0d cmp %g1, %o5 4000e8b8: 12 80 00 05 bne 4000e8cc <_POSIX_signals_Clear_signals+0xbc> 4000e8bc: 80 a7 20 00 cmp %i4, 0 _POSIX_signals_Clear_process_signals( mask ); 4000e8c0: 40 00 01 a7 call 4000ef5c <_POSIX_signals_Clear_process_signals> 4000e8c4: 90 10 00 10 mov %l0, %o0 if ( psiginfo ) { 4000e8c8: 80 a7 20 00 cmp %i4, 0 4000e8cc: 02 80 00 1b be 4000e938 <_POSIX_signals_Clear_signals+0x128> 4000e8d0: b0 10 20 01 mov 1, %i0 *info = psiginfo->Info; 4000e8d4: 90 10 00 1a mov %i2, %o0 4000e8d8: 92 07 20 08 add %i4, 8, %o1 4000e8dc: 40 00 03 8d call 4000f710 4000e8e0: 94 10 20 0c mov 0xc, %o2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4000e8e4: 03 10 00 6d sethi %hi(0x4001b400), %g1 4000e8e8: 82 10 61 e8 or %g1, 0x1e8, %g1 ! 4001b5e8 <_POSIX_signals_Inactive_siginfo+0x4> Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000e8ec: c2 27 00 00 st %g1, [ %i4 ] old_last_node = the_chain->last; 4000e8f0: 82 00 7f fc add %g1, -4, %g1 4000e8f4: c4 00 60 08 ld [ %g1 + 8 ], %g2 the_chain->last = the_node; 4000e8f8: f8 20 60 08 st %i4, [ %g1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000e8fc: c4 27 20 04 st %g2, [ %i4 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 4000e900: 10 80 00 0e b 4000e938 <_POSIX_signals_Clear_signals+0x128> 4000e904: f8 20 80 00 st %i4, [ %g2 ] &psiginfo->Node ); } else do_callout = FALSE; } else _POSIX_signals_Clear_process_signals( mask ); 4000e908: 40 00 01 95 call 4000ef5c <_POSIX_signals_Clear_process_signals> 4000e90c: 90 10 00 10 mov %l0, %o0 do_callout = TRUE; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; 4000e910: 10 80 00 0a b 4000e938 <_POSIX_signals_Clear_signals+0x128> 4000e914: b0 10 20 01 mov 1, %i0 } else _POSIX_signals_Clear_process_signals( mask ); do_callout = TRUE; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 4000e918: 82 0c 00 08 and %l0, %o0, %g1 4000e91c: 80 88 40 1c btst %g1, %i4 4000e920: 02 80 00 05 be 4000e934 <_POSIX_signals_Clear_signals+0x124> 4000e924: 82 2a 00 10 andn %o0, %l0, %g1 api->signals_pending &= ~mask; 4000e928: c2 26 20 c8 st %g1, [ %i0 + 0xc8 ] 4000e92c: 10 80 00 03 b 4000e938 <_POSIX_signals_Clear_signals+0x128> 4000e930: b0 10 20 01 mov 1, %i0 4000e934: b0 10 20 00 clr %i0 do_callout = TRUE; } } _ISR_Enable( level ); 4000e938: 7f ff cd 69 call 40001edc 4000e93c: 90 10 00 11 mov %l1, %o0 return do_callout; } 4000e940: 81 c7 e0 08 ret 4000e944: 81 e8 00 00 restore 4000710c <_POSIX_signals_Get_highest>: #include int _POSIX_signals_Get_highest( sigset_t set ) { 4000710c: 86 10 00 08 mov %o0, %g3 40007110: 90 10 20 1b mov 0x1b, %o0 int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) 40007114: 84 02 3f ff add %o0, -1, %g2 40007118: 82 10 20 01 mov 1, %g1 4000711c: 83 28 40 02 sll %g1, %g2, %g1 40007120: 80 88 40 03 btst %g1, %g3 40007124: 12 80 00 12 bne 4000716c <_POSIX_signals_Get_highest+0x60> 40007128: 01 00 00 00 nop sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 4000712c: 90 02 20 01 inc %o0 40007130: 80 a2 20 20 cmp %o0, 0x20 40007134: 12 bf ff f9 bne 40007118 <_POSIX_signals_Get_highest+0xc> 40007138: 84 02 3f ff add %o0, -1, %g2 4000713c: 90 10 20 01 mov 1, %o0 } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) 40007140: 84 02 3f ff add %o0, -1, %g2 40007144: 82 10 20 01 mov 1, %g1 40007148: 83 28 40 02 sll %g1, %g2, %g1 4000714c: 80 88 40 03 btst %g1, %g3 40007150: 12 80 00 07 bne 4000716c <_POSIX_signals_Get_highest+0x60> 40007154: 01 00 00 00 nop return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 40007158: 90 02 20 01 inc %o0 4000715c: 80 a2 20 1b cmp %o0, 0x1b 40007160: 12 bf ff f9 bne 40007144 <_POSIX_signals_Get_highest+0x38> 40007164: 84 02 3f ff add %o0, -1, %g2 40007168: 90 10 20 00 clr %o0 <== NOT EXECUTED if ( set & signo_to_mask( signo ) ) return signo; } return 0; } 4000716c: 81 c3 e0 08 retl 40007170: 01 00 00 00 nop 4000cdec <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) { 4000cdec: 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 ]; 4000cdf0: e0 06 21 70 ld [ %i0 + 0x170 ], %l0 * processed at all. No point in doing this loop otherwise. */ restart: _ISR_Disable( level ); if ( !(~api->signals_blocked & 4000cdf4: 23 10 00 6d sethi %hi(0x4001b400), %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 ); 4000cdf8: 7f ff d4 35 call 40001ecc 4000cdfc: 01 00 00 00 nop 4000ce00: b0 10 00 08 mov %o0, %i0 if ( !(~api->signals_blocked & 4000ce04: c2 04 62 30 ld [ %l1 + 0x230 ], %g1 4000ce08: c4 04 20 c8 ld [ %l0 + 0xc8 ], %g2 4000ce0c: c6 04 20 c4 ld [ %l0 + 0xc4 ], %g3 4000ce10: 82 10 40 02 or %g1, %g2, %g1 4000ce14: 80 a8 40 03 andncc %g1, %g3, %g0 4000ce18: 12 80 00 04 bne 4000ce28 <_POSIX_signals_Post_switch_extension+0x3c> 4000ce1c: 01 00 00 00 nop (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); 4000ce20: 7f ff d4 2f call 40001edc 4000ce24: 81 e8 00 00 restore return; } _ISR_Enable( level ); 4000ce28: 7f ff d4 2d call 40001edc 4000ce2c: b0 10 20 1b mov 0x1b, %i0 for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, FALSE ) ) 4000ce30: 92 10 00 18 mov %i0, %o1 4000ce34: 94 10 20 00 clr %o2 4000ce38: 40 00 06 42 call 4000e740 <_POSIX_signals_Check_signal> 4000ce3c: 90 10 00 10 mov %l0, %o0 4000ce40: 80 a2 20 00 cmp %o0, 0 4000ce44: 12 bf ff ed bne 4000cdf8 <_POSIX_signals_Post_switch_extension+0xc> 4000ce48: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) 4000ce4c: 90 10 00 10 mov %l0, %o0 4000ce50: 94 10 20 01 mov 1, %o2 4000ce54: 40 00 06 3b call 4000e740 <_POSIX_signals_Check_signal> 4000ce58: b0 06 20 01 inc %i0 4000ce5c: 80 a2 20 00 cmp %o0, 0 4000ce60: 12 bf ff e6 bne 4000cdf8 <_POSIX_signals_Post_switch_extension+0xc> 4000ce64: 80 a6 20 20 cmp %i0, 0x20 _ISR_Enable( level ); return; } _ISR_Enable( level ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 4000ce68: 12 bf ff f3 bne 4000ce34 <_POSIX_signals_Post_switch_extension+0x48> 4000ce6c: 92 10 00 18 mov %i0, %o1 4000ce70: 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 ) ) 4000ce74: 92 10 00 18 mov %i0, %o1 4000ce78: 94 10 20 00 clr %o2 4000ce7c: 40 00 06 31 call 4000e740 <_POSIX_signals_Check_signal> 4000ce80: 90 10 00 10 mov %l0, %o0 4000ce84: 80 a2 20 00 cmp %o0, 0 4000ce88: 12 bf ff dc bne 4000cdf8 <_POSIX_signals_Post_switch_extension+0xc> 4000ce8c: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) 4000ce90: 90 10 00 10 mov %l0, %o0 4000ce94: 94 10 20 01 mov 1, %o2 4000ce98: 40 00 06 2a call 4000e740 <_POSIX_signals_Check_signal> 4000ce9c: b0 06 20 01 inc %i0 4000cea0: 80 a2 20 00 cmp %o0, 0 4000cea4: 12 bf ff d5 bne 4000cdf8 <_POSIX_signals_Post_switch_extension+0xc> 4000cea8: 80 a6 20 1b cmp %i0, 0x1b } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 4000ceac: 12 bf ff f3 bne 4000ce78 <_POSIX_signals_Post_switch_extension+0x8c> 4000ceb0: 92 10 00 18 mov %i0, %o1 if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) goto restart; } } 4000ceb4: 81 c7 e0 08 ret <== NOT EXECUTED 4000ceb8: 81 e8 00 00 restore <== NOT EXECUTED 40023528 <_POSIX_signals_Unblock_thread>: boolean _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 40023528: 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 ) ) { 4002352c: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 40023530: 05 04 00 20 sethi %hi(0x10008000), %g2 sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; mask = signo_to_mask( signo ); 40023534: 82 06 7f ff add %i1, -1, %g1 40023538: 9a 10 20 01 mov 1, %o5 boolean _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 4002353c: 92 10 00 1a mov %i2, %o1 sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; mask = signo_to_mask( signo ); 40023540: 87 2b 40 01 sll %o5, %g1, %g3 /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 40023544: 82 09 00 02 and %g4, %g2, %g1 40023548: 80 a0 40 02 cmp %g1, %g2 4002354c: 12 80 00 19 bne 400235b0 <_POSIX_signals_Unblock_thread+0x88> 40023550: c4 06 21 70 ld [ %i0 + 0x170 ], %g2 if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 40023554: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 40023558: 80 88 c0 01 btst %g3, %g1 4002355c: 12 80 00 06 bne 40023574 <_POSIX_signals_Unblock_thread+0x4c> 40023560: 82 10 20 04 mov 4, %g1 40023564: c2 00 a0 c4 ld [ %g2 + 0xc4 ], %g1 40023568: 80 a8 c0 01 andncc %g3, %g1, %g0 4002356c: 02 80 00 31 be 40023630 <_POSIX_signals_Unblock_thread+0x108> 40023570: 82 10 20 04 mov 4, %g1 the_thread->Wait.return_code = EINTR; 40023574: c2 26 20 34 st %g1, [ %i0 + 0x34 ] the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { 40023578: 80 a2 60 00 cmp %o1, 0 4002357c: 12 80 00 06 bne 40023594 <_POSIX_signals_Unblock_thread+0x6c> 40023580: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 the_info->si_signo = signo; 40023584: f2 22 00 00 st %i1, [ %o0 ] the_info->si_code = SI_USER; 40023588: da 22 20 04 st %o5, [ %o0 + 4 ] the_info->si_value.sival_int = 0; 4002358c: 10 80 00 04 b 4002359c <_POSIX_signals_Unblock_thread+0x74> 40023590: c0 22 20 08 clr [ %o0 + 8 ] } else { *the_info = *info; 40023594: 7f ff d6 47 call 40018eb0 40023598: 94 10 20 0c mov 0xc, %o2 } _Thread_queue_Extract_with_proxy( the_thread ); 4002359c: 90 10 00 18 mov %i0, %o0 400235a0: 7f ff ad 61 call 4000eb24 <_Thread_queue_Extract_with_proxy> 400235a4: b0 10 20 01 mov 1, %i0 400235a8: 81 c7 e0 08 ret 400235ac: 81 e8 00 00 restore */ return FALSE; } if ( ~api->signals_blocked & mask ) { 400235b0: c2 00 a0 c4 ld [ %g2 + 0xc4 ], %g1 400235b4: 80 a8 c0 01 andncc %g3, %g1, %g0 400235b8: 02 80 00 1e be 40023630 <_POSIX_signals_Unblock_thread+0x108> 400235bc: 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 ) { 400235c0: 80 89 00 01 btst %g4, %g1 400235c4: 02 80 00 1b be 40023630 <_POSIX_signals_Unblock_thread+0x108> 400235c8: da 26 20 78 st %o5, [ %i0 + 0x78 ] the_thread->Wait.return_code = EINTR; 400235cc: 82 10 20 04 mov 4, %g1 400235d0: c2 26 20 34 st %g1, [ %i0 + 0x34 ] if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) 400235d4: 03 00 00 ef sethi %hi(0x3bc00), %g1 400235d8: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 400235dc: 80 89 00 01 btst %g4, %g1 400235e0: 02 80 00 06 be 400235f8 <_POSIX_signals_Unblock_thread+0xd0> 400235e4: 80 89 20 08 btst 8, %g4 _Thread_queue_Extract_with_proxy( the_thread ); 400235e8: 7f ff ad 4f call 4000eb24 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 400235ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 400235f0: 81 c7 e0 08 ret <== NOT EXECUTED 400235f4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED else if ( _States_Is_delaying(the_thread->current_state)){ 400235f8: 22 bf ff ec be,a 400235a8 <_POSIX_signals_Unblock_thread+0x80> 400235fc: b0 10 20 00 clr %i0 <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 40023600: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 40023604: 80 a0 60 02 cmp %g1, 2 40023608: 32 80 00 05 bne,a 4002361c <_POSIX_signals_Unblock_thread+0xf4> 4002360c: 13 04 00 ff sethi %hi(0x1003fc00), %o1 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 40023610: 7f ff b0 77 call 4000f7ec <_Watchdog_Remove> 40023614: 90 06 20 48 add %i0, 0x48, %o0 40023618: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4002361c: 90 10 00 18 mov %i0, %o0 40023620: 7f ff aa 50 call 4000df60 <_Thread_Clear_state> 40023624: 92 12 63 f8 or %o1, 0x3f8, %o1 40023628: 81 c7 e0 08 ret 4002362c: 91 e8 20 00 restore %g0, 0, %o0 40023630: b0 10 20 00 clr %i0 } } } return FALSE; } 40023634: 81 c7 e0 08 ret 40023638: 81 e8 00 00 restore 400089f4 <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 400089f4: 9d e3 bf 98 save %sp, -104, %sp void *p; _RTEMS_Lock_allocator(); 400089f8: 7f ff e5 35 call 40001ecc 400089fc: 01 00 00 00 nop 40008a00: a2 10 00 08 mov %o0, %l1 40008a04: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008a08: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 40008a0c: 80 a0 60 00 cmp %g1, 0 40008a10: 02 80 00 0b be 40008a3c <_Protected_heap_Allocate+0x48> 40008a14: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008a18: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008a1c: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 4001afb0 <_System_state_Current> 40008a20: 80 a0 60 01 cmp %g1, 1 40008a24: 08 80 00 05 bleu 40008a38 <_Protected_heap_Allocate+0x44> 40008a28: 90 10 20 00 clr %o0 40008a2c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008a30: 7f ff fd 8a call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 40008a34: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40008a38: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008a3c: e0 00 62 a4 ld [ %g1 + 0x2a4 ], %l0 ! 4001aea4 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40008a40: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008a44: c4 00 62 ac ld [ %g1 + 0x2ac ], %g2 ! 4001aeac <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40008a48: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40008a4c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40008a50: 80 a0 60 00 cmp %g1, 0 40008a54: 22 80 00 33 be,a 40008b20 <_Protected_heap_Allocate+0x12c> 40008a58: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40008a5c: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40008a60: 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; 40008a64: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; 40008a68: 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; 40008a6c: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 40008a70: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40008a74: 80 a0 e0 02 cmp %g3, 2 40008a78: 02 80 00 05 be 40008a8c <_Protected_heap_Allocate+0x98> 40008a7c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 40008a80: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40008a84: 32 80 00 06 bne,a 40008a9c <_Protected_heap_Allocate+0xa8> <== NOT EXECUTED 40008a88: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008a8c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 40008a90: 82 00 60 01 inc %g1 40008a94: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008a98: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 40008a9c: 80 a0 60 03 cmp %g1, 3 40008aa0: 22 80 00 03 be,a 40008aac <_Protected_heap_Allocate+0xb8> 40008aa4: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 40008aa8: 30 80 00 2c b,a 40008b58 <_Protected_heap_Allocate+0x164> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 40008aac: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40008ab0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40008ab4: 12 80 00 03 bne 40008ac0 <_Protected_heap_Allocate+0xcc> <== NOT EXECUTED 40008ab8: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 40008abc: 30 80 00 27 b,a 40008b58 <_Protected_heap_Allocate+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 40008ac0: 08 80 00 10 bleu 40008b00 <_Protected_heap_Allocate+0x10c> <== NOT EXECUTED 40008ac4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008ac8: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 40008acc: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40008ad0: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008ad4: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40008ad8: 7f ff e5 01 call 40001edc <== NOT EXECUTED 40008adc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 40008ae0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40008ae4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40008ae8: 40 00 02 95 call 4000953c <_Thread_Change_priority> <== NOT EXECUTED 40008aec: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 40008af0: 7f ff ff b4 call 400089c0 <_Thread_Enable_dispatch> <== NOT EXECUTED 40008af4: 01 00 00 00 nop <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 40008af8: 10 80 00 32 b 40008bc0 <_Protected_heap_Allocate+0x1cc> <== NOT EXECUTED 40008afc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40008b00: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008b04: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40008b08: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008b0c: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 40008b10: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008b14: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008b18: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40008b1c: 30 80 00 0f b,a 40008b58 <_Protected_heap_Allocate+0x164> <== 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 ) ) { 40008b20: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40008b24: 32 80 00 13 bne,a 40008b70 <_Protected_heap_Allocate+0x17c> <== NOT EXECUTED 40008b28: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40008b2c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 4001ac50 <== NOT EXECUTED 40008b30: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008b34: 22 80 00 07 be,a 40008b50 <_Protected_heap_Allocate+0x15c> <== NOT EXECUTED 40008b38: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40008b3c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40008b40: 32 80 00 0c bne,a 40008b70 <_Protected_heap_Allocate+0x17c> <== NOT EXECUTED 40008b44: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== 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; 40008b48: 10 80 00 08 b 40008b68 <_Protected_heap_Allocate+0x174> <== NOT EXECUTED 40008b4c: 82 10 20 02 mov 2, %g1 <== 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++; 40008b50: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008b54: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40008b58: 7f ff e4 e1 call 40001edc 40008b5c: 90 10 00 11 mov %l1, %o0 40008b60: 10 80 00 18 b 40008bc0 <_Protected_heap_Allocate+0x1cc> 40008b64: 90 10 00 18 mov %i0, %o0 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40008b68: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40008b6c: 30 bf ff fb b,a 40008b58 <_Protected_heap_Allocate+0x164> <== NOT EXECUTED size_t size ) { void *p; _RTEMS_Lock_allocator(); 40008b70: c6 04 22 a4 ld [ %l0 + 0x2a4 ], %g3 <== NOT EXECUTED 40008b74: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008b78: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 40008b7c: c8 00 62 ac ld [ %g1 + 0x2ac ], %g4 <== NOT EXECUTED 40008b80: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 40008b84: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40008b88: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 40008b8c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008b90: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED 40008b94: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 40008b98: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== 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; 40008b9c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40008ba0: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40008ba4: 7f ff e4 ce call 40001edc <== NOT EXECUTED 40008ba8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40008bac: d0 04 22 a4 ld [ %l0 + 0x2a4 ], %o0 <== NOT EXECUTED 40008bb0: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008bb4: 7f ff fb 0f call 400077f0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40008bb8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 40008bbc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008bc0: 7f ff fb fb call 40007bac <_Heap_Allocate> 40008bc4: 92 10 00 19 mov %i1, %o1 40008bc8: 05 10 00 6b sethi %hi(0x4001ac00), %g2 40008bcc: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 40008bd0: b0 10 00 08 mov %o0, %i0 40008bd4: 82 00 60 01 inc %g1 40008bd8: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] _RTEMS_Unlock_allocator(); 40008bdc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008be0: d0 00 62 a4 ld [ %g1 + 0x2a4 ], %o0 ! 4001aea4 <_RTEMS_Allocator_Mutex> 40008be4: 94 10 20 00 clr %o2 40008be8: d2 02 20 08 ld [ %o0 + 8 ], %o1 40008bec: 7f ff fb 23 call 40007878 <_CORE_mutex_Surrender> 40008bf0: 90 02 20 10 add %o0, 0x10, %o0 40008bf4: 7f ff ff 73 call 400089c0 <_Thread_Enable_dispatch> 40008bf8: 01 00 00 00 nop return p; } 40008bfc: 81 c7 e0 08 ret 40008c00: 81 e8 00 00 restore 40008c38 <_Protected_heap_Extend>: boolean _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 40008c38: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 40008c3c: 7f ff e4 a4 call 40001ecc <== NOT EXECUTED 40008c40: 01 00 00 00 nop <== NOT EXECUTED 40008c44: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 40008c48: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008c4c: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40008c50: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008c54: 02 80 00 0b be 40008c80 <_Protected_heap_Extend+0x48> <== NOT EXECUTED 40008c58: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008c5c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008c60: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 4001afb0 <_System_state_Current> <== NOT EXECUTED 40008c64: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40008c68: 08 80 00 05 bleu 40008c7c <_Protected_heap_Extend+0x44> <== NOT EXECUTED 40008c6c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40008c70: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008c74: 7f ff fc f9 call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 40008c78: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40008c7c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008c80: e0 00 62 a4 ld [ %g1 + 0x2a4 ], %l0 ! 4001aea4 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40008c84: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008c88: c4 00 62 ac ld [ %g1 + 0x2ac ], %g2 ! 4001aeac <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40008c8c: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40008c90: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 40008c94: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008c98: 22 80 00 33 be,a 40008d64 <_Protected_heap_Extend+0x12c> <== NOT EXECUTED 40008c9c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40008ca0: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40008ca4: 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; 40008ca8: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== 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; 40008cac: 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; 40008cb0: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 40008cb4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40008cb8: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 40008cbc: 02 80 00 05 be 40008cd0 <_Protected_heap_Extend+0x98> <== NOT EXECUTED 40008cc0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 40008cc4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40008cc8: 32 80 00 06 bne,a 40008ce0 <_Protected_heap_Extend+0xa8> <== NOT EXECUTED 40008ccc: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008cd0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008cd4: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008cd8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008cdc: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 40008ce0: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 40008ce4: 22 80 00 03 be,a 40008cf0 <_Protected_heap_Extend+0xb8> <== NOT EXECUTED 40008ce8: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 40008cec: 30 80 00 2c b,a 40008d9c <_Protected_heap_Extend+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 40008cf0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40008cf4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40008cf8: 12 80 00 03 bne 40008d04 <_Protected_heap_Extend+0xcc> <== NOT EXECUTED 40008cfc: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 40008d00: 30 80 00 27 b,a 40008d9c <_Protected_heap_Extend+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 40008d04: 08 80 00 10 bleu 40008d44 <_Protected_heap_Extend+0x10c> <== NOT EXECUTED 40008d08: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008d0c: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 40008d10: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40008d14: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008d18: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40008d1c: 7f ff e4 70 call 40001edc <== NOT EXECUTED 40008d20: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 40008d24: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40008d28: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40008d2c: 40 00 02 04 call 4000953c <_Thread_Change_priority> <== NOT EXECUTED 40008d30: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 40008d34: 7f ff ff b4 call 40008c04 <_Thread_Enable_dispatch> <== NOT EXECUTED 40008d38: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 40008d3c: 10 80 00 32 b 40008e04 <_Protected_heap_Extend+0x1cc> <== NOT EXECUTED 40008d40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40008d44: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008d48: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40008d4c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008d50: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 40008d54: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008d58: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008d5c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40008d60: 30 80 00 0f b,a 40008d9c <_Protected_heap_Extend+0x164> <== 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 ) ) { 40008d64: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40008d68: 32 80 00 13 bne,a 40008db4 <_Protected_heap_Extend+0x17c> <== NOT EXECUTED 40008d6c: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40008d70: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 4001ac50 <== NOT EXECUTED 40008d74: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008d78: 22 80 00 07 be,a 40008d94 <_Protected_heap_Extend+0x15c> <== NOT EXECUTED 40008d7c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40008d80: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40008d84: 12 80 00 0c bne 40008db4 <_Protected_heap_Extend+0x17c> <== NOT EXECUTED 40008d88: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== 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; 40008d8c: 10 80 00 08 b 40008dac <_Protected_heap_Extend+0x174> <== NOT EXECUTED 40008d90: 82 10 20 02 mov 2, %g1 <== 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++; 40008d94: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008d98: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40008d9c: 7f ff e4 50 call 40001edc <== NOT EXECUTED 40008da0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40008da4: 10 80 00 18 b 40008e04 <_Protected_heap_Extend+0x1cc> <== NOT EXECUTED 40008da8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40008dac: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40008db0: 30 bf ff fb b,a 40008d9c <_Protected_heap_Extend+0x164> <== NOT EXECUTED ) { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 40008db4: c6 04 22 a4 ld [ %l0 + 0x2a4 ], %g3 <== NOT EXECUTED 40008db8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008dbc: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 40008dc0: c8 00 62 ac ld [ %g1 + 0x2ac ], %g4 <== NOT EXECUTED 40008dc4: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 40008dc8: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40008dcc: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 40008dd0: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008dd4: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED 40008dd8: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 40008ddc: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 40008de0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40008de4: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40008de8: 7f ff e4 3d call 40001edc <== NOT EXECUTED 40008dec: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40008df0: d0 04 22 a4 ld [ %l0 + 0x2a4 ], %o0 <== NOT EXECUTED 40008df4: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008df8: 7f ff fa 7e call 400077f0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40008dfc: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 40008e00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008e04: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40008e08: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40008e0c: 40 00 12 7f call 4000d808 <_Heap_Extend> <== NOT EXECUTED 40008e10: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 40008e14: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 40008e18: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40008e1c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 40008e20: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008e24: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 40008e28: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008e2c: d0 00 62 a4 ld [ %g1 + 0x2a4 ], %o0 ! 4001aea4 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 40008e30: 94 10 20 00 clr %o2 <== NOT EXECUTED 40008e34: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40008e38: 7f ff fa 90 call 40007878 <_CORE_mutex_Surrender> <== NOT EXECUTED 40008e3c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40008e40: 7f ff ff 71 call 40008c04 <_Thread_Enable_dispatch> <== NOT EXECUTED 40008e44: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 40008e48: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 40008e4c: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 40008e50: 81 c7 e0 08 ret <== NOT EXECUTED 40008e54: 81 e8 00 00 restore <== NOT EXECUTED 40008e8c <_Protected_heap_Free>: boolean _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 40008e8c: 9d e3 bf 98 save %sp, -104, %sp boolean status; _RTEMS_Lock_allocator(); 40008e90: 7f ff e4 0f call 40001ecc 40008e94: 01 00 00 00 nop 40008e98: a2 10 00 08 mov %o0, %l1 40008e9c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008ea0: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 40008ea4: 80 a0 60 00 cmp %g1, 0 40008ea8: 02 80 00 0b be 40008ed4 <_Protected_heap_Free+0x48> 40008eac: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008eb0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008eb4: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 4001afb0 <_System_state_Current> <== NOT EXECUTED 40008eb8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40008ebc: 08 80 00 05 bleu 40008ed0 <_Protected_heap_Free+0x44> <== NOT EXECUTED 40008ec0: 90 10 20 00 clr %o0 <== NOT EXECUTED 40008ec4: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008ec8: 7f ff fc 64 call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 40008ecc: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40008ed0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40008ed4: e0 00 62 a4 ld [ %g1 + 0x2a4 ], %l0 ! 4001aea4 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40008ed8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008edc: c4 00 62 ac ld [ %g1 + 0x2ac ], %g2 ! 4001aeac <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40008ee0: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40008ee4: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40008ee8: 80 a0 60 00 cmp %g1, 0 40008eec: 22 80 00 33 be,a 40008fb8 <_Protected_heap_Free+0x12c> 40008ef0: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40008ef4: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40008ef8: 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; 40008efc: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; 40008f00: 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; 40008f04: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 40008f08: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40008f0c: 80 a0 e0 02 cmp %g3, 2 40008f10: 02 80 00 05 be 40008f24 <_Protected_heap_Free+0x98> 40008f14: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 40008f18: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40008f1c: 32 80 00 06 bne,a 40008f34 <_Protected_heap_Free+0xa8> <== NOT EXECUTED 40008f20: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008f24: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 40008f28: 82 00 60 01 inc %g1 40008f2c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008f30: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 40008f34: 80 a0 60 03 cmp %g1, 3 40008f38: 22 80 00 03 be,a 40008f44 <_Protected_heap_Free+0xb8> 40008f3c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 40008f40: 30 80 00 2c b,a 40008ff0 <_Protected_heap_Free+0x164> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 40008f44: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40008f48: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40008f4c: 12 80 00 03 bne 40008f58 <_Protected_heap_Free+0xcc> <== NOT EXECUTED 40008f50: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 40008f54: 30 80 00 27 b,a 40008ff0 <_Protected_heap_Free+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 40008f58: 08 80 00 10 bleu 40008f98 <_Protected_heap_Free+0x10c> <== NOT EXECUTED 40008f5c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008f60: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 40008f64: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40008f68: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008f6c: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40008f70: 7f ff e3 db call 40001edc <== NOT EXECUTED 40008f74: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 40008f78: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40008f7c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40008f80: 40 00 01 6f call 4000953c <_Thread_Change_priority> <== NOT EXECUTED 40008f84: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 40008f88: 7f ff ff b4 call 40008e58 <_Thread_Enable_dispatch> <== NOT EXECUTED 40008f8c: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 40008f90: 10 80 00 32 b 40009058 <_Protected_heap_Free+0x1cc> <== NOT EXECUTED 40008f94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40008f98: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008f9c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40008fa0: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008fa4: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 40008fa8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008fac: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008fb0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40008fb4: 30 80 00 0f b,a 40008ff0 <_Protected_heap_Free+0x164> <== 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 ) ) { 40008fb8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40008fbc: 32 80 00 13 bne,a 40009008 <_Protected_heap_Free+0x17c> <== NOT EXECUTED 40008fc0: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40008fc4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 4001ac50 <== NOT EXECUTED 40008fc8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008fcc: 22 80 00 07 be,a 40008fe8 <_Protected_heap_Free+0x15c> <== NOT EXECUTED 40008fd0: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40008fd4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40008fd8: 32 80 00 0c bne,a 40009008 <_Protected_heap_Free+0x17c> <== NOT EXECUTED 40008fdc: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== 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; 40008fe0: 10 80 00 08 b 40009000 <_Protected_heap_Free+0x174> <== NOT EXECUTED 40008fe4: 82 10 20 02 mov 2, %g1 <== 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++; 40008fe8: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008fec: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40008ff0: 7f ff e3 bb call 40001edc 40008ff4: 90 10 00 11 mov %l1, %o0 40008ff8: 10 80 00 18 b 40009058 <_Protected_heap_Free+0x1cc> 40008ffc: 90 10 00 18 mov %i0, %o0 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40009000: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40009004: 30 bf ff fb b,a 40008ff0 <_Protected_heap_Free+0x164> <== NOT EXECUTED void *start_address ) { boolean status; _RTEMS_Lock_allocator(); 40009008: c6 04 22 a4 ld [ %l0 + 0x2a4 ], %g3 <== NOT EXECUTED 4000900c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009010: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 40009014: c8 00 62 ac ld [ %g1 + 0x2ac ], %g4 <== NOT EXECUTED 40009018: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 4000901c: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009020: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 40009024: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009028: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED 4000902c: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 40009030: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 40009034: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40009038: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 4000903c: 7f ff e3 a8 call 40001edc <== NOT EXECUTED 40009040: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40009044: d0 04 22 a4 ld [ %l0 + 0x2a4 ], %o0 <== NOT EXECUTED 40009048: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000904c: 7f ff f9 e9 call 400077f0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40009050: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 40009054: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009058: 7f ff fa fc call 40007c48 <_Heap_Free> 4000905c: 92 10 00 19 mov %i1, %o1 40009060: 05 10 00 6b sethi %hi(0x4001ac00), %g2 40009064: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 40009068: b0 10 00 08 mov %o0, %i0 4000906c: 82 00 60 01 inc %g1 40009070: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] _RTEMS_Unlock_allocator(); 40009074: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009078: d0 00 62 a4 ld [ %g1 + 0x2a4 ], %o0 ! 4001aea4 <_RTEMS_Allocator_Mutex> 4000907c: 94 10 20 00 clr %o2 40009080: d2 02 20 08 ld [ %o0 + 8 ], %o1 40009084: 7f ff f9 fd call 40007878 <_CORE_mutex_Surrender> 40009088: 90 02 20 10 add %o0, 0x10, %o0 4000908c: 7f ff ff 73 call 40008e58 <_Thread_Enable_dispatch> 40009090: 01 00 00 00 nop return status; } 40009094: 81 c7 e0 08 ret 40009098: 81 e8 00 00 restore 400090d0 <_Protected_heap_Get_block_size>: boolean _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 400090d0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED boolean status; _RTEMS_Lock_allocator(); 400090d4: 7f ff e3 7e call 40001ecc <== NOT EXECUTED 400090d8: 01 00 00 00 nop <== NOT EXECUTED 400090dc: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 400090e0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 400090e4: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400090e8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400090ec: 02 80 00 0b be 40009118 <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 400090f0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 400090f4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 400090f8: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 4001afb0 <_System_state_Current> <== NOT EXECUTED 400090fc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40009100: 08 80 00 05 bleu 40009114 <_Protected_heap_Get_block_size+0x44> <== NOT EXECUTED 40009104: 90 10 20 00 clr %o0 <== NOT EXECUTED 40009108: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000910c: 7f ff fb d3 call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 40009110: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40009114: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009118: e0 00 62 a4 ld [ %g1 + 0x2a4 ], %l0 ! 4001aea4 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 4000911c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009120: c4 00 62 ac ld [ %g1 + 0x2ac ], %g2 ! 4001aeac <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40009124: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40009128: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 4000912c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009130: 22 80 00 33 be,a 400091fc <_Protected_heap_Get_block_size+0x12c> <== NOT EXECUTED 40009134: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40009138: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 4000913c: 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; 40009140: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== 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; 40009144: 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; 40009148: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 4000914c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40009150: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 40009154: 02 80 00 05 be 40009168 <_Protected_heap_Get_block_size+0x98> <== NOT EXECUTED 40009158: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 4000915c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40009160: 32 80 00 06 bne,a 40009178 <_Protected_heap_Get_block_size+0xa8> <== NOT EXECUTED 40009164: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40009168: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4000916c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009170: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40009174: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 40009178: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 4000917c: 22 80 00 03 be,a 40009188 <_Protected_heap_Get_block_size+0xb8> <== NOT EXECUTED 40009180: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 40009184: 30 80 00 2c b,a 40009234 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 40009188: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 4000918c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40009190: 12 80 00 03 bne 4000919c <_Protected_heap_Get_block_size+0xcc> <== NOT EXECUTED 40009194: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 40009198: 30 80 00 27 b,a 40009234 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 4000919c: 08 80 00 10 bleu 400091dc <_Protected_heap_Get_block_size+0x10c> <== NOT EXECUTED 400091a0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400091a4: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 400091a8: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400091ac: 82 00 60 01 inc %g1 <== NOT EXECUTED 400091b0: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 400091b4: 7f ff e3 4a call 40001edc <== NOT EXECUTED 400091b8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 400091bc: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 400091c0: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 400091c4: 40 00 00 de call 4000953c <_Thread_Change_priority> <== NOT EXECUTED 400091c8: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 400091cc: 7f ff ff b4 call 4000909c <_Thread_Enable_dispatch> <== NOT EXECUTED 400091d0: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 400091d4: 10 80 00 32 b 4000929c <_Protected_heap_Get_block_size+0x1cc> <== NOT EXECUTED 400091d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 400091dc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400091e0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 400091e4: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 400091e8: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 400091ec: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400091f0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400091f4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400091f8: 30 80 00 0f b,a 40009234 <_Protected_heap_Get_block_size+0x164> <== 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 ) ) { 400091fc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40009200: 32 80 00 13 bne,a 4000924c <_Protected_heap_Get_block_size+0x17c> <== NOT EXECUTED 40009204: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40009208: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 4001ac50 <== NOT EXECUTED 4000920c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009210: 22 80 00 07 be,a 4000922c <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 40009214: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40009218: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000921c: 32 80 00 0c bne,a 4000924c <_Protected_heap_Get_block_size+0x17c> <== NOT EXECUTED 40009220: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== 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; 40009224: 10 80 00 08 b 40009244 <_Protected_heap_Get_block_size+0x174> <== NOT EXECUTED 40009228: 82 10 20 02 mov 2, %g1 <== 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++; 4000922c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009230: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40009234: 7f ff e3 2a call 40001edc <== NOT EXECUTED 40009238: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 4000923c: 10 80 00 18 b 4000929c <_Protected_heap_Get_block_size+0x1cc> <== NOT EXECUTED 40009240: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40009244: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40009248: 30 bf ff fb b,a 40009234 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED size_t *size ) { boolean status; _RTEMS_Lock_allocator(); 4000924c: c6 04 22 a4 ld [ %l0 + 0x2a4 ], %g3 <== NOT EXECUTED 40009250: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009254: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 40009258: c8 00 62 ac ld [ %g1 + 0x2ac ], %g4 <== NOT EXECUTED 4000925c: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 40009260: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009264: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 40009268: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000926c: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED 40009270: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 40009274: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 40009278: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4000927c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40009280: 7f ff e3 17 call 40001edc <== NOT EXECUTED 40009284: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40009288: d0 04 22 a4 ld [ %l0 + 0x2a4 ], %o0 <== NOT EXECUTED 4000928c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40009290: 7f ff f9 58 call 400077f0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40009294: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 40009298: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000929c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 400092a0: 40 00 12 14 call 4000daf0 <_Heap_Size_of_user_area> <== NOT EXECUTED 400092a4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 400092a8: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 400092ac: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400092b0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 400092b4: 82 00 60 01 inc %g1 <== NOT EXECUTED 400092b8: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 400092bc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 400092c0: d0 00 62 a4 ld [ %g1 + 0x2a4 ], %o0 ! 4001aea4 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 400092c4: 94 10 20 00 clr %o2 <== NOT EXECUTED 400092c8: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 400092cc: 7f ff f9 6b call 40007878 <_CORE_mutex_Surrender> <== NOT EXECUTED 400092d0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 400092d4: 7f ff ff 72 call 4000909c <_Thread_Enable_dispatch> <== NOT EXECUTED 400092d8: 01 00 00 00 nop <== NOT EXECUTED return status; } 400092dc: 81 c7 e0 08 ret <== NOT EXECUTED 400092e0: 81 e8 00 00 restore <== NOT EXECUTED 4000c898 <_Protected_heap_Get_free_information>: void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 4000c898: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 4000c89c: 7f ff dd 24 call 40003d2c <== NOT EXECUTED 4000c8a0: 01 00 00 00 nop <== NOT EXECUTED 4000c8a4: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 4000c8a8: 03 10 00 ef sethi %hi(0x4003bc00), %g1 <== NOT EXECUTED 4000c8ac: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 ! 4003bf20 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000c8b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000c8b4: 02 80 00 0b be 4000c8e0 <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 4000c8b8: 03 10 00 ef sethi %hi(0x4003bc00), %g1 <== NOT EXECUTED 4000c8bc: 03 10 00 f0 sethi %hi(0x4003c000), %g1 <== NOT EXECUTED 4000c8c0: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 4003c100 <_System_state_Current> <== NOT EXECUTED 4000c8c4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000c8c8: 08 80 00 05 bleu 4000c8dc <_Protected_heap_Get_free_information+0x44> <== NOT EXECUTED 4000c8cc: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000c8d0: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000c8d4: 7f ff fb 80 call 4000b6d4 <_Internal_error_Occurred> <== NOT EXECUTED 4000c8d8: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 4000c8dc: 03 10 00 ef sethi %hi(0x4003bc00), %g1 <== NOT EXECUTED 4000c8e0: e0 00 63 f4 ld [ %g1 + 0x3f4 ], %l0 ! 4003bff4 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 4000c8e4: 03 10 00 ef sethi %hi(0x4003bc00), %g1 <== NOT EXECUTED 4000c8e8: c4 00 63 fc ld [ %g1 + 0x3fc ], %g2 ! 4003bffc <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 4000c8ec: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 4000c8f0: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 4000c8f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000c8f8: 22 80 00 33 be,a 4000c9c4 <_Protected_heap_Get_free_information+0x12c> <== NOT EXECUTED 4000c8fc: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 4000c900: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 4000c904: 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; 4000c908: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== 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; 4000c90c: 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; 4000c910: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 4000c914: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4000c918: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 4000c91c: 02 80 00 05 be 4000c930 <_Protected_heap_Get_free_information+0x98> <== NOT EXECUTED 4000c920: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 4000c924: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 4000c928: 32 80 00 06 bne,a 4000c940 <_Protected_heap_Get_free_information+0xa8> <== NOT EXECUTED 4000c92c: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4000c930: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4000c934: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c938: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000c93c: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 4000c940: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 4000c944: 22 80 00 03 be,a 4000c950 <_Protected_heap_Get_free_information+0xb8> <== NOT EXECUTED 4000c948: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 4000c94c: 30 80 00 2c b,a 4000c9fc <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 4000c950: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 4000c954: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4000c958: 12 80 00 03 bne 4000c964 <_Protected_heap_Get_free_information+0xcc> <== NOT EXECUTED 4000c95c: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 4000c960: 30 80 00 27 b,a 4000c9fc <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 4000c964: 08 80 00 10 bleu 4000c9a4 <_Protected_heap_Get_free_information+0x10c> <== NOT EXECUTED 4000c968: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000c96c: 05 10 00 ef sethi %hi(0x4003bc00), %g2 <== NOT EXECUTED 4000c970: c2 00 a3 20 ld [ %g2 + 0x320 ], %g1 ! 4003bf20 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000c974: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c978: c2 20 a3 20 st %g1, [ %g2 + 0x320 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 4000c97c: 7f ff dc f0 call 40003d3c <== NOT EXECUTED 4000c980: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 4000c984: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 4000c988: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 4000c98c: 40 00 00 db call 4000ccf8 <_Thread_Change_priority> <== NOT EXECUTED 4000c990: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 4000c994: 7f ff ff b4 call 4000c864 <_Thread_Enable_dispatch> <== NOT EXECUTED 4000c998: 01 00 00 00 nop <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 4000c99c: 10 80 00 32 b 4000ca64 <_Protected_heap_Get_free_information+0x1cc> <== NOT EXECUTED 4000c9a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 4000c9a4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 4000c9a8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4000c9ac: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 4000c9b0: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 4000c9b4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4000c9b8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000c9bc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000c9c0: 30 80 00 0f b,a 4000c9fc <_Protected_heap_Get_free_information+0x164> <== 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 ) ) { 4000c9c4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 4000c9c8: 32 80 00 13 bne,a 4000ca14 <_Protected_heap_Get_free_information+0x17c> <== NOT EXECUTED 4000c9cc: 21 10 00 ef sethi %hi(0x4003bc00), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 4000c9d0: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 4003bc50 <== NOT EXECUTED 4000c9d4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000c9d8: 22 80 00 07 be,a 4000c9f4 <_Protected_heap_Get_free_information+0x15c> <== NOT EXECUTED 4000c9dc: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 4000c9e0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000c9e4: 32 80 00 0c bne,a 4000ca14 <_Protected_heap_Get_free_information+0x17c> <== NOT EXECUTED 4000c9e8: 21 10 00 ef sethi %hi(0x4003bc00), %l0 <== 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; 4000c9ec: 10 80 00 08 b 4000ca0c <_Protected_heap_Get_free_information+0x174> <== NOT EXECUTED 4000c9f0: 82 10 20 02 mov 2, %g1 <== 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++; 4000c9f4: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c9f8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 4000c9fc: 7f ff dc d0 call 40003d3c <== NOT EXECUTED 4000ca00: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 4000ca04: 10 80 00 18 b 4000ca64 <_Protected_heap_Get_free_information+0x1cc> <== NOT EXECUTED 4000ca08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 4000ca0c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 4000ca10: 30 bf ff fb b,a 4000c9fc <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); 4000ca14: c6 04 23 f4 ld [ %l0 + 0x3f4 ], %g3 <== NOT EXECUTED 4000ca18: 03 10 00 ef sethi %hi(0x4003bc00), %g1 <== NOT EXECUTED 4000ca1c: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 4000ca20: c8 00 63 fc ld [ %g1 + 0x3fc ], %g4 <== NOT EXECUTED 4000ca24: 05 10 00 ef sethi %hi(0x4003bc00), %g2 <== NOT EXECUTED 4000ca28: c2 00 a3 20 ld [ %g2 + 0x320 ], %g1 ! 4003bf20 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000ca2c: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 4000ca30: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000ca34: c2 20 a3 20 st %g1, [ %g2 + 0x320 ] <== NOT EXECUTED 4000ca38: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 4000ca3c: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 4000ca40: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4000ca44: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 4000ca48: 7f ff dc bd call 40003d3c <== NOT EXECUTED 4000ca4c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 4000ca50: d0 04 23 f4 ld [ %l0 + 0x3f4 ], %o0 <== NOT EXECUTED 4000ca54: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000ca58: 7f ff f9 05 call 4000ae6c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 4000ca5c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 4000ca60: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000ca64: 40 00 34 d0 call 40019da4 <_Heap_Get_free_information> <== NOT EXECUTED 4000ca68: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000ca6c: 05 10 00 ef sethi %hi(0x4003bc00), %g2 <== NOT EXECUTED 4000ca70: c2 00 a3 20 ld [ %g2 + 0x320 ], %g1 ! 4003bf20 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000ca74: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000ca78: c2 20 a3 20 st %g1, [ %g2 + 0x320 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 4000ca7c: 03 10 00 ef sethi %hi(0x4003bc00), %g1 <== NOT EXECUTED 4000ca80: d0 00 63 f4 ld [ %g1 + 0x3f4 ], %o0 ! 4003bff4 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 4000ca84: 94 10 20 00 clr %o2 <== NOT EXECUTED 4000ca88: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 4000ca8c: 7f ff f9 1a call 4000aef4 <_CORE_mutex_Surrender> <== NOT EXECUTED 4000ca90: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 4000ca94: 7f ff ff 74 call 4000c864 <_Thread_Enable_dispatch> <== NOT EXECUTED 4000ca98: 81 e8 00 00 restore <== NOT EXECUTED 4000ca9c: 01 00 00 00 nop 40009318 <_Protected_heap_Resize_block>: boolean _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 40009318: 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(); 4000931c: 7f ff e2 ec call 40001ecc <== NOT EXECUTED 40009320: 01 00 00 00 nop <== NOT EXECUTED 40009324: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 40009328: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000932c: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009330: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009334: 02 80 00 0b be 40009360 <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 40009338: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000933c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009340: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 4001afb0 <_System_state_Current> <== NOT EXECUTED 40009344: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40009348: 08 80 00 05 bleu 4000935c <_Protected_heap_Resize_block+0x44> <== NOT EXECUTED 4000934c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40009350: 92 10 20 00 clr %o1 <== NOT EXECUTED 40009354: 7f ff fb 41 call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 40009358: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 4000935c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009360: e0 00 62 a4 ld [ %g1 + 0x2a4 ], %l0 ! 4001aea4 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40009364: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009368: c4 00 62 ac ld [ %g1 + 0x2ac ], %g2 ! 4001aeac <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 4000936c: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40009370: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 40009374: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009378: 22 80 00 33 be,a 40009444 <_Protected_heap_Resize_block+0x12c> <== NOT EXECUTED 4000937c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40009380: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40009384: 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; 40009388: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== 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; 4000938c: 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; 40009390: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 40009394: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40009398: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 4000939c: 02 80 00 05 be 400093b0 <_Protected_heap_Resize_block+0x98> <== NOT EXECUTED 400093a0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 400093a4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 400093a8: 32 80 00 06 bne,a 400093c0 <_Protected_heap_Resize_block+0xa8> <== NOT EXECUTED 400093ac: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400093b0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400093b4: 82 00 60 01 inc %g1 <== NOT EXECUTED 400093b8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400093bc: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 400093c0: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 400093c4: 22 80 00 03 be,a 400093d0 <_Protected_heap_Resize_block+0xb8> <== NOT EXECUTED 400093c8: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 400093cc: 30 80 00 2c b,a 4000947c <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 400093d0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 400093d4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 400093d8: 12 80 00 03 bne 400093e4 <_Protected_heap_Resize_block+0xcc> <== NOT EXECUTED 400093dc: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 400093e0: 30 80 00 27 b,a 4000947c <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 400093e4: 08 80 00 10 bleu 40009424 <_Protected_heap_Resize_block+0x10c> <== NOT EXECUTED 400093e8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400093ec: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 400093f0: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400093f4: 82 00 60 01 inc %g1 <== NOT EXECUTED 400093f8: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 400093fc: 7f ff e2 b8 call 40001edc <== NOT EXECUTED 40009400: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 40009404: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40009408: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 4000940c: 40 00 00 4c call 4000953c <_Thread_Change_priority> <== NOT EXECUTED 40009410: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 40009414: 7f ff ff b4 call 400092e4 <_Thread_Enable_dispatch> <== NOT EXECUTED 40009418: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Resize_block( 4000941c: 10 80 00 32 b 400094e4 <_Protected_heap_Resize_block+0x1cc> <== NOT EXECUTED 40009420: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40009424: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40009428: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4000942c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 40009430: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 40009434: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40009438: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000943c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40009440: 30 80 00 0f b,a 4000947c <_Protected_heap_Resize_block+0x164> <== 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 ) ) { 40009444: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40009448: 32 80 00 13 bne,a 40009494 <_Protected_heap_Resize_block+0x17c> <== NOT EXECUTED 4000944c: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40009450: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 4001ac50 <== NOT EXECUTED 40009454: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009458: 22 80 00 07 be,a 40009474 <_Protected_heap_Resize_block+0x15c> <== NOT EXECUTED 4000945c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40009460: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40009464: 12 80 00 0c bne 40009494 <_Protected_heap_Resize_block+0x17c> <== NOT EXECUTED 40009468: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== 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; 4000946c: 10 80 00 08 b 4000948c <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 40009470: 82 10 20 02 mov 2, %g1 <== 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++; 40009474: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009478: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 4000947c: 7f ff e2 98 call 40001edc <== NOT EXECUTED 40009480: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40009484: 10 80 00 18 b 400094e4 <_Protected_heap_Resize_block+0x1cc> <== NOT EXECUTED 40009488: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 4000948c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40009490: 30 bf ff fb b,a 4000947c <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED { Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 40009494: c6 04 22 a4 ld [ %l0 + 0x2a4 ], %g3 <== NOT EXECUTED 40009498: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000949c: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 400094a0: c8 00 62 ac ld [ %g1 + 0x2ac ], %g4 <== NOT EXECUTED 400094a4: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 400094a8: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400094ac: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 400094b0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400094b4: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED 400094b8: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 400094bc: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 400094c0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 400094c4: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 400094c8: 7f ff e2 85 call 40001edc <== NOT EXECUTED 400094cc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400094d0: d0 04 22 a4 ld [ %l0 + 0x2a4 ], %o0 <== NOT EXECUTED 400094d4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400094d8: 7f ff f8 c6 call 400077f0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 400094dc: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 400094e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400094e4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 400094e8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 400094ec: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 400094f0: 40 00 10 f7 call 4000d8cc <_Heap_Resize_block> <== NOT EXECUTED 400094f4: 98 07 bf f0 add %fp, -16, %o4 <== NOT EXECUTED 400094f8: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 400094fc: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009500: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 40009504: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009508: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 4000950c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009510: d0 00 62 a4 ld [ %g1 + 0x2a4 ], %o0 ! 4001aea4 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 40009514: 94 10 20 00 clr %o2 <== NOT EXECUTED 40009518: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 4000951c: 7f ff f8 d7 call 40007878 <_CORE_mutex_Surrender> <== NOT EXECUTED 40009520: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40009524: 7f ff ff 70 call 400092e4 <_Thread_Enable_dispatch> <== NOT EXECUTED 40009528: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 4000952c: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 40009530: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 40009534: 81 c7 e0 08 ret <== NOT EXECUTED 40009538: 81 e8 00 00 restore <== NOT EXECUTED 4000d5ac <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 4000d5ac: 9d e3 bf 98 save %sp, -104, %sp /* * Free per task variable memory */ tvp = deleted->task_variables; 4000d5b0: e0 06 61 7c ld [ %i1 + 0x17c ], %l0 deleted->task_variables = NULL; while (tvp) { next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 4000d5b4: 25 10 00 6b sethi %hi(0x4001ac00), %l2 /* * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; 4000d5b8: 10 80 00 18 b 4000d618 <_RTEMS_tasks_Delete_extension+0x6c> 4000d5bc: c0 26 61 7c clr [ %i1 + 0x17c ] 4000d5c0: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED while (tvp) { next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 4000d5c4: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 4000d5c8: 12 80 00 0c bne 4000d5f8 <_RTEMS_tasks_Delete_extension+0x4c> <== NOT EXECUTED 4000d5cc: e2 04 00 00 ld [ %l0 ], %l1 <== NOT EXECUTED if (tvp->dtor) 4000d5d0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000d5d4: 22 80 00 06 be,a 4000d5ec <_RTEMS_tasks_Delete_extension+0x40> <== NOT EXECUTED 4000d5d8: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED (*tvp->dtor)(*tvp->ptr); 4000d5dc: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 4000d5e0: 9f c0 80 00 call %g2 <== NOT EXECUTED 4000d5e4: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 4000d5e8: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED 4000d5ec: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 4000d5f0: 10 80 00 07 b 4000d60c <_RTEMS_tasks_Delete_extension+0x60> <== NOT EXECUTED 4000d5f4: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED } else { if (tvp->dtor) 4000d5f8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000d5fc: 02 80 00 05 be 4000d610 <_RTEMS_tasks_Delete_extension+0x64> <== NOT EXECUTED 4000d600: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 4000d604: 9f c0 80 00 call %g2 <== NOT EXECUTED 4000d608: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED } _Workspace_Free( tvp ); 4000d60c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 4000d610: 7f ff ff e0 call 4000d590 <_Workspace_Free> <== NOT EXECUTED 4000d614: a0 10 00 11 mov %l1, %l0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 4000d618: 80 a4 20 00 cmp %l0, 0 4000d61c: 12 bf ff e9 bne 4000d5c0 <_RTEMS_tasks_Delete_extension+0x14> 4000d620: c2 04 a2 ac ld [ %l2 + 0x2ac ], %g1 /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 4000d624: 7f ff ff db call 4000d590 <_Workspace_Free> 4000d628: d0 06 61 6c ld [ %i1 + 0x16c ], %o0 deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 4000d62c: c0 26 61 6c clr [ %i1 + 0x16c ] } 4000d630: 81 c7 e0 08 ret 4000d634: 81 e8 00 00 restore 40006ed8 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 40006ed8: 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; 40006edc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006ee0: c2 00 62 90 ld [ %g1 + 0x290 ], %g1 ! 4001ae90 <_Configuration_Table> 40006ee4: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 40006ee8: d0 00 60 28 ld [ %g1 + 0x28 ], %o0 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) 40006eec: 80 a2 20 00 cmp %o0, 0 40006ef0: 02 80 00 25 be 40006f84 <_RTEMS_tasks_Initialize_user_tasks_body+0xac> 40006ef4: e4 00 60 24 ld [ %g1 + 0x24 ], %l2 40006ef8: 80 a4 a0 00 cmp %l2, 0 40006efc: 02 80 00 22 be 40006f84 <_RTEMS_tasks_Initialize_user_tasks_body+0xac> 40006f00: a0 10 00 08 mov %o0, %l0 return; 40006f04: a2 10 20 00 clr %l1 for ( index=0 ; index < maximum ; index++ ) { return_value = rtems_task_create( 40006f08: 10 80 00 1c b 40006f78 <_RTEMS_tasks_Initialize_user_tasks_body+0xa0> 40006f0c: a6 07 bf f4 add %fp, -12, %l3 40006f10: d6 04 20 14 ld [ %l0 + 0x14 ], %o3 40006f14: d8 04 20 0c ld [ %l0 + 0xc ], %o4 40006f18: d2 04 20 08 ld [ %l0 + 8 ], %o1 40006f1c: d4 04 20 04 ld [ %l0 + 4 ], %o2 40006f20: d0 04 00 00 ld [ %l0 ], %o0 40006f24: 7f ff ff 34 call 40006bf4 40006f28: a2 04 60 01 inc %l1 user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 40006f2c: 80 a2 20 00 cmp %o0, 0 40006f30: 22 80 00 07 be,a 40006f4c <_RTEMS_tasks_Initialize_user_tasks_body+0x74> 40006f34: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 40006f38: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 40006f3c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40006f40: 40 00 04 46 call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 40006f44: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED return_value = rtems_task_start( 40006f48: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED 40006f4c: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 40006f50: d0 07 bf f4 ld [ %fp + -12 ], %o0 40006f54: 40 00 00 1b call 40006fc0 40006f58: a0 04 20 1c add %l0, 0x1c, %l0 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 40006f5c: 80 a2 20 00 cmp %o0, 0 40006f60: 02 80 00 07 be 40006f7c <_RTEMS_tasks_Initialize_user_tasks_body+0xa4> 40006f64: 80 a4 40 12 cmp %l1, %l2 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 40006f68: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 40006f6c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40006f70: 40 00 04 3a call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 40006f74: 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++ ) { 40006f78: 80 a4 40 12 cmp %l1, %l2 40006f7c: 12 bf ff e5 bne 40006f10 <_RTEMS_tasks_Initialize_user_tasks_body+0x38> 40006f80: 9a 10 00 13 mov %l3, %o5 40006f84: 81 c7 e0 08 ret 40006f88: 81 e8 00 00 restore 40007ae8 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 40007ae8: 9d e3 bf 90 save %sp, -112, %sp 40007aec: 11 10 00 7e sethi %hi(0x4001f800), %o0 40007af0: 92 10 00 18 mov %i0, %o1 40007af4: 90 12 22 1c or %o0, 0x21c, %o0 40007af8: 40 00 09 5f call 4000a074 <_Objects_Get> 40007afc: 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 ) { 40007b00: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007b04: 80 a0 60 00 cmp %g1, 0 40007b08: 12 80 00 20 bne 40007b88 <_Rate_monotonic_Timeout+0xa0> 40007b0c: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: /* impossible */ case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; 40007b10: d0 02 20 50 ld [ %o0 + 0x50 ], %o0 if ( _States_Is_waiting_for_period( the_thread->current_state ) && 40007b14: 03 00 00 10 sethi %hi(0x4000), %g1 40007b18: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 40007b1c: 80 88 80 01 btst %g2, %g1 40007b20: 22 80 00 0c be,a 40007b50 <_Rate_monotonic_Timeout+0x68> 40007b24: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 40007b28: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40007b2c: c2 06 20 08 ld [ %i0 + 8 ], %g1 40007b30: 80 a0 80 01 cmp %g2, %g1 40007b34: 32 80 00 07 bne,a 40007b50 <_Rate_monotonic_Timeout+0x68> 40007b38: 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 ); 40007b3c: 13 04 00 ff sethi %hi(0x1003fc00), %o1 40007b40: 40 00 0d 87 call 4000b15c <_Thread_Clear_state> 40007b44: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 40007b48: 10 80 00 08 b 40007b68 <_Rate_monotonic_Timeout+0x80> 40007b4c: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 40007b50: 80 a0 60 01 cmp %g1, 1 40007b54: 12 80 00 08 bne 40007b74 <_Rate_monotonic_Timeout+0x8c> 40007b58: 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 ); 40007b5c: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 <== 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; 40007b60: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 40007b64: c2 26 20 38 st %g1, [ %i0 + 0x38 ] <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 40007b68: 7f ff ff d8 call 40007ac8 <_Watchdog_Insert_ticks> 40007b6c: 90 06 20 10 add %i0, 0x10, %o0 40007b70: 30 80 00 02 b,a 40007b78 <_Rate_monotonic_Timeout+0x90> } else the_period->state = RATE_MONOTONIC_EXPIRED; 40007b74: 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; 40007b78: 05 10 00 7e sethi %hi(0x4001f800), %g2 40007b7c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 4001fbb0 <_Thread_Dispatch_disable_level> 40007b80: 82 00 7f ff add %g1, -1, %g1 40007b84: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 40007b88: 81 c7 e0 08 ret 40007b8c: 81 e8 00 00 restore 4000945c <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 4000945c: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009460: 03 10 00 9e sethi %hi(0x40027800), %g1 40009464: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 400279f0 <_Thread_Dispatch_disable_level> 40009468: 84 00 a0 01 inc %g2 4000946c: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 40009470: 03 10 00 9e sethi %hi(0x40027800), %g1 40009474: d2 06 00 00 ld [ %i0 ], %o1 40009478: c2 00 62 a8 ld [ %g1 + 0x2a8 ], %g1 4000947c: 80 a2 40 01 cmp %o1, %g1 40009480: 36 80 00 05 bge,a 40009494 <_TOD_Set+0x38> 40009484: 92 22 40 01 sub %o1, %g1, %o1 _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, 40009488: 92 20 40 09 sub %g1, %o1, %o1 4000948c: 10 80 00 03 b 40009498 <_TOD_Set+0x3c> 40009490: 90 10 20 01 mov 1, %o0 _TOD_Seconds_since_epoch - time->tv_sec ); else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, 40009494: 90 10 20 00 clr %o0 40009498: 7f ff ff e9 call 4000943c <_Watchdog_Adjust_seconds> 4000949c: 01 00 00 00 nop time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 400094a0: c4 06 00 00 ld [ %i0 ], %g2 400094a4: 03 10 00 9e sethi %hi(0x40027800), %g1 400094a8: c4 20 62 a8 st %g2, [ %g1 + 0x2a8 ] ! 40027aa8 <_TOD_Now> 400094ac: c4 06 20 04 ld [ %i0 + 4 ], %g2 400094b0: 82 10 62 a8 or %g1, 0x2a8, %g1 400094b4: c4 20 60 04 st %g2, [ %g1 + 4 ] _TOD_Is_set = TRUE; 400094b8: 84 10 20 01 mov 1, %g2 400094bc: 03 10 00 9e sethi %hi(0x40027800), %g1 400094c0: c4 20 62 2c st %g2, [ %g1 + 0x22c ] ! 40027a2c <_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 ) 400094c4: 05 10 00 9e sethi %hi(0x40027800), %g2 400094c8: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 400279f0 <_Thread_Dispatch_disable_level> 400094cc: 82 00 7f ff add %g1, -1, %g1 400094d0: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 400094d4: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 400094d8: 80 a0 60 00 cmp %g1, 0 400094dc: 12 80 00 04 bne 400094ec <_TOD_Set+0x90> 400094e0: 01 00 00 00 nop _Thread_Dispatch(); 400094e4: 40 00 07 e1 call 4000b468 <_Thread_Dispatch> <== NOT EXECUTED 400094e8: 81 e8 00 00 restore <== NOT EXECUTED 400094ec: 81 c7 e0 08 ret 400094f0: 81 e8 00 00 restore 4000987c <_Thread_Create_idle>: */ const char *_Thread_Idle_name = "IDLE"; void _Thread_Create_idle( void ) { 4000987c: 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 ); 40009880: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40009884: 7f ff fa 22 call 4000810c <_Objects_Allocate> 40009888: 90 12 23 60 or %o0, 0x360, %o0 ! 4001af60 <_Thread_Internal_information> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 4000988c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009890: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 4001adf0 <_CPU_Table+0xc> * 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(); 40009894: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009898: d0 20 63 b8 st %o0, [ %g1 + 0x3b8 ] ! 4001afb8 <_Thread_Idle> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 4000989c: 80 a0 a0 00 cmp %g2, 0 400098a0: 03 10 00 26 sethi %hi(0x40009800), %g1 400098a4: 02 80 00 03 be 400098b0 <_Thread_Create_idle+0x34> 400098a8: b4 10 63 2c or %g1, 0x32c, %i2 ! 40009b2c <_Thread_Idle_body> idle = _CPU_Table.idle_task; 400098ac: b4 10 00 02 mov %g2, %i2 <== NOT EXECUTED idle_task_stack_size = _CPU_Table.idle_task_stack_size; 400098b0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400098b4: d6 00 61 f8 ld [ %g1 + 0x1f8 ], %o3 ! 4001adf8 <_CPU_Table+0x14> if ( idle_task_stack_size < STACK_MINIMUM_SIZE ) 400098b8: 80 a2 ef ff cmp %o3, 0xfff 400098bc: 28 80 00 02 bleu,a 400098c4 <_Thread_Create_idle+0x48> 400098c0: 17 00 00 04 sethi %hi(0x1000), %o3 idle_task_stack_size = STACK_MINIMUM_SIZE; _Thread_Initialize( 400098c4: 03 10 00 67 sethi %hi(0x40019c00), %g1 400098c8: c2 00 63 78 ld [ %g1 + 0x378 ], %g1 ! 40019f78 <_Thread_Idle_name> 400098cc: 92 10 00 08 mov %o0, %o1 400098d0: c2 23 a0 6c st %g1, [ %sp + 0x6c ] 400098d4: 82 10 20 01 mov 1, %g1 400098d8: c0 23 a0 60 clr [ %sp + 0x60 ] 400098dc: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 400098e0: c0 23 a0 64 clr [ %sp + 0x64 ] 400098e4: c0 23 a0 68 clr [ %sp + 0x68 ] 400098e8: 11 10 00 6b sethi %hi(0x4001ac00), %o0 400098ec: 94 10 20 00 clr %o2 400098f0: 90 12 23 60 or %o0, 0x360, %o0 400098f4: 98 10 20 00 clr %o4 400098f8: 40 00 00 8e call 40009b30 <_Thread_Initialize> 400098fc: 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 = 40009900: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009904: c4 00 63 b8 ld [ %g1 + 0x3b8 ], %g2 ! 4001afb8 <_Thread_Idle> 40009908: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000990c: c4 20 62 ac st %g2, [ %g1 + 0x2ac ] ! 4001aeac <_Thread_Executing> 40009910: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _Thread_Executing = _Thread_Idle; _Thread_Start( 40009914: b0 10 00 02 mov %g2, %i0 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 40009918: c4 20 62 84 st %g2, [ %g1 + 0x284 ] _Thread_Executing = _Thread_Idle; _Thread_Start( 4000991c: b2 10 20 00 clr %i1 40009920: b6 10 20 00 clr %i3 40009924: 40 00 03 d8 call 4000a884 <_Thread_Start> 40009928: 99 e8 20 00 restore %g0, 0, %o4 4000992c: 01 00 00 00 nop 40009930 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 40009930: 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 ) ) { 40009934: 92 96 20 00 orcc %i0, 0, %o1 40009938: 12 80 00 0a bne 40009960 <_Thread_Delay_ended+0x30> 4000993c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009940: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009944: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009948: 84 00 a0 01 inc %g2 <== NOT EXECUTED 4000994c: c4 20 61 d0 st %g2, [ %g1 + 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; 40009950: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009954: d0 00 62 ac ld [ %g1 + 0x2ac ], %o0 ! 4001aeac <_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; 40009958: 10 80 00 19 b 400099bc <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 4000995c: c0 27 bf f4 clr [ %fp + -12 ] <== 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); 40009960: 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 ) { 40009964: 80 a0 a0 04 cmp %g2, 4 40009968: 18 80 00 06 bgu 40009980 <_Thread_Delay_ended+0x50> 4000996c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40009970: 83 32 60 1b srl %o1, 0x1b, %g1 40009974: 80 a0 60 01 cmp %g1, 1 40009978: 02 80 00 05 be 4000998c <_Thread_Delay_ended+0x5c> 4000997c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 40009980: 90 10 20 00 clr %o0 <== NOT EXECUTED 40009984: 10 80 00 0e b 400099bc <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 40009988: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4000998c: 83 28 a0 02 sll %g2, 2, %g1 40009990: 05 10 00 6b sethi %hi(0x4001ac00), %g2 40009994: 84 10 a1 30 or %g2, 0x130, %g2 ! 4001ad30 <_Objects_Information_table> 40009998: c2 00 80 01 ld [ %g2 + %g1 ], %g1 4000999c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 400099a0: 80 a2 20 00 cmp %o0, 0 400099a4: 12 80 00 04 bne 400099b4 <_Thread_Delay_ended+0x84> 400099a8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 400099ac: 10 80 00 04 b 400099bc <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 400099b0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 400099b4: 7f ff fb 1a call 4000861c <_Objects_Get> 400099b8: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 400099bc: c2 07 bf f4 ld [ %fp + -12 ], %g1 400099c0: 80 a0 60 00 cmp %g1, 0 400099c4: 12 80 00 08 bne 400099e4 <_Thread_Delay_ended+0xb4> 400099c8: 13 04 00 ff sethi %hi(0x1003fc00), %o1 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 400099cc: 7f ff ff 4e call 40009704 <_Thread_Clear_state> 400099d0: 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; 400099d4: 05 10 00 6b sethi %hi(0x4001ac00), %g2 400099d8: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 400099dc: 82 00 7f ff add %g1, -1, %g1 400099e0: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] 400099e4: 81 c7 e0 08 ret 400099e8: 81 e8 00 00 restore 4000ed1c <_Thread_Evaluate_mode>: boolean _Thread_Evaluate_mode( void ) { Thread_Control *executing; executing = _Thread_Executing; 4000ed1c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000ed20: c4 00 62 ac ld [ %g1 + 0x2ac ], %g2 ! 4001aeac <_Thread_Executing> if ( !_States_Is_ready( executing->current_state ) || 4000ed24: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 4000ed28: 80 a0 60 00 cmp %g1, 0 4000ed2c: 32 80 00 0b bne,a 4000ed58 <_Thread_Evaluate_mode+0x3c> 4000ed30: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 4000ed34: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000ed38: c2 00 62 84 ld [ %g1 + 0x284 ], %g1 ! 4001ae84 <_Thread_Heir> 4000ed3c: 80 a0 80 01 cmp %g2, %g1 4000ed40: 02 80 00 0b be 4000ed6c <_Thread_Evaluate_mode+0x50> 4000ed44: 01 00 00 00 nop 4000ed48: c2 00 a0 7c ld [ %g2 + 0x7c ], %g1 4000ed4c: 80 a0 60 00 cmp %g1, 0 4000ed50: 02 80 00 07 be 4000ed6c <_Thread_Evaluate_mode+0x50> 4000ed54: 84 10 20 01 mov 1, %g2 ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 4000ed58: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000ed5c: 90 10 20 01 mov 1, %o0 4000ed60: c4 20 62 bc st %g2, [ %g1 + 0x2bc ] 4000ed64: 81 c3 e0 08 retl 4000ed68: 01 00 00 00 nop return TRUE; } return FALSE; } 4000ed6c: 81 c3 e0 08 retl 4000ed70: 90 10 20 00 clr %o0 ! 0 4000ed74 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 4000ed74: 9d e3 bf 98 save %sp, -104, %sp #endif #if defined(__USE__MAIN__) extern void _main(void); #endif executing = _Thread_Executing; 4000ed78: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000ed7c: f4 00 62 ac ld [ %g1 + 0x2ac ], %i2 ! 4001aeac <_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(); 4000ed80: 3f 10 00 3b sethi %hi(0x4000ec00), %i7 4000ed84: be 17 e1 74 or %i7, 0x174, %i7 ! 4000ed74 <_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); 4000ed88: d0 06 a0 c4 ld [ %i2 + 0xc4 ], %o0 4000ed8c: 7f ff cc 54 call 40001edc 4000ed90: 91 2a 20 08 sll %o0, 8, %o0 #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 4000ed94: 05 10 00 6a sethi %hi(0x4001a800), %g2 doneConstructors = 1; 4000ed98: 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; 4000ed9c: f2 08 a3 f0 ldub [ %g2 + 0x3f0 ], %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 ); 4000eda0: 90 10 00 1a mov %i2, %o0 4000eda4: 7f ff ef 70 call 4000ab64 <_User_extensions_Thread_begin> 4000eda8: c2 28 a3 f0 stb %g1, [ %g2 + 0x3f0 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000edac: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000edb0: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 4000edb4: 82 00 7f ff add %g1, -1, %g1 4000edb8: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] 4000edbc: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 4000edc0: 80 a0 60 00 cmp %g1, 0 4000edc4: 12 80 00 05 bne 4000edd8 <_Thread_Handler+0x64> 4000edc8: 83 2e 60 18 sll %i1, 0x18, %g1 _Thread_Dispatch(); 4000edcc: 7f ff eb 08 call 400099ec <_Thread_Dispatch> 4000edd0: 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) */ 4000edd4: 83 2e 60 18 sll %i1, 0x18, %g1 4000edd8: 80 a0 60 00 cmp %g1, 0 4000eddc: 32 80 00 05 bne,a 4000edf0 <_Thread_Handler+0x7c> 4000ede0: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 _init (); 4000ede4: 40 00 2a fd call 400199d8 <_init> 4000ede8: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 4000edec: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 4000edf0: 80 a0 60 01 cmp %g1, 1 4000edf4: 22 80 00 0d be,a 4000ee28 <_Thread_Handler+0xb4> 4000edf8: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 4000edfc: 2a 80 00 09 bcs,a 4000ee20 <_Thread_Handler+0xac> 4000ee00: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 4000ee04: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000ee08: 02 80 00 0d be 4000ee3c <_Thread_Handler+0xc8> <== NOT EXECUTED 4000ee0c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 4000ee10: 12 80 00 14 bne 4000ee60 <_Thread_Handler+0xec> <== NOT EXECUTED 4000ee14: 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 = 4000ee18: 10 80 00 0c b 4000ee48 <_Thread_Handler+0xd4> <== NOT EXECUTED 4000ee1c: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED __main (); #endif switch ( executing->Start.prototype ) { case THREAD_START_NUMERIC: executing->Wait.return_argument = 4000ee20: 10 80 00 03 b 4000ee2c <_Thread_Handler+0xb8> 4000ee24: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 4000ee28: d0 06 a0 b0 ld [ %i2 + 0xb0 ], %o0 4000ee2c: 9f c0 40 00 call %g1 4000ee30: 01 00 00 00 nop executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 4000ee34: 10 80 00 0a b 4000ee5c <_Thread_Handler+0xe8> 4000ee38: d0 26 a0 28 st %o0, [ %i2 + 0x28 ] (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 4000ee3c: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 4000ee40: 10 80 00 04 b 4000ee50 <_Thread_Handler+0xdc> <== NOT EXECUTED 4000ee44: d0 1e a0 b0 ldd [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 4000ee48: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 <== NOT EXECUTED 4000ee4c: d2 06 a0 b0 ld [ %i2 + 0xb0 ], %o1 <== NOT EXECUTED 4000ee50: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000ee54: 01 00 00 00 nop <== NOT EXECUTED 4000ee58: 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 ); 4000ee5c: 90 10 00 1a mov %i2, %o0 4000ee60: 7f ff ef 64 call 4000abf0 <_User_extensions_Thread_exitted> 4000ee64: b0 10 20 00 clr %i0 _Internal_error_Occurred( 4000ee68: b2 10 20 01 mov 1, %i1 4000ee6c: 7f ff e4 7b call 40008058 <_Internal_error_Occurred> 4000ee70: 95 e8 20 06 restore %g0, 6, %o2 4000ee74: 01 00 00 00 nop 40009cec <_Thread_Handler_initialization>: void _Thread_Handler_initialization( uint32_t ticks_per_timeslice, uint32_t maximum_extensions, uint32_t maximum_proxies ) { 40009cec: 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 ) 40009cf0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009cf4: 82 10 61 e4 or %g1, 0x1e4, %g1 ! 4001ade4 <_CPU_Table> 40009cf8: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 40009cfc: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 40009d00: 80 a0 00 02 cmp %g0, %g2 40009d04: 84 60 3f ff subx %g0, -1, %g2 40009d08: 80 a0 00 01 cmp %g0, %g1 40009d0c: 82 60 3f ff subx %g0, -1, %g1 40009d10: 80 a0 80 01 cmp %g2, %g1 40009d14: 02 80 00 07 be 40009d30 <_Thread_Handler_initialization+0x44> 40009d18: 03 10 00 6b sethi %hi(0x4001ac00), %g1 == ( _CPU_Table.stack_free_hook == 0 ) ) ) _Internal_error_Occurred( 40009d1c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40009d20: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40009d24: 7f ff f8 cd call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 40009d28: 94 10 20 0f mov 0xf, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 40009d2c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009d30: c0 20 62 bc clr [ %g1 + 0x2bc ] ! 4001aebc <_Context_Switch_necessary> _Thread_Executing = NULL; 40009d34: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009d38: c0 20 62 ac clr [ %g1 + 0x2ac ] ! 4001aeac <_Thread_Executing> _Thread_Heir = NULL; 40009d3c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009d40: c0 20 62 84 clr [ %g1 + 0x284 ] ! 4001ae84 <_Thread_Heir> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; 40009d44: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009d48: c0 20 62 9c clr [ %g1 + 0x29c ] ! 4001ae9c <_Thread_Do_post_task_switch_extension> _Thread_Maximum_extensions = maximum_extensions; 40009d4c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009d50: f2 20 62 98 st %i1, [ %g1 + 0x298 ] ! 4001ae98 <_Thread_Maximum_extensions> _Thread_Ticks_per_timeslice = ticks_per_timeslice; 40009d54: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 40009d58: 90 10 2c 00 mov 0xc00, %o0 40009d5c: 40 00 04 ac call 4000b00c <_Workspace_Allocate_or_fatal_error> 40009d60: f0 20 61 28 st %i0, [ %g1 + 0x128 ] 40009d64: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009d68: 84 10 00 08 mov %o0, %g2 40009d6c: d0 20 61 24 st %o0, [ %g1 + 0x124 ] (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 40009d70: 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); 40009d74: 82 00 a0 04 add %g2, 4, %g1 the_chain->permanent_null = NULL; 40009d78: c0 20 a0 04 clr [ %g2 + 4 ] the_chain->last = _Chain_Head(the_chain); 40009d7c: 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); 40009d80: c2 20 80 00 st %g1, [ %g2 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009d84: 84 00 a0 0c add %g2, 0xc, %g2 40009d88: 80 a0 80 03 cmp %g2, %g3 40009d8c: 12 bf ff fb bne 40009d78 <_Thread_Handler_initialization+0x8c> 40009d90: 82 00 a0 04 add %g2, 4, %g1 /* * Initialize this class of objects. */ _Objects_Initialize_information( 40009d94: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009d98: c2 00 62 d8 ld [ %g1 + 0x2d8 ], %g1 ! 4001aed8 <_System_state_Is_multiprocessing> 40009d9c: 96 10 20 02 mov 2, %o3 40009da0: 80 a0 00 01 cmp %g0, %g1 40009da4: 82 10 20 08 mov 8, %g1 40009da8: 96 42 ff ff addx %o3, -1, %o3 40009dac: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 40009db0: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40009db4: 92 10 20 01 mov 1, %o1 40009db8: 90 12 23 60 or %o0, 0x360, %o0 40009dbc: 94 10 20 01 mov 1, %o2 40009dc0: 98 10 21 80 mov 0x180, %o4 40009dc4: 7f ff fa 3b call 400086b0 <_Objects_Initialize_information> 40009dc8: 9a 10 20 01 mov 1, %o5 FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 40009dcc: 81 c7 e0 08 ret 40009dd0: 81 e8 00 00 restore 40009b30 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 40009b30: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the Ada self pointer */ the_thread->rtems_ada_self = NULL; 40009b34: c0 26 60 80 clr [ %i1 + 0x80 ] /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 40009b38: 80 a6 a0 00 cmp %i2, 0 40009b3c: 12 80 00 10 bne 40009b7c <_Thread_Initialize+0x4c> 40009b40: e0 07 a0 60 ld [ %fp + 0x60 ], %l0 if ( !_Stack_Is_enough( stack_size ) ) 40009b44: 80 a6 ef ff cmp %i3, 0xfff 40009b48: 08 80 00 03 bleu 40009b54 <_Thread_Initialize+0x24> 40009b4c: 13 00 00 04 sethi %hi(0x1000), %o1 40009b50: 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 ); 40009b54: 40 00 03 13 call 4000a7a0 <_Thread_Stack_Allocate> 40009b58: 90 10 00 19 mov %i1, %o0 if ( !actual_stack_size || actual_stack_size < stack_size ) 40009b5c: 80 a2 20 00 cmp %o0, 0 40009b60: 02 80 00 1f be 40009bdc <_Thread_Initialize+0xac> 40009b64: 80 a2 00 1b cmp %o0, %i3 40009b68: 0a 80 00 1d bcs 40009bdc <_Thread_Initialize+0xac> 40009b6c: 82 10 20 01 mov 1, %g1 return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 40009b70: f4 06 60 d8 ld [ %i1 + 0xd8 ], %i2 the_thread->Start.core_allocated_stack = TRUE; 40009b74: 10 80 00 04 b 40009b84 <_Thread_Initialize+0x54> 40009b78: c2 26 60 cc st %g1, [ %i1 + 0xcc ] } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 40009b7c: c0 26 60 cc clr [ %i1 + 0xcc ] <== NOT EXECUTED 40009b80: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 40009b84: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009b88: d2 00 62 98 ld [ %g1 + 0x298 ], %o1 ! 4001ae98 <_Thread_Maximum_extensions> Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 40009b8c: f4 26 60 d4 st %i2, [ %i1 + 0xd4 ] the_stack->size = size; 40009b90: d0 26 60 d0 st %o0, [ %i1 + 0xd0 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40009b94: c0 26 60 50 clr [ %i1 + 0x50 ] the_watchdog->routine = routine; 40009b98: c0 26 60 64 clr [ %i1 + 0x64 ] the_watchdog->id = id; 40009b9c: c0 26 60 68 clr [ %i1 + 0x68 ] the_watchdog->user_data = user_data; 40009ba0: c0 26 60 6c clr [ %i1 + 0x6c ] /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 40009ba4: c0 26 61 68 clr [ %i1 + 0x168 ] /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 40009ba8: 80 a2 60 00 cmp %o1, 0 40009bac: 02 80 00 0e be 40009be4 <_Thread_Initialize+0xb4> 40009bb0: b6 10 20 00 clr %i3 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 40009bb4: 92 02 60 01 inc %o1 40009bb8: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40009bbc: 93 2a 60 02 sll %o1, 2, %o1 40009bc0: 7f ff f7 fb call 40007bac <_Heap_Allocate> 40009bc4: 90 12 22 1c or %o0, 0x21c, %o0 extensions_area = _Workspace_Allocate( (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 40009bc8: b6 92 20 00 orcc %o0, 0, %i3 40009bcc: 12 80 00 07 bne 40009be8 <_Thread_Initialize+0xb8> 40009bd0: 80 a6 e0 00 cmp %i3, 0 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); 40009bd4: 40 00 03 0a call 4000a7fc <_Thread_Stack_Free> <== NOT EXECUTED 40009bd8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40009bdc: 81 c7 e0 08 ret 40009be0: 91 e8 20 00 restore %g0, 0, %o0 * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { 40009be4: 80 a6 e0 00 cmp %i3, 0 40009be8: 02 80 00 0d be 40009c1c <_Thread_Initialize+0xec> 40009bec: f6 26 61 78 st %i3, [ %i1 + 0x178 ] int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 40009bf0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009bf4: c2 00 62 98 ld [ %g1 + 0x298 ], %g1 ! 4001ae98 <_Thread_Maximum_extensions> 40009bf8: 86 10 20 00 clr %g3 40009bfc: 10 80 00 05 b 40009c10 <_Thread_Initialize+0xe0> 40009c00: 88 00 60 01 add %g1, 1, %g4 the_thread->extensions[i] = NULL; 40009c04: 83 28 e0 02 sll %g3, 2, %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 40009c08: 86 00 e0 01 inc %g3 the_thread->extensions[i] = NULL; 40009c0c: c0 20 80 01 clr [ %g2 + %g1 ] * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 40009c10: 80 a0 c0 04 cmp %g3, %g4 40009c14: 32 bf ff fc bne,a 40009c04 <_Thread_Initialize+0xd4> 40009c18: c4 06 61 78 ld [ %i1 + 0x178 ], %g2 /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 40009c1c: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 the_thread->Start.budget_algorithm = budget_algorithm; 40009c20: e0 26 60 bc st %l0, [ %i1 + 0xbc ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 40009c24: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 40009c28: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 switch ( budget_algorithm ) { 40009c2c: 80 a4 20 02 cmp %l0, 2 40009c30: 12 80 00 05 bne 40009c44 <_Thread_Initialize+0x114> 40009c34: 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; 40009c38: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009c3c: c2 00 61 28 ld [ %g1 + 0x128 ], %g1 ! 4001ad28 <_Thread_Ticks_per_timeslice> <== NOT EXECUTED 40009c40: c2 26 60 84 st %g1, [ %i1 + 0x84 ] <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 40009c44: c2 07 a0 68 ld [ %fp + 0x68 ], %g1 the_thread->current_state = STATES_DORMANT; the_thread->Wait.queue = NULL; 40009c48: c0 26 60 44 clr [ %i1 + 0x44 ] break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 40009c4c: c2 26 60 c4 st %g1, [ %i1 + 0xc4 ] the_thread->current_state = STATES_DORMANT; 40009c50: 82 10 20 01 mov 1, %g1 the_thread->Wait.queue = NULL; the_thread->resource_count = 0; 40009c54: c0 26 60 1c clr [ %i1 + 0x1c ] break; } the_thread->Start.isr_level = isr_level; the_thread->current_state = STATES_DORMANT; 40009c58: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_thread->Wait.queue = NULL; the_thread->resource_count = 0; the_thread->suspend_count = 0; 40009c5c: c0 26 60 70 clr [ %i1 + 0x70 ] the_thread->real_priority = priority; 40009c60: fa 26 60 18 st %i5, [ %i1 + 0x18 ] the_thread->Start.initial_priority = priority; 40009c64: fa 26 60 c8 st %i5, [ %i1 + 0xc8 ] _Thread_Set_priority( the_thread, priority ); 40009c68: 92 10 00 1d mov %i5, %o1 40009c6c: 40 00 02 2c call 4000a51c <_Thread_Set_priority> 40009c70: 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 ); 40009c74: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40009c78: 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; 40009c7c: c0 26 60 90 clr [ %i1 + 0x90 ] 40009c80: 03 00 00 3f sethi %hi(0xfc00), %g1 40009c84: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40009c88: 82 08 80 01 and %g2, %g1, %g1 40009c8c: 80 a0 40 03 cmp %g1, %g3 40009c90: 18 80 00 05 bgu 40009ca4 <_Thread_Initialize+0x174> 40009c94: c0 26 60 94 clr [ %i1 + 0x94 ] information->local_table[ index ] = the_object; 40009c98: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 40009c9c: 83 28 60 02 sll %g1, 2, %g1 40009ca0: f2 20 80 01 st %i1, [ %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; 40009ca4: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 /* * Invoke create extensions */ if ( !_User_extensions_Thread_create( the_thread ) ) { 40009ca8: 90 10 00 19 mov %i1, %o0 40009cac: c2 26 60 0c st %g1, [ %i1 + 0xc ] 40009cb0: 40 00 03 e1 call 4000ac34 <_User_extensions_Thread_create> 40009cb4: b0 10 20 01 mov 1, %i0 40009cb8: 80 a2 20 00 cmp %o0, 0 40009cbc: 12 80 00 0a bne 40009ce4 <_Thread_Initialize+0x1b4> 40009cc0: 80 a6 e0 00 cmp %i3, 0 if ( extensions_area ) 40009cc4: 02 80 00 05 be 40009cd8 <_Thread_Initialize+0x1a8> <== NOT EXECUTED 40009cc8: 11 10 00 6b sethi %hi(0x4001ac00), %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 40009ccc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 40009cd0: 7f ff f7 de call 40007c48 <_Heap_Free> <== NOT EXECUTED 40009cd4: 90 12 22 1c or %o0, 0x21c, %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 ); 40009cd8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40009cdc: 40 00 02 c8 call 4000a7fc <_Thread_Stack_Free> <== NOT EXECUTED 40009ce0: b0 10 20 00 clr %i0 <== NOT EXECUTED return FALSE; } return TRUE; } 40009ce4: 81 c7 e0 08 ret 40009ce8: 81 e8 00 00 restore 4000ee3c <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { 4000ee3c: 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; 4000ee40: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000ee44: c4 06 20 bc ld [ %i0 + 0xbc ], %g2 the_thread->budget_callout = the_thread->Start.budget_callout; 4000ee48: 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; 4000ee4c: 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; 4000ee50: c4 3e 20 88 std %g2, [ %i0 + 0x88 ] the_thread->Start.pointer_argument = pointer_argument; 4000ee54: f2 26 20 b0 st %i1, [ %i0 + 0xb0 ] the_thread->Start.numeric_argument = numeric_argument; 4000ee58: f4 26 20 b4 st %i2, [ %i0 + 0xb4 ] Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { the_thread->resource_count = 0; 4000ee5c: c0 26 20 1c clr [ %i0 + 0x1c ] the_thread->suspend_count = 0; 4000ee60: 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 ) ) { 4000ee64: 7f ff f0 55 call 4000afb8 <_Thread_queue_Extract_with_proxy> 4000ee68: 90 10 00 18 mov %i0, %o0 4000ee6c: 80 a2 20 00 cmp %o0, 0 4000ee70: 32 80 00 09 bne,a 4000ee94 <_Thread_Reset+0x58> 4000ee74: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 if ( _Watchdog_Is_active( &the_thread->Timer ) ) 4000ee78: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000ee7c: 80 a0 60 02 cmp %g1, 2 4000ee80: 32 80 00 05 bne,a 4000ee94 <_Thread_Reset+0x58> 4000ee84: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 (void) _Watchdog_Remove( &the_thread->Timer ); 4000ee88: 7f ff f3 8d call 4000bcbc <_Watchdog_Remove> <== NOT EXECUTED 4000ee8c: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 4000ee90: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 <== NOT EXECUTED 4000ee94: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4000ee98: 80 a0 40 19 cmp %g1, %i1 4000ee9c: 02 80 00 05 be 4000eeb0 <_Thread_Reset+0x74> 4000eea0: 01 00 00 00 nop the_thread->real_priority = the_thread->Start.initial_priority; 4000eea4: f2 26 20 18 st %i1, [ %i0 + 0x18 ] _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 4000eea8: 7f ff f1 0a call 4000b2d0 <_Thread_Set_priority> 4000eeac: 81 e8 00 00 restore 4000eeb0: 81 c7 e0 08 ret 4000eeb4: 81 e8 00 00 restore 4000dfec <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 4000dfec: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 4000dff0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000dff4: e0 00 62 ac ld [ %g1 + 0x2ac ], %l0 ! 4001aeac <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 4000dff8: 7f ff cf b5 call 40001ecc 4000dffc: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 4000e000: b0 10 00 08 mov %o0, %i0 if ( _Chain_Has_only_one_node( ready ) ) { 4000e004: c4 04 40 00 ld [ %l1 ], %g2 4000e008: c2 04 60 08 ld [ %l1 + 8 ], %g1 4000e00c: 80 a0 80 01 cmp %g2, %g1 4000e010: 32 80 00 03 bne,a 4000e01c <_Thread_Reset_timeslice+0x30> 4000e014: c6 04 00 00 ld [ %l0 ], %g3 _ISR_Enable( level ); 4000e018: 30 80 00 18 b,a 4000e078 <_Thread_Reset_timeslice+0x8c> { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 4000e01c: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000e020: 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; 4000e024: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000e028: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000e02c: 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; 4000e030: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 4000e034: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000e038: 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; 4000e03c: e0 20 40 00 st %l0, [ %g1 ] return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 4000e040: 7f ff cf a7 call 40001edc 4000e044: 01 00 00 00 nop 4000e048: 7f ff cf a1 call 40001ecc 4000e04c: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 4000e050: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000e054: c2 00 a2 84 ld [ %g2 + 0x284 ], %g1 ! 4001ae84 <_Thread_Heir> 4000e058: 80 a4 00 01 cmp %l0, %g1 4000e05c: 32 80 00 05 bne,a 4000e070 <_Thread_Reset_timeslice+0x84> 4000e060: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 4000e064: c2 04 40 00 ld [ %l1 ], %g1 4000e068: c2 20 a2 84 st %g1, [ %g2 + 0x284 ] _Context_Switch_necessary = TRUE; 4000e06c: 84 10 20 01 mov 1, %g2 4000e070: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000e074: c4 20 62 bc st %g2, [ %g1 + 0x2bc ] ! 4001aebc <_Context_Switch_necessary> _ISR_Enable( level ); 4000e078: 7f ff cf 99 call 40001edc 4000e07c: 81 e8 00 00 restore 4000e080: 01 00 00 00 nop 4000bff0 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, boolean force ) { 4000bff0: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; States_Control current_state; _ISR_Disable( level ); 4000bff4: 7f ff da ff call 40002bf0 4000bff8: 01 00 00 00 nop 4000bffc: a0 10 00 08 mov %o0, %l0 if ( force == TRUE ) 4000c000: 80 a6 60 01 cmp %i1, 1 4000c004: 32 80 00 04 bne,a 4000c014 <_Thread_Resume+0x24> 4000c008: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED the_thread->suspend_count = 0; 4000c00c: 10 80 00 04 b 4000c01c <_Thread_Resume+0x2c> 4000c010: c0 26 20 70 clr [ %i0 + 0x70 ] else the_thread->suspend_count--; 4000c014: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000c018: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 4000c01c: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 4000c020: 80 a0 60 00 cmp %g1, 0 4000c024: 22 80 00 03 be,a 4000c030 <_Thread_Resume+0x40> 4000c028: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 _ISR_Enable( level ); 4000c02c: 30 80 00 2e b,a 4000c0e4 <_Thread_Resume+0xf4> <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { 4000c030: 80 88 60 02 btst 2, %g1 4000c034: 02 80 00 2c be 4000c0e4 <_Thread_Resume+0xf4> 4000c038: 82 08 7f fd and %g1, -3, %g1 current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 4000c03c: 80 a0 60 00 cmp %g1, 0 4000c040: 12 80 00 29 bne 4000c0e4 <_Thread_Resume+0xf4> 4000c044: c2 26 20 10 st %g1, [ %i0 + 0x10 ] RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 4000c048: c8 06 20 9c ld [ %i0 + 0x9c ], %g4 4000c04c: c4 16 20 a2 lduh [ %i0 + 0xa2 ], %g2 4000c050: c2 11 00 00 lduh [ %g4 ], %g1 _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 4000c054: c6 06 20 98 ld [ %i0 + 0x98 ], %g3 4000c058: 82 10 40 02 or %g1, %g2, %g1 4000c05c: c2 31 00 00 sth %g1, [ %g4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000c060: 82 00 e0 04 add %g3, 4, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 4000c064: 09 10 00 9e sethi %hi(0x40027800), %g4 4000c068: c2 26 00 00 st %g1, [ %i0 ] 4000c06c: da 16 20 a0 lduh [ %i0 + 0xa0 ], %o5 old_last_node = the_chain->last; 4000c070: c2 00 e0 08 ld [ %g3 + 8 ], %g1 4000c074: c4 11 22 c0 lduh [ %g4 + 0x2c0 ], %g2 the_chain->last = the_node; 4000c078: f0 20 e0 08 st %i0, [ %g3 + 8 ] 4000c07c: 84 10 80 0d or %g2, %o5, %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 4000c080: c2 26 20 04 st %g1, [ %i0 + 4 ] 4000c084: c4 31 22 c0 sth %g2, [ %g4 + 0x2c0 ] 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; 4000c088: f0 20 40 00 st %i0, [ %g1 ] _ISR_Flash( level ); 4000c08c: 7f ff da dd call 40002c00 4000c090: 90 10 00 10 mov %l0, %o0 4000c094: 7f ff da d7 call 40002bf0 4000c098: 01 00 00 00 nop if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 4000c09c: 07 10 00 9e sethi %hi(0x40027800), %g3 4000c0a0: c2 00 e2 a4 ld [ %g3 + 0x2a4 ], %g1 ! 40027aa4 <_Thread_Heir> 4000c0a4: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 4000c0a8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 4000c0ac: 80 a0 80 01 cmp %g2, %g1 4000c0b0: 1a 80 00 0d bcc 4000c0e4 <_Thread_Resume+0xf4> 4000c0b4: 03 10 00 9e sethi %hi(0x40027800), %g1 _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 4000c0b8: c2 00 62 cc ld [ %g1 + 0x2cc ], %g1 ! 40027acc <_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; 4000c0bc: f0 20 e2 a4 st %i0, [ %g3 + 0x2a4 ] if ( _Thread_Executing->is_preemptible || 4000c0c0: c2 00 60 7c ld [ %g1 + 0x7c ], %g1 4000c0c4: 80 a0 60 00 cmp %g1, 0 4000c0c8: 32 80 00 05 bne,a 4000c0dc <_Thread_Resume+0xec> 4000c0cc: 84 10 20 01 mov 1, %g2 4000c0d0: 80 a0 a0 00 cmp %g2, 0 4000c0d4: 12 80 00 04 bne 4000c0e4 <_Thread_Resume+0xf4> 4000c0d8: 84 10 20 01 mov 1, %g2 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 4000c0dc: 03 10 00 9e sethi %hi(0x40027800), %g1 4000c0e0: c4 20 62 dc st %g2, [ %g1 + 0x2dc ] ! 40027adc <_Context_Switch_necessary> } } } _ISR_Enable( level ); 4000c0e4: 7f ff da c7 call 40002c00 4000c0e8: 91 e8 00 10 restore %g0, %l0, %o0 4000c0ec: 01 00 00 00 nop 4000a7a0 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 4000a7a0: 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 ) ) 4000a7a4: 80 a6 6f ff cmp %i1, 0xfff 4000a7a8: 28 80 00 02 bleu,a 4000a7b0 <_Thread_Stack_Allocate+0x10> 4000a7ac: 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 ) { 4000a7b0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a7b4: c2 00 62 04 ld [ %g1 + 0x204 ], %g1 ! 4001ae04 <_CPU_Table+0x20> 4000a7b8: 80 a0 60 00 cmp %g1, 0 4000a7bc: 02 80 00 06 be 4000a7d4 <_Thread_Stack_Allocate+0x34> 4000a7c0: 92 06 60 10 add %i1, 0x10, %o1 stack_addr = (*_CPU_Table.stack_allocate_hook)( the_stack_size ); 4000a7c4: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a7c8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 4000a7cc: 10 80 00 07 b 4000a7e8 <_Thread_Stack_Allocate+0x48> <== NOT EXECUTED 4000a7d0: d0 26 20 d8 st %o0, [ %i0 + 0xd8 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 4000a7d4: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000a7d8: b2 10 00 09 mov %o1, %i1 4000a7dc: 7f ff f4 f4 call 40007bac <_Heap_Allocate> 4000a7e0: 90 12 22 1c or %o0, 0x21c, %o0 4000a7e4: 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 ) 4000a7e8: 80 a0 00 08 cmp %g0, %o0 4000a7ec: b0 60 20 00 subx %g0, 0, %i0 the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 4000a7f0: b0 0e 40 18 and %i1, %i0, %i0 4000a7f4: 81 c7 e0 08 ret 4000a7f8: 81 e8 00 00 restore 4000a7fc <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 4000a7fc: 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 ) 4000a800: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 4000a804: 80 a0 60 00 cmp %g1, 0 4000a808: 02 80 00 08 be 4000a828 <_Thread_Stack_Free+0x2c> 4000a80c: 03 10 00 6b sethi %hi(0x4001ac00), %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 ) 4000a810: c2 00 62 08 ld [ %g1 + 0x208 ], %g1 ! 4001ae08 <_CPU_Table+0x24> 4000a814: 80 a0 60 00 cmp %g1, 0 4000a818: 02 80 00 06 be 4000a830 <_Thread_Stack_Free+0x34> 4000a81c: d0 06 20 d4 ld [ %i0 + 0xd4 ], %o0 (*_CPU_Table.stack_free_hook)( the_thread->Start.Initial_stack.area ); 4000a820: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a824: 01 00 00 00 nop <== NOT EXECUTED 4000a828: 81 c7 e0 08 ret <== NOT EXECUTED 4000a82c: 81 e8 00 00 restore <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4000a830: 31 10 00 6b sethi %hi(0x4001ac00), %i0 4000a834: b2 10 00 08 mov %o0, %i1 4000a838: 7f ff f5 04 call 40007c48 <_Heap_Free> 4000a83c: 91 ee 22 1c restore %i0, 0x21c, %o0 4000a840: 01 00 00 00 nop 40009dd4 <_Thread_queue_Dequeue>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 40009dd4: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 40009dd8: 80 a0 60 00 cmp %g1, 0 40009ddc: 02 80 00 05 be 40009df0 <_Thread_queue_Dequeue+0x1c> 40009de0: 80 a0 60 01 cmp %g1, 1 40009de4: 12 80 00 09 bne 40009e08 <_Thread_queue_Dequeue+0x34> 40009de8: 01 00 00 00 nop 40009dec: 30 80 00 04 b,a 40009dfc <_Thread_queue_Dequeue+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); 40009df0: 82 13 c0 00 mov %o7, %g1 40009df4: 40 00 0f 88 call 4000dc14 <_Thread_queue_Dequeue_fifo> 40009df8: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_Dequeue_priority( the_thread_queue ); 40009dfc: 82 13 c0 00 mov %o7, %g1 40009e00: 40 00 00 0a call 40009e28 <_Thread_queue_Dequeue_priority> 40009e04: 9e 10 40 00 mov %g1, %o7 the_thread = NULL; break; } return( the_thread ); } 40009e08: 81 c3 e0 08 retl <== NOT EXECUTED 40009e0c: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000dc14 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 4000dc14: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 4000dc18: 7f ff d0 ad call 40001ecc 4000dc1c: a0 10 00 18 mov %i0, %l0 4000dc20: 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)); 4000dc24: f0 06 00 00 ld [ %i0 ], %i0 if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 4000dc28: 82 04 20 04 add %l0, 4, %g1 4000dc2c: 80 a6 00 01 cmp %i0, %g1 4000dc30: 22 80 00 16 be,a 4000dc88 <_Thread_queue_Dequeue_fifo+0x74> 4000dc34: 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; 4000dc38: c2 06 00 00 ld [ %i0 ], %g1 the_chain->first = new_first; 4000dc3c: 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 ) ) { 4000dc40: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 new_first->previous = _Chain_Head(the_chain); 4000dc44: e0 20 60 04 st %l0, [ %g1 + 4 ] 4000dc48: 80 a0 a0 02 cmp %g2, 2 4000dc4c: 02 80 00 05 be 4000dc60 <_Thread_queue_Dequeue_fifo+0x4c> 4000dc50: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 4000dc54: 7f ff d0 a2 call 40001edc 4000dc58: 01 00 00 00 nop 4000dc5c: 30 80 00 07 b,a 4000dc78 <_Thread_queue_Dequeue_fifo+0x64> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 4000dc60: 82 10 20 03 mov 3, %g1 ! 3 4000dc64: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000dc68: 7f ff d0 9d call 40001edc 4000dc6c: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 4000dc70: 7f ff f4 94 call 4000aec0 <_Watchdog_Remove> 4000dc74: 90 06 20 48 add %i0, 0x48, %o0 _Thread_Unblock( the_thread ); 4000dc78: 7f ff ff e1 call 4000dbfc <_Thread_Unblock> 4000dc7c: 90 10 00 18 mov %i0, %o0 4000dc80: 81 c7 e0 08 ret 4000dc84: 81 e8 00 00 restore #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 4000dc88: 80 a0 60 02 cmp %g1, 2 4000dc8c: 18 80 00 06 bgu 4000dca4 <_Thread_queue_Dequeue_fifo+0x90> 4000dc90: 80 a0 60 03 cmp %g1, 3 4000dc94: 80 a0 60 01 cmp %g1, 1 4000dc98: 1a 80 00 0a bcc 4000dcc0 <_Thread_queue_Dequeue_fifo+0xac> 4000dc9c: 82 10 20 03 mov 3, %g1 4000dca0: 30 80 00 03 b,a 4000dcac <_Thread_queue_Dequeue_fifo+0x98> 4000dca4: 12 bf ff f7 bne 4000dc80 <_Thread_queue_Dequeue_fifo+0x6c> <== NOT EXECUTED 4000dca8: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 4000dcac: b0 10 20 00 clr %i0 4000dcb0: 7f ff d0 8b call 40001edc 4000dcb4: 90 10 00 02 mov %g2, %o0 4000dcb8: 81 c7 e0 08 ret 4000dcbc: 81 e8 00 00 restore return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 4000dcc0: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 4000dcc4: 7f ff d0 86 call 40001edc <== NOT EXECUTED 4000dcc8: 01 00 00 00 nop <== NOT EXECUTED return _Thread_Executing; 4000dccc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000dcd0: f0 00 62 ac ld [ %g1 + 0x2ac ], %i0 ! 4001aeac <_Thread_Executing> <== NOT EXECUTED } return NULL; /* this is only to prevent warnings */ } 4000dcd4: 81 c7 e0 08 ret <== NOT EXECUTED 4000dcd8: 81 e8 00 00 restore <== NOT EXECUTED 40009e28 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 40009e28: 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 ); 40009e2c: 7f ff e0 28 call 40001ecc 40009e30: 01 00 00 00 nop 40009e34: 98 10 00 08 mov %o0, %o4 40009e38: 86 10 20 00 clr %g3 40009e3c: 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)); 40009e40: 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 ] ) ) { 40009e44: 85 28 e0 02 sll %g3, 2, %g2 40009e48: 83 28 e0 04 sll %g3, 4, %g1 40009e4c: 82 20 40 02 sub %g1, %g2, %g1 40009e50: 82 06 00 01 add %i0, %g1, %g1 40009e54: 82 00 60 04 add %g1, 4, %g1 40009e58: 80 a2 00 01 cmp %o0, %g1 40009e5c: 02 80 00 04 be 40009e6c <_Thread_queue_Dequeue_priority+0x44> 40009e60: 88 01 20 0c add %g4, 0xc, %g4 the_thread = (Thread_Control *) 40009e64: 10 80 00 1c b 40009ed4 <_Thread_queue_Dequeue_priority+0xac> 40009e68: b0 10 00 08 mov %o0, %i0 Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 40009e6c: 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 ; 40009e70: 80 a0 e0 04 cmp %g3, 4 40009e74: 32 bf ff f4 bne,a 40009e44 <_Thread_queue_Dequeue_priority+0x1c> 40009e78: d0 01 00 18 ld [ %g4 + %i0 ], %o0 the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 40009e7c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 40009e80: 80 a0 60 02 cmp %g1, 2 40009e84: 18 80 00 06 bgu 40009e9c <_Thread_queue_Dequeue_priority+0x74> 40009e88: 80 a0 60 03 cmp %g1, 3 40009e8c: 80 a0 60 01 cmp %g1, 1 40009e90: 1a 80 00 0a bcc 40009eb8 <_Thread_queue_Dequeue_priority+0x90> 40009e94: 82 10 20 03 mov 3, %g1 40009e98: 30 80 00 03 b,a 40009ea4 <_Thread_queue_Dequeue_priority+0x7c> 40009e9c: 12 80 00 0e bne 40009ed4 <_Thread_queue_Dequeue_priority+0xac> <== NOT EXECUTED 40009ea0: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 40009ea4: b0 10 20 00 clr %i0 40009ea8: 7f ff e0 0d call 40001edc 40009eac: 90 10 00 0c mov %o4, %o0 40009eb0: 81 c7 e0 08 ret 40009eb4: 81 e8 00 00 restore return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 40009eb8: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 40009ebc: 7f ff e0 08 call 40001edc <== NOT EXECUTED 40009ec0: 90 10 00 0c mov %o4, %o0 <== NOT EXECUTED return _Thread_Executing; 40009ec4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009ec8: f0 00 62 ac ld [ %g1 + 0x2ac ], %i0 ! 4001aeac <_Thread_Executing> <== NOT EXECUTED 40009ecc: 81 c7 e0 08 ret <== NOT EXECUTED 40009ed0: 81 e8 00 00 restore <== NOT EXECUTED } dequeue: the_thread->Wait.queue = NULL; new_first_node = the_thread->Wait.Block2n.first; 40009ed4: 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 ) ) { 40009ed8: 82 06 20 3c add %i0, 0x3c, %g1 _ISR_Enable( level ); return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; 40009edc: 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 ) ) { 40009ee0: 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; 40009ee4: c4 06 00 00 ld [ %i0 ], %g2 previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 40009ee8: 02 80 00 14 be 40009f38 <_Thread_queue_Dequeue_priority+0x110> 40009eec: c2 06 20 04 ld [ %i0 + 4 ], %g1 last_node = the_thread->Wait.Block2n.last; 40009ef0: da 06 20 40 ld [ %i0 + 0x40 ], %o5 new_second_node = new_first_node->next; 40009ef4: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 40009ef8: 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; 40009efc: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 40009f00: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 40009f04: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 40009f08: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 40009f0c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 40009f10: 80 a0 80 01 cmp %g2, %g1 40009f14: 22 80 00 0c be,a 40009f44 <_Thread_queue_Dequeue_priority+0x11c> 40009f18: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 /* > two threads on 2-n */ new_second_node->previous = 40009f1c: 82 00 e0 38 add %g3, 0x38, %g1 40009f20: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 40009f24: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] new_first_thread->Wait.Block2n.last = last_node; 40009f28: da 20 e0 40 st %o5, [ %g3 + 0x40 ] last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 40009f2c: 82 00 e0 3c add %g3, 0x3c, %g1 40009f30: 10 80 00 04 b 40009f40 <_Thread_queue_Dequeue_priority+0x118> 40009f34: c2 23 40 00 st %g1, [ %o5 ] } } else { previous_node->next = next_node; next_node->previous = previous_node; 40009f38: 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; 40009f3c: c4 20 40 00 st %g2, [ %g1 ] next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 40009f40: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 40009f44: 80 a0 60 02 cmp %g1, 2 40009f48: 02 80 00 08 be 40009f68 <_Thread_queue_Dequeue_priority+0x140> 40009f4c: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 40009f50: 7f ff df e3 call 40001edc 40009f54: 90 10 00 0c mov %o4, %o0 _Thread_Unblock( the_thread ); 40009f58: 7f ff ff ae call 40009e10 <_Thread_Unblock> 40009f5c: 90 10 00 18 mov %i0, %o0 40009f60: 81 c7 e0 08 ret 40009f64: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 40009f68: c2 26 20 50 st %g1, [ %i0 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 40009f6c: 7f ff df dc call 40001edc 40009f70: 90 10 00 0c mov %o4, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 40009f74: 40 00 03 d3 call 4000aec0 <_Watchdog_Remove> 40009f78: 90 06 20 48 add %i0, 0x48, %o0 _Thread_Unblock( the_thread ); 40009f7c: 7f ff ff a5 call 40009e10 <_Thread_Unblock> 40009f80: 90 10 00 18 mov %i0, %o0 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 40009f84: 81 c7 e0 08 ret 40009f88: 81 e8 00 00 restore 4000dcdc <_Thread_queue_Enqueue_fifo>: void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000dcdc: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); 4000dce0: 7f ff d0 7b call 40001ecc 4000dce4: a0 10 00 18 mov %i0, %l0 void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000dce8: b0 10 00 19 mov %i1, %i0 ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); sync_state = the_thread_queue->sync_state; 4000dcec: c4 04 20 30 ld [ %l0 + 0x30 ], %g2 the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 4000dcf0: 80 a0 a0 02 cmp %g2, 2 4000dcf4: 02 80 00 10 be 4000dd34 <_Thread_queue_Enqueue_fifo+0x58> 4000dcf8: c0 24 20 30 clr [ %l0 + 0x30 ] 4000dcfc: 80 a0 a0 03 cmp %g2, 3 4000dd00: 02 80 00 12 be 4000dd48 <_Thread_queue_Enqueue_fifo+0x6c> 4000dd04: 80 a0 a0 01 cmp %g2, 1 4000dd08: 32 80 00 1e bne,a 4000dd80 <_Thread_queue_Enqueue_fifo+0xa4> 4000dd0c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000dd10: 82 04 20 04 add %l0, 4, %g1 4000dd14: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 4000dd18: c2 04 20 08 ld [ %l0 + 8 ], %g1 the_chain->last = the_node; 4000dd1c: f2 24 20 08 st %i1, [ %l0 + 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; 4000dd20: e0 26 60 44 st %l0, [ %i1 + 0x44 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000dd24: c2 26 60 04 st %g1, [ %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; 4000dd28: f2 20 40 00 st %i1, [ %g1 ] _ISR_Enable( level ); 4000dd2c: 7f ff d0 6c call 40001edc 4000dd30: 91 e8 00 08 restore %g0, %o0, %o0 return; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 4000dd34: c2 06 60 44 ld [ %i1 + 0x44 ], %g1 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000dd38: 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; 4000dd3c: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED 4000dd40: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 4000dd44: 30 80 00 0d b,a 4000dd78 <_Thread_queue_Enqueue_fifo+0x9c> <== NOT EXECUTED break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 4000dd48: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 4000dd4c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000dd50: 12 80 00 0a bne 4000dd78 <_Thread_queue_Enqueue_fifo+0x9c> <== NOT EXECUTED 4000dd54: 01 00 00 00 nop <== NOT EXECUTED 4000dd58: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 4000dd5c: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 4000dd60: 7f ff d0 5f call 40001edc <== NOT EXECUTED 4000dd64: 01 00 00 00 nop <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 4000dd68: 7f ff f4 56 call 4000aec0 <_Watchdog_Remove> <== NOT EXECUTED 4000dd6c: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 4000dd70: 10 80 00 04 b 4000dd80 <_Thread_queue_Enqueue_fifo+0xa4> <== NOT EXECUTED 4000dd74: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED } else _ISR_Enable( level ); 4000dd78: 7f ff d0 59 call 40001edc <== NOT EXECUTED 4000dd7c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000dd80: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000dd84: 7f ff ee 60 call 40009704 <_Thread_Clear_state> <== NOT EXECUTED 4000dd88: 81 e8 00 00 restore <== NOT EXECUTED 4000dd8c: 01 00 00 00 nop 4000a010 <_Thread_queue_Enqueue_priority>: void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000a010: 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; 4000a014: 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); 4000a018: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; 4000a01c: c0 26 60 3c clr [ %i1 + 0x3c ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 4000a020: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4000a024: 82 06 60 38 add %i1, 0x38, %g1 4000a028: c2 26 60 40 st %g1, [ %i1 + 0x40 ] 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 ) ) 4000a02c: 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); 4000a030: 85 34 a0 06 srl %l2, 6, %g2 4000a034: 12 80 00 34 bne 4000a104 <_Thread_queue_Enqueue_priority+0xf4> 4000a038: ec 06 20 38 ld [ %i0 + 0x38 ], %l6 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 4000a03c: 83 28 a0 04 sll %g2, 4, %g1 4000a040: 85 28 a0 02 sll %g2, 2, %g2 4000a044: aa 20 40 02 sub %g1, %g2, %l5 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4000a048: 82 06 00 15 add %i0, %l5, %g1 4000a04c: a8 00 60 04 add %g1, 4, %l4 if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 4000a050: 7f ff df 9f call 40001ecc 4000a054: 01 00 00 00 nop 4000a058: a2 10 00 08 mov %o0, %l1 search_thread = (Thread_Control *) header->first; 4000a05c: e0 06 00 15 ld [ %i0 + %l5 ], %l0 4000a060: 10 80 00 18 b 4000a0c0 <_Thread_queue_Enqueue_priority+0xb0> 4000a064: a6 10 3f ff mov -1, %l3 while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; if ( priority <= search_priority ) 4000a068: 80 a4 80 13 cmp %l2, %l3 4000a06c: 28 80 00 19 bleu,a 4000a0d0 <_Thread_queue_Enqueue_priority+0xc0> 4000a070: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 4000a074: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 4000a078: 80 a4 00 14 cmp %l0, %l4 4000a07c: 22 80 00 15 be,a 4000a0d0 <_Thread_queue_Enqueue_priority+0xc0> 4000a080: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 4000a084: e6 04 20 14 ld [ %l0 + 0x14 ], %l3 if ( priority <= search_priority ) 4000a088: 80 a4 80 13 cmp %l2, %l3 4000a08c: 28 80 00 11 bleu,a 4000a0d0 <_Thread_queue_Enqueue_priority+0xc0> 4000a090: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #endif _ISR_Flash( level ); 4000a094: 7f ff df 92 call 40001edc 4000a098: 90 10 00 11 mov %l1, %o0 4000a09c: 7f ff df 8c call 40001ecc 4000a0a0: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 4000a0a4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 4000a0a8: 80 8d 80 01 btst %l6, %g1 4000a0ac: 32 80 00 05 bne,a 4000a0c0 <_Thread_queue_Enqueue_priority+0xb0> 4000a0b0: e0 04 00 00 ld [ %l0 ], %l0 _ISR_Enable( level ); 4000a0b4: 7f ff df 8a call 40001edc <== NOT EXECUTED 4000a0b8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 4000a0bc: 30 bf ff e5 b,a 4000a050 <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED 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 ) ) { 4000a0c0: 80 a4 00 14 cmp %l0, %l4 4000a0c4: 32 bf ff e9 bne,a 4000a068 <_Thread_queue_Enqueue_priority+0x58> 4000a0c8: e6 04 20 14 ld [ %l0 + 0x14 ], %l3 } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 4000a0cc: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 4000a0d0: 80 a0 60 01 cmp %g1, 1 4000a0d4: 32 80 00 47 bne,a 4000a1f0 <_Thread_queue_Enqueue_priority+0x1e0> 4000a0d8: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 <== NOT EXECUTED goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 4000a0dc: 80 a4 80 13 cmp %l2, %l3 4000a0e0: 02 80 00 3c be 4000a1d0 <_Thread_queue_Enqueue_priority+0x1c0> 4000a0e4: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 4000a0e8: c2 04 20 04 ld [ %l0 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 4000a0ec: e0 26 40 00 st %l0, [ %i1 ] the_node->previous = previous_node; 4000a0f0: 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; 4000a0f4: f0 26 60 44 st %i0, [ %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; 4000a0f8: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 4000a0fc: f2 24 20 04 st %i1, [ %l0 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 4000a100: 30 80 00 32 b,a 4000a1c8 <_Thread_queue_Enqueue_priority+0x1b8> restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 4000a104: 83 28 a0 04 sll %g2, 4, %g1 4000a108: 85 28 a0 02 sll %g2, 2, %g2 4000a10c: 82 20 40 02 sub %g1, %g2, %g1 4000a110: a6 00 40 18 add %g1, %i0, %l3 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 4000a114: aa 10 00 13 mov %l3, %l5 return; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); 4000a118: 7f ff df 6d call 40001ecc 4000a11c: 01 00 00 00 nop 4000a120: a2 10 00 08 mov %o0, %l1 search_thread = (Thread_Control *) header->last; 4000a124: e0 05 60 08 ld [ %l5 + 8 ], %l0 4000a128: 10 80 00 18 b 4000a188 <_Thread_queue_Enqueue_priority+0x178> 4000a12c: a8 10 21 00 mov 0x100, %l4 while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; if ( priority >= search_priority ) 4000a130: 80 a4 80 14 cmp %l2, %l4 4000a134: 3a 80 00 19 bcc,a 4000a198 <_Thread_queue_Enqueue_priority+0x188> 4000a138: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 4000a13c: e0 04 20 04 ld [ %l0 + 4 ], %l0 if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 4000a140: 80 a4 00 13 cmp %l0, %l3 4000a144: 22 80 00 15 be,a 4000a198 <_Thread_queue_Enqueue_priority+0x188> 4000a148: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 4000a14c: e8 04 20 14 ld [ %l0 + 0x14 ], %l4 if ( priority >= search_priority ) 4000a150: 80 a4 80 14 cmp %l2, %l4 4000a154: 3a 80 00 11 bcc,a 4000a198 <_Thread_queue_Enqueue_priority+0x188> 4000a158: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED break; #endif _ISR_Flash( level ); 4000a15c: 7f ff df 60 call 40001edc 4000a160: 90 10 00 11 mov %l1, %o0 4000a164: 7f ff df 5a call 40001ecc 4000a168: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 4000a16c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 4000a170: 80 8d 80 01 btst %l6, %g1 4000a174: 32 80 00 05 bne,a 4000a188 <_Thread_queue_Enqueue_priority+0x178> 4000a178: e0 04 20 04 ld [ %l0 + 4 ], %l0 _ISR_Enable( level ); 4000a17c: 7f ff df 58 call 40001edc <== NOT EXECUTED 4000a180: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 4000a184: 30 bf ff e5 b,a 4000a118 <_Thread_queue_Enqueue_priority+0x108> <== NOT EXECUTED 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 ) ) { 4000a188: 80 a4 00 13 cmp %l0, %l3 4000a18c: 32 bf ff e9 bne,a 4000a130 <_Thread_queue_Enqueue_priority+0x120> 4000a190: e8 04 20 14 ld [ %l0 + 0x14 ], %l4 } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 4000a194: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 4000a198: 80 a0 60 01 cmp %g1, 1 4000a19c: 32 80 00 15 bne,a 4000a1f0 <_Thread_queue_Enqueue_priority+0x1e0> 4000a1a0: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 <== NOT EXECUTED goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 4000a1a4: 80 a4 80 14 cmp %l2, %l4 4000a1a8: 02 80 00 0a be 4000a1d0 <_Thread_queue_Enqueue_priority+0x1c0> 4000a1ac: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 4000a1b0: c2 04 00 00 ld [ %l0 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 4000a1b4: 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; 4000a1b8: 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; 4000a1bc: f0 26 60 44 st %i0, [ %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; 4000a1c0: f2 24 00 00 st %i1, [ %l0 ] next_node->previous = the_node; 4000a1c4: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 4000a1c8: 7f ff df 45 call 40001edc 4000a1cc: 91 e8 00 11 restore %g0, %l1, %o0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4000a1d0: 82 04 20 3c add %l0, 0x3c, %g1 return; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 4000a1d4: c4 00 60 04 ld [ %g1 + 4 ], %g2 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 4000a1d8: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = previous_node; 4000a1dc: 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; 4000a1e0: f0 26 60 44 st %i0, [ %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; 4000a1e4: f2 20 80 00 st %i1, [ %g2 ] search_node->previous = the_node; 4000a1e8: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 4000a1ec: 30 bf ff f7 b,a 4000a1c8 <_Thread_queue_Enqueue_priority+0x1b8> synchronize: sync_state = the_thread_queue->sync_state; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 4000a1f0: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 4000a1f4: 02 80 00 07 be 4000a210 <_Thread_queue_Enqueue_priority+0x200> <== NOT EXECUTED 4000a1f8: c0 26 20 30 clr [ %i0 + 0x30 ] <== NOT EXECUTED 4000a1fc: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 4000a200: 12 80 00 17 bne 4000a25c <_Thread_queue_Enqueue_priority+0x24c> <== NOT EXECUTED 4000a204: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 4000a208: 10 80 00 07 b 4000a224 <_Thread_queue_Enqueue_priority+0x214> <== NOT EXECUTED 4000a20c: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== 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; 4000a210: c2 06 60 44 ld [ %i1 + 0x44 ], %g1 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000a214: 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; 4000a218: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED 4000a21c: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 4000a220: 30 80 00 0c b,a 4000a250 <_Thread_queue_Enqueue_priority+0x240> <== NOT EXECUTED break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 4000a224: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000a228: 12 80 00 0a bne 4000a250 <_Thread_queue_Enqueue_priority+0x240> <== NOT EXECUTED 4000a22c: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 4000a230: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 4000a234: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 4000a238: 7f ff df 29 call 40001edc <== NOT EXECUTED 4000a23c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 4000a240: 40 00 03 20 call 4000aec0 <_Watchdog_Remove> <== NOT EXECUTED 4000a244: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 4000a248: 10 80 00 05 b 4000a25c <_Thread_queue_Enqueue_priority+0x24c> <== NOT EXECUTED 4000a24c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED } else _ISR_Enable( level ); 4000a250: 7f ff df 23 call 40001edc <== NOT EXECUTED 4000a254: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 4000a258: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000a25c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000a260: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000a264: 7f ff fd 28 call 40009704 <_Thread_Clear_state> <== NOT EXECUTED 4000a268: 81 e8 00 00 restore <== NOT EXECUTED 4000a26c: 01 00 00 00 nop 40009f8c <_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 ) { 40009f8c: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; the_thread = _Thread_Executing; 40009f90: 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 ); 40009f94: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 Thread_queue_Timeout_callout handler ) { Thread_Control *the_thread; the_thread = _Thread_Executing; 40009f98: e0 00 62 ac ld [ %g1 + 0x2ac ], %l0 void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 40009f9c: 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 ); 40009fa0: 40 00 01 79 call 4000a584 <_Thread_Set_state> 40009fa4: 90 10 00 10 mov %l0, %o0 /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 40009fa8: 80 a6 60 00 cmp %i1, 0 40009fac: 22 80 00 0d be,a 40009fe0 <_Thread_queue_Enqueue_with_handler+0x54> 40009fb0: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 _Watchdog_Initialize( 40009fb4: c2 04 20 08 ld [ %l0 + 8 ], %g1 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40009fb8: 11 10 00 6b sethi %hi(0x4001ac00), %o0 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40009fbc: f4 24 20 64 st %i2, [ %l0 + 0x64 ] the_watchdog->id = id; 40009fc0: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40009fc4: f2 24 20 54 st %i1, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40009fc8: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 40009fcc: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40009fd0: 90 12 22 cc or %o0, 0x2cc, %o0 40009fd4: 40 00 03 63 call 4000ad60 <_Watchdog_Insert> 40009fd8: 92 04 20 48 add %l0, 0x48, %o1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 40009fdc: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 40009fe0: 80 a0 60 00 cmp %g1, 0 40009fe4: 02 80 00 05 be 40009ff8 <_Thread_queue_Enqueue_with_handler+0x6c> 40009fe8: 80 a0 60 01 cmp %g1, 1 40009fec: 12 80 00 07 bne 4000a008 <_Thread_queue_Enqueue_with_handler+0x7c> 40009ff0: 01 00 00 00 nop 40009ff4: 30 80 00 03 b,a 4000a000 <_Thread_queue_Enqueue_with_handler+0x74> case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); 40009ff8: 40 00 0f 39 call 4000dcdc <_Thread_queue_Enqueue_fifo> 40009ffc: 93 e8 00 10 restore %g0, %l0, %o1 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Enqueue_priority( the_thread_queue, the_thread ); 4000a000: 40 00 00 04 call 4000a010 <_Thread_queue_Enqueue_priority> 4000a004: 93 e8 00 10 restore %g0, %l0, %o1 4000a008: 81 c7 e0 08 ret <== NOT EXECUTED 4000a00c: 81 e8 00 00 restore <== NOT EXECUTED 4000dd90 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 4000dd90: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4000dd94: 80 a0 60 00 cmp %g1, 0 4000dd98: 02 80 00 05 be 4000ddac <_Thread_queue_Extract+0x1c> 4000dd9c: 80 a0 60 01 cmp %g1, 1 4000dda0: 12 80 00 09 bne 4000ddc4 <_Thread_queue_Extract+0x34> 4000dda4: 94 10 20 00 clr %o2 4000dda8: 30 80 00 04 b,a 4000ddb8 <_Thread_queue_Extract+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 4000ddac: 82 13 c0 00 mov %o7, %g1 4000ddb0: 40 00 04 32 call 4000ee78 <_Thread_queue_Extract_fifo> 4000ddb4: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 4000ddb8: 82 13 c0 00 mov %o7, %g1 4000ddbc: 40 00 00 04 call 4000ddcc <_Thread_queue_Extract_priority_helper> 4000ddc0: 9e 10 40 00 mov %g1, %o7 4000ddc4: 81 c3 e0 08 retl <== NOT EXECUTED 4000ddc8: 01 00 00 00 nop 4000ee78 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000ee78: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 4000ee7c: 7f ff cc 14 call 40001ecc 4000ee80: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 4000ee84: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 4000ee88: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000ee8c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000ee90: 80 88 80 01 btst %g2, %g1 4000ee94: 32 80 00 04 bne,a 4000eea4 <_Thread_queue_Extract_fifo+0x2c> 4000ee98: c2 06 40 00 ld [ %i1 ], %g1 _ISR_Enable( level ); 4000ee9c: 7f ff cc 10 call 40001edc <== NOT EXECUTED 4000eea0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 4000eea4: 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 ) ) { 4000eea8: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 next->previous = previous; previous->next = next; 4000eeac: c2 20 80 00 st %g1, [ %g2 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000eeb0: c4 20 60 04 st %g2, [ %g1 + 4 ] 4000eeb4: 80 a0 e0 02 cmp %g3, 2 4000eeb8: 02 80 00 06 be 4000eed0 <_Thread_queue_Extract_fifo+0x58> 4000eebc: c0 26 60 44 clr [ %i1 + 0x44 ] _ISR_Enable( level ); 4000eec0: 7f ff cc 07 call 40001edc 4000eec4: 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 ); 4000eec8: 10 80 00 0a b 4000eef0 <_Thread_queue_Extract_fifo+0x78> 4000eecc: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000eed0: 82 10 20 03 mov 3, %g1 4000eed4: c2 26 60 50 st %g1, [ %i1 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000eed8: 7f ff cc 01 call 40001edc 4000eedc: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 4000eee0: 7f ff ef f8 call 4000aec0 <_Watchdog_Remove> 4000eee4: 90 06 60 48 add %i1, 0x48, %o0 4000eee8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 4000eeec: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000eef0: 7f ff ea 05 call 40009704 <_Thread_Clear_state> 4000eef4: 81 e8 00 00 restore 4000eef8: 01 00 00 00 nop 4000ddcc <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, boolean requeuing ) { 4000ddcc: 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 ); 4000ddd0: 7f ff d0 3f call 40001ecc 4000ddd4: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 4000ddd8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 4000dddc: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000dde0: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000dde4: 80 88 80 01 btst %g2, %g1 4000dde8: 32 80 00 03 bne,a 4000ddf4 <_Thread_queue_Extract_priority_helper+0x28> 4000ddec: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 _ISR_Enable( level ); 4000ddf0: 30 80 00 1d b,a 4000de64 <_Thread_queue_Extract_priority_helper+0x98> <== NOT EXECUTED */ next_node = the_node->next; previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 4000ddf4: 82 06 60 3c add %i1, 0x3c, %g1 /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 4000ddf8: c4 06 40 00 ld [ %i1 ], %g2 previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 4000ddfc: 80 a0 c0 01 cmp %g3, %g1 4000de00: 02 80 00 14 be 4000de50 <_Thread_queue_Extract_priority_helper+0x84> 4000de04: c2 06 60 04 ld [ %i1 + 4 ], %g1 new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 4000de08: da 06 60 40 ld [ %i1 + 0x40 ], %o5 new_second_node = new_first_node->next; 4000de0c: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 4000de10: 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; 4000de14: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 4000de18: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 4000de1c: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 4000de20: c4 06 60 38 ld [ %i1 + 0x38 ], %g2 4000de24: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 4000de28: 80 a0 80 01 cmp %g2, %g1 4000de2c: 02 80 00 0c be 4000de5c <_Thread_queue_Extract_priority_helper+0x90> 4000de30: 80 a6 a0 00 cmp %i2, 0 /* > two threads on 2-n */ new_second_node->previous = 4000de34: 82 00 e0 38 add %g3, 0x38, %g1 <== NOT EXECUTED 4000de38: 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; 4000de3c: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 4000de40: da 20 e0 40 st %o5, [ %g3 + 0x40 ] <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 4000de44: 82 00 e0 3c add %g3, 0x3c, %g1 <== NOT EXECUTED 4000de48: 10 80 00 05 b 4000de5c <_Thread_queue_Extract_priority_helper+0x90> <== NOT EXECUTED 4000de4c: c2 23 40 00 st %g1, [ %o5 ] <== NOT EXECUTED } } else { previous_node->next = next_node; next_node->previous = previous_node; 4000de50: 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; 4000de54: c4 20 40 00 st %g2, [ %g1 ] /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 4000de58: 80 a6 a0 00 cmp %i2, 0 4000de5c: 22 80 00 04 be,a 4000de6c <_Thread_queue_Extract_priority_helper+0xa0> 4000de60: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 _ISR_Enable( level ); 4000de64: 7f ff d0 1e call 40001edc 4000de68: 91 e8 00 08 restore %g0, %o0, %o0 return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 4000de6c: 80 a0 60 02 cmp %g1, 2 4000de70: 02 80 00 06 be 4000de88 <_Thread_queue_Extract_priority_helper+0xbc> 4000de74: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 4000de78: 7f ff d0 19 call 40001edc 4000de7c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 4000de80: 10 80 00 08 b 4000dea0 <_Thread_queue_Extract_priority_helper+0xd4> 4000de84: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000de88: c2 26 20 50 st %g1, [ %i0 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000de8c: 7f ff d0 14 call 40001edc 4000de90: 33 04 00 ff sethi %hi(0x1003fc00), %i1 (void) _Watchdog_Remove( &the_thread->Timer ); 4000de94: 7f ff f4 0b call 4000aec0 <_Watchdog_Remove> 4000de98: 90 06 20 48 add %i0, 0x48, %o0 4000de9c: b2 16 63 f8 or %i1, 0x3f8, %i1 4000dea0: 7f ff ee 19 call 40009704 <_Thread_Clear_state> 4000dea4: 81 e8 00 00 restore 4000dea8: 01 00 00 00 nop 4000a270 <_Thread_queue_Extract_with_proxy>: */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 4000a270: 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; 4000a274: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 4000a278: 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 ) ) { 4000a27c: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000a280: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000a284: 80 88 80 01 btst %g2, %g1 4000a288: 02 80 00 1e be 4000a300 <_Thread_queue_Extract_with_proxy+0x90> 4000a28c: b0 10 20 00 clr %i0 if ( _States_Is_waiting_for_rpc_reply( state ) && 4000a290: 03 00 00 08 sethi %hi(0x2000), %g1 4000a294: 80 88 80 01 btst %g2, %g1 4000a298: 22 80 00 17 be,a 4000a2f4 <_Thread_queue_Extract_with_proxy+0x84> 4000a29c: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 4000a2a0: 03 00 00 e7 sethi %hi(0x39c00), %g1 <== NOT EXECUTED 4000a2a4: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 39ee0 <== NOT EXECUTED 4000a2a8: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 4000a2ac: 22 80 00 12 be,a 4000a2f4 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 4000a2b0: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED _States_Is_locally_blocked( state ) ) { the_information = _Objects_Get_information( the_thread->Wait.id ); 4000a2b4: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED proxy_extract_callout = 4000a2b8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000a2bc: 85 30 e0 16 srl %g3, 0x16, %g2 <== NOT EXECUTED 4000a2c0: 82 10 61 30 or %g1, 0x130, %g1 <== NOT EXECUTED 4000a2c4: 84 08 a0 1c and %g2, 0x1c, %g2 <== NOT EXECUTED 4000a2c8: c2 00 40 02 ld [ %g1 + %g2 ], %g1 <== NOT EXECUTED 4000a2cc: 87 30 e0 1b srl %g3, 0x1b, %g3 <== NOT EXECUTED 4000a2d0: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED 4000a2d4: c2 00 40 03 ld [ %g1 + %g3 ], %g1 <== NOT EXECUTED 4000a2d8: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 <== NOT EXECUTED (Objects_Thread_queue_Extract_callout) the_information->extract; if ( proxy_extract_callout ) 4000a2dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000a2e0: 22 80 00 05 be,a 4000a2f4 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 4000a2e4: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED (*proxy_extract_callout)( the_thread ); 4000a2e8: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a2ec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 4000a2f0: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED 4000a2f4: 92 10 00 10 mov %l0, %o1 4000a2f8: 40 00 0e a6 call 4000dd90 <_Thread_queue_Extract> 4000a2fc: b0 10 20 01 mov 1, %i0 return TRUE; } return FALSE; } 4000a300: 81 c7 e0 08 ret 4000a304: 81 e8 00 00 restore 4000c930 <_Thread_queue_First>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 4000c930: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4000c934: 80 a0 60 00 cmp %g1, 0 4000c938: 02 80 00 05 be 4000c94c <_Thread_queue_First+0x1c> 4000c93c: 80 a0 60 01 cmp %g1, 1 4000c940: 12 80 00 09 bne 4000c964 <_Thread_queue_First+0x34> 4000c944: 01 00 00 00 nop 4000c948: 30 80 00 04 b,a 4000c958 <_Thread_queue_First+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); 4000c94c: 82 13 c0 00 mov %o7, %g1 4000c950: 40 00 0f 51 call 40010694 <_Thread_queue_First_fifo> 4000c954: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_First_priority( the_thread_queue ); 4000c958: 82 13 c0 00 mov %o7, %g1 4000c95c: 40 00 00 04 call 4000c96c <_Thread_queue_First_priority> 4000c960: 9e 10 40 00 mov %g1, %o7 the_thread = NULL; break; } return the_thread; } 4000c964: 81 c3 e0 08 retl <== NOT EXECUTED 4000c968: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000a3b4 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000a3b4: 9d e3 bf 98 save %sp, -104, %sp /* just in case the thread really wasn't blocked here */ if ( !the_thread_queue ) { 4000a3b8: 80 a6 20 00 cmp %i0, 0 4000a3bc: 02 80 00 18 be 4000a41c <_Thread_queue_Requeue+0x68> 4000a3c0: 01 00 00 00 nop return; } switch ( the_thread_queue->discipline ) { 4000a3c4: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 4000a3c8: 80 a4 20 01 cmp %l0, 1 4000a3cc: 12 80 00 14 bne 4000a41c <_Thread_queue_Requeue+0x68> 4000a3d0: 01 00 00 00 nop break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; _ISR_Disable( level ); 4000a3d4: 7f ff de be call 40001ecc 4000a3d8: 01 00 00 00 nop 4000a3dc: a2 10 00 08 mov %o0, %l1 if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 4000a3e0: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 4000a3e4: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000a3e8: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000a3ec: 80 88 80 01 btst %g2, %g1 4000a3f0: 02 80 00 09 be 4000a414 <_Thread_queue_Requeue+0x60> 4000a3f4: 90 10 00 18 mov %i0, %o0 _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 4000a3f8: 92 10 00 19 mov %i1, %o1 4000a3fc: 94 10 20 01 mov 1, %o2 4000a400: 40 00 0e 73 call 4000ddcc <_Thread_queue_Extract_priority_helper> 4000a404: e0 26 20 30 st %l0, [ %i0 + 0x30 ] _Thread_queue_Enqueue_priority( tq, the_thread ); 4000a408: 90 10 00 18 mov %i0, %o0 4000a40c: 7f ff ff 01 call 4000a010 <_Thread_queue_Enqueue_priority> 4000a410: 92 10 00 19 mov %i1, %o1 } _ISR_Enable( level ); 4000a414: 7f ff de b2 call 40001edc 4000a418: 91 e8 00 11 restore %g0, %l1, %o0 4000a41c: 81 c7 e0 08 ret <== NOT EXECUTED 4000a420: 81 e8 00 00 restore <== NOT EXECUTED 4000a424 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 4000a424: 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 ) ) { 4000a428: 92 96 20 00 orcc %i0, 0, %o1 4000a42c: 12 80 00 0a bne 4000a454 <_Thread_queue_Timeout+0x30> 4000a430: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000a434: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000a438: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000a43c: 84 00 a0 01 inc %g2 <== NOT EXECUTED 4000a440: c4 20 61 d0 st %g2, [ %g1 + 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; 4000a444: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000a448: d2 00 62 ac ld [ %g1 + 0x2ac ], %o1 ! 4001aeac <_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; 4000a44c: 10 80 00 18 b 4000a4ac <_Thread_queue_Timeout+0x88> <== NOT EXECUTED 4000a450: c0 27 bf f4 clr [ %fp + -12 ] <== 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); 4000a454: 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 ) { 4000a458: 80 a0 a0 04 cmp %g2, 4 4000a45c: 18 80 00 0e bgu 4000a494 <_Thread_queue_Timeout+0x70> 4000a460: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4000a464: 83 32 60 1b srl %o1, 0x1b, %g1 4000a468: 80 a0 60 01 cmp %g1, 1 4000a46c: 12 80 00 0a bne 4000a494 <_Thread_queue_Timeout+0x70> 4000a470: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4000a474: 83 28 a0 02 sll %g2, 2, %g1 4000a478: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000a47c: 84 10 a1 30 or %g2, 0x130, %g2 ! 4001ad30 <_Objects_Information_table> 4000a480: c2 00 80 01 ld [ %g2 + %g1 ], %g1 4000a484: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 4000a488: 80 a2 20 00 cmp %o0, 0 4000a48c: 12 80 00 05 bne 4000a4a0 <_Thread_queue_Timeout+0x7c> 4000a490: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 4000a494: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000a498: 10 80 00 05 b 4000a4ac <_Thread_queue_Timeout+0x88> <== NOT EXECUTED 4000a49c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4000a4a0: 7f ff f8 5f call 4000861c <_Objects_Get> 4000a4a4: 94 07 bf f4 add %fp, -12, %o2 4000a4a8: 92 10 00 08 mov %o0, %o1 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000a4ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000a4b0: 80 a0 60 00 cmp %g1, 0 4000a4b4: 12 80 00 18 bne 4000a514 <_Thread_queue_Timeout+0xf0> 4000a4b8: 01 00 00 00 nop */ static inline void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 4000a4bc: c4 02 60 44 ld [ %o1 + 0x44 ], %g2 * 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 && 4000a4c0: c6 00 a0 30 ld [ %g2 + 0x30 ], %g3 4000a4c4: 80 a0 e0 00 cmp %g3, 0 4000a4c8: 02 80 00 0b be 4000a4f4 <_Thread_queue_Timeout+0xd0> 4000a4cc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a4d0: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 4001aeac <_Thread_Executing> <== NOT EXECUTED 4000a4d4: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED 4000a4d8: 32 80 00 08 bne,a 4000a4f8 <_Thread_queue_Timeout+0xd4> <== NOT EXECUTED 4000a4dc: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 4000a4e0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 4000a4e4: 02 80 00 08 be 4000a504 <_Thread_queue_Timeout+0xe0> <== NOT EXECUTED 4000a4e8: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 4000a4ec: 10 80 00 06 b 4000a504 <_Thread_queue_Timeout+0xe0> <== NOT EXECUTED 4000a4f0: c2 20 a0 30 st %g1, [ %g2 + 0x30 ] <== NOT EXECUTED } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 4000a4f4: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 4000a4f8: d0 02 60 44 ld [ %o1 + 0x44 ], %o0 4000a4fc: 40 00 0e 25 call 4000dd90 <_Thread_queue_Extract> 4000a500: 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; 4000a504: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000a508: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 4000a50c: 82 00 7f ff add %g1, -1, %g1 4000a510: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] 4000a514: 81 c7 e0 08 ret 4000a518: 81 e8 00 00 restore 40013888 <_Timer_Server_body>: */ Thread _Timer_Server_body( uint32_t ignored ) { 40013888: 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; 4001388c: 03 10 00 d2 sethi %hi(0x40034800), %g1 40013890: c8 00 62 34 ld [ %g1 + 0x234 ], %g4 ! 40034a34 <_Watchdog_Ticks_since_boot> _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 40013894: 03 10 00 d2 sethi %hi(0x40034800), %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40013898: 07 10 00 d2 sethi %hi(0x40034800), %g3 4001389c: da 00 61 68 ld [ %g1 + 0x168 ], %o5 400138a0: c2 00 e0 b0 ld [ %g3 + 0xb0 ], %g1 /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 400138a4: 05 10 00 d1 sethi %hi(0x40034400), %g2 400138a8: 82 00 60 01 inc %g1 400138ac: c8 20 a3 bc st %g4, [ %g2 + 0x3bc ] 400138b0: c2 20 e0 b0 st %g1, [ %g3 + 0xb0 ] _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 400138b4: 03 10 00 d1 sethi %hi(0x40034400), %g1 400138b8: da 20 63 b8 st %o5, [ %g1 + 0x3b8 ] ! 400347b8 <_Timer_Server_seconds_last_time> ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400138bc: 03 10 00 d2 sethi %hi(0x40034800), %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 400138c0: 27 10 00 d1 sethi %hi(0x40034400), %l3 400138c4: ba 10 61 ac or %g1, 0x1ac, %i5 400138c8: 82 14 e3 ac or %l3, 0x3ac, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 400138cc: ae 00 60 04 add %g1, 4, %l7 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400138d0: 03 10 00 d1 sethi %hi(0x40034400), %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 400138d4: 25 10 00 d1 sethi %hi(0x40034400), %l2 400138d8: a2 10 63 cc or %g1, 0x3cc, %l1 400138dc: 82 14 a3 c0 or %l2, 0x3c0, %g1 400138e0: a8 10 00 03 mov %g3, %l4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 400138e4: ac 00 60 04 add %g1, 4, %l6 /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 400138e8: 21 10 00 d4 sethi %hi(0x40035000), %l0 _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 400138ec: 03 10 00 d2 sethi %hi(0x40034800), %g1 400138f0: aa 10 61 a0 or %g1, 0x1a0, %l5 ! 400349a0 <_Watchdog_Seconds_chain> 400138f4: d0 04 23 38 ld [ %l0 + 0x338 ], %o0 400138f8: 40 00 10 38 call 400179d8 <_Thread_Set_state> 400138fc: 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)); 40013900: c2 04 e3 ac ld [ %l3 + 0x3ac ], %g1 _Timer_Server_reset_ticks_timer(); 40013904: 80 a0 40 17 cmp %g1, %l7 40013908: 22 80 00 09 be,a 4001392c <_Timer_Server_body+0xa4> 4001390c: c2 04 a3 c0 ld [ %l2 + 0x3c0 ], %g1 40013910: d2 04 23 38 ld [ %l0 + 0x338 ], %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40013914: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40013918: 90 10 00 1d mov %i5, %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4001391c: c2 22 60 54 st %g1, [ %o1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40013920: 40 00 12 e7 call 400184bc <_Watchdog_Insert> 40013924: 92 02 60 48 add %o1, 0x48, %o1 40013928: c2 04 a3 c0 ld [ %l2 + 0x3c0 ], %g1 _Timer_Server_reset_seconds_timer(); 4001392c: 80 a0 40 16 cmp %g1, %l6 40013930: 02 80 00 06 be 40013948 <_Timer_Server_body+0xc0> 40013934: 92 10 00 11 mov %l1, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40013938: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED 4001393c: c2 24 60 0c st %g1, [ %l1 + 0xc ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 40013940: 40 00 12 df call 400184bc <_Watchdog_Insert> <== NOT EXECUTED 40013944: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); 40013948: 7f ff ff c3 call 40013854 <_Thread_Enable_dispatch> 4001394c: 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(); 40013950: d0 04 23 38 ld [ %l0 + 0x338 ], %o0 40013954: 40 00 13 32 call 4001861c <_Watchdog_Remove> 40013958: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_stop_seconds_timer(); 4001395c: 40 00 13 30 call 4001861c <_Watchdog_Remove> 40013960: 90 10 00 11 mov %l1, %o0 40013964: c2 05 20 b0 ld [ %l4 + 0xb0 ], %g1 40013968: 82 00 60 01 inc %g1 4001396c: c2 25 20 b0 st %g1, [ %l4 + 0xb0 ] * 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(); 40013970: 7f ff ff a7 call 4001380c <_Timer_Server_process_ticks_chain> 40013974: 01 00 00 00 nop _Timer_Server_process_seconds_chain(); 40013978: 7f ff ff 8d call 400137ac <_Timer_Server_process_seconds_chain> 4001397c: 01 00 00 00 nop /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 40013980: 10 bf ff de b 400138f8 <_Timer_Server_body+0x70> 40013984: d0 04 23 38 ld [ %l0 + 0x338 ], %o0 4001380c <_Timer_Server_process_ticks_chain>: void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 4001380c: 03 10 00 d2 sethi %hi(0x40034800), %g1 40013810: c4 00 62 34 ld [ %g1 + 0x234 ], %g2 ! 40034a34 <_Watchdog_Ticks_since_boot> if ( snapshot >= _Timer_Server_ticks_last_time ) 40013814: 03 10 00 d1 sethi %hi(0x40034400), %g1 40013818: c2 00 63 bc ld [ %g1 + 0x3bc ], %g1 ! 400347bc <_Timer_Server_ticks_last_time> 4001381c: 80 a0 80 01 cmp %g2, %g1 40013820: 1a 80 00 04 bcc 40013830 <_Timer_Server_process_ticks_chain+0x24> 40013824: 94 20 80 01 sub %g2, %g1, %o2 ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 40013828: 82 38 00 01 xnor %g0, %g1, %g1 <== NOT EXECUTED 4001382c: 94 00 40 02 add %g1, %g2, %o2 <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; 40013830: 03 10 00 d1 sethi %hi(0x40034400), %g1 _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 40013834: 11 10 00 d1 sethi %hi(0x40034400), %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; 40013838: c4 20 63 bc st %g2, [ %g1 + 0x3bc ] _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 4001383c: 90 12 23 ac or %o0, 0x3ac, %o0 40013840: 92 10 20 00 clr %o1 40013844: 82 13 c0 00 mov %o7, %g1 40013848: 40 00 12 f5 call 4001841c <_Watchdog_Adjust> 4001384c: 9e 10 40 00 mov %g1, %o7 40013850: 01 00 00 00 nop 4000c7e4 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 4000c7e4: 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; 4000c7e8: 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; 4000c7ec: de 06 20 04 ld [ %i0 + 4 ], %o7 right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4000c7f0: 96 10 00 01 mov %g1, %o3 4000c7f4: 95 38 60 1f sra %g1, 0x1f, %o2 4000c7f8: 83 30 60 1d srl %g1, 0x1d, %g1 4000c7fc: 9b 2a e0 03 sll %o3, 3, %o5 4000c800: 99 2a a0 03 sll %o2, 3, %o4 4000c804: 98 10 40 0c or %g1, %o4, %o4 4000c808: 83 33 60 1b srl %o5, 0x1b, %g1 4000c80c: 85 2b 20 05 sll %o4, 5, %g2 4000c810: 87 2b 60 05 sll %o5, 5, %g3 4000c814: 84 10 40 02 or %g1, %g2, %g2 4000c818: 86 a0 c0 0d subcc %g3, %o5, %g3 4000c81c: 83 30 e0 1a srl %g3, 0x1a, %g1 4000c820: 84 60 80 0c subx %g2, %o4, %g2 4000c824: 9b 28 e0 06 sll %g3, 6, %o5 4000c828: 99 28 a0 06 sll %g2, 6, %o4 4000c82c: 9a a3 40 03 subcc %o5, %g3, %o5 4000c830: 98 10 40 0c or %g1, %o4, %o4 4000c834: 98 63 00 02 subx %o4, %g2, %o4 4000c838: 9a 83 40 0b addcc %o5, %o3, %o5 4000c83c: 83 33 60 1e srl %o5, 0x1e, %g1 4000c840: 98 43 00 0a addx %o4, %o2, %o4 4000c844: 87 2b 60 02 sll %o5, 2, %g3 4000c848: 85 2b 20 02 sll %o4, 2, %g2 4000c84c: 9a 83 40 03 addcc %o5, %g3, %o5 4000c850: 84 10 40 02 or %g1, %g2, %g2 4000c854: 83 33 60 1e srl %o5, 0x1e, %g1 4000c858: 98 43 00 02 addx %o4, %g2, %o4 4000c85c: 87 2b 60 02 sll %o5, 2, %g3 4000c860: 85 2b 20 02 sll %o4, 2, %g2 4000c864: 9a 83 40 03 addcc %o5, %g3, %o5 4000c868: 84 10 40 02 or %g1, %g2, %g2 4000c86c: 83 33 60 1e srl %o5, 0x1e, %g1 4000c870: 98 43 00 02 addx %o4, %g2, %o4 4000c874: 85 2b 20 02 sll %o4, 2, %g2 4000c878: 84 10 40 02 or %g1, %g2, %g2 right += rhs->tv_nsec; 4000c87c: 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; 4000c880: 87 2b 60 02 sll %o5, 2, %g3 4000c884: 9a 83 40 03 addcc %o5, %g3, %o5 right += rhs->tv_nsec; 4000c888: 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; 4000c88c: 98 43 00 02 addx %o4, %g2, %o4 4000c890: 89 33 60 17 srl %o5, 0x17, %g4 4000c894: 85 2b 20 09 sll %o4, 9, %g2 4000c898: 87 2b 60 09 sll %o5, 9, %g3 4000c89c: 84 11 00 02 or %g4, %g2, %g2 right += rhs->tv_nsec; 4000c8a0: 96 80 c0 01 addcc %g3, %g1, %o3 4000c8a4: 94 40 80 0a addx %g2, %o2, %o2 if ( right == 0 ) { 4000c8a8: 80 92 80 0b orcc %o2, %o3, %g0 4000c8ac: 12 80 00 06 bne 4000c8c4 <_Timespec_Divide+0xe0> 4000c8b0: f0 06 00 00 ld [ %i0 ], %i0 *ival_percentage = 0; 4000c8b4: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED *fval_percentage = 0; 4000c8b8: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 4000c8bc: 81 c7 e0 08 ret <== NOT EXECUTED 4000c8c0: 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; 4000c8c4: 83 36 20 1d srl %i0, 0x1d, %g1 4000c8c8: 9b 2e 20 03 sll %i0, 3, %o5 4000c8cc: 91 3e 20 1f sra %i0, 0x1f, %o0 4000c8d0: 99 2a 20 03 sll %o0, 3, %o4 4000c8d4: 98 10 40 0c or %g1, %o4, %o4 4000c8d8: 83 33 60 1b srl %o5, 0x1b, %g1 4000c8dc: 85 2b 20 05 sll %o4, 5, %g2 4000c8e0: 87 2b 60 05 sll %o5, 5, %g3 4000c8e4: 84 10 40 02 or %g1, %g2, %g2 4000c8e8: 86 a0 c0 0d subcc %g3, %o5, %g3 4000c8ec: 83 30 e0 1a srl %g3, 0x1a, %g1 4000c8f0: 84 60 80 0c subx %g2, %o4, %g2 4000c8f4: 9b 28 e0 06 sll %g3, 6, %o5 4000c8f8: 99 28 a0 06 sll %g2, 6, %o4 4000c8fc: 9a a3 40 03 subcc %o5, %g3, %o5 4000c900: 98 10 40 0c or %g1, %o4, %o4 4000c904: 98 63 00 02 subx %o4, %g2, %o4 4000c908: 9a 83 40 18 addcc %o5, %i0, %o5 4000c90c: 83 33 60 1e srl %o5, 0x1e, %g1 4000c910: 98 43 00 08 addx %o4, %o0, %o4 4000c914: 87 2b 60 02 sll %o5, 2, %g3 4000c918: 85 2b 20 02 sll %o4, 2, %g2 4000c91c: 9a 83 40 03 addcc %o5, %g3, %o5 4000c920: 84 10 40 02 or %g1, %g2, %g2 4000c924: 83 33 60 1e srl %o5, 0x1e, %g1 4000c928: 98 43 00 02 addx %o4, %g2, %o4 4000c92c: 87 2b 60 02 sll %o5, 2, %g3 4000c930: 85 2b 20 02 sll %o4, 2, %g2 4000c934: 9a 83 40 03 addcc %o5, %g3, %o5 4000c938: 84 10 40 02 or %g1, %g2, %g2 4000c93c: 83 33 60 1e srl %o5, 0x1e, %g1 4000c940: 98 43 00 02 addx %o4, %g2, %o4 4000c944: 87 2b 60 02 sll %o5, 2, %g3 4000c948: 85 2b 20 02 sll %o4, 2, %g2 4000c94c: 9a 83 40 03 addcc %o5, %g3, %o5 4000c950: 84 10 40 02 or %g1, %g2, %g2 4000c954: 83 33 60 17 srl %o5, 0x17, %g1 4000c958: 98 43 00 02 addx %o4, %g2, %o4 4000c95c: 93 2b 60 09 sll %o5, 9, %o1 4000c960: 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; 4000c964: 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; 4000c968: 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; 4000c96c: 83 32 60 1e srl %o1, 0x1e, %g1 4000c970: a1 3b e0 1f sra %o7, 0x1f, %l0 4000c974: 87 2a 60 02 sll %o1, 2, %g3 4000c978: 90 42 00 10 addx %o0, %l0, %o0 4000c97c: 85 2a 20 02 sll %o0, 2, %g2 4000c980: 84 10 40 02 or %g1, %g2, %g2 4000c984: 83 30 e0 1b srl %g3, 0x1b, %g1 4000c988: 99 28 a0 05 sll %g2, 5, %o4 4000c98c: 9b 28 e0 05 sll %g3, 5, %o5 4000c990: 98 10 40 0c or %g1, %o4, %o4 4000c994: 9a a3 40 03 subcc %o5, %g3, %o5 4000c998: 98 63 00 02 subx %o4, %g2, %o4 4000c99c: 9a 83 40 09 addcc %o5, %o1, %o5 4000c9a0: 83 33 60 1e srl %o5, 0x1e, %g1 4000c9a4: 98 43 00 08 addx %o4, %o0, %o4 4000c9a8: 87 2b 60 02 sll %o5, 2, %g3 4000c9ac: 85 2b 20 02 sll %o4, 2, %g2 4000c9b0: 9a 83 40 03 addcc %o5, %g3, %o5 4000c9b4: 84 10 40 02 or %g1, %g2, %g2 4000c9b8: 83 33 60 1e srl %o5, 0x1e, %g1 4000c9bc: 87 2b 60 02 sll %o5, 2, %g3 4000c9c0: 98 43 00 02 addx %o4, %g2, %o4 4000c9c4: 9a 83 40 03 addcc %o5, %g3, %o5 4000c9c8: 85 2b 20 02 sll %o4, 2, %g2 4000c9cc: 84 10 40 02 or %g1, %g2, %g2 4000c9d0: 83 33 60 1b srl %o5, 0x1b, %g1 4000c9d4: 98 43 00 02 addx %o4, %g2, %o4 4000c9d8: 93 2b 60 05 sll %o5, 5, %o1 4000c9dc: 91 2b 20 05 sll %o4, 5, %o0 4000c9e0: 40 00 35 10 call 40019e20 <__udivdi3> 4000c9e4: 90 10 40 08 or %g1, %o0, %o0 *ival_percentage = answer / 1000; 4000c9e8: 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; 4000c9ec: a0 10 00 08 mov %o0, %l0 4000c9f0: a2 10 00 09 mov %o1, %l1 *ival_percentage = answer / 1000; 4000c9f4: 96 10 23 e8 mov 0x3e8, %o3 4000c9f8: 40 00 35 0a call 40019e20 <__udivdi3> 4000c9fc: 90 10 00 10 mov %l0, %o0 *fval_percentage = answer % 1000; 4000ca00: 90 10 00 10 mov %l0, %o0 * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 4000ca04: d2 26 80 00 st %o1, [ %i2 ] *fval_percentage = answer % 1000; 4000ca08: 94 10 20 00 clr %o2 4000ca0c: 92 10 00 11 mov %l1, %o1 4000ca10: 40 00 35 e3 call 4001a19c <__umoddi3> 4000ca14: 96 10 23 e8 mov 0x3e8, %o3 4000ca18: d2 26 c0 00 st %o1, [ %i3 ] 4000ca1c: 81 c7 e0 08 ret 4000ca20: 81 e8 00 00 restore 4000aba8 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, boolean is_internal, uint32_t the_error ) { 4000aba8: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 4000abac: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000abb0: 82 10 60 54 or %g1, 0x54, %g1 ! 4001b054 <_User_extensions_List> 4000abb4: e0 00 60 08 ld [ %g1 + 8 ], %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 4000abb8: 10 80 00 09 b 4000abdc <_User_extensions_Fatal+0x34> 4000abbc: a2 10 00 01 mov %g1, %l1 !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 4000abc0: 80 a0 60 00 cmp %g1, 0 4000abc4: 02 80 00 05 be 4000abd8 <_User_extensions_Fatal+0x30> 4000abc8: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 4000abcc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000abd0: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000abd4: 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 ) { 4000abd8: 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 ) ; 4000abdc: 80 a4 00 11 cmp %l0, %l1 4000abe0: 32 bf ff f8 bne,a 4000abc0 <_User_extensions_Fatal+0x18> 4000abe4: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 4000abe8: 81 c7 e0 08 ret 4000abec: 81 e8 00 00 restore 4000f464 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 4000f464: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 4000f468: 40 00 13 1d call 400140dc <_Chain_Extract> <== NOT EXECUTED 4000f46c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 4000f470: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED 4000f474: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000f478: 02 80 00 04 be 4000f488 <_User_extensions_Remove_set+0x24> <== NOT EXECUTED 4000f47c: 01 00 00 00 nop <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 4000f480: 40 00 13 17 call 400140dc <_Chain_Extract> <== NOT EXECUTED 4000f484: 91 ee 20 08 restore %i0, 8, %o0 <== NOT EXECUTED 4000f488: 81 c7 e0 08 ret <== NOT EXECUTED 4000f48c: 81 e8 00 00 restore <== NOT EXECUTED 4000ac34 <_User_extensions_Thread_create>: */ boolean _User_extensions_Thread_create ( Thread_Control *the_thread ) { 4000ac34: 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 ; 4000ac38: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000ac3c: e0 00 60 54 ld [ %g1 + 0x54 ], %l0 ! 4001b054 <_User_extensions_List> the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { status = (*the_extension->Callouts.thread_create)( 4000ac40: 23 10 00 6b sethi %hi(0x4001ac00), %l1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4000ac44: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000ac48: 10 80 00 0d b 4000ac7c <_User_extensions_Thread_create+0x48> 4000ac4c: a4 10 60 58 or %g1, 0x58, %l2 ! 4001b058 <_User_extensions_List+0x4> !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 4000ac50: 80 a0 60 00 cmp %g1, 0 4000ac54: 02 80 00 09 be 4000ac78 <_User_extensions_Thread_create+0x44> 4000ac58: 92 10 00 18 mov %i0, %o1 status = (*the_extension->Callouts.thread_create)( 4000ac5c: 9f c0 40 00 call %g1 4000ac60: d0 04 62 ac ld [ %l1 + 0x2ac ], %o0 _Thread_Executing, the_thread ); if ( !status ) 4000ac64: 80 a2 20 00 cmp %o0, 0 4000ac68: 32 80 00 05 bne,a 4000ac7c <_User_extensions_Thread_create+0x48> 4000ac6c: e0 04 00 00 ld [ %l0 ], %l0 4000ac70: 81 c7 e0 08 ret <== NOT EXECUTED 4000ac74: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 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 ) { 4000ac78: 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 ) ; 4000ac7c: 80 a4 00 12 cmp %l0, %l2 4000ac80: 32 bf ff f4 bne,a 4000ac50 <_User_extensions_Thread_create+0x1c> 4000ac84: c2 04 20 14 ld [ %l0 + 0x14 ], %g1 return FALSE; } } return TRUE; } 4000ac88: 81 c7 e0 08 ret 4000ac8c: 91 e8 20 01 restore %g0, 1, %o0 4000ad60 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 4000ad60: 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; 4000ad64: 03 10 00 6b sethi %hi(0x4001ac00), %g1 void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 4000ad68: aa 10 00 18 mov %i0, %l5 Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 4000ad6c: e6 00 62 94 ld [ %g1 + 0x294 ], %l3 _ISR_Disable( level ); 4000ad70: 7f ff dc 57 call 40001ecc 4000ad74: 01 00 00 00 nop 4000ad78: 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 ) { 4000ad7c: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000ad80: 80 a0 60 00 cmp %g1, 0 4000ad84: 02 80 00 03 be 4000ad90 <_Watchdog_Insert+0x30> 4000ad88: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _ISR_Enable( level ); 4000ad8c: 30 80 00 37 b,a 4000ae68 <_Watchdog_Insert+0x108> <== NOT EXECUTED return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 4000ad90: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 4001af50 <_Watchdog_Sync_count> if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 4000ad94: 86 10 20 01 mov 1, %g3 _Watchdog_Sync_count++; 4000ad98: 84 00 a0 01 inc %g2 if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 4000ad9c: c6 26 60 08 st %g3, [ %i1 + 8 ] _Watchdog_Sync_count++; 4000ada0: c4 20 63 50 st %g2, [ %g1 + 0x350 ] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 4000ada4: 29 10 00 6b sethi %hi(0x4001ac00), %l4 the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 4000ada8: 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 ; 4000adac: e2 05 40 00 ld [ %l5 ], %l1 ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 4000adb0: 80 a4 a0 00 cmp %l2, 0 4000adb4: 22 80 00 1c be,a 4000ae24 <_Watchdog_Insert+0xc4> 4000adb8: c4 04 60 04 ld [ %l1 + 4 ], %g2 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 4000adbc: c2 04 40 00 ld [ %l1 ], %g1 4000adc0: 80 a0 60 00 cmp %g1, 0 4000adc4: 22 80 00 18 be,a 4000ae24 <_Watchdog_Insert+0xc4> 4000adc8: c4 04 60 04 ld [ %l1 + 4 ], %g2 break; if ( delta_interval < after->delta_interval ) { 4000adcc: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 4000add0: 80 a4 80 10 cmp %l2, %l0 4000add4: 1a 80 00 04 bcc 4000ade4 <_Watchdog_Insert+0x84> 4000add8: 82 24 00 12 sub %l0, %l2, %g1 after->delta_interval -= delta_interval; 4000addc: 10 80 00 11 b 4000ae20 <_Watchdog_Insert+0xc0> 4000ade0: c2 24 60 10 st %g1, [ %l1 + 0x10 ] * 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 ); 4000ade4: 7f ff dc 3e call 40001edc 4000ade8: 90 10 00 18 mov %i0, %o0 4000adec: 7f ff dc 38 call 40001ecc 4000adf0: 01 00 00 00 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 4000adf4: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000adf8: 80 a0 60 01 cmp %g1, 1 4000adfc: 12 80 00 15 bne 4000ae50 <_Watchdog_Insert+0xf0> 4000ae00: a4 24 80 10 sub %l2, %l0, %l2 goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 4000ae04: c2 05 22 a8 ld [ %l4 + 0x2a8 ], %g1 4000ae08: 80 a0 40 13 cmp %g1, %l3 4000ae0c: 28 bf ff e9 bleu,a 4000adb0 <_Watchdog_Insert+0x50> 4000ae10: e2 04 40 00 ld [ %l1 ], %l1 _Watchdog_Sync_level = insert_isr_nest_level; 4000ae14: e6 25 22 a8 st %l3, [ %l4 + 0x2a8 ] the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 4000ae18: 10 bf ff e5 b 4000adac <_Watchdog_Insert+0x4c> 4000ae1c: e4 06 60 0c ld [ %i1 + 0xc ], %l2 _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 4000ae20: c4 04 60 04 ld [ %l1 + 4 ], %g2 the_watchdog->start_time = _Watchdog_Ticks_since_boot; 4000ae24: 03 10 00 6b sethi %hi(0x4001ac00), %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 4000ae28: c6 00 80 00 ld [ %g2 ], %g3 4000ae2c: c2 00 63 54 ld [ %g1 + 0x354 ], %g1 after_node->next = the_node; 4000ae30: f2 20 80 00 st %i1, [ %g2 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 4000ae34: c4 26 60 04 st %g2, [ %i1 + 4 ] 4000ae38: c2 26 60 14 st %g1, [ %i1 + 0x14 ] } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 4000ae3c: e4 26 60 10 st %l2, [ %i1 + 0x10 ] RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 4000ae40: 82 10 20 02 mov 2, %g1 before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; before_node->previous = the_node; 4000ae44: f2 20 e0 04 st %i1, [ %g3 + 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; 4000ae48: c6 26 40 00 st %g3, [ %i1 ] 4000ae4c: c2 26 60 08 st %g1, [ %i1 + 8 ] _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; 4000ae50: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _Watchdog_Sync_count--; 4000ae54: 05 10 00 6b sethi %hi(0x4001ac00), %g2 _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; 4000ae58: e6 20 62 a8 st %l3, [ %g1 + 0x2a8 ] _Watchdog_Sync_count--; 4000ae5c: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 4000ae60: 82 00 7f ff add %g1, -1, %g1 4000ae64: c2 20 a3 50 st %g1, [ %g2 + 0x350 ] _ISR_Enable( level ); 4000ae68: 7f ff dc 1d call 40001edc 4000ae6c: 81 e8 00 00 restore 4000ae70: 01 00 00 00 nop 4000bda0 <_Watchdog_Insert_ticks_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 4000bda0: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; (void) _Watchdog_Remove( timer ); 4000bda4: 40 00 16 f3 call 40011970 <_Watchdog_Remove> 4000bda8: 90 10 00 18 mov %i0, %o0 _ISR_Disable( level ); 4000bdac: 7f ff ea 92 call 400067f4 4000bdb0: 01 00 00 00 nop 4000bdb4: 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 ) { 4000bdb8: c2 06 20 08 ld [ %i0 + 8 ], %g1 4000bdbc: 80 a0 60 00 cmp %g1, 0 4000bdc0: 22 80 00 06 be,a 4000bdd8 <_Watchdog_Insert_ticks_helper+0x38> 4000bdc4: f6 26 20 1c st %i3, [ %i0 + 0x1c ] _ISR_Enable( level ); 4000bdc8: 7f ff ea 8f call 40006804 <== NOT EXECUTED 4000bdcc: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000bdd0: 81 c7 e0 08 ret <== NOT EXECUTED 4000bdd4: 81 e8 00 00 restore <== NOT EXECUTED void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 4000bdd8: f4 26 20 20 st %i2, [ %i0 + 0x20 ] the_watchdog->user_data = user_data; 4000bddc: f8 26 20 24 st %i4, [ %i0 + 0x24 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000bde0: f2 26 20 0c st %i1, [ %i0 + 0xc ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4000bde4: c0 26 20 08 clr [ %i0 + 8 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4000bde8: 92 10 00 18 mov %i0, %o1 4000bdec: 11 10 00 97 sethi %hi(0x40025c00), %o0 4000bdf0: 40 00 16 88 call 40011810 <_Watchdog_Insert> 4000bdf4: 90 12 21 3c or %o0, 0x13c, %o0 ! 40025d3c <_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 ); 4000bdf8: b0 10 20 01 mov 1, %i0 4000bdfc: 7f ff ea 82 call 40006804 4000be00: 90 10 00 10 mov %l0, %o0 return TRUE; } 4000be04: 81 c7 e0 08 ret 4000be08: 81 e8 00 00 restore 4000aec0 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 4000aec0: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 4000aec4: 7f ff dc 02 call 40001ecc 4000aec8: 01 00 00 00 nop previous_state = the_watchdog->state; 4000aecc: e0 06 20 08 ld [ %i0 + 8 ], %l0 switch ( previous_state ) { 4000aed0: 80 a4 20 01 cmp %l0, 1 4000aed4: 22 80 00 1e be,a 4000af4c <_Watchdog_Remove+0x8c> 4000aed8: c0 26 20 08 clr [ %i0 + 8 ] <== NOT EXECUTED 4000aedc: 0a 80 00 1d bcs 4000af50 <_Watchdog_Remove+0x90> 4000aee0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000aee4: 80 a4 20 03 cmp %l0, 3 4000aee8: 18 80 00 1a bgu 4000af50 <_Watchdog_Remove+0x90> 4000aeec: 01 00 00 00 nop 4000aef0: c6 06 00 00 ld [ %i0 ], %g3 break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 4000aef4: c0 26 20 08 clr [ %i0 + 8 ] next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 4000aef8: c2 00 c0 00 ld [ %g3 ], %g1 4000aefc: 80 a0 60 00 cmp %g1, 0 4000af00: 02 80 00 07 be 4000af1c <_Watchdog_Remove+0x5c> 4000af04: 03 10 00 6b sethi %hi(0x4001ac00), %g1 next_watchdog->delta_interval += the_watchdog->delta_interval; 4000af08: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1 4000af0c: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 4000af10: 82 00 40 02 add %g1, %g2, %g1 4000af14: c2 20 e0 10 st %g1, [ %g3 + 0x10 ] if ( _Watchdog_Sync_count ) 4000af18: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000af1c: c2 00 63 50 ld [ %g1 + 0x350 ], %g1 ! 4001af50 <_Watchdog_Sync_count> 4000af20: 80 a0 60 00 cmp %g1, 0 4000af24: 22 80 00 07 be,a 4000af40 <_Watchdog_Remove+0x80> 4000af28: c4 06 00 00 ld [ %i0 ], %g2 _Watchdog_Sync_level = _ISR_Nest_level; 4000af2c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000af30: c4 00 62 94 ld [ %g1 + 0x294 ], %g2 ! 4001ae94 <_ISR_Nest_level> <== NOT EXECUTED 4000af34: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000af38: c4 20 62 a8 st %g2, [ %g1 + 0x2a8 ] ! 4001aea8 <_Watchdog_Sync_level> <== NOT EXECUTED ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 4000af3c: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED previous = the_node->previous; 4000af40: c2 06 20 04 ld [ %i0 + 4 ], %g1 next->previous = previous; previous->next = next; 4000af44: c4 20 40 00 st %g2, [ %g1 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000af48: c2 20 a0 04 st %g1, [ %g2 + 4 ] _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 4000af4c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000af50: c2 00 63 54 ld [ %g1 + 0x354 ], %g1 ! 4001af54 <_Watchdog_Ticks_since_boot> 4000af54: c2 26 20 18 st %g1, [ %i0 + 0x18 ] _ISR_Enable( level ); 4000af58: 7f ff db e1 call 40001edc 4000af5c: b0 10 00 10 mov %l0, %i0 return( previous_state ); } 4000af60: 81 c7 e0 08 ret 4000af64: 81 e8 00 00 restore 4000b00c <_Workspace_Allocate_or_fatal_error>: */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 4000b00c: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 4000b010: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000b014: 92 10 00 18 mov %i0, %o1 4000b018: 7f ff f2 e5 call 40007bac <_Heap_Allocate> 4000b01c: 90 12 22 1c or %o0, 0x21c, %o0 void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 4000b020: b0 92 20 00 orcc %o0, 0, %i0 4000b024: 12 80 00 04 bne 4000b034 <_Workspace_Allocate_or_fatal_error+0x28> 4000b028: 92 10 20 01 mov 1, %o1 _Internal_error_Occurred( 4000b02c: 7f ff f4 0b call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 4000b030: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 4000b034: 81 c7 e0 08 ret 4000b038: 81 e8 00 00 restore 4000b03c <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 4000b03c: 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 ) ) 4000b040: 80 a6 20 00 cmp %i0, 0 4000b044: 02 80 00 04 be 4000b054 <_Workspace_Handler_initialization+0x18> 4000b048: 80 8e 20 07 btst 7, %i0 4000b04c: 02 80 00 07 be 4000b068 <_Workspace_Handler_initialization+0x2c> 4000b050: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _Internal_error_Occurred( 4000b054: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000b058: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 4000b05c: 7f ff f3 ff call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 4000b060: 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 ) { 4000b064: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000b068: c2 00 61 f4 ld [ %g1 + 0x1f4 ], %g1 ! 4001adf4 <_CPU_Table+0x10> 4000b06c: 84 10 20 00 clr %g2 4000b070: 80 a0 60 00 cmp %g1, 0 4000b074: 12 80 00 06 bne 4000b08c <_Workspace_Handler_initialization+0x50> 4000b078: 87 36 60 02 srl %i1, 2, %g3 index < size / sizeof( uint32_t ) ; index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 4000b07c: 10 80 00 08 b 4000b09c <_Workspace_Handler_initialization+0x60> 4000b080: 92 10 00 18 mov %i0, %o1 ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; index++ ) 4000b084: 84 00 a0 01 inc %g2 <== NOT EXECUTED zero_out_array[ index ] = 0; 4000b088: c0 20 40 18 clr [ %g1 + %i0 ] <== 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 ) ; 4000b08c: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED 4000b090: 0a bf ff fd bcs 4000b084 <_Workspace_Handler_initialization+0x48> <== NOT EXECUTED 4000b094: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 4000b098: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000b09c: 94 10 00 19 mov %i1, %o2 4000b0a0: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000b0a4: 96 10 20 08 mov 8, %o3 4000b0a8: 7f ff f3 a2 call 40007f30 <_Heap_Initialize> 4000b0ac: 90 12 22 1c or %o0, 0x21c, %o0 starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 4000b0b0: 80 a2 20 00 cmp %o0, 0 4000b0b4: 12 80 00 05 bne 4000b0c8 <_Workspace_Handler_initialization+0x8c> 4000b0b8: b0 10 20 00 clr %i0 _Internal_error_Occurred( 4000b0bc: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED 4000b0c0: 7f ff f3 e6 call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 4000b0c4: 95 e8 20 03 restore %g0, 3, %o2 <== NOT EXECUTED 4000b0c8: 81 c7 e0 08 ret 4000b0cc: 81 e8 00 00 restore 40023088 <_kill_r>: struct _reent *ptr, pid_t pid, int sig ) { return kill( pid, sig ); 40023088: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 4002308c: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 40023090: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40023094: 7f ff ff f8 call 40023074 <== NOT EXECUTED 40023098: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 4002309c: 01 00 00 00 nop 40006c14 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 40006c14: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 40006c18: 90 96 60 00 orcc %i1, 0, %o0 40006c1c: 12 80 00 08 bne 40006c3c 40006c20: 80 a6 20 02 cmp %i0, 2 rtems_set_errno_and_return_minus_one( EINVAL ); 40006c24: 40 00 27 5d call 40010998 <__errno> <== NOT EXECUTED 40006c28: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40006c2c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 40006c30: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40006c34: 81 c7 e0 08 ret <== NOT EXECUTED 40006c38: 81 e8 00 00 restore <== NOT EXECUTED switch ( clock_id ) { 40006c3c: 02 80 00 10 be 40006c7c 40006c40: 80 a6 20 02 cmp %i0, 2 40006c44: 18 80 00 06 bgu 40006c5c 40006c48: 80 a6 20 03 cmp %i0, 3 40006c4c: 80 a6 20 01 cmp %i0, 1 40006c50: 12 80 00 11 bne 40006c94 40006c54: 01 00 00 00 nop 40006c58: 30 80 00 06 b,a 40006c70 40006c5c: 02 80 00 0c be 40006c8c <== NOT EXECUTED 40006c60: 80 a6 20 04 cmp %i0, 4 <== NOT EXECUTED 40006c64: 12 80 00 0c bne 40006c94 <== NOT EXECUTED 40006c68: 01 00 00 00 nop <== NOT EXECUTED 40006c6c: 30 80 00 04 b,a 40006c7c <== NOT EXECUTED case CLOCK_REALTIME: _TOD_Get(tp); 40006c70: 40 00 0a b8 call 40009750 <_TOD_Get> 40006c74: b0 10 20 00 clr %i0 40006c78: 30 80 00 0b b,a 40006ca4 break; #endif #ifdef _POSIX_CPUTIME case CLOCK_PROCESS_CPUTIME: _TOD_Get_uptime(tp); 40006c7c: 40 00 0a ce call 400097b4 <_TOD_Get_uptime> <== NOT EXECUTED 40006c80: b0 10 20 00 clr %i0 <== NOT EXECUTED 40006c84: 81 c7 e0 08 ret <== NOT EXECUTED 40006c88: 81 e8 00 00 restore <== NOT EXECUTED break; #endif #ifdef _POSIX_THREAD_CPUTIME case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); 40006c8c: 40 00 02 fb call 40007878 <== NOT EXECUTED 40006c90: 81 e8 00 00 restore <== NOT EXECUTED break; #endif default: rtems_set_errno_and_return_minus_one( EINVAL ); 40006c94: 40 00 27 41 call 40010998 <__errno> <== NOT EXECUTED 40006c98: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40006c9c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 40006ca0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return 0; } 40006ca4: 81 c7 e0 08 ret 40006ca8: 81 e8 00 00 restore 40006cac : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 40006cac: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 40006cb0: 90 96 60 00 orcc %i1, 0, %o0 40006cb4: 02 80 00 0d be 40006ce8 40006cb8: 80 a6 20 02 cmp %i0, 2 rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 40006cbc: 02 80 00 22 be 40006d44 40006cc0: 80 a6 20 03 cmp %i0, 3 40006cc4: 02 80 00 20 be 40006d44 40006cc8: 80 a6 20 01 cmp %i0, 1 40006ccc: 12 80 00 20 bne 40006d4c 40006cd0: 03 08 76 b9 sethi %hi(0x21dae400), %g1 case CLOCK_REALTIME: if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 40006cd4: c4 02 00 00 ld [ %o0 ], %g2 40006cd8: 82 10 60 ff or %g1, 0xff, %g1 40006cdc: 80 a0 80 01 cmp %g2, %g1 40006ce0: 18 80 00 08 bgu 40006d00 40006ce4: 21 10 00 7a sethi %hi(0x4001e800), %l0 rtems_set_errno_and_return_minus_one( EINVAL ); 40006ce8: 40 00 27 2c call 40010998 <__errno> <== NOT EXECUTED 40006cec: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40006cf0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 40006cf4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40006cf8: 81 c7 e0 08 ret <== NOT EXECUTED 40006cfc: 81 e8 00 00 restore <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006d00: c2 04 22 f0 ld [ %l0 + 0x2f0 ], %g1 40006d04: 82 00 60 01 inc %g1 40006d08: c2 24 22 f0 st %g1, [ %l0 + 0x2f0 ] _Thread_Disable_dispatch(); _TOD_Set( tp ); 40006d0c: 40 00 0a da call 40009874 <_TOD_Set> 40006d10: 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 ) 40006d14: c2 04 22 f0 ld [ %l0 + 0x2f0 ], %g1 40006d18: b0 10 20 00 clr %i0 40006d1c: 82 00 7f ff add %g1, -1, %g1 40006d20: c2 24 22 f0 st %g1, [ %l0 + 0x2f0 ] 40006d24: c2 04 22 f0 ld [ %l0 + 0x2f0 ], %g1 40006d28: 80 a0 60 00 cmp %g1, 0 40006d2c: 12 80 00 0c bne 40006d5c 40006d30: 01 00 00 00 nop _Thread_Dispatch(); 40006d34: 40 00 12 69 call 4000b6d8 <_Thread_Dispatch> 40006d38: 01 00 00 00 nop 40006d3c: 81 c7 e0 08 ret 40006d40: 81 e8 00 00 restore break; #endif #ifdef _POSIX_THREAD_CPUTIME case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); 40006d44: 40 00 02 cd call 40007878 <== NOT EXECUTED 40006d48: 81 e8 00 00 restore <== NOT EXECUTED break; #endif default: rtems_set_errno_and_return_minus_one( EINVAL ); 40006d4c: 40 00 27 13 call 40010998 <__errno> 40006d50: b0 10 3f ff mov -1, %i0 40006d54: 82 10 20 16 mov 0x16, %g1 40006d58: c2 22 00 00 st %g1, [ %o0 ] } return 0; } 40006d5c: 81 c7 e0 08 ret 40006d60: 81 e8 00 00 restore 400231ac : int killinfo( pid_t pid, int sig, const union sigval *value ) { 400231ac: 9d e3 bf 88 save %sp, -120, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 400231b0: 7f ff ff 15 call 40022e04 400231b4: 01 00 00 00 nop 400231b8: 80 a6 00 08 cmp %i0, %o0 400231bc: 02 80 00 06 be 400231d4 400231c0: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 400231c4: 7f ff d1 49 call 400176e8 <__errno> 400231c8: 01 00 00 00 nop 400231cc: 10 80 00 07 b 400231e8 400231d0: 82 10 20 03 mov 3, %g1 ! 3 /* * Validate the signal passed. */ if ( !sig ) 400231d4: 12 80 00 08 bne 400231f4 400231d8: 82 06 7f ff add %i1, -1, %g1 rtems_set_errno_and_return_minus_one( EINVAL ); 400231dc: 7f ff d1 43 call 400176e8 <__errno> 400231e0: 01 00 00 00 nop 400231e4: 82 10 20 16 mov 0x16, %g1 ! 16 400231e8: c2 22 00 00 st %g1, [ %o0 ] 400231ec: 10 80 00 bc b 400234dc 400231f0: 90 10 3f ff mov -1, %o0 if ( !is_valid_signo(sig) ) 400231f4: 80 a0 60 1f cmp %g1, 0x1f 400231f8: 18 bf ff f9 bgu 400231dc 400231fc: 83 2e 60 02 sll %i1, 2, %g1 /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 40023200: 85 2e 60 04 sll %i1, 4, %g2 40023204: 84 20 80 01 sub %g2, %g1, %g2 40023208: 03 10 00 a8 sethi %hi(0x4002a000), %g1 4002320c: 82 10 63 78 or %g1, 0x378, %g1 ! 4002a378 <_POSIX_signals_Vectors> 40023210: 84 00 80 01 add %g2, %g1, %g2 40023214: c2 00 a0 08 ld [ %g2 + 8 ], %g1 40023218: 80 a0 60 01 cmp %g1, 1 4002321c: 02 80 00 b0 be 400234dc 40023220: 90 10 20 00 clr %o0 * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ switch ( sig ) { 40023224: 80 a6 60 0b cmp %i1, 0xb 40023228: 18 80 00 0d bgu 4002325c 4002322c: 84 10 20 01 mov 1, %g2 40023230: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40023234: 83 28 40 19 sll %g1, %i1, %g1 <== NOT EXECUTED 40023238: 80 88 69 10 btst 0x910, %g1 <== NOT EXECUTED 4002323c: 22 80 00 09 be,a 40023260 <== NOT EXECUTED 40023240: f2 27 bf ec st %i1, [ %fp + -20 ] <== NOT EXECUTED case SIGFPE: case SIGILL: case SIGSEGV: return pthread_kill( pthread_self(), sig ); 40023244: 40 00 01 4c call 40023774 <== NOT EXECUTED 40023248: 01 00 00 00 nop <== NOT EXECUTED 4002324c: 40 00 01 09 call 40023670 <== NOT EXECUTED 40023250: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); return 0; } 40023254: 81 c7 e0 08 ret <== NOT EXECUTED 40023258: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 4002325c: f2 27 bf ec st %i1, [ %fp + -20 ] siginfo->si_code = SI_USER; 40023260: c4 27 bf f0 st %g2, [ %fp + -16 ] return pthread_kill( pthread_self(), sig ); default: break; } mask = signo_to_mask( sig ); 40023264: 82 06 7f ff add %i1, -1, %g1 */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { 40023268: 80 a6 a0 00 cmp %i2, 0 4002326c: 12 80 00 04 bne 4002327c 40023270: b1 28 80 01 sll %g2, %g1, %i0 siginfo->si_value.sival_int = 0; 40023274: 10 80 00 04 b 40023284 40023278: c0 27 bf f4 clr [ %fp + -12 ] } else { siginfo->si_value = *value; 4002327c: c2 06 80 00 ld [ %i2 ], %g1 40023280: c2 27 bf f4 st %g1, [ %fp + -12 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40023284: 05 10 00 a7 sethi %hi(0x40029c00), %g2 40023288: c2 00 a0 60 ld [ %g2 + 0x60 ], %g1 ! 40029c60 <_Thread_Dispatch_disable_level> 4002328c: 82 00 60 01 inc %g1 40023290: c2 20 a0 60 st %g1, [ %g2 + 0x60 ] /* * 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; 40023294: 03 10 00 a7 sethi %hi(0x40029c00), %g1 40023298: c4 00 61 3c ld [ %g1 + 0x13c ], %g2 ! 40029d3c <_Thread_Executing> api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 4002329c: c2 00 a1 70 ld [ %g2 + 0x170 ], %g1 400232a0: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 400232a4: 80 ae 00 01 andncc %i0, %g1, %g0 400232a8: 12 80 00 65 bne 4002343c 400232ac: 03 10 00 a9 sethi %hi(0x4002a400), %g1 goto process_it; 400232b0: 88 10 61 04 or %g1, 0x104, %g4 ! 4002a504 <_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 ; 400232b4: 98 01 20 30 add %g4, 0x30, %o4 index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; 400232b8: c2 01 00 00 ld [ %g4 ], %g1 !_Chain_Is_tail( the_chain, the_node ) ; 400232bc: 10 80 00 0b b 400232e8 400232c0: 9a 01 20 04 add %g4, 4, %o5 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)) { 400232c4: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 400232c8: 80 8e 00 01 btst %i0, %g1 400232cc: 12 80 00 5c bne 4002343c 400232d0: c6 00 a1 70 ld [ %g2 + 0x170 ], %g3 400232d4: c2 00 e0 c4 ld [ %g3 + 0xc4 ], %g1 <== NOT EXECUTED 400232d8: 80 ae 00 01 andncc %i0, %g1, %g0 <== NOT EXECUTED 400232dc: 12 80 00 59 bne 40023440 <== NOT EXECUTED 400232e0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 400232e4: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 400232e8: 80 a0 40 0d cmp %g1, %o5 400232ec: 12 bf ff f6 bne 400232c4 400232f0: 84 10 00 01 mov %g1, %g2 400232f4: 88 01 20 0c add %g4, 0xc, %g4 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 400232f8: 80 a1 00 0c cmp %g4, %o4 400232fc: 32 bf ff f0 bne,a 400232bc 40023300: c2 01 00 00 ld [ %g4 ], %g1 the_api++ ) { if ( the_api == OBJECTS_INTERNAL_THREADS ) continue; if ( !_Objects_Information_table[ the_api ] ) /* API not installed */ 40023304: 03 10 00 a6 sethi %hi(0x40029800), %g1 40023308: ae 10 63 c0 or %g1, 0x3c0, %l7 ! 40029bc0 <_Objects_Information_table> continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 4002330c: 03 10 00 9d sethi %hi(0x40027400), %g1 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 40023310: a4 10 21 00 mov 0x100, %l2 continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 40023314: ac 10 61 b0 or %g1, 0x1b0, %l6 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 40023318: a0 10 20 00 clr %l0 continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 4002331c: 03 10 00 9d sethi %hi(0x40027400), %g1 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 40023320: b4 10 20 02 mov 2, %i2 continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 40023324: aa 10 61 f8 or %g1, 0x1f8, %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 ) 40023328: 10 80 00 04 b 40023338 4002332c: 29 04 00 00 sethi %hi(0x10000000), %l4 for ( the_api = 2; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( the_api == OBJECTS_INTERNAL_THREADS ) 40023330: 22 80 00 3d be,a 40023424 40023334: b4 06 a0 01 inc %i2 <== NOT EXECUTED continue; if ( !_Objects_Information_table[ the_api ] ) /* API not installed */ 40023338: 83 2e a0 02 sll %i2, 2, %g1 4002333c: c2 05 c0 01 ld [ %l7 + %g1 ], %g1 40023340: 80 a0 60 00 cmp %g1, 0 40023344: 22 80 00 38 be,a 40023424 40023348: b4 06 a0 01 inc %i2 continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 4002334c: c2 00 60 04 ld [ %g1 + 4 ], %g1 if ( !the_info ) /* manager not installed */ 40023350: 80 a0 60 00 cmp %g1, 0 40023354: 22 80 00 34 be,a 40023424 40023358: b4 06 a0 01 inc %i2 <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; 4002335c: e2 00 60 20 ld [ %g1 + 0x20 ], %l1 assert( object_table ); /* always at least 1 entry */ 40023360: 80 a4 60 00 cmp %l1, 0 40023364: 12 80 00 06 bne 4002337c 40023368: e6 10 60 10 lduh [ %g1 + 0x10 ], %l3 4002336c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED 40023370: 92 10 20 c1 mov 0xc1, %o1 <== NOT EXECUTED 40023374: 7f ff 8e a4 call 40006e04 <__assert> <== NOT EXECUTED 40023378: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED 4002337c: 10 80 00 26 b 40023414 40023380: 9a 10 20 01 mov 1, %o5 for ( index = 1 ; index <= maximum ; index++ ) { the_thread = (Thread_Control *) object_table[ index ]; 40023384: c4 00 40 11 ld [ %g1 + %l1 ], %g2 if ( !the_thread ) 40023388: 80 a0 a0 00 cmp %g2, 0 4002338c: 22 80 00 22 be,a 40023414 40023390: 9a 03 60 01 inc %o5 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 40023394: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4 40023398: 80 a1 00 12 cmp %g4, %l2 4002339c: 38 80 00 1e bgu,a 40023414 400233a0: 9a 03 60 01 inc %o5 <== NOT EXECUTED /* * If this thread is not interested, then go on to the next thread. */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 400233a4: c2 00 a1 70 ld [ %g2 + 0x170 ], %g1 if ( !api || !_POSIX_signals_Is_interested( api, mask ) ) 400233a8: 80 a0 60 00 cmp %g1, 0 400233ac: 22 80 00 1a be,a 40023414 400233b0: 9a 03 60 01 inc %o5 <== NOT EXECUTED 400233b4: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 400233b8: 80 ae 00 01 andncc %i0, %g1, %g0 400233bc: 22 80 00 16 be,a 40023414 400233c0: 9a 03 60 01 inc %o5 * Now we know the thread under connsideration is interested. * If the thread under consideration is of higher priority, then * it becomes the interested thread. */ if ( the_thread->current_priority < interested_priority ) { 400233c4: 80 a1 00 12 cmp %g4, %l2 400233c8: 2a 80 00 11 bcs,a 4002340c 400233cc: a0 10 00 02 mov %g2, %l0 * 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 ) ) 400233d0: c6 04 20 10 ld [ %l0 + 0x10 ], %g3 <== NOT EXECUTED 400233d4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 400233d8: 22 80 00 0f be,a 40023414 <== NOT EXECUTED 400233dc: 9a 03 60 01 inc %o5 <== NOT EXECUTED * Now the interested thread is blocked. * If the thread we are considering is not, the it becomes the * interested thread. */ if ( _States_Is_ready( the_thread->current_state ) ) { 400233e0: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 <== NOT EXECUTED 400233e4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400233e8: 22 80 00 09 be,a 4002340c <== NOT EXECUTED 400233ec: a0 10 00 02 mov %g2, %l0 <== 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 ) 400233f0: 80 88 c0 14 btst %g3, %l4 <== NOT EXECUTED 400233f4: 32 80 00 08 bne,a 40023414 <== NOT EXECUTED 400233f8: 9a 03 60 01 inc %o5 <== NOT EXECUTED * If the thread under consideration is interruptible by a signal, * then it becomes the interested thread. */ /* XXX need a new states macro */ if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 400233fc: 80 88 40 14 btst %g1, %l4 <== NOT EXECUTED 40023400: 22 80 00 05 be,a 40023414 <== NOT EXECUTED 40023404: 9a 03 60 01 inc %o5 <== NOT EXECUTED 40023408: a0 10 00 02 mov %g2, %l0 <== NOT EXECUTED 4002340c: a4 10 00 04 mov %g4, %l2 maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ for ( index = 1 ; index <= maximum ; index++ ) { 40023410: 9a 03 60 01 inc %o5 40023414: 80 a3 40 13 cmp %o5, %l3 40023418: 08 bf ff db bleu 40023384 4002341c: 83 2b 60 02 sll %o5, 2, %g1 interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = 2; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 40023420: b4 06 a0 01 inc %i2 interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = 2; the_api <= OBJECTS_APIS_LAST; 40023424: 80 a6 a0 04 cmp %i2, 4 40023428: 08 bf ff c2 bleu 40023330 4002342c: 80 a6 a0 01 cmp %i2, 1 interested_priority = the_thread->current_priority; } } } if ( interested_thread ) { 40023430: 80 a4 20 00 cmp %l0, 0 40023434: 02 80 00 0b be 40023460 40023438: 84 10 00 10 mov %l0, %g2 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 4002343c: 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 ) ) { 40023440: 90 10 00 02 mov %g2, %o0 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 40023444: c2 20 a0 78 st %g1, [ %g2 + 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 ) ) { 40023448: 92 10 00 19 mov %i1, %o1 4002344c: 40 00 00 37 call 40023528 <_POSIX_signals_Unblock_thread> 40023450: 94 07 bf ec add %fp, -20, %o2 40023454: 80 a2 20 00 cmp %o0, 0 40023458: 12 80 00 1e bne 400234d0 4002345c: 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 ); 40023460: 40 00 00 22 call 400234e8 <_POSIX_signals_Set_process_signals> 40023464: 90 10 00 18 mov %i0, %o0 if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 40023468: 83 2e 60 02 sll %i1, 2, %g1 4002346c: 85 2e 60 04 sll %i1, 4, %g2 40023470: b2 20 80 01 sub %g2, %g1, %i1 40023474: 03 10 00 a8 sethi %hi(0x4002a000), %g1 40023478: 82 10 63 78 or %g1, 0x378, %g1 ! 4002a378 <_POSIX_signals_Vectors> 4002347c: c2 00 40 19 ld [ %g1 + %i1 ], %g1 40023480: 80 a0 60 02 cmp %g1, 2 40023484: 12 80 00 13 bne 400234d0 40023488: 11 10 00 a9 sethi %hi(0x4002a400), %o0 psiginfo = (POSIX_signals_Siginfo_node *) 4002348c: 7f ff a2 ae call 4000bf44 <_Chain_Get> 40023490: 90 12 20 f8 or %o0, 0xf8, %o0 ! 4002a4f8 <_POSIX_signals_Inactive_siginfo> _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 40023494: b4 92 20 00 orcc %o0, 0, %i2 40023498: 12 80 00 06 bne 400234b0 4002349c: 92 07 bf ec add %fp, -20, %o1 rtems_set_errno_and_return_minus_one( EAGAIN ); 400234a0: 7f ff d0 92 call 400176e8 <__errno> <== NOT EXECUTED 400234a4: 01 00 00 00 nop <== NOT EXECUTED 400234a8: 10 bf ff 50 b 400231e8 <== NOT EXECUTED 400234ac: 82 10 20 0b mov 0xb, %g1 ! b <== NOT EXECUTED } psiginfo->Info = *siginfo; 400234b0: 90 06 a0 08 add %i2, 8, %o0 400234b4: 7f ff d6 7f call 40018eb0 400234b8: 94 10 20 0c mov 0xc, %o2 _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 400234bc: 11 10 00 a9 sethi %hi(0x4002a400), %o0 400234c0: 92 10 00 1a mov %i2, %o1 400234c4: 90 12 21 48 or %o0, 0x148, %o0 400234c8: 7f ff a2 93 call 4000bf14 <_Chain_Append> 400234cc: 90 06 40 08 add %i1, %o0, %o0 } _Thread_Enable_dispatch(); 400234d0: 7f ff ff 2a call 40023178 <_Thread_Enable_dispatch> 400234d4: 01 00 00 00 nop 400234d8: 90 10 20 00 clr %o0 ! 0 return 0; } 400234dc: b0 10 00 08 mov %o0, %i0 400234e0: 81 c7 e0 08 ret 400234e4: 81 e8 00 00 restore 4000a6c8 : */ int mq_close( mqd_t mqdes ) { 4000a6c8: 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 *) 4000a6cc: 21 10 00 98 sethi %hi(0x40026000), %l0 4000a6d0: 92 10 00 18 mov %i0, %o1 4000a6d4: 94 07 bf f4 add %fp, -12, %o2 4000a6d8: 40 00 12 6f call 4000f094 <_Objects_Get> 4000a6dc: 90 14 22 10 or %l0, 0x210, %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 ) { 4000a6e0: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000a6e4: 80 a0 60 01 cmp %g1, 1 4000a6e8: 02 80 00 0e be 4000a720 4000a6ec: b0 10 00 08 mov %o0, %i0 4000a6f0: 80 a0 60 01 cmp %g1, 1 4000a6f4: 2a 80 00 11 bcs,a 4000a738 4000a6f8: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 4000a6fc: 80 a0 60 02 cmp %g1, 2 4000a700: 12 80 00 2f bne 4000a7bc 4000a704: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 4000a708: 40 00 2e 9a call 40016170 <__errno> 4000a70c: 01 00 00 00 nop 4000a710: 82 10 20 09 mov 9, %g1 ! 9 4000a714: c2 22 00 00 st %g1, [ %o0 ] 4000a718: 10 80 00 2b b 4000a7c4 4000a71c: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 4000a720: 40 00 17 12 call 40010368 <_Thread_Dispatch> <== NOT EXECUTED 4000a724: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000a728: 40 00 07 53 call 4000c474 <== NOT EXECUTED 4000a72c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000a730: 81 c7 e0 08 ret <== NOT EXECUTED 4000a734: 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; 4000a738: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 _POSIX_Message_queue_Delete( the_mq ); 4000a73c: 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; 4000a740: 82 00 7f ff add %g1, -1, %g1 _POSIX_Message_queue_Delete( the_mq ); 4000a744: 40 00 00 23 call 4000a7d0 <_POSIX_Message_queue_Delete> 4000a748: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000a74c: 90 14 22 10 or %l0, 0x210, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000a750: c4 06 20 08 ld [ %i0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000a754: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4000a758: 03 00 00 3f sethi %hi(0xfc00), %g1 4000a75c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000a760: 82 08 80 01 and %g2, %g1, %g1 4000a764: 80 a0 40 03 cmp %g1, %g3 4000a768: 38 80 00 06 bgu,a 4000a780 4000a76c: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000a770: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000a774: 83 28 60 02 sll %g1, 2, %g1 4000a778: 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; 4000a77c: 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 ); 4000a780: 40 00 12 03 call 4000ef8c <_Objects_Free> 4000a784: 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 ) 4000a788: 03 10 00 97 sethi %hi(0x40025c00), %g1 4000a78c: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 40025c40 <_Thread_Dispatch_disable_level> 4000a790: 90 10 20 00 clr %o0 4000a794: 84 00 bf ff add %g2, -1, %g2 4000a798: c4 20 60 40 st %g2, [ %g1 + 0x40 ] 4000a79c: c2 00 60 40 ld [ %g1 + 0x40 ], %g1 4000a7a0: 80 a0 60 00 cmp %g1, 0 4000a7a4: 32 80 00 09 bne,a 4000a7c8 4000a7a8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 4000a7ac: 40 00 16 ef call 40010368 <_Thread_Dispatch> 4000a7b0: 01 00 00 00 nop 4000a7b4: 10 80 00 04 b 4000a7c4 4000a7b8: 90 10 20 00 clr %o0 ! 0 _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 4000a7bc: 40 00 07 24 call 4000c44c <== NOT EXECUTED 4000a7c0: 01 00 00 00 nop <== NOT EXECUTED } 4000a7c4: b0 10 00 08 mov %o0, %i0 4000a7c8: 81 c7 e0 08 ret 4000a7cc: 81 e8 00 00 restore 4000a860 : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 4000a860: 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 ) 4000a864: 80 a6 60 00 cmp %i1, 0 4000a868: 12 80 00 06 bne 4000a880 4000a86c: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); 4000a870: 40 00 2e 40 call 40016170 <__errno> 4000a874: 01 00 00 00 nop 4000a878: 10 80 00 12 b 4000a8c0 4000a87c: 82 10 20 16 mov 0x16, %g1 ! 16 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 *) 4000a880: 11 10 00 98 sethi %hi(0x40026000), %o0 4000a884: 94 07 bf f4 add %fp, -12, %o2 4000a888: 40 00 12 03 call 4000f094 <_Objects_Get> 4000a88c: 90 12 22 10 or %o0, 0x210, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 4000a890: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000a894: 80 a0 60 01 cmp %g1, 1 4000a898: 02 80 00 0d be 4000a8cc 4000a89c: 01 00 00 00 nop 4000a8a0: 2a 80 00 11 bcs,a 4000a8e4 4000a8a4: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 4000a8a8: 80 a0 60 02 cmp %g1, 2 4000a8ac: 12 80 00 23 bne 4000a938 4000a8b0: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 4000a8b4: 40 00 2e 2f call 40016170 <__errno> 4000a8b8: 01 00 00 00 nop 4000a8bc: 82 10 20 09 mov 9, %g1 ! 9 4000a8c0: c2 22 00 00 st %g1, [ %o0 ] 4000a8c4: 10 80 00 1f b 4000a940 4000a8c8: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 4000a8cc: 40 00 16 a7 call 40010368 <_Thread_Dispatch> <== NOT EXECUTED 4000a8d0: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000a8d4: 40 00 06 e8 call 4000c474 <== NOT EXECUTED 4000a8d8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000a8dc: 81 c7 e0 08 ret <== NOT EXECUTED 4000a8e0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED * Return the old values. */ the_mq_attr = &the_mq->Message_queue.Attributes; mqstat->mq_flags = the_mq_fd->oflag; 4000a8e4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 4000a8e8: c2 26 40 00 st %g1, [ %i1 ] mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 4000a8ec: c2 00 a0 6c ld [ %g2 + 0x6c ], %g1 4000a8f0: c2 26 60 08 st %g1, [ %i1 + 8 ] mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 4000a8f4: c2 00 a0 64 ld [ %g2 + 0x64 ], %g1 4000a8f8: c2 26 60 04 st %g1, [ %i1 + 4 ] mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 4000a8fc: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1 4000a900: 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 ) 4000a904: 05 10 00 97 sethi %hi(0x40025c00), %g2 4000a908: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 ! 40025c40 <_Thread_Dispatch_disable_level> 4000a90c: 90 10 20 00 clr %o0 4000a910: 82 00 7f ff add %g1, -1, %g1 4000a914: c2 20 a0 40 st %g1, [ %g2 + 0x40 ] 4000a918: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 4000a91c: 80 a0 60 00 cmp %g1, 0 4000a920: 32 80 00 09 bne,a 4000a944 4000a924: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 4000a928: 40 00 16 90 call 40010368 <_Thread_Dispatch> 4000a92c: 01 00 00 00 nop 4000a930: 10 80 00 04 b 4000a940 4000a934: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 4000a938: 40 00 06 c5 call 4000c44c <== NOT EXECUTED 4000a93c: 01 00 00 00 nop <== NOT EXECUTED } 4000a940: b0 10 00 08 mov %o0, %i0 4000a944: 81 c7 e0 08 ret 4000a948: 81 e8 00 00 restore 4000a9a4 : int mq_notify( mqd_t mqdes, const struct sigevent *notification ) { 4000a9a4: 9d e3 bf 90 save %sp, -112, %sp 4000a9a8: 11 10 00 98 sethi %hi(0x40026000), %o0 4000a9ac: 92 10 00 18 mov %i0, %o1 4000a9b0: 90 12 22 10 or %o0, 0x210, %o0 4000a9b4: 40 00 11 b8 call 4000f094 <_Objects_Get> 4000a9b8: 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 ) { 4000a9bc: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000a9c0: 80 a0 60 01 cmp %g1, 1 4000a9c4: 02 80 00 0c be 4000a9f4 4000a9c8: 92 10 00 19 mov %i1, %o1 4000a9cc: 80 a0 60 01 cmp %g1, 1 4000a9d0: 0a 80 00 0f bcs 4000aa0c 4000a9d4: 80 a6 60 00 cmp %i1, 0 4000a9d8: 80 a0 60 02 cmp %g1, 2 4000a9dc: 12 80 00 29 bne 4000aa80 4000a9e0: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 4000a9e4: 40 00 2d e3 call 40016170 <__errno> 4000a9e8: 01 00 00 00 nop 4000a9ec: 10 80 00 13 b 4000aa38 4000a9f0: 82 10 20 09 mov 9, %g1 ! 9 case OBJECTS_REMOTE: _Thread_Dispatch(); 4000a9f4: 40 00 16 5d call 40010368 <_Thread_Dispatch> <== NOT EXECUTED 4000a9f8: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000a9fc: 40 00 06 9e call 4000c474 <== NOT EXECUTED 4000aa00: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000aa04: 81 c7 e0 08 ret <== NOT EXECUTED 4000aa08: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; if ( notification ) { 4000aa0c: 02 80 00 17 be 4000aa68 4000aa10: f0 02 20 10 ld [ %o0 + 0x10 ], %i0 if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { 4000aa14: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 4000aa18: 80 a0 60 00 cmp %g1, 0 4000aa1c: 22 80 00 0a be,a 4000aa44 4000aa20: c0 26 20 80 clr [ %i0 + 0x80 ] _Thread_Enable_dispatch(); 4000aa24: 7f ff ff ca call 4000a94c <_Thread_Enable_dispatch> 4000aa28: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EBUSY ); 4000aa2c: 40 00 2d d1 call 40016170 <__errno> 4000aa30: 01 00 00 00 nop 4000aa34: 82 10 20 10 mov 0x10, %g1 ! 10 4000aa38: c2 22 00 00 st %g1, [ %o0 ] 4000aa3c: 10 80 00 13 b 4000aa88 4000aa40: 90 10 3f ff mov -1, %o0 the_message_queue->notify_argument = the_argument; 4000aa44: c0 26 20 84 clr [ %i0 + 0x84 ] } _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); the_mq->notification = *notification; 4000aa48: 90 06 20 94 add %i0, 0x94, %o0 4000aa4c: 40 00 2f af call 40016908 4000aa50: 94 10 20 14 mov 0x14, %o2 CORE_message_queue_Control *the_message_queue, CORE_message_queue_Notify_Handler the_handler, void *the_argument ) { the_message_queue->notify_handler = the_handler; 4000aa54: 03 10 00 2a sethi %hi(0x4000a800), %g1 the_message_queue->notify_argument = the_argument; 4000aa58: f0 26 20 84 st %i0, [ %i0 + 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; 4000aa5c: 82 10 61 80 or %g1, 0x180, %g1 4000aa60: 10 80 00 04 b 4000aa70 4000aa64: c2 26 20 80 st %g1, [ %i0 + 0x80 ] the_message_queue->notify_argument = the_argument; 4000aa68: c0 26 20 84 clr [ %i0 + 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; 4000aa6c: c0 26 20 80 clr [ %i0 + 0x80 ] _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); } _Thread_Enable_dispatch(); 4000aa70: 7f ff ff b7 call 4000a94c <_Thread_Enable_dispatch> 4000aa74: 01 00 00 00 nop 4000aa78: 10 80 00 04 b 4000aa88 4000aa7c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 4000aa80: 40 00 06 73 call 4000c44c <== NOT EXECUTED 4000aa84: 01 00 00 00 nop <== NOT EXECUTED } 4000aa88: b0 10 00 08 mov %o0, %i0 4000aa8c: 81 c7 e0 08 ret 4000aa90: 81 e8 00 00 restore 4000ab14 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 4000ab14: 9d e3 bf 88 save %sp, -120, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000ab18: 05 10 00 97 sethi %hi(0x40025c00), %g2 4000ab1c: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 ! 40025c40 <_Thread_Dispatch_disable_level> 4000ab20: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 4000ab24: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 4000ab28: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 4000ab2c: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 4000ab30: 82 00 60 01 inc %g1 4000ab34: a0 10 00 18 mov %i0, %l0 4000ab38: c2 20 a0 40 st %g1, [ %g2 + 0x40 ] POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 4000ab3c: b6 8e 62 00 andcc %i1, 0x200, %i3 4000ab40: 02 80 00 05 be 4000ab54 4000ab44: b4 10 20 00 clr %i2 va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); 4000ab48: f4 07 a0 50 ld [ %fp + 0x50 ], %i2 4000ab4c: 82 07 a0 54 add %fp, 0x54, %g1 4000ab50: c2 27 bf f4 st %g1, [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd * _POSIX_Message_queue_Allocate_fd( void ) { return (POSIX_Message_queue_Control_fd *) 4000ab54: 39 10 00 98 sethi %hi(0x40026000), %i4 4000ab58: 40 00 10 0b call 4000eb84 <_Objects_Allocate> 4000ab5c: 90 17 22 10 or %i4, 0x210, %o0 ! 40026210 <_POSIX_Message_queue_Information_fds> va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 4000ab60: b0 92 20 00 orcc %o0, 0, %i0 4000ab64: 32 80 00 08 bne,a 4000ab84 4000ab68: f2 26 20 14 st %i1, [ %i0 + 0x14 ] _Thread_Enable_dispatch(); 4000ab6c: 7f ff ff dd call 4000aae0 <_Thread_Enable_dispatch> 4000ab70: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENFILE ); 4000ab74: 40 00 2d 7f call 40016170 <__errno> 4000ab78: 01 00 00 00 nop 4000ab7c: 10 80 00 20 b 4000abfc 4000ab80: 82 10 20 17 mov 0x17, %g1 ! 17 } the_mq_fd->oflag = oflag; status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 4000ab84: 90 10 00 10 mov %l0, %o0 4000ab88: 40 00 23 84 call 40013998 <_POSIX_Message_queue_Name_to_id> 4000ab8c: 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 ) { 4000ab90: ba 92 20 00 orcc %o0, 0, %i5 4000ab94: 02 80 00 10 be 4000abd4 4000ab98: 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) ) ) { 4000ab9c: 80 a7 60 02 cmp %i5, 2 4000aba0: 12 80 00 04 bne 4000abb0 4000aba4: 80 a6 e0 00 cmp %i3, 0 4000aba8: 12 80 00 2c bne 4000ac58 4000abac: 90 10 00 10 mov %l0, %o0 _POSIX_Message_queue_Free_fd( the_mq_fd ); 4000abb0: 7f ff ff c5 call 4000aac4 <_POSIX_Message_queue_Free_fd> 4000abb4: 90 10 00 18 mov %i0, %o0 _Thread_Enable_dispatch(); 4000abb8: 7f ff ff ca call 4000aae0 <_Thread_Enable_dispatch> 4000abbc: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 4000abc0: 40 00 2d 6c call 40016170 <__errno> 4000abc4: 01 00 00 00 nop 4000abc8: fa 22 00 00 st %i5, [ %o0 ] 4000abcc: 81 c7 e0 08 ret 4000abd0: 81 e8 00 00 restore /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 4000abd4: 80 a0 6a 00 cmp %g1, 0xa00 4000abd8: 12 80 00 0b bne 4000ac04 4000abdc: d2 07 bf f0 ld [ %fp + -16 ], %o1 _POSIX_Message_queue_Free_fd( the_mq_fd ); 4000abe0: 7f ff ff b9 call 4000aac4 <_POSIX_Message_queue_Free_fd> 4000abe4: 90 10 00 18 mov %i0, %o0 _Thread_Enable_dispatch(); 4000abe8: 7f ff ff be call 4000aae0 <_Thread_Enable_dispatch> 4000abec: 01 00 00 00 nop rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 4000abf0: 40 00 2d 60 call 40016170 <__errno> 4000abf4: 01 00 00 00 nop 4000abf8: 82 10 20 11 mov 0x11, %g1 ! 11 4000abfc: 10 80 00 22 b 4000ac84 4000ac00: c2 22 00 00 st %g1, [ %o0 ] RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control *) 4000ac04: 94 07 bf e8 add %fp, -24, %o2 <== NOT EXECUTED 4000ac08: 11 10 00 98 sethi %hi(0x40026000), %o0 <== NOT EXECUTED 4000ac0c: 40 00 11 22 call 4000f094 <_Objects_Get> <== NOT EXECUTED 4000ac10: 90 12 20 58 or %o0, 0x58, %o0 ! 40026058 <_POSIX_Message_queue_Information> <== 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; 4000ac14: c4 02 20 1c ld [ %o0 + 0x1c ], %g2 <== NOT EXECUTED 4000ac18: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED the_mq_fd->Queue = the_mq; _Objects_Open( 4000ac1c: 92 10 00 18 mov %i0, %o1 <== 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 ); 4000ac20: c2 27 bf ec st %g1, [ %fp + -20 ] <== NOT EXECUTED the_mq->open_count += 1; 4000ac24: 84 00 a0 01 inc %g2 <== NOT EXECUTED the_mq_fd->Queue = the_mq; _Objects_Open( 4000ac28: 90 17 22 10 or %i4, 0x210, %o0 <== NOT EXECUTED 4000ac2c: 94 10 20 00 clr %o2 <== NOT EXECUTED * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); the_mq->open_count += 1; the_mq_fd->Queue = the_mq; 4000ac30: c2 26 20 10 st %g1, [ %i0 + 0x10 ] <== NOT EXECUTED _Objects_Open( 4000ac34: 7f ff ff 98 call 4000aa94 <_Objects_Open> <== NOT EXECUTED 4000ac38: c4 20 60 1c st %g2, [ %g1 + 0x1c ] <== NOT EXECUTED &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 4000ac3c: 7f ff ff a9 call 4000aae0 <_Thread_Enable_dispatch> <== NOT EXECUTED 4000ac40: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); 4000ac44: 7f ff ff a7 call 4000aae0 <_Thread_Enable_dispatch> <== NOT EXECUTED 4000ac48: 01 00 00 00 nop <== NOT EXECUTED return (mqd_t)the_mq_fd->Object.id; 4000ac4c: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED 4000ac50: 81 c7 e0 08 ret <== NOT EXECUTED 4000ac54: 81 e8 00 00 restore <== NOT EXECUTED /* * 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( 4000ac58: 94 10 00 1a mov %i2, %o2 4000ac5c: 92 10 20 01 mov 1, %o1 4000ac60: 40 00 22 e2 call 400137e8 <_POSIX_Message_queue_Create_support> 4000ac64: 96 07 bf ec add %fp, -20, %o3 /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 4000ac68: 80 a2 3f ff cmp %o0, -1 4000ac6c: 12 80 00 08 bne 4000ac8c 4000ac70: c2 07 bf ec ld [ %fp + -20 ], %g1 _Thread_Enable_dispatch(); 4000ac74: 7f ff ff 9b call 4000aae0 <_Thread_Enable_dispatch> 4000ac78: 01 00 00 00 nop _POSIX_Message_queue_Free_fd( the_mq_fd ); 4000ac7c: 7f ff ff 92 call 4000aac4 <_POSIX_Message_queue_Free_fd> 4000ac80: 90 10 00 18 mov %i0, %o0 4000ac84: 81 c7 e0 08 ret 4000ac88: 91 e8 3f ff restore %g0, -1, %o0 return (mqd_t) -1; } the_mq_fd->Queue = the_mq; _Objects_Open( 4000ac8c: 92 10 00 18 mov %i0, %o1 4000ac90: 90 17 22 10 or %i4, 0x210, %o0 4000ac94: 94 10 20 00 clr %o2 4000ac98: 7f ff ff 7f call 4000aa94 <_Objects_Open> 4000ac9c: c2 26 20 10 st %g1, [ %i0 + 0x10 ] &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 4000aca0: 7f ff ff 90 call 4000aae0 <_Thread_Enable_dispatch> 4000aca4: 01 00 00 00 nop return (mqd_t) the_mq_fd->Object.id; 4000aca8: f0 06 20 08 ld [ %i0 + 8 ], %i0 } 4000acac: 81 c7 e0 08 ret 4000acb0: 81 e8 00 00 restore 4000afcc : int mq_setattr( mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat ) { 4000afcc: 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 ) 4000afd0: 80 a6 60 00 cmp %i1, 0 4000afd4: 12 80 00 06 bne 4000afec 4000afd8: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); 4000afdc: 40 00 2c 65 call 40016170 <__errno> 4000afe0: 01 00 00 00 nop 4000afe4: 10 80 00 12 b 4000b02c 4000afe8: 82 10 20 16 mov 0x16, %g1 ! 16 4000afec: 11 10 00 98 sethi %hi(0x40026000), %o0 4000aff0: 94 07 bf f4 add %fp, -12, %o2 4000aff4: 40 00 10 28 call 4000f094 <_Objects_Get> 4000aff8: 90 12 22 10 or %o0, 0x210, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 4000affc: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000b000: 80 a0 60 01 cmp %g1, 1 4000b004: 02 80 00 0d be 4000b038 4000b008: 01 00 00 00 nop 4000b00c: 0a 80 00 11 bcs 4000b050 4000b010: 80 a6 a0 00 cmp %i2, 0 4000b014: 80 a0 60 02 cmp %g1, 2 4000b018: 12 80 00 27 bne 4000b0b4 4000b01c: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 4000b020: 40 00 2c 54 call 40016170 <__errno> 4000b024: 01 00 00 00 nop 4000b028: 82 10 20 09 mov 9, %g1 ! 9 4000b02c: c2 22 00 00 st %g1, [ %o0 ] 4000b030: 10 80 00 23 b 4000b0bc 4000b034: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 4000b038: 40 00 14 cc call 40010368 <_Thread_Dispatch> <== NOT EXECUTED 4000b03c: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000b040: 40 00 05 0d call 4000c474 <== NOT EXECUTED 4000b044: 01 00 00 00 nop <== NOT EXECUTED the_mq_fd->oflag = mqstat->mq_flags; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000b048: 81 c7 e0 08 ret <== NOT EXECUTED 4000b04c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * Return the old values. */ if ( omqstat ) { 4000b050: 02 80 00 0a be 4000b078 4000b054: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 omqstat->mq_flags = the_mq_fd->oflag; 4000b058: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 4000b05c: c2 26 80 00 st %g1, [ %i2 ] omqstat->mq_msgsize = the_core_mq->maximum_message_size; 4000b060: c2 00 a0 6c ld [ %g2 + 0x6c ], %g1 4000b064: c2 26 a0 08 st %g1, [ %i2 + 8 ] omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages; 4000b068: c2 00 a0 64 ld [ %g2 + 0x64 ], %g1 4000b06c: c2 26 a0 04 st %g1, [ %i2 + 4 ] omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages; 4000b070: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1 4000b074: c2 26 a0 0c st %g1, [ %i2 + 0xc ] } the_mq_fd->oflag = mqstat->mq_flags; 4000b078: c2 06 40 00 ld [ %i1 ], %g1 4000b07c: 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 ) 4000b080: 05 10 00 97 sethi %hi(0x40025c00), %g2 4000b084: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 ! 40025c40 <_Thread_Dispatch_disable_level> 4000b088: 90 10 20 00 clr %o0 4000b08c: 82 00 7f ff add %g1, -1, %g1 4000b090: c2 20 a0 40 st %g1, [ %g2 + 0x40 ] 4000b094: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 4000b098: 80 a0 60 00 cmp %g1, 0 4000b09c: 32 80 00 09 bne,a 4000b0c0 4000b0a0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 4000b0a4: 40 00 14 b1 call 40010368 <_Thread_Dispatch> 4000b0a8: 01 00 00 00 nop 4000b0ac: 10 80 00 04 b 4000b0bc 4000b0b0: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 4000b0b4: 40 00 04 e6 call 4000c44c <== NOT EXECUTED 4000b0b8: 01 00 00 00 nop <== NOT EXECUTED } 4000b0bc: b0 10 00 08 mov %o0, %i0 4000b0c0: 81 c7 e0 08 ret 4000b0c4: 81 e8 00 00 restore 4000b0c8 : char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 4000b0c8: 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 ) ) { 4000b0cc: 92 07 bf f4 add %fp, -12, %o1 4000b0d0: 40 00 00 88 call 4000b2f0 <_POSIX_Absolute_timeout_to_ticks> 4000b0d4: 90 10 00 1c mov %i4, %o0 char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 4000b0d8: 92 10 00 19 mov %i1, %o1 4000b0dc: 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 ) ) { 4000b0e0: 80 a2 20 02 cmp %o0, 2 4000b0e4: 08 80 00 07 bleu 4000b100 4000b0e8: 96 10 00 1b mov %i3, %o3 4000b0ec: 80 a2 20 03 cmp %o0, 3 4000b0f0: 22 80 00 05 be,a 4000b104 4000b0f4: b8 10 20 01 mov 1, %i4 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Receive_support( 4000b0f8: 10 80 00 04 b 4000b108 <== NOT EXECUTED 4000b0fc: da 07 bf f4 ld [ %fp + -12 ], %o5 <== 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 ) ) { 4000b100: 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( 4000b104: da 07 bf f4 ld [ %fp + -12 ], %o5 4000b108: 90 10 00 18 mov %i0, %o0 4000b10c: 7f ff fe fd call 4000ad00 <_POSIX_Message_queue_Receive_support> 4000b110: 98 10 00 1c mov %i4, %o4 msg_len, msg_prio, do_wait, ticks ); } 4000b114: 81 c7 e0 08 ret 4000b118: 91 e8 00 08 restore %g0, %o0, %o0 4000b11c : const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 4000b11c: 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 ) ) { 4000b120: 92 07 bf f4 add %fp, -12, %o1 4000b124: 40 00 00 73 call 4000b2f0 <_POSIX_Absolute_timeout_to_ticks> 4000b128: 90 10 00 1c mov %i4, %o0 const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 4000b12c: 92 10 00 19 mov %i1, %o1 4000b130: 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 ) ) { 4000b134: 80 a2 20 02 cmp %o0, 2 4000b138: 08 80 00 07 bleu 4000b154 4000b13c: 96 10 00 1b mov %i3, %o3 4000b140: 80 a2 20 03 cmp %o0, 3 4000b144: 22 80 00 05 be,a 4000b158 4000b148: b8 10 20 01 mov 1, %i4 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Send_support( 4000b14c: 10 80 00 04 b 4000b15c <== NOT EXECUTED 4000b150: da 07 bf f4 ld [ %fp + -12 ], %o5 <== 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 ) ) { 4000b154: 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( 4000b158: da 07 bf f4 ld [ %fp + -12 ], %o5 4000b15c: 90 10 00 18 mov %i0, %o0 4000b160: 7f ff ff 4e call 4000ae98 <_POSIX_Message_queue_Send_support> 4000b164: 98 10 00 1c mov %i4, %o4 msg_len, msg_prio, do_wait, ticks ); } 4000b168: 81 c7 e0 08 ret 4000b16c: 91 e8 00 08 restore %g0, %o0, %o0 400065f8 : */ int pthread_barrier_destroy( pthread_barrier_t *barrier ) { 400065f8: 9d e3 bf 90 save %sp, -112, %sp POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 400065fc: 80 a6 20 00 cmp %i0, 0 40006600: 02 80 00 2c be 400066b0 40006604: 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( 40006608: d2 06 00 00 ld [ %i0 ], %o1 4000660c: 31 10 00 72 sethi %hi(0x4001c800), %i0 40006610: 40 00 0c b4 call 400098e0 <_Objects_Get> 40006614: 90 16 21 c0 or %i0, 0x1c0, %o0 ! 4001c9c0 <_POSIX_Barrier_Information> return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 40006618: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000661c: 80 a0 60 00 cmp %g1, 0 40006620: 02 80 00 07 be 4000663c 40006624: 88 10 00 08 mov %o0, %g4 40006628: 80 a0 60 02 cmp %g1, 2 4000662c: 18 80 00 1d bgu 400066a0 40006630: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40006634: 81 c7 e0 08 ret 40006638: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) { 4000663c: c2 02 20 58 ld [ %o0 + 0x58 ], %g1 40006640: 80 a0 60 00 cmp %g1, 0 40006644: 22 80 00 06 be,a 4000665c 40006648: 90 16 21 c0 or %i0, 0x1c0, %o0 _Thread_Enable_dispatch(); 4000664c: 7f ff ff de call 400065c4 <_Thread_Enable_dispatch> 40006650: 01 00 00 00 nop 40006654: 10 80 00 18 b 400066b4 40006658: 90 10 20 10 mov 0x10, %o0 ! 10 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000665c: c2 01 20 08 ld [ %g4 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006660: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40006664: 05 00 00 3f sethi %hi(0xfc00), %g2 40006668: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000666c: 82 08 40 02 and %g1, %g2, %g1 40006670: 80 a0 40 03 cmp %g1, %g3 40006674: 18 80 00 05 bgu 40006688 40006678: 92 10 00 04 mov %g4, %o1 information->local_table[ index ] = the_object; 4000667c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006680: 83 28 60 02 sll %g1, 2, %g1 40006684: 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 ); 40006688: 40 00 0c 54 call 400097d8 <_Objects_Free> 4000668c: c0 21 20 0c clr [ %g4 + 0xc ] _Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object ); _POSIX_Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 40006690: 7f ff ff cd call 400065c4 <_Thread_Enable_dispatch> 40006694: 01 00 00 00 nop 40006698: 10 80 00 07 b 400066b4 4000669c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 400066a0: 40 00 01 fc call 40006e90 <== NOT EXECUTED 400066a4: 01 00 00 00 nop <== NOT EXECUTED } 400066a8: 81 c7 e0 08 ret <== NOT EXECUTED 400066ac: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400066b0: 90 10 20 16 mov 0x16, %o0 } 400066b4: b0 10 00 08 mov %o0, %i0 400066b8: 81 c7 e0 08 ret 400066bc: 81 e8 00 00 restore 400066f4 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 400066f4: 9d e3 bf 88 save %sp, -120, %sp const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 400066f8: 80 a6 20 00 cmp %i0, 0 400066fc: 02 80 00 36 be 400067d4 40006700: a0 10 00 19 mov %i1, %l0 return EINVAL; if ( count == 0 ) 40006704: 80 a6 a0 00 cmp %i2, 0 40006708: 02 80 00 33 be 400067d4 4000670c: 80 a6 60 00 cmp %i1, 0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 40006710: 32 80 00 06 bne,a 40006728 40006714: c2 04 00 00 ld [ %l0 ], %g1 the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 40006718: a0 07 bf e8 add %fp, -24, %l0 4000671c: 7f ff ff 93 call 40006568 40006720: 90 10 00 10 mov %l0, %o0 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 40006724: c2 04 00 00 ld [ %l0 ], %g1 40006728: 80 a0 60 00 cmp %g1, 0 4000672c: 02 80 00 2a be 400067d4 40006730: 01 00 00 00 nop return EINVAL; switch ( the_attr->process_shared ) { 40006734: c2 04 20 04 ld [ %l0 + 4 ], %g1 40006738: 80 a0 60 00 cmp %g1, 0 4000673c: 12 80 00 26 bne 400067d4 40006740: 05 10 00 71 sethi %hi(0x4001c400), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006744: c2 00 a1 10 ld [ %g2 + 0x110 ], %g1 ! 4001c510 <_Thread_Dispatch_disable_level> /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; the_attributes.maximum_count = count; 40006748: f4 27 bf f4 st %i2, [ %fp + -12 ] 4000674c: 82 00 60 01 inc %g1 } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 40006750: c0 27 bf f0 clr [ %fp + -16 ] 40006754: c2 20 a1 10 st %g1, [ %g2 + 0x110 ] * 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 *) 40006758: 35 10 00 72 sethi %hi(0x4001c800), %i2 4000675c: 40 00 0b 1d call 400093d0 <_Objects_Allocate> 40006760: 90 16 a1 c0 or %i2, 0x1c0, %o0 ! 4001c9c0 <_POSIX_Barrier_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 40006764: a0 92 20 00 orcc %o0, 0, %l0 40006768: 12 80 00 06 bne 40006780 4000676c: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); 40006770: 7f ff ff d4 call 400066c0 <_Thread_Enable_dispatch> 40006774: b0 10 20 0b mov 0xb, %i0 40006778: 81 c7 e0 08 ret 4000677c: 81 e8 00 00 restore return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 40006780: 40 00 08 6b call 4000892c <_CORE_barrier_Initialize> 40006784: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006788: 90 16 a1 c0 or %i2, 0x1c0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000678c: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006790: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40006794: 05 00 00 3f sethi %hi(0xfc00), %g2 40006798: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000679c: 82 08 40 02 and %g1, %g2, %g1 400067a0: 80 a0 40 03 cmp %g1, %g3 400067a4: 38 80 00 06 bgu,a 400067bc 400067a8: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 400067ac: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400067b0: 83 28 60 02 sll %g1, 2, %g1 400067b4: e0 20 80 01 st %l0, [ %g2 + %g1 ] ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 400067b8: c2 04 20 08 ld [ %l0 + 8 ], %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; 400067bc: c0 24 20 0c clr [ %l0 + 0xc ] 400067c0: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 400067c4: 7f ff ff bf call 400066c0 <_Thread_Enable_dispatch> 400067c8: b0 10 20 00 clr %i0 400067cc: 81 c7 e0 08 ret 400067d0: 81 e8 00 00 restore return 0; } 400067d4: 81 c7 e0 08 ret 400067d8: 91 e8 20 16 restore %g0, 0x16, %o0 400067dc : */ int pthread_barrier_wait( pthread_barrier_t *barrier ) { 400067dc: 9d e3 bf 90 save %sp, -112, %sp POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 400067e0: 80 a6 20 00 cmp %i0, 0 400067e4: 02 80 00 28 be 40006884 400067e8: 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( 400067ec: d2 06 00 00 ld [ %i0 ], %o1 400067f0: 94 07 bf f4 add %fp, -12, %o2 400067f4: 40 00 0c 3b call 400098e0 <_Objects_Get> 400067f8: 90 12 21 c0 or %o0, 0x1c0, %o0 return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 400067fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006800: 80 a0 60 00 cmp %g1, 0 40006804: 22 80 00 07 be,a 40006820 40006808: d2 02 20 08 ld [ %o0 + 8 ], %o1 4000680c: 80 a0 60 02 cmp %g1, 2 40006810: 18 80 00 19 bgu 40006874 40006814: 90 10 20 16 mov 0x16, %o0 return _POSIX_Barrier_Translate_core_barrier_return_code( _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40006818: 81 c7 e0 08 ret 4000681c: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_barrier_Wait( 40006820: 94 10 20 01 mov 1, %o2 40006824: 90 02 20 10 add %o0, 0x10, %o0 40006828: 96 10 20 00 clr %o3 4000682c: 40 00 08 4c call 4000895c <_CORE_barrier_Wait> 40006830: 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 ) 40006834: 03 10 00 71 sethi %hi(0x4001c400), %g1 40006838: c4 00 61 10 ld [ %g1 + 0x110 ], %g2 ! 4001c510 <_Thread_Dispatch_disable_level> 4000683c: 84 00 bf ff add %g2, -1, %g2 40006840: c4 20 61 10 st %g2, [ %g1 + 0x110 ] 40006844: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 40006848: 80 a0 60 00 cmp %g1, 0 4000684c: 12 80 00 05 bne 40006860 40006850: 03 10 00 71 sethi %hi(0x4001c400), %g1 _Thread_Dispatch(); 40006854: 40 00 10 d8 call 4000abb4 <_Thread_Dispatch> 40006858: 01 00 00 00 nop TRUE, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 4000685c: 03 10 00 71 sethi %hi(0x4001c400), %g1 40006860: c2 00 61 ec ld [ %g1 + 0x1ec ], %g1 ! 4001c5ec <_Thread_Executing> 40006864: 40 00 1e 5e call 4000e1dc <_POSIX_Barrier_Translate_core_barrier_return_code> 40006868: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 4000686c: 81 c7 e0 08 ret 40006870: 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(); 40006874: 40 00 01 87 call 40006e90 <== NOT EXECUTED 40006878: 01 00 00 00 nop <== NOT EXECUTED } 4000687c: 81 c7 e0 08 ret <== NOT EXECUTED 40006880: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40006884: 90 10 20 16 mov 0x16, %o0 } 40006888: b0 10 00 08 mov %o0, %i0 4000688c: 81 c7 e0 08 ret 40006890: 81 e8 00 00 restore 40005d74 : */ int pthread_cancel( pthread_t thread ) { 40005d74: 9d e3 bf 90 save %sp, -112, %sp /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 40005d78: 03 10 00 5f sethi %hi(0x40017c00), %g1 40005d7c: c2 00 62 94 ld [ %g1 + 0x294 ], %g1 ! 40017e94 <_ISR_Nest_level> */ int pthread_cancel( pthread_t thread ) { 40005d80: 92 10 00 18 mov %i0, %o1 /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 40005d84: 80 a0 60 00 cmp %g1, 0 40005d88: 12 80 00 2e bne 40005e40 40005d8c: 90 10 20 47 mov 0x47, %o0 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 40005d90: 11 10 00 60 sethi %hi(0x40018000), %o0 40005d94: 94 07 bf f4 add %fp, -12, %o2 40005d98: 40 00 0d 01 call 4000919c <_Objects_Get> 40005d9c: 90 12 20 b8 or %o0, 0xb8, %o0 return EPROTO; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 40005da0: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005da4: 80 a0 60 01 cmp %g1, 1 40005da8: 02 80 00 08 be 40005dc8 40005dac: 01 00 00 00 nop 40005db0: 2a 80 00 0a bcs,a 40005dd8 40005db4: c6 02 21 70 ld [ %o0 + 0x170 ], %g3 40005db8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40005dbc: 02 80 00 21 be 40005e40 <== NOT EXECUTED 40005dc0: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 40005dc4: 30 80 00 1d b,a 40005e38 <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_REMOTE: return POSIX_MP_NOT_IMPLEMENTED(); 40005dc8: 40 00 02 9b call 40006834 <== NOT EXECUTED 40005dcc: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40005dd0: 81 c7 e0 08 ret <== NOT EXECUTED 40005dd4: 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; 40005dd8: 82 10 20 01 mov 1, %g1 if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 40005ddc: c4 00 e0 cc ld [ %g3 + 0xcc ], %g2 40005de0: 80 a0 a0 00 cmp %g2, 0 40005de4: 12 80 00 08 bne 40005e04 40005de8: c2 20 e0 d4 st %g1, [ %g3 + 0xd4 ] 40005dec: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 40005df0: 80 a0 60 01 cmp %g1, 1 40005df4: 12 80 00 04 bne 40005e04 40005df8: 01 00 00 00 nop thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS ) { _POSIX_Threads_cancel_run( the_thread ); 40005dfc: 40 00 00 14 call 40005e4c <_POSIX_Threads_cancel_run> 40005e00: 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 ) 40005e04: 03 10 00 5f sethi %hi(0x40017c00), %g1 40005e08: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 40017dd0 <_Thread_Dispatch_disable_level> 40005e0c: 90 10 20 00 clr %o0 40005e10: 84 00 bf ff add %g2, -1, %g2 40005e14: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ] 40005e18: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 40005e1c: 80 a0 60 00 cmp %g1, 0 40005e20: 32 80 00 09 bne,a 40005e44 40005e24: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 40005e28: 40 00 11 92 call 4000a470 <_Thread_Dispatch> 40005e2c: 01 00 00 00 nop 40005e30: 10 80 00 04 b 40005e40 40005e34: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40005e38: 40 00 02 75 call 4000680c <== NOT EXECUTED 40005e3c: 01 00 00 00 nop <== NOT EXECUTED } 40005e40: b0 10 00 08 mov %o0, %i0 40005e44: 81 c7 e0 08 ret 40005e48: 81 e8 00 00 restore 40006fe8 : */ int pthread_cond_destroy( pthread_cond_t *cond ) { 40006fe8: 9d e3 bf 90 save %sp, -112, %sp ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 40006fec: 80 a6 20 00 cmp %i0, 0 40006ff0: 32 80 00 05 bne,a 40007004 40006ff4: c2 06 00 00 ld [ %i0 ], %g1 *location = OBJECTS_ERROR; 40006ff8: 82 10 20 02 mov 2, %g1 40006ffc: 10 80 00 14 b 4000704c 40007000: c2 27 bf f4 st %g1, [ %fp + -12 ] return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 40007004: 80 a0 7f ff cmp %g1, -1 40007008: 32 80 00 0c bne,a 40007038 4000700c: d2 06 00 00 ld [ %i0 ], %o1 /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 40007010: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40007014: 40 00 00 41 call 40007118 <== NOT EXECUTED 40007018: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 4000701c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007020: 22 80 00 06 be,a 40007038 <== NOT EXECUTED 40007024: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; 40007028: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 4000702c: b0 10 20 00 clr %i0 <== NOT EXECUTED 40007030: 10 80 00 07 b 4000704c <== NOT EXECUTED 40007034: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 40007038: 11 10 00 66 sethi %hi(0x40019800), %o0 4000703c: 94 07 bf f4 add %fp, -12, %o2 40007040: 40 00 0f 40 call 4000ad40 <_Objects_Get> 40007044: 90 12 20 2c or %o0, 0x2c, %o0 40007048: b0 10 00 08 mov %o0, %i0 POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 4000704c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007050: 80 a0 60 00 cmp %g1, 0 40007054: 02 80 00 05 be 40007068 40007058: 80 a0 60 02 cmp %g1, 2 4000705c: 08 80 00 20 bleu 400070dc 40007060: 90 10 20 16 mov 0x16, %o0 40007064: 30 80 00 1c b,a 400070d4 <== NOT EXECUTED return EINVAL; case OBJECTS_LOCAL: if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { 40007068: 40 00 16 32 call 4000c930 <_Thread_queue_First> 4000706c: 90 06 20 18 add %i0, 0x18, %o0 40007070: 80 a2 20 00 cmp %o0, 0 40007074: 02 80 00 06 be 4000708c 40007078: 03 10 00 66 sethi %hi(0x40019800), %g1 _Thread_Enable_dispatch(); 4000707c: 7f ff ff ce call 40006fb4 <_Thread_Enable_dispatch> 40007080: 01 00 00 00 nop 40007084: 10 80 00 16 b 400070dc 40007088: 90 10 20 10 mov 0x10, %o0 ! 10 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000708c: c6 06 20 08 ld [ %i0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40007090: 90 10 60 2c or %g1, 0x2c, %o0 40007094: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40007098: 03 00 00 3f sethi %hi(0xfc00), %g1 4000709c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400070a0: 82 08 c0 01 and %g3, %g1, %g1 400070a4: 80 a0 40 02 cmp %g1, %g2 400070a8: 18 80 00 05 bgu 400070bc 400070ac: 92 10 00 18 mov %i0, %o1 information->local_table[ index ] = the_object; 400070b0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400070b4: 83 28 60 02 sll %g1, 2, %g1 400070b8: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free ( POSIX_Condition_variables_Control *the_condition_variable ) { _Objects_Free( 400070bc: 40 00 0e df call 4000ac38 <_Objects_Free> 400070c0: c0 26 20 0c clr [ %i0 + 0xc ] 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 400070c4: 7f ff ff bc call 40006fb4 <_Thread_Enable_dispatch> 400070c8: 01 00 00 00 nop 400070cc: 10 80 00 04 b 400070dc 400070d0: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 400070d4: 40 00 04 cb call 40008400 <== NOT EXECUTED 400070d8: 01 00 00 00 nop <== NOT EXECUTED } 400070dc: 81 c7 e0 08 ret 400070e0: 91 e8 00 08 restore %g0, %o0, %o0 40007118 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 40007118: 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; 4000711c: 03 10 00 5c sethi %hi(0x40017000), %g1 int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 40007120: a4 10 00 18 mov %i0, %l2 POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 40007124: 80 a6 60 00 cmp %i1, 0 40007128: 02 80 00 03 be 40007134 4000712c: a0 10 63 f4 or %g1, 0x3f4, %l0 40007130: a0 10 00 19 mov %i1, %l0 /* * XXX: Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 40007134: c2 04 20 04 ld [ %l0 + 4 ], %g1 40007138: 80 a0 60 01 cmp %g1, 1 4000713c: 32 80 00 04 bne,a 4000714c 40007140: c2 04 00 00 ld [ %l0 ], %g1 return POSIX_MP_NOT_IMPLEMENTED(); 40007144: 40 00 04 b9 call 40008428 <== NOT EXECUTED 40007148: 81 e8 00 00 restore <== NOT EXECUTED if ( !the_attr->is_initialized ) 4000714c: 80 a0 60 00 cmp %g1, 0 40007150: 02 80 00 0e be 40007188 40007154: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007158: 05 10 00 64 sethi %hi(0x40019000), %g2 4000715c: c2 00 a2 e0 ld [ %g2 + 0x2e0 ], %g1 ! 400192e0 <_Thread_Dispatch_disable_level> 40007160: 82 00 60 01 inc %g1 40007164: c2 20 a2 e0 st %g1, [ %g2 + 0x2e0 ] */ RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) 40007168: 23 10 00 66 sethi %hi(0x40019800), %l1 4000716c: 40 00 0d b1 call 4000a830 <_Objects_Allocate> 40007170: 90 14 60 2c or %l1, 0x2c, %o0 ! 4001982c <_POSIX_Condition_variables_Information> _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 40007174: b2 92 20 00 orcc %o0, 0, %i1 40007178: 32 80 00 06 bne,a 40007190 4000717c: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Thread_Enable_dispatch(); 40007180: 7f ff ff d9 call 400070e4 <_Thread_Enable_dispatch> 40007184: b0 10 20 0c mov 0xc, %i0 40007188: 81 c7 e0 08 ret 4000718c: 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( 40007190: 90 06 60 18 add %i1, 0x18, %o0 _Thread_Enable_dispatch(); return EAGAIN; } #endif the_cond->process_shared = the_attr->process_shared; 40007194: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 40007198: c0 26 60 14 clr [ %i1 + 0x14 ] /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 4000719c: 92 10 20 00 clr %o1 400071a0: 94 10 28 00 mov 0x800, %o2 400071a4: 40 00 16 0d call 4000c9d8 <_Thread_queue_Initialize> 400071a8: 96 10 20 74 mov 0x74, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400071ac: 90 14 60 2c or %l1, 0x2c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 400071b0: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400071b4: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 400071b8: 03 00 00 3f sethi %hi(0xfc00), %g1 400071bc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400071c0: 82 08 80 01 and %g2, %g1, %g1 400071c4: 80 a0 40 03 cmp %g1, %g3 400071c8: 38 80 00 06 bgu,a 400071e0 400071cc: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 400071d0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400071d4: 83 28 60 02 sll %g1, 2, %g1 400071d8: f2 20 80 01 st %i1, [ %g2 + %g1 ] &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 400071dc: c2 06 60 08 ld [ %i1 + 8 ], %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; 400071e0: c0 26 60 0c clr [ %i1 + 0xc ] 400071e4: c2 24 80 00 st %g1, [ %l2 ] 0, /* Name not used */ 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 400071e8: 7f ff ff bf call 400070e4 <_Thread_Enable_dispatch> 400071ec: b0 10 20 00 clr %i0 return 0; } 400071f0: 81 c7 e0 08 ret 400071f4: 81 e8 00 00 restore 40006f2c : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 40006f2c: 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; 40006f30: 03 10 00 72 sethi %hi(0x4001c800), %g1 pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 40006f34: 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; 40006f38: 80 a6 60 00 cmp %i1, 0 40006f3c: 02 80 00 03 be 40006f48 40006f40: a2 10 63 00 or %g1, 0x300, %l1 40006f44: a2 10 00 19 mov %i1, %l1 if ( !the_attr->is_initialized ) 40006f48: c2 04 40 00 ld [ %l1 ], %g1 40006f4c: 80 a0 60 00 cmp %g1, 0 40006f50: 02 80 00 65 be 400070e4 40006f54: b0 10 20 16 mov 0x16, %i0 /* * 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 ) ) 40006f58: c2 04 60 04 ld [ %l1 + 4 ], %g1 40006f5c: 80 a0 60 00 cmp %g1, 0 40006f60: 22 80 00 07 be,a 40006f7c 40006f64: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 40006f68: c2 04 60 08 ld [ %l1 + 8 ], %g1 40006f6c: 80 a0 6f ff cmp %g1, 0xfff 40006f70: 08 80 00 8b bleu 4000719c 40006f74: 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 ) { 40006f78: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 <== NOT EXECUTED 40006f7c: 80 a0 60 01 cmp %g1, 1 40006f80: 02 80 00 06 be 40006f98 40006f84: 80 a0 60 02 cmp %g1, 2 40006f88: 12 80 00 57 bne 400070e4 40006f8c: b0 10 20 16 mov 0x16, %i0 schedpolicy = api->schedpolicy; schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 40006f90: 10 80 00 0a b 40006fb8 40006f94: e4 04 60 14 ld [ %l1 + 0x14 ], %l2 * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 40006f98: 03 10 00 7a sethi %hi(0x4001e800), %g1 40006f9c: c2 00 63 cc ld [ %g1 + 0x3cc ], %g1 ! 4001ebcc <_Thread_Executing> schedpolicy = api->schedpolicy; schedparam = api->schedparam; 40006fa0: 90 07 bf e0 add %fp, -32, %o0 * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 40006fa4: d2 00 61 70 ld [ %g1 + 0x170 ], %o1 schedpolicy = api->schedpolicy; schedparam = api->schedparam; 40006fa8: 94 10 20 18 mov 0x18, %o2 */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; schedpolicy = api->schedpolicy; 40006fac: e4 02 60 7c ld [ %o1 + 0x7c ], %l2 schedparam = api->schedparam; 40006fb0: 10 80 00 05 b 40006fc4 40006fb4: 92 02 60 80 add %o1, 0x80, %o1 break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; 40006fb8: 90 07 bf e0 add %fp, -32, %o0 40006fbc: 92 04 60 18 add %l1, 0x18, %o1 40006fc0: 94 10 20 18 mov 0x18, %o2 40006fc4: 40 00 28 62 call 4001114c 40006fc8: b0 10 20 86 mov 0x86, %i0 /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 40006fcc: c2 04 60 0c ld [ %l1 + 0xc ], %g1 40006fd0: 80 a0 60 00 cmp %g1, 0 40006fd4: 12 80 00 44 bne 400070e4 40006fd8: ea 07 bf e0 ld [ %fp + -32 ], %l5 /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 40006fdc: 82 05 7f ff add %l5, -1, %g1 40006fe0: 80 a0 60 fd cmp %g1, 0xfd 40006fe4: 18 80 00 6d bgu 40007198 40006fe8: 80 a4 a0 01 cmp %l2, 1 */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 40006fec: 02 80 00 10 be 4000702c 40006ff0: a0 10 20 00 clr %l0 40006ff4: 14 80 00 08 bg 40007014 40006ff8: 80 a4 a0 02 cmp %l2, 2 40006ffc: 80 a4 a0 00 cmp %l2, 0 40007000: a0 10 20 01 mov 1, %l0 40007004: 02 80 00 1a be 4000706c 40007008: a8 10 20 00 clr %l4 *thread = the_thread->Object.id; _Thread_Enable_dispatch(); return 0; 4000700c: 81 c7 e0 08 ret 40007010: 91 e8 20 16 restore %g0, 0x16, %o0 */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 40007014: 02 80 00 05 be 40007028 40007018: 80 a4 a0 03 cmp %l2, 3 4000701c: 12 80 00 32 bne 400070e4 40007020: b0 10 20 16 mov 0x16, %i0 40007024: 30 80 00 04 b,a 40007034 40007028: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED 4000702c: 10 80 00 10 b 4000706c 40007030: a8 10 20 00 clr %l4 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 ) < 40007034: 40 00 16 1c call 4000c8a4 <_Timespec_To_ticks> 40007038: 90 07 bf e8 add %fp, -24, %o0 4000703c: a0 10 00 08 mov %o0, %l0 40007040: 40 00 16 19 call 4000c8a4 <_Timespec_To_ticks> 40007044: 90 07 bf f0 add %fp, -16, %o0 40007048: 80 a4 00 08 cmp %l0, %o0 4000704c: 0a 80 00 53 bcs 40007198 40007050: 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 ) ) 40007054: 82 00 7f ff add %g1, -1, %g1 40007058: 80 a0 60 fd cmp %g1, 0xfd 4000705c: 18 80 00 4f bgu 40007198 40007060: 03 10 00 1d sethi %hi(0x40007400), %g1 40007064: a0 10 20 03 mov 3, %l0 40007068: a8 10 61 54 or %g1, 0x154, %l4 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000706c: 05 10 00 7a sethi %hi(0x4001e800), %g2 40007070: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 4001eaf0 <_Thread_Dispatch_disable_level> 40007074: 82 00 60 01 inc %g1 40007078: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 4000707c: 27 10 00 7b sethi %hi(0x4001ec00), %l3 40007080: 40 00 0b 9d call 40009ef4 <_Objects_Allocate> 40007084: 90 14 e1 d8 or %l3, 0x1d8, %o0 ! 4001edd8 <_POSIX_Threads_Information> * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 40007088: b2 92 20 00 orcc %o0, 0, %i1 4000708c: 02 80 00 14 be 400070dc 40007090: 90 14 e1 d8 or %l3, 0x1d8, %o0 /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 40007094: d4 04 60 04 ld [ %l1 + 4 ], %o2 40007098: d6 04 60 08 ld [ %l1 + 8 ], %o3 4000709c: e0 23 a0 60 st %l0, [ %sp + 0x60 ] 400070a0: e8 23 a0 64 st %l4, [ %sp + 0x64 ] 400070a4: c0 23 a0 68 clr [ %sp + 0x68 ] 400070a8: c0 23 a0 6c clr [ %sp + 0x6c ] 400070ac: 9a 10 20 ff mov 0xff, %o5 400070b0: a6 10 20 01 mov 1, %l3 400070b4: 9a 23 40 15 sub %o5, %l5, %o5 400070b8: e6 23 a0 5c st %l3, [ %sp + 0x5c ] 400070bc: 92 10 00 19 mov %i1, %o1 400070c0: 40 00 11 ed call 4000b874 <_Thread_Initialize> 400070c4: 98 10 20 00 clr %o4 budget_callout, 0, /* isr level */ NULL /* posix threads don't have a name */ ); if ( !status ) { 400070c8: 80 a2 20 00 cmp %o0, 0 400070cc: 32 80 00 08 bne,a 400070ec 400070d0: e0 06 61 70 ld [ %i1 + 0x170 ], %l0 _POSIX_Threads_Free( the_thread ); 400070d4: 7f ff ff 82 call 40006edc <_POSIX_Threads_Free> 400070d8: 90 10 00 19 mov %i1, %o0 _Thread_Enable_dispatch(); 400070dc: 7f ff ff 87 call 40006ef8 <_Thread_Enable_dispatch> 400070e0: b0 10 20 0b mov 0xb, %i0 400070e4: 81 c7 e0 08 ret 400070e8: 81 e8 00 00 restore */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; 400070ec: 92 10 00 11 mov %l1, %o1 400070f0: 94 10 20 38 mov 0x38, %o2 400070f4: 40 00 28 16 call 4001114c 400070f8: 90 10 00 10 mov %l0, %o0 api->detachstate = the_attr->detachstate; 400070fc: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 api->schedpolicy = schedpolicy; api->schedparam = schedparam; 40007100: 92 07 bf e0 add %fp, -32, %o1 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; 40007104: c2 24 20 38 st %g1, [ %l0 + 0x38 ] api->schedpolicy = schedpolicy; api->schedparam = schedparam; 40007108: 94 10 20 18 mov 0x18, %o2 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; 4000710c: e4 24 20 7c st %l2, [ %l0 + 0x7c ] api->schedparam = schedparam; 40007110: 40 00 28 0f call 4001114c 40007114: 90 04 20 80 add %l0, 0x80, %o0 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 40007118: 94 10 00 1a mov %i2, %o2 * first run. * * NOTE: Since the thread starts with all unblocked, this is necessary. */ the_thread->do_post_task_switch_extension = TRUE; 4000711c: e6 26 60 78 st %l3, [ %i1 + 0x78 ] /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 40007120: 96 10 00 1b mov %i3, %o3 40007124: 90 10 00 19 mov %i1, %o0 40007128: 92 10 20 01 mov 1, %o1 4000712c: 40 00 15 27 call 4000c5c8 <_Thread_Start> 40007130: 98 10 20 00 clr %o4 start_routine, arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { 40007134: 80 a4 a0 03 cmp %l2, 3 40007138: 12 80 00 09 bne 4000715c 4000713c: a2 10 00 08 mov %o0, %l1 _Watchdog_Insert_ticks( 40007140: 40 00 15 d9 call 4000c8a4 <_Timespec_To_ticks> 40007144: 90 04 20 88 add %l0, 0x88, %o0 40007148: 92 04 20 9c add %l0, 0x9c, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000714c: d0 24 20 a8 st %o0, [ %l0 + 0xa8 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40007150: 11 10 00 7a sethi %hi(0x4001e800), %o0 40007154: 40 00 16 cd call 4000cc88 <_Watchdog_Insert> 40007158: 90 12 23 ec or %o0, 0x3ec, %o0 ! 4001ebec <_Watchdog_Ticks_chain> /* * _Thread_Start only fails if the thread was in the incorrect state */ if ( !status ) { 4000715c: 80 a4 60 00 cmp %l1, 0 40007160: 12 80 00 08 bne 40007180 40007164: 90 10 00 19 mov %i1, %o0 _POSIX_Threads_Free( the_thread ); 40007168: 7f ff ff 5d call 40006edc <_POSIX_Threads_Free> <== NOT EXECUTED 4000716c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 40007170: 7f ff ff 62 call 40006ef8 <_Thread_Enable_dispatch> <== NOT EXECUTED 40007174: 01 00 00 00 nop <== NOT EXECUTED 40007178: 81 c7 e0 08 ret <== NOT EXECUTED 4000717c: 81 e8 00 00 restore <== NOT EXECUTED /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 40007180: c2 06 60 08 ld [ %i1 + 8 ], %g1 _Thread_Enable_dispatch(); 40007184: b0 10 20 00 clr %i0 40007188: 7f ff ff 5c call 40006ef8 <_Thread_Enable_dispatch> 4000718c: c2 25 80 00 st %g1, [ %l6 ] 40007190: 81 c7 e0 08 ret 40007194: 81 e8 00 00 restore return 0; 40007198: b0 10 20 16 mov 0x16, %i0 } 4000719c: 81 c7 e0 08 ret 400071a0: 81 e8 00 00 restore 400065e0 : #include int pthread_detach( pthread_t thread ) { 400065e0: 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 *) 400065e4: 11 10 00 5f sethi %hi(0x40017c00), %o0 400065e8: 92 10 00 18 mov %i0, %o1 400065ec: 90 12 22 88 or %o0, 0x288, %o0 400065f0: 40 00 0b ff call 400095ec <_Objects_Get> 400065f4: 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 ) { 400065f8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400065fc: 80 a0 60 00 cmp %g1, 0 40006600: 22 80 00 06 be,a 40006618 40006604: c2 02 21 70 ld [ %o0 + 0x170 ], %g1 40006608: 80 a0 60 02 cmp %g1, 2 4000660c: 08 80 00 13 bleu 40006658 40006610: 90 10 20 03 mov 3, %o0 40006614: 30 80 00 0f b,a 40006650 <== NOT EXECUTED case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->detachstate = PTHREAD_CREATE_DETACHED; 40006618: 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 ) 4000661c: 05 10 00 5e sethi %hi(0x40017800), %g2 40006620: c2 00 a3 a0 ld [ %g2 + 0x3a0 ], %g1 ! 40017ba0 <_Thread_Dispatch_disable_level> 40006624: 90 10 20 00 clr %o0 40006628: 82 00 7f ff add %g1, -1, %g1 4000662c: c2 20 a3 a0 st %g1, [ %g2 + 0x3a0 ] 40006630: c2 00 a3 a0 ld [ %g2 + 0x3a0 ], %g1 40006634: 80 a0 60 00 cmp %g1, 0 40006638: 12 80 00 08 bne 40006658 4000663c: 01 00 00 00 nop _Thread_Dispatch(); 40006640: 40 00 10 a0 call 4000a8c0 <_Thread_Dispatch> 40006644: 01 00 00 00 nop 40006648: 10 80 00 04 b 40006658 4000664c: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40006650: 40 00 01 82 call 40006c58 <== NOT EXECUTED 40006654: 01 00 00 00 nop <== NOT EXECUTED } 40006658: 81 c7 e0 08 ret 4000665c: 91 e8 00 08 restore %g0, %o0, %o0 4000e948 : #include void pthread_exit( void *value_ptr ) { 4000e948: 9d e3 bf 98 save %sp, -104, %sp Objects_Information *the_information; the_information = _Objects_Get_information( _Thread_Executing->Object.id ); 4000e94c: 25 10 00 6b sethi %hi(0x4001ac00), %l2 4000e950: c2 04 a2 ac ld [ %l2 + 0x2ac ], %g1 ! 4001aeac <_Thread_Executing> 4000e954: 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 ]; 4000e958: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000e95c: 85 30 e0 16 srl %g3, 0x16, %g2 4000e960: 82 10 61 30 or %g1, 0x130, %g1 4000e964: 84 08 a0 1c and %g2, 0x1c, %g2 4000e968: c2 00 40 02 ld [ %g1 + %g2 ], %g1 4000e96c: 87 30 e0 1b srl %g3, 0x1b, %g3 4000e970: 87 28 e0 02 sll %g3, 2, %g3 4000e974: e2 00 40 03 ld [ %g1 + %g3 ], %l1 /* This should never happen if _Thread_Get() works right */ assert( the_information ); 4000e978: 80 a4 60 00 cmp %l1, 0 4000e97c: 12 80 00 09 bne 4000e9a0 4000e980: 21 10 00 6b sethi %hi(0x4001ac00), %l0 4000e984: 11 10 00 64 sethi %hi(0x40019000), %o0 <== NOT EXECUTED 4000e988: 15 10 00 64 sethi %hi(0x40019000), %o2 <== NOT EXECUTED 4000e98c: 90 12 22 c0 or %o0, 0x2c0, %o0 <== NOT EXECUTED 4000e990: 94 12 a3 08 or %o2, 0x308, %o2 <== NOT EXECUTED 4000e994: 7f ff d0 f0 call 40002d54 <__assert> <== NOT EXECUTED 4000e998: 92 10 20 25 mov 0x25, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000e99c: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== NOT EXECUTED 4000e9a0: c2 04 21 d0 ld [ %l0 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 4000e9a4: 82 00 60 01 inc %g1 4000e9a8: c2 24 21 d0 st %g1, [ %l0 + 0x1d0 ] _Thread_Disable_dispatch(); _Thread_Executing->Wait.return_argument = value_ptr; 4000e9ac: d2 04 a2 ac ld [ %l2 + 0x2ac ], %o1 _Thread_Close( the_information, _Thread_Executing ); 4000e9b0: 90 10 00 11 mov %l1, %o0 4000e9b4: 7f ff eb 89 call 400097d8 <_Thread_Close> 4000e9b8: 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 ); 4000e9bc: d2 04 a2 ac ld [ %l2 + 0x2ac ], %o1 4000e9c0: 11 10 00 6c sethi %hi(0x4001b000), %o0 4000e9c4: 7f ff e6 d4 call 40008514 <_Objects_Free> 4000e9c8: 90 12 20 b8 or %o0, 0xb8, %o0 ! 4001b0b8 <_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 ) 4000e9cc: c2 04 21 d0 ld [ %l0 + 0x1d0 ], %g1 4000e9d0: 82 00 7f ff add %g1, -1, %g1 4000e9d4: c2 24 21 d0 st %g1, [ %l0 + 0x1d0 ] 4000e9d8: c2 04 21 d0 ld [ %l0 + 0x1d0 ], %g1 4000e9dc: 80 a0 60 00 cmp %g1, 0 4000e9e0: 12 80 00 04 bne 4000e9f0 4000e9e4: 01 00 00 00 nop _Thread_Dispatch(); 4000e9e8: 7f ff ec 01 call 400099ec <_Thread_Dispatch> 4000e9ec: 81 e8 00 00 restore 4000e9f0: 81 c7 e0 08 ret <== NOT EXECUTED 4000e9f4: 81 e8 00 00 restore <== NOT EXECUTED 40008b68 : int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { 40008b68: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 40008b6c: 80 a6 60 00 cmp %i1, 0 40008b70: 02 80 00 05 be 40008b84 40008b74: 92 10 00 18 mov %i0, %o1 40008b78: 80 a6 a0 00 cmp %i2, 0 40008b7c: 32 80 00 04 bne,a 40008b8c 40008b80: 11 10 00 6c sethi %hi(0x4001b000), %o0 40008b84: 10 80 00 27 b 40008c20 40008b88: 90 10 20 16 mov 0x16, %o0 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 40008b8c: 94 07 bf f4 add %fp, -12, %o2 40008b90: 40 00 0c 13 call 4000bbdc <_Objects_Get> 40008b94: 90 12 23 a8 or %o0, 0x3a8, %o0 return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 40008b98: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008b9c: 80 a0 60 00 cmp %g1, 0 40008ba0: 02 80 00 06 be 40008bb8 40008ba4: b0 10 00 08 mov %o0, %i0 40008ba8: 80 a0 60 02 cmp %g1, 2 40008bac: 08 80 00 1d bleu 40008c20 40008bb0: 90 10 20 03 mov 3, %o0 40008bb4: 30 80 00 19 b,a 40008c18 <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 40008bb8: d2 02 21 70 ld [ %o0 + 0x170 ], %o1 if ( policy ) *policy = api->schedpolicy; if ( param ) { *param = api->schedparam; 40008bbc: 94 10 20 18 mov 0x18, %o2 case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( policy ) *policy = api->schedpolicy; 40008bc0: c2 02 60 7c ld [ %o1 + 0x7c ], %g1 if ( param ) { *param = api->schedparam; 40008bc4: 90 10 00 1a mov %i2, %o0 case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( policy ) *policy = api->schedpolicy; 40008bc8: c2 26 40 00 st %g1, [ %i1 ] if ( param ) { *param = api->schedparam; 40008bcc: 40 00 28 05 call 40012be0 40008bd0: 92 02 60 80 add %o1, 0x80, %o1 param->sched_priority = 40008bd4: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 40008bd8: 82 10 20 ff mov 0xff, %g1 40008bdc: 82 20 40 02 sub %g1, %g2, %g1 40008be0: 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 ) 40008be4: 05 10 00 6c sethi %hi(0x4001b000), %g2 40008be8: c2 00 a0 c0 ld [ %g2 + 0xc0 ], %g1 ! 4001b0c0 <_Thread_Dispatch_disable_level> 40008bec: 90 10 20 00 clr %o0 40008bf0: 82 00 7f ff add %g1, -1, %g1 40008bf4: c2 20 a0 c0 st %g1, [ %g2 + 0xc0 ] 40008bf8: c2 00 a0 c0 ld [ %g2 + 0xc0 ], %g1 40008bfc: 80 a0 60 00 cmp %g1, 0 40008c00: 12 80 00 08 bne 40008c20 40008c04: 01 00 00 00 nop _Thread_Dispatch(); 40008c08: 40 00 10 aa call 4000ceb0 <_Thread_Dispatch> 40008c0c: 01 00 00 00 nop 40008c10: 10 80 00 04 b 40008c20 40008c14: 90 10 20 00 clr %o0 ! 0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40008c18: 40 00 01 8c call 40009248 <== NOT EXECUTED 40008c1c: 01 00 00 00 nop <== NOT EXECUTED } 40008c20: 81 c7 e0 08 ret 40008c24: 91 e8 00 08 restore %g0, %o0, %o0 400065e8 : */ void *pthread_getspecific( pthread_key_t key ) { 400065e8: 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 *) 400065ec: 11 10 00 60 sethi %hi(0x40018000), %o0 400065f0: 92 10 00 18 mov %i0, %o1 400065f4: 90 12 22 c0 or %o0, 0x2c0, %o0 400065f8: 40 00 0c a5 call 4000988c <_Objects_Get> 400065fc: 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 ) { 40006600: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006604: 80 a0 60 00 cmp %g1, 0 40006608: 22 80 00 06 be,a 40006620 4000660c: 03 10 00 5f sethi %hi(0x40017c00), %g1 40006610: 80 a0 60 02 cmp %g1, 2 40006614: 08 80 00 18 bleu 40006674 40006618: b0 10 20 00 clr %i0 4000661c: 30 80 00 18 b,a 4000667c <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never happen */ return NULL; case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 40006620: c2 00 62 9c ld [ %g1 + 0x29c ], %g1 40006624: c4 00 60 08 ld [ %g1 + 8 ], %g2 index = _Objects_Get_index( _Thread_Executing->Object.id ); key_data = (void *) the_key->Values[ api ][ index ]; 40006628: 83 30 a0 16 srl %g2, 0x16, %g1 4000662c: 82 08 60 1c and %g1, 0x1c, %g1 40006630: 82 00 40 08 add %g1, %o0, %g1 40006634: c6 00 60 18 ld [ %g1 + 0x18 ], %g3 40006638: 03 00 00 3f sethi %hi(0xfc00), %g1 4000663c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40006640: 84 08 80 01 and %g2, %g1, %g2 40006644: 85 28 a0 02 sll %g2, 2, %g2 40006648: f0 00 c0 02 ld [ %g3 + %g2 ], %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000664c: 05 10 00 5f sethi %hi(0x40017c00), %g2 40006650: c2 00 a1 c0 ld [ %g2 + 0x1c0 ], %g1 ! 40017dc0 <_Thread_Dispatch_disable_level> 40006654: 82 00 7f ff add %g1, -1, %g1 40006658: c2 20 a1 c0 st %g1, [ %g2 + 0x1c0 ] 4000665c: c2 00 a1 c0 ld [ %g2 + 0x1c0 ], %g1 40006660: 80 a0 60 00 cmp %g1, 0 40006664: 12 80 00 08 bne 40006684 40006668: 01 00 00 00 nop _Thread_Dispatch(); 4000666c: 40 00 11 3d call 4000ab60 <_Thread_Dispatch> 40006670: 01 00 00 00 nop 40006674: 81 c7 e0 08 ret 40006678: 81 e8 00 00 restore _Thread_Enable_dispatch(); return key_data; } (void) POSIX_BOTTOM_REACHED(); 4000667c: 40 00 02 1f call 40006ef8 <== NOT EXECUTED 40006680: b0 10 20 00 clr %i0 <== NOT EXECUTED return (void *)NULL; } 40006684: 81 c7 e0 08 ret <== NOT EXECUTED 40006688: 81 e8 00 00 restore <== NOT EXECUTED 4000807c : int pthread_join( pthread_t thread, void **value_ptr ) { 4000807c: 9d e3 bf 90 save %sp, -112, %sp 40008080: 11 10 00 69 sethi %hi(0x4001a400), %o0 40008084: 92 10 00 18 mov %i0, %o1 40008088: 90 12 21 38 or %o0, 0x138, %o0 4000808c: 40 00 0b d0 call 4000afcc <_Objects_Get> 40008090: 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 ) { 40008094: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008098: 80 a0 60 00 cmp %g1, 0 4000809c: 22 80 00 06 be,a 400080b4 400080a0: c4 02 21 70 ld [ %o0 + 0x170 ], %g2 400080a4: 80 a0 60 02 cmp %g1, 2 400080a8: 08 80 00 25 bleu 4000813c 400080ac: 90 10 20 03 mov 3, %o0 400080b0: 30 80 00 21 b,a 40008134 <== NOT EXECUTED case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { 400080b4: c2 00 a0 38 ld [ %g2 + 0x38 ], %g1 400080b8: 80 a0 60 00 cmp %g1, 0 400080bc: 12 80 00 06 bne 400080d4 400080c0: 03 10 00 68 sethi %hi(0x4001a000), %g1 _Thread_Enable_dispatch(); 400080c4: 7f ff ff e1 call 40008048 <_Thread_Enable_dispatch> 400080c8: 01 00 00 00 nop 400080cc: 10 80 00 1c b 4000813c 400080d0: 90 10 20 16 mov 0x16, %o0 ! 16 RTEMS_INLINE_ROUTINE boolean _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 400080d4: c6 00 63 2c ld [ %g1 + 0x32c ], %g3 return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { 400080d8: 80 a2 00 03 cmp %o0, %g3 400080dc: 12 80 00 06 bne 400080f4 400080e0: 82 07 bf f0 add %fp, -16, %g1 _Thread_Enable_dispatch(); 400080e4: 7f ff ff d9 call 40008048 <_Thread_Enable_dispatch> 400080e8: 01 00 00 00 nop 400080ec: 10 80 00 14 b 4000813c 400080f0: 90 10 20 2d mov 0x2d, %o0 ! 2d _Thread_Executing->Wait.return_argument = &return_pointer; _Thread_queue_Enter_critical_section( &api->Join_List ); _Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT ); 400080f4: 90 00 a0 3c add %g2, 0x3c, %o0 /* * Put ourself on the threads join list */ _Thread_Executing->Wait.return_argument = &return_pointer; 400080f8: c2 20 e0 28 st %g1, [ %g3 + 0x28 ] _Thread_queue_Enter_critical_section( &api->Join_List ); _Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT ); 400080fc: 92 10 20 00 clr %o1 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 40008100: 82 10 20 01 mov 1, %g1 40008104: 15 10 00 33 sethi %hi(0x4000cc00), %o2 40008108: 94 12 a0 d8 or %o2, 0xd8, %o2 ! 4000ccd8 <_Thread_queue_Timeout> 4000810c: 40 00 11 cd call 4000c840 <_Thread_queue_Enqueue_with_handler> 40008110: c2 20 a0 6c st %g1, [ %g2 + 0x6c ] _Thread_Enable_dispatch(); 40008114: 7f ff ff cd call 40008048 <_Thread_Enable_dispatch> 40008118: 01 00 00 00 nop if ( value_ptr ) 4000811c: 80 a6 60 00 cmp %i1, 0 40008120: 02 80 00 07 be 4000813c 40008124: 90 10 20 00 clr %o0 *value_ptr = return_pointer; 40008128: c2 07 bf f0 ld [ %fp + -16 ], %g1 4000812c: 10 80 00 04 b 4000813c 40008130: c2 26 40 00 st %g1, [ %i1 ] return 0; } return POSIX_BOTTOM_REACHED(); 40008134: 40 00 01 41 call 40008638 <== NOT EXECUTED 40008138: 01 00 00 00 nop <== NOT EXECUTED } 4000813c: 81 c7 e0 08 ret 40008140: 91 e8 00 08 restore %g0, %o0, %o0 40006380 : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 40006380: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006384: 03 10 00 5f sethi %hi(0x40017c00), %g1 40006388: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 40017dc0 <_Thread_Dispatch_disable_level> 4000638c: 84 00 a0 01 inc %g2 40006390: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] * _POSIX_Keys_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void ) { return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information ); 40006394: 11 10 00 60 sethi %hi(0x40018000), %o0 40006398: 40 00 0b f9 call 4000937c <_Objects_Allocate> 4000639c: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 400182c0 <_POSIX_Keys_Information> _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 400063a0: a0 92 20 00 orcc %o0, 0, %l0 400063a4: 12 80 00 06 bne 400063bc 400063a8: 03 10 00 5f sethi %hi(0x40017c00), %g1 _Thread_Enable_dispatch(); 400063ac: 7f ff ff e8 call 4000634c <_Thread_Enable_dispatch> 400063b0: b0 10 20 0b mov 0xb, %i0 400063b4: 81 c7 e0 08 ret 400063b8: 81 e8 00 00 restore return EAGAIN; } the_key->destructor = destructor; 400063bc: f2 24 20 14 st %i1, [ %l0 + 0x14 ] for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] && 400063c0: aa 10 61 20 or %g1, 0x120, %l5 if ( !the_key ) { _Thread_Enable_dispatch(); return EAGAIN; } the_key->destructor = destructor; 400063c4: a2 10 00 10 mov %l0, %l1 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 400063c8: 03 10 00 5f sethi %hi(0x40017c00), %g1 400063cc: a6 10 20 01 mov 1, %l3 400063d0: a8 10 62 0c or %g1, 0x20c, %l4 for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] && 400063d4: a5 2c e0 02 sll %l3, 2, %l2 400063d8: c2 04 80 15 ld [ %l2 + %l5 ], %g1 400063dc: 80 a0 60 00 cmp %g1, 0 400063e0: 02 80 00 29 be 40006484 400063e4: 90 10 00 14 mov %l4, %o0 400063e8: c2 00 60 04 ld [ %g1 + 4 ], %g1 400063ec: 80 a0 60 00 cmp %g1, 0 400063f0: 22 80 00 26 be,a 40006488 400063f4: c0 24 60 1c clr [ %l1 + 0x1c ] <== NOT EXECUTED _Objects_Information_table[ the_api ][ 1 ] ) { bytes_to_allocate = sizeof( void * ) * 400063f8: c2 10 60 10 lduh [ %g1 + 0x10 ], %g1 400063fc: 82 00 60 01 inc %g1 40006400: b3 28 60 02 sll %g1, 2, %i1 40006404: 40 00 0a 86 call 40008e1c <_Heap_Allocate> 40006408: 92 10 00 19 mov %i1, %o1 (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { 4000640c: 82 92 20 00 orcc %o0, 0, %g1 40006410: 32 80 00 18 bne,a 40006470 40006414: c2 24 60 1c st %g1, [ %l1 + 0x1c ] 40006418: 82 04 a0 14 add %l2, 0x14, %g1 <== NOT EXECUTED 4000641c: b0 10 20 00 clr %i0 <== NOT EXECUTED 40006420: b2 04 00 01 add %l0, %g1, %i1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 40006424: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED 40006428: 10 80 00 05 b 4000643c <== NOT EXECUTED 4000642c: a2 10 62 0c or %g1, 0x20c, %l1 ! 40017e0c <_Workspace_Area> <== NOT EXECUTED 40006430: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED 40006434: 40 00 0a a1 call 40008eb8 <_Heap_Free> <== NOT EXECUTED 40006438: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 4000643c: b0 06 20 01 inc %i0 <== NOT EXECUTED for ( --the_api; the_api >= 1; 40006440: 80 a6 00 13 cmp %i0, %l3 <== NOT EXECUTED 40006444: 12 bf ff fb bne 40006430 <== NOT EXECUTED 40006448: b2 06 7f fc add %i1, -4, %i1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 4000644c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 40006450: 11 10 00 60 sethi %hi(0x40018000), %o0 <== NOT EXECUTED 40006454: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 400182c0 <_POSIX_Keys_Information> <== NOT EXECUTED 40006458: 40 00 0c cb call 40009784 <_Objects_Free> <== NOT EXECUTED 4000645c: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 40006460: 7f ff ff bb call 4000634c <_Thread_Enable_dispatch> <== NOT EXECUTED 40006464: 01 00 00 00 nop <== NOT EXECUTED 40006468: 81 c7 e0 08 ret <== NOT EXECUTED 4000646c: 81 e8 00 00 restore <== NOT EXECUTED return ENOMEM; } the_key->Values[ the_api ] = table; memset( table, '\0', bytes_to_allocate ); 40006470: 94 10 00 19 mov %i1, %o2 40006474: 40 00 29 21 call 400108f8 40006478: 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++ ) { 4000647c: 10 80 00 04 b 4000648c 40006480: a6 04 e0 01 inc %l3 } the_key->Values[ the_api ] = table; memset( table, '\0', bytes_to_allocate ); } else { the_key->Values[ the_api ] = NULL; 40006484: c0 24 60 1c clr [ %l1 + 0x1c ] * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 40006488: 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; 4000648c: 80 a4 e0 05 cmp %l3, 5 40006490: 12 bf ff d1 bne 400063d4 40006494: a2 04 60 04 add %l1, 4, %l1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006498: 03 10 00 60 sethi %hi(0x40018000), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000649c: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400064a0: 88 10 62 c0 or %g1, 0x2c0, %g4 400064a4: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 } } the_key->is_active = TRUE; 400064a8: 82 10 20 01 mov 1, %g1 400064ac: c2 24 20 10 st %g1, [ %l0 + 0x10 ] 400064b0: 03 00 00 3f sethi %hi(0xfc00), %g1 400064b4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400064b8: 82 08 c0 01 and %g3, %g1, %g1 400064bc: 80 a0 40 02 cmp %g1, %g2 400064c0: 38 80 00 06 bgu,a 400064d8 400064c4: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 400064c8: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 400064cc: 83 28 60 02 sll %g1, 2, %g1 400064d0: e0 20 80 01 st %l0, [ %g2 + %g1 ] _Objects_Open( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 400064d4: c2 04 20 08 ld [ %l0 + 8 ], %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; 400064d8: c0 24 20 0c clr [ %l0 + 0xc ] 400064dc: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 400064e0: 7f ff ff 9b call 4000634c <_Thread_Enable_dispatch> 400064e4: b0 10 20 00 clr %i0 return 0; } 400064e8: 81 c7 e0 08 ret 400064ec: 81 e8 00 00 restore 400064f0 : */ int pthread_key_delete( pthread_key_t key ) { 400064f0: 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 *) 400064f4: 92 10 00 18 mov %i0, %o1 400064f8: 94 07 bf f4 add %fp, -12, %o2 400064fc: 31 10 00 60 sethi %hi(0x40018000), %i0 40006500: 40 00 0c e3 call 4000988c <_Objects_Get> 40006504: 90 16 22 c0 or %i0, 0x2c0, %o0 ! 400182c0 <_POSIX_Keys_Information> register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 40006508: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000650c: 80 a0 60 00 cmp %g1, 0 40006510: 02 80 00 06 be 40006528 40006514: a0 10 00 08 mov %o0, %l0 40006518: 80 a0 60 02 cmp %g1, 2 4000651c: 08 80 00 31 bleu 400065e0 40006520: 90 10 20 16 mov 0x16, %o0 40006524: 30 80 00 2d b,a 400065d8 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006528: 90 16 22 c0 or %i0, 0x2c0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000652c: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006530: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40006534: 05 00 00 3f sethi %hi(0xfc00), %g2 40006538: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000653c: 82 08 40 02 and %g1, %g2, %g1 40006540: 80 a0 40 03 cmp %g1, %g3 40006544: 38 80 00 06 bgu,a 4000655c 40006548: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 4000654c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006550: 83 28 60 02 sll %g1, 2, %g1 40006554: c0 20 80 01 clr [ %g2 + %g1 ] 40006558: 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; 4000655c: 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; 40006560: c0 24 20 10 clr [ %l0 + 0x10 ] 40006564: a2 10 62 0c or %g1, 0x20c, %l1 40006568: b0 10 20 00 clr %i0 for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 4000656c: 82 04 00 18 add %l0, %i0, %g1 40006570: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 40006574: 80 a2 60 00 cmp %o1, 0 40006578: 02 80 00 04 be 40006588 4000657c: b0 06 20 04 add %i0, 4, %i0 40006580: 40 00 0a 4e call 40008eb8 <_Heap_Free> 40006584: 90 10 00 11 mov %l1, %o0 _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; 40006588: 80 a6 20 10 cmp %i0, 0x10 4000658c: 12 bf ff f9 bne 40006570 40006590: 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 ); 40006594: 92 10 00 10 mov %l0, %o1 40006598: 11 10 00 60 sethi %hi(0x40018000), %o0 4000659c: 40 00 0c 7a call 40009784 <_Objects_Free> 400065a0: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 400182c0 <_POSIX_Keys_Information> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400065a4: 05 10 00 5f sethi %hi(0x40017c00), %g2 400065a8: c2 00 a1 c0 ld [ %g2 + 0x1c0 ], %g1 ! 40017dc0 <_Thread_Dispatch_disable_level> 400065ac: 90 10 20 00 clr %o0 400065b0: 82 00 7f ff add %g1, -1, %g1 400065b4: c2 20 a1 c0 st %g1, [ %g2 + 0x1c0 ] 400065b8: c2 00 a1 c0 ld [ %g2 + 0x1c0 ], %g1 400065bc: 80 a0 60 00 cmp %g1, 0 400065c0: 12 80 00 08 bne 400065e0 400065c4: 01 00 00 00 nop _Thread_Dispatch(); 400065c8: 40 00 11 66 call 4000ab60 <_Thread_Dispatch> 400065cc: 01 00 00 00 nop 400065d0: 10 80 00 04 b 400065e0 400065d4: 90 10 20 00 clr %o0 ! 0 _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400065d8: 40 00 02 48 call 40006ef8 <== NOT EXECUTED 400065dc: 01 00 00 00 nop <== NOT EXECUTED } 400065e0: 81 c7 e0 08 ret 400065e4: 91 e8 00 08 restore %g0, %o0, %o0 40023670 : int pthread_kill( pthread_t thread, int sig ) { 40023670: 9d e3 bf 90 save %sp, -112, %sp POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 40023674: 80 a6 60 00 cmp %i1, 0 40023678: 02 80 00 06 be 40023690 4002367c: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 40023680: a0 06 7f ff add %i1, -1, %l0 40023684: 80 a4 20 1f cmp %l0, 0x1f 40023688: 28 80 00 06 bleu,a 400236a0 4002368c: 11 10 00 a7 sethi %hi(0x40029c00), %o0 rtems_set_errno_and_return_minus_one( EINVAL ); 40023690: 7f ff d0 16 call 400176e8 <__errno> 40023694: 01 00 00 00 nop 40023698: 10 80 00 0f b 400236d4 4002369c: 82 10 20 16 mov 0x16, %g1 ! 16 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 400236a0: 94 07 bf f4 add %fp, -12, %o2 400236a4: 7f ff a5 f5 call 4000ce78 <_Objects_Get> 400236a8: 90 12 23 94 or %o0, 0x394, %o0 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 ) { 400236ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 400236b0: 80 a0 60 00 cmp %g1, 0 400236b4: 02 80 00 0b be 400236e0 400236b8: b0 10 00 08 mov %o0, %i0 400236bc: 80 a0 60 02 cmp %g1, 2 400236c0: 18 80 00 29 bgu 40023764 400236c4: 01 00 00 00 nop case OBJECTS_ERROR: case OBJECTS_REMOTE: rtems_set_errno_and_return_minus_one( ESRCH ); 400236c8: 7f ff d0 08 call 400176e8 <__errno> 400236cc: 01 00 00 00 nop 400236d0: 82 10 20 03 mov 3, %g1 ! 3 400236d4: c2 22 00 00 st %g1, [ %o0 ] 400236d8: 10 80 00 25 b 4002376c 400236dc: 90 10 3f ff mov -1, %o0 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 400236e0: 83 2e 60 02 sll %i1, 2, %g1 400236e4: 85 2e 60 04 sll %i1, 4, %g2 400236e8: 84 20 80 01 sub %g2, %g1, %g2 400236ec: 03 10 00 a8 sethi %hi(0x4002a000), %g1 400236f0: 82 10 63 78 or %g1, 0x378, %g1 ! 4002a378 <_POSIX_signals_Vectors> 400236f4: 84 00 80 01 add %g2, %g1, %g2 400236f8: c2 00 a0 08 ld [ %g2 + 8 ], %g1 400236fc: 80 a0 60 01 cmp %g1, 1 40023700: 02 80 00 15 be 40023754 40023704: c6 02 21 70 ld [ %o0 + 0x170 ], %g3 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 40023708: c4 00 e0 c8 ld [ %g3 + 0xc8 ], %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 4002370c: 92 10 00 19 mov %i1, %o1 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 40023710: b2 10 20 01 mov 1, %i1 40023714: 83 2e 40 10 sll %i1, %l0, %g1 40023718: 84 10 80 01 or %g2, %g1, %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 4002371c: 94 10 20 00 clr %o2 40023720: 7f ff ff 82 call 40023528 <_POSIX_signals_Unblock_thread> 40023724: c4 20 e0 c8 st %g2, [ %g3 + 0xc8 ] the_thread->do_post_task_switch_extension = TRUE; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 40023728: 03 10 00 a7 sethi %hi(0x40029c00), %g1 4002372c: c2 00 61 24 ld [ %g1 + 0x124 ], %g1 ! 40029d24 <_ISR_Nest_level> 40023730: 80 a0 60 00 cmp %g1, 0 40023734: 02 80 00 08 be 40023754 40023738: f2 26 20 78 st %i1, [ %i0 + 0x78 ] 4002373c: 03 10 00 a7 sethi %hi(0x40029c00), %g1 40023740: c2 00 61 3c ld [ %g1 + 0x13c ], %g1 ! 40029d3c <_Thread_Executing> 40023744: 80 a6 00 01 cmp %i0, %g1 40023748: 12 80 00 03 bne 40023754 4002374c: 03 10 00 a7 sethi %hi(0x40029c00), %g1 _ISR_Signals_to_thread_executing = TRUE; 40023750: f2 20 61 e8 st %i1, [ %g1 + 0x1e8 ] ! 40029de8 <_ISR_Signals_to_thread_executing> <== NOT EXECUTED } _Thread_Enable_dispatch(); 40023754: 7f ff ff ba call 4002363c <_Thread_Enable_dispatch> 40023758: 01 00 00 00 nop 4002375c: 10 80 00 04 b 4002376c 40023760: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 40023764: 40 00 00 12 call 400237ac <== NOT EXECUTED 40023768: 01 00 00 00 nop <== NOT EXECUTED } 4002376c: 81 c7 e0 08 ret 40023770: 91 e8 00 08 restore %g0, %o0, %o0 40007edc : */ int pthread_mutex_destroy( pthread_mutex_t *mutex ) { 40007edc: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40007ee0: 80 a6 20 00 cmp %i0, 0 40007ee4: 02 80 00 0d be 40007f18 40007ee8: 82 10 20 02 mov 2, %g1 40007eec: c2 06 00 00 ld [ %i0 ], %g1 40007ef0: 80 a0 7f ff cmp %g1, -1 40007ef4: 32 80 00 0c bne,a 40007f24 40007ef8: d2 06 00 00 ld [ %i0 ], %o1 40007efc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40007f00: 40 00 00 7e call 400080f8 <== NOT EXECUTED 40007f04: 92 10 20 00 clr %o1 <== NOT EXECUTED 40007f08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007f0c: 22 80 00 06 be,a 40007f24 <== NOT EXECUTED 40007f10: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 40007f14: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40007f18: a0 10 20 00 clr %l0 <== NOT EXECUTED 40007f1c: 10 80 00 07 b 40007f38 <== NOT EXECUTED 40007f20: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 40007f24: 11 10 00 6d sethi %hi(0x4001b400), %o0 40007f28: 94 07 bf f4 add %fp, -12, %o2 40007f2c: 40 00 0f 2c call 4000bbdc <_Objects_Get> 40007f30: 90 12 21 24 or %o0, 0x124, %o0 40007f34: a0 10 00 08 mov %o0, %l0 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 40007f38: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007f3c: 80 a0 60 00 cmp %g1, 0 40007f40: 22 80 00 06 be,a 40007f58 40007f44: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 40007f48: 80 a0 60 02 cmp %g1, 2 40007f4c: 08 80 00 23 bleu 40007fd8 40007f50: 90 10 20 16 mov 0x16, %o0 40007f54: 30 80 00 1f b,a 40007fd0 <== NOT EXECUTED /* * 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 ) ) { 40007f58: 80 a0 60 00 cmp %g1, 0 40007f5c: 12 80 00 06 bne 40007f74 40007f60: 03 10 00 6d sethi %hi(0x4001b400), %g1 _Thread_Enable_dispatch(); 40007f64: 7f ff ff d1 call 40007ea8 <_Thread_Enable_dispatch> 40007f68: 01 00 00 00 nop 40007f6c: 10 80 00 1b b 40007fd8 40007f70: 90 10 20 10 mov 0x10, %o0 ! 10 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40007f74: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40007f78: b0 10 61 24 or %g1, 0x124, %i0 40007f7c: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 40007f80: 03 00 00 3f sethi %hi(0xfc00), %g1 40007f84: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40007f88: 82 08 c0 01 and %g3, %g1, %g1 40007f8c: 80 a0 40 02 cmp %g1, %g2 40007f90: 18 80 00 05 bgu 40007fa4 40007f94: 94 10 20 16 mov 0x16, %o2 information->local_table[ index ] = the_object; 40007f98: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 40007f9c: 83 28 60 02 sll %g1, 2, %g1 40007fa0: c0 20 80 01 clr [ %g2 + %g1 ] return EBUSY; } _Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object ); _CORE_mutex_Flush( 40007fa4: 90 04 20 14 add %l0, 0x14, %o0 40007fa8: 92 10 20 00 clr %o1 40007fac: 40 00 0b 21 call 4000ac30 <_CORE_mutex_Flush> 40007fb0: c0 24 20 0c clr [ %l0 + 0xc ] RTEMS_INLINE_ROUTINE void _POSIX_Mutex_Free ( POSIX_Mutex_Control *the_mutex ) { _Objects_Free( &_POSIX_Mutex_Information, &the_mutex->Object ); 40007fb4: 90 10 00 18 mov %i0, %o0 40007fb8: 40 00 0e c7 call 4000bad4 <_Objects_Free> 40007fbc: 92 10 00 10 mov %l0, %o1 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 40007fc0: 7f ff ff ba call 40007ea8 <_Thread_Enable_dispatch> 40007fc4: 01 00 00 00 nop 40007fc8: 10 80 00 04 b 40007fd8 40007fcc: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 40007fd0: 40 00 04 9e call 40009248 <== NOT EXECUTED 40007fd4: 01 00 00 00 nop <== NOT EXECUTED } 40007fd8: 81 c7 e0 08 ret 40007fdc: 91 e8 00 08 restore %g0, %o0, %o0 40007fe0 : int pthread_mutex_getprioceiling( pthread_mutex_t *mutex, int *prioceiling ) { 40007fe0: 9d e3 bf 90 save %sp, -112, %sp register POSIX_Mutex_Control *the_mutex; Objects_Locations location; if ( !prioceiling ) 40007fe4: 80 a6 60 00 cmp %i1, 0 40007fe8: 02 80 00 33 be 400080b4 40007fec: 80 a6 20 00 cmp %i0, 0 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40007ff0: 02 80 00 0d be 40008024 40007ff4: 82 10 20 02 mov 2, %g1 40007ff8: c2 06 00 00 ld [ %i0 ], %g1 40007ffc: 80 a0 7f ff cmp %g1, -1 40008000: 32 80 00 0c bne,a 40008030 40008004: d2 06 00 00 ld [ %i0 ], %o1 40008008: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000800c: 40 00 00 3b call 400080f8 <== NOT EXECUTED 40008010: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008014: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40008018: 22 80 00 06 be,a 40008030 <== NOT EXECUTED 4000801c: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 40008020: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40008024: 90 10 20 00 clr %o0 <== NOT EXECUTED 40008028: 10 80 00 06 b 40008040 <== NOT EXECUTED 4000802c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 40008030: 11 10 00 6d sethi %hi(0x4001b400), %o0 40008034: 94 07 bf f4 add %fp, -12, %o2 40008038: 40 00 0e e9 call 4000bbdc <_Objects_Get> 4000803c: 90 12 21 24 or %o0, 0x124, %o0 return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 40008040: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008044: 80 a0 60 00 cmp %g1, 0 40008048: 22 80 00 07 be,a 40008064 4000804c: c4 02 20 60 ld [ %o0 + 0x60 ], %g2 40008050: 80 a0 60 02 cmp %g1, 2 40008054: 18 80 00 14 bgu 400080a4 40008058: 90 10 20 16 mov 0x16, %o0 ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000805c: 81 c7 e0 08 ret 40008060: 91 e8 00 08 restore %g0, %o0, %o0 return POSIX_MP_NOT_IMPLEMENTED(); /* XXX feels questionable */ #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( 40008064: 82 10 20 ff mov 0xff, %g1 40008068: 82 20 40 02 sub %g1, %g2, %g1 4000806c: 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 ) 40008070: 05 10 00 6c sethi %hi(0x4001b000), %g2 40008074: c2 00 a0 c0 ld [ %g2 + 0xc0 ], %g1 ! 4001b0c0 <_Thread_Dispatch_disable_level> 40008078: 90 10 20 00 clr %o0 4000807c: 82 00 7f ff add %g1, -1, %g1 40008080: c2 20 a0 c0 st %g1, [ %g2 + 0xc0 ] 40008084: c2 00 a0 c0 ld [ %g2 + 0xc0 ], %g1 40008088: 80 a0 60 00 cmp %g1, 0 4000808c: 32 80 00 0c bne,a 400080bc 40008090: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 40008094: 40 00 13 87 call 4000ceb0 <_Thread_Dispatch> 40008098: 01 00 00 00 nop 4000809c: 10 80 00 07 b 400080b8 400080a0: 90 10 20 00 clr %o0 ! 0 the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400080a4: 40 00 04 69 call 40009248 <== NOT EXECUTED 400080a8: 01 00 00 00 nop <== NOT EXECUTED } 400080ac: 81 c7 e0 08 ret <== NOT EXECUTED 400080b0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400080b4: 90 10 20 16 mov 0x16, %o0 } 400080b8: b0 10 00 08 mov %o0, %i0 400080bc: 81 c7 e0 08 ret 400080c0: 81 e8 00 00 restore 400080f8 : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 400080f8: 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; 400080fc: 03 10 00 64 sethi %hi(0x40019000), %g1 40008100: 80 a6 60 00 cmp %i1, 0 40008104: 02 80 00 03 be 40008110 40008108: a0 10 61 7c or %g1, 0x17c, %l0 4000810c: a0 10 00 19 mov %i1, %l0 else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 40008110: 80 a6 20 00 cmp %i0, 0 40008114: 22 80 00 2e be,a 400081cc 40008118: b0 10 20 16 mov 0x16, %i0 return EBUSY; } } #endif if ( !the_attr->is_initialized ) 4000811c: c2 04 00 00 ld [ %l0 ], %g1 40008120: 80 a0 60 00 cmp %g1, 0 40008124: 22 80 00 2a be,a 400081cc 40008128: b0 10 20 16 mov 0x16, %i0 /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 4000812c: c2 04 20 04 ld [ %l0 + 4 ], %g1 40008130: 80 a0 60 00 cmp %g1, 0 40008134: 22 80 00 09 be,a 40008158 40008138: c2 04 20 0c ld [ %l0 + 0xc ], %g1 4000813c: 11 10 00 64 sethi %hi(0x40019000), %o0 <== NOT EXECUTED 40008140: 15 10 00 64 sethi %hi(0x40019000), %o2 <== NOT EXECUTED 40008144: 90 12 21 90 or %o0, 0x190, %o0 <== NOT EXECUTED 40008148: 94 12 a1 d8 or %o2, 0x1d8, %o2 <== NOT EXECUTED 4000814c: 7f ff f2 cd call 40004c80 <__assert> <== NOT EXECUTED 40008150: 92 10 20 64 mov 0x64, %o1 <== NOT EXECUTED /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 40008154: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED 40008158: 80 a0 60 01 cmp %g1, 1 4000815c: 02 80 00 08 be 4000817c 40008160: 80 a0 60 02 cmp %g1, 2 40008164: 02 80 00 08 be 40008184 40008168: 80 a0 60 00 cmp %g1, 0 4000816c: 02 80 00 07 be 40008188 40008170: a2 10 20 00 clr %l1 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return 0; 40008174: 81 c7 e0 08 ret 40008178: 91 e8 20 16 restore %g0, 0x16, %o0 /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 4000817c: 10 80 00 03 b 40008188 40008180: a2 10 20 02 mov 2, %l1 40008184: a2 10 20 03 mov 3, %l1 break; default: return EINVAL; } if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 40008188: c2 04 20 08 ld [ %l0 + 8 ], %g1 4000818c: 82 00 7f ff add %g1, -1, %g1 40008190: 80 a0 60 fd cmp %g1, 0xfd 40008194: 38 80 00 0e bgu,a 400081cc 40008198: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000819c: 03 10 00 6c sethi %hi(0x4001b000), %g1 400081a0: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 4001b0c0 <_Thread_Dispatch_disable_level> 400081a4: 84 00 a0 01 inc %g2 400081a8: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ] * _POSIX_Mutex_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void ) { return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information ); 400081ac: 11 10 00 6d sethi %hi(0x4001b400), %o0 400081b0: 40 00 0d 47 call 4000b6cc <_Objects_Allocate> 400081b4: 90 12 21 24 or %o0, 0x124, %o0 ! 4001b524 <_POSIX_Mutex_Information> _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 400081b8: b2 92 20 00 orcc %o0, 0, %i1 400081bc: 32 80 00 06 bne,a 400081d4 400081c0: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Thread_Enable_dispatch(); 400081c4: 7f ff ff c0 call 400080c4 <_Thread_Enable_dispatch> 400081c8: b0 10 20 0b mov 0xb, %i0 400081cc: 81 c7 e0 08 ret 400081d0: 81 e8 00 00 restore _Thread_Enable_dispatch(); return EAGAIN; } #endif the_mutex->process_shared = the_attr->process_shared; 400081d4: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_mutex_attr = &the_mutex->Mutex.Attributes; if ( the_attr->recursive ) 400081d8: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 400081dc: 80 a0 60 00 cmp %g1, 0 400081e0: 02 80 00 04 be 400081f0 400081e4: 82 10 20 01 mov 1, %g1 the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 400081e8: 10 80 00 03 b 400081f4 <== NOT EXECUTED 400081ec: c0 26 60 54 clr [ %i1 + 0x54 ] <== NOT EXECUTED else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; 400081f0: c2 26 60 54 st %g1, [ %i1 + 0x54 ] the_mutex_attr->only_owner_release = TRUE; the_mutex_attr->priority_ceiling = 400081f4: c4 04 20 08 ld [ %l0 + 8 ], %g2 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; 400081f8: 82 10 20 01 mov 1, %g1 400081fc: c2 26 60 58 st %g1, [ %i1 + 0x58 ] the_mutex_attr->priority_ceiling = 40008200: 82 10 20 ff mov 0xff, %g1 40008204: 82 20 40 02 sub %g1, %g2, %g1 _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 40008208: e2 26 60 5c st %l1, [ %i1 + 0x5c ] 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; the_mutex_attr->priority_ceiling = 4000820c: c2 26 60 60 st %g1, [ %i1 + 0x60 ] /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 40008210: 90 06 60 14 add %i1, 0x14, %o0 40008214: 92 06 60 54 add %i1, 0x54, %o1 40008218: 40 00 0a 8a call 4000ac40 <_CORE_mutex_Initialize> 4000821c: 94 10 20 01 mov 1, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40008220: 03 10 00 6d sethi %hi(0x4001b400), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40008224: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40008228: 88 10 61 24 or %g1, 0x124, %g4 4000822c: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 40008230: 03 00 00 3f sethi %hi(0xfc00), %g1 40008234: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40008238: 82 08 c0 01 and %g3, %g1, %g1 4000823c: 80 a0 40 02 cmp %g1, %g2 40008240: 38 80 00 06 bgu,a 40008258 40008244: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 40008248: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 4000824c: 83 28 60 02 sll %g1, 2, %g1 40008250: 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; 40008254: c2 06 60 08 ld [ %i1 + 8 ], %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; 40008258: c0 26 60 0c clr [ %i1 + 0xc ] 4000825c: c2 26 00 00 st %g1, [ %i0 ] 0, /* Name not used */ 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 40008260: 7f ff ff 99 call 400080c4 <_Thread_Enable_dispatch> 40008264: b0 10 20 00 clr %i0 40008268: 81 c7 e0 08 ret 4000826c: 81 e8 00 00 restore return 0; } 40008270: 81 c7 e0 08 ret <== NOT EXECUTED 40008274: 81 e8 00 00 restore <== NOT EXECUTED 40008530 : int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { 40008530: 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 ) 40008534: 80 a6 a0 00 cmp %i2, 0 40008538: 02 80 00 3f be 40008634 4000853c: 82 06 7f ff add %i1, -1, %g1 return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 40008540: 80 a0 60 fd cmp %g1, 0xfd 40008544: 18 80 00 3d bgu 40008638 40008548: a0 10 20 16 mov 0x16, %l0 /* * Must acquire the mutex before we can change it's ceiling */ status = pthread_mutex_lock( mutex ); 4000854c: 7f ff ff 4b call 40008278 40008550: 90 10 00 18 mov %i0, %o0 if ( status ) 40008554: a0 92 20 00 orcc %o0, 0, %l0 40008558: 12 80 00 38 bne 40008638 4000855c: 80 a6 20 00 cmp %i0, 0 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 40008560: 02 80 00 0d be 40008594 40008564: 82 10 20 02 mov 2, %g1 40008568: c2 06 00 00 ld [ %i0 ], %g1 4000856c: 80 a0 7f ff cmp %g1, -1 40008570: 32 80 00 0c bne,a 400085a0 40008574: d2 06 00 00 ld [ %i0 ], %o1 40008578: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000857c: 7f ff fe df call 400080f8 <== NOT EXECUTED 40008580: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008584: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40008588: 22 80 00 06 be,a 400085a0 <== NOT EXECUTED 4000858c: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 40008590: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40008594: 90 10 20 00 clr %o0 <== NOT EXECUTED 40008598: 10 80 00 06 b 400085b0 <== NOT EXECUTED 4000859c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 400085a0: 11 10 00 6d sethi %hi(0x4001b400), %o0 400085a4: 94 07 bf f4 add %fp, -12, %o2 400085a8: 40 00 0d 8d call 4000bbdc <_Objects_Get> 400085ac: 90 12 21 24 or %o0, 0x124, %o0 return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 400085b0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400085b4: 80 a0 60 00 cmp %g1, 0 400085b8: 22 80 00 07 be,a 400085d4 400085bc: c6 02 20 60 ld [ %o0 + 0x60 ], %g3 400085c0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 400085c4: 18 80 00 18 bgu 40008624 <== NOT EXECUTED 400085c8: 01 00 00 00 nop <== NOT EXECUTED #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400085cc: 10 80 00 1b b 40008638 <== NOT EXECUTED 400085d0: a0 10 20 16 mov 0x16, %l0 ! 16 <== NOT EXECUTED case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( 400085d4: 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( 400085d8: 82 10 20 ff mov 0xff, %g1 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 400085dc: 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( 400085e0: 82 20 40 03 sub %g1, %g3, %g1 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 400085e4: 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( 400085e8: c2 26 80 00 st %g1, [ %i2 ] the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( 400085ec: 94 10 20 00 clr %o2 400085f0: 40 00 09 e4 call 4000ad80 <_CORE_mutex_Surrender> 400085f4: 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 ) 400085f8: 05 10 00 6c sethi %hi(0x4001b000), %g2 400085fc: c2 00 a0 c0 ld [ %g2 + 0xc0 ], %g1 ! 4001b0c0 <_Thread_Dispatch_disable_level> 40008600: 82 00 7f ff add %g1, -1, %g1 40008604: c2 20 a0 c0 st %g1, [ %g2 + 0xc0 ] 40008608: c2 00 a0 c0 ld [ %g2 + 0xc0 ], %g1 4000860c: 80 a0 60 00 cmp %g1, 0 40008610: 12 80 00 0b bne 4000863c 40008614: b0 10 00 10 mov %l0, %i0 _Thread_Dispatch(); 40008618: 40 00 12 26 call 4000ceb0 <_Thread_Dispatch> 4000861c: 01 00 00 00 nop 40008620: 30 80 00 07 b,a 4000863c #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40008624: 40 00 03 09 call 40009248 <== NOT EXECUTED 40008628: 01 00 00 00 nop <== NOT EXECUTED 4000862c: 10 80 00 03 b 40008638 <== NOT EXECUTED 40008630: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 40008634: a0 10 20 16 mov 0x16, %l0 } 40008638: b0 10 00 10 mov %l0, %i0 4000863c: 81 c7 e0 08 ret 40008640: 81 e8 00 00 restore 40008644 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 40008644: 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 ); 40008648: 90 10 00 19 mov %i1, %o0 4000864c: 40 00 00 4b call 40008778 <_POSIX_Absolute_timeout_to_ticks> 40008650: 92 07 bf f4 add %fp, -12, %o1 switch ( status ) { 40008654: 80 a2 20 02 cmp %o0, 2 40008658: 28 80 00 07 bleu,a 40008674 4000865c: b2 10 20 00 clr %i1 <== NOT EXECUTED 40008660: 80 a2 20 03 cmp %o0, 3 40008664: 22 80 00 04 be,a 40008674 40008668: b2 10 20 01 mov 1, %i1 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 4000866c: 10 80 00 03 b 40008678 <== NOT EXECUTED 40008670: d4 07 bf f4 ld [ %fp + -12 ], %o2 <== NOT EXECUTED 40008674: d4 07 bf f4 ld [ %fp + -12 ], %o2 40008678: 90 10 00 18 mov %i0, %o0 4000867c: 7f ff ff 05 call 40008290 <_POSIX_Mutex_Lock_support> 40008680: 92 10 00 19 mov %i1, %o1 break; } } return lock_status; } 40008684: 81 c7 e0 08 ret 40008688: 91 e8 00 08 restore %g0, %o0, %o0 400086a4 : */ int pthread_mutex_unlock( pthread_mutex_t *mutex ) { 400086a4: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 400086a8: 80 a6 20 00 cmp %i0, 0 400086ac: 02 80 00 0d be 400086e0 400086b0: 82 10 20 02 mov 2, %g1 400086b4: c2 06 00 00 ld [ %i0 ], %g1 400086b8: 80 a0 7f ff cmp %g1, -1 400086bc: 32 80 00 0c bne,a 400086ec 400086c0: d2 06 00 00 ld [ %i0 ], %o1 400086c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400086c8: 7f ff fe 8c call 400080f8 <== NOT EXECUTED 400086cc: 92 10 20 00 clr %o1 <== NOT EXECUTED 400086d0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400086d4: 22 80 00 06 be,a 400086ec <== NOT EXECUTED 400086d8: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 400086dc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 400086e0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400086e4: 10 80 00 06 b 400086fc <== NOT EXECUTED 400086e8: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 400086ec: 11 10 00 6d sethi %hi(0x4001b400), %o0 400086f0: 94 07 bf f4 add %fp, -12, %o2 400086f4: 40 00 0d 3a call 4000bbdc <_Objects_Get> 400086f8: 90 12 21 24 or %o0, 0x124, %o0 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 400086fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008700: 80 a0 60 00 cmp %g1, 0 40008704: 22 80 00 06 be,a 4000871c 40008708: d2 02 20 08 ld [ %o0 + 8 ], %o1 4000870c: 80 a0 60 02 cmp %g1, 2 40008710: 08 80 00 17 bleu 4000876c 40008714: 90 10 20 16 mov 0x16, %o0 40008718: 30 80 00 13 b,a 40008764 <== NOT EXECUTED ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_mutex_Surrender( 4000871c: 94 10 20 00 clr %o2 40008720: 40 00 09 98 call 4000ad80 <_CORE_mutex_Surrender> 40008724: 90 02 20 14 add %o0, 0x14, %o0 40008728: 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 ) 4000872c: 03 10 00 6c sethi %hi(0x4001b000), %g1 40008730: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 4001b0c0 <_Thread_Dispatch_disable_level> 40008734: 84 00 bf ff add %g2, -1, %g2 40008738: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ] 4000873c: c2 00 60 c0 ld [ %g1 + 0xc0 ], %g1 40008740: 80 a0 60 00 cmp %g1, 0 40008744: 12 80 00 04 bne 40008754 40008748: 01 00 00 00 nop _Thread_Dispatch(); 4000874c: 40 00 11 d9 call 4000ceb0 <_Thread_Dispatch> 40008750: 01 00 00 00 nop #else NULL #endif ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); 40008754: 40 00 1f 19 call 400103b8 <_POSIX_Mutex_From_core_mutex_status> 40008758: 90 10 00 18 mov %i0, %o0 break; } return POSIX_BOTTOM_REACHED(); } 4000875c: 81 c7 e0 08 ret 40008760: 91 e8 00 08 restore %g0, %o0, %o0 ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); break; } return POSIX_BOTTOM_REACHED(); 40008764: 40 00 02 b9 call 40009248 <== NOT EXECUTED 40008768: 01 00 00 00 nop <== NOT EXECUTED } 4000876c: b0 10 00 08 mov %o0, %i0 40008770: 81 c7 e0 08 ret 40008774: 81 e8 00 00 restore 40006bf4 : */ int pthread_rwlock_destroy( pthread_rwlock_t *rwlock ) { 40006bf4: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock = NULL; Objects_Locations location; if ( !rwlock ) 40006bf8: 80 a6 20 00 cmp %i0, 0 40006bfc: 02 80 00 2d be 40006cb0 40006c00: 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( 40006c04: d2 06 00 00 ld [ %i0 ], %o1 40006c08: 94 07 bf f4 add %fp, -12, %o2 40006c0c: 40 00 0e f6 call 4000a7e4 <_Objects_Get> 40006c10: 90 14 23 6c or %l0, 0x36c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 40006c14: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006c18: 80 a0 60 00 cmp %g1, 0 40006c1c: 02 80 00 07 be 40006c38 40006c20: b0 10 00 08 mov %o0, %i0 40006c24: 80 a0 60 02 cmp %g1, 2 40006c28: 18 80 00 1e bgu 40006ca0 40006c2c: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40006c30: 81 c7 e0 08 ret 40006c34: 91 e8 00 08 restore %g0, %o0, %o0 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 ) { 40006c38: 40 00 16 2e call 4000c4f0 <_Thread_queue_First> 40006c3c: 90 02 20 10 add %o0, 0x10, %o0 40006c40: 80 a2 20 00 cmp %o0, 0 40006c44: 22 80 00 06 be,a 40006c5c 40006c48: 90 14 23 6c or %l0, 0x36c, %o0 _Thread_Enable_dispatch(); 40006c4c: 7f ff ff dd call 40006bc0 <_Thread_Enable_dispatch> 40006c50: 01 00 00 00 nop 40006c54: 10 80 00 18 b 40006cb4 40006c58: 90 10 20 10 mov 0x10, %o0 ! 10 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40006c5c: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006c60: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40006c64: 05 00 00 3f sethi %hi(0xfc00), %g2 40006c68: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40006c6c: 82 08 40 02 and %g1, %g2, %g1 40006c70: 80 a0 40 03 cmp %g1, %g3 40006c74: 18 80 00 05 bgu 40006c88 40006c78: 92 10 00 18 mov %i0, %o1 information->local_table[ index ] = the_object; 40006c7c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006c80: 83 28 60 02 sll %g1, 2, %g1 40006c84: c0 20 80 01 clr [ %g2 + %g1 ] */ RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free ( POSIX_RWLock_Control *the_RWLock ) { _Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object ); 40006c88: 40 00 0e 95 call 4000a6dc <_Objects_Free> 40006c8c: c0 26 20 0c clr [ %i0 + 0xc ] _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object ); _POSIX_RWLock_Free( the_rwlock ); _Thread_Enable_dispatch(); 40006c90: 7f ff ff cc call 40006bc0 <_Thread_Enable_dispatch> 40006c94: 01 00 00 00 nop 40006c98: 10 80 00 07 b 40006cb4 40006c9c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 40006ca0: 40 00 03 73 call 40007a6c <== NOT EXECUTED 40006ca4: 01 00 00 00 nop <== NOT EXECUTED } 40006ca8: 81 c7 e0 08 ret <== NOT EXECUTED 40006cac: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40006cb0: 90 10 20 16 mov 0x16, %o0 } 40006cb4: b0 10 00 08 mov %o0, %i0 40006cb8: 81 c7 e0 08 ret 40006cbc: 81 e8 00 00 restore 40006cf4 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 40006cf4: 9d e3 bf 88 save %sp, -120, %sp const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 40006cf8: 80 a6 20 00 cmp %i0, 0 40006cfc: 02 80 00 32 be 40006dc4 40006d00: a0 10 00 19 mov %i1, %l0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 40006d04: 80 a6 60 00 cmp %i1, 0 40006d08: 32 80 00 06 bne,a 40006d20 40006d0c: c2 04 00 00 ld [ %l0 ], %g1 the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 40006d10: a0 07 bf ec add %fp, -20, %l0 <== NOT EXECUTED 40006d14: 40 00 03 2c call 400079c4 <== NOT EXECUTED 40006d18: 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 ) 40006d1c: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED 40006d20: 80 a0 60 00 cmp %g1, 0 40006d24: 02 80 00 28 be 40006dc4 40006d28: 01 00 00 00 nop return EINVAL; switch ( the_attr->process_shared ) { 40006d2c: c2 04 20 04 ld [ %l0 + 4 ], %g1 40006d30: 80 a0 60 00 cmp %g1, 0 40006d34: 12 80 00 24 bne 40006dc4 40006d38: 05 10 00 76 sethi %hi(0x4001d800), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006d3c: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 ! 4001d8d0 <_Thread_Dispatch_disable_level> 40006d40: 82 00 60 01 inc %g1 40006d44: c2 20 a0 d0 st %g1, [ %g2 + 0xd0 ] * 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 *) 40006d48: 33 10 00 76 sethi %hi(0x4001d800), %i1 40006d4c: 40 00 0d 62 call 4000a2d4 <_Objects_Allocate> 40006d50: 90 16 63 6c or %i1, 0x36c, %o0 ! 4001db6c <_POSIX_RWLock_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 40006d54: a0 92 20 00 orcc %o0, 0, %l0 40006d58: 12 80 00 06 bne 40006d70 40006d5c: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); 40006d60: 7f ff ff d8 call 40006cc0 <_Thread_Enable_dispatch> 40006d64: b0 10 20 0b mov 0xb, %i0 40006d68: 81 c7 e0 08 ret 40006d6c: 81 e8 00 00 restore return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 40006d70: 40 00 0a 95 call 400097c4 <_CORE_RWLock_Initialize> 40006d74: 92 07 bf f4 add %fp, -12, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006d78: 90 16 63 6c or %i1, 0x36c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40006d7c: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006d80: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40006d84: 05 00 00 3f sethi %hi(0xfc00), %g2 40006d88: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40006d8c: 82 08 40 02 and %g1, %g2, %g1 40006d90: 80 a0 40 03 cmp %g1, %g3 40006d94: 38 80 00 06 bgu,a 40006dac 40006d98: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 40006d9c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006da0: 83 28 60 02 sll %g1, 2, %g1 40006da4: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 40006da8: c2 04 20 08 ld [ %l0 + 8 ], %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; 40006dac: c0 24 20 0c clr [ %l0 + 0xc ] 40006db0: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 40006db4: 7f ff ff c3 call 40006cc0 <_Thread_Enable_dispatch> 40006db8: b0 10 20 00 clr %i0 40006dbc: 81 c7 e0 08 ret 40006dc0: 81 e8 00 00 restore return 0; } 40006dc4: 81 c7 e0 08 ret 40006dc8: 91 e8 20 16 restore %g0, 0x16, %o0 40006dcc : */ int pthread_rwlock_rdlock( pthread_rwlock_t *rwlock ) { 40006dcc: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 40006dd0: 80 a6 20 00 cmp %i0, 0 40006dd4: 02 80 00 28 be 40006e74 40006dd8: 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( 40006ddc: d2 06 00 00 ld [ %i0 ], %o1 40006de0: 94 07 bf f4 add %fp, -12, %o2 40006de4: 40 00 0e 80 call 4000a7e4 <_Objects_Get> 40006de8: 90 12 23 6c or %o0, 0x36c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 40006dec: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006df0: 80 a0 60 00 cmp %g1, 0 40006df4: 22 80 00 07 be,a 40006e10 40006df8: d2 06 00 00 ld [ %i0 ], %o1 40006dfc: 80 a0 60 02 cmp %g1, 2 40006e00: 18 80 00 19 bgu 40006e64 40006e04: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40006e08: 81 c7 e0 08 ret 40006e0c: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 40006e10: 90 02 20 10 add %o0, 0x10, %o0 40006e14: 94 10 20 01 mov 1, %o2 40006e18: 96 10 20 00 clr %o3 40006e1c: 40 00 0a 75 call 400097f0 <_CORE_RWLock_Obtain_for_reading> 40006e20: 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 ) 40006e24: 03 10 00 76 sethi %hi(0x4001d800), %g1 40006e28: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 4001d8d0 <_Thread_Dispatch_disable_level> 40006e2c: 84 00 bf ff add %g2, -1, %g2 40006e30: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 40006e34: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 40006e38: 80 a0 60 00 cmp %g1, 0 40006e3c: 12 80 00 05 bne 40006e50 40006e40: 03 10 00 76 sethi %hi(0x4001d800), %g1 _Thread_Dispatch(); 40006e44: 40 00 13 1d call 4000bab8 <_Thread_Dispatch> 40006e48: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 40006e4c: 03 10 00 76 sethi %hi(0x4001d800), %g1 40006e50: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1 ! 4001d9ac <_Thread_Executing> 40006e54: 40 00 00 9a call 400070bc <_POSIX_RWLock_Translate_core_RWLock_return_code> 40006e58: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40006e5c: 81 c7 e0 08 ret 40006e60: 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(); 40006e64: 40 00 03 02 call 40007a6c <== NOT EXECUTED 40006e68: 01 00 00 00 nop <== NOT EXECUTED } 40006e6c: 81 c7 e0 08 ret <== NOT EXECUTED 40006e70: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40006e74: 90 10 20 16 mov 0x16, %o0 } 40006e78: b0 10 00 08 mov %o0, %i0 40006e7c: 81 c7 e0 08 ret 40006e80: 81 e8 00 00 restore 40006e84 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 40006e84: 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 ) 40006e88: 80 a6 20 00 cmp %i0, 0 40006e8c: 02 80 00 41 be 40006f90 40006e90: 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 ); 40006e94: 40 00 20 fc call 4000f284 <_POSIX_Absolute_timeout_to_ticks> 40006e98: 92 07 bf f0 add %fp, -16, %o1 switch (status) { 40006e9c: 80 a2 20 02 cmp %o0, 2 40006ea0: 08 80 00 07 bleu 40006ebc 40006ea4: b2 10 00 08 mov %o0, %i1 40006ea8: 80 a2 20 03 cmp %o0, 3 40006eac: 22 80 00 05 be,a 40006ec0 40006eb0: a0 10 20 01 mov 1, %l0 40006eb4: 10 80 00 04 b 40006ec4 <== NOT EXECUTED 40006eb8: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 40006ebc: a0 10 20 00 clr %l0 40006ec0: d2 06 00 00 ld [ %i0 ], %o1 40006ec4: 11 10 00 76 sethi %hi(0x4001d800), %o0 40006ec8: 94 07 bf f4 add %fp, -12, %o2 40006ecc: 40 00 0e 46 call 4000a7e4 <_Objects_Get> 40006ed0: 90 12 23 6c or %o0, 0x36c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 40006ed4: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006ed8: 80 a0 60 00 cmp %g1, 0 40006edc: 22 80 00 07 be,a 40006ef8 40006ee0: d2 06 00 00 ld [ %i0 ], %o1 40006ee4: 80 a0 60 02 cmp %g1, 2 40006ee8: 18 80 00 26 bgu 40006f80 40006eec: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40006ef0: 81 c7 e0 08 ret 40006ef4: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 40006ef8: d6 07 bf f0 ld [ %fp + -16 ], %o3 40006efc: 90 02 20 10 add %o0, 0x10, %o0 40006f00: 94 10 00 10 mov %l0, %o2 40006f04: 40 00 0a 3b call 400097f0 <_CORE_RWLock_Obtain_for_reading> 40006f08: 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 ) 40006f0c: 03 10 00 76 sethi %hi(0x4001d800), %g1 40006f10: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 4001d8d0 <_Thread_Dispatch_disable_level> 40006f14: 84 00 bf ff add %g2, -1, %g2 40006f18: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 40006f1c: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 40006f20: 80 a0 60 00 cmp %g1, 0 40006f24: 12 80 00 05 bne 40006f38 40006f28: 80 a4 20 00 cmp %l0, 0 _Thread_Dispatch(); 40006f2c: 40 00 12 e3 call 4000bab8 <_Thread_Dispatch> 40006f30: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 40006f34: 80 a4 20 00 cmp %l0, 0 40006f38: 12 80 00 0c bne 40006f68 40006f3c: 03 10 00 76 sethi %hi(0x4001d800), %g1 40006f40: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1 ! 4001d9ac <_Thread_Executing> <== NOT EXECUTED 40006f44: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 <== NOT EXECUTED 40006f48: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40006f4c: 12 80 00 07 bne 40006f68 <== NOT EXECUTED 40006f50: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 40006f54: 02 80 00 10 be 40006f94 <== NOT EXECUTED 40006f58: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 40006f5c: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED 40006f60: 08 80 00 0d bleu 40006f94 <== NOT EXECUTED 40006f64: 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( 40006f68: 03 10 00 76 sethi %hi(0x4001d800), %g1 40006f6c: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1 ! 4001d9ac <_Thread_Executing> 40006f70: 40 00 00 53 call 400070bc <_POSIX_RWLock_Translate_core_RWLock_return_code> 40006f74: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40006f78: 81 c7 e0 08 ret 40006f7c: 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(); 40006f80: 40 00 02 bb call 40007a6c <== NOT EXECUTED 40006f84: 01 00 00 00 nop <== NOT EXECUTED } 40006f88: 81 c7 e0 08 ret <== NOT EXECUTED 40006f8c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40006f90: 90 10 20 16 mov 0x16, %o0 } 40006f94: b0 10 00 08 mov %o0, %i0 40006f98: 81 c7 e0 08 ret 40006f9c: 81 e8 00 00 restore 40006fa0 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 40006fa0: 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 ) 40006fa4: 80 a6 20 00 cmp %i0, 0 40006fa8: 02 80 00 41 be 400070ac 40006fac: 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 ); 40006fb0: 40 00 20 b5 call 4000f284 <_POSIX_Absolute_timeout_to_ticks> 40006fb4: 92 07 bf f0 add %fp, -16, %o1 switch (status) { 40006fb8: 80 a2 20 02 cmp %o0, 2 40006fbc: 08 80 00 07 bleu 40006fd8 40006fc0: b2 10 00 08 mov %o0, %i1 40006fc4: 80 a2 20 03 cmp %o0, 3 40006fc8: 22 80 00 05 be,a 40006fdc 40006fcc: a0 10 20 01 mov 1, %l0 40006fd0: 10 80 00 04 b 40006fe0 <== NOT EXECUTED 40006fd4: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 40006fd8: a0 10 20 00 clr %l0 40006fdc: d2 06 00 00 ld [ %i0 ], %o1 40006fe0: 11 10 00 76 sethi %hi(0x4001d800), %o0 40006fe4: 94 07 bf f4 add %fp, -12, %o2 40006fe8: 40 00 0d ff call 4000a7e4 <_Objects_Get> 40006fec: 90 12 23 6c or %o0, 0x36c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 40006ff0: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006ff4: 80 a0 60 00 cmp %g1, 0 40006ff8: 22 80 00 07 be,a 40007014 40006ffc: d2 06 00 00 ld [ %i0 ], %o1 40007000: 80 a0 60 02 cmp %g1, 2 40007004: 18 80 00 26 bgu 4000709c 40007008: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 4000700c: 81 c7 e0 08 ret 40007010: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 40007014: d6 07 bf f0 ld [ %fp + -16 ], %o3 40007018: 90 02 20 10 add %o0, 0x10, %o0 4000701c: 94 10 00 10 mov %l0, %o2 40007020: 40 00 0a 28 call 400098c0 <_CORE_RWLock_Obtain_for_writing> 40007024: 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 ) 40007028: 03 10 00 76 sethi %hi(0x4001d800), %g1 4000702c: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 4001d8d0 <_Thread_Dispatch_disable_level> 40007030: 84 00 bf ff add %g2, -1, %g2 40007034: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 40007038: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 4000703c: 80 a0 60 00 cmp %g1, 0 40007040: 12 80 00 05 bne 40007054 40007044: 80 a4 20 00 cmp %l0, 0 _Thread_Dispatch(); 40007048: 40 00 12 9c call 4000bab8 <_Thread_Dispatch> 4000704c: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 40007050: 80 a4 20 00 cmp %l0, 0 40007054: 12 80 00 0c bne 40007084 40007058: 03 10 00 76 sethi %hi(0x4001d800), %g1 4000705c: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1 ! 4001d9ac <_Thread_Executing> <== NOT EXECUTED 40007060: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 <== NOT EXECUTED 40007064: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40007068: 12 80 00 07 bne 40007084 <== NOT EXECUTED 4000706c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 40007070: 02 80 00 10 be 400070b0 <== NOT EXECUTED 40007074: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 40007078: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED 4000707c: 08 80 00 0d bleu 400070b0 <== NOT EXECUTED 40007080: 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( 40007084: 03 10 00 76 sethi %hi(0x4001d800), %g1 40007088: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1 ! 4001d9ac <_Thread_Executing> 4000708c: 40 00 00 0c call 400070bc <_POSIX_RWLock_Translate_core_RWLock_return_code> 40007090: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40007094: 81 c7 e0 08 ret 40007098: 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(); 4000709c: 40 00 02 74 call 40007a6c <== NOT EXECUTED 400070a0: 01 00 00 00 nop <== NOT EXECUTED } 400070a4: 81 c7 e0 08 ret <== NOT EXECUTED 400070a8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 400070ac: 90 10 20 16 mov 0x16, %o0 } 400070b0: b0 10 00 08 mov %o0, %i0 400070b4: 81 c7 e0 08 ret 400070b8: 81 e8 00 00 restore 400070e4 : */ int pthread_rwlock_tryrdlock( pthread_rwlock_t *rwlock ) { 400070e4: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 400070e8: 80 a6 20 00 cmp %i0, 0 400070ec: 02 80 00 28 be 4000718c 400070f0: 11 10 00 76 sethi %hi(0x4001d800), %o0 400070f4: d2 06 00 00 ld [ %i0 ], %o1 400070f8: 94 07 bf f4 add %fp, -12, %o2 400070fc: 40 00 0d ba call 4000a7e4 <_Objects_Get> 40007100: 90 12 23 6c or %o0, 0x36c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 40007104: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007108: 80 a0 60 00 cmp %g1, 0 4000710c: 22 80 00 07 be,a 40007128 40007110: d2 06 00 00 ld [ %i0 ], %o1 40007114: 80 a0 60 02 cmp %g1, 2 40007118: 18 80 00 19 bgu 4000717c 4000711c: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40007120: 81 c7 e0 08 ret 40007124: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 40007128: 90 02 20 10 add %o0, 0x10, %o0 4000712c: 94 10 20 00 clr %o2 40007130: 96 10 20 00 clr %o3 40007134: 40 00 09 af call 400097f0 <_CORE_RWLock_Obtain_for_reading> 40007138: 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 ) 4000713c: 03 10 00 76 sethi %hi(0x4001d800), %g1 40007140: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 4001d8d0 <_Thread_Dispatch_disable_level> 40007144: 84 00 bf ff add %g2, -1, %g2 40007148: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 4000714c: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 40007150: 80 a0 60 00 cmp %g1, 0 40007154: 12 80 00 05 bne 40007168 40007158: 03 10 00 76 sethi %hi(0x4001d800), %g1 _Thread_Dispatch(); 4000715c: 40 00 12 57 call 4000bab8 <_Thread_Dispatch> 40007160: 01 00 00 00 nop NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 40007164: 03 10 00 76 sethi %hi(0x4001d800), %g1 40007168: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1 ! 4001d9ac <_Thread_Executing> 4000716c: 7f ff ff d4 call 400070bc <_POSIX_RWLock_Translate_core_RWLock_return_code> 40007170: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40007174: 81 c7 e0 08 ret 40007178: 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(); 4000717c: 40 00 02 3c call 40007a6c <== NOT EXECUTED 40007180: 01 00 00 00 nop <== NOT EXECUTED } 40007184: 81 c7 e0 08 ret <== NOT EXECUTED 40007188: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 4000718c: 90 10 20 16 mov 0x16, %o0 } 40007190: b0 10 00 08 mov %o0, %i0 40007194: 81 c7 e0 08 ret 40007198: 81 e8 00 00 restore 4000719c : */ int pthread_rwlock_trywrlock( pthread_rwlock_t *rwlock ) { 4000719c: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 400071a0: 80 a6 20 00 cmp %i0, 0 400071a4: 02 80 00 28 be 40007244 400071a8: 11 10 00 76 sethi %hi(0x4001d800), %o0 400071ac: d2 06 00 00 ld [ %i0 ], %o1 400071b0: 94 07 bf f4 add %fp, -12, %o2 400071b4: 40 00 0d 8c call 4000a7e4 <_Objects_Get> 400071b8: 90 12 23 6c or %o0, 0x36c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 400071bc: c2 07 bf f4 ld [ %fp + -12 ], %g1 400071c0: 80 a0 60 00 cmp %g1, 0 400071c4: 22 80 00 07 be,a 400071e0 400071c8: d2 06 00 00 ld [ %i0 ], %o1 400071cc: 80 a0 60 02 cmp %g1, 2 400071d0: 18 80 00 19 bgu 40007234 400071d4: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 400071d8: 81 c7 e0 08 ret 400071dc: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 400071e0: 90 02 20 10 add %o0, 0x10, %o0 400071e4: 94 10 20 00 clr %o2 400071e8: 96 10 20 00 clr %o3 400071ec: 40 00 09 b5 call 400098c0 <_CORE_RWLock_Obtain_for_writing> 400071f0: 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 ) 400071f4: 03 10 00 76 sethi %hi(0x4001d800), %g1 400071f8: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 4001d8d0 <_Thread_Dispatch_disable_level> 400071fc: 84 00 bf ff add %g2, -1, %g2 40007200: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 40007204: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 40007208: 80 a0 60 00 cmp %g1, 0 4000720c: 12 80 00 05 bne 40007220 40007210: 03 10 00 76 sethi %hi(0x4001d800), %g1 _Thread_Dispatch(); 40007214: 40 00 12 29 call 4000bab8 <_Thread_Dispatch> 40007218: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 4000721c: 03 10 00 76 sethi %hi(0x4001d800), %g1 40007220: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1 ! 4001d9ac <_Thread_Executing> 40007224: 7f ff ff a6 call 400070bc <_POSIX_RWLock_Translate_core_RWLock_return_code> 40007228: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 4000722c: 81 c7 e0 08 ret 40007230: 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(); 40007234: 40 00 02 0e call 40007a6c <== NOT EXECUTED 40007238: 01 00 00 00 nop <== NOT EXECUTED } 4000723c: 81 c7 e0 08 ret <== NOT EXECUTED 40007240: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 40007244: 90 10 20 16 mov 0x16, %o0 } 40007248: b0 10 00 08 mov %o0, %i0 4000724c: 81 c7 e0 08 ret 40007250: 81 e8 00 00 restore 40007254 : */ int pthread_rwlock_unlock( pthread_rwlock_t *rwlock ) { 40007254: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; CORE_RWLock_Status status; if ( !rwlock ) 40007258: 80 a6 20 00 cmp %i0, 0 4000725c: 02 80 00 23 be 400072e8 40007260: 11 10 00 76 sethi %hi(0x4001d800), %o0 40007264: d2 06 00 00 ld [ %i0 ], %o1 40007268: 94 07 bf f4 add %fp, -12, %o2 4000726c: 40 00 0d 5e call 4000a7e4 <_Objects_Get> 40007270: 90 12 23 6c or %o0, 0x36c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 40007274: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007278: 80 a0 60 00 cmp %g1, 0 4000727c: 02 80 00 06 be 40007294 40007280: 80 a0 60 02 cmp %g1, 2 40007284: 18 80 00 15 bgu 400072d8 40007288: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); } return POSIX_BOTTOM_REACHED(); } 4000728c: 81 c7 e0 08 ret 40007290: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_RWLock_Release( &the_rwlock->RWLock ); 40007294: 40 00 09 ad call 40009948 <_CORE_RWLock_Release> 40007298: 90 02 20 10 add %o0, 0x10, %o0 4000729c: 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 ) 400072a0: 03 10 00 76 sethi %hi(0x4001d800), %g1 400072a4: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 4001d8d0 <_Thread_Dispatch_disable_level> 400072a8: 84 00 bf ff add %g2, -1, %g2 400072ac: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 400072b0: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 400072b4: 80 a0 60 00 cmp %g1, 0 400072b8: 12 80 00 04 bne 400072c8 400072bc: 01 00 00 00 nop _Thread_Dispatch(); 400072c0: 40 00 11 fe call 4000bab8 <_Thread_Dispatch> 400072c4: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); 400072c8: 7f ff ff 7d call 400070bc <_POSIX_RWLock_Translate_core_RWLock_return_code> 400072cc: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 400072d0: 81 c7 e0 08 ret 400072d4: 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(); 400072d8: 40 00 01 e5 call 40007a6c <== NOT EXECUTED 400072dc: 01 00 00 00 nop <== NOT EXECUTED } 400072e0: 81 c7 e0 08 ret <== NOT EXECUTED 400072e4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED status = _CORE_RWLock_Release( &the_rwlock->RWLock ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 400072e8: 90 10 20 16 mov 0x16, %o0 } 400072ec: b0 10 00 08 mov %o0, %i0 400072f0: 81 c7 e0 08 ret 400072f4: 81 e8 00 00 restore 400072f8 : */ int pthread_rwlock_wrlock( pthread_rwlock_t *rwlock ) { 400072f8: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 400072fc: 80 a6 20 00 cmp %i0, 0 40007300: 02 80 00 28 be 400073a0 40007304: 11 10 00 76 sethi %hi(0x4001d800), %o0 40007308: d2 06 00 00 ld [ %i0 ], %o1 4000730c: 94 07 bf f4 add %fp, -12, %o2 40007310: 40 00 0d 35 call 4000a7e4 <_Objects_Get> 40007314: 90 12 23 6c or %o0, 0x36c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 40007318: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000731c: 80 a0 60 00 cmp %g1, 0 40007320: 22 80 00 07 be,a 4000733c 40007324: d2 06 00 00 ld [ %i0 ], %o1 40007328: 80 a0 60 02 cmp %g1, 2 4000732c: 18 80 00 19 bgu 40007390 40007330: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40007334: 81 c7 e0 08 ret 40007338: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 4000733c: 90 02 20 10 add %o0, 0x10, %o0 40007340: 94 10 20 01 mov 1, %o2 40007344: 96 10 20 00 clr %o3 40007348: 40 00 09 5e call 400098c0 <_CORE_RWLock_Obtain_for_writing> 4000734c: 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 ) 40007350: 03 10 00 76 sethi %hi(0x4001d800), %g1 40007354: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 4001d8d0 <_Thread_Dispatch_disable_level> 40007358: 84 00 bf ff add %g2, -1, %g2 4000735c: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 40007360: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 40007364: 80 a0 60 00 cmp %g1, 0 40007368: 12 80 00 05 bne 4000737c 4000736c: 03 10 00 76 sethi %hi(0x4001d800), %g1 _Thread_Dispatch(); 40007370: 40 00 11 d2 call 4000bab8 <_Thread_Dispatch> 40007374: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 40007378: 03 10 00 76 sethi %hi(0x4001d800), %g1 4000737c: c2 00 61 ac ld [ %g1 + 0x1ac ], %g1 ! 4001d9ac <_Thread_Executing> 40007380: 7f ff ff 4f call 400070bc <_POSIX_RWLock_Translate_core_RWLock_return_code> 40007384: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 40007388: 81 c7 e0 08 ret 4000738c: 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(); 40007390: 40 00 01 b7 call 40007a6c <== NOT EXECUTED 40007394: 01 00 00 00 nop <== NOT EXECUTED } 40007398: 81 c7 e0 08 ret <== NOT EXECUTED 4000739c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 400073a0: 90 10 20 16 mov 0x16, %o0 } 400073a4: b0 10 00 08 mov %o0, %i0 400073a8: 81 c7 e0 08 ret 400073ac: 81 e8 00 00 restore 400065a8 : int pthread_setcancelstate( int state, int *oldstate ) { 400065a8: 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() ) 400065ac: 03 10 00 5f sethi %hi(0x40017c00), %g1 400065b0: c2 00 62 94 ld [ %g1 + 0x294 ], %g1 ! 40017e94 <_ISR_Nest_level> int pthread_setcancelstate( int state, int *oldstate ) { 400065b4: 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() ) 400065b8: 80 a0 60 00 cmp %g1, 0 400065bc: 12 80 00 28 bne 4000665c 400065c0: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldstate ) 400065c4: 80 a6 60 00 cmp %i1, 0 400065c8: 02 80 00 27 be 40006664 400065cc: 80 a1 20 01 cmp %g4, 1 return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 400065d0: 38 80 00 23 bgu,a 4000665c 400065d4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400065d8: 07 10 00 5f sethi %hi(0x40017c00), %g3 return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 400065dc: 1b 10 00 5f sethi %hi(0x40017c00), %o5 400065e0: c2 00 e1 d0 ld [ %g3 + 0x1d0 ], %g1 400065e4: c4 03 62 ac ld [ %o5 + 0x2ac ], %g2 400065e8: 82 00 60 01 inc %g1 400065ec: c4 00 a1 70 ld [ %g2 + 0x170 ], %g2 400065f0: c2 20 e1 d0 st %g1, [ %g3 + 0x1d0 ] _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 400065f4: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 400065f8: 80 a1 20 00 cmp %g4, 0 return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 400065fc: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 40006600: 12 80 00 0c bne 40006630 40006604: c8 20 a0 cc st %g4, [ %g2 + 0xcc ] 40006608: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 4000660c: 80 a0 60 01 cmp %g1, 1 40006610: 12 80 00 08 bne 40006630 40006614: 01 00 00 00 nop 40006618: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 <== NOT EXECUTED 4000661c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40006620: 02 80 00 04 be 40006630 <== NOT EXECUTED 40006624: 01 00 00 00 nop <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 40006628: 7f ff fe 09 call 40005e4c <_POSIX_Threads_cancel_run> <== NOT EXECUTED 4000662c: d0 03 62 ac ld [ %o5 + 0x2ac ], %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 ) 40006630: 03 10 00 5f sethi %hi(0x40017c00), %g1 40006634: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 40017dd0 <_Thread_Dispatch_disable_level> 40006638: b0 10 20 00 clr %i0 4000663c: 84 00 bf ff add %g2, -1, %g2 40006640: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ] 40006644: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 40006648: 80 a0 60 00 cmp %g1, 0 4000664c: 12 80 00 07 bne 40006668 40006650: 01 00 00 00 nop _Thread_Dispatch(); 40006654: 40 00 0f 87 call 4000a470 <_Thread_Dispatch> 40006658: 01 00 00 00 nop 4000665c: 81 c7 e0 08 ret 40006660: 81 e8 00 00 restore 40006664: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } 40006668: 81 c7 e0 08 ret <== NOT EXECUTED 4000666c: 81 e8 00 00 restore <== NOT EXECUTED 40006670 : int pthread_setcanceltype( int type, int *oldtype ) { 40006670: 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() ) 40006674: 03 10 00 5f sethi %hi(0x40017c00), %g1 40006678: c2 00 62 94 ld [ %g1 + 0x294 ], %g1 ! 40017e94 <_ISR_Nest_level> int pthread_setcanceltype( int type, int *oldtype ) { 4000667c: 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() ) 40006680: 80 a0 60 00 cmp %g1, 0 40006684: 12 80 00 28 bne 40006724 40006688: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldtype ) 4000668c: 80 a6 60 00 cmp %i1, 0 40006690: 02 80 00 27 be 4000672c 40006694: 80 a1 20 01 cmp %g4, 1 return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 40006698: 38 80 00 23 bgu,a 40006724 4000669c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400066a0: 07 10 00 5f sethi %hi(0x40017c00), %g3 return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 400066a4: 1b 10 00 5f sethi %hi(0x40017c00), %o5 400066a8: c2 00 e1 d0 ld [ %g3 + 0x1d0 ], %g1 400066ac: c4 03 62 ac ld [ %o5 + 0x2ac ], %g2 400066b0: 82 00 60 01 inc %g1 400066b4: c4 00 a1 70 ld [ %g2 + 0x170 ], %g2 400066b8: c2 20 e1 d0 st %g1, [ %g3 + 0x1d0 ] _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 400066bc: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 400066c0: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_type = type; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 400066c4: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 400066c8: 80 a0 60 00 cmp %g1, 0 400066cc: 12 80 00 0b bne 400066f8 400066d0: c8 20 a0 d0 st %g4, [ %g2 + 0xd0 ] 400066d4: 80 a1 20 01 cmp %g4, 1 400066d8: 12 80 00 08 bne 400066f8 400066dc: 01 00 00 00 nop 400066e0: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 400066e4: 80 a0 60 00 cmp %g1, 0 400066e8: 02 80 00 04 be 400066f8 400066ec: 01 00 00 00 nop thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 400066f0: 7f ff fd d7 call 40005e4c <_POSIX_Threads_cancel_run> <== NOT EXECUTED 400066f4: d0 03 62 ac ld [ %o5 + 0x2ac ], %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 ) 400066f8: 03 10 00 5f sethi %hi(0x40017c00), %g1 400066fc: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 40017dd0 <_Thread_Dispatch_disable_level> 40006700: b0 10 20 00 clr %i0 40006704: 84 00 bf ff add %g2, -1, %g2 40006708: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ] 4000670c: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 40006710: 80 a0 60 00 cmp %g1, 0 40006714: 12 80 00 07 bne 40006730 40006718: 01 00 00 00 nop _Thread_Dispatch(); 4000671c: 40 00 0f 55 call 4000a470 <_Thread_Dispatch> 40006720: 01 00 00 00 nop 40006724: 81 c7 e0 08 ret 40006728: 81 e8 00 00 restore 4000672c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } 40006730: 81 c7 e0 08 ret <== NOT EXECUTED 40006734: 81 e8 00 00 restore <== NOT EXECUTED 40009028 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 40009028: 9d e3 bf 90 save %sp, -112, %sp /* * Check all the parameters */ if ( !param ) 4000902c: 80 a6 a0 00 cmp %i2, 0 40009030: 02 80 00 70 be 400091f0 40009034: 90 10 20 16 mov 0x16, %o0 return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 40009038: c2 06 80 00 ld [ %i2 ], %g1 4000903c: 82 00 7f ff add %g1, -1, %g1 40009040: 80 a0 60 fd cmp %g1, 0xfd 40009044: 18 80 00 6b bgu 400091f0 40009048: 80 a6 60 01 cmp %i1, 1 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 4000904c: 02 80 00 10 be 4000908c 40009050: a2 10 20 00 clr %l1 40009054: 14 80 00 08 bg 40009074 40009058: 80 a6 60 02 cmp %i1, 2 4000905c: 80 a6 60 00 cmp %i1, 0 40009060: a2 10 20 01 mov 1, %l1 40009064: 02 80 00 1b be 400090d0 40009068: a4 10 20 00 clr %l2 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 4000906c: 81 c7 e0 08 ret 40009070: 91 e8 00 08 restore %g0, %o0, %o0 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 40009074: 02 80 00 05 be 40009088 40009078: 80 a6 60 03 cmp %i1, 3 4000907c: 32 80 00 5d bne,a 400091f0 40009080: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 40009084: 30 80 00 04 b,a 40009094 40009088: a2 10 20 02 mov 2, %l1 4000908c: 10 80 00 11 b 400090d0 40009090: a4 10 20 00 clr %l2 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 ) < 40009094: 40 00 13 e0 call 4000e014 <_Timespec_To_ticks> 40009098: 90 06 a0 08 add %i2, 8, %o0 4000909c: a0 10 00 08 mov %o0, %l0 400090a0: 40 00 13 dd call 4000e014 <_Timespec_To_ticks> 400090a4: 90 06 a0 10 add %i2, 0x10, %o0 400090a8: 80 a4 00 08 cmp %l0, %o0 400090ac: 2a 80 00 51 bcs,a 400091f0 400090b0: 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 ) ) 400090b4: c2 06 a0 04 ld [ %i2 + 4 ], %g1 400090b8: 82 00 7f ff add %g1, -1, %g1 400090bc: 80 a0 60 fd cmp %g1, 0xfd 400090c0: 18 80 00 4b bgu 400091ec 400090c4: 03 10 00 23 sethi %hi(0x40008c00), %g1 400090c8: a2 10 20 03 mov 3, %l1 400090cc: a4 10 63 18 or %g1, 0x318, %l2 400090d0: 92 10 00 18 mov %i0, %o1 400090d4: 11 10 00 6c sethi %hi(0x4001b000), %o0 400090d8: 94 07 bf f4 add %fp, -12, %o2 400090dc: 40 00 0a c0 call 4000bbdc <_Objects_Get> 400090e0: 90 12 23 a8 or %o0, 0x3a8, %o0 /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 400090e4: c2 07 bf f4 ld [ %fp + -12 ], %g1 400090e8: 80 a0 60 00 cmp %g1, 0 400090ec: 02 80 00 06 be 40009104 400090f0: b0 10 00 08 mov %o0, %i0 400090f4: 80 a0 60 02 cmp %g1, 2 400090f8: 08 80 00 3e bleu 400091f0 400090fc: 90 10 20 03 mov 3, %o0 40009100: 30 80 00 37 b,a 400091dc <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 40009104: e0 02 21 70 ld [ %o0 + 0x170 ], %l0 if ( api->schedpolicy == SCHED_SPORADIC ) 40009108: c2 04 20 7c ld [ %l0 + 0x7c ], %g1 4000910c: 80 a0 60 03 cmp %g1, 3 40009110: 32 80 00 05 bne,a 40009124 40009114: f2 24 20 7c st %i1, [ %l0 + 0x7c ] (void) _Watchdog_Remove( &api->Sporadic_timer ); 40009118: 40 00 15 10 call 4000e558 <_Watchdog_Remove> 4000911c: 90 04 20 9c add %l0, 0x9c, %o0 api->schedpolicy = policy; 40009120: f2 24 20 7c st %i1, [ %l0 + 0x7c ] api->schedparam = *param; 40009124: 92 10 00 1a mov %i2, %o1 40009128: 90 04 20 80 add %l0, 0x80, %o0 4000912c: 40 00 26 ad call 40012be0 40009130: 94 10 20 18 mov 0x18, %o2 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 40009134: c2 04 20 7c ld [ %l0 + 0x7c ], %g1 if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; the_thread->budget_algorithm = budget_algorithm; 40009138: e2 26 20 88 st %l1, [ %i0 + 0x88 ] the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 4000913c: 80 a0 60 00 cmp %g1, 0 40009140: 06 80 00 1a bl 400091a8 40009144: e4 26 20 8c st %l2, [ %i0 + 0x8c ] 40009148: 80 a0 60 02 cmp %g1, 2 4000914c: 24 80 00 07 ble,a 40009168 40009150: c4 04 20 80 ld [ %l0 + 0x80 ], %g2 40009154: 80 a0 60 03 cmp %g1, 3 40009158: 12 80 00 14 bne 400091a8 4000915c: 01 00 00 00 nop TRUE ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 40009160: 10 80 00 0c b 40009190 40009164: c2 04 20 80 ld [ %l0 + 0x80 ], %g1 switch ( api->schedpolicy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 40009168: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000916c: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 ! 4001b018 <_Thread_Ticks_per_timeslice> the_thread->real_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 40009170: 90 10 00 18 mov %i0, %o0 switch ( api->schedpolicy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 40009174: c2 26 20 84 st %g1, [ %i0 + 0x84 ] 40009178: 92 10 20 ff mov 0xff, %o1 the_thread->real_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 4000917c: 94 10 20 01 mov 1, %o2 40009180: 92 22 40 02 sub %o1, %g2, %o1 40009184: 40 00 0e 1f call 4000ca00 <_Thread_Change_priority> 40009188: d2 26 20 18 st %o1, [ %i0 + 0x18 ] 4000918c: 30 80 00 07 b,a 400091a8 ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; _Watchdog_Remove( &api->Sporadic_timer ); 40009190: 90 04 20 9c add %l0, 0x9c, %o0 40009194: 40 00 14 f1 call 4000e558 <_Watchdog_Remove> 40009198: c2 24 20 98 st %g1, [ %l0 + 0x98 ] _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 4000919c: 92 10 00 18 mov %i0, %o1 400091a0: 7f ff ff 72 call 40008f68 <_POSIX_Threads_Sporadic_budget_TSR> 400091a4: 90 10 20 00 clr %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400091a8: 03 10 00 6c sethi %hi(0x4001b000), %g1 400091ac: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 4001b0c0 <_Thread_Dispatch_disable_level> 400091b0: 90 10 20 00 clr %o0 400091b4: 84 00 bf ff add %g2, -1, %g2 400091b8: c4 20 60 c0 st %g2, [ %g1 + 0xc0 ] 400091bc: c2 00 60 c0 ld [ %g1 + 0xc0 ], %g1 400091c0: 80 a0 60 00 cmp %g1, 0 400091c4: 32 80 00 0c bne,a 400091f4 400091c8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 400091cc: 40 00 0f 39 call 4000ceb0 <_Thread_Dispatch> 400091d0: 01 00 00 00 nop 400091d4: 10 80 00 07 b 400091f0 400091d8: 90 10 20 00 clr %o0 ! 0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400091dc: 40 00 00 1b call 40009248 <== NOT EXECUTED 400091e0: 01 00 00 00 nop <== NOT EXECUTED } 400091e4: 81 c7 e0 08 ret <== NOT EXECUTED 400091e8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400091ec: 90 10 20 16 mov 0x16, %o0 } 400091f0: b0 10 00 08 mov %o0, %i0 400091f4: 81 c7 e0 08 ret 400091f8: 81 e8 00 00 restore 4000668c : int pthread_setspecific( pthread_key_t key, const void *value ) { 4000668c: 9d e3 bf 90 save %sp, -112, %sp 40006690: 11 10 00 60 sethi %hi(0x40018000), %o0 40006694: 92 10 00 18 mov %i0, %o1 40006698: 90 12 22 c0 or %o0, 0x2c0, %o0 4000669c: 40 00 0c 7c call 4000988c <_Objects_Get> 400066a0: 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 ) { 400066a4: c2 07 bf f4 ld [ %fp + -12 ], %g1 400066a8: 80 a0 60 00 cmp %g1, 0 400066ac: 22 80 00 06 be,a 400066c4 400066b0: 03 10 00 5f sethi %hi(0x40017c00), %g1 400066b4: 80 a0 60 02 cmp %g1, 2 400066b8: 08 80 00 1d bleu 4000672c 400066bc: 90 10 20 16 mov 0x16, %o0 400066c0: 30 80 00 19 b,a 40006724 <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never happen */ return EINVAL; case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 400066c4: c2 00 62 9c ld [ %g1 + 0x29c ], %g1 400066c8: c4 00 60 08 ld [ %g1 + 8 ], %g2 index = _Objects_Get_index( _Thread_Executing->Object.id ); the_key->Values[ api ][ index ] = (void *) value; 400066cc: 83 30 a0 16 srl %g2, 0x16, %g1 400066d0: 82 08 60 1c and %g1, 0x1c, %g1 400066d4: 82 00 40 08 add %g1, %o0, %g1 400066d8: c6 00 60 18 ld [ %g1 + 0x18 ], %g3 400066dc: 03 00 00 3f sethi %hi(0xfc00), %g1 400066e0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400066e4: 84 08 80 01 and %g2, %g1, %g2 400066e8: 85 28 a0 02 sll %g2, 2, %g2 400066ec: f2 20 c0 02 st %i1, [ %g3 + %g2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400066f0: 05 10 00 5f sethi %hi(0x40017c00), %g2 400066f4: c2 00 a1 c0 ld [ %g2 + 0x1c0 ], %g1 ! 40017dc0 <_Thread_Dispatch_disable_level> 400066f8: 90 10 20 00 clr %o0 400066fc: 82 00 7f ff add %g1, -1, %g1 40006700: c2 20 a1 c0 st %g1, [ %g2 + 0x1c0 ] 40006704: c2 00 a1 c0 ld [ %g2 + 0x1c0 ], %g1 40006708: 80 a0 60 00 cmp %g1, 0 4000670c: 12 80 00 08 bne 4000672c 40006710: 01 00 00 00 nop _Thread_Dispatch(); 40006714: 40 00 11 13 call 4000ab60 <_Thread_Dispatch> 40006718: 01 00 00 00 nop 4000671c: 10 80 00 04 b 4000672c 40006720: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40006724: 40 00 01 f5 call 40006ef8 <== NOT EXECUTED 40006728: 01 00 00 00 nop <== NOT EXECUTED } 4000672c: 81 c7 e0 08 ret 40006730: 91 e8 00 08 restore %g0, %o0, %o0 40006338 : */ int pthread_spin_destroy( pthread_spinlock_t *spinlock ) { 40006338: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; if ( !spinlock ) 4000633c: 80 a6 20 00 cmp %i0, 0 40006340: 02 80 00 2c be 400063f0 40006344: 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( 40006348: d2 06 00 00 ld [ %i0 ], %o1 4000634c: 31 10 00 55 sethi %hi(0x40015400), %i0 40006350: 40 00 0b da call 400092b8 <_Objects_Get> 40006354: 90 16 20 d4 or %i0, 0xd4, %o0 ! 400154d4 <_POSIX_Spinlock_Information> return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 40006358: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000635c: 80 a0 60 00 cmp %g1, 0 40006360: 02 80 00 07 be 4000637c 40006364: 88 10 00 08 mov %o0, %g4 40006368: 80 a0 60 02 cmp %g1, 2 4000636c: 18 80 00 1d bgu 400063e0 40006370: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40006374: 81 c7 e0 08 ret 40006378: 91 e8 00 08 restore %g0, %o0, %o0 RTEMS_INLINE_ROUTINE boolean _CORE_spinlock_Is_busy( CORE_spinlock_Control *the_spinlock ) { return (the_spinlock->users != 0); 4000637c: 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 ) ) { 40006380: 80 a0 60 00 cmp %g1, 0 40006384: 22 80 00 06 be,a 4000639c 40006388: 90 16 20 d4 or %i0, 0xd4, %o0 _Thread_Enable_dispatch(); 4000638c: 7f ff ff de call 40006304 <_Thread_Enable_dispatch> 40006390: 01 00 00 00 nop 40006394: 10 80 00 18 b 400063f4 40006398: 90 10 20 10 mov 0x10, %o0 ! 10 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000639c: c2 01 20 08 ld [ %g4 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400063a0: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 400063a4: 05 00 00 3f sethi %hi(0xfc00), %g2 400063a8: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 400063ac: 82 08 40 02 and %g1, %g2, %g1 400063b0: 80 a0 40 03 cmp %g1, %g3 400063b4: 18 80 00 05 bgu 400063c8 400063b8: 92 10 00 04 mov %g4, %o1 information->local_table[ index ] = the_object; 400063bc: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400063c0: 83 28 60 02 sll %g1, 2, %g1 400063c4: 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 ); 400063c8: 40 00 0b 7a call 400091b0 <_Objects_Free> 400063cc: c0 21 20 0c clr [ %g4 + 0xc ] _Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object ); _POSIX_Spinlock_Free( the_spinlock ); _Thread_Enable_dispatch(); 400063d0: 7f ff ff cd call 40006304 <_Thread_Enable_dispatch> 400063d4: 01 00 00 00 nop 400063d8: 10 80 00 07 b 400063f4 400063dc: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 400063e0: 40 00 00 db call 4000674c <== NOT EXECUTED 400063e4: 01 00 00 00 nop <== NOT EXECUTED } 400063e8: 81 c7 e0 08 ret <== NOT EXECUTED 400063ec: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400063f0: 90 10 20 16 mov 0x16, %o0 } 400063f4: b0 10 00 08 mov %o0, %i0 400063f8: 81 c7 e0 08 ret 400063fc: 81 e8 00 00 restore 40006434 : int pthread_spin_init( pthread_spinlock_t *spinlock, int pshared ) { 40006434: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock; CORE_spinlock_Attributes attributes; if ( !spinlock ) 40006438: 80 a6 20 00 cmp %i0, 0 4000643c: 02 80 00 26 be 400064d4 40006440: 80 a6 60 00 cmp %i1, 0 return EINVAL; switch ( pshared ) { 40006444: 12 80 00 24 bne 400064d4 40006448: 05 10 00 54 sethi %hi(0x40015000), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000644c: c2 00 a1 a0 ld [ %g2 + 0x1a0 ], %g1 ! 400151a0 <_Thread_Dispatch_disable_level> 40006450: 82 00 60 01 inc %g1 40006454: c2 20 a1 a0 st %g1, [ %g2 + 0x1a0 ] * 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 *) 40006458: 21 10 00 55 sethi %hi(0x40015400), %l0 4000645c: 40 00 0a 53 call 40008da8 <_Objects_Allocate> 40006460: 90 14 20 d4 or %l0, 0xd4, %o0 ! 400154d4 <_POSIX_Spinlock_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_spinlock = _POSIX_Spinlock_Allocate(); if ( !the_spinlock ) { 40006464: b2 92 20 00 orcc %o0, 0, %i1 40006468: 12 80 00 06 bne 40006480 4000646c: 90 06 60 10 add %i1, 0x10, %o0 _Thread_Enable_dispatch(); 40006470: 7f ff ff e4 call 40006400 <_Thread_Enable_dispatch> 40006474: b0 10 20 0b mov 0xb, %i0 40006478: 81 c7 e0 08 ret 4000647c: 81 e8 00 00 restore return EAGAIN; } _CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes ); 40006480: 40 00 08 31 call 40008544 <_CORE_spinlock_Initialize> 40006484: 92 07 bf f4 add %fp, -12, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006488: 90 14 20 d4 or %l0, 0xd4, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000648c: c2 06 60 08 ld [ %i1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006490: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40006494: 05 00 00 3f sethi %hi(0xfc00), %g2 40006498: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000649c: 82 08 40 02 and %g1, %g2, %g1 400064a0: 80 a0 40 03 cmp %g1, %g3 400064a4: 38 80 00 06 bgu,a 400064bc 400064a8: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 400064ac: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400064b0: 83 28 60 02 sll %g1, 2, %g1 400064b4: f2 20 80 01 st %i1, [ %g2 + %g1 ] &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 ); *spinlock = the_spinlock->Object.id; 400064b8: c2 06 60 08 ld [ %i1 + 8 ], %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; 400064bc: c0 26 60 0c clr [ %i1 + 0xc ] 400064c0: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 400064c4: 7f ff ff cf call 40006400 <_Thread_Enable_dispatch> 400064c8: b0 10 20 00 clr %i0 400064cc: 81 c7 e0 08 ret 400064d0: 81 e8 00 00 restore return 0; } 400064d4: 81 c7 e0 08 ret 400064d8: 91 e8 20 16 restore %g0, 0x16, %o0 400064dc : */ int pthread_spin_lock( pthread_spinlock_t *spinlock ) { 400064dc: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 400064e0: 80 a6 20 00 cmp %i0, 0 400064e4: 02 80 00 25 be 40006578 400064e8: 11 10 00 55 sethi %hi(0x40015400), %o0 RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get ( pthread_spinlock_t *spinlock, Objects_Locations *location ) { return (POSIX_Spinlock_Control *) _Objects_Get( 400064ec: d2 06 00 00 ld [ %i0 ], %o1 400064f0: 94 07 bf f4 add %fp, -12, %o2 400064f4: 40 00 0b 71 call 400092b8 <_Objects_Get> 400064f8: 90 12 20 d4 or %o0, 0xd4, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 400064fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006500: 80 a0 60 00 cmp %g1, 0 40006504: 02 80 00 07 be 40006520 40006508: 92 10 20 01 mov 1, %o1 4000650c: 80 a0 60 02 cmp %g1, 2 40006510: 18 80 00 16 bgu 40006568 40006514: 90 10 20 16 mov 0x16, %o0 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(); } 40006518: 81 c7 e0 08 ret 4000651c: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); 40006520: 94 10 20 00 clr %o2 40006524: 40 00 08 2d call 400085d8 <_CORE_spinlock_Wait> 40006528: 90 02 20 10 add %o0, 0x10, %o0 4000652c: 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 ) 40006530: 03 10 00 54 sethi %hi(0x40015000), %g1 40006534: c4 00 61 a0 ld [ %g1 + 0x1a0 ], %g2 ! 400151a0 <_Thread_Dispatch_disable_level> 40006538: 84 00 bf ff add %g2, -1, %g2 4000653c: c4 20 61 a0 st %g2, [ %g1 + 0x1a0 ] 40006540: c2 00 61 a0 ld [ %g1 + 0x1a0 ], %g1 40006544: 80 a0 60 00 cmp %g1, 0 40006548: 12 80 00 04 bne 40006558 4000654c: 01 00 00 00 nop _Thread_Dispatch(); 40006550: 40 00 10 0f call 4000a58c <_Thread_Dispatch> 40006554: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 40006558: 40 00 00 0c call 40006588 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 4000655c: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 40006560: 81 c7 e0 08 ret 40006564: 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(); 40006568: 40 00 00 79 call 4000674c <== NOT EXECUTED 4000656c: 01 00 00 00 nop <== NOT EXECUTED } 40006570: 81 c7 e0 08 ret <== NOT EXECUTED 40006574: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 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(); 40006578: 90 10 20 16 mov 0x16, %o0 } 4000657c: b0 10 00 08 mov %o0, %i0 40006580: 81 c7 e0 08 ret 40006584: 81 e8 00 00 restore 400065b0 : */ int pthread_spin_trylock( pthread_spinlock_t *spinlock ) { 400065b0: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 400065b4: 80 a6 20 00 cmp %i0, 0 400065b8: 02 80 00 25 be 4000664c 400065bc: 11 10 00 55 sethi %hi(0x40015400), %o0 400065c0: d2 06 00 00 ld [ %i0 ], %o1 400065c4: 94 07 bf f4 add %fp, -12, %o2 400065c8: 40 00 0b 3c call 400092b8 <_Objects_Get> 400065cc: 90 12 20 d4 or %o0, 0xd4, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 400065d0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400065d4: 80 a0 60 00 cmp %g1, 0 400065d8: 02 80 00 07 be 400065f4 400065dc: 92 10 20 00 clr %o1 400065e0: 80 a0 60 02 cmp %g1, 2 400065e4: 18 80 00 16 bgu 4000663c 400065e8: 90 10 20 16 mov 0x16, %o0 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(); } 400065ec: 81 c7 e0 08 ret 400065f0: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); 400065f4: 94 10 20 00 clr %o2 400065f8: 40 00 07 f8 call 400085d8 <_CORE_spinlock_Wait> 400065fc: 90 02 20 10 add %o0, 0x10, %o0 40006600: 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 ) 40006604: 03 10 00 54 sethi %hi(0x40015000), %g1 40006608: c4 00 61 a0 ld [ %g1 + 0x1a0 ], %g2 ! 400151a0 <_Thread_Dispatch_disable_level> 4000660c: 84 00 bf ff add %g2, -1, %g2 40006610: c4 20 61 a0 st %g2, [ %g1 + 0x1a0 ] 40006614: c2 00 61 a0 ld [ %g1 + 0x1a0 ], %g1 40006618: 80 a0 60 00 cmp %g1, 0 4000661c: 12 80 00 04 bne 4000662c 40006620: 01 00 00 00 nop _Thread_Dispatch(); 40006624: 40 00 0f da call 4000a58c <_Thread_Dispatch> 40006628: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 4000662c: 7f ff ff d7 call 40006588 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 40006630: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 40006634: 81 c7 e0 08 ret 40006638: 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(); 4000663c: 40 00 00 44 call 4000674c <== NOT EXECUTED 40006640: 01 00 00 00 nop <== NOT EXECUTED } 40006644: 81 c7 e0 08 ret <== NOT EXECUTED 40006648: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 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(); 4000664c: 90 10 20 16 mov 0x16, %o0 } 40006650: b0 10 00 08 mov %o0, %i0 40006654: 81 c7 e0 08 ret 40006658: 81 e8 00 00 restore 4000665c : */ int pthread_spin_unlock( pthread_spinlock_t *spinlock ) { 4000665c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 40006660: 80 a6 20 00 cmp %i0, 0 40006664: 02 80 00 23 be 400066f0 40006668: 11 10 00 55 sethi %hi(0x40015400), %o0 4000666c: d2 06 00 00 ld [ %i0 ], %o1 40006670: 94 07 bf f4 add %fp, -12, %o2 40006674: 40 00 0b 11 call 400092b8 <_Objects_Get> 40006678: 90 12 20 d4 or %o0, 0xd4, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 4000667c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006680: 80 a0 60 00 cmp %g1, 0 40006684: 02 80 00 06 be 4000669c 40006688: 80 a0 60 02 cmp %g1, 2 4000668c: 18 80 00 15 bgu 400066e0 40006690: 90 10 20 16 mov 0x16, %o0 status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); } 40006694: 81 c7 e0 08 ret 40006698: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); 4000669c: 40 00 07 b1 call 40008560 <_CORE_spinlock_Release> 400066a0: 90 02 20 10 add %o0, 0x10, %o0 400066a4: 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 ) 400066a8: 03 10 00 54 sethi %hi(0x40015000), %g1 400066ac: c4 00 61 a0 ld [ %g1 + 0x1a0 ], %g2 ! 400151a0 <_Thread_Dispatch_disable_level> 400066b0: 84 00 bf ff add %g2, -1, %g2 400066b4: c4 20 61 a0 st %g2, [ %g1 + 0x1a0 ] 400066b8: c2 00 61 a0 ld [ %g1 + 0x1a0 ], %g1 400066bc: 80 a0 60 00 cmp %g1, 0 400066c0: 12 80 00 04 bne 400066d0 400066c4: 01 00 00 00 nop _Thread_Dispatch(); 400066c8: 40 00 0f b1 call 4000a58c <_Thread_Dispatch> 400066cc: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 400066d0: 7f ff ff ae call 40006588 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 400066d4: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 400066d8: 81 c7 e0 08 ret 400066dc: 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(); 400066e0: 40 00 00 1b call 4000674c <== NOT EXECUTED 400066e4: 01 00 00 00 nop <== NOT EXECUTED } 400066e8: 81 c7 e0 08 ret <== NOT EXECUTED 400066ec: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 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(); 400066f0: 90 10 20 16 mov 0x16, %o0 } 400066f4: b0 10 00 08 mov %o0, %i0 400066f8: 81 c7 e0 08 ret 400066fc: 81 e8 00 00 restore 4000675c : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 4000675c: 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() ) 40006760: 03 10 00 5f sethi %hi(0x40017c00), %g1 40006764: c2 00 62 94 ld [ %g1 + 0x294 ], %g1 ! 40017e94 <_ISR_Nest_level> 40006768: 80 a0 60 00 cmp %g1, 0 4000676c: 12 80 00 1c bne 400067dc 40006770: 07 10 00 5f sethi %hi(0x40017c00), %g3 return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 40006774: 09 10 00 5f sethi %hi(0x40017c00), %g4 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006778: c2 00 e1 d0 ld [ %g3 + 0x1d0 ], %g1 4000677c: c4 01 22 ac ld [ %g4 + 0x2ac ], %g2 40006780: 82 00 60 01 inc %g1 40006784: c4 00 a1 70 ld [ %g2 + 0x170 ], %g2 40006788: c2 20 e1 d0 st %g1, [ %g3 + 0x1d0 ] _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 4000678c: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 40006790: 80 a0 60 00 cmp %g1, 0 40006794: 12 80 00 08 bne 400067b4 40006798: 01 00 00 00 nop 4000679c: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 400067a0: 80 a0 60 00 cmp %g1, 0 400067a4: 02 80 00 04 be 400067b4 400067a8: 01 00 00 00 nop thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 400067ac: 7f ff fd a8 call 40005e4c <_POSIX_Threads_cancel_run> 400067b0: d0 01 22 ac ld [ %g4 + 0x2ac ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400067b4: 03 10 00 5f sethi %hi(0x40017c00), %g1 400067b8: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 40017dd0 <_Thread_Dispatch_disable_level> 400067bc: 84 00 bf ff add %g2, -1, %g2 400067c0: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ] 400067c4: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 400067c8: 80 a0 60 00 cmp %g1, 0 400067cc: 12 80 00 04 bne 400067dc 400067d0: 01 00 00 00 nop _Thread_Dispatch(); 400067d4: 40 00 0f 27 call 4000a470 <_Thread_Dispatch> 400067d8: 81 e8 00 00 restore 400067dc: 81 c7 e0 08 ret <== NOT EXECUTED 400067e0: 81 e8 00 00 restore <== NOT EXECUTED 40006ba8 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 40006ba8: 9d e3 bf 90 save %sp, -112, %sp Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 40006bac: a2 96 20 00 orcc %i0, 0, %l1 40006bb0: 02 80 00 1b be 40006c1c 40006bb4: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 40006bb8: 80 a6 e0 00 cmp %i3, 0 40006bbc: 02 80 00 18 be 40006c1c 40006bc0: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 40006bc4: 80 8e 60 10 btst 0x10, %i1 40006bc8: 02 80 00 06 be 40006be0 40006bcc: 80 a6 a0 00 cmp %i2, 0 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 40006bd0: 02 80 00 13 be 40006c1c 40006bd4: 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; 40006bd8: 10 80 00 04 b 40006be8 40006bdc: c0 27 bf f0 clr [ %fp + -16 ] if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 40006be0: 82 10 20 01 mov 1, %g1 40006be4: c2 27 bf f0 st %g1, [ %fp + -16 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006be8: 05 10 00 7d sethi %hi(0x4001f400), %g2 40006bec: c2 00 a0 00 ld [ %g2 ], %g1 the_attributes.maximum_count = maximum_waiters; 40006bf0: f4 27 bf f4 st %i2, [ %fp + -12 ] 40006bf4: 82 00 60 01 inc %g1 40006bf8: c2 20 a0 00 st %g1, [ %g2 ] * 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 ); 40006bfc: 21 10 00 7c sethi %hi(0x4001f000), %l0 40006c00: 40 00 09 fc call 400093f0 <_Objects_Allocate> 40006c04: 90 14 22 68 or %l0, 0x268, %o0 ! 4001f268 <_Barrier_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 40006c08: b4 92 20 00 orcc %o0, 0, %i2 40006c0c: 12 80 00 06 bne 40006c24 40006c10: 90 06 a0 14 add %i2, 0x14, %o0 _Thread_Enable_dispatch(); 40006c14: 7f ff ff d8 call 40006b74 <_Thread_Enable_dispatch> 40006c18: b0 10 20 05 mov 5, %i0 40006c1c: 81 c7 e0 08 ret 40006c20: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 40006c24: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 40006c28: 40 00 07 3e call 40008920 <_CORE_barrier_Initialize> 40006c2c: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006c30: 90 14 22 68 or %l0, 0x268, %o0 Objects_Name name ) { uint32_t index; index = _Objects_Get_index( the_object->id ); 40006c34: c6 06 a0 08 ld [ %i2 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006c38: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40006c3c: 03 00 00 3f sethi %hi(0xfc00), %g1 40006c40: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40006c44: 82 08 c0 01 and %g3, %g1, %g1 40006c48: 80 a0 40 02 cmp %g1, %g2 40006c4c: 38 80 00 06 bgu,a 40006c64 40006c50: e2 26 a0 0c st %l1, [ %i2 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40006c54: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006c58: 83 28 60 02 sll %g1, 2, %g1 40006c5c: 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; 40006c60: e2 26 a0 0c st %l1, [ %i2 + 0xc ] &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 40006c64: c6 26 c0 00 st %g3, [ %i3 ] _Thread_Enable_dispatch(); 40006c68: 7f ff ff c3 call 40006b74 <_Thread_Enable_dispatch> 40006c6c: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 40006c70: 81 c7 e0 08 ret 40006c74: 81 e8 00 00 restore 40006c78 : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 40006c78: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 40006c7c: 21 10 00 7c sethi %hi(0x4001f000), %l0 40006c80: 92 10 00 18 mov %i0, %o1 40006c84: 94 07 bf f4 add %fp, -12, %o2 40006c88: 40 00 0b 1e call 40009900 <_Objects_Get> 40006c8c: 90 14 22 68 or %l0, 0x268, %o0 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 40006c90: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006c94: 80 a0 60 00 cmp %g1, 0 40006c98: 02 80 00 07 be 40006cb4 40006c9c: b0 10 00 08 mov %o0, %i0 40006ca0: 80 a0 60 02 cmp %g1, 2 40006ca4: 08 80 00 22 bleu 40006d2c 40006ca8: b0 10 20 04 mov 4, %i0 40006cac: 81 c7 e0 08 ret <== NOT EXECUTED 40006cb0: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Flush( 40006cb4: 90 02 20 14 add %o0, 0x14, %o0 40006cb8: 92 10 20 00 clr %o1 40006cbc: 40 00 12 4c call 4000b5ec <_Thread_queue_Flush> 40006cc0: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006cc4: 90 14 22 68 or %l0, 0x268, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40006cc8: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006ccc: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40006cd0: 05 00 00 3f sethi %hi(0xfc00), %g2 40006cd4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40006cd8: 82 08 40 02 and %g1, %g2, %g1 40006cdc: 80 a0 40 03 cmp %g1, %g3 40006ce0: 38 80 00 06 bgu,a 40006cf8 40006ce4: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40006ce8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006cec: 83 28 60 02 sll %g1, 2, %g1 40006cf0: 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; 40006cf4: c0 26 20 0c clr [ %i0 + 0xc ] */ RTEMS_INLINE_ROUTINE void _Barrier_Free ( Barrier_Control *the_barrier ) { _Objects_Free( &_Barrier_Information, &the_barrier->Object ); 40006cf8: 40 00 0a c0 call 400097f8 <_Objects_Free> 40006cfc: 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 ) 40006d00: 03 10 00 7d sethi %hi(0x4001f400), %g1 40006d04: c4 00 60 00 ld [ %g1 ], %g2 40006d08: b0 10 20 00 clr %i0 40006d0c: 84 00 bf ff add %g2, -1, %g2 40006d10: c4 20 60 00 st %g2, [ %g1 ] 40006d14: c2 00 60 00 ld [ %g1 ], %g1 40006d18: 80 a0 60 00 cmp %g1, 0 40006d1c: 12 80 00 04 bne 40006d2c 40006d20: 01 00 00 00 nop _Thread_Dispatch(); 40006d24: 40 00 0f eb call 4000acd0 <_Thread_Dispatch> 40006d28: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006d2c: 81 c7 e0 08 ret 40006d30: 81 e8 00 00 restore 40006d6c : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 40006d6c: 9d e3 bf 90 save %sp, -112, %sp 40006d70: a0 10 00 18 mov %i0, %l0 Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 40006d74: 80 a6 60 00 cmp %i1, 0 40006d78: 02 80 00 1f be 40006df4 40006d7c: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 40006d80: 11 10 00 7c sethi %hi(0x4001f000), %o0 40006d84: 92 10 00 10 mov %l0, %o1 40006d88: 90 12 22 68 or %o0, 0x268, %o0 40006d8c: 40 00 0a dd call 40009900 <_Objects_Get> 40006d90: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 40006d94: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006d98: 80 a0 60 00 cmp %g1, 0 40006d9c: 02 80 00 07 be 40006db8 40006da0: 92 10 00 10 mov %l0, %o1 40006da4: 80 a0 60 02 cmp %g1, 2 40006da8: 08 80 00 13 bleu 40006df4 40006dac: b0 10 20 04 mov 4, %i0 40006db0: 81 c7 e0 08 ret <== NOT EXECUTED 40006db4: 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 ); 40006db8: 94 10 20 00 clr %o2 40006dbc: 40 00 06 e5 call 40008950 <_CORE_barrier_Release> 40006dc0: 90 02 20 14 add %o0, 0x14, %o0 40006dc4: 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 ) 40006dc8: 03 10 00 7d sethi %hi(0x4001f400), %g1 40006dcc: c4 00 60 00 ld [ %g1 ], %g2 40006dd0: b0 10 20 00 clr %i0 40006dd4: 84 00 bf ff add %g2, -1, %g2 40006dd8: c4 20 60 00 st %g2, [ %g1 ] 40006ddc: c2 00 60 00 ld [ %g1 ], %g1 40006de0: 80 a0 60 00 cmp %g1, 0 40006de4: 12 80 00 04 bne 40006df4 40006de8: 01 00 00 00 nop _Thread_Dispatch(); 40006dec: 40 00 0f b9 call 4000acd0 <_Thread_Dispatch> 40006df0: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006df4: 81 c7 e0 08 ret 40006df8: 81 e8 00 00 restore 40006dfc : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 40006dfc: 9d e3 bf 90 save %sp, -112, %sp 40006e00: 11 10 00 7c sethi %hi(0x4001f000), %o0 40006e04: 92 10 00 18 mov %i0, %o1 40006e08: 90 12 22 68 or %o0, 0x268, %o0 40006e0c: 40 00 0a bd call 40009900 <_Objects_Get> 40006e10: 94 07 bf f4 add %fp, -12, %o2 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 40006e14: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006e18: 80 a0 60 00 cmp %g1, 0 40006e1c: 02 80 00 07 be 40006e38 40006e20: 96 10 00 19 mov %i1, %o3 40006e24: 80 a0 60 02 cmp %g1, 2 40006e28: 08 80 00 17 bleu 40006e84 40006e2c: 90 10 20 04 mov 4, %o0 40006e30: 10 80 00 15 b 40006e84 <== NOT EXECUTED 40006e34: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Wait( 40006e38: 90 02 20 14 add %o0, 0x14, %o0 40006e3c: 92 10 00 18 mov %i0, %o1 40006e40: 94 10 20 01 mov 1, %o2 40006e44: 40 00 06 ce call 4000897c <_CORE_barrier_Wait> 40006e48: 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 ) 40006e4c: 03 10 00 7d sethi %hi(0x4001f400), %g1 40006e50: c4 00 60 00 ld [ %g1 ], %g2 40006e54: 84 00 bf ff add %g2, -1, %g2 40006e58: c4 20 60 00 st %g2, [ %g1 ] 40006e5c: c2 00 60 00 ld [ %g1 ], %g1 40006e60: 80 a0 60 00 cmp %g1, 0 40006e64: 12 80 00 05 bne 40006e78 40006e68: 03 10 00 7d sethi %hi(0x4001f400), %g1 _Thread_Dispatch(); 40006e6c: 40 00 0f 99 call 4000acd0 <_Thread_Dispatch> 40006e70: 01 00 00 00 nop TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 40006e74: 03 10 00 7d sethi %hi(0x4001f400), %g1 40006e78: c2 00 60 dc ld [ %g1 + 0xdc ], %g1 ! 4001f4dc <_Thread_Executing> 40006e7c: 40 00 1d e9 call 4000e620 <_Barrier_Translate_core_barrier_return_code> 40006e80: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006e84: 81 c7 e0 08 ret 40006e88: 91 e8 00 08 restore %g0, %o0, %o0 40005cd0 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 40005cd0: 9d e3 bf 68 save %sp, -152, %sp 40005cd4: 82 10 00 18 mov %i0, %g1 if ( !time_buffer ) 40005cd8: 80 a6 60 00 cmp %i1, 0 40005cdc: 02 80 00 47 be 40005df8 40005ce0: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; switch ( option ) { 40005ce4: 80 a0 60 04 cmp %g1, 4 40005ce8: 18 80 00 44 bgu 40005df8 40005cec: b0 10 20 19 mov 0x19, %i0 40005cf0: 83 28 60 02 sll %g1, 2, %g1 40005cf4: 05 10 00 17 sethi %hi(0x40005c00), %g2 40005cf8: 84 10 a0 7c or %g2, 0x7c, %g2 ! 40005c7c 40005cfc: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40005d00: 81 c0 40 00 jmp %g1 40005d04: 01 00 00 00 nop 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 ) 40005d08: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40005d0c: c2 00 62 0c ld [ %g1 + 0x20c ], %g1 ! 4001ae0c <_TOD_Is_set> 40005d10: 80 a0 60 00 cmp %g1, 0 40005d14: 22 80 00 39 be,a 40005df8 40005d18: b0 10 20 0b mov 0xb, %i0 return RTEMS_NOT_DEFINED; /* Obtain the current time */ _TOD_Get_timeval( &now ); 40005d1c: a0 07 bf f0 add %fp, -16, %l0 40005d20: 7f ff ff dc call 40005c90 <_TOD_Get_timeval> 40005d24: 90 10 00 10 mov %l0, %o0 /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 40005d28: 92 07 bf cc add %fp, -52, %o1 40005d2c: 40 00 26 74 call 4000f6fc 40005d30: 90 10 00 10 mov %l0, %o0 tmbuf->month = time.tm_mon + 1; 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; 40005d34: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40005d38: d2 00 63 ac ld [ %g1 + 0x3ac ], %o1 ! 4001afac <_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; 40005d3c: c2 07 bf d8 ld [ %fp + -40 ], %g1 tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 40005d40: d0 07 bf f4 ld [ %fp + -12 ], %o0 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; 40005d44: c2 26 60 08 st %g1, [ %i1 + 8 ] tmbuf->hour = time.tm_hour; 40005d48: c2 07 bf d4 ld [ %fp + -44 ], %g1 40005d4c: c2 26 60 0c st %g1, [ %i1 + 0xc ] tmbuf->minute = time.tm_min; 40005d50: c2 07 bf d0 ld [ %fp + -48 ], %g1 40005d54: c2 26 60 10 st %g1, [ %i1 + 0x10 ] tmbuf->second = time.tm_sec; 40005d58: c2 07 bf cc ld [ %fp + -52 ], %g1 40005d5c: c2 26 60 14 st %g1, [ %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; 40005d60: c2 07 bf e0 ld [ %fp + -32 ], %g1 40005d64: 82 00 67 6c add %g1, 0x76c, %g1 40005d68: c2 26 40 00 st %g1, [ %i1 ] tmbuf->month = time.tm_mon + 1; 40005d6c: c2 07 bf dc ld [ %fp + -36 ], %g1 40005d70: 82 00 60 01 inc %g1 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; 40005d74: 40 00 40 bb call 40016060 <.udiv> 40005d78: c2 26 60 04 st %g1, [ %i1 + 4 ] 40005d7c: 10 80 00 1c b 40005dec 40005d80: d0 26 60 18 st %o0, [ %i1 + 0x18 ] return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: { rtems_interval *interval = (rtems_interval *)time_buffer; if ( !_TOD_Is_set ) 40005d84: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40005d88: c2 00 62 0c ld [ %g1 + 0x20c ], %g1 ! 4001ae0c <_TOD_Is_set> 40005d8c: 80 a0 60 00 cmp %g1, 0 40005d90: 02 80 00 19 be 40005df4 40005d94: 03 10 00 6b sethi %hi(0x4001ac00), %g1 return RTEMS_NOT_DEFINED; *interval = _TOD_Seconds_since_epoch; 40005d98: 10 80 00 04 b 40005da8 40005d9c: c2 00 62 88 ld [ %g1 + 0x288 ], %g1 ! 4001ae88 <_TOD_Now> } case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = _Watchdog_Ticks_since_boot; 40005da0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40005da4: c2 00 63 54 ld [ %g1 + 0x354 ], %g1 ! 4001af54 <_Watchdog_Ticks_since_boot> 40005da8: c2 26 40 00 st %g1, [ %i1 ] 40005dac: 81 c7 e0 08 ret 40005db0: 91 e8 20 00 restore %g0, 0, %o0 } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick; 40005db4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40005db8: d2 00 63 ac ld [ %g1 + 0x3ac ], %o1 ! 4001afac <_TOD_Microseconds_per_tick> 40005dbc: 11 00 03 d0 sethi %hi(0xf4000), %o0 40005dc0: 40 00 40 a8 call 40016060 <.udiv> 40005dc4: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 40005dc8: 10 80 00 09 b 40005dec 40005dcc: d0 26 40 00 st %o0, [ %i1 ] } case RTEMS_CLOCK_GET_TIME_VALUE: { struct timeval *time = (struct timeval *)time_buffer; if ( !_TOD_Is_set ) 40005dd0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40005dd4: c2 00 62 0c ld [ %g1 + 0x20c ], %g1 ! 4001ae0c <_TOD_Is_set> <== NOT EXECUTED 40005dd8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40005ddc: 22 80 00 07 be,a 40005df8 <== NOT EXECUTED 40005de0: b0 10 20 0b mov 0xb, %i0 <== NOT EXECUTED return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); 40005de4: 7f ff ff ab call 40005c90 <_TOD_Get_timeval> <== NOT EXECUTED 40005de8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 40005dec: 81 c7 e0 08 ret 40005df0: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; 40005df4: b0 10 20 0b mov 0xb, %i0 <== NOT EXECUTED } } return RTEMS_INTERNAL_ERROR; /* should never get here */ } 40005df8: 81 c7 e0 08 ret 40005dfc: 81 e8 00 00 restore 40005e20 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 40005e20: 9d e3 bf 98 save %sp, -104, %sp _TOD_Tickle_ticks(); 40005e24: 40 00 07 40 call 40007b24 <_TOD_Tickle_ticks> 40005e28: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 40005e2c: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40005e30: 40 00 14 4e call 4000af68 <_Watchdog_Tickle> 40005e34: 90 12 22 cc or %o0, 0x2cc, %o0 ! 4001aecc <_Watchdog_Ticks_chain> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 40005e38: 40 00 12 a5 call 4000a8cc <_Thread_Tickle_timeslice> 40005e3c: 01 00 00 00 nop * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_context_switch_necessary( void ) { return ( _Context_Switch_necessary ); 40005e40: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40005e44: c2 00 62 bc ld [ %g1 + 0x2bc ], %g1 ! 4001aebc <_Context_Switch_necessary> if ( _Thread_Is_context_switch_necessary() && 40005e48: 80 a0 60 00 cmp %g1, 0 40005e4c: 02 80 00 08 be 40005e6c 40005e50: 03 10 00 6b sethi %hi(0x4001ac00), %g1 * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 40005e54: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 40005e58: 80 a0 60 00 cmp %g1, 0 40005e5c: 12 80 00 04 bne 40005e6c 40005e60: 01 00 00 00 nop _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 40005e64: 40 00 0e e2 call 400099ec <_Thread_Dispatch> <== NOT EXECUTED 40005e68: 01 00 00 00 nop <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 40005e6c: 81 c7 e0 08 ret 40005e70: 91 e8 20 00 restore %g0, 0, %o0 40006084 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 40006084: 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 ) ) { 40006088: 92 96 20 00 orcc %i0, 0, %o1 4000608c: 12 80 00 0a bne 400060b4 40006090: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006094: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006098: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 4001add0 <_Thread_Dispatch_disable_level> 4000609c: 84 00 a0 01 inc %g2 400060a0: c4 20 61 d0 st %g2, [ %g1 + 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; 400060a4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400060a8: f0 00 62 ac ld [ %g1 + 0x2ac ], %i0 ! 4001aeac <_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; 400060ac: 10 80 00 18 b 4000610c 400060b0: c0 27 bf f4 clr [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 400060b4: 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 ) { 400060b8: 80 a0 a0 04 cmp %g2, 4 400060bc: 18 80 00 0e bgu 400060f4 400060c0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 400060c4: 83 32 60 1b srl %o1, 0x1b, %g1 400060c8: 80 a0 60 01 cmp %g1, 1 400060cc: 12 80 00 0a bne 400060f4 400060d0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400060d4: 83 28 a0 02 sll %g2, 2, %g1 400060d8: 05 10 00 6b sethi %hi(0x4001ac00), %g2 400060dc: 84 10 a1 30 or %g2, 0x130, %g2 ! 4001ad30 <_Objects_Information_table> 400060e0: c2 00 80 01 ld [ %g2 + %g1 ], %g1 400060e4: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 400060e8: 80 a2 20 00 cmp %o0, 0 400060ec: 12 80 00 05 bne 40006100 400060f0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 400060f4: b0 10 20 00 clr %i0 400060f8: 10 80 00 05 b 4000610c 400060fc: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40006100: 40 00 09 47 call 4000861c <_Objects_Get> 40006104: 94 07 bf f4 add %fp, -12, %o2 40006108: b0 10 00 08 mov %o0, %i0 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000610c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006110: 80 a0 60 00 cmp %g1, 0 40006114: 02 80 00 06 be 4000612c 40006118: 80 a0 60 02 cmp %g1, 2 4000611c: 08 80 00 18 bleu 4000617c 40006120: b0 10 20 04 mov 4, %i0 40006124: 81 c7 e0 08 ret <== NOT EXECUTED 40006128: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 4000612c: 7f ff ef 68 call 40001ecc 40006130: e0 06 21 6c ld [ %i0 + 0x16c ], %l0 *the_event_set |= the_new_events; 40006134: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 40006138: 82 10 40 19 or %g1, %i1, %g1 4000613c: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _ISR_Enable( level ); 40006140: 7f ff ef 67 call 40001edc 40006144: 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 ); 40006148: 40 00 00 15 call 4000619c <_Event_Surrender> 4000614c: 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 ) 40006150: 05 10 00 6b sethi %hi(0x4001ac00), %g2 40006154: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 40006158: b0 10 20 00 clr %i0 4000615c: 82 00 7f ff add %g1, -1, %g1 40006160: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] 40006164: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 40006168: 80 a0 60 00 cmp %g1, 0 4000616c: 12 80 00 04 bne 4000617c 40006170: 01 00 00 00 nop _Thread_Dispatch(); 40006174: 40 00 0e 1e call 400099ec <_Thread_Dispatch> 40006178: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000617c: 81 c7 e0 08 ret 40006180: 81 e8 00 00 restore 4000ba94 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 4000ba94: 9d e3 bf 98 save %sp, -104, %sp Extension_Control *the_extension; if ( !rtems_is_name_valid( name ) ) 4000ba98: a4 96 20 00 orcc %i0, 0, %l2 4000ba9c: 02 80 00 0e be 4000bad4 4000baa0: b0 10 20 03 mov 3, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000baa4: 05 10 00 a7 sethi %hi(0x40029c00), %g2 4000baa8: c2 00 a0 60 ld [ %g2 + 0x60 ], %g1 ! 40029c60 <_Thread_Dispatch_disable_level> 4000baac: 82 00 60 01 inc %g1 4000bab0: c2 20 a0 60 st %g1, [ %g2 + 0x60 ] * the inactive chain of free extension control blocks. */ RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void ) { return (Extension_Control *) _Objects_Allocate( &_Extension_Information ); 4000bab4: 23 10 00 a7 sethi %hi(0x40029c00), %l1 4000bab8: 40 00 03 ac call 4000c968 <_Objects_Allocate> 4000babc: 90 14 62 fc or %l1, 0x2fc, %o0 ! 40029efc <_Extension_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 4000bac0: a0 92 20 00 orcc %o0, 0, %l0 4000bac4: 12 80 00 06 bne 4000badc 4000bac8: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); 4000bacc: 7f ff ff e5 call 4000ba60 <_Thread_Enable_dispatch> <== NOT EXECUTED 4000bad0: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 4000bad4: 81 c7 e0 08 ret <== NOT EXECUTED 4000bad8: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 4000badc: 40 00 0e 28 call 4000f37c <_User_extensions_Add_set> 4000bae0: 92 10 00 19 mov %i1, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000bae4: 90 14 62 fc or %l1, 0x2fc, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000bae8: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000baec: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4000baf0: 05 00 00 3f sethi %hi(0xfc00), %g2 4000baf4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000baf8: 82 08 40 02 and %g1, %g2, %g1 4000bafc: 80 a0 40 03 cmp %g1, %g3 4000bb00: 38 80 00 06 bgu,a 4000bb18 4000bb04: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 4000bb08: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000bb0c: 83 28 60 02 sll %g1, 2, %g1 4000bb10: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 4000bb14: c2 04 20 08 ld [ %l0 + 8 ], %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; 4000bb18: e4 24 20 0c st %l2, [ %l0 + 0xc ] 4000bb1c: c2 26 80 00 st %g1, [ %i2 ] _Thread_Enable_dispatch(); 4000bb20: 7f ff ff d0 call 4000ba60 <_Thread_Enable_dispatch> 4000bb24: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 4000bb28: 81 c7 e0 08 ret 4000bb2c: 81 e8 00 00 restore 4000bb30 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 4000bb30: 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 *) 4000bb34: 21 10 00 a7 sethi %hi(0x40029c00), %l0 <== NOT EXECUTED 4000bb38: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000bb3c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 4000bb40: 40 00 04 ce call 4000ce78 <_Objects_Get> <== NOT EXECUTED 4000bb44: 90 14 22 fc or %l0, 0x2fc, %o0 <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 4000bb48: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4000bb4c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bb50: 02 80 00 07 be 4000bb6c <== NOT EXECUTED 4000bb54: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 4000bb58: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000bb5c: 08 80 00 20 bleu 4000bbdc <== NOT EXECUTED 4000bb60: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 4000bb64: 81 c7 e0 08 ret <== NOT EXECUTED 4000bb68: 91 e8 20 19 restore %g0, 0x19, %o0 <== 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 ); 4000bb6c: 40 00 0e 3e call 4000f464 <_User_extensions_Remove_set> <== NOT EXECUTED 4000bb70: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000bb74: 90 14 22 fc or %l0, 0x2fc, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000bb78: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000bb7c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 <== NOT EXECUTED 4000bb80: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED 4000bb84: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <== NOT EXECUTED 4000bb88: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 4000bb8c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4000bb90: 38 80 00 06 bgu,a 4000bba8 <== NOT EXECUTED 4000bb94: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000bb98: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 <== NOT EXECUTED 4000bb9c: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4000bba0: 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; 4000bba4: 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 ); 4000bba8: 40 00 04 72 call 4000cd70 <_Objects_Free> <== NOT EXECUTED 4000bbac: 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 ) 4000bbb0: 03 10 00 a7 sethi %hi(0x40029c00), %g1 <== NOT EXECUTED 4000bbb4: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 ! 40029c60 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000bbb8: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000bbbc: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 4000bbc0: c4 20 60 60 st %g2, [ %g1 + 0x60 ] <== NOT EXECUTED 4000bbc4: c2 00 60 60 ld [ %g1 + 0x60 ], %g1 <== NOT EXECUTED 4000bbc8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bbcc: 12 80 00 04 bne 4000bbdc <== NOT EXECUTED 4000bbd0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4000bbd4: 40 00 09 9d call 4000e248 <_Thread_Dispatch> <== NOT EXECUTED 4000bbd8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000bbdc: 81 c7 e0 08 ret <== NOT EXECUTED 4000bbe0: 81 e8 00 00 restore <== NOT EXECUTED 400073d8 : #include const char *rtems_get_version_string(void) { return _RTEMS_version; } 400073d8: 11 10 00 66 sethi %hi(0x40019800), %o0 <== NOT EXECUTED 400073dc: 81 c3 e0 08 retl <== NOT EXECUTED 400073e0: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 400199b0 <_RTEMS_version> <== NOT EXECUTED 40007178 : rtems_interrupt_level rtems_initialize_executive_early( rtems_configuration_table *configuration_table, rtems_cpu_table *cpu_table ) { 40007178: 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 ); 4000717c: 7f ff eb 54 call 40001ecc 40007180: 01 00 00 00 nop 40007184: a4 10 00 08 mov %o0, %l2 if ( configuration_table == NULL ) 40007188: 80 a6 20 00 cmp %i0, 0 4000718c: 12 80 00 07 bne 400071a8 40007190: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _Internal_error_Occurred( 40007194: 90 10 20 00 clr %o0 <== NOT EXECUTED 40007198: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 4000719c: 40 00 03 af call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 400071a0: 94 10 20 00 clr %o2 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; 400071a4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 400071a8: c0 20 63 b0 clr [ %g1 + 0x3b0 ] ! 4001afb0 <_System_state_Current> _System_state_Is_multiprocessing = is_multiprocessing; 400071ac: 03 10 00 6b sethi %hi(0x4001ac00), %g1 /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 400071b0: 94 10 20 28 mov 0x28, %o2 400071b4: 92 10 00 19 mov %i1, %o1 400071b8: c0 20 62 d8 clr [ %g1 + 0x2d8 ] 400071bc: 11 10 00 6b sethi %hi(0x4001ac00), %o0 400071c0: 40 00 21 54 call 4000f710 400071c4: 90 12 21 e4 or %o0, 0x1e4, %o0 ! 4001ade4 <_CPU_Table> /* * Provided just for user convenience. */ _Configuration_Table = configuration_table; 400071c8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_NO_CPU_TABLE ); _CPU_Initialize( cpu_table, _Thread_Dispatch ); 400071cc: 90 10 00 19 mov %i1, %o0 400071d0: 13 10 00 26 sethi %hi(0x40009800), %o1 400071d4: 92 12 61 ec or %o1, 0x1ec, %o1 ! 400099ec <_Thread_Dispatch> 400071d8: 40 00 10 c3 call 4000b4e4 <_CPU_Initialize> 400071dc: f0 20 62 90 st %i0, [ %g1 + 0x290 ] /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 400071e0: 40 00 19 41 call 4000d6e4 <_Debug_Manager_initialization> 400071e4: 01 00 00 00 nop _API_extensions_Initialization(); 400071e8: 40 00 00 f2 call 400075b0 <_API_extensions_Initialization> 400071ec: 01 00 00 00 nop _Thread_Dispatch_initialization(); _Workspace_Handler_initialization( 400071f0: d2 06 20 04 ld [ %i0 + 4 ], %o1 400071f4: 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; 400071f8: 84 10 20 01 mov 1, %g2 400071fc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40007200: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ] ! 4001add0 <_Thread_Dispatch_disable_level> 40007204: 40 00 0f 8e call 4000b03c <_Workspace_Handler_initialization> 40007208: 23 10 00 6b sethi %hi(0x4001ac00), %l1 (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 4000720c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 40007210: 40 00 0e 2e call 4000aac8 <_User_extensions_Handler_initialization> 40007214: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 40007218: 40 00 03 a0 call 40008098 <_ISR_Handler_initialization> 4000721c: a0 07 bf e8 add %fp, -24, %l0 _Objects_Handler_initialization( 40007220: 90 10 20 01 mov 1, %o0 40007224: 92 10 20 01 mov 1, %o1 40007228: 40 00 05 96 call 40008880 <_Objects_Handler_initialization> 4000722c: 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; 40007230: 05 10 00 6b sethi %hi(0x4001ac00), %g2 /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 40007234: 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; 40007238: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000723c: 82 10 62 10 or %g1, 0x210, %g1 ! 4001ae10 <_Internal_Objects> /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 40007240: 96 10 20 01 mov 1, %o3 multiprocessing_table->node, multiprocessing_table->maximum_nodes, multiprocessing_table->maximum_global_objects ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 40007244: c2 20 a1 34 st %g1, [ %g2 + 0x134 ] /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 40007248: 98 10 20 74 mov 0x74, %o4 4000724c: 9a 10 20 00 clr %o5 40007250: 90 14 62 dc or %l1, 0x2dc, %o0 40007254: 92 10 20 01 mov 1, %o1 40007258: 40 00 05 16 call 400086b0 <_Objects_Initialize_information> 4000725c: 94 10 20 02 mov 2, %o2 _API_Mutex_Allocate( _RTEMS_Allocator_Mutex ); 40007260: 94 10 20 10 mov 0x10, %o2 40007264: 13 10 00 64 sethi %hi(0x40019000), %o1 40007268: 90 10 00 10 mov %l0, %o0 4000726c: 40 00 21 29 call 4000f710 40007270: 92 12 60 08 or %o1, 8, %o1 40007274: 40 00 03 a6 call 4000810c <_Objects_Allocate> 40007278: 90 14 62 dc or %l1, 0x2dc, %o0 4000727c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40007280: 84 10 00 08 mov %o0, %g2 40007284: 92 10 00 10 mov %l0, %o1 40007288: c4 20 62 a4 st %g2, [ %g1 + 0x2a4 ] 4000728c: 90 02 20 10 add %o0, 0x10, %o0 40007290: 40 00 01 2a call 40007738 <_CORE_mutex_Initialize> 40007294: 94 10 20 01 mov 1, %o2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 40007298: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000729c: 84 10 20 00 clr %g2 400072a0: c0 30 62 a0 clrh [ %g1 + 0x2a0 ] for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 400072a4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400072a8: 82 10 63 30 or %g1, 0x330, %g1 ! 4001af30 <_Priority_Bit_map> 400072ac: c0 30 80 01 clrh [ %g2 + %g1 ] 400072b0: 84 00 a0 02 add %g2, 2, %g2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; for ( index=0 ; index <16 ; index++ ) 400072b4: 80 a0 a0 20 cmp %g2, 0x20 400072b8: 32 bf ff fe bne,a 400072b0 400072bc: c0 30 80 01 clrh [ %g2 + %g1 ] _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 400072c0: 40 00 0e ed call 4000ae74 <_Watchdog_Handler_initialization> 400072c4: 01 00 00 00 nop _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 400072c8: 40 00 02 08 call 40007ae8 <_TOD_Handler_initialization> 400072cc: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _Thread_Handler_initialization( 400072d0: d2 06 20 08 ld [ %i0 + 8 ], %o1 400072d4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 400072d8: 40 00 0a 85 call 40009cec <_Thread_Handler_initialization> 400072dc: 94 10 20 00 clr %o2 ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 400072e0: 40 00 00 95 call 40007534 <_RTEMS_API_Initialize> 400072e4: 90 10 00 18 mov %i0, %o0 _Extension_Manager_initialization( configuration_table->maximum_extensions ); 400072e8: 40 00 00 28 call 40007388 <_Extension_Manager_initialization> 400072ec: d0 06 20 08 ld [ %i0 + 8 ], %o0 _IO_Manager_initialization( 400072f0: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 400072f4: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 400072f8: 40 00 00 49 call 4000741c <_IO_Manager_initialization> 400072fc: 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 ); 40007300: 40 00 00 68 call 400074a0 <_POSIX_API_Initialize> 40007304: 90 10 00 18 mov %i0, %o0 RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 40007308: 84 10 20 01 mov 1, %g2 4000730c: 03 10 00 6b sethi %hi(0x4001ac00), %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(); 40007310: 40 00 09 5b call 4000987c <_Thread_Create_idle> 40007314: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] ! 4001afb0 <_System_state_Current> /* * Scheduling can properly occur now as long as we avoid dispatching. */ if ( cpu_table->pretasking_hook ) 40007318: d0 06 40 00 ld [ %i1 ], %o0 4000731c: 80 a2 20 00 cmp %o0, 0 40007320: 02 80 00 04 be 40007330 40007324: 01 00 00 00 nop (*cpu_table->pretasking_hook)(); 40007328: 9f c2 00 00 call %o0 4000732c: 01 00 00 00 nop /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 40007330: 40 00 00 bf call 4000762c <_API_extensions_Run_predriver> 40007334: 01 00 00 00 nop if ( _CPU_Table.predriver_hook ) 40007338: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000733c: a0 10 61 e4 or %g1, 0x1e4, %l0 ! 4001ade4 <_CPU_Table> 40007340: c2 04 20 04 ld [ %l0 + 4 ], %g1 40007344: 80 a0 60 00 cmp %g1, 0 40007348: 02 80 00 04 be 40007358 4000734c: 01 00 00 00 nop (*_CPU_Table.predriver_hook)(); 40007350: 9f c0 40 00 call %g1 40007354: 01 00 00 00 nop * Initialize all the device drivers and initialize the MPCI layer. * * NOTE: The MPCI may be build upon a device driver. */ _IO_Initialize_all_drivers(); 40007358: 40 00 00 23 call 400073e4 <_IO_Initialize_all_drivers> 4000735c: 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(); 40007360: 40 00 00 9b call 400075cc <_API_extensions_Run_postdriver> 40007364: 01 00 00 00 nop if ( _CPU_Table.postdriver_hook ) 40007368: c2 04 20 08 ld [ %l0 + 8 ], %g1 4000736c: 80 a0 60 00 cmp %g1, 0 40007370: 02 80 00 04 be 40007380 40007374: 01 00 00 00 nop (*_CPU_Table.postdriver_hook)(); 40007378: 9f c0 40 00 call %g1 4000737c: 01 00 00 00 nop return bsp_level; } 40007380: 81 c7 e0 08 ret 40007384: 91 e8 00 12 restore %g0, %l2, %o0 40008478 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 40008478: 9d e3 bf 98 save %sp, -104, %sp /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 4000847c: 92 96 60 00 orcc %i1, 0, %o1 40008480: 02 80 00 40 be 40008580 40008484: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 40008488: 02 80 00 41 be 4000858c 4000848c: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 40008490: c2 02 40 00 ld [ %o1 ], %g1 40008494: 80 a0 60 00 cmp %g1, 0 40008498: 12 80 00 07 bne 400084b4 4000849c: 03 10 00 7c sethi %hi(0x4001f000), %g1 400084a0: c2 02 60 04 ld [ %o1 + 4 ], %g1 400084a4: 80 a0 60 00 cmp %g1, 0 400084a8: 22 80 00 39 be,a 4000858c 400084ac: 82 10 20 09 mov 9, %g1 *registered_major = 0; /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 400084b0: 03 10 00 7c sethi %hi(0x4001f000), %g1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) return RTEMS_INVALID_ADDRESS; *registered_major = 0; 400084b4: c0 26 80 00 clr [ %i2 ] /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 400084b8: c8 00 63 1c ld [ %g1 + 0x31c ], %g4 400084bc: 80 a6 00 04 cmp %i0, %g4 400084c0: 1a 80 00 33 bcc 4000858c 400084c4: 82 10 20 0a mov 0xa, %g1 /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 400084c8: 80 a6 20 00 cmp %i0, 0 400084cc: 12 80 00 18 bne 4000852c 400084d0: 03 10 00 7c sethi %hi(0x4001f000), %g1 boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 400084d4: c6 00 63 20 ld [ %g1 + 0x320 ], %g3 ! 4001f320 <_IO_Driver_address_table> 400084d8: 85 29 20 03 sll %g4, 3, %g2 400084dc: 83 29 20 05 sll %g4, 5, %g1 400084e0: b0 01 3f ff add %g4, -1, %i0 400084e4: 82 20 40 02 sub %g1, %g2, %g1 400084e8: 82 00 7f e8 add %g1, -24, %g1 400084ec: 10 80 00 0b b 40008518 400084f0: 84 00 40 03 add %g1, %g3, %g2 if ( !_IO_Driver_address_table[major].initialization_entry && 400084f4: 80 a0 60 00 cmp %g1, 0 400084f8: 32 80 00 07 bne,a 40008514 400084fc: b0 06 3f ff add %i0, -1, %i0 40008500: c2 00 a0 04 ld [ %g2 + 4 ], %g1 40008504: 80 a0 60 00 cmp %g1, 0 40008508: 02 80 00 09 be 4000852c 4000850c: 03 10 00 7c sethi %hi(0x4001f000), %g1 * in use. */ if ( major == 0 ) { boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 40008510: b0 06 3f ff add %i0, -1, %i0 <== NOT EXECUTED 40008514: 84 00 bf e8 add %g2, -24, %g2 40008518: 80 a6 20 00 cmp %i0, 0 4000851c: 32 bf ff f6 bne,a 400084f4 40008520: c2 00 80 00 ld [ %g2 ], %g1 40008524: 10 80 00 1a b 4000858c 40008528: 82 10 20 05 mov 5, %g1 if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 4000852c: c6 00 63 20 ld [ %g1 + 0x320 ], %g3 40008530: 85 2e 20 03 sll %i0, 3, %g2 40008534: 83 2e 20 05 sll %i0, 5, %g1 40008538: 82 20 40 02 sub %g1, %g2, %g1 4000853c: c4 00 40 03 ld [ %g1 + %g3 ], %g2 40008540: 80 a0 a0 00 cmp %g2, 0 40008544: 12 80 00 11 bne 40008588 40008548: 90 00 40 03 add %g1, %g3, %o0 4000854c: c2 02 20 04 ld [ %o0 + 4 ], %g1 40008550: 80 a0 60 00 cmp %g1, 0 40008554: 32 80 00 0e bne,a 4000858c 40008558: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 4000855c: 40 00 20 2e call 40010614 40008560: 94 10 20 18 mov 0x18, %o2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40008564: 90 10 00 18 mov %i0, %o0 _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; *registered_major = major; 40008568: f0 26 80 00 st %i0, [ %i2 ] rtems_io_initialize( major, 0, NULL ); 4000856c: 92 10 20 00 clr %o1 40008570: 7f ff ff 52 call 400082b8 40008574: 94 10 20 00 clr %o2 40008578: 10 80 00 05 b 4000858c 4000857c: 82 10 20 00 clr %g1 return RTEMS_SUCCESSFUL; 40008580: 10 80 00 03 b 4000858c 40008584: 82 10 20 09 mov 9, %g1 40008588: 82 10 20 0c mov 0xc, %g1 } 4000858c: 81 c7 e0 08 ret 40008590: 91 e8 00 01 restore %g0, %g1, %o0 40009adc : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 40009adc: 9d e3 bf 98 save %sp, -104, %sp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 40009ae0: 80 a6 20 00 cmp %i0, 0 40009ae4: 02 80 00 1d be 40009b58 40009ae8: 03 10 00 9e sethi %hi(0x40027800), %g1 return; 40009aec: a4 10 61 54 or %g1, 0x154, %l2 ! 40027954 <_Objects_Information_table+0x4> for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 40009af0: a6 04 a0 10 add %l2, 0x10, %l3 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 40009af4: c2 04 80 00 ld [ %l2 ], %g1 40009af8: 80 a0 60 00 cmp %g1, 0 40009afc: 22 80 00 14 be,a 40009b4c 40009b00: a4 04 a0 04 add %l2, 4, %l2 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 40009b04: e0 00 60 04 ld [ %g1 + 4 ], %l0 if ( information ) { 40009b08: 80 a4 20 00 cmp %l0, 0 40009b0c: 12 80 00 0b bne 40009b38 40009b10: a2 10 20 01 mov 1, %l1 for ( i=1 ; i <= information->maximum ; i++ ) { 40009b14: 10 80 00 0e b 40009b4c <== NOT EXECUTED 40009b18: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED the_thread = (Thread_Control *)information->local_table[ i ]; 40009b1c: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 40009b20: d0 00 40 08 ld [ %g1 + %o0 ], %o0 if ( !the_thread ) 40009b24: 80 a2 20 00 cmp %o0, 0 40009b28: 02 80 00 04 be 40009b38 40009b2c: a2 04 60 01 inc %l1 continue; (*routine)(the_thread); 40009b30: 9f c6 00 00 call %i0 40009b34: 01 00 00 00 nop 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++ ) { 40009b38: c2 14 20 10 lduh [ %l0 + 0x10 ], %g1 40009b3c: 80 a4 40 01 cmp %l1, %g1 40009b40: 08 bf ff f7 bleu 40009b1c 40009b44: 91 2c 60 02 sll %l1, 2, %o0 40009b48: a4 04 a0 04 add %l2, 4, %l2 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 40009b4c: 80 a4 80 13 cmp %l2, %l3 40009b50: 32 bf ff ea bne,a 40009af8 40009b54: c2 04 80 00 ld [ %l2 ], %g1 40009b58: 81 c7 e0 08 ret 40009b5c: 81 e8 00 00 restore 4000f624 : Objects_Id id, void *buffer, size_t size, uint32_t *count ) { 4000f624: 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 ) 4000f628: 80 a6 60 00 cmp %i1, 0 4000f62c: 02 80 00 26 be 4000f6c4 4000f630: 80 a6 e0 00 cmp %i3, 0 return RTEMS_INVALID_ADDRESS; if ( !count ) 4000f634: 02 80 00 24 be 4000f6c4 4000f638: 11 10 00 d4 sethi %hi(0x40035000), %o0 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 4000f63c: 92 10 00 18 mov %i0, %o1 4000f640: 90 12 22 a0 or %o0, 0x2a0, %o0 4000f644: 40 00 18 b0 call 40015904 <_Objects_Get> 4000f648: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 4000f64c: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f650: 80 a0 60 00 cmp %g1, 0 4000f654: 02 80 00 07 be 4000f670 4000f658: 9a 10 00 1b mov %i3, %o5 4000f65c: 80 a0 60 02 cmp %g1, 2 4000f660: 08 80 00 1a bleu 4000f6c8 4000f664: 90 10 20 04 mov 4, %o0 4000f668: 10 80 00 18 b 4000f6c8 <== NOT EXECUTED 4000f66c: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 4000f670: 92 10 00 19 mov %i1, %o1 4000f674: 94 10 00 1a mov %i2, %o2 4000f678: 96 10 00 18 mov %i0, %o3 4000f67c: 98 10 20 00 clr %o4 4000f680: 40 00 13 3e call 40014378 <_CORE_message_queue_Broadcast> 4000f684: 90 02 20 14 add %o0, 0x14, %o0 4000f688: 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 ) 4000f68c: 03 10 00 d2 sethi %hi(0x40034800), %g1 4000f690: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 400348b0 <_Thread_Dispatch_disable_level> 4000f694: 84 00 bf ff add %g2, -1, %g2 4000f698: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ] 4000f69c: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 4000f6a0: 80 a0 60 00 cmp %g1, 0 4000f6a4: 12 80 00 04 bne 4000f6b4 4000f6a8: 01 00 00 00 nop _Thread_Dispatch(); 4000f6ac: 40 00 1d 8a call 40016cd4 <_Thread_Dispatch> 4000f6b0: 01 00 00 00 nop #endif count ); _Thread_Enable_dispatch(); return 4000f6b4: 40 00 01 2e call 4000fb6c <_Message_queue_Translate_core_message_queue_return_code> 4000f6b8: 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 */ } 4000f6bc: 81 c7 e0 08 ret 4000f6c0: 91 e8 00 08 restore %g0, %o0, %o0 #endif count ); _Thread_Enable_dispatch(); return 4000f6c4: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED _Message_queue_Translate_core_message_queue_return_code( core_status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f6c8: b0 10 00 08 mov %o0, %i0 4000f6cc: 81 c7 e0 08 ret 4000f6d0: 81 e8 00 00 restore 4000f708 : uint32_t count, uint32_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 4000f708: 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 ) ) 4000f70c: a2 96 20 00 orcc %i0, 0, %l1 4000f710: 02 80 00 17 be 4000f76c 4000f714: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 4000f718: 80 a7 20 00 cmp %i4, 0 4000f71c: 02 80 00 14 be 4000f76c 4000f720: 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 ) 4000f724: 80 a6 60 00 cmp %i1, 0 4000f728: 02 80 00 11 be 4000f76c 4000f72c: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 4000f730: 80 a6 a0 00 cmp %i2, 0 4000f734: 02 80 00 0e be 4000f76c 4000f738: b0 10 20 08 mov 8, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000f73c: 05 10 00 d2 sethi %hi(0x40034800), %g2 4000f740: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 4000f744: 82 00 60 01 inc %g1 4000f748: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate( count, max_message_size ); 4000f74c: 90 10 00 19 mov %i1, %o0 4000f750: 40 00 2c f2 call 4001ab18 <_Message_queue_Allocate> 4000f754: 92 10 00 1a mov %i2, %o1 if ( !the_message_queue ) { 4000f758: a0 92 20 00 orcc %o0, 0, %l0 4000f75c: 12 80 00 06 bne 4000f774 4000f760: 80 8e e0 04 btst 4, %i3 _Thread_Enable_dispatch(); 4000f764: 7f ff ff dc call 4000f6d4 <_Thread_Enable_dispatch> 4000f768: b0 10 20 05 mov 5, %i0 4000f76c: 81 c7 e0 08 ret 4000f770: 81 e8 00 00 restore } #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) 4000f774: 02 80 00 05 be 4000f788 4000f778: f6 24 20 10 st %i3, [ %l0 + 0x10 ] the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 4000f77c: 82 10 20 01 mov 1, %g1 4000f780: 10 80 00 03 b 4000f78c 4000f784: c2 27 bf f4 st %g1, [ %fp + -12 ] else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 4000f788: c0 27 bf f4 clr [ %fp + -12 ] if ( ! _CORE_message_queue_Initialize( 4000f78c: 94 10 00 19 mov %i1, %o2 4000f790: 96 10 00 1a mov %i2, %o3 4000f794: 90 04 20 14 add %l0, 0x14, %o0 4000f798: 40 00 13 44 call 400144a8 <_CORE_message_queue_Initialize> 4000f79c: 92 07 bf f4 add %fp, -12, %o1 4000f7a0: 80 a2 20 00 cmp %o0, 0 4000f7a4: 12 80 00 0a bne 4000f7cc 4000f7a8: 11 10 00 d4 sethi %hi(0x40035000), %o0 RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 4000f7ac: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 400352a0 <_Message_queue_Information> <== NOT EXECUTED 4000f7b0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 4000f7b4: 40 00 17 fe call 400157ac <_Objects_Free> <== NOT EXECUTED 4000f7b8: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 4000f7bc: 7f ff ff c6 call 4000f6d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 4000f7c0: 01 00 00 00 nop <== NOT EXECUTED 4000f7c4: 81 c7 e0 08 ret <== NOT EXECUTED 4000f7c8: 81 e8 00 00 restore <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f7cc: 90 12 22 a0 or %o0, 0x2a0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000f7d0: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f7d4: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4000f7d8: 05 00 00 3f sethi %hi(0xfc00), %g2 4000f7dc: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000f7e0: 82 08 40 02 and %g1, %g2, %g1 4000f7e4: 80 a0 40 03 cmp %g1, %g3 4000f7e8: 38 80 00 06 bgu,a 4000f800 4000f7ec: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 4000f7f0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000f7f4: 83 28 60 02 sll %g1, 2, %g1 4000f7f8: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 4000f7fc: c2 04 20 08 ld [ %l0 + 8 ], %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; 4000f800: e2 24 20 0c st %l1, [ %l0 + 0xc ] 4000f804: c2 27 00 00 st %g1, [ %i4 ] name, 0 ); #endif _Thread_Enable_dispatch(); 4000f808: 7f ff ff b3 call 4000f6d4 <_Thread_Enable_dispatch> 4000f80c: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 4000f810: 81 c7 e0 08 ret 4000f814: 81 e8 00 00 restore 40013a50 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 40013a50: 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 *) 40013a54: 21 10 00 a9 sethi %hi(0x4002a400), %l0 40013a58: 92 10 00 18 mov %i0, %o1 40013a5c: 94 07 bf f4 add %fp, -12, %o2 40013a60: 7f ff e5 06 call 4000ce78 <_Objects_Get> 40013a64: 90 14 22 cc or %l0, 0x2cc, %o0 register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 40013a68: c2 07 bf f4 ld [ %fp + -12 ], %g1 40013a6c: 80 a0 60 00 cmp %g1, 0 40013a70: 02 80 00 07 be 40013a8c 40013a74: b0 10 00 08 mov %o0, %i0 40013a78: 80 a0 60 02 cmp %g1, 2 40013a7c: 08 80 00 22 bleu 40013b04 40013a80: b0 10 20 04 mov 4, %i0 40013a84: 81 c7 e0 08 ret <== NOT EXECUTED 40013a88: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40013a8c: a0 14 22 cc or %l0, 0x2cc, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40013a90: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40013a94: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 40013a98: 05 00 00 3f sethi %hi(0xfc00), %g2 40013a9c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40013aa0: 82 08 40 02 and %g1, %g2, %g1 40013aa4: 80 a0 40 03 cmp %g1, %g3 40013aa8: 18 80 00 05 bgu 40013abc 40013aac: 94 10 20 05 mov 5, %o2 information->local_table[ index ] = the_object; 40013ab0: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 40013ab4: 83 28 60 02 sll %g1, 2, %g1 40013ab8: c0 20 80 01 clr [ %g2 + %g1 ] case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, &the_message_queue->Object ); _CORE_message_queue_Close( 40013abc: 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; 40013ac0: c0 26 20 0c clr [ %i0 + 0xc ] 40013ac4: 40 00 01 9e call 4001413c <_CORE_message_queue_Close> 40013ac8: 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 ); 40013acc: 90 10 00 10 mov %l0, %o0 40013ad0: 7f ff e4 a8 call 4000cd70 <_Objects_Free> 40013ad4: 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 ) 40013ad8: 03 10 00 a7 sethi %hi(0x40029c00), %g1 40013adc: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 ! 40029c60 <_Thread_Dispatch_disable_level> 40013ae0: b0 10 20 00 clr %i0 40013ae4: 84 00 bf ff add %g2, -1, %g2 40013ae8: c4 20 60 60 st %g2, [ %g1 + 0x60 ] 40013aec: c2 00 60 60 ld [ %g1 + 0x60 ], %g1 40013af0: 80 a0 60 00 cmp %g1, 0 40013af4: 12 80 00 04 bne 40013b04 40013af8: 01 00 00 00 nop _Thread_Dispatch(); 40013afc: 7f ff e9 d3 call 4000e248 <_Thread_Dispatch> 40013b00: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40013b04: 81 c7 e0 08 ret 40013b08: 81 e8 00 00 restore 4000f8d4 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 4000f8d4: 9d e3 bf 90 save %sp, -112, %sp 4000f8d8: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 4000f8dc: 80 a6 60 00 cmp %i1, 0 4000f8e0: 02 80 00 1c be 4000f950 4000f8e4: 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 *) 4000f8e8: 11 10 00 d4 sethi %hi(0x40035000), %o0 4000f8ec: 94 07 bf f4 add %fp, -12, %o2 4000f8f0: 40 00 18 05 call 40015904 <_Objects_Get> 4000f8f4: 90 12 22 a0 or %o0, 0x2a0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 4000f8f8: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f8fc: 80 a0 60 00 cmp %g1, 0 4000f900: 02 80 00 06 be 4000f918 4000f904: 80 a0 60 02 cmp %g1, 2 4000f908: 08 80 00 12 bleu 4000f950 4000f90c: b0 10 20 04 mov 4, %i0 4000f910: 81 c7 e0 08 ret <== NOT EXECUTED 4000f914: 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 ); 4000f918: 40 00 12 c5 call 4001442c <_CORE_message_queue_Flush> 4000f91c: 90 02 20 14 add %o0, 0x14, %o0 4000f920: 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 ) 4000f924: 03 10 00 d2 sethi %hi(0x40034800), %g1 4000f928: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 400348b0 <_Thread_Dispatch_disable_level> 4000f92c: b0 10 20 00 clr %i0 4000f930: 84 00 bf ff add %g2, -1, %g2 4000f934: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ] 4000f938: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 4000f93c: 80 a0 60 00 cmp %g1, 0 4000f940: 12 80 00 04 bne 4000f950 4000f944: 01 00 00 00 nop _Thread_Dispatch(); 4000f948: 40 00 1c e3 call 40016cd4 <_Thread_Dispatch> 4000f94c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f950: 81 c7 e0 08 ret 4000f954: 81 e8 00 00 restore 4000f958 : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 4000f958: 9d e3 bf 90 save %sp, -112, %sp 4000f95c: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 4000f960: 80 a6 60 00 cmp %i1, 0 4000f964: 02 80 00 1b be 4000f9d0 4000f968: b0 10 20 09 mov 9, %i0 4000f96c: 11 10 00 d4 sethi %hi(0x40035000), %o0 4000f970: 94 07 bf f4 add %fp, -12, %o2 4000f974: 40 00 17 e4 call 40015904 <_Objects_Get> 4000f978: 90 12 22 a0 or %o0, 0x2a0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 4000f97c: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f980: 80 a0 60 00 cmp %g1, 0 4000f984: 22 80 00 07 be,a 4000f9a0 4000f988: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 4000f98c: 80 a0 60 02 cmp %g1, 2 4000f990: 08 80 00 10 bleu 4000f9d0 4000f994: b0 10 20 04 mov 4, %i0 4000f998: 81 c7 e0 08 ret <== NOT EXECUTED 4000f99c: 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; 4000f9a0: 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 ) 4000f9a4: 05 10 00 d2 sethi %hi(0x40034800), %g2 4000f9a8: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 4000f9ac: b0 10 20 00 clr %i0 4000f9b0: 82 00 7f ff add %g1, -1, %g1 4000f9b4: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] 4000f9b8: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 4000f9bc: 80 a0 60 00 cmp %g1, 0 4000f9c0: 12 80 00 04 bne 4000f9d0 4000f9c4: 01 00 00 00 nop _Thread_Dispatch(); 4000f9c8: 40 00 1c c3 call 40016cd4 <_Thread_Dispatch> 4000f9cc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f9d0: 81 c7 e0 08 ret 4000f9d4: 81 e8 00 00 restore 40013b40 : void *buffer, size_t *size, uint32_t option_set, rtems_interval timeout ) { 40013b40: 9d e3 bf 90 save %sp, -112, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; boolean wait; if ( !buffer ) 40013b44: 80 a6 60 00 cmp %i1, 0 40013b48: 02 80 00 28 be 40013be8 40013b4c: 92 10 00 18 mov %i0, %o1 return RTEMS_INVALID_ADDRESS; if ( !size ) 40013b50: 80 a6 a0 00 cmp %i2, 0 40013b54: 02 80 00 25 be 40013be8 40013b58: 11 10 00 a9 sethi %hi(0x4002a400), %o0 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 40013b5c: 94 07 bf f4 add %fp, -12, %o2 40013b60: 7f ff e4 c6 call 4000ce78 <_Objects_Get> 40013b64: 90 12 22 cc or %o0, 0x2cc, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 40013b68: c2 07 bf f4 ld [ %fp + -12 ], %g1 40013b6c: 80 a0 60 00 cmp %g1, 0 40013b70: 22 80 00 07 be,a 40013b8c 40013b74: d2 02 20 08 ld [ %o0 + 8 ], %o1 40013b78: 80 a0 60 02 cmp %g1, 2 40013b7c: 08 80 00 1c bleu 40013bec 40013b80: 90 10 20 04 mov 4, %o0 40013b84: 10 80 00 1a b 40013bec <== NOT EXECUTED 40013b88: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED 40013b8c: 98 0e e0 01 and %i3, 1, %o4 if ( _Options_Is_no_wait( option_set ) ) wait = FALSE; else wait = TRUE; _CORE_message_queue_Seize( 40013b90: 94 10 00 19 mov %i1, %o2 40013b94: 96 10 00 1a mov %i2, %o3 40013b98: 98 1b 20 01 xor %o4, 1, %o4 40013b9c: 9a 10 00 1c mov %i4, %o5 40013ba0: 40 00 01 94 call 400141f0 <_CORE_message_queue_Seize> 40013ba4: 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 ) 40013ba8: 05 10 00 a7 sethi %hi(0x40029c00), %g2 40013bac: c2 00 a0 60 ld [ %g2 + 0x60 ], %g1 ! 40029c60 <_Thread_Dispatch_disable_level> 40013bb0: 82 00 7f ff add %g1, -1, %g1 40013bb4: c2 20 a0 60 st %g1, [ %g2 + 0x60 ] 40013bb8: c2 00 a0 60 ld [ %g2 + 0x60 ], %g1 40013bbc: 80 a0 60 00 cmp %g1, 0 40013bc0: 12 80 00 05 bne 40013bd4 40013bc4: 03 10 00 a7 sethi %hi(0x40029c00), %g1 _Thread_Dispatch(); 40013bc8: 7f ff e9 a0 call 4000e248 <_Thread_Dispatch> 40013bcc: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 40013bd0: 03 10 00 a7 sethi %hi(0x40029c00), %g1 40013bd4: c2 00 61 3c ld [ %g1 + 0x13c ], %g1 ! 40029d3c <_Thread_Executing> 40013bd8: 40 00 00 32 call 40013ca0 <_Message_queue_Translate_core_message_queue_return_code> 40013bdc: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40013be0: 81 c7 e0 08 ret 40013be4: 91 e8 00 08 restore %g0, %o0, %o0 size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 40013be8: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40013bec: b0 10 00 08 mov %o0, %i0 40013bf0: 81 c7 e0 08 ret 40013bf4: 81 e8 00 00 restore 40013bf8 : rtems_status_code rtems_message_queue_send( Objects_Id id, void *buffer, size_t size ) { 40013bf8: 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 ) 40013bfc: 80 a6 60 00 cmp %i1, 0 40013c00: 02 80 00 26 be 40013c98 40013c04: 90 10 20 09 mov 9, %o0 40013c08: 11 10 00 a9 sethi %hi(0x4002a400), %o0 40013c0c: 92 10 00 18 mov %i0, %o1 40013c10: 90 12 22 cc or %o0, 0x2cc, %o0 40013c14: 7f ff e4 99 call 4000ce78 <_Objects_Get> 40013c18: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 40013c1c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40013c20: 80 a0 60 00 cmp %g1, 0 40013c24: 22 80 00 07 be,a 40013c40 40013c28: 94 10 00 1a mov %i2, %o2 40013c2c: 80 a0 60 02 cmp %g1, 2 40013c30: 08 80 00 1a bleu 40013c98 40013c34: 90 10 20 04 mov 4, %o0 40013c38: 10 80 00 18 b 40013c98 <== NOT EXECUTED 40013c3c: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 40013c40: c0 23 a0 5c clr [ %sp + 0x5c ] 40013c44: c0 23 a0 60 clr [ %sp + 0x60 ] 40013c48: 92 10 00 19 mov %i1, %o1 40013c4c: 96 10 00 18 mov %i0, %o3 40013c50: 98 10 20 00 clr %o4 40013c54: 90 02 20 14 add %o0, 0x14, %o0 40013c58: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5 40013c5c: 40 00 01 b2 call 40014324 <_CORE_message_queue_Submit> 40013c60: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff 40013c64: 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 ) 40013c68: 05 10 00 a7 sethi %hi(0x40029c00), %g2 40013c6c: c2 00 a0 60 ld [ %g2 + 0x60 ], %g1 ! 40029c60 <_Thread_Dispatch_disable_level> 40013c70: 82 00 7f ff add %g1, -1, %g1 40013c74: c2 20 a0 60 st %g1, [ %g2 + 0x60 ] 40013c78: c2 00 a0 60 ld [ %g2 + 0x60 ], %g1 40013c7c: 80 a0 60 00 cmp %g1, 0 40013c80: 12 80 00 04 bne 40013c90 40013c84: 01 00 00 00 nop _Thread_Dispatch(); 40013c88: 7f ff e9 70 call 4000e248 <_Thread_Dispatch> 40013c8c: 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); 40013c90: 40 00 00 04 call 40013ca0 <_Message_queue_Translate_core_message_queue_return_code> 40013c94: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40013c98: 81 c7 e0 08 ret 40013c9c: 91 e8 00 08 restore %g0, %o0, %o0 4000916c : rtems_status_code rtems_message_queue_urgent( Objects_Id id, void *buffer, size_t size ) { 4000916c: 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 ) 40009170: 80 a6 60 00 cmp %i1, 0 40009174: 02 80 00 25 be 40009208 40009178: 90 10 20 09 mov 9, %o0 4000917c: 11 10 00 8d sethi %hi(0x40023400), %o0 40009180: 92 10 00 18 mov %i0, %o1 40009184: 90 12 22 b8 or %o0, 0x2b8, %o0 40009188: 40 00 0a 05 call 4000b99c <_Objects_Get> 4000918c: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 40009190: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009194: 80 a0 60 00 cmp %g1, 0 40009198: 22 80 00 07 be,a 400091b4 4000919c: 94 10 00 1a mov %i2, %o2 400091a0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 400091a4: 08 80 00 19 bleu 40009208 <== NOT EXECUTED 400091a8: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED 400091ac: 10 80 00 17 b 40009208 <== NOT EXECUTED 400091b0: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 400091b4: c0 23 a0 5c clr [ %sp + 0x5c ] 400091b8: c0 23 a0 60 clr [ %sp + 0x60 ] 400091bc: 92 10 00 19 mov %i1, %o1 400091c0: 96 10 00 18 mov %i0, %o3 400091c4: 98 10 20 00 clr %o4 400091c8: 1b 20 00 00 sethi %hi(0x80000000), %o5 400091cc: 40 00 05 ef call 4000a988 <_CORE_message_queue_Submit> 400091d0: 90 02 20 14 add %o0, 0x14, %o0 400091d4: 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 ) 400091d8: 03 10 00 8b sethi %hi(0x40022c00), %g1 400091dc: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 40022cd0 <_Thread_Dispatch_disable_level> 400091e0: 84 00 bf ff add %g2, -1, %g2 400091e4: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 400091e8: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 400091ec: 80 a0 60 00 cmp %g1, 0 400091f0: 12 80 00 04 bne 40009200 400091f4: 01 00 00 00 nop _Thread_Dispatch(); 400091f8: 40 00 0e dd call 4000cd6c <_Thread_Dispatch> 400091fc: 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); 40009200: 7f ff ff d1 call 40009144 <_Message_queue_Translate_core_message_queue_return_code> 40009204: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40009208: 81 c7 e0 08 ret 4000920c: 91 e8 00 08 restore %g0, %o0, %o0 4000fbc8 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 4000fbc8: 9d e3 bf 98 save %sp, -104, %sp register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 4000fbcc: a6 96 20 00 orcc %i0, 0, %l3 4000fbd0: 02 80 00 1e be 4000fc48 4000fbd4: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 4000fbd8: 80 a6 60 00 cmp %i1, 0 4000fbdc: 02 80 00 3d be 4000fcd0 4000fbe0: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 4000fbe4: 02 80 00 3b be 4000fcd0 4000fbe8: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 4000fbec: 22 80 00 17 be,a 4000fc48 4000fbf0: b0 10 20 08 mov 8, %i0 4000fbf4: 80 a6 e0 00 cmp %i3, 0 4000fbf8: 22 80 00 14 be,a 4000fc48 4000fbfc: b0 10 20 08 mov 8, %i0 4000fc00: 80 a6 80 1b cmp %i2, %i3 4000fc04: 0a 80 00 35 bcs 4000fcd8 4000fc08: 80 8e e0 07 btst 7, %i3 4000fc0c: 12 80 00 33 bne 4000fcd8 4000fc10: 80 8e 60 07 btst 7, %i1 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 4000fc14: 12 80 00 2f bne 4000fcd0 4000fc18: 05 10 00 d2 sethi %hi(0x40034800), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000fc1c: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 4000fc20: 82 00 60 01 inc %g1 4000fc24: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 4000fc28: 25 10 00 d1 sethi %hi(0x40034400), %l2 4000fc2c: 40 00 15 de call 400153a4 <_Objects_Allocate> 4000fc30: 90 14 a2 30 or %l2, 0x230, %o0 ! 40034630 <_Partition_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 4000fc34: a2 92 20 00 orcc %o0, 0, %l1 4000fc38: 12 80 00 06 bne 4000fc50 4000fc3c: 92 10 00 1b mov %i3, %o1 _Thread_Enable_dispatch(); 4000fc40: 7f ff ff d5 call 4000fb94 <_Thread_Enable_dispatch> 4000fc44: b0 10 20 05 mov 5, %i0 4000fc48: 81 c7 e0 08 ret 4000fc4c: 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; 4000fc50: f8 24 60 1c st %i4, [ %l1 + 0x1c ] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 4000fc54: f2 24 60 10 st %i1, [ %l1 + 0x10 ] the_partition->length = length; 4000fc58: f4 24 60 14 st %i2, [ %l1 + 0x14 ] the_partition->buffer_size = buffer_size; 4000fc5c: f6 24 60 18 st %i3, [ %l1 + 0x18 ] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 4000fc60: c0 24 60 20 clr [ %l1 + 0x20 ] _Chain_Initialize( &the_partition->Memory, starting_address, 4000fc64: 40 00 55 a0 call 400252e4 <.udiv> 4000fc68: 90 10 00 1a mov %i2, %o0 4000fc6c: a0 04 60 24 add %l1, 0x24, %l0 4000fc70: 94 10 00 08 mov %o0, %o2 4000fc74: 92 10 00 19 mov %i1, %o1 4000fc78: 90 10 00 10 mov %l0, %o0 4000fc7c: 40 00 11 b1 call 40014340 <_Chain_Initialize> 4000fc80: 96 10 00 1b mov %i3, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000fc84: 90 14 a2 30 or %l2, 0x230, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000fc88: c4 04 60 08 ld [ %l1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000fc8c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4000fc90: 03 00 00 3f sethi %hi(0xfc00), %g1 4000fc94: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000fc98: 82 08 80 01 and %g2, %g1, %g1 4000fc9c: 80 a0 40 03 cmp %g1, %g3 4000fca0: 38 80 00 06 bgu,a 4000fcb8 4000fca4: c2 04 60 08 ld [ %l1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 4000fca8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000fcac: 83 28 60 02 sll %g1, 2, %g1 4000fcb0: e2 20 80 01 st %l1, [ %g2 + %g1 ] &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 4000fcb4: c2 04 60 08 ld [ %l1 + 8 ], %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; 4000fcb8: e6 24 60 0c st %l3, [ %l1 + 0xc ] 4000fcbc: c2 27 40 00 st %g1, [ %i5 ] name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 4000fcc0: 7f ff ff b5 call 4000fb94 <_Thread_Enable_dispatch> 4000fcc4: b0 10 20 00 clr %i0 4000fcc8: 81 c7 e0 08 ret 4000fccc: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 4000fcd0: 81 c7 e0 08 ret 4000fcd4: 91 e8 20 09 restore %g0, 9, %o0 4000fcd8: b0 10 20 08 mov 8, %i0 } 4000fcdc: 81 c7 e0 08 ret 4000fce0: 81 e8 00 00 restore 4000fd18 : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 4000fd18: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 4000fd1c: 92 10 00 18 mov %i0, %o1 4000fd20: 94 07 bf f4 add %fp, -12, %o2 4000fd24: 31 10 00 d1 sethi %hi(0x40034400), %i0 4000fd28: 40 00 16 f7 call 40015904 <_Objects_Get> 4000fd2c: 90 16 22 30 or %i0, 0x230, %o0 ! 40034630 <_Partition_Information> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000fd30: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000fd34: 80 a0 60 00 cmp %g1, 0 4000fd38: 02 80 00 07 be 4000fd54 4000fd3c: 88 10 00 08 mov %o0, %g4 4000fd40: 80 a0 60 02 cmp %g1, 2 4000fd44: 08 80 00 18 bleu 4000fda4 4000fd48: b0 10 20 04 mov 4, %i0 4000fd4c: 81 c7 e0 08 ret <== NOT EXECUTED 4000fd50: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 4000fd54: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 4000fd58: 80 a0 60 00 cmp %g1, 0 4000fd5c: 12 80 00 14 bne 4000fdac 4000fd60: 90 16 22 30 or %i0, 0x230, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000fd64: c2 01 20 08 ld [ %g4 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000fd68: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4000fd6c: 05 00 00 3f sethi %hi(0xfc00), %g2 4000fd70: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000fd74: 82 08 40 02 and %g1, %g2, %g1 4000fd78: 80 a0 40 03 cmp %g1, %g3 4000fd7c: 18 80 00 05 bgu 4000fd90 4000fd80: 92 10 00 04 mov %g4, %o1 information->local_table[ index ] = the_object; 4000fd84: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000fd88: 83 28 60 02 sll %g1, 2, %g1 4000fd8c: 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; 4000fd90: c0 21 20 0c clr [ %g4 + 0xc ] RTEMS_INLINE_ROUTINE void _Partition_Free ( Partition_Control *the_partition ) { _Objects_Free( &_Partition_Information, &the_partition->Object ); 4000fd94: 40 00 16 86 call 400157ac <_Objects_Free> 4000fd98: b0 10 20 00 clr %i0 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 4000fd9c: 7f ff ff d2 call 4000fce4 <_Thread_Enable_dispatch> 4000fda0: 01 00 00 00 nop 4000fda4: 81 c7 e0 08 ret 4000fda8: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 4000fdac: 7f ff ff ce call 4000fce4 <_Thread_Enable_dispatch> 4000fdb0: b0 10 20 0c mov 0xc, %i0 return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000fdb4: 81 c7 e0 08 ret 4000fdb8: 81 e8 00 00 restore 4000fdf0 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 4000fdf0: 9d e3 bf 90 save %sp, -112, %sp 4000fdf4: 92 10 00 18 mov %i0, %o1 register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 4000fdf8: 80 a6 60 00 cmp %i1, 0 4000fdfc: 02 80 00 1a be 4000fe64 4000fe00: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 4000fe04: 11 10 00 d1 sethi %hi(0x40034400), %o0 4000fe08: 94 07 bf f4 add %fp, -12, %o2 4000fe0c: 40 00 16 be call 40015904 <_Objects_Get> 4000fe10: 90 12 22 30 or %o0, 0x230, %o0 return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000fe14: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000fe18: 80 a0 60 00 cmp %g1, 0 4000fe1c: 02 80 00 07 be 4000fe38 4000fe20: b0 10 00 08 mov %o0, %i0 4000fe24: 80 a0 60 02 cmp %g1, 2 4000fe28: 08 80 00 0f bleu 4000fe64 4000fe2c: b0 10 20 04 mov 4, %i0 4000fe30: 81 c7 e0 08 ret <== NOT EXECUTED 4000fe34: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 4000fe38: 40 00 11 32 call 40014300 <_Chain_Get> 4000fe3c: 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 ) { 4000fe40: a0 92 20 00 orcc %o0, 0, %l0 4000fe44: 02 80 00 0a be 4000fe6c 4000fe48: 01 00 00 00 nop the_partition->number_of_used_blocks += 1; 4000fe4c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 4000fe50: 82 00 60 01 inc %g1 4000fe54: c2 26 20 20 st %g1, [ %i0 + 0x20 ] _Thread_Enable_dispatch(); 4000fe58: 7f ff ff d9 call 4000fdbc <_Thread_Enable_dispatch> 4000fe5c: b0 10 20 00 clr %i0 *buffer = the_buffer; 4000fe60: e0 26 40 00 st %l0, [ %i1 ] 4000fe64: 81 c7 e0 08 ret 4000fe68: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 4000fe6c: 7f ff ff d4 call 4000fdbc <_Thread_Enable_dispatch> 4000fe70: b0 10 20 0d mov 0xd, %i0 return RTEMS_UNSATISFIED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000fe74: 81 c7 e0 08 ret 4000fe78: 81 e8 00 00 restore 4000fee4 : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 4000fee4: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 4000fee8: 11 10 00 d1 sethi %hi(0x40034400), %o0 4000feec: 92 10 00 18 mov %i0, %o1 4000fef0: 90 12 22 30 or %o0, 0x230, %o0 4000fef4: 40 00 16 84 call 40015904 <_Objects_Get> 4000fef8: 94 07 bf f4 add %fp, -12, %o2 register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000fefc: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000ff00: 80 a0 60 00 cmp %g1, 0 4000ff04: 02 80 00 07 be 4000ff20 4000ff08: b0 10 00 08 mov %o0, %i0 4000ff0c: 80 a0 60 02 cmp %g1, 2 4000ff10: 08 80 00 1a bleu 4000ff78 4000ff14: b0 10 20 04 mov 4, %i0 4000ff18: 81 c7 e0 08 ret <== NOT EXECUTED 4000ff1c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED ) { void *starting; void *ending; starting = the_partition->starting_address; 4000ff20: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( 4000ff24: 80 a6 40 02 cmp %i1, %g2 4000ff28: 0a 80 00 16 bcs 4000ff80 4000ff2c: 01 00 00 00 nop 4000ff30: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 4000ff34: 82 00 80 01 add %g2, %g1, %g1 4000ff38: 80 a6 40 01 cmp %i1, %g1 4000ff3c: 18 80 00 11 bgu 4000ff80 4000ff40: 01 00 00 00 nop 4000ff44: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 4000ff48: 40 00 55 93 call 40025594 <.urem> 4000ff4c: 90 26 40 02 sub %i1, %g2, %o0 4000ff50: 80 a2 20 00 cmp %o0, 0 4000ff54: 12 80 00 0b bne 4000ff80 4000ff58: 90 06 20 24 add %i0, 0x24, %o0 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 4000ff5c: 40 00 10 dd call 400142d0 <_Chain_Append> 4000ff60: 92 10 00 19 mov %i1, %o1 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; 4000ff64: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 4000ff68: 82 00 7f ff add %g1, -1, %g1 4000ff6c: c2 26 20 20 st %g1, [ %i0 + 0x20 ] _Thread_Enable_dispatch(); 4000ff70: 7f ff ff d0 call 4000feb0 <_Thread_Enable_dispatch> 4000ff74: b0 10 20 00 clr %i0 4000ff78: 81 c7 e0 08 ret 4000ff7c: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 4000ff80: 7f ff ff cc call 4000feb0 <_Thread_Enable_dispatch> 4000ff84: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000ff88: 81 c7 e0 08 ret 4000ff8c: 81 e8 00 00 restore 4000ed8c : void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) { 4000ed8c: 9d e3 bf 98 save %sp, -104, %sp register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 4000ed90: a2 96 20 00 orcc %i0, 0, %l1 4000ed94: 02 80 00 15 be 4000ede8 4000ed98: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 4000ed9c: 80 a7 20 00 cmp %i4, 0 4000eda0: 02 80 00 29 be 4000ee44 4000eda4: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 4000eda8: 12 80 00 27 bne 4000ee44 4000edac: 80 8e a0 07 btst 7, %i2 4000edb0: 32 80 00 0e bne,a 4000ede8 4000edb4: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000edb8: 05 10 00 d2 sethi %hi(0x40034800), %g2 4000edbc: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 4000edc0: 82 00 60 01 inc %g1 4000edc4: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] */ RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Allocate ( void ) { return (Dual_ported_memory_Control *) 4000edc8: 21 10 00 d1 sethi %hi(0x40034400), %l0 4000edcc: 40 00 19 76 call 400153a4 <_Objects_Allocate> 4000edd0: 90 14 21 e4 or %l0, 0x1e4, %o0 ! 400345e4 <_Dual_ported_memory_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 4000edd4: 80 a2 20 00 cmp %o0, 0 4000edd8: 12 80 00 06 bne 4000edf0 4000eddc: 88 14 21 e4 or %l0, 0x1e4, %g4 _Thread_Enable_dispatch(); 4000ede0: 7f ff ff de call 4000ed58 <_Thread_Enable_dispatch> 4000ede4: b0 10 20 05 mov 5, %i0 4000ede8: 81 c7 e0 08 ret 4000edec: 81 e8 00 00 restore ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000edf0: c4 02 20 08 ld [ %o0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000edf4: c6 11 20 10 lduh [ %g4 + 0x10 ], %g3 return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; the_port->external_base = external_start; the_port->length = length - 1; 4000edf8: 82 06 ff ff add %i3, -1, %g1 if ( !the_port ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 4000edfc: f2 22 20 10 st %i1, [ %o0 + 0x10 ] the_port->external_base = external_start; the_port->length = length - 1; 4000ee00: c2 22 20 18 st %g1, [ %o0 + 0x18 ] 4000ee04: 03 00 00 3f sethi %hi(0xfc00), %g1 4000ee08: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000ee0c: 82 08 80 01 and %g2, %g1, %g1 4000ee10: 80 a0 40 03 cmp %g1, %g3 4000ee14: 18 80 00 05 bgu 4000ee28 4000ee18: f4 22 20 14 st %i2, [ %o0 + 0x14 ] information->local_table[ index ] = the_object; 4000ee1c: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 4000ee20: 83 28 60 02 sll %g1, 2, %g1 4000ee24: d0 20 80 01 st %o0, [ %g2 + %g1 ] &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 4000ee28: c2 02 20 08 ld [ %o0 + 8 ], %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; 4000ee2c: e2 22 20 0c st %l1, [ %o0 + 0xc ] 4000ee30: c2 27 00 00 st %g1, [ %i4 ] _Thread_Enable_dispatch(); 4000ee34: 7f ff ff c9 call 4000ed58 <_Thread_Enable_dispatch> 4000ee38: b0 10 20 00 clr %i0 4000ee3c: 81 c7 e0 08 ret 4000ee40: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 4000ee44: b0 10 20 09 mov 9, %i0 } 4000ee48: 81 c7 e0 08 ret 4000ee4c: 81 e8 00 00 restore 40007294 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) { 40007294: 9d e3 bf 98 save %sp, -104, %sp Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 40007298: a4 96 20 00 orcc %i0, 0, %l2 4000729c: 02 80 00 11 be 400072e0 400072a0: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 400072a4: 80 a6 60 00 cmp %i1, 0 400072a8: 02 80 00 0e be 400072e0 400072ac: b0 10 20 09 mov 9, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400072b0: 05 10 00 7e sethi %hi(0x4001f800), %g2 400072b4: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 4001fbb0 <_Thread_Dispatch_disable_level> 400072b8: 82 00 60 01 inc %g1 400072bc: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] * the inactive chain of free period control blocks. */ RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void ) { return (Rate_monotonic_Control *) 400072c0: 23 10 00 7e sethi %hi(0x4001f800), %l1 400072c4: 40 00 09 df call 40009a40 <_Objects_Allocate> 400072c8: 90 14 62 1c or %l1, 0x21c, %o0 ! 4001fa1c <_Rate_monotonic_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 400072cc: a0 92 20 00 orcc %o0, 0, %l0 400072d0: 12 80 00 06 bne 400072e8 400072d4: 03 10 00 7f sethi %hi(0x4001fc00), %g1 _Thread_Enable_dispatch(); 400072d8: 7f ff ff e2 call 40007260 <_Thread_Enable_dispatch> 400072dc: b0 10 20 05 mov 5, %i0 400072e0: 81 c7 e0 08 ret 400072e4: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 400072e8: c2 00 60 8c ld [ %g1 + 0x8c ], %g1 the_period->state = RATE_MONOTONIC_INACTIVE; 400072ec: c0 24 20 38 clr [ %l0 + 0x38 ] if ( !the_period ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 400072f0: c2 24 20 50 st %g1, [ %l0 + 0x50 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 400072f4: c0 24 20 18 clr [ %l0 + 0x18 ] the_watchdog->routine = routine; 400072f8: c0 24 20 2c clr [ %l0 + 0x2c ] the_watchdog->id = id; 400072fc: c0 24 20 30 clr [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 40007300: c0 24 20 34 clr [ %l0 + 0x34 ] the_period->state = RATE_MONOTONIC_INACTIVE; _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 40007304: 90 04 20 54 add %l0, 0x54, %o0 40007308: 92 10 20 00 clr %o1 4000730c: 40 00 28 30 call 400113cc 40007310: 94 10 20 38 mov 0x38, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40007314: 90 14 62 1c or %l1, 0x21c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40007318: c4 04 20 08 ld [ %l0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000731c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40007320: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 40007324: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff 40007328: c2 24 20 78 st %g1, [ %l0 + 0x78 ] 4000732c: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 40007330: c2 24 20 60 st %g1, [ %l0 + 0x60 ] 40007334: c2 24 20 74 st %g1, [ %l0 + 0x74 ] 40007338: 03 00 00 3f sethi %hi(0xfc00), %g1 4000733c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40007340: 82 08 80 01 and %g2, %g1, %g1 40007344: 80 a0 40 03 cmp %g1, %g3 40007348: 38 80 00 06 bgu,a 40007360 4000734c: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 40007350: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40007354: 83 28 60 02 sll %g1, 2, %g1 40007358: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 4000735c: c2 04 20 08 ld [ %l0 + 8 ], %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; 40007360: e4 24 20 0c st %l2, [ %l0 + 0xc ] 40007364: c2 26 40 00 st %g1, [ %i1 ] _Thread_Enable_dispatch(); 40007368: 7f ff ff be call 40007260 <_Thread_Enable_dispatch> 4000736c: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 40007370: 81 c7 e0 08 ret 40007374: 81 e8 00 00 restore 40010160 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 40010160: 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 *) 40010164: 21 10 00 d1 sethi %hi(0x40034400), %l0 40010168: 92 10 00 18 mov %i0, %o1 4001016c: 94 07 bf f4 add %fp, -12, %o2 40010170: 40 00 15 e5 call 40015904 <_Objects_Get> 40010174: 90 14 22 7c or %l0, 0x27c, %o0 Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 40010178: c2 07 bf f4 ld [ %fp + -12 ], %g1 4001017c: 80 a0 60 00 cmp %g1, 0 40010180: 02 80 00 08 be 400101a0 40010184: b0 10 00 08 mov %o0, %i0 40010188: 82 18 60 02 xor %g1, 2, %g1 4001018c: 80 a0 00 01 cmp %g0, %g1 40010190: 82 60 20 00 subx %g0, 0, %g1 40010194: b0 08 60 15 and %g1, 0x15, %i0 40010198: 81 c7 e0 08 ret 4001019c: 91 ee 20 04 restore %i0, 4, %o0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400101a0: a0 14 22 7c or %l0, 0x27c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 400101a4: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400101a8: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 400101ac: 05 00 00 3f sethi %hi(0xfc00), %g2 400101b0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 400101b4: 82 08 40 02 and %g1, %g2, %g1 400101b8: 80 a0 40 03 cmp %g1, %g3 400101bc: 38 80 00 06 bgu,a 400101d4 400101c0: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 400101c4: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 400101c8: 83 28 60 02 sll %g1, 2, %g1 400101cc: 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; 400101d0: 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 ); 400101d4: 40 00 21 12 call 4001861c <_Watchdog_Remove> 400101d8: 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 ); 400101dc: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_INACTIVE; 400101e0: c0 26 20 38 clr [ %i0 + 0x38 ] 400101e4: 40 00 15 72 call 400157ac <_Objects_Free> 400101e8: 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 ) 400101ec: 03 10 00 d2 sethi %hi(0x40034800), %g1 400101f0: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 400348b0 <_Thread_Dispatch_disable_level> 400101f4: b0 10 20 00 clr %i0 400101f8: 84 00 bf ff add %g2, -1, %g2 400101fc: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ] 40010200: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 40010204: 80 a0 60 00 cmp %g1, 0 40010208: 12 80 00 04 bne 40010218 4001020c: 01 00 00 00 nop _Thread_Dispatch(); 40010210: 40 00 1a b1 call 40016cd4 <_Thread_Dispatch> 40010214: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40010218: 81 c7 e0 08 ret 4001021c: 81 e8 00 00 restore 4000f084 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 4000f084: 9d e3 bf 88 save %sp, -120, %sp 4000f088: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 4000f08c: 80 a6 60 00 cmp %i1, 0 4000f090: 02 80 00 36 be 4000f168 4000f094: b0 10 20 09 mov 9, %i0 4000f098: 11 10 00 7e sethi %hi(0x4001f800), %o0 4000f09c: 94 07 bf f4 add %fp, -12, %o2 4000f0a0: 7f ff eb f5 call 4000a074 <_Objects_Get> 4000f0a4: 90 12 22 1c or %o0, 0x21c, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000f0a8: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f0ac: 80 a0 60 00 cmp %g1, 0 4000f0b0: 02 80 00 08 be 4000f0d0 4000f0b4: b0 10 00 08 mov %o0, %i0 4000f0b8: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 4000f0bc: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 4000f0c0: 82 60 20 00 subx %g0, 0, %g1 <== NOT EXECUTED 4000f0c4: b0 08 60 15 and %g1, 0x15, %i0 <== NOT EXECUTED 4000f0c8: 81 c7 e0 08 ret <== NOT EXECUTED 4000f0cc: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 4000f0d0: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 4000f0d4: 80 a0 60 00 cmp %g1, 0 4000f0d8: 02 80 00 03 be 4000f0e4 4000f0dc: 84 10 20 00 clr %g2 4000f0e0: c4 00 60 08 ld [ %g1 + 8 ], %g2 status->state = the_period->state; 4000f0e4: 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); 4000f0e8: c4 26 40 00 st %g2, [ %i1 ] status->state = the_period->state; if ( status->state == RATE_MONOTONIC_INACTIVE ) { 4000f0ec: 80 a0 60 00 cmp %g1, 0 4000f0f0: 12 80 00 07 bne 4000f10c 4000f0f4: 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; 4000f0f8: 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; 4000f0fc: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 4000f100: 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; 4000f104: 10 80 00 0e b 4000f13c <== NOT EXECUTED 4000f108: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED * 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 ); 4000f10c: a0 07 bf ec add %fp, -20, %l0 4000f110: 7f ff e8 aa call 400093b8 <_TOD_Get_uptime> 4000f114: 90 10 00 10 mov %l0, %o0 #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 4000f118: 90 06 20 44 add %i0, 0x44, %o0 4000f11c: 92 10 00 10 mov %l0, %o1 4000f120: 7f ff f5 4b call 4000c64c <_Timespec_Subtract> 4000f124: 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( 4000f128: 11 10 00 7f sethi %hi(0x4001fc00), %o0 4000f12c: 92 10 00 10 mov %l0, %o1 4000f130: 94 06 60 10 add %i1, 0x10, %o2 4000f134: 7f ff f5 46 call 4000c64c <_Timespec_Subtract> 4000f138: 90 12 20 94 or %o0, 0x94, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f13c: 03 10 00 7e sethi %hi(0x4001f800), %g1 4000f140: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 4001fbb0 <_Thread_Dispatch_disable_level> 4000f144: b0 10 20 00 clr %i0 4000f148: 84 00 bf ff add %g2, -1, %g2 4000f14c: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 4000f150: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 4000f154: 80 a0 60 00 cmp %g1, 0 4000f158: 12 80 00 04 bne 4000f168 4000f15c: 01 00 00 00 nop _Thread_Dispatch(); 4000f160: 7f ff f0 b9 call 4000b444 <_Thread_Dispatch> 4000f164: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f168: 81 c7 e0 08 ret 4000f16c: 81 e8 00 00 restore 40007580 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 40007580: 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 *) 40007584: 11 10 00 7e sethi %hi(0x4001f800), %o0 40007588: 92 10 00 18 mov %i0, %o1 4000758c: 90 12 22 1c or %o0, 0x21c, %o0 40007590: 40 00 0a b9 call 4000a074 <_Objects_Get> 40007594: 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 ) { 40007598: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000759c: 80 a0 60 00 cmp %g1, 0 400075a0: 02 80 00 07 be 400075bc 400075a4: a2 10 00 08 mov %o0, %l1 400075a8: 80 a0 60 02 cmp %g1, 2 400075ac: 02 80 00 0c be 400075dc 400075b0: b0 10 20 04 mov 4, %i0 the_period->state = RATE_MONOTONIC_ACTIVE; the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_TIMEOUT; 400075b4: 81 c7 e0 08 ret <== NOT EXECUTED 400075b8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 400075bc: 27 10 00 7f sethi %hi(0x4001fc00), %l3 400075c0: c4 02 20 50 ld [ %o0 + 0x50 ], %g2 400075c4: c2 04 e0 8c ld [ %l3 + 0x8c ], %g1 400075c8: 80 a0 80 01 cmp %g2, %g1 400075cc: 02 80 00 06 be 400075e4 400075d0: 80 a6 60 00 cmp %i1, 0 _Thread_Enable_dispatch(); 400075d4: 7f ff ff 7f call 400073d0 <_Thread_Enable_dispatch> 400075d8: b0 10 20 17 mov 0x17, %i0 400075dc: 81 c7 e0 08 ret 400075e0: 81 e8 00 00 restore return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 400075e4: 12 80 00 11 bne 40007628 400075e8: 01 00 00 00 nop switch ( the_period->state ) { 400075ec: d0 02 20 38 ld [ %o0 + 0x38 ], %o0 400075f0: 80 a2 20 02 cmp %o0, 2 400075f4: 02 80 00 09 be 40007618 400075f8: b0 10 20 00 clr %i0 400075fc: 80 a2 20 04 cmp %o0, 4 40007600: 02 80 00 06 be 40007618 40007604: b0 10 20 06 mov 6, %i0 40007608: 80 a2 20 00 cmp %o0, 0 4000760c: 02 80 00 03 be 40007618 40007610: b0 10 20 0b mov 0xb, %i0 40007614: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED break; default: /* unreached -- only to remove warnings */ return_value = RTEMS_INTERNAL_ERROR; break; } _Thread_Enable_dispatch(); 40007618: 7f ff ff 6e call 400073d0 <_Thread_Enable_dispatch> 4000761c: 01 00 00 00 nop 40007620: 81 c7 e0 08 ret 40007624: 81 e8 00 00 restore return( return_value ); } _ISR_Disable( level ); 40007628: 7f ff ed 0b call 40002a54 4000762c: 01 00 00 00 nop 40007630: a0 10 00 08 mov %o0, %l0 switch ( the_period->state ) { 40007634: e4 04 60 38 ld [ %l1 + 0x38 ], %l2 40007638: 80 a4 a0 02 cmp %l2, 2 4000763c: 02 80 00 29 be 400076e0 40007640: 80 a4 a0 04 cmp %l2, 4 40007644: 02 80 00 43 be 40007750 40007648: 80 a4 a0 00 cmp %l2, 0 4000764c: 32 bf ff e4 bne,a 400075dc 40007650: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED /* * No need to update statistics -- there are not a period active */ _ISR_Enable( level ); 40007654: 7f ff ed 04 call 40002a64 40007658: 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 ); 4000765c: 40 00 07 57 call 400093b8 <_TOD_Get_uptime> 40007660: 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; 40007664: c2 07 bf ec ld [ %fp + -20 ], %g1 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40007668: c4 04 e0 8c ld [ %l3 + 0x8c ], %g2 #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; 4000766c: c2 24 60 44 st %g1, [ %l1 + 0x44 ] 40007670: 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( 40007674: 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; 40007678: c2 24 60 48 st %g1, [ %l1 + 0x48 ] #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 4000767c: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40007680: a0 07 bf e4 add %fp, -28, %l0 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40007684: c2 24 60 3c st %g1, [ %l1 + 0x3c ] 40007688: c2 00 a0 94 ld [ %g2 + 0x94 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 4000768c: 94 10 00 10 mov %l0, %o2 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40007690: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40007694: 11 10 00 7f sethi %hi(0x4001fc00), %o0 40007698: 40 00 13 ed call 4000c64c <_Timespec_Subtract> 4000769c: 90 12 20 94 or %o0, 0x94, %o0 ! 4001fc94 <_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 ); 400076a0: 92 10 00 10 mov %l0, %o1 400076a4: 40 00 13 89 call 4000c4c8 <_Timespec_Add_to> 400076a8: 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; 400076ac: 82 10 20 02 mov 2, %g1 400076b0: c2 24 60 38 st %g1, [ %l1 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 400076b4: 03 10 00 1e sethi %hi(0x40007800), %g1 400076b8: 82 10 62 e8 or %g1, 0x2e8, %g1 ! 40007ae8 <_Rate_monotonic_Timeout> NULL ); the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); 400076bc: 90 04 60 10 add %l1, 0x10, %o0 400076c0: 92 10 00 19 mov %i1, %o1 the_watchdog->id = id; 400076c4: f0 24 60 30 st %i0, [ %l1 + 0x30 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 400076c8: c0 24 60 18 clr [ %l1 + 0x18 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 400076cc: c0 24 60 34 clr [ %l1 + 0x34 ] _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 400076d0: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert_ticks( &the_period->Timer, length ); 400076d4: 7f ff ff 37 call 400073b0 <_Watchdog_Insert_ticks> 400076d8: c2 24 60 2c st %g1, [ %l1 + 0x2c ] 400076dc: 30 80 00 19 b,a 40007740 case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 400076e0: 7f ff ff 49 call 40007404 <_Rate_monotonic_Update_statistics> 400076e4: 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; 400076e8: 82 10 20 01 mov 1, %g1 the_period->next_length = length; 400076ec: 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; 400076f0: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; _ISR_Enable( level ); 400076f4: 7f ff ec dc call 40002a64 400076f8: 90 10 00 10 mov %l0, %o0 _Thread_Executing->Wait.id = the_period->Object.id; 400076fc: c2 04 e0 8c ld [ %l3 + 0x8c ], %g1 40007700: c4 04 60 08 ld [ %l1 + 8 ], %g2 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 40007704: 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; 40007708: c4 20 60 20 st %g2, [ %g1 + 0x20 ] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 4000770c: 40 00 12 4a call 4000c034 <_Thread_Set_state> 40007710: 13 00 00 10 sethi %hi(0x4000), %o1 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 40007714: 7f ff ec d0 call 40002a54 40007718: 01 00 00 00 nop local_state = the_period->state; 4000771c: e0 04 60 38 ld [ %l1 + 0x38 ], %l0 the_period->state = RATE_MONOTONIC_ACTIVE; 40007720: e4 24 60 38 st %l2, [ %l1 + 0x38 ] _ISR_Enable( level ); 40007724: 7f ff ec d0 call 40002a64 40007728: 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 ) 4000772c: 80 a4 20 03 cmp %l0, 3 40007730: 12 80 00 04 bne 40007740 40007734: d0 04 e0 8c ld [ %l3 + 0x8c ], %o0 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 40007738: 40 00 0e 89 call 4000b15c <_Thread_Clear_state> <== NOT EXECUTED 4000773c: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED _Thread_Enable_dispatch(); 40007740: 7f ff ff 24 call 400073d0 <_Thread_Enable_dispatch> 40007744: b0 10 20 00 clr %i0 40007748: 81 c7 e0 08 ret 4000774c: 81 e8 00 00 restore case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 40007750: 7f ff ff 2d call 40007404 <_Rate_monotonic_Update_statistics> 40007754: 90 10 00 11 mov %l1, %o0 _ISR_Enable( level ); 40007758: 7f ff ec c3 call 40002a64 4000775c: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 40007760: 82 10 20 02 mov 2, %g1 the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); 40007764: 90 04 60 10 add %l1, 0x10, %o0 40007768: 92 10 00 19 mov %i1, %o1 */ _Rate_monotonic_Update_statistics( the_period ); _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 4000776c: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; 40007770: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert_ticks( &the_period->Timer, length ); 40007774: 7f ff ff 0f call 400073b0 <_Watchdog_Insert_ticks> 40007778: b0 10 20 06 mov 6, %i0 _Thread_Enable_dispatch(); 4000777c: 7f ff ff 15 call 400073d0 <_Thread_Enable_dispatch> 40007780: 01 00 00 00 nop 40007784: 81 c7 e0 08 ret 40007788: 81 e8 00 00 restore break; } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000778c: 81 c7 e0 08 ret <== NOT EXECUTED 40007790: 81 e8 00 00 restore <== NOT EXECUTED 40007794 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 40007794: 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 ) 40007798: 80 a6 60 00 cmp %i1, 0 4000779c: 02 80 00 7f be 40007998 400077a0: 90 10 00 18 mov %i0, %o0 return; (*print)( context, "Period information by period\n" ); 400077a4: 13 10 00 73 sethi %hi(0x4001cc00), %o1 400077a8: 9f c6 40 00 call %i1 400077ac: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 4001cfb8 #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 400077b0: 90 10 00 18 mov %i0, %o0 400077b4: 13 10 00 73 sethi %hi(0x4001cc00), %o1 400077b8: 9f c6 40 00 call %i1 400077bc: 92 12 63 d8 or %o1, 0x3d8, %o1 ! 4001cfd8 #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 400077c0: 90 10 00 18 mov %i0, %o0 400077c4: 13 10 00 74 sethi %hi(0x4001d000), %o1 400077c8: 9f c6 40 00 call %i1 400077cc: 92 12 60 00 mov %o1, %o1 ! 4001d000 Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 400077d0: 90 10 00 18 mov %i0, %o0 400077d4: 13 10 00 74 sethi %hi(0x4001d000), %o1 400077d8: 9f c6 40 00 call %i1 400077dc: 92 12 60 28 or %o1, 0x28, %o1 ! 4001d028 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 400077e0: 90 10 00 18 mov %i0, %o0 400077e4: 13 10 00 74 sethi %hi(0x4001d000), %o1 400077e8: 9f c6 40 00 call %i1 400077ec: 92 12 60 78 or %o1, 0x78, %o1 ! 4001d078 /* * 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 ; 400077f0: 03 10 00 7e sethi %hi(0x4001f800), %g1 400077f4: 82 10 62 1c or %g1, 0x21c, %g1 ! 4001fa1c <_Rate_monotonic_Information> 400077f8: e4 00 60 08 ld [ %g1 + 8 ], %l2 _Timespec_Divide_by_integer( &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 400077fc: 03 10 00 74 sethi %hi(0x4001d000), %g1 40007800: b4 10 60 e0 or %g1, 0xe0, %i2 ! 4001d0e0 _Timespec_Divide_by_integer( &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 40007804: 03 10 00 74 sethi %hi(0x4001d000), %g1 * 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++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 40007808: ba 07 bf 98 add %fp, -104, %i5 _Timespec_Divide_by_integer( &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 4000780c: b6 10 61 00 or %g1, 0x100, %i3 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 ); 40007810: ae 07 bf d0 add %fp, -48, %l7 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 40007814: 03 10 00 73 sethi %hi(0x4001cc00), %g1 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 40007818: a8 07 bf f3 add %fp, -13, %l4 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 4000781c: b8 10 63 f8 or %g1, 0x3f8, %i4 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 40007820: ac 07 bf b0 add %fp, -80, %l6 40007824: a6 07 bf e8 add %fp, -24, %l3 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 40007828: 10 80 00 56 b 40007980 4000782c: aa 07 bf c8 add %fp, -56, %l5 * 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++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 40007830: 40 00 1d f1 call 4000eff4 40007834: 92 10 00 1d mov %i5, %o1 if ( status != RTEMS_SUCCESSFUL ) 40007838: 80 a2 20 00 cmp %o0, 0 4000783c: 32 80 00 51 bne,a 40007980 40007840: a4 04 a0 01 inc %l2 continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 40007844: 92 10 00 17 mov %l7, %o1 40007848: 40 00 1e 0f call 4000f084 4000784c: 90 10 00 12 mov %l2, %o0 if ( status != RTEMS_SUCCESSFUL ) 40007850: 80 a2 20 00 cmp %o0, 0 40007854: 32 80 00 4b bne,a 40007980 40007858: a4 04 a0 01 inc %l2 <== NOT EXECUTED continue; name[ 0 ] = '\0'; if ( the_status.owner ) { 4000785c: d0 07 bf d0 ld [ %fp + -48 ], %o0 40007860: 80 a2 20 00 cmp %o0, 0 40007864: 02 80 00 05 be 40007878 40007868: c0 2f bf f3 clrb [ %fp + -13 ] rtems_object_get_name( the_status.owner, sizeof(name), name ); 4000786c: 94 10 00 14 mov %l4, %o2 40007870: 40 00 00 c8 call 40007b90 40007874: 92 10 20 05 mov 5, %o1 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 40007878: d8 1f bf 98 ldd [ %fp + -104 ], %o4 4000787c: 94 10 00 12 mov %l2, %o2 40007880: 96 10 00 14 mov %l4, %o3 40007884: 13 10 00 74 sethi %hi(0x4001d000), %o1 40007888: 90 10 00 18 mov %i0, %o0 4000788c: 9f c6 40 00 call %i1 40007890: 92 12 60 c8 or %o1, 0xc8, %o1 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 40007894: c2 07 bf 98 ld [ %fp + -104 ], %g1 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 40007898: 94 10 00 13 mov %l3, %o2 4000789c: 90 10 00 16 mov %l6, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 400078a0: 80 a0 60 00 cmp %g1, 0 400078a4: 12 80 00 06 bne 400078bc 400078a8: 92 10 00 1c mov %i4, %o1 (*print)( context, "\n" ); 400078ac: 9f c6 40 00 call %i1 400078b0: 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 ; id++ ) { 400078b4: 10 80 00 33 b 40007980 400078b8: a4 04 a0 01 inc %l2 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 400078bc: 40 00 13 1b call 4000c528 <_Timespec_Divide_by_integer> 400078c0: 92 10 00 01 mov %g1, %o1 &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 400078c4: d0 07 bf a4 ld [ %fp + -92 ], %o0 400078c8: 40 00 47 a5 call 4001975c <.div> 400078cc: 92 10 23 e8 mov 0x3e8, %o1 400078d0: a2 10 00 08 mov %o0, %l1 400078d4: d0 07 bf ac ld [ %fp + -84 ], %o0 400078d8: 40 00 47 a1 call 4001975c <.div> 400078dc: 92 10 23 e8 mov 0x3e8, %o1 400078e0: c2 07 bf e8 ld [ %fp + -24 ], %g1 400078e4: a0 10 00 08 mov %o0, %l0 400078e8: d0 07 bf ec ld [ %fp + -20 ], %o0 400078ec: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 400078f0: 40 00 47 9b call 4001975c <.div> 400078f4: 92 10 23 e8 mov 0x3e8, %o1 400078f8: d8 07 bf a8 ld [ %fp + -88 ], %o4 400078fc: d4 07 bf a0 ld [ %fp + -96 ], %o2 40007900: 96 10 00 11 mov %l1, %o3 40007904: 9a 10 00 10 mov %l0, %o5 40007908: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 4000790c: 92 10 00 1a mov %i2, %o1 40007910: 9f c6 40 00 call %i1 40007914: 90 10 00 18 mov %i0, %o0 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 40007918: d2 07 bf 98 ld [ %fp + -104 ], %o1 4000791c: 94 10 00 13 mov %l3, %o2 40007920: 40 00 13 02 call 4000c528 <_Timespec_Divide_by_integer> 40007924: 90 10 00 15 mov %l5, %o0 &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 40007928: d0 07 bf bc ld [ %fp + -68 ], %o0 4000792c: 40 00 47 8c call 4001975c <.div> 40007930: 92 10 23 e8 mov 0x3e8, %o1 40007934: a2 10 00 08 mov %o0, %l1 40007938: d0 07 bf c4 ld [ %fp + -60 ], %o0 4000793c: 40 00 47 88 call 4001975c <.div> 40007940: 92 10 23 e8 mov 0x3e8, %o1 40007944: c2 07 bf e8 ld [ %fp + -24 ], %g1 40007948: a0 10 00 08 mov %o0, %l0 4000794c: d0 07 bf ec ld [ %fp + -20 ], %o0 40007950: 92 10 23 e8 mov 0x3e8, %o1 40007954: 40 00 47 82 call 4001975c <.div> 40007958: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 4000795c: d4 07 bf b8 ld [ %fp + -72 ], %o2 40007960: d8 07 bf c0 ld [ %fp + -64 ], %o4 40007964: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 40007968: 96 10 00 11 mov %l1, %o3 4000796c: 9a 10 00 10 mov %l0, %o5 40007970: 90 10 00 18 mov %i0, %o0 40007974: 9f c6 40 00 call %i1 40007978: 92 10 00 1b mov %i3, %o1 * 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++ ) { 4000797c: 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 ; 40007980: 05 10 00 7e sethi %hi(0x4001f800), %g2 40007984: 84 10 a2 1c or %g2, 0x21c, %g2 ! 4001fa1c <_Rate_monotonic_Information> 40007988: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 4000798c: 80 a4 80 01 cmp %l2, %g1 40007990: 08 bf ff a8 bleu 40007830 40007994: 90 10 00 12 mov %l2, %o0 40007998: 81 c7 e0 08 ret 4000799c: 81 e8 00 00 restore 400079bc : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 400079bc: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400079c0: 03 10 00 7e sethi %hi(0x4001f800), %g1 400079c4: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 4001fbb0 <_Thread_Dispatch_disable_level> 400079c8: 84 00 a0 01 inc %g2 400079cc: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 400079d0: 03 10 00 7e sethi %hi(0x4001f800), %g1 400079d4: 82 10 62 1c or %g1, 0x21c, %g1 ! 4001fa1c <_Rate_monotonic_Information> 400079d8: e0 00 60 08 ld [ %g1 + 8 ], %l0 id <= _Rate_monotonic_Information.maximum_id ; 400079dc: 10 80 00 04 b 400079ec 400079e0: a2 10 00 01 mov %g1, %l1 id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 400079e4: 40 00 00 12 call 40007a2c 400079e8: 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 ; 400079ec: c2 04 60 0c ld [ %l1 + 0xc ], %g1 400079f0: 80 a4 00 01 cmp %l0, %g1 400079f4: 08 bf ff fc bleu 400079e4 400079f8: 90 10 00 10 mov %l0, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400079fc: 03 10 00 7e sethi %hi(0x4001f800), %g1 40007a00: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 4001fbb0 <_Thread_Dispatch_disable_level> 40007a04: 84 00 bf ff add %g2, -1, %g2 40007a08: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 40007a0c: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 40007a10: 80 a0 60 00 cmp %g1, 0 40007a14: 12 80 00 04 bne 40007a24 40007a18: 01 00 00 00 nop _Thread_Dispatch(); 40007a1c: 40 00 0e 8a call 4000b444 <_Thread_Dispatch> 40007a20: 81 e8 00 00 restore 40007a24: 81 c7 e0 08 ret <== NOT EXECUTED 40007a28: 81 e8 00 00 restore <== NOT EXECUTED 40010738 : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 40010738: 9d e3 bf 98 save %sp, -104, %sp Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 4001073c: a4 96 20 00 orcc %i0, 0, %l2 40010740: 02 80 00 87 be 4001095c 40010744: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 40010748: 80 a6 60 00 cmp %i1, 0 4001074c: 02 80 00 c7 be 40010a68 40010750: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 40010754: 02 80 00 c5 be 40010a68 40010758: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 4001075c: 32 80 00 80 bne,a 4001095c 40010760: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 40010764: 7f ff e8 53 call 4000a8b0 40010768: 01 00 00 00 nop 4001076c: a2 10 00 08 mov %o0, %l1 40010770: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010774: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 40010778: 80 a0 60 00 cmp %g1, 0 4001077c: 02 80 00 0b be 400107a8 40010780: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010784: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40010788: c2 00 62 90 ld [ %g1 + 0x290 ], %g1 ! 40034a90 <_System_state_Current> <== NOT EXECUTED 4001078c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40010790: 08 80 00 05 bleu 400107a4 <== NOT EXECUTED 40010794: 90 10 20 00 clr %o0 <== NOT EXECUTED 40010798: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001079c: 40 00 12 d5 call 400152f0 <_Internal_error_Occurred> <== NOT EXECUTED 400107a0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400107a4: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 400107a8: e0 00 61 84 ld [ %g1 + 0x184 ], %l0 ! 40034984 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400107ac: 03 10 00 d2 sethi %hi(0x40034800), %g1 400107b0: c4 00 61 8c ld [ %g1 + 0x18c ], %g2 ! 4003498c <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 400107b4: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 400107b8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 400107bc: 80 a0 60 00 cmp %g1, 0 400107c0: 22 80 00 30 be,a 40010880 400107c4: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 400107c8: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400107cc: 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; 400107d0: 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; 400107d4: 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; 400107d8: 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; 400107dc: 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 ) || 400107e0: 80 a0 e0 02 cmp %g3, 2 400107e4: 02 80 00 05 be 400107f8 400107e8: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 400107ec: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 400107f0: 12 80 00 07 bne 4001080c <== NOT EXECUTED 400107f4: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400107f8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400107fc: 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++; 40010800: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010804: 02 80 00 03 be 40010810 40010808: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 4001080c: 30 80 00 2b b,a 400108b8 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40010810: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40010814: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40010818: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4001081c: 12 80 00 03 bne 40010828 <== NOT EXECUTED 40010820: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 40010824: 30 80 00 25 b,a 400108b8 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 40010828: 08 80 00 0f bleu 40010864 <== NOT EXECUTED 4001082c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010830: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40010834: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40010838: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001083c: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40010840: 7f ff e8 20 call 4000a8c0 <== NOT EXECUTED 40010844: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 40010848: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 4001084c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40010850: 40 00 17 f5 call 40016824 <_Thread_Change_priority> <== NOT EXECUTED 40010854: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 40010858: 7f ff ff ab call 40010704 <_Thread_Enable_dispatch> <== NOT EXECUTED 4001085c: 23 10 00 d1 sethi %hi(0x40034400), %l1 <== NOT EXECUTED 40010860: 30 80 00 2f b,a 4001091c <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40010864: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40010868: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4001086c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40010870: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40010874: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010878: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4001087c: 30 80 00 0f b,a 400108b8 <== 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 ) ) { 40010880: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40010884: 12 80 00 13 bne 400108d0 <== NOT EXECUTED 40010888: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 4001088c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40010890: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40010894: 22 80 00 07 be,a 400108b0 <== NOT EXECUTED 40010898: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 4001089c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400108a0: 32 80 00 0c bne,a 400108d0 <== NOT EXECUTED 400108a4: 03 10 00 d2 sethi %hi(0x40034800), %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; 400108a8: 10 80 00 08 b 400108c8 <== NOT EXECUTED 400108ac: 82 10 20 02 mov 2, %g1 <== 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++; 400108b0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400108b4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400108b8: 7f ff e8 02 call 4000a8c0 400108bc: 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 ); 400108c0: 10 80 00 17 b 4001091c 400108c4: 23 10 00 d1 sethi %hi(0x40034400), %l1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 400108c8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400108cc: 30 bf ff fb b,a 400108b8 <== NOT EXECUTED 400108d0: c6 04 20 08 ld [ %l0 + 8 ], %g3 <== NOT EXECUTED 400108d4: c8 00 61 8c ld [ %g1 + 0x18c ], %g4 <== NOT EXECUTED 400108d8: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 400108dc: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400108e0: c6 21 20 20 st %g3, [ %g4 + 0x20 ] <== NOT EXECUTED 400108e4: 82 00 60 01 inc %g1 <== NOT EXECUTED 400108e8: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== 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; 400108ec: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 400108f0: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== NOT EXECUTED 400108f4: 82 04 20 10 add %l0, 0x10, %g1 <== NOT EXECUTED 400108f8: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 400108fc: 7f ff e7 f1 call 4000a8c0 <== NOT EXECUTED 40010900: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40010904: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40010908: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 4001090c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010910: 40 00 0f e6 call 400148a8 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40010914: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40010918: 23 10 00 d1 sethi %hi(0x40034400), %l1 <== NOT EXECUTED 4001091c: 40 00 12 a2 call 400153a4 <_Objects_Allocate> 40010920: 90 14 62 c8 or %l1, 0x2c8, %o0 ! 400346c8 <_Region_Information> the_region = _Region_Allocate(); if ( !the_region ) { 40010924: a0 92 20 00 orcc %o0, 0, %l0 40010928: 12 80 00 0f bne 40010964 4001092c: 05 10 00 d2 sethi %hi(0x40034800), %g2 40010930: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 40010934: 82 00 60 01 inc %g1 40010938: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] _RTEMS_Unlock_allocator(); 4001093c: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010940: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 40010944: 94 10 20 00 clr %o2 40010948: d2 02 20 08 ld [ %o0 + 8 ], %o1 4001094c: 40 00 0f f9 call 40014930 <_CORE_mutex_Surrender> 40010950: 90 02 20 10 add %o0, 0x10, %o0 40010954: 7f ff ff 6c call 40010704 <_Thread_Enable_dispatch> 40010958: b0 10 20 05 mov 5, %i0 4001095c: 81 c7 e0 08 ret 40010960: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_region->maximum_segment_size = 40010964: 90 04 20 68 add %l0, 0x68, %o0 40010968: 92 10 00 19 mov %i1, %o1 4001096c: 94 10 00 1a mov %i2, %o2 40010970: 40 00 12 16 call 400151c8 <_Heap_Initialize> 40010974: 96 10 00 1b mov %i3, %o3 _Heap_Initialize(&the_region->Memory, starting_address, length, page_size); if ( !the_region->maximum_segment_size ) { 40010978: 80 a2 20 00 cmp %o0, 0 4001097c: 12 80 00 13 bne 400109c8 40010980: 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 ); 40010984: 90 14 62 c8 or %l1, 0x2c8, %o0 40010988: 40 00 13 89 call 400157ac <_Objects_Free> 4001098c: 92 10 00 10 mov %l0, %o1 40010990: 05 10 00 d2 sethi %hi(0x40034800), %g2 40010994: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 40010998: 82 00 60 01 inc %g1 4001099c: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 400109a0: 03 10 00 d2 sethi %hi(0x40034800), %g1 400109a4: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 400109a8: 94 10 20 00 clr %o2 400109ac: d2 02 20 08 ld [ %o0 + 8 ], %o1 400109b0: 40 00 0f e0 call 40014930 <_CORE_mutex_Surrender> 400109b4: 90 02 20 10 add %o0, 0x10, %o0 400109b8: 7f ff ff 53 call 40010704 <_Thread_Enable_dispatch> 400109bc: b0 10 20 08 mov 8, %i0 400109c0: 81 c7 e0 08 ret 400109c4: 81 e8 00 00 restore 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( 400109c8: 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; 400109cc: f2 24 20 50 st %i1, [ %l0 + 0x50 ] the_region->length = length; 400109d0: f4 24 20 54 st %i2, [ %l0 + 0x54 ] the_region->page_size = page_size; 400109d4: f6 24 20 58 st %i3, [ %l0 + 0x58 ] the_region->attribute_set = attribute_set; 400109d8: f8 24 20 60 st %i4, [ %l0 + 0x60 ] the_region->number_of_used_blocks = 0; 400109dc: c0 24 20 64 clr [ %l0 + 0x64 ] _Thread_queue_Initialize( 400109e0: 93 37 20 02 srl %i4, 2, %o1 400109e4: 94 10 20 40 mov 0x40, %o2 400109e8: 92 0a 60 01 and %o1, 1, %o1 400109ec: 40 00 1b 09 call 40017610 <_Thread_queue_Initialize> 400109f0: 96 10 20 06 mov 6, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400109f4: 90 14 62 c8 or %l1, 0x2c8, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 400109f8: c4 04 20 08 ld [ %l0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400109fc: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40010a00: 03 00 00 3f sethi %hi(0xfc00), %g1 40010a04: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40010a08: 82 08 80 01 and %g2, %g1, %g1 40010a0c: 80 a0 40 03 cmp %g1, %g3 40010a10: 38 80 00 06 bgu,a 40010a28 40010a14: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 40010a18: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40010a1c: 83 28 60 02 sll %g1, 2, %g1 40010a20: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 40010a24: c2 04 20 08 ld [ %l0 + 8 ], %g1 40010a28: 05 10 00 d2 sethi %hi(0x40034800), %g2 40010a2c: c2 27 40 00 st %g1, [ %i5 ] 40010a30: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %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; 40010a34: e4 24 20 0c st %l2, [ %l0 + 0xc ] 40010a38: 82 00 60 01 inc %g1 40010a3c: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] _RTEMS_Unlock_allocator(); 40010a40: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010a44: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 40010a48: 94 10 20 00 clr %o2 40010a4c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010a50: 40 00 0f b8 call 40014930 <_CORE_mutex_Surrender> 40010a54: 90 02 20 10 add %o0, 0x10, %o0 40010a58: 7f ff ff 2b call 40010704 <_Thread_Enable_dispatch> 40010a5c: b0 10 20 00 clr %i0 40010a60: 81 c7 e0 08 ret 40010a64: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 40010a68: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED } 40010a6c: 81 c7 e0 08 ret <== NOT EXECUTED 40010a70: 81 e8 00 00 restore <== NOT EXECUTED 40010aa8 : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 40010aa8: 9d e3 bf 90 save %sp, -112, %sp register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 40010aac: 7f ff e7 81 call 4000a8b0 40010ab0: 01 00 00 00 nop 40010ab4: a2 10 00 08 mov %o0, %l1 40010ab8: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010abc: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 40010ac0: 80 a0 60 00 cmp %g1, 0 40010ac4: 02 80 00 0b be 40010af0 40010ac8: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010acc: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40010ad0: c2 00 62 90 ld [ %g1 + 0x290 ], %g1 ! 40034a90 <_System_state_Current> <== NOT EXECUTED 40010ad4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40010ad8: 08 80 00 05 bleu 40010aec <== NOT EXECUTED 40010adc: 90 10 20 00 clr %o0 <== NOT EXECUTED 40010ae0: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010ae4: 40 00 12 03 call 400152f0 <_Internal_error_Occurred> <== NOT EXECUTED 40010ae8: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40010aec: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40010af0: e0 00 61 84 ld [ %g1 + 0x184 ], %l0 ! 40034984 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40010af4: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010af8: c4 00 61 8c ld [ %g1 + 0x18c ], %g2 ! 4003498c <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40010afc: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40010b00: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40010b04: 80 a0 60 00 cmp %g1, 0 40010b08: 22 80 00 33 be,a 40010bd4 40010b0c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40010b10: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40010b14: 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; 40010b18: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; 40010b1c: 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; 40010b20: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 40010b24: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40010b28: 80 a0 e0 02 cmp %g3, 2 40010b2c: 02 80 00 05 be 40010b40 40010b30: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 40010b34: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40010b38: 32 80 00 06 bne,a 40010b50 <== NOT EXECUTED 40010b3c: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40010b40: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 40010b44: 82 00 60 01 inc %g1 40010b48: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010b4c: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 40010b50: 80 a0 60 03 cmp %g1, 3 40010b54: 22 80 00 03 be,a 40010b60 40010b58: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 40010b5c: 30 80 00 2c b,a 40010c0c { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 40010b60: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40010b64: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40010b68: 12 80 00 03 bne 40010b74 <== NOT EXECUTED 40010b6c: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 40010b70: 30 80 00 27 b,a 40010c0c <== NOT EXECUTED return 0; } if ( current > ceiling ) { 40010b74: 08 80 00 10 bleu 40010bb4 <== NOT EXECUTED 40010b78: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010b7c: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40010b80: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40010b84: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010b88: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40010b8c: 7f ff e7 4d call 4000a8c0 <== NOT EXECUTED 40010b90: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 40010b94: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40010b98: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40010b9c: 40 00 17 22 call 40016824 <_Thread_Change_priority> <== NOT EXECUTED 40010ba0: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 40010ba4: 7f ff ff b4 call 40010a74 <_Thread_Enable_dispatch> <== NOT EXECUTED 40010ba8: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 40010bac: 10 80 00 32 b 40010c74 <== NOT EXECUTED 40010bb0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40010bb4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40010bb8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40010bbc: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 40010bc0: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 40010bc4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40010bc8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010bcc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40010bd0: 30 80 00 0f b,a 40010c0c <== 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 ) ) { 40010bd4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40010bd8: 32 80 00 13 bne,a 40010c24 <== NOT EXECUTED 40010bdc: 21 10 00 d2 sethi %hi(0x40034800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40010be0: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 40034850 <_Thread_BSP_context+0x28> <== NOT EXECUTED 40010be4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40010be8: 22 80 00 07 be,a 40010c04 <== NOT EXECUTED 40010bec: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40010bf0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40010bf4: 12 80 00 0c bne 40010c24 <== NOT EXECUTED 40010bf8: 21 10 00 d2 sethi %hi(0x40034800), %l0 <== 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; 40010bfc: 10 80 00 08 b 40010c1c <== NOT EXECUTED 40010c00: 82 10 20 02 mov 2, %g1 <== 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++; 40010c04: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010c08: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40010c0c: 7f ff e7 2d call 4000a8c0 40010c10: 90 10 00 11 mov %l1, %o0 40010c14: 10 80 00 18 b 40010c74 40010c18: 92 10 00 18 mov %i0, %o1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40010c1c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40010c20: 30 bf ff fb b,a 40010c0c <== NOT EXECUTED 40010c24: c6 04 21 84 ld [ %l0 + 0x184 ], %g3 <== NOT EXECUTED 40010c28: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40010c2c: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 40010c30: c8 00 61 8c ld [ %g1 + 0x18c ], %g4 <== NOT EXECUTED 40010c34: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40010c38: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40010c3c: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 40010c40: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010c44: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED 40010c48: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 40010c4c: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 40010c50: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40010c54: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40010c58: 7f ff e7 1a call 4000a8c0 <== NOT EXECUTED 40010c5c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40010c60: d0 04 21 84 ld [ %l0 + 0x184 ], %o0 <== NOT EXECUTED 40010c64: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010c68: 40 00 0f 10 call 400148a8 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40010c6c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40010c70: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 40010c74: 21 10 00 d1 sethi %hi(0x40034400), %l0 40010c78: 94 07 bf f4 add %fp, -12, %o2 40010c7c: 40 00 13 0e call 400158b4 <_Objects_Get_no_protection> 40010c80: 90 14 22 c8 or %l0, 0x2c8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 40010c84: c2 07 bf f4 ld [ %fp + -12 ], %g1 40010c88: 80 a0 60 01 cmp %g1, 1 40010c8c: 02 80 00 0a be 40010cb4 40010c90: 92 10 00 08 mov %o0, %o1 40010c94: 80 a0 60 01 cmp %g1, 1 40010c98: 2a 80 00 22 bcs,a 40010d20 40010c9c: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 40010ca0: 80 a0 60 02 cmp %g1, 2 40010ca4: 12 80 00 10 bne 40010ce4 40010ca8: b0 10 20 19 mov 0x19, %i0 40010cac: 10 80 00 10 b 40010cec 40010cb0: 05 10 00 d2 sethi %hi(0x40034800), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 40010cb4: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40010cb8: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40010cbc: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010cc0: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED 40010cc4: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40010cc8: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 40010ccc: 94 10 20 00 clr %o2 <== NOT EXECUTED 40010cd0: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40010cd4: 40 00 0f 17 call 40014930 <_CORE_mutex_Surrender> <== NOT EXECUTED 40010cd8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40010cdc: 7f ff ff 66 call 40010a74 <_Thread_Enable_dispatch> <== NOT EXECUTED 40010ce0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 40010ce4: 81 c7 e0 08 ret <== NOT EXECUTED 40010ce8: 81 e8 00 00 restore <== NOT EXECUTED 40010cec: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 40010cf0: 82 00 60 01 inc %g1 40010cf4: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40010cf8: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010cfc: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 40010d00: 94 10 20 00 clr %o2 40010d04: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010d08: 40 00 0f 0a call 40014930 <_CORE_mutex_Surrender> 40010d0c: 90 02 20 10 add %o0, 0x10, %o0 40010d10: 7f ff ff 59 call 40010a74 <_Thread_Enable_dispatch> 40010d14: b0 10 20 04 mov 4, %i0 40010d18: 81 c7 e0 08 ret 40010d1c: 81 e8 00 00 restore return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks == 0 ) { 40010d20: 80 a0 60 00 cmp %g1, 0 40010d24: 12 80 00 1d bne 40010d98 40010d28: 05 10 00 d2 sethi %hi(0x40034800), %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40010d2c: 90 14 22 c8 or %l0, 0x2c8, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40010d30: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40010d34: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40010d38: 05 00 00 3f sethi %hi(0xfc00), %g2 40010d3c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40010d40: 82 08 40 02 and %g1, %g2, %g1 40010d44: 80 a0 40 03 cmp %g1, %g3 40010d48: 18 80 00 04 bgu 40010d58 40010d4c: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 40010d50: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40010d54: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 40010d58: 40 00 12 95 call 400157ac <_Objects_Free> 40010d5c: c0 22 60 0c clr [ %o1 + 0xc ] 40010d60: 05 10 00 d2 sethi %hi(0x40034800), %g2 40010d64: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 40010d68: 82 00 60 01 inc %g1 40010d6c: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 40010d70: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010d74: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 40010d78: 94 10 20 00 clr %o2 40010d7c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010d80: 40 00 0e ec call 40014930 <_CORE_mutex_Surrender> 40010d84: 90 02 20 10 add %o0, 0x10, %o0 40010d88: 7f ff ff 3b call 40010a74 <_Thread_Enable_dispatch> 40010d8c: b0 10 20 00 clr %i0 40010d90: 81 c7 e0 08 ret 40010d94: 81 e8 00 00 restore 40010d98: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 40010d9c: 82 00 60 01 inc %g1 40010da0: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] return RTEMS_SUCCESSFUL; } _RTEMS_Unlock_allocator(); 40010da4: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010da8: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 40010dac: 94 10 20 00 clr %o2 40010db0: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010db4: 40 00 0e df call 40014930 <_CORE_mutex_Surrender> 40010db8: 90 02 20 10 add %o0, 0x10, %o0 40010dbc: 7f ff ff 2e call 40010a74 <_Thread_Enable_dispatch> 40010dc0: b0 10 20 0c mov 0xc, %i0 return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40010dc4: 81 c7 e0 08 ret 40010dc8: 81 e8 00 00 restore 40010e00 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 40010e00: 9d e3 bf 90 save %sp, -112, %sp 40010e04: a4 10 00 18 mov %i0, %l2 Objects_Locations location; uint32_t amount_extended; Heap_Extend_status heap_status; rtems_status_code status; if ( !starting_address ) 40010e08: 80 a6 60 00 cmp %i1, 0 40010e0c: 02 80 00 90 be 4001104c 40010e10: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 40010e14: 7f ff e6 a7 call 4000a8b0 40010e18: 01 00 00 00 nop 40010e1c: a2 10 00 08 mov %o0, %l1 40010e20: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010e24: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 40010e28: 80 a0 60 00 cmp %g1, 0 40010e2c: 02 80 00 0b be 40010e58 40010e30: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010e34: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40010e38: c2 00 62 90 ld [ %g1 + 0x290 ], %g1 ! 40034a90 <_System_state_Current> <== NOT EXECUTED 40010e3c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40010e40: 08 80 00 05 bleu 40010e54 <== NOT EXECUTED 40010e44: 90 10 20 00 clr %o0 <== NOT EXECUTED 40010e48: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010e4c: 40 00 11 29 call 400152f0 <_Internal_error_Occurred> <== NOT EXECUTED 40010e50: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40010e54: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40010e58: e0 00 61 84 ld [ %g1 + 0x184 ], %l0 ! 40034984 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40010e5c: 03 10 00 d2 sethi %hi(0x40034800), %g1 40010e60: c4 00 61 8c ld [ %g1 + 0x18c ], %g2 ! 4003498c <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40010e64: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40010e68: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40010e6c: 80 a0 60 00 cmp %g1, 0 40010e70: 22 80 00 33 be,a 40010f3c 40010e74: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40010e78: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40010e7c: 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; 40010e80: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; 40010e84: 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; 40010e88: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 40010e8c: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40010e90: 80 a0 e0 02 cmp %g3, 2 40010e94: 02 80 00 05 be 40010ea8 40010e98: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 40010e9c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40010ea0: 32 80 00 06 bne,a 40010eb8 <== NOT EXECUTED 40010ea4: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40010ea8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 40010eac: 82 00 60 01 inc %g1 40010eb0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010eb4: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 40010eb8: 80 a0 60 03 cmp %g1, 3 40010ebc: 22 80 00 03 be,a 40010ec8 40010ec0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 40010ec4: 30 80 00 2c b,a 40010f74 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 40010ec8: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40010ecc: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40010ed0: 12 80 00 03 bne 40010edc <== NOT EXECUTED 40010ed4: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 40010ed8: 30 80 00 27 b,a 40010f74 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 40010edc: 08 80 00 10 bleu 40010f1c <== NOT EXECUTED 40010ee0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010ee4: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40010ee8: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40010eec: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010ef0: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40010ef4: 7f ff e6 73 call 4000a8c0 <== NOT EXECUTED 40010ef8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 40010efc: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40010f00: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40010f04: 40 00 16 48 call 40016824 <_Thread_Change_priority> <== NOT EXECUTED 40010f08: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 40010f0c: 7f ff ff b0 call 40010dcc <_Thread_Enable_dispatch> <== NOT EXECUTED 40010f10: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 40010f14: 10 80 00 32 b 40010fdc <== NOT EXECUTED 40010f18: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40010f1c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40010f20: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40010f24: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 40010f28: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 40010f2c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40010f30: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010f34: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40010f38: 30 80 00 0f b,a 40010f74 <== 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 ) ) { 40010f3c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40010f40: 32 80 00 13 bne,a 40010f8c <== NOT EXECUTED 40010f44: 21 10 00 d2 sethi %hi(0x40034800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40010f48: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 40034850 <_Thread_BSP_context+0x28> <== NOT EXECUTED 40010f4c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40010f50: 22 80 00 07 be,a 40010f6c <== NOT EXECUTED 40010f54: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40010f58: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40010f5c: 12 80 00 0c bne 40010f8c <== NOT EXECUTED 40010f60: 21 10 00 d2 sethi %hi(0x40034800), %l0 <== 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; 40010f64: 10 80 00 08 b 40010f84 <== NOT EXECUTED 40010f68: 82 10 20 02 mov 2, %g1 <== 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++; 40010f6c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010f70: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40010f74: 7f ff e6 53 call 4000a8c0 40010f78: 90 10 00 11 mov %l1, %o0 40010f7c: 10 80 00 18 b 40010fdc 40010f80: 92 10 00 12 mov %l2, %o1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40010f84: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40010f88: 30 bf ff fb b,a 40010f74 <== NOT EXECUTED 40010f8c: c6 04 21 84 ld [ %l0 + 0x184 ], %g3 <== NOT EXECUTED 40010f90: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40010f94: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 40010f98: c8 00 61 8c ld [ %g1 + 0x18c ], %g4 <== NOT EXECUTED 40010f9c: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40010fa0: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40010fa4: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 40010fa8: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010fac: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED 40010fb0: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 40010fb4: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 40010fb8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40010fbc: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40010fc0: 7f ff e6 40 call 4000a8c0 <== NOT EXECUTED 40010fc4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40010fc8: d0 04 21 84 ld [ %l0 + 0x184 ], %o0 <== NOT EXECUTED 40010fcc: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010fd0: 40 00 0e 36 call 400148a8 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40010fd4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40010fd8: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 40010fdc: 11 10 00 d1 sethi %hi(0x40034400), %o0 40010fe0: 94 07 bf f4 add %fp, -12, %o2 40010fe4: 40 00 12 34 call 400158b4 <_Objects_Get_no_protection> 40010fe8: 90 12 22 c8 or %o0, 0x2c8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 40010fec: c2 07 bf f4 ld [ %fp + -12 ], %g1 40010ff0: 80 a0 60 01 cmp %g1, 1 40010ff4: 02 80 00 0a be 4001101c 40010ff8: a0 10 00 08 mov %o0, %l0 40010ffc: 80 a0 60 01 cmp %g1, 1 40011000: 0a 80 00 22 bcs 40011088 40011004: 92 10 00 19 mov %i1, %o1 40011008: 80 a0 60 02 cmp %g1, 2 4001100c: 12 80 00 10 bne 4001104c 40011010: b0 10 20 19 mov 0x19, %i0 40011014: 10 80 00 10 b 40011054 40011018: 05 10 00 d2 sethi %hi(0x40034800), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 4001101c: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40011020: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40011024: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011028: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED 4001102c: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40011030: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 40011034: 94 10 20 00 clr %o2 <== NOT EXECUTED 40011038: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 4001103c: 40 00 0e 3d call 40014930 <_CORE_mutex_Surrender> <== NOT EXECUTED 40011040: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40011044: 7f ff ff 62 call 40010dcc <_Thread_Enable_dispatch> <== NOT EXECUTED 40011048: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 4001104c: 81 c7 e0 08 ret <== NOT EXECUTED 40011050: 81 e8 00 00 restore <== NOT EXECUTED 40011054: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 40011058: 82 00 60 01 inc %g1 4001105c: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40011060: 03 10 00 d2 sethi %hi(0x40034800), %g1 40011064: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 40011068: 94 10 20 00 clr %o2 4001106c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011070: 40 00 0e 30 call 40014930 <_CORE_mutex_Surrender> 40011074: 90 02 20 10 add %o0, 0x10, %o0 40011078: 7f ff ff 55 call 40010dcc <_Thread_Enable_dispatch> 4001107c: b0 10 20 04 mov 4, %i0 40011080: 81 c7 e0 08 ret 40011084: 81 e8 00 00 restore return RTEMS_INVALID_ID; case OBJECTS_LOCAL: heap_status = _Heap_Extend( 40011088: 94 10 00 1a mov %i2, %o2 4001108c: 90 02 20 68 add %o0, 0x68, %o0 40011090: 96 07 bf f0 add %fp, -16, %o3 40011094: 40 00 0f 62 call 40014e1c <_Heap_Extend> 40011098: b0 10 20 09 mov 9, %i0 starting_address, length, &amount_extended ); switch ( heap_status ) { 4001109c: 80 a2 20 01 cmp %o0, 1 400110a0: 02 80 00 12 be 400110e8 400110a4: 05 10 00 d2 sethi %hi(0x40034800), %g2 400110a8: 0a 80 00 08 bcs 400110c8 400110ac: c6 07 bf f0 ld [ %fp + -16 ], %g3 400110b0: 82 1a 20 02 xor %o0, 2, %g1 400110b4: 80 a0 00 01 cmp %g0, %g1 400110b8: 82 60 20 00 subx %g0, 0, %g1 400110bc: b0 08 7f e8 and %g1, -24, %i0 400110c0: 10 80 00 0a b 400110e8 400110c4: b0 06 20 18 add %i0, 0x18, %i0 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 400110c8: c4 04 20 54 ld [ %l0 + 0x54 ], %g2 the_region->maximum_segment_size += amount_extended; 400110cc: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 400110d0: 84 00 80 03 add %g2, %g3, %g2 the_region->maximum_segment_size += amount_extended; 400110d4: 82 00 40 03 add %g1, %g3, %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 400110d8: c4 24 20 54 st %g2, [ %l0 + 0x54 ] the_region->maximum_segment_size += amount_extended; 400110dc: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 400110e0: b0 10 20 00 clr %i0 400110e4: 05 10 00 d2 sethi %hi(0x40034800), %g2 400110e8: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 400110ec: 82 00 60 01 inc %g1 400110f0: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] break; case HEAP_EXTEND_NOT_IMPLEMENTED: status = RTEMS_NOT_IMPLEMENTED; break; } _RTEMS_Unlock_allocator(); 400110f4: 03 10 00 d2 sethi %hi(0x40034800), %g1 400110f8: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 400110fc: 94 10 20 00 clr %o2 40011100: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011104: 40 00 0e 0b call 40014930 <_CORE_mutex_Surrender> 40011108: 90 02 20 10 add %o0, 0x10, %o0 4001110c: 7f ff ff 30 call 40010dcc <_Thread_Enable_dispatch> 40011110: 01 00 00 00 nop return( status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40011114: 81 c7 e0 08 ret 40011118: 81 e8 00 00 restore 40011150 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 40011150: 9d e3 bf 90 save %sp, -112, %sp 40011154: a4 10 00 18 mov %i0, %l2 register Region_Control *the_region; Objects_Locations location; Thread_Control *executing; void *the_segment; if ( !segment ) 40011158: 80 a7 20 00 cmp %i4, 0 4001115c: 02 80 00 96 be 400113b4 40011160: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; *segment = NULL; 40011164: c0 27 00 00 clr [ %i4 ] if ( size == 0 ) 40011168: 80 a6 60 00 cmp %i1, 0 4001116c: 02 80 00 92 be 400113b4 40011170: b0 10 20 08 mov 8, %i0 return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 40011174: 7f ff e5 cf call 4000a8b0 40011178: 01 00 00 00 nop 4001117c: a2 10 00 08 mov %o0, %l1 40011180: 03 10 00 d2 sethi %hi(0x40034800), %g1 40011184: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 40011188: 80 a0 60 00 cmp %g1, 0 4001118c: 02 80 00 0b be 400111b8 40011190: 03 10 00 d2 sethi %hi(0x40034800), %g1 40011194: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40011198: c2 00 62 90 ld [ %g1 + 0x290 ], %g1 ! 40034a90 <_System_state_Current> <== NOT EXECUTED 4001119c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400111a0: 08 80 00 05 bleu 400111b4 <== NOT EXECUTED 400111a4: 90 10 20 00 clr %o0 <== NOT EXECUTED 400111a8: 92 10 20 00 clr %o1 <== NOT EXECUTED 400111ac: 40 00 10 51 call 400152f0 <_Internal_error_Occurred> <== NOT EXECUTED 400111b0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400111b4: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 400111b8: e0 00 61 84 ld [ %g1 + 0x184 ], %l0 ! 40034984 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400111bc: 03 10 00 d2 sethi %hi(0x40034800), %g1 400111c0: c4 00 61 8c ld [ %g1 + 0x18c ], %g2 ! 4003498c <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 400111c4: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 400111c8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 400111cc: 80 a0 60 00 cmp %g1, 0 400111d0: 22 80 00 33 be,a 4001129c 400111d4: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 400111d8: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400111dc: 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; 400111e0: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; 400111e4: 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; 400111e8: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 400111ec: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400111f0: 80 a0 e0 02 cmp %g3, 2 400111f4: 02 80 00 05 be 40011208 400111f8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 400111fc: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40011200: 32 80 00 06 bne,a 40011218 <== NOT EXECUTED 40011204: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40011208: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 4001120c: 82 00 60 01 inc %g1 40011210: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40011214: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 40011218: 80 a0 60 03 cmp %g1, 3 4001121c: 22 80 00 03 be,a 40011228 40011220: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 40011224: 30 80 00 2c b,a 400112d4 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 40011228: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 4001122c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40011230: 12 80 00 03 bne 4001123c <== NOT EXECUTED 40011234: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 40011238: 30 80 00 27 b,a 400112d4 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 4001123c: 28 80 00 10 bleu,a 4001127c <== NOT EXECUTED 40011240: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011244: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40011248: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4001124c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011250: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40011254: 7f ff e5 9b call 4000a8c0 <== NOT EXECUTED 40011258: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 4001125c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40011260: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40011264: 40 00 15 70 call 40016824 <_Thread_Change_priority> <== NOT EXECUTED 40011268: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 4001126c: 7f ff ff ac call 4001111c <_Thread_Enable_dispatch> <== NOT EXECUTED 40011270: 01 00 00 00 nop <== NOT EXECUTED executing = _Thread_Executing; 40011274: 10 80 00 32 b 4001133c <== NOT EXECUTED 40011278: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 4001127c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40011280: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40011284: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 40011288: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 4001128c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40011290: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40011294: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40011298: 30 80 00 0f b,a 400112d4 <== 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 ) ) { 4001129c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400112a0: 32 80 00 13 bne,a 400112ec <== NOT EXECUTED 400112a4: 21 10 00 d2 sethi %hi(0x40034800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400112a8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 40034850 <_Thread_BSP_context+0x28> <== NOT EXECUTED 400112ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400112b0: 22 80 00 07 be,a 400112cc <== NOT EXECUTED 400112b4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 400112b8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400112bc: 12 80 00 0c bne 400112ec <== NOT EXECUTED 400112c0: 21 10 00 d2 sethi %hi(0x40034800), %l0 <== 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; 400112c4: 10 80 00 08 b 400112e4 <== NOT EXECUTED 400112c8: 82 10 20 02 mov 2, %g1 <== 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++; 400112cc: 82 00 60 01 inc %g1 <== NOT EXECUTED 400112d0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400112d4: 7f ff e5 7b call 4000a8c0 400112d8: 90 10 00 11 mov %l1, %o0 400112dc: 10 80 00 18 b 4001133c 400112e0: 03 10 00 d2 sethi %hi(0x40034800), %g1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 400112e4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400112e8: 30 bf ff fb b,a 400112d4 <== NOT EXECUTED *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 400112ec: c6 04 21 84 ld [ %l0 + 0x184 ], %g3 <== NOT EXECUTED 400112f0: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 400112f4: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 400112f8: c8 00 61 8c ld [ %g1 + 0x18c ], %g4 <== NOT EXECUTED 400112fc: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40011300: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40011304: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 40011308: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001130c: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED 40011310: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 40011314: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 40011318: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4001131c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40011320: 7f ff e5 68 call 4000a8c0 <== NOT EXECUTED 40011324: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40011328: d0 04 21 84 ld [ %l0 + 0x184 ], %o0 <== NOT EXECUTED 4001132c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40011330: 40 00 0d 5e call 400148a8 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40011334: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED executing = _Thread_Executing; 40011338: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 4001133c: 11 10 00 d1 sethi %hi(0x40034400), %o0 40011340: f0 00 61 8c ld [ %g1 + 0x18c ], %i0 40011344: 90 12 22 c8 or %o0, 0x2c8, %o0 40011348: 92 10 00 12 mov %l2, %o1 4001134c: 40 00 11 5a call 400158b4 <_Objects_Get_no_protection> 40011350: 94 07 bf f4 add %fp, -12, %o2 the_region = _Region_Get( id, &location ); switch ( location ) { 40011354: c2 07 bf f4 ld [ %fp + -12 ], %g1 40011358: 80 a0 60 01 cmp %g1, 1 4001135c: 02 80 00 0a be 40011384 40011360: a0 10 00 08 mov %o0, %l0 40011364: 80 a0 60 01 cmp %g1, 1 40011368: 2a 80 00 22 bcs,a 400113f0 4001136c: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 40011370: 80 a0 60 02 cmp %g1, 2 40011374: 12 80 00 10 bne 400113b4 40011378: b0 10 20 19 mov 0x19, %i0 4001137c: 10 80 00 10 b 400113bc 40011380: 05 10 00 d2 sethi %hi(0x40034800), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 40011384: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40011388: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4001138c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011390: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED 40011394: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40011398: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 4001139c: 94 10 20 00 clr %o2 <== NOT EXECUTED 400113a0: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 400113a4: 40 00 0d 63 call 40014930 <_CORE_mutex_Surrender> <== NOT EXECUTED 400113a8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 400113ac: 7f ff ff 5c call 4001111c <_Thread_Enable_dispatch> <== NOT EXECUTED 400113b0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 400113b4: 81 c7 e0 08 ret <== NOT EXECUTED 400113b8: 81 e8 00 00 restore <== NOT EXECUTED 400113bc: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 400113c0: 82 00 60 01 inc %g1 400113c4: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 400113c8: 03 10 00 d2 sethi %hi(0x40034800), %g1 400113cc: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 400113d0: 94 10 20 00 clr %o2 400113d4: d2 02 20 08 ld [ %o0 + 8 ], %o1 400113d8: 40 00 0d 56 call 40014930 <_CORE_mutex_Surrender> 400113dc: 90 02 20 10 add %o0, 0x10, %o0 400113e0: 7f ff ff 4f call 4001111c <_Thread_Enable_dispatch> 400113e4: b0 10 20 04 mov 4, %i0 400113e8: 81 c7 e0 08 ret 400113ec: 81 e8 00 00 restore return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) { 400113f0: 80 a6 40 01 cmp %i1, %g1 400113f4: 08 80 00 0f bleu 40011430 400113f8: 05 10 00 d2 sethi %hi(0x40034800), %g2 400113fc: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 40011400: 82 00 60 01 inc %g1 40011404: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] _RTEMS_Unlock_allocator(); 40011408: 03 10 00 d2 sethi %hi(0x40034800), %g1 4001140c: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 40011410: 94 10 20 00 clr %o2 40011414: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011418: 40 00 0d 46 call 40014930 <_CORE_mutex_Surrender> 4001141c: 90 02 20 10 add %o0, 0x10, %o0 40011420: 7f ff ff 3f call 4001111c <_Thread_Enable_dispatch> 40011424: b0 10 20 08 mov 8, %i0 40011428: 81 c7 e0 08 ret 4001142c: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 40011430: 90 02 20 68 add %o0, 0x68, %o0 40011434: 40 00 0e 53 call 40014d80 <_Heap_Allocate> 40011438: 92 10 00 19 mov %i1, %o1 the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 4001143c: a2 92 20 00 orcc %o0, 0, %l1 40011440: 02 80 00 13 be 4001148c 40011444: 07 10 00 d2 sethi %hi(0x40034800), %g3 the_region->number_of_used_blocks += 1; 40011448: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 4001144c: c4 00 e0 b0 ld [ %g3 + 0xb0 ], %g2 40011450: 82 00 60 01 inc %g1 40011454: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 40011458: 84 00 a0 01 inc %g2 4001145c: c4 20 e0 b0 st %g2, [ %g3 + 0xb0 ] _RTEMS_Unlock_allocator(); 40011460: 03 10 00 d2 sethi %hi(0x40034800), %g1 40011464: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 40011468: 94 10 20 00 clr %o2 4001146c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011470: 40 00 0d 30 call 40014930 <_CORE_mutex_Surrender> 40011474: 90 02 20 10 add %o0, 0x10, %o0 40011478: 7f ff ff 29 call 4001111c <_Thread_Enable_dispatch> 4001147c: b0 10 20 00 clr %i0 *segment = the_segment; 40011480: e2 27 00 00 st %l1, [ %i4 ] 40011484: 81 c7 e0 08 ret 40011488: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } if ( _Options_Is_no_wait( option_set ) ) { 4001148c: 80 8e a0 01 btst 1, %i2 40011490: 05 10 00 d2 sethi %hi(0x40034800), %g2 40011494: 02 80 00 0e be 400114cc 40011498: 07 10 00 d2 sethi %hi(0x40034800), %g3 4001149c: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 400114a0: 82 00 60 01 inc %g1 400114a4: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] _RTEMS_Unlock_allocator(); 400114a8: d0 00 e1 84 ld [ %g3 + 0x184 ], %o0 400114ac: 94 10 20 00 clr %o2 400114b0: d2 02 20 08 ld [ %o0 + 8 ], %o1 400114b4: 40 00 0d 1f call 40014930 <_CORE_mutex_Surrender> 400114b8: 90 02 20 10 add %o0, 0x10, %o0 400114bc: 7f ff ff 18 call 4001111c <_Thread_Enable_dispatch> 400114c0: b0 10 20 0d mov 0xd, %i0 400114c4: 81 c7 e0 08 ret 400114c8: 81 e8 00 00 restore 400114cc: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 400114d0: 82 00 60 01 inc %g1 400114d4: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] 400114d8: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 400114dc: 82 00 60 01 inc %g1 400114e0: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] * 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(); 400114e4: d0 00 e1 84 ld [ %g3 + 0x184 ], %o0 400114e8: 94 10 20 00 clr %o2 400114ec: d2 02 20 08 ld [ %o0 + 8 ], %o1 400114f0: 40 00 0d 10 call 40014930 <_CORE_mutex_Surrender> 400114f4: 90 02 20 10 add %o0, 0x10, %o0 400114f8: 7f ff ff 09 call 4001111c <_Thread_Enable_dispatch> 400114fc: 01 00 00 00 nop executing->Wait.queue = &the_region->Wait_queue; 40011500: 82 04 20 10 add %l0, 0x10, %g1 executing->Wait.count = size; executing->Wait.return_argument = segment; _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 40011504: 92 10 00 1b mov %i3, %o1 40011508: 90 10 00 01 mov %g1, %o0 * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; 4001150c: c2 26 20 44 st %g1, [ %i0 + 0x44 ] 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 ); 40011510: 15 10 00 5d sethi %hi(0x40017400), %o2 40011514: 82 10 20 01 mov 1, %g1 40011518: 94 12 a3 0c or %o2, 0x30c, %o2 */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; executing->Wait.id = id; 4001151c: e4 26 20 20 st %l2, [ %i0 + 0x20 ] executing->Wait.count = size; 40011520: f2 26 20 24 st %i1, [ %i0 + 0x24 ] executing->Wait.return_argument = segment; 40011524: 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 ); 40011528: 40 00 17 53 call 40017274 <_Thread_queue_Enqueue_with_handler> 4001152c: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _Thread_Enable_dispatch(); 40011530: 7f ff fe fb call 4001111c <_Thread_Enable_dispatch> 40011534: 01 00 00 00 nop return (rtems_status_code) executing->Wait.return_code; 40011538: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001153c: 81 c7 e0 08 ret 40011540: 81 e8 00 00 restore 400115b0 : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 400115b0: 9d e3 bf 90 save %sp, -112, %sp #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 400115b4: 7f ff e4 bf call 4000a8b0 400115b8: 01 00 00 00 nop 400115bc: a2 10 00 08 mov %o0, %l1 400115c0: 03 10 00 d2 sethi %hi(0x40034800), %g1 400115c4: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 400115c8: 80 a0 60 00 cmp %g1, 0 400115cc: 02 80 00 0b be 400115f8 400115d0: 03 10 00 d2 sethi %hi(0x40034800), %g1 400115d4: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 400115d8: c2 00 62 90 ld [ %g1 + 0x290 ], %g1 ! 40034a90 <_System_state_Current> <== NOT EXECUTED 400115dc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400115e0: 08 80 00 05 bleu 400115f4 <== NOT EXECUTED 400115e4: 90 10 20 00 clr %o0 <== NOT EXECUTED 400115e8: 92 10 20 00 clr %o1 <== NOT EXECUTED 400115ec: 40 00 0f 41 call 400152f0 <_Internal_error_Occurred> <== NOT EXECUTED 400115f0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400115f4: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 400115f8: e0 00 61 84 ld [ %g1 + 0x184 ], %l0 ! 40034984 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400115fc: 03 10 00 d2 sethi %hi(0x40034800), %g1 40011600: c4 00 61 8c ld [ %g1 + 0x18c ], %g2 ! 4003498c <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40011604: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40011608: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 4001160c: 80 a0 60 00 cmp %g1, 0 40011610: 22 80 00 33 be,a 400116dc 40011614: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40011618: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 4001161c: 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; 40011620: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; 40011624: 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; 40011628: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 4001162c: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40011630: 80 a0 e0 02 cmp %g3, 2 40011634: 02 80 00 05 be 40011648 40011638: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 4001163c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40011640: 32 80 00 06 bne,a 40011658 <== NOT EXECUTED 40011644: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40011648: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 4001164c: 82 00 60 01 inc %g1 40011650: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40011654: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 40011658: 80 a0 60 03 cmp %g1, 3 4001165c: 22 80 00 03 be,a 40011668 40011660: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 40011664: 30 80 00 2c b,a 40011714 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 40011668: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 4001166c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40011670: 12 80 00 03 bne 4001167c <== NOT EXECUTED 40011674: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 40011678: 30 80 00 27 b,a 40011714 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 4001167c: 08 80 00 10 bleu 400116bc <== NOT EXECUTED 40011680: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011684: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40011688: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4001168c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011690: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40011694: 7f ff e4 8b call 4000a8c0 <== NOT EXECUTED 40011698: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 4001169c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 400116a0: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 400116a4: 40 00 14 60 call 40016824 <_Thread_Change_priority> <== NOT EXECUTED 400116a8: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 400116ac: 7f ff ff b4 call 4001157c <_Thread_Enable_dispatch> <== NOT EXECUTED 400116b0: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 400116b4: 10 80 00 32 b 4001177c <== NOT EXECUTED 400116b8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 400116bc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400116c0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 400116c4: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 400116c8: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 400116cc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400116d0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400116d4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400116d8: 30 80 00 0f b,a 40011714 <== 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 ) ) { 400116dc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400116e0: 32 80 00 13 bne,a 4001172c <== NOT EXECUTED 400116e4: 21 10 00 d2 sethi %hi(0x40034800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400116e8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 40034850 <_Thread_BSP_context+0x28> <== NOT EXECUTED 400116ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400116f0: 22 80 00 07 be,a 4001170c <== NOT EXECUTED 400116f4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 400116f8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400116fc: 12 80 00 0c bne 4001172c <== NOT EXECUTED 40011700: 21 10 00 d2 sethi %hi(0x40034800), %l0 <== 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; 40011704: 10 80 00 08 b 40011724 <== NOT EXECUTED 40011708: 82 10 20 02 mov 2, %g1 <== 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++; 4001170c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011710: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40011714: 7f ff e4 6b call 4000a8c0 40011718: 90 10 00 11 mov %l1, %o0 4001171c: 10 80 00 18 b 4001177c 40011720: 92 10 00 18 mov %i0, %o1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40011724: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40011728: 30 bf ff fb b,a 40011714 <== NOT EXECUTED 4001172c: c6 04 21 84 ld [ %l0 + 0x184 ], %g3 <== NOT EXECUTED 40011730: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40011734: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 40011738: c8 00 61 8c ld [ %g1 + 0x18c ], %g4 <== NOT EXECUTED 4001173c: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 40011740: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40011744: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 40011748: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001174c: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED 40011750: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 40011754: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 40011758: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4001175c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40011760: 7f ff e4 58 call 4000a8c0 <== NOT EXECUTED 40011764: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40011768: d0 04 21 84 ld [ %l0 + 0x184 ], %o0 <== NOT EXECUTED 4001176c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40011770: 40 00 0c 4e call 400148a8 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40011774: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40011778: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4001177c: 11 10 00 d1 sethi %hi(0x40034400), %o0 40011780: 94 07 bf f4 add %fp, -12, %o2 40011784: 40 00 10 4c call 400158b4 <_Objects_Get_no_protection> 40011788: 90 12 22 c8 or %o0, 0x2c8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 4001178c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40011790: 80 a0 60 01 cmp %g1, 1 40011794: 02 80 00 0a be 400117bc 40011798: a0 10 00 08 mov %o0, %l0 4001179c: 80 a0 60 01 cmp %g1, 1 400117a0: 0a 80 00 22 bcs 40011828 400117a4: 92 10 00 19 mov %i1, %o1 400117a8: 80 a0 60 02 cmp %g1, 2 400117ac: 12 80 00 10 bne 400117ec 400117b0: b0 10 20 19 mov 0x19, %i0 400117b4: 10 80 00 10 b 400117f4 400117b8: 05 10 00 d2 sethi %hi(0x40034800), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 400117bc: 05 10 00 d2 sethi %hi(0x40034800), %g2 <== NOT EXECUTED 400117c0: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400117c4: 82 00 60 01 inc %g1 <== NOT EXECUTED 400117c8: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED 400117cc: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 400117d0: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 400117d4: 94 10 20 00 clr %o2 <== NOT EXECUTED 400117d8: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 400117dc: 40 00 0c 55 call 40014930 <_CORE_mutex_Surrender> <== NOT EXECUTED 400117e0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 400117e4: 7f ff ff 66 call 4001157c <_Thread_Enable_dispatch> <== NOT EXECUTED 400117e8: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 400117ec: 81 c7 e0 08 ret <== NOT EXECUTED 400117f0: 81 e8 00 00 restore <== NOT EXECUTED 400117f4: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 400117f8: 82 00 60 01 inc %g1 400117fc: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40011800: 03 10 00 d2 sethi %hi(0x40034800), %g1 40011804: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 40011808: 94 10 20 00 clr %o2 4001180c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011810: 40 00 0c 48 call 40014930 <_CORE_mutex_Surrender> 40011814: 90 02 20 10 add %o0, 0x10, %o0 40011818: 7f ff ff 59 call 4001157c <_Thread_Enable_dispatch> 4001181c: b0 10 20 04 mov 4, %i0 40011820: 81 c7 e0 08 ret 40011824: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE boolean _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 40011828: 40 00 0d ae call 40014ee0 <_Heap_Free> 4001182c: 90 02 20 68 add %o0, 0x68, %o0 status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) { 40011830: 80 a2 20 00 cmp %o0, 0 40011834: 12 80 00 0f bne 40011870 40011838: 05 10 00 d2 sethi %hi(0x40034800), %g2 4001183c: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 40011840: 82 00 60 01 inc %g1 40011844: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] _RTEMS_Unlock_allocator(); 40011848: 03 10 00 d2 sethi %hi(0x40034800), %g1 4001184c: d0 00 61 84 ld [ %g1 + 0x184 ], %o0 ! 40034984 <_RTEMS_Allocator_Mutex> 40011850: 94 10 20 00 clr %o2 40011854: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011858: 40 00 0c 36 call 40014930 <_CORE_mutex_Surrender> 4001185c: 90 02 20 10 add %o0, 0x10, %o0 40011860: 7f ff ff 47 call 4001157c <_Thread_Enable_dispatch> 40011864: b0 10 20 09 mov 9, %i0 40011868: 81 c7 e0 08 ret 4001186c: 81 e8 00 00 restore return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 40011870: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 40011874: 90 10 00 10 mov %l0, %o0 if ( !status ) { _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 40011878: 82 00 7f ff add %g1, -1, %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 4001187c: b0 10 20 00 clr %i0 40011880: 40 00 24 e0 call 4001ac00 <_Region_Process_queue> 40011884: c2 24 20 64 st %g1, [ %l0 + 0x64 ] return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40011888: 81 c7 e0 08 ret 4001188c: 81 e8 00 00 restore 40006458 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 40006458: 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 ) ) 4000645c: a8 96 20 00 orcc %i0, 0, %l4 40006460: 02 80 00 2c be 40006510 40006464: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 40006468: 80 a7 20 00 cmp %i4, 0 4000646c: 02 80 00 29 be 40006510 40006470: b0 10 20 09 mov 9, %i0 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 40006474: a4 8e a0 40 andcc %i2, 0x40, %l2 40006478: 12 80 00 06 bne 40006490 4000647c: 82 0e a0 30 and %i2, 0x30, %g1 40006480: 80 8e a0 80 btst 0x80, %i2 40006484: 02 80 00 10 be 400064c4 40006488: a6 0e a0 30 and %i2, 0x30, %l3 RTEMS_INLINE_ROUTINE boolean _Attributes_Is_binary_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE); 4000648c: 82 0e a0 30 and %i2, 0x30, %g1 _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 40006490: 80 a0 60 10 cmp %g1, 0x10 40006494: 02 80 00 05 be 400064a8 40006498: 80 8e a0 04 btst 4, %i2 4000649c: 80 a0 60 20 cmp %g1, 0x20 400064a0: 12 80 00 71 bne 40006664 400064a4: 80 8e a0 04 btst 4, %i2 400064a8: 02 80 00 6f be 40006664 400064ac: 80 a4 a0 00 cmp %l2, 0 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 400064b0: 02 80 00 04 be 400064c0 400064b4: 80 8e a0 80 btst 0x80, %i2 400064b8: 32 80 00 16 bne,a 40006510 400064bc: b0 10 20 0b mov 0xb, %i0 RTEMS_INLINE_ROUTINE boolean _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 400064c0: a6 0e a0 30 and %i2, 0x30, %l3 400064c4: 80 a0 00 13 cmp %g0, %l3 400064c8: a2 60 3f ff subx %g0, -1, %l1 _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 400064cc: 80 a4 60 00 cmp %l1, 0 400064d0: 12 80 00 04 bne 400064e0 400064d4: 80 a6 60 01 cmp %i1, 1 400064d8: 18 80 00 0e bgu 40006510 400064dc: b0 10 20 0a mov 0xa, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400064e0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400064e4: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 4001add0 <_Thread_Dispatch_disable_level> 400064e8: 84 00 a0 01 inc %g2 400064ec: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ] * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 400064f0: 11 10 00 6b sethi %hi(0x4001ac00), %o0 400064f4: 40 00 07 06 call 4000810c <_Objects_Allocate> 400064f8: 90 12 20 88 or %o0, 0x88, %o0 ! 4001ac88 <_Semaphore_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 400064fc: a0 92 20 00 orcc %o0, 0, %l0 40006500: 12 80 00 06 bne 40006518 40006504: 80 a4 60 00 cmp %l1, 0 _Thread_Enable_dispatch(); 40006508: 7f ff ff c7 call 40006424 <_Thread_Enable_dispatch> 4000650c: b0 10 20 05 mov 5, %i0 40006510: 81 c7 e0 08 ret 40006514: 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 ) ) { 40006518: 12 80 00 32 bne 400065e0 4000651c: f4 24 20 10 st %i2, [ %l0 + 0x10 ] CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 40006520: 80 a4 a0 00 cmp %l2, 0 40006524: 12 80 00 06 bne 4000653c 40006528: 82 10 20 02 mov 2, %g1 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 4000652c: 80 8e a0 80 btst 0x80, %i2 40006530: 02 80 00 05 be 40006544 40006534: 80 8e a0 04 btst 4, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 40006538: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 4000653c: 10 80 00 05 b 40006550 40006540: c2 27 bf e8 st %g1, [ %fp + -24 ] else if ( _Attributes_Is_priority( attribute_set ) ) 40006544: 12 bf ff fe bne 4000653c 40006548: 82 10 20 01 mov 1, %g1 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; 4000654c: c0 27 bf e8 clr [ %fp + -24 ] if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 40006550: 80 a4 e0 10 cmp %l3, 0x10 40006554: 12 80 00 0f bne 40006590 40006558: 82 10 20 02 mov 2, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 4000655c: c2 07 bf e8 ld [ %fp + -24 ], %g1 40006560: 80 a0 60 01 cmp %g1, 1 40006564: 08 80 00 07 bleu 40006580 40006568: c0 27 bf e0 clr [ %fp + -32 ] 4000656c: 80 a0 60 03 cmp %g1, 3 40006570: 38 80 00 0b bgu,a 4000659c 40006574: 82 1e 60 01 xor %i1, 1, %g1 <== NOT EXECUTED 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; 40006578: 10 80 00 04 b 40006588 4000657c: 82 10 20 01 mov 1, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; 40006580: 10 80 00 06 b 40006598 40006584: c0 27 bf e4 clr [ %fp + -28 ] break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 40006588: 10 80 00 04 b 40006598 4000658c: c2 27 bf e4 st %g1, [ %fp + -28 ] break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; the_mutex_attributes.only_owner_release = FALSE; 40006590: 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; 40006594: c2 27 bf e0 st %g1, [ %fp + -32 ] the_mutex_attributes.only_owner_release = FALSE; } the_mutex_attributes.priority_ceiling = priority_ceiling; mutex_status = _CORE_mutex_Initialize( 40006598: 82 1e 60 01 xor %i1, 1, %g1 4000659c: 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; 400065a0: f6 27 bf ec st %i3, [ %fp + -20 ] mutex_status = _CORE_mutex_Initialize( 400065a4: 94 60 3f ff subx %g0, -1, %o2 400065a8: 90 04 20 14 add %l0, 0x14, %o0 400065ac: 40 00 04 63 call 40007738 <_CORE_mutex_Initialize> 400065b0: 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 ) { 400065b4: 80 a2 20 06 cmp %o0, 6 400065b8: 12 80 00 17 bne 40006614 400065bc: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 400065c0: 11 10 00 6b sethi %hi(0x4001ac00), %o0 <== NOT EXECUTED 400065c4: 90 12 20 88 or %o0, 0x88, %o0 ! 4001ac88 <_Semaphore_Information> <== NOT EXECUTED 400065c8: 40 00 07 d3 call 40008514 <_Objects_Free> <== NOT EXECUTED 400065cc: b0 10 20 13 mov 0x13, %i0 <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 400065d0: 7f ff ff 95 call 40006424 <_Thread_Enable_dispatch> <== NOT EXECUTED 400065d4: 01 00 00 00 nop <== NOT EXECUTED 400065d8: 81 c7 e0 08 ret <== NOT EXECUTED 400065dc: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) 400065e0: 80 8e a0 04 btst 4, %i2 400065e4: 22 80 00 04 be,a 400065f4 400065e8: c0 27 bf f4 clr [ %fp + -12 ] the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 400065ec: 82 10 20 01 mov 1, %g1 400065f0: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 400065f4: 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; 400065f8: c0 27 bf e0 clr [ %fp + -32 ] the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 400065fc: c0 27 bf ec clr [ %fp + -20 ] _CORE_semaphore_Initialize( 40006600: 94 10 00 19 mov %i1, %o2 /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 40006604: 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( 40006608: 90 04 20 14 add %l0, 0x14, %o0 4000660c: 40 00 04 fa call 400079f4 <_CORE_semaphore_Initialize> 40006610: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006614: 03 10 00 6b sethi %hi(0x4001ac00), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40006618: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000661c: 88 10 60 88 or %g1, 0x88, %g4 40006620: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 40006624: 03 00 00 3f sethi %hi(0xfc00), %g1 40006628: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000662c: 82 08 c0 01 and %g3, %g1, %g1 40006630: 80 a0 40 02 cmp %g1, %g2 40006634: 38 80 00 06 bgu,a 4000664c 40006638: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 4000663c: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 40006640: 83 28 60 02 sll %g1, 2, %g1 40006644: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 40006648: c2 04 20 08 ld [ %l0 + 8 ], %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; 4000664c: e8 24 20 0c st %l4, [ %l0 + 0xc ] 40006650: c2 27 00 00 st %g1, [ %i4 ] the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 40006654: 7f ff ff 74 call 40006424 <_Thread_Enable_dispatch> 40006658: b0 10 20 00 clr %i0 4000665c: 81 c7 e0 08 ret 40006660: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 40006664: b0 10 20 0b mov 0xb, %i0 } 40006668: 81 c7 e0 08 ret 4000666c: 81 e8 00 00 restore 400066a4 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 400066a4: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 400066a8: 11 10 00 6b sethi %hi(0x4001ac00), %o0 400066ac: 92 10 00 18 mov %i0, %o1 400066b0: 90 12 20 88 or %o0, 0x88, %o0 400066b4: 40 00 07 da call 4000861c <_Objects_Get> 400066b8: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 400066bc: c2 07 bf f4 ld [ %fp + -12 ], %g1 400066c0: 80 a0 60 00 cmp %g1, 0 400066c4: 02 80 00 07 be 400066e0 400066c8: b0 10 00 08 mov %o0, %i0 400066cc: 80 a0 60 02 cmp %g1, 2 400066d0: 08 80 00 10 bleu 40006710 400066d4: b0 10 20 04 mov 4, %i0 400066d8: 81 c7 e0 08 ret <== NOT EXECUTED 400066dc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 400066e0: 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) ) { 400066e4: 84 88 60 30 andcc %g1, 0x30, %g2 400066e8: 22 80 00 12 be,a 40006730 400066ec: 90 02 20 14 add %o0, 0x14, %o0 if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 400066f0: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 400066f4: 80 a0 60 00 cmp %g1, 0 400066f8: 12 80 00 08 bne 40006718 400066fc: 80 a0 a0 20 cmp %g2, 0x20 40006700: 02 80 00 07 be 4000671c 40006704: 90 06 20 14 add %i0, 0x14, %o0 !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 40006708: 7f ff ff da call 40006670 <_Thread_Enable_dispatch> 4000670c: b0 10 20 0c mov 0xc, %i0 40006710: 81 c7 e0 08 ret 40006714: 81 e8 00 00 restore return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 40006718: 90 06 20 14 add %i0, 0x14, %o0 4000671c: 92 10 20 00 clr %o1 40006720: 40 00 04 02 call 40007728 <_CORE_mutex_Flush> 40006724: 94 10 20 04 mov 4, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006728: 10 80 00 06 b 40006740 4000672c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 40006730: 92 10 20 00 clr %o1 40006734: 40 00 04 ac call 400079e4 <_CORE_semaphore_Flush> 40006738: 94 10 20 02 mov 2, %o2 4000673c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40006740: c6 06 20 08 ld [ %i0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006744: 90 10 60 88 or %g1, 0x88, %o0 40006748: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 4000674c: 03 00 00 3f sethi %hi(0xfc00), %g1 40006750: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40006754: 82 08 c0 01 and %g3, %g1, %g1 40006758: 80 a0 40 02 cmp %g1, %g2 4000675c: 18 80 00 05 bgu 40006770 40006760: 92 10 00 18 mov %i0, %o1 information->local_table[ index ] = the_object; 40006764: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006768: 83 28 60 02 sll %g1, 2, %g1 4000676c: 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; 40006770: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 40006774: 40 00 07 68 call 40008514 <_Objects_Free> 40006778: b0 10 20 00 clr %i0 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 4000677c: 7f ff ff bd call 40006670 <_Thread_Enable_dispatch> 40006780: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006784: 81 c7 e0 08 ret 40006788: 81 e8 00 00 restore 40006be8 : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 40006be8: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 40006bec: 11 10 00 73 sethi %hi(0x4001cc00), %o0 40006bf0: 92 10 00 18 mov %i0, %o1 40006bf4: 90 12 22 60 or %o0, 0x260, %o0 40006bf8: 40 00 08 57 call 40008d54 <_Objects_Get> 40006bfc: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 40006c00: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006c04: 80 a0 60 00 cmp %g1, 0 40006c08: 22 80 00 07 be,a 40006c24 40006c0c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40006c10: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40006c14: 08 80 00 19 bleu 40006c78 <== NOT EXECUTED 40006c18: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 40006c1c: 81 c7 e0 08 ret <== NOT EXECUTED 40006c20: 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) ) { 40006c24: 80 88 60 30 btst 0x30, %g1 40006c28: 02 80 00 06 be 40006c40 40006c2c: 90 02 20 14 add %o0, 0x14, %o0 _CORE_mutex_Flush( 40006c30: 92 10 20 00 clr %o1 40006c34: 40 00 04 8b call 40007e60 <_CORE_mutex_Flush> 40006c38: 94 10 20 01 mov 1, %o2 40006c3c: 30 80 00 04 b,a 40006c4c &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 40006c40: 92 10 20 00 clr %o1 <== NOT EXECUTED 40006c44: 40 00 05 36 call 4000811c <_CORE_semaphore_Flush> <== NOT EXECUTED 40006c48: 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 ) 40006c4c: 03 10 00 73 sethi %hi(0x4001cc00), %g1 40006c50: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 4001cfb0 <_Thread_Dispatch_disable_level> 40006c54: b0 10 20 00 clr %i0 40006c58: 84 00 bf ff add %g2, -1, %g2 40006c5c: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 40006c60: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 40006c64: 80 a0 60 00 cmp %g1, 0 40006c68: 12 80 00 04 bne 40006c78 40006c6c: 01 00 00 00 nop _Thread_Dispatch(); 40006c70: 40 00 0c ee call 4000a028 <_Thread_Dispatch> 40006c74: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006c78: 81 c7 e0 08 ret 40006c7c: 81 e8 00 00 restore 400067c0 : rtems_status_code rtems_semaphore_obtain( rtems_id id, uint32_t option_set, rtems_interval timeout ) { 400067c0: 9d e3 bf 90 save %sp, -112, %sp Objects_Id id, Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) 400067c4: 11 10 00 6b sethi %hi(0x4001ac00), %o0 400067c8: 92 10 00 18 mov %i0, %o1 400067cc: 90 12 20 88 or %o0, 0x88, %o0 400067d0: 94 07 bf f4 add %fp, -12, %o2 400067d4: 40 00 07 74 call 400085a4 <_Objects_Get_isr_disable> 400067d8: 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 ) { 400067dc: c2 07 bf f4 ld [ %fp + -12 ], %g1 400067e0: 80 a0 60 00 cmp %g1, 0 400067e4: 02 80 00 07 be 40006800 400067e8: a0 10 00 08 mov %o0, %l0 400067ec: 80 a0 60 02 cmp %g1, 2 400067f0: 08 80 00 ab bleu 40006a9c 400067f4: 90 10 20 04 mov 4, %o0 400067f8: 10 80 00 a9 b 40006a9c <== NOT EXECUTED 400067fc: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 40006800: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40006804: 80 88 60 30 btst 0x30, %g1 40006808: 02 80 00 7c be 400069f8 4000680c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _CORE_mutex_Seize( 40006810: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006814: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> 40006818: 80 a0 60 00 cmp %g1, 0 4000681c: 02 80 00 0e be 40006854 40006820: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006824: 80 8e 60 01 btst 1, %i1 40006828: 12 80 00 0c bne 40006858 4000682c: c4 00 62 ac ld [ %g1 + 0x2ac ], %g2 40006830: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006834: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 4001afb0 <_System_state_Current> 40006838: 80 a0 60 01 cmp %g1, 1 4000683c: 08 80 00 05 bleu 40006850 40006840: 90 10 20 00 clr %o0 40006844: 92 10 20 00 clr %o1 <== NOT EXECUTED 40006848: 40 00 06 04 call 40008058 <_Internal_error_Occurred> <== NOT EXECUTED 4000684c: 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; 40006850: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006854: c4 00 62 ac ld [ %g1 + 0x2ac ], %g2 ! 4001aeac <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 40006858: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 4000685c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40006860: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 40006864: 80 a0 60 00 cmp %g1, 0 40006868: 22 80 00 33 be,a 40006934 4000686c: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 40006870: c0 24 20 64 clr [ %l0 + 0x64 ] the_mutex->holder = executing; 40006874: c4 24 20 70 st %g2, [ %l0 + 0x70 ] the_mutex->holder_id = executing->Object.id; 40006878: 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; 4000687c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 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; 40006880: c2 24 20 74 st %g1, [ %l0 + 0x74 ] the_mutex->nest_count = 1; 40006884: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40006888: 80 a0 e0 02 cmp %g3, 2 4000688c: 02 80 00 05 be 400068a0 40006890: c2 24 20 68 st %g1, [ %l0 + 0x68 ] 40006894: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40006898: 32 80 00 06 bne,a 400068b0 <== NOT EXECUTED 4000689c: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400068a0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 400068a4: 82 00 60 01 inc %g1 400068a8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400068ac: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 400068b0: 80 a0 60 03 cmp %g1, 3 400068b4: 22 80 00 03 be,a 400068c0 400068b8: c6 04 20 60 ld [ %l0 + 0x60 ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 400068bc: 30 80 00 2e b,a 40006974 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 400068c0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 400068c4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 400068c8: 12 80 00 03 bne 400068d4 <== NOT EXECUTED 400068cc: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 400068d0: 30 80 00 29 b,a 40006974 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 400068d4: 28 80 00 10 bleu,a 40006914 <== NOT EXECUTED 400068d8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400068dc: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 400068e0: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 ! 4001add0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400068e4: 82 00 60 01 inc %g1 <== NOT EXECUTED 400068e8: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 400068ec: 7f ff ed 7c call 40001edc <== NOT EXECUTED 400068f0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Change_priority( 400068f4: d2 04 20 60 ld [ %l0 + 0x60 ], %o1 <== NOT EXECUTED 400068f8: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 <== NOT EXECUTED 400068fc: 40 00 0b 10 call 4000953c <_Thread_Change_priority> <== NOT EXECUTED 40006900: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 40006904: 7f ff ff a2 call 4000678c <_Thread_Enable_dispatch> <== NOT EXECUTED 40006908: 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( 4000690c: 10 80 00 36 b 400069e4 <== NOT EXECUTED 40006910: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40006914: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40006918: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4000691c: c0 24 20 68 clr [ %l0 + 0x68 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 40006920: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 40006924: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40006928: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000692c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40006930: 30 80 00 11 b,a 40006974 <== 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 ) ) { 40006934: 80 a0 40 02 cmp %g1, %g2 40006938: 12 80 00 13 bne 40006984 4000693c: 80 8e 60 01 btst 1, %i1 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40006940: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 40006944: 80 a0 60 00 cmp %g1, 0 40006948: 22 80 00 07 be,a 40006964 4000694c: c2 04 20 68 ld [ %l0 + 0x68 ], %g1 40006950: 80 a0 60 01 cmp %g1, 1 40006954: 12 80 00 0c bne 40006984 40006958: 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; 4000695c: 10 80 00 05 b 40006970 <== NOT EXECUTED 40006960: 82 10 20 02 mov 2, %g1 <== 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++; 40006964: 82 00 60 01 inc %g1 40006968: c2 24 20 68 st %g1, [ %l0 + 0x68 ] _ISR_Enable( level ); 4000696c: 30 80 00 02 b,a 40006974 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40006970: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40006974: 7f ff ed 5a call 40001edc 40006978: 01 00 00 00 nop 4000697c: 10 80 00 1a b 400069e4 40006980: 03 10 00 6b sethi %hi(0x4001ac00), %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 40006984: 02 80 00 08 be 400069a4 40006988: 23 10 00 6b sethi %hi(0x4001ac00), %l1 4000698c: 7f ff ed 54 call 40001edc 40006990: d0 07 bf f0 ld [ %fp + -16 ], %o0 40006994: c4 04 62 ac ld [ %l1 + 0x2ac ], %g2 40006998: 82 10 20 01 mov 1, %g1 4000699c: 10 80 00 11 b 400069e0 400069a0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] 400069a4: c6 04 62 ac ld [ %l1 + 0x2ac ], %g3 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 400069a8: 82 10 20 01 mov 1, %g1 400069ac: 05 10 00 6b sethi %hi(0x4001ac00), %g2 400069b0: c2 24 20 44 st %g1, [ %l0 + 0x44 ] 400069b4: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 400069b8: f0 20 e0 20 st %i0, [ %g3 + 0x20 ] 400069bc: 82 00 60 01 inc %g1 400069c0: a0 04 20 14 add %l0, 0x14, %l0 400069c4: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] 400069c8: e0 20 e0 44 st %l0, [ %g3 + 0x44 ] 400069cc: 7f ff ed 44 call 40001edc 400069d0: d0 07 bf f0 ld [ %fp + -16 ], %o0 400069d4: 90 10 00 10 mov %l0, %o0 400069d8: 40 00 03 86 call 400077f0 <_CORE_mutex_Seize_interrupt_blocking> 400069dc: 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( 400069e0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400069e4: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 4001aeac <_Thread_Executing> 400069e8: 40 00 00 62 call 40006b70 <_Semaphore_Translate_core_mutex_return_code> 400069ec: 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 */ } 400069f0: 81 c7 e0 08 ret 400069f4: 91 e8 00 08 restore %g0, %o0, %o0 Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400069f8: e2 00 62 ac ld [ %g1 + 0x2ac ], %l1 Watchdog_Interval timeout, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 400069fc: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 40006a00: c0 24 60 34 clr [ %l1 + 0x34 ] if ( the_semaphore->count != 0 ) { 40006a04: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 40006a08: 80 a0 60 00 cmp %g1, 0 40006a0c: 02 80 00 08 be 40006a2c 40006a10: 80 8e 60 01 btst 1, %i1 the_semaphore->count -= 1; 40006a14: 82 00 7f ff add %g1, -1, %g1 40006a18: c2 24 20 5c st %g1, [ %l0 + 0x5c ] _ISR_Enable( level ); 40006a1c: 7f ff ed 30 call 40001edc 40006a20: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 40006a24: 10 80 00 1b b 40006a90 40006a28: 03 10 00 6b sethi %hi(0x4001ac00), %g1 return; } if ( !wait ) { 40006a2c: 02 80 00 07 be 40006a48 40006a30: 05 10 00 6b sethi %hi(0x4001ac00), %g2 _ISR_Enable( level ); 40006a34: 7f ff ed 2a call 40001edc 40006a38: 01 00 00 00 nop executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 40006a3c: 82 10 20 01 mov 1, %g1 ! 1 40006a40: 10 80 00 13 b 40006a8c 40006a44: c2 24 60 34 st %g1, [ %l1 + 0x34 ] 40006a48: c2 00 a1 d0 ld [ %g2 + 0x1d0 ], %g1 40006a4c: 82 00 60 01 inc %g1 40006a50: c2 20 a1 d0 st %g1, [ %g2 + 0x1d0 ] 40006a54: 82 10 20 01 mov 1, %g1 40006a58: 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; 40006a5c: f0 24 60 20 st %i0, [ %l1 + 0x20 ] return; } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 40006a60: a0 04 20 14 add %l0, 0x14, %l0 40006a64: e0 24 60 44 st %l0, [ %l1 + 0x44 ] executing->Wait.id = id; _ISR_Enable( level ); 40006a68: 7f ff ed 1d call 40001edc 40006a6c: 01 00 00 00 nop _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 40006a70: 90 10 00 10 mov %l0, %o0 40006a74: 92 10 00 1a mov %i2, %o1 40006a78: 15 10 00 29 sethi %hi(0x4000a400), %o2 40006a7c: 40 00 0d 44 call 40009f8c <_Thread_queue_Enqueue_with_handler> 40006a80: 94 12 a0 24 or %o2, 0x24, %o2 ! 4000a424 <_Thread_queue_Timeout> _Thread_Enable_dispatch(); 40006a84: 7f ff ff 42 call 4000678c <_Thread_Enable_dispatch> 40006a88: 01 00 00 00 nop 40006a8c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006a90: c2 00 62 ac ld [ %g1 + 0x2ac ], %g1 ! 4001aeac <_Thread_Executing> 40006a94: 40 00 00 41 call 40006b98 <_Semaphore_Translate_core_semaphore_return_code> 40006a98: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006a9c: b0 10 00 08 mov %o0, %i0 40006aa0: 81 c7 e0 08 ret 40006aa4: 81 e8 00 00 restore 40006adc : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 40006adc: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 40006ae0: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40006ae4: 92 10 00 18 mov %i0, %o1 40006ae8: 90 12 20 88 or %o0, 0x88, %o0 40006aec: 40 00 06 cc call 4000861c <_Objects_Get> 40006af0: 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 ) { 40006af4: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006af8: 80 a0 60 00 cmp %g1, 0 40006afc: 22 80 00 07 be,a 40006b18 40006b00: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40006b04: 80 a0 60 02 cmp %g1, 2 40006b08: 08 80 00 17 bleu 40006b64 40006b0c: 90 10 20 04 mov 4, %o0 40006b10: 10 80 00 15 b 40006b64 <== NOT EXECUTED 40006b14: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 40006b18: 80 88 60 30 btst 0x30, %g1 40006b1c: 02 80 00 0b be 40006b48 40006b20: 90 02 20 14 add %o0, 0x14, %o0 mutex_status = _CORE_mutex_Surrender( 40006b24: 92 10 00 18 mov %i0, %o1 40006b28: 40 00 03 54 call 40007878 <_CORE_mutex_Surrender> 40006b2c: 94 10 20 00 clr %o2 &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 40006b30: 7f ff ff de call 40006aa8 <_Thread_Enable_dispatch> 40006b34: a0 10 00 08 mov %o0, %l0 return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 40006b38: 40 00 00 0e call 40006b70 <_Semaphore_Translate_core_mutex_return_code> 40006b3c: 90 10 00 10 mov %l0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006b40: 81 c7 e0 08 ret 40006b44: 91 e8 00 08 restore %g0, %o0, %o0 MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 40006b48: 92 10 00 18 mov %i0, %o1 40006b4c: 40 00 03 b9 call 40007a30 <_CORE_semaphore_Surrender> 40006b50: 94 10 20 00 clr %o2 &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 40006b54: 7f ff ff d5 call 40006aa8 <_Thread_Enable_dispatch> 40006b58: a0 10 00 08 mov %o0, %l0 return 40006b5c: 40 00 00 0f call 40006b98 <_Semaphore_Translate_core_semaphore_return_code> 40006b60: 90 10 00 10 mov %l0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006b64: b0 10 00 08 mov %o0, %i0 40006b68: 81 c7 e0 08 ret 40006b6c: 81 e8 00 00 restore 40018650 : */ void rtems_shutdown_executive( uint32_t result ) { 40018650: 9d e3 bf 98 save %sp, -104, %sp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 40018654: 33 10 00 6b sethi %hi(0x4001ac00), %i1 40018658: c2 06 63 b0 ld [ %i1 + 0x3b0 ], %g1 ! 4001afb0 <_System_state_Current> 4001865c: 80 a0 60 04 cmp %g1, 4 40018660: 02 80 00 0c be 40018690 40018664: 11 10 00 66 sethi %hi(0x40019800), %o0 #if defined(__USE_INIT_FINI__) extern void _fini( void ); atexit( _fini ); 40018668: 7f ff da 4d call 4000ef9c 4001866c: 90 12 21 f4 or %o0, 0x1f4, %o0 ! 400199f4 <_fini> * routine which initialized the system. */ RTEMS_INLINE_ROUTINE void _Thread_Stop_multitasking( void ) { _Context_Switch( &_Thread_Executing->Registers, &_Thread_BSP_context ); 40018670: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40018674: f0 00 62 ac ld [ %g1 + 0x2ac ], %i0 ! 4001aeac <_Thread_Executing> 40018678: 82 10 20 04 mov 4, %g1 4001867c: b0 06 20 e0 add %i0, 0xe0, %i0 40018680: c2 26 63 b0 st %g1, [ %i1 + 0x3b0 ] 40018684: 33 10 00 6b sethi %hi(0x4001ac00), %i1 40018688: 7f ff ca 92 call 4000b0d0 <_CPU_Context_switch> 4001868c: 93 ee 61 48 restore %i1, 0x148, %o1 40018690: 81 c7 e0 08 ret <== NOT EXECUTED 40018694: 81 e8 00 00 restore <== NOT EXECUTED 400120b8 : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 400120b8: 9d e3 bf 90 save %sp, -112, %sp 400120bc: 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 ) 400120c0: 80 a6 60 00 cmp %i1, 0 400120c4: 02 80 00 47 be 400121e0 400120c8: 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 ) ) { 400120cc: 80 a2 60 00 cmp %o1, 0 400120d0: 12 80 00 0a bne 400120f8 400120d4: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400120d8: 03 10 00 d2 sethi %hi(0x40034800), %g1 400120dc: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 400348b0 <_Thread_Dispatch_disable_level> 400120e0: 84 00 a0 01 inc %g2 400120e4: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ] 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; 400120e8: 03 10 00 d2 sethi %hi(0x40034800), %g1 400120ec: f0 00 61 8c ld [ %g1 + 0x18c ], %i0 ! 4003498c <_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; 400120f0: 10 80 00 18 b 40012150 400120f4: c0 27 bf f4 clr [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 400120f8: 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 ) { 400120fc: 80 a0 a0 04 cmp %g2, 4 40012100: 18 80 00 0e bgu 40012138 40012104: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40012108: 83 32 60 1b srl %o1, 0x1b, %g1 4001210c: 80 a0 60 01 cmp %g1, 1 40012110: 12 80 00 0a bne 40012138 40012114: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40012118: 83 28 a0 02 sll %g2, 2, %g1 4001211c: 05 10 00 d2 sethi %hi(0x40034800), %g2 40012120: 84 10 a0 10 or %g2, 0x10, %g2 ! 40034810 <_Objects_Information_table> 40012124: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40012128: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 4001212c: 80 a2 20 00 cmp %o0, 0 40012130: 12 80 00 05 bne 40012144 40012134: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 40012138: b0 10 20 00 clr %i0 4001213c: 10 80 00 05 b 40012150 40012140: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40012144: 40 00 0d f0 call 40015904 <_Objects_Get> 40012148: 94 07 bf f4 add %fp, -12, %o2 4001214c: b0 10 00 08 mov %o0, %i0 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40012150: c2 07 bf f4 ld [ %fp + -12 ], %g1 40012154: 80 a0 60 00 cmp %g1, 0 40012158: 22 80 00 07 be,a 40012174 4001215c: d2 06 21 6c ld [ %i0 + 0x16c ], %o1 40012160: 80 a0 60 02 cmp %g1, 2 40012164: 08 80 00 1f bleu 400121e0 40012168: b0 10 20 04 mov 4, %i0 4001216c: 81 c7 e0 08 ret <== NOT EXECUTED 40012170: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 40012174: c2 02 60 4c ld [ %o1 + 0x4c ], %g1 40012178: 80 a0 60 00 cmp %g1, 0 4001217c: 02 80 00 1b be 400121e8 40012180: 01 00 00 00 nop if ( asr->is_enabled ) { 40012184: c2 02 60 48 ld [ %o1 + 0x48 ], %g1 40012188: 80 a0 60 00 cmp %g1, 0 4001218c: 02 80 00 11 be 400121d0 40012190: 90 10 00 19 mov %i1, %o0 _ASR_Post_signals( signal_set, &asr->signals_posted ); 40012194: 7f ff ff b3 call 40012060 <_ASR_Post_signals> 40012198: 92 02 60 54 add %o1, 0x54, %o1 the_thread->do_post_task_switch_extension = TRUE; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 4001219c: 03 10 00 d2 sethi %hi(0x40034800), %g1 400121a0: c2 00 61 74 ld [ %g1 + 0x174 ], %g1 ! 40034974 <_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; 400121a4: 84 10 20 01 mov 1, %g2 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 400121a8: 80 a0 60 00 cmp %g1, 0 400121ac: 02 80 00 0b be 400121d8 400121b0: c4 26 20 78 st %g2, [ %i0 + 0x78 ] 400121b4: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 400121b8: c2 00 61 8c ld [ %g1 + 0x18c ], %g1 ! 4003498c <_Thread_Executing> <== NOT EXECUTED 400121bc: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 400121c0: 12 80 00 06 bne 400121d8 <== NOT EXECUTED 400121c4: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 400121c8: 10 80 00 04 b 400121d8 <== NOT EXECUTED 400121cc: c4 20 62 38 st %g2, [ %g1 + 0x238 ] ! 40034a38 <_ISR_Signals_to_thread_executing> <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); 400121d0: 7f ff ff a4 call 40012060 <_ASR_Post_signals> 400121d4: 92 02 60 58 add %o1, 0x58, %o1 } _Thread_Enable_dispatch(); 400121d8: 7f ff ff ab call 40012084 <_Thread_Enable_dispatch> 400121dc: b0 10 20 00 clr %i0 400121e0: 81 c7 e0 08 ret 400121e4: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 400121e8: 7f ff ff a7 call 40012084 <_Thread_Enable_dispatch> 400121ec: b0 10 20 0b mov 0xb, %i0 return RTEMS_NOT_DEFINED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400121f0: 81 c7 e0 08 ret 400121f4: 81 e8 00 00 restore 40006d80 : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 40006d80: 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 ) ) { 40006d84: 92 96 20 00 orcc %i0, 0, %o1 40006d88: 12 80 00 0a bne 40006db0 40006d8c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006d90: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006d94: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 4001add0 <_Thread_Dispatch_disable_level> 40006d98: 84 00 a0 01 inc %g2 40006d9c: c4 20 61 d0 st %g2, [ %g1 + 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; 40006da0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006da4: f0 00 62 ac ld [ %g1 + 0x2ac ], %i0 ! 4001aeac <_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; 40006da8: 10 80 00 18 b 40006e08 40006dac: c0 27 bf f4 clr [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40006db0: 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 ) { 40006db4: 80 a0 a0 04 cmp %g2, 4 40006db8: 18 80 00 0e bgu 40006df0 40006dbc: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40006dc0: 83 32 60 1b srl %o1, 0x1b, %g1 40006dc4: 80 a0 60 01 cmp %g1, 1 40006dc8: 12 80 00 0a bne 40006df0 40006dcc: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40006dd0: 83 28 a0 02 sll %g2, 2, %g1 40006dd4: 05 10 00 6b sethi %hi(0x4001ac00), %g2 40006dd8: 84 10 a1 30 or %g2, 0x130, %g2 ! 4001ad30 <_Objects_Information_table> 40006ddc: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40006de0: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 40006de4: 80 a2 20 00 cmp %o0, 0 40006de8: 12 80 00 05 bne 40006dfc 40006dec: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 40006df0: b0 10 20 00 clr %i0 40006df4: 10 80 00 05 b 40006e08 40006df8: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40006dfc: 40 00 06 08 call 4000861c <_Objects_Get> 40006e00: 94 07 bf f4 add %fp, -12, %o2 40006e04: b0 10 00 08 mov %o0, %i0 register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40006e08: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006e0c: 80 a0 60 00 cmp %g1, 0 40006e10: 02 80 00 06 be 40006e28 40006e14: 80 a0 60 02 cmp %g1, 2 40006e18: 08 80 00 0b bleu 40006e44 40006e1c: b0 10 20 04 mov 4, %i0 40006e20: 81 c7 e0 08 ret <== NOT EXECUTED 40006e24: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_information = _Objects_Get_information( the_thread->Object.id ); 40006e28: 7f ff ff c0 call 40006d28 <_Objects_Get_information> 40006e2c: d0 06 20 08 ld [ %i0 + 8 ], %o0 if ( !the_information ) { 40006e30: 80 a2 20 00 cmp %o0, 0 40006e34: 12 80 00 06 bne 40006e4c 40006e38: 01 00 00 00 nop _Thread_Enable_dispatch(); 40006e3c: 7f ff ff c4 call 40006d4c <_Thread_Enable_dispatch> <== NOT EXECUTED 40006e40: b0 10 20 04 mov 4, %i0 ! 4 <== NOT EXECUTED 40006e44: 81 c7 e0 08 ret 40006e48: 81 e8 00 00 restore return RTEMS_INVALID_ID; /* This should never happen if _Thread_Get() works right */ } _Thread_Close( the_information, the_thread ); 40006e4c: 40 00 0a 63 call 400097d8 <_Thread_Close> 40006e50: 92 10 00 18 mov %i0, %o1 40006e54: 7f ff ff b5 call 40006d28 <_Objects_Get_information> 40006e58: d0 06 20 08 ld [ %i0 + 8 ], %o0 40006e5c: 92 10 00 18 mov %i0, %o1 40006e60: 40 00 05 ad call 40008514 <_Objects_Free> 40006e64: b0 10 20 00 clr %i0 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 40006e68: 7f ff ff b9 call 40006d4c <_Thread_Enable_dispatch> 40006e6c: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006e70: 81 c7 e0 08 ret 40006e74: 81 e8 00 00 restore 4000868c : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 4000868c: 9d e3 bf 90 save %sp, -112, %sp 40008690: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !note ) 40008694: 80 a6 a0 00 cmp %i2, 0 40008698: 02 80 00 43 be 400087a4 4000869c: 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 ) 400086a0: 80 a6 60 0f cmp %i1, 0xf 400086a4: 18 80 00 40 bgu 400087a4 400086a8: 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 ) || 400086ac: 80 a2 60 00 cmp %o1, 0 400086b0: 02 80 00 08 be 400086d0 400086b4: 03 10 00 82 sethi %hi(0x40020800), %g1 400086b8: c2 00 60 4c ld [ %g1 + 0x4c ], %g1 ! 4002084c <_Thread_Executing> 400086bc: c2 00 60 08 ld [ %g1 + 8 ], %g1 400086c0: 80 a2 40 01 cmp %o1, %g1 400086c4: 12 80 00 0a bne 400086ec 400086c8: 83 32 60 18 srl %o1, 0x18, %g1 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 400086cc: 03 10 00 82 sethi %hi(0x40020800), %g1 <== NOT EXECUTED 400086d0: c2 00 60 4c ld [ %g1 + 0x4c ], %g1 ! 4002084c <_Thread_Executing> 400086d4: 85 2e 60 02 sll %i1, 2, %g2 400086d8: c2 00 61 6c ld [ %g1 + 0x16c ], %g1 400086dc: c2 00 40 02 ld [ %g1 + %g2 ], %g1 400086e0: c2 26 80 00 st %g1, [ %i2 ] 400086e4: 81 c7 e0 08 ret 400086e8: 91 e8 20 00 restore %g0, 0, %o0 400086ec: 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 ) { 400086f0: 80 a0 a0 04 cmp %g2, 4 400086f4: 18 80 00 06 bgu 4000870c 400086f8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 400086fc: 83 32 60 1b srl %o1, 0x1b, %g1 40008700: 80 a0 60 01 cmp %g1, 1 40008704: 02 80 00 05 be 40008718 40008708: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 4000870c: 90 10 20 00 clr %o0 40008710: 10 80 00 0e b 40008748 40008714: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40008718: 83 28 a0 02 sll %g2, 2, %g1 4000871c: 05 10 00 81 sethi %hi(0x40020400), %g2 40008720: 84 10 a2 d0 or %g2, 0x2d0, %g2 ! 400206d0 <_Objects_Information_table> 40008724: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40008728: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 4000872c: 80 a2 20 00 cmp %o0, 0 40008730: 12 80 00 04 bne 40008740 40008734: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 40008738: 10 80 00 04 b 40008748 <== NOT EXECUTED 4000873c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40008740: 40 00 07 52 call 4000a488 <_Objects_Get> 40008744: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40008748: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000874c: 80 a0 60 00 cmp %g1, 0 40008750: 22 80 00 07 be,a 4000876c 40008754: c4 02 21 6c ld [ %o0 + 0x16c ], %g2 40008758: 80 a0 60 02 cmp %g1, 2 4000875c: 08 80 00 12 bleu 400087a4 40008760: b0 10 20 04 mov 4, %i0 40008764: 81 c7 e0 08 ret <== NOT EXECUTED 40008768: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 4000876c: 83 2e 60 02 sll %i1, 2, %g1 40008770: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40008774: 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 ) 40008778: 05 10 00 81 sethi %hi(0x40020400), %g2 4000877c: c2 00 a3 70 ld [ %g2 + 0x370 ], %g1 ! 40020770 <_Thread_Dispatch_disable_level> 40008780: b0 10 20 00 clr %i0 40008784: 82 00 7f ff add %g1, -1, %g1 40008788: c2 20 a3 70 st %g1, [ %g2 + 0x370 ] 4000878c: c2 00 a3 70 ld [ %g2 + 0x370 ], %g1 40008790: 80 a0 60 00 cmp %g1, 0 40008794: 12 80 00 04 bne 400087a4 40008798: 01 00 00 00 nop _Thread_Dispatch(); 4000879c: 40 00 0b f0 call 4000b75c <_Thread_Dispatch> 400087a0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400087a4: 81 c7 e0 08 ret 400087a8: 81 e8 00 00 restore 4000750c : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 4000750c: 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 ) ) { 40007510: 92 96 20 00 orcc %i0, 0, %o1 40007514: 12 80 00 0a bne 4000753c 40007518: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000751c: 03 10 00 79 sethi %hi(0x4001e400), %g1 <== NOT EXECUTED 40007520: c4 00 61 80 ld [ %g1 + 0x180 ], %g2 ! 4001e580 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40007524: 84 00 a0 01 inc %g2 <== NOT EXECUTED 40007528: c4 20 61 80 st %g2, [ %g1 + 0x180 ] <== 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; 4000752c: 03 10 00 79 sethi %hi(0x4001e400), %g1 <== NOT EXECUTED 40007530: d0 00 62 5c ld [ %g1 + 0x25c ], %o0 ! 4001e65c <_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; 40007534: 10 80 00 19 b 40007598 <== NOT EXECUTED 40007538: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 4000753c: 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 ) { 40007540: 80 a0 a0 04 cmp %g2, 4 40007544: 18 80 00 06 bgu 4000755c 40007548: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4000754c: 83 32 60 1b srl %o1, 0x1b, %g1 40007550: 80 a0 60 01 cmp %g1, 1 40007554: 02 80 00 05 be 40007568 40007558: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 4000755c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40007560: 10 80 00 0e b 40007598 <== NOT EXECUTED 40007564: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007568: 83 28 a0 02 sll %g2, 2, %g1 4000756c: 05 10 00 79 sethi %hi(0x4001e400), %g2 40007570: 84 10 a0 e0 or %g2, 0xe0, %g2 ! 4001e4e0 <_Objects_Information_table> 40007574: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40007578: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 4000757c: 80 a2 20 00 cmp %o0, 0 40007580: 12 80 00 04 bne 40007590 40007584: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 40007588: 10 80 00 04 b 40007598 <== NOT EXECUTED 4000758c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007590: 40 00 06 58 call 40008ef0 <_Objects_Get> 40007594: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007598: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000759c: 80 a0 60 00 cmp %g1, 0 400075a0: 22 80 00 07 be,a 400075bc 400075a4: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 400075a8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 400075ac: 08 80 00 09 bleu 400075d0 <== NOT EXECUTED 400075b0: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 400075b4: 81 c7 e0 08 ret <== NOT EXECUTED 400075b8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 400075bc: 80 88 60 02 btst 2, %g1 400075c0: 12 80 00 06 bne 400075d8 400075c4: 01 00 00 00 nop _Thread_Enable_dispatch(); 400075c8: 7f ff ff c4 call 400074d8 <_Thread_Enable_dispatch> 400075cc: b0 10 20 00 clr %i0 ! 0 400075d0: 81 c7 e0 08 ret 400075d4: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 400075d8: 7f ff ff c0 call 400074d8 <_Thread_Enable_dispatch> 400075dc: b0 10 20 0f mov 0xf, %i0 return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400075e0: 81 c7 e0 08 ret 400075e4: 81 e8 00 00 restore 40007b60 : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 40007b60: 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 ) ) { 40007b64: 92 96 20 00 orcc %i0, 0, %o1 40007b68: 12 80 00 0a bne 40007b90 40007b6c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007b70: 03 10 00 7a sethi %hi(0x4001e800), %g1 40007b74: c4 00 62 90 ld [ %g1 + 0x290 ], %g2 ! 4001ea90 <_Thread_Dispatch_disable_level> 40007b78: 84 00 a0 01 inc %g2 40007b7c: c4 20 62 90 st %g2, [ %g1 + 0x290 ] 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; 40007b80: 03 10 00 7a sethi %hi(0x4001e800), %g1 40007b84: d0 00 63 6c ld [ %g1 + 0x36c ], %o0 ! 4001eb6c <_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; 40007b88: 10 80 00 19 b 40007bec 40007b8c: c0 27 bf f4 clr [ %fp + -12 ] 40007b90: 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 ) { 40007b94: 80 a0 a0 04 cmp %g2, 4 40007b98: 18 80 00 06 bgu 40007bb0 40007b9c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40007ba0: 83 32 60 1b srl %o1, 0x1b, %g1 40007ba4: 80 a0 60 01 cmp %g1, 1 40007ba8: 02 80 00 05 be 40007bbc 40007bac: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 40007bb0: 90 10 20 00 clr %o0 40007bb4: 10 80 00 0e b 40007bec 40007bb8: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007bbc: 83 28 a0 02 sll %g2, 2, %g1 40007bc0: 05 10 00 7a sethi %hi(0x4001e800), %g2 40007bc4: 84 10 a1 f0 or %g2, 0x1f0, %g2 ! 4001e9f0 <_Objects_Information_table> 40007bc8: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40007bcc: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 40007bd0: 80 a2 20 00 cmp %o0, 0 40007bd4: 12 80 00 04 bne 40007be4 40007bd8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 40007bdc: 10 80 00 04 b 40007bec <== NOT EXECUTED 40007be0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007be4: 40 00 06 1f call 40009460 <_Objects_Get> 40007be8: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007bec: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007bf0: 80 a0 60 00 cmp %g1, 0 40007bf4: 22 80 00 07 be,a 40007c10 40007bf8: 94 10 00 19 mov %i1, %o2 40007bfc: 80 a0 60 02 cmp %g1, 2 40007c00: 08 80 00 0b bleu 40007c2c 40007c04: b0 10 20 04 mov 4, %i0 40007c08: 81 c7 e0 08 ret <== NOT EXECUTED 40007c0c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 40007c10: 40 00 0d 95 call 4000b264 <_Thread_Restart> 40007c14: 92 10 20 00 clr %o1 40007c18: 80 a2 20 00 cmp %o0, 0 40007c1c: 02 80 00 06 be 40007c34 40007c20: 01 00 00 00 nop _Thread_Enable_dispatch(); 40007c24: 7f ff ff c2 call 40007b2c <_Thread_Enable_dispatch> 40007c28: b0 10 20 00 clr %i0 ! 0 40007c2c: 81 c7 e0 08 ret 40007c30: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 40007c34: 7f ff ff be call 40007b2c <_Thread_Enable_dispatch> 40007c38: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007c3c: 81 c7 e0 08 ret 40007c40: 81 e8 00 00 restore 4000852c : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 4000852c: 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 ) ) { 40008530: 92 96 20 00 orcc %i0, 0, %o1 40008534: 12 80 00 0a bne 4000855c 40008538: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000853c: 03 10 00 9e sethi %hi(0x40027800), %g1 40008540: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 400279f0 <_Thread_Dispatch_disable_level> 40008544: 84 00 a0 01 inc %g2 40008548: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 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; 4000854c: 03 10 00 9e sethi %hi(0x40027800), %g1 40008550: d0 00 62 cc ld [ %g1 + 0x2cc ], %o0 ! 40027acc <_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; 40008554: 10 80 00 19 b 400085b8 40008558: c0 27 bf f4 clr [ %fp + -12 ] 4000855c: 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 ) { 40008560: 80 a0 a0 04 cmp %g2, 4 40008564: 18 80 00 06 bgu 4000857c 40008568: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4000856c: 83 32 60 1b srl %o1, 0x1b, %g1 40008570: 80 a0 60 01 cmp %g1, 1 40008574: 02 80 00 05 be 40008588 40008578: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 4000857c: 90 10 20 00 clr %o0 40008580: 10 80 00 0e b 400085b8 40008584: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40008588: 83 28 a0 02 sll %g2, 2, %g1 4000858c: 05 10 00 9e sethi %hi(0x40027800), %g2 40008590: 84 10 a1 50 or %g2, 0x150, %g2 ! 40027950 <_Objects_Information_table> 40008594: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40008598: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 4000859c: 80 a2 20 00 cmp %o0, 0 400085a0: 12 80 00 04 bne 400085b0 400085a4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 400085a8: 10 80 00 04 b 400085b8 <== NOT EXECUTED 400085ac: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 400085b0: 40 00 06 f9 call 4000a194 <_Objects_Get> 400085b4: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 400085b8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400085bc: 80 a0 60 00 cmp %g1, 0 400085c0: 22 80 00 07 be,a 400085dc 400085c4: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 400085c8: 80 a0 60 02 cmp %g1, 2 400085cc: 08 80 00 0b bleu 400085f8 400085d0: b0 10 20 04 mov 4, %i0 400085d4: 81 c7 e0 08 ret <== NOT EXECUTED 400085d8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 400085dc: 80 88 60 02 btst 2, %g1 400085e0: 02 80 00 08 be 40008600 400085e4: 92 10 20 01 mov 1, %o1 _Thread_Resume( the_thread, TRUE ); 400085e8: 40 00 0e 82 call 4000bff0 <_Thread_Resume> 400085ec: b0 10 20 00 clr %i0 _Thread_Enable_dispatch(); 400085f0: 7f ff ff c2 call 400084f8 <_Thread_Enable_dispatch> 400085f4: 01 00 00 00 nop 400085f8: 81 c7 e0 08 ret 400085fc: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 40008600: 7f ff ff be call 400084f8 <_Thread_Enable_dispatch> 40008604: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008608: 81 c7 e0 08 ret 4000860c: 81 e8 00 00 restore 40008978 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 40008978: 9d e3 bf 90 save %sp, -112, %sp 4000897c: 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 ) 40008980: 80 a6 60 0f cmp %i1, 0xf 40008984: 18 80 00 3e bgu 40008a7c 40008988: 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 ) || 4000898c: 80 a2 60 00 cmp %o1, 0 40008990: 02 80 00 08 be 400089b0 40008994: 03 10 00 82 sethi %hi(0x40020800), %g1 40008998: c2 00 60 4c ld [ %g1 + 0x4c ], %g1 ! 4002084c <_Thread_Executing> 4000899c: c2 00 60 08 ld [ %g1 + 8 ], %g1 400089a0: 80 a2 40 01 cmp %o1, %g1 400089a4: 12 80 00 09 bne 400089c8 400089a8: 83 32 60 18 srl %o1, 0x18, %g1 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 400089ac: 03 10 00 82 sethi %hi(0x40020800), %g1 <== NOT EXECUTED 400089b0: c2 00 60 4c ld [ %g1 + 0x4c ], %g1 ! 4002084c <_Thread_Executing> <== NOT EXECUTED 400089b4: 85 2e 60 02 sll %i1, 2, %g2 <== NOT EXECUTED 400089b8: c2 00 61 6c ld [ %g1 + 0x16c ], %g1 <== NOT EXECUTED 400089bc: f4 20 40 02 st %i2, [ %g1 + %g2 ] <== NOT EXECUTED 400089c0: 81 c7 e0 08 ret <== NOT EXECUTED 400089c4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 400089c8: 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 ) { 400089cc: 80 a0 a0 04 cmp %g2, 4 400089d0: 18 80 00 06 bgu 400089e8 400089d4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 400089d8: 83 32 60 1b srl %o1, 0x1b, %g1 400089dc: 80 a0 60 01 cmp %g1, 1 400089e0: 02 80 00 05 be 400089f4 400089e4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 400089e8: 90 10 20 00 clr %o0 400089ec: 10 80 00 0e b 40008a24 400089f0: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400089f4: 83 28 a0 02 sll %g2, 2, %g1 400089f8: 05 10 00 81 sethi %hi(0x40020400), %g2 400089fc: 84 10 a2 d0 or %g2, 0x2d0, %g2 ! 400206d0 <_Objects_Information_table> 40008a00: c2 00 80 01 ld [ %g2 + %g1 ], %g1 40008a04: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 40008a08: 80 a2 20 00 cmp %o0, 0 40008a0c: 12 80 00 04 bne 40008a1c 40008a10: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 40008a14: 10 80 00 04 b 40008a24 <== NOT EXECUTED 40008a18: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40008a1c: 40 00 06 9b call 4000a488 <_Objects_Get> 40008a20: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40008a24: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008a28: 80 a0 60 00 cmp %g1, 0 40008a2c: 22 80 00 07 be,a 40008a48 40008a30: c4 02 21 6c ld [ %o0 + 0x16c ], %g2 40008a34: 80 a0 60 02 cmp %g1, 2 40008a38: 08 80 00 11 bleu 40008a7c 40008a3c: b0 10 20 04 mov 4, %i0 40008a40: 81 c7 e0 08 ret <== NOT EXECUTED 40008a44: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 40008a48: 83 2e 60 02 sll %i1, 2, %g1 40008a4c: 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 ) 40008a50: 05 10 00 81 sethi %hi(0x40020400), %g2 40008a54: c2 00 a3 70 ld [ %g2 + 0x370 ], %g1 ! 40020770 <_Thread_Dispatch_disable_level> 40008a58: b0 10 20 00 clr %i0 40008a5c: 82 00 7f ff add %g1, -1, %g1 40008a60: c2 20 a3 70 st %g1, [ %g2 + 0x370 ] 40008a64: c2 00 a3 70 ld [ %g2 + 0x370 ], %g1 40008a68: 80 a0 60 00 cmp %g1, 0 40008a6c: 12 80 00 04 bne 40008a7c 40008a70: 01 00 00 00 nop _Thread_Dispatch(); 40008a74: 40 00 0b 3a call 4000b75c <_Thread_Dispatch> 40008a78: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008a7c: 81 c7 e0 08 ret 40008a80: 81 e8 00 00 restore 4000b4d8 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 4000b4d8: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 4000b4dc: 80 a6 60 00 cmp %i1, 0 4000b4e0: 02 80 00 06 be 4000b4f8 4000b4e4: 92 10 00 18 mov %i0, %o1 4000b4e8: 82 06 7f ff add %i1, -1, %g1 4000b4ec: 80 a0 60 fe cmp %g1, 0xfe 4000b4f0: 18 80 00 49 bgu 4000b614 4000b4f4: b0 10 20 13 mov 0x13, %i0 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 4000b4f8: 80 a6 a0 00 cmp %i2, 0 4000b4fc: 02 80 00 46 be 4000b614 4000b500: 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 ) ) { 4000b504: 80 a2 60 00 cmp %o1, 0 4000b508: 12 80 00 0a bne 4000b530 4000b50c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000b510: 03 10 00 a7 sethi %hi(0x40029c00), %g1 4000b514: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 ! 40029c60 <_Thread_Dispatch_disable_level> 4000b518: 84 00 a0 01 inc %g2 4000b51c: c4 20 60 60 st %g2, [ %g1 + 0x60 ] 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; 4000b520: 03 10 00 a7 sethi %hi(0x40029c00), %g1 4000b524: d0 00 61 3c ld [ %g1 + 0x13c ], %o0 ! 40029d3c <_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; 4000b528: 10 80 00 19 b 4000b58c 4000b52c: c0 27 bf f4 clr [ %fp + -12 ] 4000b530: 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 ) { 4000b534: 80 a0 a0 04 cmp %g2, 4 4000b538: 18 80 00 06 bgu 4000b550 4000b53c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4000b540: 83 32 60 1b srl %o1, 0x1b, %g1 4000b544: 80 a0 60 01 cmp %g1, 1 4000b548: 02 80 00 05 be 4000b55c 4000b54c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 4000b550: 90 10 20 00 clr %o0 4000b554: 10 80 00 0e b 4000b58c 4000b558: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4000b55c: 83 28 a0 02 sll %g2, 2, %g1 4000b560: 05 10 00 a6 sethi %hi(0x40029800), %g2 4000b564: 84 10 a3 c0 or %g2, 0x3c0, %g2 ! 40029bc0 <_Objects_Information_table> 4000b568: c2 00 80 01 ld [ %g2 + %g1 ], %g1 4000b56c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 4000b570: 80 a2 20 00 cmp %o0, 0 4000b574: 12 80 00 04 bne 4000b584 4000b578: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 4000b57c: 10 80 00 04 b 4000b58c <== NOT EXECUTED 4000b580: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4000b584: 40 00 06 3d call 4000ce78 <_Objects_Get> 4000b588: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000b58c: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000b590: 80 a0 60 00 cmp %g1, 0 4000b594: 22 80 00 07 be,a 4000b5b0 4000b598: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 4000b59c: 80 a0 60 02 cmp %g1, 2 4000b5a0: 08 80 00 1d bleu 4000b614 4000b5a4: b0 10 20 04 mov 4, %i0 4000b5a8: 81 c7 e0 08 ret <== NOT EXECUTED 4000b5ac: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED return RTEMS_INVALID_ID; case OBJECTS_LOCAL: /* XXX convert from core priority */ *old_priority = the_thread->current_priority; if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 4000b5b0: 80 a6 60 00 cmp %i1, 0 4000b5b4: 02 80 00 0d be 4000b5e8 4000b5b8: c2 26 80 00 st %g1, [ %i2 ] the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 4000b5bc: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 4000b5c0: 80 a0 60 00 cmp %g1, 0 4000b5c4: 02 80 00 06 be 4000b5dc 4000b5c8: f2 22 20 18 st %i1, [ %o0 + 0x18 ] 4000b5cc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 4000b5d0: 80 a0 40 19 cmp %g1, %i1 4000b5d4: 08 80 00 05 bleu 4000b5e8 4000b5d8: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 4000b5dc: 92 10 00 19 mov %i1, %o1 4000b5e0: 40 00 09 ee call 4000dd98 <_Thread_Change_priority> 4000b5e4: 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 ) 4000b5e8: 03 10 00 a7 sethi %hi(0x40029c00), %g1 4000b5ec: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 ! 40029c60 <_Thread_Dispatch_disable_level> 4000b5f0: b0 10 20 00 clr %i0 4000b5f4: 84 00 bf ff add %g2, -1, %g2 4000b5f8: c4 20 60 60 st %g2, [ %g1 + 0x60 ] 4000b5fc: c2 00 60 60 ld [ %g1 + 0x60 ], %g1 4000b600: 80 a0 60 00 cmp %g1, 0 4000b604: 12 80 00 04 bne 4000b614 4000b608: 01 00 00 00 nop _Thread_Dispatch(); 4000b60c: 40 00 0b 0f call 4000e248 <_Thread_Dispatch> 4000b610: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000b614: 81 c7 e0 08 ret 4000b618: 81 e8 00 00 restore 40006fc0 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 40006fc0: 9d e3 bf 90 save %sp, -112, %sp 40006fc4: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 40006fc8: 80 a6 60 00 cmp %i1, 0 40006fcc: 02 80 00 36 be 400070a4 40006fd0: 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 ) ) { 40006fd4: 80 a2 60 00 cmp %o1, 0 40006fd8: 12 80 00 0a bne 40007000 40006fdc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006fe0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006fe4: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 4001add0 <_Thread_Dispatch_disable_level> 40006fe8: 84 00 a0 01 inc %g2 40006fec: c4 20 61 d0 st %g2, [ %g1 + 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; 40006ff0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006ff4: d0 00 62 ac ld [ %g1 + 0x2ac ], %o0 ! 4001aeac <_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; 40006ff8: 10 80 00 19 b 4000705c 40006ffc: c0 27 bf f4 clr [ %fp + -12 ] 40007000: 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 ) { 40007004: 80 a0 a0 04 cmp %g2, 4 40007008: 18 80 00 06 bgu 40007020 4000700c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40007010: 83 32 60 1b srl %o1, 0x1b, %g1 40007014: 80 a0 60 01 cmp %g1, 1 40007018: 02 80 00 05 be 4000702c 4000701c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 40007020: 90 10 20 00 clr %o0 40007024: 10 80 00 0e b 4000705c 40007028: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4000702c: 83 28 a0 02 sll %g2, 2, %g1 40007030: 05 10 00 6b sethi %hi(0x4001ac00), %g2 40007034: 84 10 a1 30 or %g2, 0x130, %g2 ! 4001ad30 <_Objects_Information_table> 40007038: c2 00 80 01 ld [ %g2 + %g1 ], %g1 4000703c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 40007040: 80 a2 20 00 cmp %o0, 0 40007044: 12 80 00 04 bne 40007054 40007048: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 4000704c: 10 80 00 04 b 4000705c <== NOT EXECUTED 40007050: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007054: 40 00 05 72 call 4000861c <_Objects_Get> 40007058: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000705c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007060: 80 a0 60 00 cmp %g1, 0 40007064: 22 80 00 07 be,a 40007080 40007068: 94 10 00 19 mov %i1, %o2 4000706c: 80 a0 60 02 cmp %g1, 2 40007070: 08 80 00 0d bleu 400070a4 40007074: b0 10 20 04 mov 4, %i0 40007078: 81 c7 e0 08 ret <== NOT EXECUTED 4000707c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Start( 40007080: 98 10 00 1a mov %i2, %o4 40007084: 92 10 20 00 clr %o1 40007088: 40 00 0d ff call 4000a884 <_Thread_Start> 4000708c: 96 10 20 00 clr %o3 40007090: 80 a2 20 00 cmp %o0, 0 40007094: 02 80 00 06 be 400070ac 40007098: 01 00 00 00 nop the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 4000709c: 7f ff ff bc call 40006f8c <_Thread_Enable_dispatch> 400070a0: b0 10 20 00 clr %i0 ! 0 400070a4: 81 c7 e0 08 ret 400070a8: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 400070ac: 7f ff ff b8 call 40006f8c <_Thread_Enable_dispatch> 400070b0: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400070b4: 81 c7 e0 08 ret 400070b8: 81 e8 00 00 restore 40008774 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 40008774: 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 ) ) { 40008778: 92 96 20 00 orcc %i0, 0, %o1 4000877c: 12 80 00 0a bne 400087a4 40008780: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008784: 03 10 00 9e sethi %hi(0x40027800), %g1 40008788: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 400279f0 <_Thread_Dispatch_disable_level> 4000878c: 84 00 a0 01 inc %g2 40008790: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 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; 40008794: 03 10 00 9e sethi %hi(0x40027800), %g1 40008798: d0 00 62 cc ld [ %g1 + 0x2cc ], %o0 ! 40027acc <_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; 4000879c: 10 80 00 19 b 40008800 400087a0: c0 27 bf f4 clr [ %fp + -12 ] 400087a4: 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 ) { 400087a8: 80 a0 a0 04 cmp %g2, 4 400087ac: 18 80 00 06 bgu 400087c4 400087b0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 400087b4: 83 32 60 1b srl %o1, 0x1b, %g1 400087b8: 80 a0 60 01 cmp %g1, 1 400087bc: 02 80 00 05 be 400087d0 400087c0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 400087c4: 90 10 20 00 clr %o0 400087c8: 10 80 00 0e b 40008800 400087cc: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400087d0: 83 28 a0 02 sll %g2, 2, %g1 400087d4: 05 10 00 9e sethi %hi(0x40027800), %g2 400087d8: 84 10 a1 50 or %g2, 0x150, %g2 ! 40027950 <_Objects_Information_table> 400087dc: c2 00 80 01 ld [ %g2 + %g1 ], %g1 400087e0: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 400087e4: 80 a2 20 00 cmp %o0, 0 400087e8: 12 80 00 04 bne 400087f8 400087ec: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 400087f0: 10 80 00 04 b 40008800 <== NOT EXECUTED 400087f4: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 400087f8: 40 00 06 67 call 4000a194 <_Objects_Get> 400087fc: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40008800: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008804: 80 a0 60 00 cmp %g1, 0 40008808: 22 80 00 07 be,a 40008824 4000880c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40008810: 80 a0 60 02 cmp %g1, 2 40008814: 08 80 00 0b bleu 40008840 40008818: b0 10 20 04 mov 4, %i0 4000881c: 81 c7 e0 08 ret <== NOT EXECUTED 40008820: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 40008824: 80 88 60 02 btst 2, %g1 40008828: 12 80 00 08 bne 40008848 4000882c: 01 00 00 00 nop _Thread_Suspend( the_thread ); 40008830: 40 00 0f 1c call 4000c4a0 <_Thread_Suspend> 40008834: b0 10 20 00 clr %i0 ! 0 _Thread_Enable_dispatch(); 40008838: 7f ff ff c2 call 40008740 <_Thread_Enable_dispatch> 4000883c: 01 00 00 00 nop 40008840: 81 c7 e0 08 ret 40008844: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 40008848: 7f ff ff be call 40008740 <_Thread_Enable_dispatch> 4000884c: b0 10 20 0f mov 0xf, %i0 return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008850: 81 c7 e0 08 ret 40008854: 81 e8 00 00 restore 40019704 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 40019704: 9d e3 bf 90 save %sp, -112, %sp 40019708: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 4001970c: 80 a6 60 00 cmp %i1, 0 40019710: 02 80 00 32 be 400197d8 40019714: 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 ) ) { 40019718: 80 a2 60 00 cmp %o1, 0 4001971c: 12 80 00 0a bne 40019744 40019720: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40019724: 03 10 00 ef sethi %hi(0x4003bc00), %g1 40019728: c4 00 63 20 ld [ %g1 + 0x320 ], %g2 ! 4003bf20 <_Thread_Dispatch_disable_level> 4001972c: 84 00 a0 01 inc %g2 40019730: c4 20 63 20 st %g2, [ %g1 + 0x320 ] 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; 40019734: 03 10 00 ef sethi %hi(0x4003bc00), %g1 40019738: f0 00 63 fc ld [ %g1 + 0x3fc ], %i0 ! 4003bffc <_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; 4001973c: 10 80 00 18 b 4001979c 40019740: c0 27 bf f4 clr [ %fp + -12 ] 40019744: 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 ) { 40019748: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 4001974c: 18 80 00 0e bgu 40019784 <== NOT EXECUTED 40019750: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40019754: 83 32 60 1b srl %o1, 0x1b, %g1 <== NOT EXECUTED 40019758: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001975c: 12 80 00 0a bne 40019784 <== NOT EXECUTED 40019760: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40019764: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 40019768: 05 10 00 ef sethi %hi(0x4003bc00), %g2 <== NOT EXECUTED 4001976c: 84 10 a2 80 or %g2, 0x280, %g2 ! 4003be80 <_Objects_Information_table> <== NOT EXECUTED 40019770: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 40019774: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 40019778: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001977c: 12 80 00 05 bne 40019790 <== NOT EXECUTED 40019780: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 40019784: b0 10 20 00 clr %i0 <== NOT EXECUTED 40019788: 10 80 00 05 b 4001979c <== NOT EXECUTED 4001978c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40019790: 7f ff c9 42 call 4000bc98 <_Objects_Get> <== NOT EXECUTED 40019794: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 40019798: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 4001979c: c2 07 bf f4 ld [ %fp + -12 ], %g1 400197a0: 80 a0 60 00 cmp %g1, 0 400197a4: 22 80 00 0f be,a 400197e0 400197a8: c4 06 21 7c ld [ %i0 + 0x17c ], %g2 400197ac: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 400197b0: 08 80 00 0a bleu 400197d8 <== NOT EXECUTED 400197b4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 400197b8: 81 c7 e0 08 ret <== NOT EXECUTED 400197bc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 400197c0: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 400197c4: 32 80 00 07 bne,a 400197e0 <== NOT EXECUTED 400197c8: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED tvp->dtor = dtor; 400197cc: f4 20 a0 10 st %i2, [ %g2 + 0x10 ] <== NOT EXECUTED _Thread_Enable_dispatch(); 400197d0: 7f ff ff c0 call 400196d0 <_Thread_Enable_dispatch> <== NOT EXECUTED 400197d4: b0 10 20 00 clr %i0 <== NOT EXECUTED 400197d8: 81 c7 e0 08 ret <== NOT EXECUTED 400197dc: 81 e8 00 00 restore <== NOT EXECUTED /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 400197e0: 80 a0 a0 00 cmp %g2, 0 400197e4: 32 bf ff f7 bne,a 400197c0 400197e8: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 400197ec: 11 10 00 ef sethi %hi(0x4003bc00), %o0 400197f0: 92 10 20 14 mov 0x14, %o1 400197f4: 7f ff c6 8d call 4000b228 <_Heap_Allocate> 400197f8: 90 12 23 6c or %o0, 0x36c, %o0 * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 400197fc: 80 a2 20 00 cmp %o0, 0 40019800: 32 80 00 06 bne,a 40019818 40019804: c4 06 21 7c ld [ %i0 + 0x17c ], %g2 _Thread_Enable_dispatch(); 40019808: 7f ff ff b2 call 400196d0 <_Thread_Enable_dispatch> <== NOT EXECUTED 4001980c: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED 40019810: 81 c7 e0 08 ret <== NOT EXECUTED 40019814: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_NO_MEMORY; } new->gval = *ptr; 40019818: 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; 4001981c: 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; 40019820: c2 22 20 08 st %g1, [ %o0 + 8 ] new->ptr = ptr; 40019824: f2 22 20 04 st %i1, [ %o0 + 4 ] new->dtor = dtor; 40019828: f4 22 20 10 st %i2, [ %o0 + 0x10 ] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 4001982c: c4 22 00 00 st %g2, [ %o0 ] the_thread->task_variables = new; _Thread_Enable_dispatch(); 40019830: 7f ff ff a8 call 400196d0 <_Thread_Enable_dispatch> 40019834: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40019838: 81 c7 e0 08 ret 4001983c: 81 e8 00 00 restore 40019874 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 40019874: 9d e3 bf 90 save %sp, -112, %sp 40019878: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 4001987c: 80 a6 60 00 cmp %i1, 0 40019880: 02 80 00 52 be 400199c8 40019884: 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 ) ) { 40019888: 80 a2 60 00 cmp %o1, 0 4001988c: 12 80 00 0a bne 400198b4 40019890: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40019894: 03 10 00 ef sethi %hi(0x4003bc00), %g1 40019898: c4 00 63 20 ld [ %g1 + 0x320 ], %g2 ! 4003bf20 <_Thread_Dispatch_disable_level> 4001989c: 84 00 a0 01 inc %g2 400198a0: c4 20 63 20 st %g2, [ %g1 + 0x320 ] 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; 400198a4: 03 10 00 ef sethi %hi(0x4003bc00), %g1 400198a8: d0 00 63 fc ld [ %g1 + 0x3fc ], %o0 ! 4003bffc <_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; 400198ac: 10 80 00 19 b 40019910 400198b0: c0 27 bf f4 clr [ %fp + -12 ] 400198b4: 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 ) { 400198b8: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 400198bc: 18 80 00 06 bgu 400198d4 <== NOT EXECUTED 400198c0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 400198c4: 83 32 60 1b srl %o1, 0x1b, %g1 <== NOT EXECUTED 400198c8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400198cc: 02 80 00 05 be 400198e0 <== NOT EXECUTED 400198d0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 400198d4: 90 10 20 00 clr %o0 <== NOT EXECUTED 400198d8: 10 80 00 0e b 40019910 <== NOT EXECUTED 400198dc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400198e0: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 400198e4: 05 10 00 ef sethi %hi(0x4003bc00), %g2 <== NOT EXECUTED 400198e8: 84 10 a2 80 or %g2, 0x280, %g2 ! 4003be80 <_Objects_Information_table> <== NOT EXECUTED 400198ec: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 400198f0: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 400198f4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400198f8: 12 80 00 04 bne 40019908 <== NOT EXECUTED 400198fc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 40019900: 10 80 00 04 b 40019910 <== NOT EXECUTED 40019904: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40019908: 7f ff c8 e4 call 4000bc98 <_Objects_Get> <== NOT EXECUTED 4001990c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 40019910: c2 07 bf f4 ld [ %fp + -12 ], %g1 40019914: 80 a0 60 00 cmp %g1, 0 40019918: 22 80 00 07 be,a 40019934 4001991c: f0 02 21 7c ld [ %o0 + 0x17c ], %i0 40019920: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40019924: 08 80 00 29 bleu 400199c8 <== NOT EXECUTED 40019928: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 4001992c: 81 c7 e0 08 ret <== NOT EXECUTED 40019930: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; 40019934: 10 80 00 28 b 400199d4 40019938: 84 10 20 00 clr %g2 while (tvp) { if (tvp->ptr == ptr) { 4001993c: 80 a0 40 19 cmp %g1, %i1 40019940: 32 80 00 24 bne,a 400199d0 40019944: 84 10 00 18 mov %i0, %g2 <== NOT EXECUTED if (prev) 40019948: 80 a0 a0 00 cmp %g2, 0 4001994c: 02 80 00 04 be 4001995c 40019950: c2 06 00 00 ld [ %i0 ], %g1 prev->next = tvp->next; 40019954: 10 80 00 03 b 40019960 <== NOT EXECUTED 40019958: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 4001995c: c2 22 21 7c st %g1, [ %o0 + 0x17c ] if (_Thread_Is_executing(the_thread)) { 40019960: 03 10 00 ef sethi %hi(0x4003bc00), %g1 40019964: c2 00 63 fc ld [ %g1 + 0x3fc ], %g1 ! 4003bffc <_Thread_Executing> 40019968: 80 a2 00 01 cmp %o0, %g1 4001996c: 12 80 00 0c bne 4001999c 40019970: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 if (tvp->dtor) 40019974: 80 a0 a0 00 cmp %g2, 0 40019978: 22 80 00 06 be,a 40019990 4001997c: c4 06 20 04 ld [ %i0 + 4 ], %g2 (*tvp->dtor)(*tvp->ptr); 40019980: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 40019984: 9f c0 80 00 call %g2 <== NOT EXECUTED 40019988: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 4001998c: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED 40019990: c2 06 20 08 ld [ %i0 + 8 ], %g1 40019994: 10 80 00 07 b 400199b0 40019998: c2 20 80 00 st %g1, [ %g2 ] } else { if (tvp->dtor) 4001999c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400199a0: 02 80 00 05 be 400199b4 <== NOT EXECUTED 400199a4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 400199a8: 9f c0 80 00 call %g2 <== NOT EXECUTED 400199ac: d0 06 20 0c ld [ %i0 + 0xc ], %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 400199b0: 92 10 00 18 mov %i0, %o1 400199b4: 11 10 00 ef sethi %hi(0x4003bc00), %o0 400199b8: 7f ff c6 43 call 4000b2c4 <_Heap_Free> 400199bc: 90 12 23 6c or %o0, 0x36c, %o0 ! 4003bf6c <_Workspace_Area> } _Workspace_Free(tvp); _Thread_Enable_dispatch(); 400199c0: 7f ff ff a0 call 40019840 <_Thread_Enable_dispatch> 400199c4: b0 10 20 00 clr %i0 400199c8: 81 c7 e0 08 ret 400199cc: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 400199d0: f0 06 00 00 ld [ %i0 ], %i0 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 400199d4: 80 a6 20 00 cmp %i0, 0 400199d8: 32 bf ff d9 bne,a 4001993c 400199dc: c2 06 20 04 ld [ %i0 + 4 ], %g1 return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 400199e0: 7f ff ff 98 call 40019840 <_Thread_Enable_dispatch> <== NOT EXECUTED 400199e4: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400199e8: 81 c7 e0 08 ret <== NOT EXECUTED 400199ec: 81 e8 00 00 restore <== NOT EXECUTED 40019a24 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 40019a24: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 40019a28: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40019a2c: 02 80 00 3f be 40019b28 <== NOT EXECUTED 40019a30: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 40019a34: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 40019a38: 02 80 00 3c be 40019b28 <== NOT EXECUTED 40019a3c: 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 ) ) { 40019a40: 12 80 00 0a bne 40019a68 <== NOT EXECUTED 40019a44: 83 36 20 18 srl %i0, 0x18, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40019a48: 03 10 00 ef sethi %hi(0x4003bc00), %g1 <== NOT EXECUTED 40019a4c: c4 00 63 20 ld [ %g1 + 0x320 ], %g2 ! 4003bf20 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40019a50: 84 00 a0 01 inc %g2 <== NOT EXECUTED 40019a54: c4 20 63 20 st %g2, [ %g1 + 0x320 ] <== 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; 40019a58: 03 10 00 ef sethi %hi(0x4003bc00), %g1 <== NOT EXECUTED 40019a5c: d0 00 63 fc ld [ %g1 + 0x3fc ], %o0 ! 4003bffc <_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; 40019a60: 10 80 00 19 b 40019ac4 <== NOT EXECUTED 40019a64: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 40019a68: 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 ) { 40019a6c: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 40019a70: 18 80 00 06 bgu 40019a88 <== NOT EXECUTED 40019a74: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40019a78: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED 40019a7c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40019a80: 02 80 00 05 be 40019a94 <== NOT EXECUTED 40019a84: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 40019a88: 90 10 20 00 clr %o0 <== NOT EXECUTED 40019a8c: 10 80 00 0e b 40019ac4 <== NOT EXECUTED 40019a90: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40019a94: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 40019a98: 05 10 00 ef sethi %hi(0x4003bc00), %g2 <== NOT EXECUTED 40019a9c: 84 10 a2 80 or %g2, 0x280, %g2 ! 4003be80 <_Objects_Information_table> <== NOT EXECUTED 40019aa0: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 40019aa4: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 40019aa8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40019aac: 12 80 00 04 bne 40019abc <== NOT EXECUTED 40019ab0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 40019ab4: 10 80 00 04 b 40019ac4 <== NOT EXECUTED 40019ab8: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40019abc: 7f ff c8 77 call 4000bc98 <_Objects_Get> <== NOT EXECUTED 40019ac0: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 40019ac4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 40019ac8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40019acc: 22 80 00 10 be,a 40019b0c <== NOT EXECUTED 40019ad0: d0 02 21 7c ld [ %o0 + 0x17c ], %o0 <== NOT EXECUTED 40019ad4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40019ad8: 08 80 00 0b bleu 40019b04 <== NOT EXECUTED 40019adc: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 40019ae0: 81 c7 e0 08 ret <== NOT EXECUTED 40019ae4: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 40019ae8: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 40019aec: 32 80 00 08 bne,a 40019b0c <== NOT EXECUTED 40019af0: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 40019af4: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); 40019af8: b0 10 20 00 clr %i0 <== NOT EXECUTED 40019afc: 7f ff ff bd call 400199f0 <_Thread_Enable_dispatch> <== NOT EXECUTED 40019b00: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 40019b04: 81 c7 e0 08 ret <== NOT EXECUTED 40019b08: 81 e8 00 00 restore <== NOT EXECUTED /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 40019b0c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40019b10: 32 bf ff f6 bne,a 40019ae8 <== NOT EXECUTED 40019b14: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 40019b18: 7f ff ff b6 call 400199f0 <_Thread_Enable_dispatch> <== NOT EXECUTED 40019b1c: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED 40019b20: 81 c7 e0 08 ret <== NOT EXECUTED 40019b24: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 40019b28: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40019b2c: 81 c7 e0 08 ret <== NOT EXECUTED 40019b30: 81 e8 00 00 restore <== NOT EXECUTED 400130a8 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 400130a8: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 400130ac: 21 10 00 d4 sethi %hi(0x40035000), %l0 400130b0: 92 10 00 18 mov %i0, %o1 400130b4: 94 07 bf f4 add %fp, -12, %o2 400130b8: 40 00 0a 13 call 40015904 <_Objects_Get> 400130bc: 90 14 22 ec or %l0, 0x2ec, %o0 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 400130c0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400130c4: 80 a0 60 00 cmp %g1, 0 400130c8: 02 80 00 08 be 400130e8 400130cc: b0 10 00 08 mov %o0, %i0 400130d0: 82 18 60 02 xor %g1, 2, %g1 400130d4: 80 a0 00 01 cmp %g0, %g1 400130d8: 82 60 20 00 subx %g0, 0, %g1 400130dc: b0 08 60 15 and %g1, 0x15, %i0 400130e0: 81 c7 e0 08 ret 400130e4: 91 ee 20 04 restore %i0, 4, %o0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400130e8: a0 14 22 ec or %l0, 0x2ec, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 400130ec: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400130f0: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 400130f4: 05 00 00 3f sethi %hi(0xfc00), %g2 400130f8: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 400130fc: 82 08 40 02 and %g1, %g2, %g1 40013100: 80 a0 40 03 cmp %g1, %g3 40013104: 38 80 00 06 bgu,a 4001311c 40013108: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4001310c: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 40013110: 83 28 60 02 sll %g1, 2, %g1 40013114: 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; 40013118: 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 ); 4001311c: 40 00 15 40 call 4001861c <_Watchdog_Remove> 40013120: 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 ); 40013124: 90 10 00 10 mov %l0, %o0 40013128: 40 00 09 a1 call 400157ac <_Objects_Free> 4001312c: 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 ) 40013130: 03 10 00 d2 sethi %hi(0x40034800), %g1 40013134: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 400348b0 <_Thread_Dispatch_disable_level> 40013138: b0 10 20 00 clr %i0 4001313c: 84 00 bf ff add %g2, -1, %g2 40013140: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ] 40013144: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 40013148: 80 a0 60 00 cmp %g1, 0 4001314c: 12 80 00 04 bne 4001315c 40013150: 01 00 00 00 nop _Thread_Dispatch(); 40013154: 40 00 0e e0 call 40016cd4 <_Thread_Dispatch> 40013158: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001315c: 81 c7 e0 08 ret 40013160: 81 e8 00 00 restore 40013198 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 40013198: 9d e3 bf 90 save %sp, -112, %sp 4001319c: a4 10 00 18 mov %i0, %l2 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 400131a0: 80 a6 60 00 cmp %i1, 0 400131a4: 02 80 00 21 be 40013228 400131a8: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( !routine ) 400131ac: 80 a6 a0 00 cmp %i2, 0 400131b0: 02 80 00 1e be 40013228 400131b4: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 400131b8: 11 10 00 d4 sethi %hi(0x40035000), %o0 400131bc: 92 10 00 12 mov %l2, %o1 400131c0: 90 12 22 ec or %o0, 0x2ec, %o0 400131c4: 40 00 09 d0 call 40015904 <_Objects_Get> 400131c8: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 400131cc: c2 07 bf f4 ld [ %fp + -12 ], %g1 400131d0: 80 a0 60 00 cmp %g1, 0 400131d4: 02 80 00 08 be 400131f4 400131d8: a0 10 00 08 mov %o0, %l0 400131dc: 82 18 60 02 xor %g1, 2, %g1 400131e0: 80 a0 00 01 cmp %g0, %g1 400131e4: 82 60 20 00 subx %g0, 0, %g1 400131e8: b0 08 60 15 and %g1, 0x15, %i0 400131ec: 81 c7 e0 08 ret 400131f0: 91 ee 20 04 restore %i0, 4, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 400131f4: a2 02 20 10 add %o0, 0x10, %l1 400131f8: 40 00 15 09 call 4001861c <_Watchdog_Remove> 400131fc: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 40013200: 7f ff dd ac call 4000a8b0 40013204: 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 ) { 40013208: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 4001320c: 80 a0 60 00 cmp %g1, 0 40013210: 22 80 00 08 be,a 40013230 40013214: f4 24 20 2c st %i2, [ %l0 + 0x2c ] _ISR_Enable( level ); 40013218: 7f ff dd aa call 4000a8c0 <== NOT EXECUTED 4001321c: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 40013220: 7f ff ff d1 call 40013164 <_Thread_Enable_dispatch> <== NOT EXECUTED 40013224: 01 00 00 00 nop <== NOT EXECUTED 40013228: 81 c7 e0 08 ret 4001322c: 81 e8 00 00 restore 40013230: e4 24 20 30 st %l2, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 40013234: 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; 40013238: c0 24 20 38 clr [ %l0 + 0x38 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4001323c: c0 24 20 18 clr [ %l0 + 0x18 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 40013240: 7f ff dd a0 call 4000a8c0 40013244: b0 10 20 00 clr %i0 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40013248: 92 10 00 11 mov %l1, %o1 4001324c: 11 10 00 d2 sethi %hi(0x40034800), %o0 40013250: 90 12 21 ac or %o0, 0x1ac, %o0 ! 400349ac <_Watchdog_Ticks_chain> 40013254: 40 00 14 9a call 400184bc <_Watchdog_Insert> 40013258: f2 24 20 1c st %i1, [ %l0 + 0x1c ] _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 4001325c: 7f ff ff c2 call 40013164 <_Thread_Enable_dispatch> 40013260: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40013264: 81 c7 e0 08 ret 40013268: 81 e8 00 00 restore 40008f00 : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 40008f00: 9d e3 bf 90 save %sp, -112, %sp 40008f04: 92 10 00 18 mov %i0, %o1 Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 40008f08: 80 a6 60 00 cmp %i1, 0 40008f0c: 02 80 00 22 be 40008f94 40008f10: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40008f14: 11 10 00 83 sethi %hi(0x40020c00), %o0 40008f18: 94 07 bf f4 add %fp, -12, %o2 40008f1c: 40 00 07 66 call 4000acb4 <_Objects_Get> 40008f20: 90 12 20 08 or %o0, 8, %o0 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40008f24: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008f28: 80 a0 60 00 cmp %g1, 0 40008f2c: 22 80 00 08 be,a 40008f4c 40008f30: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 40008f34: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 40008f38: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 40008f3c: 82 60 20 00 subx %g0, 0, %g1 <== NOT EXECUTED 40008f40: b0 08 60 15 and %g1, 0x15, %i0 <== NOT EXECUTED 40008f44: 81 c7 e0 08 ret <== NOT EXECUTED 40008f48: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 40008f4c: c4 02 20 38 ld [ %o0 + 0x38 ], %g2 the_info->initial = the_timer->Ticker.initial; 40008f50: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->start_time = the_timer->Ticker.start_time; 40008f54: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 40008f58: c4 26 40 00 st %g2, [ %i1 ] the_info->initial = the_timer->Ticker.initial; the_info->start_time = the_timer->Ticker.start_time; 40008f5c: c2 26 60 08 st %g1, [ %i1 + 8 ] the_info->stop_time = the_timer->Ticker.stop_time; 40008f60: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 40008f64: 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 ) 40008f68: 05 10 00 83 sethi %hi(0x40020c00), %g2 40008f6c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 40020df0 <_Thread_Dispatch_disable_level> 40008f70: b0 10 20 00 clr %i0 40008f74: 82 00 7f ff add %g1, -1, %g1 40008f78: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 40008f7c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 40008f80: 80 a0 60 00 cmp %g1, 0 40008f84: 12 80 00 04 bne 40008f94 40008f88: 01 00 00 00 nop _Thread_Dispatch(); 40008f8c: 40 00 0c 3e call 4000c084 <_Thread_Dispatch> 40008f90: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008f94: 81 c7 e0 08 ret 40008f98: 81 e8 00 00 restore 40013988 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 40013988: 9d e3 bf 90 save %sp, -112, %sp /* * Make sure the requested priority is valid. */ _priority = priority; if ( priority == RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 4001398c: 92 10 20 00 clr %o1 40013990: 80 a6 3f ff cmp %i0, -1 40013994: 02 80 00 07 be 400139b0 40013998: 94 10 00 19 mov %i1, %o2 _priority = 0; else if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) 4001399c: 82 06 3f ff add %i0, -1, %g1 400139a0: 80 a0 60 fe cmp %g1, 0xfe 400139a4: 18 80 00 48 bgu 40013ac4 400139a8: a0 10 20 13 mov 0x13, %l0 400139ac: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 400139b0: 05 10 00 d2 sethi %hi(0x40034800), %g2 400139b4: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 400348b0 <_Thread_Dispatch_disable_level> 400139b8: 82 00 60 01 inc %g1 400139bc: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] * Just to make sure the test versus create/start operation are atomic. */ _Thread_Disable_dispatch(); if ( _Timer_Server ) { 400139c0: 03 10 00 d4 sethi %hi(0x40035000), %g1 400139c4: c2 00 63 38 ld [ %g1 + 0x338 ], %g1 ! 40035338 <_Timer_Server> 400139c8: 80 a0 60 00 cmp %g1, 0 400139cc: 02 80 00 06 be 400139e4 400139d0: 19 00 00 20 sethi %hi(0x8000), %o4 _Thread_Enable_dispatch(); 400139d4: 7f ff ff a0 call 40013854 <_Thread_Enable_dispatch> <== NOT EXECUTED 400139d8: a0 10 20 0e mov 0xe, %l0 <== NOT EXECUTED _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; } 400139dc: 81 c7 e0 08 ret <== NOT EXECUTED 400139e0: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED * 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( 400139e4: 11 15 12 53 sethi %hi(0x54494c00), %o0 400139e8: 98 16 80 0c or %i2, %o4, %o4 400139ec: 90 12 21 45 or %o0, 0x145, %o0 400139f0: 96 10 21 00 mov 0x100, %o3 400139f4: 7f ff fa 0e call 4001222c 400139f8: 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) { 400139fc: a0 92 20 00 orcc %o0, 0, %l0 40013a00: 12 80 00 2f bne 40013abc 40013a04: d0 07 bf f4 ld [ %fp + -12 ], %o0 _Thread_Enable_dispatch(); return status; } status = rtems_task_start( 40013a08: 13 10 00 4e sethi %hi(0x40013800), %o1 40013a0c: 94 10 20 00 clr %o2 40013a10: 7f ff fc 62 call 40012b98 40013a14: 92 12 60 88 or %o1, 0x88, %o1 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 40013a18: a0 92 20 00 orcc %o0, 0, %l0 40013a1c: 12 80 00 28 bne 40013abc 40013a20: 03 10 00 d1 sethi %hi(0x40034400), %g1 * * 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( 40013a24: 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 ) 40013a28: 9a 10 63 60 or %g1, 0x360, %o5 40013a2c: c4 13 60 10 lduh [ %o5 + 0x10 ], %g2 40013a30: 03 00 00 3f sethi %hi(0xfc00), %g1 40013a34: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40013a38: 82 09 00 01 and %g4, %g1, %g1 40013a3c: 80 a0 40 02 cmp %g1, %g2 40013a40: 18 80 00 05 bgu 40013a54 40013a44: 86 10 20 00 clr %g3 return NULL; return information->local_table[ index ]; 40013a48: c4 03 60 20 ld [ %o5 + 0x20 ], %g2 40013a4c: 83 28 60 02 sll %g1, 2, %g1 40013a50: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40013a54: 03 10 00 d4 sethi %hi(0x40035000), %g1 40013a58: c6 20 63 38 st %g3, [ %g1 + 0x338 ] ! 40035338 <_Timer_Server> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40013a5c: 03 10 00 d1 sethi %hi(0x40034400), %g1 40013a60: 82 10 63 b0 or %g1, 0x3b0, %g1 ! 400347b0 <_Timer_Ticks_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40013a64: c2 20 7f fc st %g1, [ %g1 + -4 ] 40013a68: 82 00 7f fc add %g1, -4, %g1 ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 40013a6c: c0 20 e0 6c clr [ %g3 + 0x6c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40013a70: c0 20 e0 50 clr [ %g3 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; 40013a74: c8 20 e0 68 st %g4, [ %g3 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40013a78: 05 10 00 5b sethi %hi(0x40016c00), %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40013a7c: c2 20 60 08 st %g1, [ %g1 + 8 ] 40013a80: 84 10 a0 18 or %g2, 0x18, %g2 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 40013a84: c0 20 60 04 clr [ %g1 + 4 ] 40013a88: c4 20 e0 64 st %g2, [ %g3 + 0x64 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40013a8c: 03 10 00 d1 sethi %hi(0x40034400), %g1 40013a90: 82 10 63 c4 or %g1, 0x3c4, %g1 ! 400347c4 <_Timer_Seconds_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40013a94: c2 20 7f fc st %g1, [ %g1 + -4 ] 40013a98: 82 00 7f fc add %g1, -4, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40013a9c: c2 20 60 08 st %g1, [ %g1 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 40013aa0: c0 20 60 04 clr [ %g1 + 4 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40013aa4: 03 10 00 d1 sethi %hi(0x40034400), %g1 40013aa8: 82 10 63 cc or %g1, 0x3cc, %g1 ! 400347cc <_Timer_Seconds_timer> the_watchdog->routine = routine; 40013aac: c4 20 60 1c st %g2, [ %g1 + 0x1c ] the_watchdog->id = id; 40013ab0: c8 20 60 20 st %g4, [ %g1 + 0x20 ] the_watchdog->user_data = user_data; 40013ab4: c0 20 60 24 clr [ %g1 + 0x24 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40013ab8: c0 20 60 08 clr [ %g1 + 8 ] */ _Watchdog_Initialize( &_Timer_Server->Timer, _Thread_Delay_ended, id, NULL ); _Watchdog_Initialize( &_Timer_Seconds_timer, _Thread_Delay_ended, id, NULL ); _Thread_Enable_dispatch(); 40013abc: 7f ff ff 66 call 40013854 <_Thread_Enable_dispatch> 40013ac0: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } 40013ac4: b0 10 00 10 mov %l0, %i0 40013ac8: 81 c7 e0 08 ret 40013acc: 81 e8 00 00 restore 40013518 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 40013518: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 4001351c: 25 10 00 d4 sethi %hi(0x40035000), %l2 40013520: c2 04 a3 38 ld [ %l2 + 0x338 ], %g1 ! 40035338 <_Timer_Server> Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 40013524: a6 10 00 18 mov %i0, %l3 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 40013528: 80 a0 60 00 cmp %g1, 0 4001352c: 02 80 00 24 be 400135bc 40013530: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; if ( !routine ) 40013534: 80 a6 a0 00 cmp %i2, 0 40013538: 02 80 00 21 be 400135bc 4001353c: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 40013540: 80 a6 60 00 cmp %i1, 0 40013544: 02 80 00 1e be 400135bc 40013548: b0 10 20 0a mov 0xa, %i0 4001354c: 11 10 00 d4 sethi %hi(0x40035000), %o0 40013550: 92 10 00 13 mov %l3, %o1 40013554: 90 12 22 ec or %o0, 0x2ec, %o0 40013558: 40 00 08 eb call 40015904 <_Objects_Get> 4001355c: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40013560: c2 07 bf f4 ld [ %fp + -12 ], %g1 40013564: 80 a0 60 00 cmp %g1, 0 40013568: 02 80 00 08 be 40013588 4001356c: a0 10 00 08 mov %o0, %l0 40013570: 82 18 60 02 xor %g1, 2, %g1 40013574: 80 a0 00 01 cmp %g0, %g1 40013578: 82 60 20 00 subx %g0, 0, %g1 4001357c: b0 08 60 15 and %g1, 0x15, %i0 40013580: 81 c7 e0 08 ret 40013584: 91 ee 20 04 restore %i0, 4, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 40013588: a2 02 20 10 add %o0, 0x10, %l1 4001358c: 40 00 14 24 call 4001861c <_Watchdog_Remove> 40013590: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 40013594: 7f ff dc c7 call 4000a8b0 40013598: 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 ) { 4001359c: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 400135a0: 80 a0 60 00 cmp %g1, 0 400135a4: 02 80 00 08 be 400135c4 400135a8: 82 10 20 01 mov 1, %g1 _ISR_Enable( level ); 400135ac: 7f ff dc c5 call 4000a8c0 <== NOT EXECUTED 400135b0: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 400135b4: 7f ff ff cc call 400134e4 <_Thread_Enable_dispatch> <== NOT EXECUTED 400135b8: 01 00 00 00 nop <== NOT EXECUTED 400135bc: 81 c7 e0 08 ret 400135c0: 81 e8 00 00 restore * 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; 400135c4: f2 24 20 1c st %i1, [ %l0 + 0x1c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 400135c8: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 400135cc: e6 24 20 30 st %l3, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 400135d0: f6 24 20 34 st %i3, [ %l0 + 0x34 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 400135d4: 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; 400135d8: 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 ); 400135dc: 7f ff dc b9 call 4000a8c0 400135e0: 21 10 00 d1 sethi %hi(0x40034400), %l0 _Timer_Server_stop_ticks_timer(); 400135e4: d0 04 a3 38 ld [ %l2 + 0x338 ], %o0 400135e8: 40 00 14 0d call 4001861c <_Watchdog_Remove> 400135ec: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_process_ticks_chain(); 400135f0: 40 00 00 87 call 4001380c <_Timer_Server_process_ticks_chain> 400135f4: 01 00 00 00 nop _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 400135f8: 90 14 23 ac or %l0, 0x3ac, %o0 400135fc: 40 00 13 b0 call 400184bc <_Watchdog_Insert> 40013600: 92 10 00 11 mov %l1, %o1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 40013604: c4 04 23 ac ld [ %l0 + 0x3ac ], %g2 40013608: a0 14 23 ac or %l0, 0x3ac, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4001360c: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 40013610: 80 a0 80 10 cmp %g2, %l0 40013614: 02 80 00 08 be 40013634 40013618: c2 04 a3 38 ld [ %l2 + 0x338 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4001361c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40013620: 11 10 00 d2 sethi %hi(0x40034800), %o0 40013624: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40013628: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4001362c: 40 00 13 a4 call 400184bc <_Watchdog_Insert> 40013630: 90 12 21 ac or %o0, 0x1ac, %o0 _Thread_Enable_dispatch(); 40013634: 7f ff ff ac call 400134e4 <_Thread_Enable_dispatch> 40013638: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001363c: 81 c7 e0 08 ret 40013640: 81 e8 00 00 restore 40007750 : */ int sched_get_priority_max( int policy ) { 40007750: 9d e3 bf 98 save %sp, -104, %sp switch ( policy ) { 40007754: 80 a6 20 03 cmp %i0, 3 40007758: 08 80 00 06 bleu 40007770 4000775c: b0 10 20 fe mov 0xfe, %i0 case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 40007760: 40 00 24 8e call 40010998 <__errno> <== NOT EXECUTED 40007764: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40007768: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 4000776c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 40007770: 81 c7 e0 08 ret 40007774: 81 e8 00 00 restore 400077b0 : int sched_getparam( pid_t pid, const struct sched_param *param ) { 400077b0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 400077b4: 40 00 24 79 call 40010998 <__errno> <== NOT EXECUTED 400077b8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 400077bc: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 400077c0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 400077c4: 81 c7 e0 08 ret <== NOT EXECUTED 400077c8: 81 e8 00 00 restore <== NOT EXECUTED 40007778 : */ int sched_getscheduler( pid_t pid ) { 40007778: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 4000777c: 40 00 24 87 call 40010998 <__errno> <== NOT EXECUTED 40007780: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 40007784: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 40007788: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 4000778c: 81 c7 e0 08 ret <== NOT EXECUTED 40007790: 81 e8 00 00 restore <== NOT EXECUTED 400077e8 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 400077e8: 9d e3 bf 98 save %sp, -104, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 400077ec: 80 a6 20 00 cmp %i0, 0 400077f0: 02 80 00 0b be 4000781c 400077f4: 80 a6 60 00 cmp %i1, 0 400077f8: 7f ff f1 7c call 40003de8 400077fc: 01 00 00 00 nop 40007800: 80 a6 00 08 cmp %i0, %o0 40007804: 02 80 00 06 be 4000781c 40007808: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 4000780c: 40 00 24 63 call 40010998 <__errno> <== NOT EXECUTED 40007810: 01 00 00 00 nop <== NOT EXECUTED 40007814: 10 80 00 07 b 40007830 <== NOT EXECUTED 40007818: 82 10 20 03 mov 3, %g1 ! 3 <== NOT EXECUTED if ( !interval ) 4000781c: 12 80 00 08 bne 4000783c 40007820: 03 10 00 7a sethi %hi(0x4001e800), %g1 rtems_set_errno_and_return_minus_one( EINVAL ); 40007824: 40 00 24 5d call 40010998 <__errno> <== NOT EXECUTED 40007828: 01 00 00 00 nop <== NOT EXECUTED 4000782c: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 40007830: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 40007834: 81 c7 e0 08 ret <== NOT EXECUTED 40007838: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 4000783c: d0 00 62 48 ld [ %g1 + 0x248 ], %o0 40007840: 92 10 00 19 mov %i1, %o1 40007844: 40 00 13 de call 4000c7bc <_Timespec_From_ticks> 40007848: b0 10 20 00 clr %i0 return 0; } 4000784c: 81 c7 e0 08 ret 40007850: 81 e8 00 00 restore 400077cc : int sched_setparam( pid_t pid, const struct sched_param *param ) { 400077cc: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 400077d0: 40 00 24 72 call 40010998 <__errno> <== NOT EXECUTED 400077d4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 400077d8: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 400077dc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 400077e0: 81 c7 e0 08 ret <== NOT EXECUTED 400077e4: 81 e8 00 00 restore <== NOT EXECUTED 40007794 : int sched_setscheduler( pid_t pid, int policy, const struct sched_param *param ) { 40007794: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 40007798: 40 00 24 80 call 40010998 <__errno> <== NOT EXECUTED 4000779c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 400077a0: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 400077a4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 400077a8: 81 c7 e0 08 ret <== NOT EXECUTED 400077ac: 81 e8 00 00 restore <== NOT EXECUTED 4000766c : */ int sem_close( sem_t *sem ) { 4000766c: 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 *) 40007670: d2 06 00 00 ld [ %i0 ], %o1 40007674: 11 10 00 81 sethi %hi(0x40020400), %o0 40007678: 94 07 bf f4 add %fp, -12, %o2 4000767c: 40 00 0b b8 call 4000a55c <_Objects_Get> 40007680: 90 12 21 b0 or %o0, 0x1b0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 40007684: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007688: 80 a0 60 01 cmp %g1, 1 4000768c: 02 80 00 0d be 400076c0 40007690: 01 00 00 00 nop 40007694: 2a 80 00 11 bcs,a 400076d8 40007698: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 4000769c: 80 a0 60 02 cmp %g1, 2 400076a0: 12 80 00 1e bne 40007718 400076a4: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 400076a8: 40 00 28 13 call 400116f4 <__errno> 400076ac: 01 00 00 00 nop 400076b0: 82 10 20 16 mov 0x16, %g1 ! 16 400076b4: c2 22 00 00 st %g1, [ %o0 ] 400076b8: 10 80 00 1a b 40007720 400076bc: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 400076c0: 40 00 10 5c call 4000b830 <_Thread_Dispatch> <== NOT EXECUTED 400076c4: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 400076c8: 40 00 01 78 call 40007ca8 <== NOT EXECUTED 400076cc: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 400076d0: 81 c7 e0 08 ret <== NOT EXECUTED 400076d4: 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; 400076d8: 82 00 7f ff add %g1, -1, %g1 _POSIX_Semaphore_Delete( the_semaphore ); 400076dc: 40 00 1f b5 call 4000f5b0 <_POSIX_Semaphore_Delete> 400076e0: 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 ) 400076e4: 05 10 00 80 sethi %hi(0x40020000), %g2 400076e8: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 ! 40020230 <_Thread_Dispatch_disable_level> 400076ec: 90 10 20 00 clr %o0 400076f0: 82 00 7f ff add %g1, -1, %g1 400076f4: c2 20 a2 30 st %g1, [ %g2 + 0x230 ] 400076f8: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 400076fc: 80 a0 60 00 cmp %g1, 0 40007700: 32 80 00 09 bne,a 40007724 40007704: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 40007708: 40 00 10 4a call 4000b830 <_Thread_Dispatch> 4000770c: 01 00 00 00 nop 40007710: 10 80 00 04 b 40007720 40007714: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40007718: 40 00 01 5a call 40007c80 <== NOT EXECUTED 4000771c: 01 00 00 00 nop <== NOT EXECUTED } 40007720: b0 10 00 08 mov %o0, %i0 40007724: 81 c7 e0 08 ret 40007728: 81 e8 00 00 restore 40007760 : */ int sem_destroy( sem_t *sem ) { 40007760: 9d e3 bf 90 save %sp, -112, %sp 40007764: d2 06 00 00 ld [ %i0 ], %o1 40007768: 11 10 00 81 sethi %hi(0x40020400), %o0 4000776c: 94 07 bf f4 add %fp, -12, %o2 40007770: 40 00 0b 7b call 4000a55c <_Objects_Get> 40007774: 90 12 21 b0 or %o0, 0x1b0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 40007778: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000777c: 80 a0 60 01 cmp %g1, 1 40007780: 02 80 00 08 be 400077a0 40007784: 01 00 00 00 nop 40007788: 2a 80 00 0c bcs,a 400077b8 4000778c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40007790: 80 a0 60 02 cmp %g1, 2 40007794: 12 80 00 1a bne 400077fc 40007798: 01 00 00 00 nop 4000779c: 30 80 00 0c b,a 400077cc case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 400077a0: 40 00 10 24 call 4000b830 <_Thread_Dispatch> <== NOT EXECUTED 400077a4: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 400077a8: 40 00 01 40 call 40007ca8 <== NOT EXECUTED 400077ac: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 400077b0: 81 c7 e0 08 ret <== NOT EXECUTED 400077b4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { 400077b8: 80 a0 60 01 cmp %g1, 1 400077bc: 12 80 00 0a bne 400077e4 400077c0: 01 00 00 00 nop _Thread_Enable_dispatch(); 400077c4: 7f ff ff da call 4000772c <_Thread_Enable_dispatch> <== NOT EXECUTED 400077c8: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 400077cc: 40 00 27 ca call 400116f4 <__errno> 400077d0: 01 00 00 00 nop 400077d4: 82 10 20 16 mov 0x16, %g1 ! 16 400077d8: c2 22 00 00 st %g1, [ %o0 ] 400077dc: 10 80 00 0a b 40007804 400077e0: 90 10 3f ff mov -1, %o0 } _POSIX_Semaphore_Delete( the_semaphore ); 400077e4: 40 00 1f 73 call 4000f5b0 <_POSIX_Semaphore_Delete> 400077e8: 01 00 00 00 nop _Thread_Enable_dispatch(); 400077ec: 7f ff ff d0 call 4000772c <_Thread_Enable_dispatch> 400077f0: 01 00 00 00 nop 400077f4: 10 80 00 04 b 40007804 400077f8: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 400077fc: 40 00 01 21 call 40007c80 <== NOT EXECUTED 40007800: 01 00 00 00 nop <== NOT EXECUTED } 40007804: b0 10 00 08 mov %o0, %i0 40007808: 81 c7 e0 08 ret 4000780c: 81 e8 00 00 restore 40007810 : int sem_getvalue( sem_t *sem, int *sval ) { 40007810: 9d e3 bf 90 save %sp, -112, %sp 40007814: d2 06 00 00 ld [ %i0 ], %o1 40007818: 11 10 00 81 sethi %hi(0x40020400), %o0 4000781c: 94 07 bf f4 add %fp, -12, %o2 40007820: 40 00 0b 4f call 4000a55c <_Objects_Get> 40007824: 90 12 21 b0 or %o0, 0x1b0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 40007828: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000782c: 80 a0 60 01 cmp %g1, 1 40007830: 02 80 00 0d be 40007864 40007834: 01 00 00 00 nop 40007838: 2a 80 00 11 bcs,a 4000787c 4000783c: c2 02 20 68 ld [ %o0 + 0x68 ], %g1 40007840: 80 a0 60 02 cmp %g1, 2 40007844: 12 80 00 1c bne 400078b4 40007848: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 4000784c: 40 00 27 aa call 400116f4 <__errno> 40007850: 01 00 00 00 nop 40007854: 82 10 20 16 mov 0x16, %g1 ! 16 40007858: c2 22 00 00 st %g1, [ %o0 ] 4000785c: 10 80 00 18 b 400078bc 40007860: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 40007864: 40 00 0f f3 call 4000b830 <_Thread_Dispatch> <== NOT EXECUTED 40007868: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 4000786c: 40 00 01 0f call 40007ca8 <== NOT EXECUTED 40007870: 01 00 00 00 nop <== NOT EXECUTED *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40007874: 81 c7 e0 08 ret <== NOT EXECUTED 40007878: 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 ); 4000787c: 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 ) 40007880: 05 10 00 80 sethi %hi(0x40020000), %g2 40007884: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 ! 40020230 <_Thread_Dispatch_disable_level> 40007888: 90 10 20 00 clr %o0 4000788c: 82 00 7f ff add %g1, -1, %g1 40007890: c2 20 a2 30 st %g1, [ %g2 + 0x230 ] 40007894: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 40007898: 80 a0 60 00 cmp %g1, 0 4000789c: 32 80 00 09 bne,a 400078c0 400078a0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 400078a4: 40 00 0f e3 call 4000b830 <_Thread_Dispatch> 400078a8: 01 00 00 00 nop 400078ac: 10 80 00 04 b 400078bc 400078b0: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 400078b4: 40 00 00 f3 call 40007c80 <== NOT EXECUTED 400078b8: 01 00 00 00 nop <== NOT EXECUTED } 400078bc: b0 10 00 08 mov %o0, %i0 400078c0: 81 c7 e0 08 ret 400078c4: 81 e8 00 00 restore 400078c8 : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 400078c8: 9d e3 bf 90 save %sp, -112, %sp 400078cc: 92 10 00 19 mov %i1, %o1 int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 400078d0: 80 a6 20 00 cmp %i0, 0 400078d4: 12 80 00 08 bne 400078f4 400078d8: 94 10 00 1a mov %i2, %o2 rtems_set_errno_and_return_minus_one( EINVAL ); 400078dc: 40 00 27 86 call 400116f4 <__errno> <== NOT EXECUTED 400078e0: 01 00 00 00 nop <== NOT EXECUTED 400078e4: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 400078e8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 400078ec: 10 80 00 0a b 40007914 <== NOT EXECUTED 400078f0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED status = _POSIX_Semaphore_Create_support( 400078f4: 90 10 20 00 clr %o0 400078f8: 40 00 1e e2 call 4000f480 <_POSIX_Semaphore_Create_support> 400078fc: 96 07 bf f4 add %fp, -12, %o3 pshared, value, &the_semaphore ); if ( status != -1 ) 40007900: 80 a2 3f ff cmp %o0, -1 40007904: 02 80 00 04 be 40007914 40007908: c2 07 bf f4 ld [ %fp + -12 ], %g1 *sem = the_semaphore->Object.id; 4000790c: c2 00 60 08 ld [ %g1 + 8 ], %g1 40007910: c2 26 00 00 st %g1, [ %i0 ] return status; } 40007914: 81 c7 e0 08 ret 40007918: 91 e8 00 08 restore %g0, %o0, %o0 40007a6c : */ int sem_post( sem_t *sem ) { 40007a6c: 9d e3 bf 90 save %sp, -112, %sp 40007a70: d2 06 00 00 ld [ %i0 ], %o1 40007a74: 11 10 00 81 sethi %hi(0x40020400), %o0 40007a78: 94 07 bf f4 add %fp, -12, %o2 40007a7c: 40 00 0a b8 call 4000a55c <_Objects_Get> 40007a80: 90 12 21 b0 or %o0, 0x1b0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 40007a84: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007a88: 80 a0 60 01 cmp %g1, 1 40007a8c: 02 80 00 0d be 40007ac0 40007a90: 01 00 00 00 nop 40007a94: 2a 80 00 11 bcs,a 40007ad8 40007a98: d2 02 20 08 ld [ %o0 + 8 ], %o1 40007a9c: 80 a0 60 02 cmp %g1, 2 40007aa0: 12 80 00 1e bne 40007b18 40007aa4: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 40007aa8: 40 00 27 13 call 400116f4 <__errno> 40007aac: 01 00 00 00 nop 40007ab0: 82 10 20 16 mov 0x16, %g1 ! 16 40007ab4: c2 22 00 00 st %g1, [ %o0 ] 40007ab8: 10 80 00 1a b 40007b20 40007abc: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 40007ac0: 40 00 0f 5c call 4000b830 <_Thread_Dispatch> <== NOT EXECUTED 40007ac4: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 40007ac8: 40 00 00 78 call 40007ca8 <== NOT EXECUTED 40007acc: 01 00 00 00 nop <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 40007ad0: 81 c7 e0 08 ret <== NOT EXECUTED 40007ad4: 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( 40007ad8: 94 10 20 00 clr %o2 40007adc: 40 00 07 a5 call 40009970 <_CORE_semaphore_Surrender> 40007ae0: 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 ) 40007ae4: 03 10 00 80 sethi %hi(0x40020000), %g1 40007ae8: c4 00 62 30 ld [ %g1 + 0x230 ], %g2 ! 40020230 <_Thread_Dispatch_disable_level> 40007aec: 90 10 20 00 clr %o0 40007af0: 84 00 bf ff add %g2, -1, %g2 40007af4: c4 20 62 30 st %g2, [ %g1 + 0x230 ] 40007af8: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 40007afc: 80 a0 60 00 cmp %g1, 0 40007b00: 32 80 00 09 bne,a 40007b24 40007b04: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 40007b08: 40 00 0f 4a call 4000b830 <_Thread_Dispatch> 40007b0c: 01 00 00 00 nop 40007b10: 10 80 00 04 b 40007b20 40007b14: 90 10 20 00 clr %o0 ! 0 #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 40007b18: 40 00 00 5a call 40007c80 <== NOT EXECUTED 40007b1c: 01 00 00 00 nop <== NOT EXECUTED } 40007b20: b0 10 00 08 mov %o0, %i0 40007b24: 81 c7 e0 08 ret 40007b28: 81 e8 00 00 restore 40006d18 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 40006d18: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; if ( oact ) 40006d1c: 90 96 a0 00 orcc %i2, 0, %o0 40006d20: 02 80 00 09 be 40006d44 40006d24: 85 2e 20 02 sll %i0, 2, %g2 *oact = _POSIX_signals_Vectors[ sig ]; 40006d28: 83 2e 20 04 sll %i0, 4, %g1 <== NOT EXECUTED 40006d2c: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 40006d30: 13 10 00 78 sethi %hi(0x4001e000), %o1 <== NOT EXECUTED 40006d34: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED 40006d38: 92 12 63 c4 or %o1, 0x3c4, %o1 <== NOT EXECUTED 40006d3c: 40 00 27 1d call 400109b0 <== NOT EXECUTED 40006d40: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED if ( !sig ) 40006d44: 80 a6 20 00 cmp %i0, 0 40006d48: 02 80 00 08 be 40006d68 40006d4c: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 40006d50: a0 06 3f ff add %i0, -1, %l0 40006d54: 80 a4 20 1f cmp %l0, 0x1f 40006d58: 18 80 00 04 bgu 40006d68 40006d5c: 80 a6 20 09 cmp %i0, 9 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 40006d60: 12 80 00 08 bne 40006d80 40006d64: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( EINVAL ); 40006d68: 40 00 25 2c call 40010218 <__errno> 40006d6c: 01 00 00 00 nop 40006d70: 82 10 20 16 mov 0x16, %g1 ! 16 40006d74: c2 22 00 00 st %g1, [ %o0 ] 40006d78: 10 80 00 1f b 40006df4 40006d7c: 82 10 3f ff mov -1, %g1 /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 40006d80: 02 80 00 1d be 40006df4 40006d84: 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 ); 40006d88: 7f ff ed c6 call 400024a0 40006d8c: 01 00 00 00 nop 40006d90: a4 10 00 08 mov %o0, %l2 if ( act->sa_handler == SIG_DFL ) { 40006d94: c2 06 60 08 ld [ %i1 + 8 ], %g1 40006d98: b5 2e 20 04 sll %i0, 4, %i2 40006d9c: 80 a0 60 00 cmp %g1, 0 40006da0: b1 2e 20 02 sll %i0, 2, %i0 40006da4: 03 10 00 78 sethi %hi(0x4001e000), %g1 40006da8: 12 80 00 08 bne 40006dc8 40006dac: a2 10 63 c4 or %g1, 0x3c4, %l1 ! 4001e3c4 <_POSIX_signals_Vectors> _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 40006db0: 82 26 80 18 sub %i2, %i0, %g1 <== NOT EXECUTED 40006db4: 13 10 00 74 sethi %hi(0x4001d000), %o1 <== NOT EXECUTED 40006db8: 90 00 40 11 add %g1, %l1, %o0 <== NOT EXECUTED 40006dbc: 92 12 60 6c or %o1, 0x6c, %o1 <== NOT EXECUTED 40006dc0: 10 80 00 08 b 40006de0 <== NOT EXECUTED 40006dc4: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED } else { _POSIX_signals_Clear_process_signals( signo_to_mask(sig) ); 40006dc8: 90 10 20 01 mov 1, %o0 40006dcc: 40 00 1d 11 call 4000e210 <_POSIX_signals_Clear_process_signals> 40006dd0: 91 2a 00 10 sll %o0, %l0, %o0 _POSIX_signals_Vectors[ sig ] = *act; 40006dd4: 90 26 80 18 sub %i2, %i0, %o0 40006dd8: 92 10 00 19 mov %i1, %o1 40006ddc: 90 02 00 11 add %o0, %l1, %o0 40006de0: 40 00 26 f4 call 400109b0 40006de4: 94 10 20 0c mov 0xc, %o2 } _ISR_Enable( level ); 40006de8: 7f ff ed b2 call 400024b0 40006dec: 90 10 00 12 mov %l2, %o0 40006df0: 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; } 40006df4: 81 c7 e0 08 ret 40006df8: 91 e8 00 01 restore %g0, %g1, %o0 40007174 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 40007174: 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 ) { 40007178: 80 a6 a0 00 cmp %i2, 0 4000717c: 02 80 00 12 be 400071c4 40007180: a6 10 20 00 clr %l3 if ( !_Timespec_Is_valid( timeout ) ) 40007184: 40 00 13 ce call 4000c0bc <_Timespec_Is_valid> 40007188: 90 10 00 1a mov %i2, %o0 4000718c: 80 a2 20 00 cmp %o0, 0 40007190: 02 80 00 07 be 400071ac 40007194: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 40007198: 40 00 13 ee call 4000c150 <_Timespec_To_ticks> 4000719c: 90 10 00 1a mov %i2, %o0 if ( !interval ) 400071a0: a6 92 20 00 orcc %o0, 0, %l3 400071a4: 12 80 00 09 bne 400071c8 400071a8: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( EINVAL ); 400071ac: 40 00 25 d4 call 400108fc <__errno> 400071b0: b0 10 3f ff mov -1, %i0 400071b4: 82 10 20 16 mov 0x16, %g1 400071b8: c2 22 00 00 st %g1, [ %o0 ] 400071bc: 81 c7 e0 08 ret 400071c0: 81 e8 00 00 restore /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 400071c4: 80 a6 60 00 cmp %i1, 0 400071c8: 02 80 00 03 be 400071d4 400071cc: a4 07 bf ec add %fp, -20, %l2 400071d0: a4 10 00 19 mov %i1, %l2 the_thread = _Thread_Executing; 400071d4: 29 10 00 79 sethi %hi(0x4001e400), %l4 400071d8: f4 05 22 6c ld [ %l4 + 0x26c ], %i2 ! 4001e66c <_Thread_Executing> * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 400071dc: 7f ff ed 72 call 400027a4 400071e0: f2 06 a1 70 ld [ %i2 + 0x170 ], %i1 400071e4: a0 10 00 08 mov %o0, %l0 if ( *set & api->signals_pending ) { 400071e8: c4 06 00 00 ld [ %i0 ], %g2 400071ec: c2 06 60 c8 ld [ %i1 + 0xc8 ], %g1 400071f0: 80 88 80 01 btst %g2, %g1 400071f4: 22 80 00 10 be,a 40007234 400071f8: 03 10 00 7b sethi %hi(0x4001ec00), %g1 /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending ); 400071fc: 7f ff ff c4 call 4000710c <_POSIX_signals_Get_highest> 40007200: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( 40007204: 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 ); 40007208: 92 10 00 08 mov %o0, %o1 _POSIX_signals_Clear_signals( 4000720c: 96 10 20 00 clr %o3 40007210: 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 ); 40007214: d2 24 80 00 st %o1, [ %l2 ] _POSIX_signals_Clear_signals( 40007218: 40 00 1d e3 call 4000e9a4 <_POSIX_signals_Clear_signals> 4000721c: 98 10 20 00 clr %o4 the_info->si_signo, the_info, FALSE, FALSE ); _ISR_Enable( level ); 40007220: 7f ff ed 65 call 400027b4 40007224: 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; 40007228: f0 04 80 00 ld [ %l2 ], %i0 FALSE ); _ISR_Enable( level ); the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; 4000722c: 10 80 00 13 b 40007278 40007230: c0 24 a0 08 clr [ %l2 + 8 ] return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 40007234: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 40007238: 80 88 80 01 btst %g2, %g1 4000723c: 02 80 00 13 be 40007288 40007240: 23 10 00 79 sethi %hi(0x4001e400), %l1 signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 40007244: 7f ff ff b2 call 4000710c <_POSIX_signals_Get_highest> 40007248: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( api, signo, the_info, TRUE, FALSE ); 4000724c: 94 10 00 12 mov %l2, %o2 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 40007250: b0 10 00 08 mov %o0, %i0 _POSIX_signals_Clear_signals( api, signo, the_info, TRUE, FALSE ); 40007254: 96 10 20 01 mov 1, %o3 40007258: 90 10 00 19 mov %i1, %o0 4000725c: 92 10 00 18 mov %i0, %o1 40007260: 40 00 1d d1 call 4000e9a4 <_POSIX_signals_Clear_signals> 40007264: 98 10 20 00 clr %o4 _ISR_Enable( level ); 40007268: 7f ff ed 53 call 400027b4 4000726c: 90 10 00 10 mov %l0, %o0 the_info->si_signo = signo; the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; 40007270: 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; 40007274: f0 24 80 00 st %i0, [ %l2 ] the_info->si_code = SI_USER; 40007278: 82 10 20 01 mov 1, %g1 4000727c: c2 24 a0 04 st %g1, [ %l2 + 4 ] 40007280: 81 c7 e0 08 ret 40007284: 81 e8 00 00 restore rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007288: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 4000728c: 84 10 3f ff mov -1, %g2 40007290: 82 00 60 01 inc %g1 40007294: c4 24 80 00 st %g2, [ %l2 ] 40007298: c2 24 61 90 st %g1, [ %l1 + 0x190 ] _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; the_thread->Wait.return_code = EINTR; 4000729c: 82 10 20 04 mov 4, %g1 400072a0: c2 26 a0 34 st %g1, [ %i2 + 0x34 ] the_thread->Wait.option = *set; 400072a4: c2 06 00 00 ld [ %i0 ], %g1 the_thread->Wait.return_argument = the_info; 400072a8: 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; 400072ac: c2 26 a0 30 st %g1, [ %i2 + 0x30 ] } the_info->si_signo = -1; _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 400072b0: 21 10 00 7b sethi %hi(0x4001ec00), %l0 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 400072b4: 82 10 20 01 mov 1, %g1 400072b8: a0 14 21 b0 or %l0, 0x1b0, %l0 400072bc: e0 26 a0 44 st %l0, [ %i2 + 0x44 ] 400072c0: 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 ); 400072c4: 7f ff ed 3c call 400027b4 400072c8: 01 00 00 00 nop _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 400072cc: 90 10 00 10 mov %l0, %o0 400072d0: 92 10 00 13 mov %l3, %o1 400072d4: 15 10 00 2e sethi %hi(0x4000b800), %o2 400072d8: 40 00 10 be call 4000b5d0 <_Thread_queue_Enqueue_with_handler> 400072dc: 94 12 a2 68 or %o2, 0x268, %o2 ! 4000ba68 <_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 ) 400072e0: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 400072e4: 82 00 7f ff add %g1, -1, %g1 400072e8: c2 24 61 90 st %g1, [ %l1 + 0x190 ] 400072ec: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 400072f0: 80 a0 60 00 cmp %g1, 0 400072f4: 32 80 00 05 bne,a 40007308 400072f8: d2 04 80 00 ld [ %l2 ], %o1 <== NOT EXECUTED _Thread_Dispatch(); 400072fc: 40 00 0f 4d call 4000b030 <_Thread_Dispatch> 40007300: 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 ); 40007304: d2 04 80 00 ld [ %l2 ], %o1 40007308: 94 10 00 12 mov %l2, %o2 4000730c: 96 10 20 00 clr %o3 40007310: 98 10 20 00 clr %o4 40007314: 40 00 1d a4 call 4000e9a4 <_POSIX_signals_Clear_signals> 40007318: 90 10 00 19 mov %i1, %o0 errno = _Thread_Executing->Wait.return_code; 4000731c: 40 00 25 78 call 400108fc <__errno> 40007320: 01 00 00 00 nop 40007324: c2 05 22 6c ld [ %l4 + 0x26c ], %g1 40007328: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 4000732c: c2 22 00 00 st %g1, [ %o0 ] return the_info->si_signo; 40007330: f0 04 80 00 ld [ %l2 ], %i0 } 40007334: 81 c7 e0 08 ret 40007338: 81 e8 00 00 restore 40008f28 : int sigwait( const sigset_t *set, int *sig ) { 40008f28: 9d e3 bf 98 save %sp, -104, %sp int status; status = sigtimedwait( set, NULL, NULL ); 40008f2c: 92 10 20 00 clr %o1 40008f30: 90 10 00 18 mov %i0, %o0 40008f34: 7f ff ff 86 call 40008d4c 40008f38: 94 10 20 00 clr %o2 if ( status != -1 ) { 40008f3c: 80 a2 3f ff cmp %o0, -1 40008f40: 02 80 00 07 be 40008f5c 40008f44: 80 a6 60 00 cmp %i1, 0 if ( sig ) 40008f48: 02 80 00 03 be 40008f54 40008f4c: b0 10 20 00 clr %i0 *sig = status; 40008f50: d0 26 40 00 st %o0, [ %i1 ] 40008f54: 81 c7 e0 08 ret 40008f58: 81 e8 00 00 restore return 0; } return errno; 40008f5c: 40 00 25 af call 40012618 <__errno> <== NOT EXECUTED 40008f60: 01 00 00 00 nop <== NOT EXECUTED 40008f64: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED } 40008f68: 81 c7 e0 08 ret <== NOT EXECUTED 40008f6c: 81 e8 00 00 restore <== NOT EXECUTED 4000c03c : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 4000c03c: 9d e3 bf 98 save %sp, -104, %sp POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 4000c040: 80 a6 20 01 cmp %i0, 1 4000c044: 12 80 00 11 bne 4000c088 4000c048: 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) { 4000c04c: 02 80 00 13 be 4000c098 4000c050: 05 10 00 97 sethi %hi(0x40025c00), %g2 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 4000c054: c2 06 40 00 ld [ %i1 ], %g1 4000c058: 82 00 7f ff add %g1, -1, %g1 4000c05c: 80 a0 60 01 cmp %g1, 1 4000c060: 18 80 00 0a bgu 4000c088 4000c064: 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 ) 4000c068: c2 06 60 04 ld [ %i1 + 4 ], %g1 4000c06c: 80 a0 60 00 cmp %g1, 0 4000c070: 02 80 00 06 be 4000c088 4000c074: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 4000c078: 82 00 7f ff add %g1, -1, %g1 4000c07c: 80 a0 60 1f cmp %g1, 0x1f 4000c080: 08 80 00 06 bleu 4000c098 4000c084: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); 4000c088: 40 00 28 3a call 40016170 <__errno> <== NOT EXECUTED 4000c08c: 01 00 00 00 nop <== NOT EXECUTED 4000c090: 10 80 00 10 b 4000c0d0 <== NOT EXECUTED 4000c094: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000c098: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 4000c09c: 82 00 60 01 inc %g1 4000c0a0: c2 20 a0 40 st %g1, [ %g2 + 0x40 ] * 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 ); 4000c0a4: 21 10 00 98 sethi %hi(0x40026000), %l0 4000c0a8: 40 00 0a b7 call 4000eb84 <_Objects_Allocate> 4000c0ac: 90 14 20 0c or %l0, 0xc, %o0 ! 4002600c <_POSIX_Timer_Information> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 4000c0b0: b0 92 20 00 orcc %o0, 0, %i0 4000c0b4: 12 80 00 0a bne 4000c0dc 4000c0b8: 82 10 20 02 mov 2, %g1 _Thread_Enable_dispatch(); 4000c0bc: 7f ff fe d1 call 4000bc00 <_Thread_Enable_dispatch> <== NOT EXECUTED 4000c0c0: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EAGAIN ); 4000c0c4: 40 00 28 2b call 40016170 <__errno> <== NOT EXECUTED 4000c0c8: 01 00 00 00 nop <== NOT EXECUTED 4000c0cc: 82 10 20 0b mov 0xb, %g1 ! b <== NOT EXECUTED 4000c0d0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000c0d4: 81 c7 e0 08 ret <== NOT EXECUTED 4000c0d8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 4000c0dc: c2 2e 20 3c stb %g1, [ %i0 + 0x3c ] ptimer->thread_id = _Thread_Executing->Object.id; 4000c0e0: 03 10 00 97 sethi %hi(0x40025c00), %g1 4000c0e4: c2 00 61 1c ld [ %g1 + 0x11c ], %g1 ! 40025d1c <_Thread_Executing> if ( evp != NULL ) { 4000c0e8: 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; 4000c0ec: c2 00 60 08 ld [ %g1 + 8 ], %g1 if ( evp != NULL ) { 4000c0f0: 02 80 00 08 be 4000c110 4000c0f4: c2 26 20 38 st %g1, [ %i0 + 0x38 ] ptimer->inf.sigev_notify = evp->sigev_notify; ptimer->inf.sigev_signo = evp->sigev_signo; ptimer->inf.sigev_value = evp->sigev_value; 4000c0f8: 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; 4000c0fc: c4 06 40 00 ld [ %i1 ], %g2 ptimer->inf.sigev_signo = evp->sigev_signo; 4000c100: 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; 4000c104: c4 26 20 40 st %g2, [ %i0 + 0x40 ] ptimer->inf.sigev_signo = evp->sigev_signo; 4000c108: c6 26 20 44 st %g3, [ %i0 + 0x44 ] ptimer->inf.sigev_value = evp->sigev_value; 4000c10c: c2 26 20 48 st %g1, [ %i0 + 0x48 ] ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000c110: c2 06 20 08 ld [ %i0 + 8 ], %g1 4000c114: 94 10 00 18 mov %i0, %o2 4000c118: 90 14 20 0c or %l0, 0xc, %o0 } ptimer->overrun = 0; 4000c11c: c0 26 20 68 clr [ %i0 + 0x68 ] ptimer->timer_data.it_value.tv_sec = 0; 4000c120: c0 26 20 5c clr [ %i0 + 0x5c ] ptimer->timer_data.it_value.tv_nsec = 0; 4000c124: c0 26 20 60 clr [ %i0 + 0x60 ] ptimer->timer_data.it_interval.tv_sec = 0; 4000c128: c0 26 20 54 clr [ %i0 + 0x54 ] ptimer->timer_data.it_interval.tv_nsec = 0; 4000c12c: c0 26 20 58 clr [ %i0 + 0x58 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4000c130: c0 26 20 18 clr [ %i0 + 0x18 ] the_watchdog->routine = routine; 4000c134: c0 26 20 2c clr [ %i0 + 0x2c ] the_watchdog->id = id; 4000c138: c0 26 20 30 clr [ %i0 + 0x30 ] the_watchdog->user_data = user_data; 4000c13c: c0 26 20 34 clr [ %i0 + 0x34 ] 4000c140: 13 00 00 3f sethi %hi(0xfc00), %o1 4000c144: 92 12 63 ff or %o1, 0x3ff, %o1 ! ffff 4000c148: 7f ff fe 9c call 4000bbb8 <_Objects_Set_local_object> 4000c14c: 92 08 40 09 and %g1, %o1, %o1 _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open(&_POSIX_Timer_Information, &ptimer->Object, (Objects_Name) 0); *timerid = ptimer->Object.id; 4000c150: c2 06 20 08 ld [ %i0 + 8 ], %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; 4000c154: c0 26 20 0c clr [ %i0 + 0xc ] 4000c158: c2 26 80 00 st %g1, [ %i2 ] _Thread_Enable_dispatch(); 4000c15c: 7f ff fe a9 call 4000bc00 <_Thread_Enable_dispatch> 4000c160: b0 10 20 00 clr %i0 return 0; } 4000c164: 81 c7 e0 08 ret 4000c168: 81 e8 00 00 restore 4000bd08 : */ int timer_delete( timer_t timerid ) { 4000bd08: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED * because rtems_timer_delete stops the timer before deleting it. */ POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); 4000bd0c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000bd10: 7f ff ff b4 call 4000bbe0 <_POSIX_Timer_Get> <== NOT EXECUTED 4000bd14: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED switch ( location ) { 4000bd18: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4000bd1c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bd20: 02 80 00 0b be 4000bd4c <== NOT EXECUTED 4000bd24: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 4000bd28: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000bd2c: 18 80 00 06 bgu 4000bd44 <== NOT EXECUTED 4000bd30: 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 ); 4000bd34: 40 00 29 0f call 40016170 <__errno> <== NOT EXECUTED 4000bd38: 01 00 00 00 nop <== NOT EXECUTED 4000bd3c: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 4000bd40: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000bd44: 81 c7 e0 08 ret <== NOT EXECUTED 4000bd48: 81 e8 00 00 restore <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000bd4c: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED 4000bd50: 94 10 20 00 clr %o2 <== NOT EXECUTED 4000bd54: 21 10 00 98 sethi %hi(0x40026000), %l0 <== NOT EXECUTED 4000bd58: 13 00 00 3f sethi %hi(0xfc00), %o1 <== NOT EXECUTED 4000bd5c: 90 14 20 0c or %l0, 0xc, %o0 <== NOT EXECUTED 4000bd60: 92 12 63 ff or %o1, 0x3ff, %o1 <== NOT EXECUTED 4000bd64: 7f ff ff 95 call 4000bbb8 <_Objects_Set_local_object> <== NOT EXECUTED 4000bd68: 92 08 40 09 and %g1, %o1, %o1 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Timer_Information, &ptimer->Object ); ptimer->state = POSIX_TIMER_STATE_FREE; 4000bd6c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 4000bd70: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED 4000bd74: c2 2e 20 3c stb %g1, [ %i0 + 0x3c ] <== NOT EXECUTED (void) _Watchdog_Remove( &ptimer->Timer ); 4000bd78: 40 00 16 fe call 40011970 <_Watchdog_Remove> <== NOT EXECUTED 4000bd7c: 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 ); 4000bd80: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000bd84: 90 14 20 0c or %l0, 0xc, %o0 <== NOT EXECUTED 4000bd88: 40 00 0c 81 call 4000ef8c <_Objects_Free> <== NOT EXECUTED 4000bd8c: b0 10 20 00 clr %i0 <== NOT EXECUTED _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); 4000bd90: 7f ff ff 9c call 4000bc00 <_Thread_Enable_dispatch> <== NOT EXECUTED 4000bd94: 01 00 00 00 nop <== NOT EXECUTED return 0; } return -1; /* unreached - only to remove warnings */ } 4000bd98: 81 c7 e0 08 ret <== NOT EXECUTED 4000bd9c: 81 e8 00 00 restore <== NOT EXECUTED 4000bc34 : */ int timer_getoverrun( timer_t timerid ) { 4000bc34: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED int overrun; POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); 4000bc38: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000bc3c: 7f ff ff e9 call 4000bbe0 <_POSIX_Timer_Get> <== NOT EXECUTED 4000bc40: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED switch ( location ) { 4000bc44: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4000bc48: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bc4c: 22 80 00 0b be,a 4000bc78 <== NOT EXECUTED 4000bc50: f0 02 20 68 ld [ %o0 + 0x68 ], %i0 <== NOT EXECUTED 4000bc54: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000bc58: 18 80 00 06 bgu 4000bc70 <== NOT EXECUTED 4000bc5c: 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 ); 4000bc60: 40 00 29 44 call 40016170 <__errno> <== NOT EXECUTED 4000bc64: 01 00 00 00 nop <== NOT EXECUTED 4000bc68: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 4000bc6c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000bc70: 81 c7 e0 08 ret <== NOT EXECUTED 4000bc74: 81 e8 00 00 restore <== NOT EXECUTED case OBJECTS_LOCAL: overrun = ptimer->overrun; ptimer->overrun = 0; _Thread_Enable_dispatch(); 4000bc78: 7f ff ff e2 call 4000bc00 <_Thread_Enable_dispatch> <== NOT EXECUTED 4000bc7c: c0 22 20 68 clr [ %o0 + 0x68 ] <== NOT EXECUTED return overrun; } return -1; /* unreached - only to remove warnings */ } 4000bc80: 81 c7 e0 08 ret <== NOT EXECUTED 4000bc84: 81 e8 00 00 restore <== NOT EXECUTED 4000bc88 : int timer_gettime( timer_t timerid, struct itimerspec *value ) { 4000bc88: 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 ); 4000bc8c: a0 07 bf ec add %fp, -20, %l0 <== NOT EXECUTED 4000bc90: 40 00 0a 02 call 4000e498 <_TOD_Get> <== NOT EXECUTED 4000bc94: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED ptimer = _POSIX_Timer_Get( timerid, &location ); 4000bc98: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000bc9c: 7f ff ff d1 call 4000bbe0 <_POSIX_Timer_Get> <== NOT EXECUTED 4000bca0: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED switch ( location ) { 4000bca4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4000bca8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000bcac: 02 80 00 0b be 4000bcd8 <== NOT EXECUTED 4000bcb0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 4000bcb4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000bcb8: 18 80 00 06 bgu 4000bcd0 <== NOT EXECUTED 4000bcbc: 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 ); 4000bcc0: 40 00 29 2c call 40016170 <__errno> <== NOT EXECUTED 4000bcc4: 01 00 00 00 nop <== NOT EXECUTED 4000bcc8: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 4000bccc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000bcd0: 81 c7 e0 08 ret <== NOT EXECUTED 4000bcd4: 81 e8 00 00 restore <== NOT EXECUTED case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ _Timespec_Subtract( 4000bcd8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 4000bcdc: 90 02 20 5c add %o0, 0x5c, %o0 <== NOT EXECUTED 4000bce0: 40 00 15 e7 call 4001147c <_Timespec_Subtract> <== NOT EXECUTED 4000bce4: 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; 4000bce8: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 4000bcec: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED 4000bcf0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); 4000bcf4: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000bcf8: 7f ff ff c2 call 4000bc00 <_Thread_Enable_dispatch> <== NOT EXECUTED 4000bcfc: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED return 0; } return -1; /* unreached - only to remove warnings */ } 4000bd00: 81 c7 e0 08 ret <== NOT EXECUTED 4000bd04: 81 e8 00 00 restore <== NOT EXECUTED 4000be0c : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 4000be0c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Timer_Control *ptimer; Objects_Locations location; boolean activated; if ( value == NULL ) { 4000be10: 80 a6 a0 00 cmp %i2, 0 4000be14: 02 80 00 0c be 4000be44 4000be18: 90 10 00 18 mov %i0, %o0 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 ) || 4000be1c: c4 06 a0 0c ld [ %i2 + 0xc ], %g2 4000be20: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 4000be24: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 4000be28: 80 a0 80 01 cmp %g2, %g1 4000be2c: 18 80 00 06 bgu 4000be44 4000be30: 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 ) { 4000be34: 02 80 00 0a be 4000be5c 4000be38: 80 a6 60 00 cmp %i1, 0 4000be3c: 02 80 00 08 be 4000be5c 4000be40: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); 4000be44: 40 00 28 cb call 40016170 <__errno> <== NOT EXECUTED 4000be48: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 4000be4c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 4000be50: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 4000be54: 81 c7 e0 08 ret <== NOT EXECUTED 4000be58: 81 e8 00 00 restore <== NOT EXECUTED /* If the function reaches this point, then it will be necessary to do * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); 4000be5c: 7f ff ff 61 call 4000bbe0 <_POSIX_Timer_Get> 4000be60: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 4000be64: c2 07 bf f4 ld [ %fp + -12 ], %g1 /* If the function reaches this point, then it will be necessary to do * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); 4000be68: a0 10 00 08 mov %o0, %l0 switch ( location ) { 4000be6c: 80 a0 60 00 cmp %g1, 0 4000be70: 12 bf ff f9 bne 4000be54 4000be74: 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 ) { 4000be78: c2 06 a0 08 ld [ %i2 + 8 ], %g1 4000be7c: 80 a0 60 00 cmp %g1, 0 4000be80: 12 80 00 15 bne 4000bed4 4000be84: 80 a6 60 00 cmp %i1, 0 4000be88: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 <== NOT EXECUTED 4000be8c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000be90: 12 80 00 11 bne 4000bed4 <== NOT EXECUTED 4000be94: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 4000be98: 40 00 16 b6 call 40011970 <_Watchdog_Remove> <== NOT EXECUTED 4000be9c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED /* The old data of the timer are returned */ if ( ovalue ) 4000bea0: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 4000bea4: 02 80 00 05 be 4000beb8 <== NOT EXECUTED 4000bea8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED *ovalue = ptimer->timer_data; 4000beac: 92 04 20 54 add %l0, 0x54, %o1 <== NOT EXECUTED 4000beb0: 40 00 2a 96 call 40016908 <== NOT EXECUTED 4000beb4: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED /* The new data are set */ ptimer->timer_data = *value; 4000beb8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4000bebc: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED 4000bec0: 40 00 2a 92 call 40016908 <== NOT EXECUTED 4000bec4: 90 04 20 54 add %l0, 0x54, %o0 <== NOT EXECUTED /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 4000bec8: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED 4000becc: 10 80 00 31 b 4000bf90 <== NOT EXECUTED 4000bed0: c2 2c 20 3c stb %g1, [ %l0 + 0x3c ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* absolute or relative? */ switch (flags) { 4000bed4: 02 80 00 15 be 4000bf28 4000bed8: 80 a6 60 04 cmp %i1, 4 4000bedc: 12 80 00 31 bne 4000bfa0 <== NOT EXECUTED 4000bee0: 11 10 00 97 sethi %hi(0x40025c00), %o0 <== NOT EXECUTED case TIMER_ABSTIME: /* The fire time is absolute: use "rtems_time_fire_when" */ /* First, it converts from struct itimerspec to rtems_time_of_day */ _Watchdog_Initialize( 4000bee4: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4000bee8: c0 24 20 18 clr [ %l0 + 0x18 ] <== NOT EXECUTED the_watchdog->routine = routine; the_watchdog->id = id; 4000beec: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000bef0: 03 10 00 97 sethi %hi(0x40025c00), %g1 <== NOT EXECUTED 4000bef4: c4 00 60 f8 ld [ %g1 + 0xf8 ], %g2 ! 40025cf8 <_TOD_Now> <== NOT EXECUTED 4000bef8: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 4000befc: e0 24 20 34 st %l0, [ %l0 + 0x34 ] <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000bf00: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 4000bf04: 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; 4000bf08: 03 10 00 2f sethi %hi(0x4000bc00), %g1 <== NOT EXECUTED 4000bf0c: 82 10 63 c0 or %g1, 0x3c0, %g1 ! 4000bfc0 <_POSIX_Timer_TSR> <== NOT EXECUTED 4000bf10: c2 24 20 2c st %g1, [ %l0 + 0x2c ] <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 4000bf14: 90 12 21 30 or %o0, 0x130, %o0 <== NOT EXECUTED 4000bf18: 40 00 16 3e call 40011810 <_Watchdog_Insert> <== NOT EXECUTED 4000bf1c: 92 04 20 10 add %l0, 0x10, %o1 <== NOT EXECUTED return 0; } /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) 4000bf20: 10 80 00 0f b 4000bf5c <== NOT EXECUTED 4000bf24: 80 a6 e0 00 cmp %i3, 0 <== 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 ); 4000bf28: 40 00 15 69 call 400114cc <_Timespec_To_ticks> 4000bf2c: 90 06 a0 08 add %i2, 8, %o0 activated = _Watchdog_Insert_ticks_helper( 4000bf30: 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 ); 4000bf34: 92 10 00 08 mov %o0, %o1 4000bf38: d0 24 20 64 st %o0, [ %l0 + 0x64 ] activated = _Watchdog_Insert_ticks_helper( 4000bf3c: 17 10 00 2f sethi %hi(0x4000bc00), %o3 4000bf40: 90 04 20 10 add %l0, 0x10, %o0 4000bf44: 96 12 e3 c0 or %o3, 0x3c0, %o3 4000bf48: 7f ff ff 96 call 4000bda0 <_Watchdog_Insert_ticks_helper> 4000bf4c: 98 10 00 10 mov %l0, %o4 ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 4000bf50: 80 a2 20 00 cmp %o0, 0 4000bf54: 02 80 00 0f be 4000bf90 4000bf58: 80 a6 e0 00 cmp %i3, 0 return 0; } /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) 4000bf5c: 02 80 00 05 be 4000bf70 4000bf60: 90 10 00 1b mov %i3, %o0 *ovalue = ptimer->timer_data; 4000bf64: 92 04 20 54 add %l0, 0x54, %o1 <== NOT EXECUTED 4000bf68: 40 00 2a 68 call 40016908 <== NOT EXECUTED 4000bf6c: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED ptimer->timer_data = *value; 4000bf70: 92 10 00 1a mov %i2, %o1 4000bf74: 94 10 20 10 mov 0x10, %o2 4000bf78: 40 00 2a 64 call 40016908 4000bf7c: 90 04 20 54 add %l0, 0x54, %o0 /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 4000bf80: 82 10 20 03 mov 3, %g1 _TOD_Get( &ptimer->time ); 4000bf84: 90 04 20 6c add %l0, 0x6c, %o0 4000bf88: 40 00 09 44 call 4000e498 <_TOD_Get> 4000bf8c: c2 2c 20 3c stb %g1, [ %l0 + 0x3c ] _Thread_Enable_dispatch(); 4000bf90: 7f ff ff 1c call 4000bc00 <_Thread_Enable_dispatch> 4000bf94: b0 10 20 00 clr %i0 4000bf98: 81 c7 e0 08 ret 4000bf9c: 81 e8 00 00 restore return 0; } _Thread_Enable_dispatch(); 4000bfa0: 7f ff ff 18 call 4000bc00 <_Thread_Enable_dispatch> <== NOT EXECUTED 4000bfa4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 4000bfa8: 40 00 28 72 call 40016170 <__errno> <== NOT EXECUTED 4000bfac: 01 00 00 00 nop <== NOT EXECUTED 4000bfb0: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 4000bfb4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return -1; /* unreached - only to remove warnings */ } 4000bfb8: 81 c7 e0 08 ret <== NOT EXECUTED 4000bfbc: 81 e8 00 00 restore <== NOT EXECUTED 40009fe0 : int usleep( useconds_t useconds ) { 40009fe0: 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; 40009fe4: 21 00 03 d0 sethi %hi(0xf4000), %l0 <== NOT EXECUTED 40009fe8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009fec: 7f ff dd e3 call 40001778 <.udiv> <== NOT EXECUTED 40009ff0: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 40009ff4: 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; 40009ff8: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 40009ffc: 40 00 5b 6b call 40020da8 <.urem> <== NOT EXECUTED 4000a000: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000a004: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED 4000a008: 83 2a 20 07 sll %o0, 7, %g1 <== NOT EXECUTED 4000a00c: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 4000a010: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 4000a014: 83 28 60 03 sll %g1, 3, %g1 <== NOT EXECUTED nanosleep( &tp, &tm ); 4000a018: 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; 4000a01c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED nanosleep( &tp, &tm ); 4000a020: 40 00 24 ac call 400132d0 <== NOT EXECUTED 4000a024: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED remaining = tm.tv_sec * TOD_MICROSECONDS_PER_SECOND; 4000a028: c4 07 bf e8 ld [ %fp + -24 ], %g2 <== NOT EXECUTED 4000a02c: d0 07 bf ec ld [ %fp + -20 ], %o0 <== NOT EXECUTED 4000a030: 87 28 a0 03 sll %g2, 3, %g3 <== NOT EXECUTED 4000a034: 83 28 a0 08 sll %g2, 8, %g1 <== NOT EXECUTED 4000a038: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 4000a03c: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED 4000a040: b1 28 60 06 sll %g1, 6, %i0 <== NOT EXECUTED 4000a044: b0 26 00 01 sub %i0, %g1, %i0 <== NOT EXECUTED 4000a048: 7f ff dd ce call 40001780 <.div> <== NOT EXECUTED 4000a04c: b0 06 00 02 add %i0, %g2, %i0 <== NOT EXECUTED 4000a050: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED remaining += tm.tv_nsec / 1000; return remaining; /* seconds remaining */ } 4000a054: 81 c7 e0 08 ret <== NOT EXECUTED 4000a058: 91 ea 00 18 restore %o0, %i0, %o0 <== NOT EXECUTED