02021560 : assert( 0 ); return 0; } int POSIX_BOTTOM_REACHED() { 2021560: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 2021564: 92 10 20 22 mov 0x22, %o1 <== NOT EXECUTED 2021568: 11 00 80 95 sethi %hi(0x2025400), %o0 <== NOT EXECUTED 202156c: 15 00 80 8e sethi %hi(0x2023800), %o2 <== NOT EXECUTED 2021570: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 2021574: 94 12 a3 b0 or %o2, 0x3b0, %o2 <== NOT EXECUTED 2021578: 7f ff 92 8f call 2005fb4 <__assert> <== NOT EXECUTED 202157c: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 2021580: 81 c7 e0 08 ret <== NOT EXECUTED 2021584: 81 e8 00 00 restore <== NOT EXECUTED 02021588 : */ #include int POSIX_MP_NOT_IMPLEMENTED() { 2021588: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 202158c: 92 10 20 1c mov 0x1c, %o1 <== NOT EXECUTED 2021590: 11 00 80 95 sethi %hi(0x2025400), %o0 <== NOT EXECUTED 2021594: 15 00 80 8e sethi %hi(0x2023800), %o2 <== NOT EXECUTED 2021598: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 202159c: 94 12 a3 b0 or %o2, 0x3b0, %o2 <== NOT EXECUTED 20215a0: 7f ff 92 85 call 2005fb4 <__assert> <== NOT EXECUTED 20215a4: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 20215a8: 81 c7 e0 08 ret <== NOT EXECUTED 20215ac: 81 e8 00 00 restore <== NOT EXECUTED 02021538 : assert( 0 ); return 0; } int POSIX_NOT_IMPLEMENTED() { 2021538: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 202153c: 92 10 20 28 mov 0x28, %o1 <== NOT EXECUTED 2021540: 11 00 80 95 sethi %hi(0x2025400), %o0 <== NOT EXECUTED 2021544: 15 00 80 8e sethi %hi(0x2023800), %o2 <== NOT EXECUTED 2021548: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 202154c: 94 12 a3 b0 or %o2, 0x3b0, %o2 <== NOT EXECUTED 2021550: 7f ff 92 99 call 2005fb4 <__assert> <== NOT EXECUTED 2021554: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 2021558: 81 c7 e0 08 ret <== NOT EXECUTED 202155c: 81 e8 00 00 restore <== NOT EXECUTED 02006778 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 2006778: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 200677c: 03 00 80 63 sethi %hi(0x2018c00), %g1 2006780: e0 00 61 80 ld [ %g1 + 0x180 ], %l0 ! 2018d80 <_API_extensions_List> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2006784: 03 00 80 63 sethi %hi(0x2018c00), %g1 2006788: 10 80 00 08 b 20067a8 <_API_extensions_Run_postdriver+0x30> 200678c: a2 10 61 84 or %g1, 0x184, %l1 ! 2018d84 <_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 ) 2006790: 80 a0 60 00 cmp %g1, 0 2006794: 22 80 00 05 be,a 20067a8 <_API_extensions_Run_postdriver+0x30> 2006798: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postdriver_hook)(); 200679c: 9f c0 40 00 call %g1 20067a0: 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 ) { 20067a4: 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 ) ; 20067a8: 80 a4 00 11 cmp %l0, %l1 20067ac: 32 bf ff f9 bne,a 2006790 <_API_extensions_Run_postdriver+0x18> 20067b0: c2 04 20 0c ld [ %l0 + 0xc ], %g1 the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 20067b4: 81 c7 e0 08 ret 20067b8: 81 e8 00 00 restore 0200681c <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 200681c: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 2006820: 03 00 80 63 sethi %hi(0x2018c00), %g1 2006824: e0 00 61 80 ld [ %g1 + 0x180 ], %l0 ! 2018d80 <_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 ); 2006828: 23 00 80 62 sethi %hi(0x2018800), %l1 200682c: 03 00 80 63 sethi %hi(0x2018c00), %g1 2006830: 10 80 00 08 b 2006850 <_API_extensions_Run_postswitch+0x34> 2006834: a4 10 61 84 or %g1, 0x184, %l2 ! 2018d84 <_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 ) 2006838: 80 a0 60 00 cmp %g1, 0 200683c: 22 80 00 05 be,a 2006850 <_API_extensions_Run_postswitch+0x34> 2006840: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 2006844: 9f c0 40 00 call %g1 2006848: d0 04 63 d0 ld [ %l1 + 0x3d0 ], %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 ) { 200684c: 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 ) ; 2006850: 80 a4 00 12 cmp %l0, %l2 2006854: 32 bf ff f9 bne,a 2006838 <_API_extensions_Run_postswitch+0x1c> 2006858: 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 ); } } 200685c: 81 c7 e0 08 ret 2006860: 81 e8 00 00 restore 020067d8 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 20067d8: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 20067dc: 03 00 80 63 sethi %hi(0x2018c00), %g1 20067e0: e0 00 61 80 ld [ %g1 + 0x180 ], %l0 ! 2018d80 <_API_extensions_List> 20067e4: 03 00 80 63 sethi %hi(0x2018c00), %g1 20067e8: 10 80 00 08 b 2006808 <_API_extensions_Run_predriver+0x30> 20067ec: a2 10 61 84 or %g1, 0x184, %l1 ! 2018d84 <_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 ) 20067f0: 80 a0 60 00 cmp %g1, 0 20067f4: 22 80 00 05 be,a 2006808 <_API_extensions_Run_predriver+0x30> 20067f8: e0 04 00 00 ld [ %l0 ], %l0 (*the_extension->predriver_hook)(); 20067fc: 9f c0 40 00 call %g1 <== NOT EXECUTED 2006800: 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 ) { 2006804: 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 ) ; 2006808: 80 a4 00 11 cmp %l0, %l1 200680c: 32 bf ff f9 bne,a 20067f0 <_API_extensions_Run_predriver+0x18> 2006810: c2 04 20 08 ld [ %l0 + 8 ], %g1 the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 2006814: 81 c7 e0 08 ret 2006818: 81 e8 00 00 restore 02008af4 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 2008af4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing = _Thread_Executing; 2008af8: 03 00 80 6d sethi %hi(0x201b400), %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 ); 2008afc: 7f ff e8 43 call 2002c08 2008b00: e0 00 62 c0 ld [ %g1 + 0x2c0 ], %l0 ! 201b6c0 <_Thread_Executing> 2008b04: 84 10 00 08 mov %o0, %g2 switch ( the_rwlock->current_state ) { 2008b08: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 2008b0c: 80 a0 60 01 cmp %g1, 1 2008b10: 22 80 00 0e be,a 2008b48 <_CORE_RWLock_Release+0x54> 2008b14: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2008b18: 0a 80 00 06 bcs 2008b30 <_CORE_RWLock_Release+0x3c> 2008b1c: 80 a0 60 02 cmp %g1, 2 2008b20: 32 80 00 13 bne,a 2008b6c <_CORE_RWLock_Release+0x78> 2008b24: 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; 2008b28: 10 80 00 10 b 2008b68 <_CORE_RWLock_Release+0x74> 2008b2c: c0 24 20 34 clr [ %l0 + 0x34 ] */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { case CORE_RWLOCK_UNLOCKED: _ISR_Enable( level ); 2008b30: 7f ff e8 3a call 2002c18 <== NOT EXECUTED 2008b34: b0 10 20 00 clr %i0 <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 2008b38: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2008b3c: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED 2008b40: 81 c7 e0 08 ret <== NOT EXECUTED 2008b44: 81 e8 00 00 restore <== NOT EXECUTED return CORE_RWLOCK_SUCCESSFUL; case CORE_RWLOCK_LOCKED_FOR_READING: the_rwlock->number_of_readers -= 1; 2008b48: 82 00 7f ff add %g1, -1, %g1 if ( the_rwlock->number_of_readers != 0 ) { 2008b4c: 80 a0 60 00 cmp %g1, 0 2008b50: 02 80 00 05 be 2008b64 <_CORE_RWLock_Release+0x70> 2008b54: c2 26 20 48 st %g1, [ %i0 + 0x48 ] /* must be unlocked again */ _ISR_Enable( level ); 2008b58: 7f ff e8 30 call 2002c18 2008b5c: b0 10 20 00 clr %i0 2008b60: 30 80 00 25 b,a 2008bf4 <_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; 2008b64: 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; 2008b68: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 2008b6c: 7f ff e8 2b call 2002c18 2008b70: 90 10 00 02 mov %g2, %o0 next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 2008b74: 40 00 09 76 call 200b14c <_Thread_queue_Dequeue> 2008b78: 90 10 00 18 mov %i0, %o0 if ( next ) { 2008b7c: 80 a2 20 00 cmp %o0, 0 2008b80: 22 80 00 1d be,a 2008bf4 <_CORE_RWLock_Release+0x100> 2008b84: b0 10 20 00 clr %i0 if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 2008b88: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 2008b8c: 80 a0 60 01 cmp %g1, 1 2008b90: 32 80 00 05 bne,a 2008ba4 <_CORE_RWLock_Release+0xb0> 2008b94: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 2008b98: 82 10 20 02 mov 2, %g1 2008b9c: 10 80 00 15 b 2008bf0 <_CORE_RWLock_Release+0xfc> 2008ba0: 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; 2008ba4: 84 10 20 01 mov 1, %g2 } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 2008ba8: 82 00 60 01 inc %g1 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 2008bac: c4 26 20 44 st %g2, [ %i0 + 0x44 ] } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 2008bb0: 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 ); 2008bb4: 40 00 0a fa call 200b79c <_Thread_queue_First> 2008bb8: 90 10 00 18 mov %i0, %o0 if ( !next || 2008bbc: 80 a2 20 00 cmp %o0, 0 2008bc0: 22 80 00 0d be,a 2008bf4 <_CORE_RWLock_Release+0x100> 2008bc4: b0 10 20 00 clr %i0 2008bc8: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 2008bcc: 80 a0 60 01 cmp %g1, 1 2008bd0: 02 80 00 08 be 2008bf0 <_CORE_RWLock_Release+0xfc> 2008bd4: 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; 2008bd8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 2008bdc: 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; 2008be0: 82 00 60 01 inc %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 2008be4: 40 00 0a 81 call 200b5e8 <_Thread_queue_Extract> 2008be8: c2 26 20 48 st %g1, [ %i0 + 0x48 ] 2008bec: 30 bf ff f2 b,a 2008bb4 <_CORE_RWLock_Release+0xc0> } } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 2008bf0: b0 10 20 00 clr %i0 2008bf4: 81 c7 e0 08 ret 2008bf8: 81 e8 00 00 restore 02008bfc <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 2008bfc: 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 ) ) { 2008c00: 92 96 20 00 orcc %i0, 0, %o1 2008c04: 12 80 00 0a bne 2008c2c <_CORE_RWLock_Timeout+0x30> 2008c08: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008c0c: 03 00 80 6d sethi %hi(0x201b400), %g1 <== NOT EXECUTED 2008c10: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008c14: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2008c18: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] <== 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; 2008c1c: 03 00 80 6d sethi %hi(0x201b400), %g1 <== NOT EXECUTED 2008c20: d2 00 62 c0 ld [ %g1 + 0x2c0 ], %o1 ! 201b6c0 <_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; 2008c24: 10 80 00 18 b 2008c84 <_CORE_RWLock_Timeout+0x88> <== NOT EXECUTED 2008c28: 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); 2008c2c: 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 ) { 2008c30: 80 a0 a0 04 cmp %g2, 4 2008c34: 18 80 00 0e bgu 2008c6c <_CORE_RWLock_Timeout+0x70> 2008c38: 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 :) */ 2008c3c: 83 32 60 1b srl %o1, 0x1b, %g1 2008c40: 80 a0 60 01 cmp %g1, 1 2008c44: 12 80 00 0a bne 2008c6c <_CORE_RWLock_Timeout+0x70> 2008c48: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2008c4c: 83 28 a0 02 sll %g2, 2, %g1 2008c50: 05 00 80 6d sethi %hi(0x201b400), %g2 2008c54: 84 10 a1 40 or %g2, 0x140, %g2 ! 201b540 <_Objects_Information_table> 2008c58: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2008c5c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2008c60: 80 a2 20 00 cmp %o0, 0 2008c64: 12 80 00 05 bne 2008c78 <_CORE_RWLock_Timeout+0x7c> 2008c68: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2008c6c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008c70: 10 80 00 05 b 2008c84 <_CORE_RWLock_Timeout+0x88> <== NOT EXECUTED 2008c74: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2008c78: 40 00 03 46 call 2009990 <_Objects_Get> 2008c7c: 94 07 bf f4 add %fp, -12, %o2 2008c80: 92 10 00 08 mov %o0, %o1 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2008c84: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008c88: 80 a0 60 00 cmp %g1, 0 2008c8c: 12 80 00 18 bne 2008cec <_CORE_RWLock_Timeout+0xf0> 2008c90: 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; 2008c94: 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 && 2008c98: c6 00 a0 30 ld [ %g2 + 0x30 ], %g3 2008c9c: 80 a0 e0 00 cmp %g3, 0 2008ca0: 02 80 00 0b be 2008ccc <_CORE_RWLock_Timeout+0xd0> 2008ca4: 03 00 80 6d sethi %hi(0x201b400), %g1 2008ca8: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> <== NOT EXECUTED 2008cac: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED 2008cb0: 32 80 00 08 bne,a 2008cd0 <_CORE_RWLock_Timeout+0xd4> <== NOT EXECUTED 2008cb4: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 2008cb8: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008cbc: 02 80 00 08 be 2008cdc <_CORE_RWLock_Timeout+0xe0> <== NOT EXECUTED 2008cc0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 2008cc4: 10 80 00 06 b 2008cdc <_CORE_RWLock_Timeout+0xe0> <== NOT EXECUTED 2008cc8: c2 20 a0 30 st %g1, [ %g2 + 0x30 ] <== NOT EXECUTED } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 2008ccc: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 2008cd0: d0 02 60 44 ld [ %o1 + 0x44 ], %o0 2008cd4: 40 00 0a 45 call 200b5e8 <_Thread_queue_Extract> 2008cd8: 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; 2008cdc: 05 00 80 6d sethi %hi(0x201b400), %g2 2008ce0: c2 00 a1 e0 ld [ %g2 + 0x1e0 ], %g1 ! 201b5e0 <_Thread_Dispatch_disable_level> 2008ce4: 82 00 7f ff add %g1, -1, %g1 2008ce8: c2 20 a1 e0 st %g1, [ %g2 + 0x1e0 ] 2008cec: 81 c7 e0 08 ret 2008cf0: 81 e8 00 00 restore 02013524 <_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 ) { 2013524: 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 ) { 2013528: 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 ) { 201352c: 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 ) { 2013530: 80 a6 80 01 cmp %i2, %g1 2013534: 18 80 00 17 bgu 2013590 <_CORE_message_queue_Broadcast+0x6c> 2013538: 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 ) { 201353c: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1 2013540: 80 a0 60 00 cmp %g1, 0 2013544: 02 80 00 0a be 201356c <_CORE_message_queue_Broadcast+0x48> 2013548: a2 10 20 00 clr %l1 *count = 0; 201354c: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED 2013550: 81 c7 e0 08 ret <== NOT EXECUTED 2013554: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 2013558: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 201355c: 40 00 23 64 call 201c2ec 2013560: a2 04 60 01 inc %l1 buffer, waitp->return_argument, size ); *(uint32_t *)the_thread->Wait.return_argument_1 = size; 2013564: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 2013568: 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))) { 201356c: 40 00 0b 7f call 2016368 <_Thread_queue_Dequeue> 2013570: 90 10 00 12 mov %l2, %o0 2013574: 92 10 00 19 mov %i1, %o1 2013578: a0 10 00 08 mov %o0, %l0 201357c: 80 a2 20 00 cmp %o0, 0 2013580: 12 bf ff f6 bne 2013558 <_CORE_message_queue_Broadcast+0x34> 2013584: 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; 2013588: e2 27 40 00 st %l1, [ %i5 ] 201358c: b0 10 20 00 clr %i0 return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 2013590: 81 c7 e0 08 ret 2013594: 81 e8 00 00 restore 02013a34 <_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 ) { 2013a34: 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; 2013a38: 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; 2013a3c: 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; 2013a40: 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; 2013a44: c0 26 20 60 clr [ %i0 + 0x60 ] the_message_queue->notify_argument = the_argument; 2013a48: 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)) { 2013a4c: 80 8e e0 03 btst 3, %i3 2013a50: 02 80 00 07 be 2013a6c <_CORE_message_queue_Initialize+0x38> 2013a54: a0 10 00 1b mov %i3, %l0 allocated_message_size += sizeof(uint32_t); 2013a58: 82 06 e0 04 add %i3, 4, %g1 allocated_message_size &= ~(sizeof(uint32_t) - 1); 2013a5c: a0 08 7f fc and %g1, -4, %l0 } if (allocated_message_size < maximum_message_size) 2013a60: 80 a4 00 1b cmp %l0, %i3 2013a64: 0a 80 00 24 bcs 2013af4 <_CORE_message_queue_Initialize+0xc0> 2013a68: 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 * 2013a6c: b6 04 20 14 add %l0, 0x14, %i3 2013a70: 92 10 00 1a mov %i2, %o1 2013a74: 40 00 29 f0 call 201e234 <.umul> 2013a78: 90 10 00 1b mov %i3, %o0 (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 2013a7c: 80 a2 00 10 cmp %o0, %l0 2013a80: 0a 80 00 1d bcs 2013af4 <_CORE_message_queue_Initialize+0xc0> 2013a84: 92 10 00 08 mov %o0, %o1 2013a88: 11 00 80 8e sethi %hi(0x2023800), %o0 2013a8c: 7f ff e7 51 call 200d7d0 <_Heap_Allocate> 2013a90: 90 12 21 9c or %o0, 0x19c, %o0 ! 202399c <_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) 2013a94: 80 a2 20 00 cmp %o0, 0 2013a98: 02 80 00 17 be 2013af4 <_CORE_message_queue_Initialize+0xc0> 2013a9c: d0 26 20 5c st %o0, [ %i0 + 0x5c ] /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 2013aa0: 92 10 00 08 mov %o0, %o1 2013aa4: 94 10 00 1a mov %i2, %o2 2013aa8: 90 06 20 68 add %i0, 0x68, %o0 2013aac: 7f ff ff 88 call 20138cc <_Chain_Initialize> 2013ab0: 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( 2013ab4: 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; 2013ab8: c0 26 20 54 clr [ %i0 + 0x54 ] 2013abc: 82 18 60 01 xor %g1, 1, %g1 2013ac0: 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); 2013ac4: 82 06 20 54 add %i0, 0x54, %g1 2013ac8: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2013acc: 82 06 20 50 add %i0, 0x50, %g1 2013ad0: 90 10 00 18 mov %i0, %o0 2013ad4: c2 26 20 58 st %g1, [ %i0 + 0x58 ] 2013ad8: 92 60 3f ff subx %g0, -1, %o1 2013adc: 94 10 20 80 mov 0x80, %o2 2013ae0: 96 10 20 06 mov 6, %o3 2013ae4: 7f ff f1 1b call 200ff50 <_Thread_queue_Initialize> 2013ae8: b0 10 20 01 mov 1, %i0 2013aec: 81 c7 e0 08 ret 2013af0: 81 e8 00 00 restore STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return TRUE; } 2013af4: 81 c7 e0 08 ret <== NOT EXECUTED 2013af8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 020135c0 <_CORE_message_queue_Seize>: void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 20135c0: 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; 20135c4: 03 00 80 9e sethi %hi(0x2027800), %g1 20135c8: e2 00 63 30 ld [ %g1 + 0x330 ], %l1 ! 2027b30 <_Thread_Executing> void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 20135cc: 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 ); 20135d0: 7f ff bb cd call 2002504 20135d4: c0 24 60 34 clr [ %l1 + 0x34 ] 20135d8: 86 10 00 08 mov %o0, %g3 if ( the_message_queue->number_of_pending_messages != 0 ) { 20135dc: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20135e0: 80 a0 60 00 cmp %g1, 0 20135e4: 02 80 00 2a be 201368c <_CORE_message_queue_Seize+0xcc> 20135e8: 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)); 20135ec: f2 06 20 50 ld [ %i0 + 0x50 ], %i1 the_message_queue->number_of_pending_messages -= 1; 20135f0: 82 00 7f ff add %g1, -1, %g1 20135f4: 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)) 20135f8: 82 06 20 54 add %i0, 0x54, %g1 20135fc: 80 a6 40 01 cmp %i1, %g1 2013600: 32 80 00 04 bne,a 2013610 <_CORE_message_queue_Seize+0x50> 2013604: c2 06 40 00 ld [ %i1 ], %g1 2013608: 10 80 00 05 b 201361c <_CORE_message_queue_Seize+0x5c> <== NOT EXECUTED 201360c: 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); 2013610: 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; 2013614: c2 26 20 50 st %g1, [ %i0 + 0x50 ] new_first->previous = _Chain_Head(the_chain); 2013618: c4 20 60 04 st %g2, [ %g1 + 4 ] the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); 201361c: 7f ff bb be call 2002514 2013620: 90 10 00 03 mov %g3, %o0 *size = the_message->Contents.size; 2013624: d4 06 60 0c ld [ %i1 + 0xc ], %o2 _Thread_Executing->Wait.count = the_message->priority; 2013628: 03 00 80 9e sethi %hi(0x2027800), %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; 201362c: d4 26 c0 00 st %o2, [ %i3 ] _Thread_Executing->Wait.count = the_message->priority; 2013630: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 2013634: c2 06 60 08 ld [ %i1 + 8 ], %g1 _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size); 2013638: 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; 201363c: c2 20 a0 24 st %g1, [ %g2 + 0x24 ] _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size); 2013640: a2 06 60 10 add %i1, 0x10, %l1 2013644: 7f ff ff d8 call 20135a4 <_CORE_message_queue_Copy_buffer> 2013648: 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 ); 201364c: 7f ff e8 ba call 200d934 <_Thread_queue_Dequeue> 2013650: 90 10 00 10 mov %l0, %o0 if ( !the_thread ) { 2013654: 82 92 20 00 orcc %o0, 0, %g1 2013658: 32 80 00 04 bne,a 2013668 <_CORE_message_queue_Seize+0xa8> 201365c: 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 ); 2013660: 7f ff de 98 call 200b0c0 <_Chain_Append> 2013664: 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( 2013668: 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; 201366c: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 the_message->Contents.size = (uint32_t)the_thread->Wait.option; 2013670: 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; 2013674: c2 26 60 08 st %g1, [ %i1 + 8 ] the_message->Contents.size = (uint32_t)the_thread->Wait.option; _CORE_message_queue_Copy_buffer( 2013678: 7f ff ff cb call 20135a4 <_CORE_message_queue_Copy_buffer> 201367c: 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( 2013680: f4 06 60 08 ld [ %i1 + 8 ], %i2 2013684: 40 00 0c 20 call 2016704 <_CORE_message_queue_Insert_message> 2013688: 91 e8 00 10 restore %g0, %l0, %o0 the_message->priority ); return; } if ( !wait ) { 201368c: 12 80 00 08 bne 20136ac <_CORE_message_queue_Seize+0xec> 2013690: 82 10 20 01 mov 1, %g1 _ISR_Enable( level ); 2013694: 7f ff bb a0 call 2002514 2013698: 01 00 00 00 nop executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 201369c: 82 10 20 04 mov 4, %g1 ! 4 20136a0: 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 ); } 20136a4: 81 c7 e0 08 ret 20136a8: 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; 20136ac: 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; 20136b0: f0 24 60 44 st %i0, [ %l1 + 0x44 ] executing->Wait.id = id; 20136b4: f2 24 60 20 st %i1, [ %l1 + 0x20 ] executing->Wait.return_argument = buffer; 20136b8: 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; 20136bc: 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 ); 20136c0: 7f ff bb 95 call 2002514 20136c4: 35 00 80 37 sethi %hi(0x200dc00), %i2 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 20136c8: b2 10 00 1d mov %i5, %i1 20136cc: 7f ff e9 08 call 200daec <_Thread_queue_Enqueue_with_handler> 20136d0: 95 ee a3 84 restore %i2, 0x384, %o2 20136d4: 01 00 00 00 nop 020136f4 <_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 ) { 20136f4: 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 ) { 20136f8: 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 ) { 20136fc: 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 ) { 2013700: 80 a6 80 01 cmp %i2, %g1 2013704: 18 80 00 3f bgu 2013800 <_CORE_message_queue_Submit+0x10c> 2013708: 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 ) { 201370c: c2 04 60 48 ld [ %l1 + 0x48 ], %g1 2013710: 80 a0 60 00 cmp %g1, 0 2013714: 32 80 00 0f bne,a 2013750 <_CORE_message_queue_Submit+0x5c> 2013718: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 201371c: 7f ff e8 86 call 200d934 <_Thread_queue_Dequeue> 2013720: 90 10 00 11 mov %l1, %o0 if ( the_thread ) { 2013724: a0 92 20 00 orcc %o0, 0, %l0 2013728: 02 80 00 09 be 201374c <_CORE_message_queue_Submit+0x58> 201372c: 90 10 00 19 mov %i1, %o0 _CORE_message_queue_Copy_buffer( 2013730: d2 04 20 28 ld [ %l0 + 0x28 ], %o1 2013734: 7f ff ff e9 call 20136d8 <_CORE_message_queue_Copy_buffer> 2013738: 94 10 00 1a mov %i2, %o2 buffer, the_thread->Wait.return_argument, size ); *(size_t *)the_thread->Wait.return_argument_1 = size; 201373c: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 the_thread->Wait.count = submit_type; 2013740: 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; 2013744: 10 80 00 15 b 2013798 <_CORE_message_queue_Submit+0xa4> 2013748: 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 < 201374c: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 2013750: c2 04 60 44 ld [ %l1 + 0x44 ], %g1 2013754: 80 a0 80 01 cmp %g2, %g1 2013758: 1a 80 00 12 bcc 20137a0 <_CORE_message_queue_Submit+0xac> 201375c: 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 *) 2013760: 7f ff de 64 call 200b0f0 <_Chain_Get> 2013764: 90 04 60 68 add %l1, 0x68, %o0 /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 2013768: a0 92 20 00 orcc %o0, 0, %l0 201376c: 02 80 00 27 be 2013808 <_CORE_message_queue_Submit+0x114> 2013770: 90 10 00 19 mov %i1, %o0 return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; } _CORE_message_queue_Copy_buffer( 2013774: 92 04 20 10 add %l0, 0x10, %o1 2013778: 7f ff ff d8 call 20136d8 <_CORE_message_queue_Copy_buffer> 201377c: 94 10 00 1a mov %i2, %o2 size ); the_message->Contents.size = size; the_message->priority = submit_type; _CORE_message_queue_Insert_message( 2013780: 90 10 00 11 mov %l1, %o0 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 2013784: f4 24 20 0c st %i2, [ %l0 + 0xc ] the_message->priority = submit_type; 2013788: fa 24 20 08 st %i5, [ %l0 + 8 ] _CORE_message_queue_Insert_message( 201378c: 92 10 00 10 mov %l0, %o1 2013790: 40 00 0b dd call 2016704 <_CORE_message_queue_Insert_message> 2013794: 94 10 00 1d mov %i5, %o2 2013798: 81 c7 e0 08 ret 201379c: 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 ) { 20137a0: 80 a0 60 00 cmp %g1, 0 20137a4: 02 80 00 17 be 2013800 <_CORE_message_queue_Submit+0x10c> 20137a8: 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() ) { 20137ac: 03 00 80 9e sethi %hi(0x2027800), %g1 20137b0: c2 00 63 18 ld [ %g1 + 0x318 ], %g1 ! 2027b18 <_ISR_Nest_level> 20137b4: 80 a0 60 00 cmp %g1, 0 20137b8: 12 80 00 14 bne 2013808 <_CORE_message_queue_Submit+0x114> 20137bc: 03 00 80 9e sethi %hi(0x2027800), %g1 */ { Thread_Control *executing = _Thread_Executing; _ISR_Disable( level ); 20137c0: 7f ff bb 51 call 2002504 20137c4: e0 00 63 30 ld [ %g1 + 0x330 ], %l0 ! 2027b30 <_Thread_Executing> 20137c8: 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; 20137cc: 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; 20137d0: f6 24 20 20 st %i3, [ %l0 + 0x20 ] executing->Wait.return_argument = buffer; 20137d4: f2 24 20 28 st %i1, [ %l0 + 0x28 ] executing->Wait.option = size; 20137d8: 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; 20137dc: e2 24 20 44 st %l1, [ %l0 + 0x44 ] 20137e0: 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 ); 20137e4: 7f ff bb 4c call 2002514 20137e8: b0 10 20 07 mov 7, %i0 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 20137ec: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 20137f0: 90 10 00 11 mov %l1, %o0 20137f4: 15 00 80 37 sethi %hi(0x200dc00), %o2 20137f8: 7f ff e8 bd call 200daec <_Thread_queue_Enqueue_with_handler> 20137fc: 94 12 a3 84 or %o2, 0x384, %o2 ! 200df84 <_Thread_queue_Timeout> 2013800: 81 c7 e0 08 ret 2013804: 81 e8 00 00 restore } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 2013808: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED } 201380c: 81 c7 e0 08 ret <== NOT EXECUTED 2013810: 81 e8 00 00 restore <== NOT EXECUTED 0200699c <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 200699c: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 20069a0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20069a4: 80 a0 60 02 cmp %g1, 2 Watchdog_Interval timeout ) { Thread_Control *executing; executing = _Thread_Executing; 20069a8: 03 00 80 62 sethi %hi(0x2018800), %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 20069ac: 12 80 00 0a bne 20069d4 <_CORE_mutex_Seize_interrupt_blocking+0x38> 20069b0: d2 00 63 d0 ld [ %g1 + 0x3d0 ], %o1 ! 2018bd0 <_Thread_Executing> if ( the_mutex->holder->current_priority > executing->current_priority ) { 20069b4: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 20069b8: d2 02 60 14 ld [ %o1 + 0x14 ], %o1 20069bc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 20069c0: 80 a0 40 09 cmp %g1, %o1 20069c4: 28 80 00 05 bleu,a 20069d8 <_CORE_mutex_Seize_interrupt_blocking+0x3c> 20069c8: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_Change_priority( 20069cc: 40 00 07 47 call 20086e8 <_Thread_Change_priority> 20069d0: 94 10 20 00 clr %o2 FALSE ); } } the_mutex->blocked_count++; 20069d4: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 20069d8: 90 10 00 18 mov %i0, %o0 FALSE ); } } the_mutex->blocked_count++; 20069dc: 82 00 60 01 inc %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 20069e0: 92 10 00 19 mov %i1, %o1 FALSE ); } } the_mutex->blocked_count++; 20069e4: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 20069e8: 15 00 80 25 sethi %hi(0x2009400), %o2 20069ec: 40 00 0a 13 call 2009238 <_Thread_queue_Enqueue_with_handler> 20069f0: 94 12 a2 d0 or %o2, 0x2d0, %o2 ! 20096d0 <_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 ) 20069f4: 05 00 80 62 sethi %hi(0x2018800), %g2 20069f8: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 20069fc: 82 00 7f ff add %g1, -1, %g1 2006a00: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2006a04: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 2006a08: 80 a0 60 00 cmp %g1, 0 2006a0c: 12 80 00 04 bne 2006a1c <_CORE_mutex_Seize_interrupt_blocking+0x80> 2006a10: 01 00 00 00 nop _Thread_Dispatch(); 2006a14: 40 00 08 72 call 2008bdc <_Thread_Dispatch> 2006a18: 81 e8 00 00 restore 2006a1c: 81 c7 e0 08 ret <== NOT EXECUTED 2006a20: 81 e8 00 00 restore <== NOT EXECUTED 02006a24 <_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 ) { 2006a24: 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 ) { 2006a28: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 2006a2c: 80 a0 60 00 cmp %g1, 0 2006a30: 02 80 00 07 be 2006a4c <_CORE_mutex_Surrender+0x28> 2006a34: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 if ( !_Thread_Is_executing( holder ) ) 2006a38: 03 00 80 62 sethi %hi(0x2018800), %g1 2006a3c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> 2006a40: 80 a2 00 01 cmp %o0, %g1 2006a44: 12 80 00 51 bne 2006b88 <_CORE_mutex_Surrender+0x164> 2006a48: 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 ) 2006a4c: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 2006a50: 80 a0 60 00 cmp %g1, 0 2006a54: 02 80 00 4c be 2006b84 <_CORE_mutex_Surrender+0x160> 2006a58: 82 00 7f ff add %g1, -1, %g1 return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; if ( the_mutex->nest_count != 0 ) { 2006a5c: 80 a0 60 00 cmp %g1, 0 2006a60: 02 80 00 09 be 2006a84 <_CORE_mutex_Surrender+0x60> 2006a64: c2 26 20 54 st %g1, [ %i0 + 0x54 ] switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2006a68: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 2006a6c: 80 a0 60 00 cmp %g1, 0 2006a70: 02 80 00 46 be 2006b88 <_CORE_mutex_Surrender+0x164> 2006a74: 84 10 20 00 clr %g2 2006a78: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2006a7c: 02 80 00 43 be 2006b88 <_CORE_mutex_Surrender+0x164> <== NOT EXECUTED 2006a80: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 2006a84: 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 ) || 2006a88: 80 a0 60 02 cmp %g1, 2 2006a8c: 22 80 00 06 be,a 2006aa4 <_CORE_mutex_Surrender+0x80> 2006a90: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006a94: 80 a0 60 03 cmp %g1, 3 2006a98: 32 80 00 07 bne,a 2006ab4 <_CORE_mutex_Surrender+0x90> 2006a9c: c0 26 20 5c clr [ %i0 + 0x5c ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; 2006aa0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006aa4: 82 00 7f ff add %g1, -1, %g1 2006aa8: c2 22 20 1c st %g1, [ %o0 + 0x1c ] 2006aac: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 the_mutex->holder = NULL; 2006ab0: 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 ) || 2006ab4: 80 a0 60 02 cmp %g1, 2 2006ab8: 02 80 00 05 be 2006acc <_CORE_mutex_Surrender+0xa8> 2006abc: c0 26 20 60 clr [ %i0 + 0x60 ] 2006ac0: 80 a0 60 03 cmp %g1, 3 2006ac4: 12 80 00 0d bne 2006af8 <_CORE_mutex_Surrender+0xd4> 2006ac8: 01 00 00 00 nop _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( holder->resource_count == 0 && 2006acc: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006ad0: 80 a0 60 00 cmp %g1, 0 2006ad4: 12 80 00 09 bne 2006af8 <_CORE_mutex_Surrender+0xd4> 2006ad8: 01 00 00 00 nop 2006adc: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 2006ae0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2006ae4: 80 a2 40 01 cmp %o1, %g1 2006ae8: 02 80 00 04 be 2006af8 <_CORE_mutex_Surrender+0xd4> 2006aec: 01 00 00 00 nop holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 2006af0: 40 00 06 fe call 20086e8 <_Thread_Change_priority> 2006af4: 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 ) ) ) { 2006af8: 40 00 09 62 call 2009080 <_Thread_queue_Dequeue> 2006afc: 90 10 00 18 mov %i0, %o0 2006b00: 86 92 20 00 orcc %o0, 0, %g3 2006b04: 02 80 00 1f be 2006b80 <_CORE_mutex_Surrender+0x15c> 2006b08: 82 10 20 01 mov 1, %g1 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 2006b0c: c2 00 e0 08 ld [ %g3 + 8 ], %g1 the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 2006b10: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 2006b14: c2 26 20 60 st %g1, [ %i0 + 0x60 ] } else #endif { the_mutex->holder = the_thread; 2006b18: c6 26 20 5c st %g3, [ %i0 + 0x5c ] the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; 2006b1c: 82 10 20 01 mov 1, %g1 switch ( the_mutex->Attributes.discipline ) { 2006b20: 80 a0 a0 02 cmp %g2, 2 2006b24: 02 80 00 07 be 2006b40 <_CORE_mutex_Surrender+0x11c> 2006b28: c2 26 20 54 st %g1, [ %i0 + 0x54 ] 2006b2c: 80 a0 a0 03 cmp %g2, 3 2006b30: 12 80 00 16 bne 2006b88 <_CORE_mutex_Surrender+0x164> 2006b34: 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++; 2006b38: 10 80 00 07 b 2006b54 <_CORE_mutex_Surrender+0x130> 2006b3c: 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++; 2006b40: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2006b44: 84 10 20 00 clr %g2 2006b48: 82 00 60 01 inc %g1 2006b4c: 10 80 00 0f b 2006b88 <_CORE_mutex_Surrender+0x164> 2006b50: 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 < 2006b54: 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++; 2006b58: 82 00 60 01 inc %g1 2006b5c: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if (the_mutex->Attributes.priority_ceiling < 2006b60: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 2006b64: 80 a2 40 02 cmp %o1, %g2 2006b68: 3a 80 00 08 bcc,a 2006b88 <_CORE_mutex_Surrender+0x164> 2006b6c: 84 10 20 00 clr %g2 <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 2006b70: 40 00 06 de call 20086e8 <_Thread_Change_priority> 2006b74: 94 10 20 00 clr %o2 } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 2006b78: 10 80 00 04 b 2006b88 <_CORE_mutex_Surrender+0x164> 2006b7c: 84 10 20 00 clr %g2 2006b80: c2 26 20 50 st %g1, [ %i0 + 0x50 ] 2006b84: 84 10 20 00 clr %g2 return CORE_MUTEX_STATUS_SUCCESSFUL; } 2006b88: 81 c7 e0 08 ret 2006b8c: 91 e8 00 02 restore %g0, %g2, %o0 0200770c <_CORE_spinlock_Release>: */ CORE_spinlock_Status _CORE_spinlock_Release( CORE_spinlock_Control *the_spinlock ) { 200770c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 2007710: 7f ff eb 35 call 20023e4 2007714: 01 00 00 00 nop /* * It must locked before it can be unlocked. */ if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 2007718: c2 06 20 04 ld [ %i0 + 4 ], %g1 200771c: 80 a0 60 00 cmp %g1, 0 2007720: 12 80 00 06 bne 2007738 <_CORE_spinlock_Release+0x2c> 2007724: 03 00 80 51 sethi %hi(0x2014400), %g1 _ISR_Enable( level ); 2007728: 7f ff eb 33 call 20023f4 200772c: b0 10 20 06 mov 6, %i0 2007730: 81 c7 e0 08 ret 2007734: 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 ) { 2007738: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 200773c: c4 06 20 0c ld [ %i0 + 0xc ], %g2 2007740: c2 00 60 08 ld [ %g1 + 8 ], %g1 2007744: 80 a0 80 01 cmp %g2, %g1 2007748: 02 80 00 06 be 2007760 <_CORE_spinlock_Release+0x54> 200774c: 01 00 00 00 nop _ISR_Enable( level ); 2007750: 7f ff eb 29 call 20023f4 <== NOT EXECUTED 2007754: b0 10 20 02 mov 2, %i0 ! 2 <== NOT EXECUTED 2007758: 81 c7 e0 08 ret <== NOT EXECUTED 200775c: 81 e8 00 00 restore <== NOT EXECUTED } /* * Let it be unlocked. */ the_spinlock->users -= 1; 2007760: c2 06 20 08 ld [ %i0 + 8 ], %g1 2007764: 82 00 7f ff add %g1, -1, %g1 2007768: c2 26 20 08 st %g1, [ %i0 + 8 ] the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; 200776c: c0 26 20 04 clr [ %i0 + 4 ] the_spinlock->holder = 0; 2007770: c0 26 20 0c clr [ %i0 + 0xc ] _ISR_Enable( level ); 2007774: 7f ff eb 20 call 20023f4 2007778: b0 10 20 00 clr %i0 return CORE_SPINLOCK_SUCCESSFUL; } 200777c: 81 c7 e0 08 ret 2007780: 81 e8 00 00 restore 02007784 <_CORE_spinlock_Wait>: CORE_spinlock_Status _CORE_spinlock_Wait( CORE_spinlock_Control *the_spinlock, boolean wait, Watchdog_Interval timeout ) { 2007784: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; 2007788: 03 00 80 51 sethi %hi(0x2014400), %g1 200778c: c2 00 63 64 ld [ %g1 + 0x364 ], %g1 ! 2014764 <_Watchdog_Ticks_since_boot> _ISR_Disable( level ); 2007790: 7f ff eb 15 call 20023e4 2007794: a2 06 80 01 add %i2, %g1, %l1 2007798: 86 10 00 08 mov %o0, %g3 if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 200779c: c2 06 20 04 ld [ %i0 + 4 ], %g1 20077a0: 80 a0 60 01 cmp %g1, 1 20077a4: 12 80 00 0c bne 20077d4 <_CORE_spinlock_Wait+0x50> 20077a8: 03 00 80 51 sethi %hi(0x2014400), %g1 20077ac: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 20146c0 <_Thread_Executing> 20077b0: c4 06 20 0c ld [ %i0 + 0xc ], %g2 20077b4: c2 00 60 08 ld [ %g1 + 8 ], %g1 20077b8: 80 a0 80 01 cmp %g2, %g1 20077bc: 12 80 00 06 bne 20077d4 <_CORE_spinlock_Wait+0x50> 20077c0: 01 00 00 00 nop (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); 20077c4: 7f ff eb 0c call 20023f4 20077c8: b0 10 20 01 mov 1, %i0 ! 1 20077cc: 81 c7 e0 08 ret 20077d0: 81 e8 00 00 restore return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 20077d4: 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) ) { 20077d8: 25 00 80 51 sethi %hi(0x2014400), %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; 20077dc: 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 ) 20077e0: 21 00 80 51 sethi %hi(0x2014400), %l0 20077e4: c2 26 20 08 st %g1, [ %i0 + 8 ] for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 20077e8: c2 06 20 04 ld [ %i0 + 4 ], %g1 20077ec: 80 a0 60 00 cmp %g1, 0 20077f0: 12 80 00 0d bne 2007824 <_CORE_spinlock_Wait+0xa0> 20077f4: 80 a6 60 00 cmp %i1, 0 the_spinlock->lock = CORE_SPINLOCK_LOCKED; the_spinlock->holder = _Thread_Executing->Object.id; 20077f8: 03 00 80 51 sethi %hi(0x2014400), %g1 20077fc: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 20146c0 <_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; 2007800: 82 10 20 01 mov 1, %g1 2007804: c2 26 20 04 st %g1, [ %i0 + 4 ] the_spinlock->holder = _Thread_Executing->Object.id; 2007808: c2 00 a0 08 ld [ %g2 + 8 ], %g1 200780c: c2 26 20 0c st %g1, [ %i0 + 0xc ] _ISR_Enable( level ); 2007810: b0 10 20 00 clr %i0 2007814: 7f ff ea f8 call 20023f4 2007818: 90 10 00 03 mov %g3, %o0 200781c: 81 c7 e0 08 ret 2007820: 81 e8 00 00 restore } /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { 2007824: 12 80 00 0a bne 200784c <_CORE_spinlock_Wait+0xc8> 2007828: 80 a6 a0 00 cmp %i2, 0 the_spinlock->users -= 1; 200782c: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 2007830: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2007834: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 2007838: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 200783c: 7f ff ea ee call 20023f4 <== NOT EXECUTED 2007840: 90 10 00 03 mov %g3, %o0 <== NOT EXECUTED 2007844: 81 c7 e0 08 ret <== NOT EXECUTED 2007848: 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) ) { 200784c: 02 80 00 0e be 2007884 <_CORE_spinlock_Wait+0x100> 2007850: 01 00 00 00 nop 2007854: c2 04 a3 64 ld [ %l2 + 0x364 ], %g1 <== NOT EXECUTED 2007858: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 200785c: 18 80 00 0a bgu 2007884 <_CORE_spinlock_Wait+0x100> <== NOT EXECUTED 2007860: 01 00 00 00 nop <== NOT EXECUTED the_spinlock->users -= 1; 2007864: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 2007868: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200786c: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 2007870: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED 2007874: 7f ff ea e0 call 20023f4 <== NOT EXECUTED 2007878: 90 10 00 03 mov %g3, %o0 <== NOT EXECUTED 200787c: 81 c7 e0 08 ret <== NOT EXECUTED 2007880: 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 ); 2007884: 7f ff ea dc call 20023f4 2007888: 90 10 00 03 mov %g3, %o0 200788c: c2 04 21 e0 ld [ %l0 + 0x1e0 ], %g1 2007890: 82 00 7f ff add %g1, -1, %g1 2007894: c2 24 21 e0 st %g1, [ %l0 + 0x1e0 ] 2007898: c2 04 21 e0 ld [ %l0 + 0x1e0 ], %g1 200789c: 80 a0 60 00 cmp %g1, 0 20078a0: 12 80 00 04 bne 20078b0 <_CORE_spinlock_Wait+0x12c> 20078a4: 01 00 00 00 nop _Thread_Dispatch(); 20078a8: 40 00 07 b5 call 200977c <_Thread_Dispatch> 20078ac: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20078b0: c2 04 21 e0 ld [ %l0 + 0x1e0 ], %g1 20078b4: 82 00 60 01 inc %g1 20078b8: c2 24 21 e0 st %g1, [ %l0 + 0x1e0 ] /* Another thread could get dispatched here */ /* Reenter the critical sections so we can attempt the lock again. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 20078bc: 7f ff ea ca call 20023e4 20078c0: 01 00 00 00 nop 20078c4: 86 10 00 08 mov %o0, %g3 20078c8: 30 bf ff c8 b,a 20077e8 <_CORE_spinlock_Wait+0x64> 0200ca9c <_Debug_Is_enabled>: */ boolean _Debug_Is_enabled( rtems_debug_control level ) { 200ca9c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200caa0: c2 00 63 d4 ld [ %g1 + 0x3d4 ], %g1 ! 2018bd4 <_Debug_Level> <== NOT EXECUTED 200caa4: 90 0a 00 01 and %o0, %g1, %o0 <== NOT EXECUTED return (_Debug_Level & level) ? TRUE : FALSE; } 200caa8: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 200caac: 81 c3 e0 08 retl <== NOT EXECUTED 200cab0: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED 020050cc <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 20050cc: 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; 20050d0: 03 00 80 62 sethi %hi(0x2018800), %g1 20050d4: e0 00 63 d0 ld [ %g1 + 0x3d0 ], %l0 ! 2018bd0 <_Thread_Executing> executing->Wait.return_code = RTEMS_SUCCESSFUL; 20050d8: c0 24 20 34 clr [ %l0 + 0x34 ] api = executing->API_Extensions[ THREAD_API_RTEMS ]; _ISR_Disable( level ); 20050dc: 7f ff f3 20 call 2001d5c 20050e0: e4 04 21 70 ld [ %l0 + 0x170 ], %l2 20050e4: 84 10 00 08 mov %o0, %g2 pending_events = api->pending_events; 20050e8: c2 04 a0 40 ld [ %l2 + 0x40 ], %g1 seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 20050ec: a2 8e 00 01 andcc %i0, %g1, %l1 20050f0: 02 80 00 0e be 2005128 <_Event_Seize+0x5c> 20050f4: 80 8e 60 01 btst 1, %i1 20050f8: 80 a4 40 18 cmp %l1, %i0 20050fc: 02 80 00 04 be 200510c <_Event_Seize+0x40> 2005100: 80 8e 60 02 btst 2, %i1 2005104: 02 80 00 09 be 2005128 <_Event_Seize+0x5c> 2005108: 80 8e 60 01 btst 1, %i1 (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 200510c: 82 28 40 11 andn %g1, %l1, %g1 2005110: c2 24 a0 40 st %g1, [ %l2 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 2005114: 7f ff f3 16 call 2001d6c 2005118: 01 00 00 00 nop 200511c: e2 26 c0 00 st %l1, [ %i3 ] 2005120: 81 c7 e0 08 ret 2005124: 81 e8 00 00 restore *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 2005128: 22 80 00 09 be,a 200514c <_Event_Seize+0x80> 200512c: 23 00 80 65 sethi %hi(0x2019400), %l1 _ISR_Enable( level ); 2005130: 7f ff f3 0f call 2001d6c 2005134: 90 10 00 02 mov %g2, %o0 executing->Wait.return_code = RTEMS_UNSATISFIED; 2005138: 82 10 20 0d mov 0xd, %g1 200513c: c2 24 20 34 st %g1, [ %l0 + 0x34 ] *event_out = seized_events; 2005140: e2 26 c0 00 st %l1, [ %i3 ] 2005144: 81 c7 e0 08 ret 2005148: 81 e8 00 00 restore return; } _Event_Sync_state = EVENT_SYNC_NOTHING_HAPPENED; 200514c: 82 10 20 01 mov 1, %g1 executing->Wait.option = (uint32_t ) option_set; 2005150: f2 24 20 30 st %i1, [ %l0 + 0x30 ] executing->Wait.count = (uint32_t ) event_in; 2005154: f0 24 20 24 st %i0, [ %l0 + 0x24 ] executing->Wait.return_argument = event_out; 2005158: 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; 200515c: c2 24 60 d4 st %g1, [ %l1 + 0xd4 ] executing->Wait.option = (uint32_t ) option_set; executing->Wait.count = (uint32_t ) event_in; executing->Wait.return_argument = event_out; _ISR_Enable( level ); 2005160: 7f ff f3 03 call 2001d6c 2005164: 90 10 00 02 mov %g2, %o0 if ( ticks ) { 2005168: 80 a6 a0 00 cmp %i2, 0 200516c: 02 80 00 0f be 20051a8 <_Event_Seize+0xdc> 2005170: 90 10 00 10 mov %l0, %o0 _Watchdog_Initialize( 2005174: c2 04 20 08 ld [ %l0 + 8 ], %g1 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2005178: 11 00 80 62 sethi %hi(0x2018800), %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200517c: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2005180: 03 00 80 15 sethi %hi(0x2005400), %g1 2005184: 82 10 60 54 or %g1, 0x54, %g1 ! 2005454 <_Event_Timeout> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2005188: f4 24 20 54 st %i2, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200518c: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2005190: c0 24 20 6c clr [ %l0 + 0x6c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2005194: c2 24 20 64 st %g1, [ %l0 + 0x64 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2005198: 90 12 23 f0 or %o0, 0x3f0, %o0 200519c: 40 00 13 a1 call 200a020 <_Watchdog_Insert> 20051a0: 92 04 20 48 add %l0, 0x48, %o1 NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 20051a4: 90 10 00 10 mov %l0, %o0 20051a8: 40 00 11 a2 call 2009830 <_Thread_Set_state> 20051ac: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 20051b0: 7f ff f2 eb call 2001d5c 20051b4: 01 00 00 00 nop 20051b8: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 20051bc: c4 04 60 d4 ld [ %l1 + 0xd4 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 20051c0: c0 24 60 d4 clr [ %l1 + 0xd4 ] switch ( sync_state ) { 20051c4: 80 a0 a0 02 cmp %g2, 2 20051c8: 02 80 00 08 be 20051e8 <_Event_Seize+0x11c> 20051cc: 80 a0 a0 03 cmp %g2, 3 20051d0: 02 80 00 09 be 20051f4 <_Event_Seize+0x128> 20051d4: 80 a0 a0 01 cmp %g2, 1 20051d8: 12 80 00 15 bne 200522c <_Event_Seize+0x160> 20051dc: 01 00 00 00 nop * enter the synchronization states above. */ return; case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); 20051e0: 7f ff f2 e3 call 2001d6c 20051e4: 81 e8 00 00 restore return; case EVENT_SYNC_TIMEOUT: executing->Wait.return_code = RTEMS_TIMEOUT; 20051e8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 20051ec: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20051f0: 30 80 00 0b b,a 200521c <_Event_Seize+0x150> <== NOT EXECUTED _Thread_Unblock( executing ); return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { 20051f4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 20051f8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20051fc: 12 80 00 08 bne 200521c <_Event_Seize+0x150> <== NOT EXECUTED 2005200: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 2005204: c4 24 20 50 st %g2, [ %l0 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); 2005208: 7f ff f2 d9 call 2001d6c <== NOT EXECUTED 200520c: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED (void) _Watchdog_Remove( &executing->Timer ); 2005210: 40 00 13 dc call 200a180 <_Watchdog_Remove> <== NOT EXECUTED 2005214: 90 04 20 48 add %l0, 0x48, %o0 <== NOT EXECUTED 2005218: 30 80 00 03 b,a 2005224 <_Event_Seize+0x158> <== NOT EXECUTED } else _ISR_Enable( level ); 200521c: 7f ff f2 d4 call 2001d6c <== NOT EXECUTED 2005220: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED _Thread_Unblock( executing ); 2005224: 7f ff ff a4 call 20050b4 <_Thread_Unblock> <== NOT EXECUTED 2005228: 81 e8 00 00 restore <== NOT EXECUTED 200522c: 81 c7 e0 08 ret <== NOT EXECUTED 2005230: 81 e8 00 00 restore <== NOT EXECUTED 0200534c <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 200534c: 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 ]; 2005350: e2 06 21 70 ld [ %i0 + 0x170 ], %l1 option_set = (rtems_option) the_thread->Wait.option; 2005354: e6 06 20 30 ld [ %i0 + 0x30 ], %l3 _ISR_Disable( level ); 2005358: 7f ff f2 81 call 2001d5c 200535c: a0 10 00 18 mov %i0, %l0 2005360: a4 10 00 08 mov %o0, %l2 pending_events = api->pending_events; 2005364: c8 04 60 40 ld [ %l1 + 0x40 ], %g4 event_condition = (rtems_event_set) the_thread->Wait.count; 2005368: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { 200536c: 86 88 80 04 andcc %g2, %g4, %g3 2005370: 02 80 00 36 be 2005448 <_Event_Surrender+0xfc> 2005374: 01 00 00 00 nop if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 2005378: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 200537c: 80 88 61 00 btst 0x100, %g1 2005380: 02 80 00 1e be 20053f8 <_Event_Surrender+0xac> 2005384: 1b 00 80 65 sethi %hi(0x2019400), %o5 if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 2005388: 80 a0 c0 02 cmp %g3, %g2 200538c: 02 80 00 04 be 200539c <_Event_Surrender+0x50> 2005390: 80 8c e0 02 btst 2, %l3 2005394: 02 80 00 19 be 20053f8 <_Event_Surrender+0xac> 2005398: 01 00 00 00 nop api->pending_events = 200539c: 82 29 00 03 andn %g4, %g3, %g1 20053a0: 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; 20053a4: 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; 20053a8: c0 24 20 24 clr [ %l0 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 20053ac: c6 20 40 00 st %g3, [ %g1 ] _ISR_Flash( level ); 20053b0: 7f ff f2 6f call 2001d6c 20053b4: 01 00 00 00 nop 20053b8: 7f ff f2 69 call 2001d5c 20053bc: 01 00 00 00 nop if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 20053c0: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 20053c4: 80 a0 60 02 cmp %g1, 2 20053c8: 02 80 00 05 be 20053dc <_Event_Surrender+0x90> 20053cc: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 20053d0: 7f ff f2 67 call 2001d6c 20053d4: 90 10 00 12 mov %l2, %o0 20053d8: 30 80 00 06 b,a 20053f0 <_Event_Surrender+0xa4> 20053dc: c2 24 20 50 st %g1, [ %l0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 20053e0: 7f ff f2 63 call 2001d6c 20053e4: 90 10 00 12 mov %l2, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 20053e8: 40 00 13 66 call 200a180 <_Watchdog_Remove> 20053ec: 90 04 20 48 add %l0, 0x48, %o0 _Thread_Unblock( the_thread ); 20053f0: 7f ff ff d1 call 2005334 <_Thread_Unblock> 20053f4: 81 e8 00 00 restore } return; } } switch ( _Event_Sync_state ) { 20053f8: c2 03 60 d4 ld [ %o5 + 0xd4 ], %g1 <== NOT EXECUTED 20053fc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2005400: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2005404: 18 80 00 11 bgu 2005448 <_Event_Surrender+0xfc> <== NOT EXECUTED 2005408: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED case EVENT_SYNC_SATISFIED: break; case EVENT_SYNC_NOTHING_HAPPENED: case EVENT_SYNC_TIMEOUT: if ( !_Thread_Is_executing( the_thread ) ) 200540c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED 2005410: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 2005414: 12 80 00 0d bne 2005448 <_Event_Surrender+0xfc> <== NOT EXECUTED 2005418: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 200541c: 02 80 00 04 be 200542c <_Event_Surrender+0xe0> <== NOT EXECUTED 2005420: 80 8c e0 02 btst 2, %l3 <== NOT EXECUTED 2005424: 02 80 00 09 be 2005448 <_Event_Surrender+0xfc> <== NOT EXECUTED 2005428: 01 00 00 00 nop <== NOT EXECUTED api->pending_events = 200542c: 82 29 00 03 andn %g4, %g3, %g1 <== NOT EXECUTED 2005430: 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; 2005434: 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; 2005438: c0 24 20 24 clr [ %l0 + 0x24 ] <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 200543c: c6 20 40 00 st %g3, [ %g1 ] <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_SATISFIED; 2005440: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 2005444: c2 23 60 d4 st %g1, [ %o5 + 0xd4 ] <== NOT EXECUTED } break; } } _ISR_Enable( level ); 2005448: 7f ff f2 49 call 2001d6c 200544c: 91 e8 00 12 restore %g0, %l2, %o0 2005450: 01 00 00 00 nop 02005454 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 2005454: 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 ) ) { 2005458: 92 96 20 00 orcc %i0, 0, %o1 200545c: 12 80 00 0a bne 2005484 <_Event_Timeout+0x30> 2005460: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005464: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2005468: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200546c: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2005470: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] <== 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; 2005474: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2005478: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_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; 200547c: 10 80 00 18 b 20054dc <_Event_Timeout+0x88> <== NOT EXECUTED 2005480: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 2005484: 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 ) { 2005488: 80 a0 a0 04 cmp %g2, 4 200548c: 18 80 00 0e bgu 20054c4 <_Event_Timeout+0x70> 2005490: 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 :) */ 2005494: 83 32 60 1b srl %o1, 0x1b, %g1 2005498: 80 a0 60 01 cmp %g1, 1 200549c: 12 80 00 0a bne 20054c4 <_Event_Timeout+0x70> 20054a0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20054a4: 83 28 a0 02 sll %g2, 2, %g1 20054a8: 05 00 80 62 sethi %hi(0x2018800), %g2 20054ac: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 20054b0: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20054b4: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20054b8: 80 a2 20 00 cmp %o0, 0 20054bc: 12 80 00 05 bne 20054d0 <_Event_Timeout+0x7c> 20054c0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20054c4: b0 10 20 00 clr %i0 <== NOT EXECUTED 20054c8: 10 80 00 05 b 20054dc <_Event_Timeout+0x88> <== NOT EXECUTED 20054cc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20054d0: 40 00 08 be call 20077c8 <_Objects_Get> 20054d4: 94 07 bf f4 add %fp, -12, %o2 20054d8: 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 ) { 20054dc: c2 07 bf f4 ld [ %fp + -12 ], %g1 20054e0: 80 a0 60 00 cmp %g1, 0 20054e4: 12 80 00 27 bne 2005580 <_Event_Timeout+0x12c> 20054e8: 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 ); 20054ec: 7f ff f2 1c call 2001d5c 20054f0: 01 00 00 00 nop 20054f4: 86 10 00 08 mov %o0, %g3 if ( the_thread->Wait.count ) { /* verify thread is waiting */ 20054f8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 20054fc: 80 a0 60 00 cmp %g1, 0 2005500: 02 80 00 1a be 2005568 <_Event_Timeout+0x114> 2005504: 05 00 80 65 sethi %hi(0x2019400), %g2 the_thread->Wait.count = 0; if ( _Event_Sync_state != EVENT_SYNC_SYNCHRONIZED && 2005508: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 ! 20194d4 <_Event_Sync_state> 200550c: 80 a0 60 00 cmp %g1, 0 2005510: 02 80 00 0d be 2005544 <_Event_Timeout+0xf0> 2005514: c0 26 20 24 clr [ %i0 + 0x24 ] 2005518: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200551c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED 2005520: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 2005524: 12 80 00 09 bne 2005548 <_Event_Timeout+0xf4> <== NOT EXECUTED 2005528: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { 200552c: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 <== NOT EXECUTED 2005530: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2005534: 02 80 00 03 be 2005540 <_Event_Timeout+0xec> <== NOT EXECUTED 2005538: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_TIMEOUT; 200553c: c2 20 a0 d4 st %g1, [ %g2 + 0xd4 ] <== NOT EXECUTED } _ISR_Enable( level ); 2005540: 30 80 00 0a b,a 2005568 <_Event_Timeout+0x114> <== NOT EXECUTED } else { the_thread->Wait.return_code = RTEMS_TIMEOUT; 2005544: 82 10 20 06 mov 6, %g1 2005548: c2 26 20 34 st %g1, [ %i0 + 0x34 ] _ISR_Enable( level ); 200554c: 7f ff f2 08 call 2001d6c 2005550: 90 10 00 03 mov %g3, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2005554: 90 10 00 18 mov %i0, %o0 2005558: 13 04 00 ff sethi %hi(0x1003fc00), %o1 200555c: 40 00 0c d5 call 20088b0 <_Thread_Clear_state> 2005560: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 2005564: 30 80 00 03 b,a 2005570 <_Event_Timeout+0x11c> _Thread_Unblock( the_thread ); } } else { _ISR_Enable( level ); 2005568: 7f ff f2 01 call 2001d6c <== NOT EXECUTED 200556c: 01 00 00 00 nop <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2005570: 05 00 80 62 sethi %hi(0x2018800), %g2 2005574: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2005578: 82 00 7f ff add %g1, -1, %g1 200557c: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2005580: 81 c7 e0 08 ret 2005584: 81 e8 00 00 restore 02018140 <_Heap_Get_free_information>: */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 2018140: 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; 2018144: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED info->largest = 0; 2018148: c0 22 60 04 clr [ %o1 + 4 ] <== NOT EXECUTED info->total = 0; 201814c: 10 80 00 0e b 2018184 <_Heap_Get_free_information+0x44> <== NOT EXECUTED 2018150: 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++; 2018154: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED info->total += the_size; 2018158: c4 02 60 08 ld [ %o1 + 8 ], %g2 <== NOT EXECUTED if ( info->largest < the_size ) 201815c: 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); 2018160: 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++; 2018164: 82 00 60 01 inc %g1 <== NOT EXECUTED info->total += the_size; 2018168: 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++; 201816c: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED info->total += the_size; if ( info->largest < the_size ) 2018170: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED 2018174: 1a 80 00 03 bcc 2018180 <_Heap_Get_free_information+0x40> <== NOT EXECUTED 2018178: c4 22 60 08 st %g2, [ %o1 + 8 ] <== NOT EXECUTED info->largest = the_size; 201817c: 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) 2018180: 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; 2018184: 80 a3 40 08 cmp %o5, %o0 <== NOT EXECUTED 2018188: 32 bf ff f3 bne,a 2018154 <_Heap_Get_free_information+0x14> <== NOT EXECUTED 201818c: 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; } } 2018190: 81 c3 e0 08 retl <== NOT EXECUTED 2018194: 01 00 00 00 nop 020070dc <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 20070dc: 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) 20070e0: 80 a6 e0 00 cmp %i3, 0 20070e4: 12 80 00 05 bne 20070f8 <_Heap_Initialize+0x1c> 20070e8: f6 27 a0 50 st %i3, [ %fp + 0x50 ] page_size = CPU_ALIGNMENT; 20070ec: 82 10 20 08 mov 8, %g1 <== NOT EXECUTED 20070f0: 10 80 00 05 b 2007104 <_Heap_Initialize+0x28> <== NOT EXECUTED 20070f4: c2 27 a0 50 st %g1, [ %fp + 0x50 ] <== NOT EXECUTED else _Heap_Align_up( &page_size, CPU_ALIGNMENT ); 20070f8: 90 07 a0 50 add %fp, 0x50, %o0 20070fc: 7f ff ff b0 call 2006fbc <_Heap_Align_up> 2007100: 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 ); 2007104: 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; 2007108: 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; 200710c: 92 10 00 10 mov %l0, %o1 2007110: 40 00 38 fd call 2015504 <.urem> 2007114: 90 10 00 12 mov %l2, %o0 *value = r ? v - r + a : v; 2007118: 80 a2 20 00 cmp %o0, 0 200711c: 02 80 00 05 be 2007130 <_Heap_Initialize+0x54> 2007120: 82 10 20 10 mov 0x10, %g1 2007124: 82 04 80 10 add %l2, %l0, %g1 2007128: 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; 200712c: 82 10 20 10 mov 0x10, %g1 _Heap_Align_up ( &the_heap->min_block_size, page_size ); 2007130: 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; 2007134: c2 26 20 14 st %g1, [ %i0 + 0x14 ] _Heap_Align_up ( &the_heap->min_block_size, page_size ); 2007138: 7f ff ff a1 call 2006fbc <_Heap_Align_up> 200713c: 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; 2007140: 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); 2007144: 82 26 c0 19 sub %i3, %i1, %g1 2007148: 82 00 60 08 add %g1, 8, %g1 if ( size < overhead ) 200714c: 80 a6 80 01 cmp %i2, %g1 2007150: 0a 80 00 2b bcs 20071fc <_Heap_Initialize+0x120> 2007154: e2 07 a0 50 ld [ %fp + 0x50 ], %l1 return 0; /* Too small area for the heap */ the_size = size - overhead; 2007158: a0 26 80 01 sub %i2, %g1, %l0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 200715c: 92 10 00 11 mov %l1, %o1 2007160: 40 00 38 e9 call 2015504 <.urem> 2007164: 90 10 00 10 mov %l0, %o0 _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 2007168: a0 a4 00 08 subcc %l0, %o0, %l0 200716c: 02 80 00 24 be 20071fc <_Heap_Initialize+0x120> 2007170: 07 00 80 61 sethi %hi(0x2018400), %g3 return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 2007174: 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; 2007178: e2 24 bf f8 st %l1, [ %l2 + -8 ] the_block->size = the_size | HEAP_PREV_USED; 200717c: 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++; 2007180: c4 00 e3 10 ld [ %g3 + 0x310 ], %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; 2007184: 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 */ 2007188: 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 ); 200718c: 88 06 c0 10 add %i3, %l0, %g4 the_block->size = page_size; 2007190: 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 ); 2007194: f0 26 e0 08 st %i0, [ %i3 + 8 ] the_block->prev = _Heap_Head( the_heap ); 2007198: 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++; 200719c: 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; 20071a0: 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; 20071a4: 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; 20071a8: 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; 20071ac: 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; 20071b0: e0 26 20 30 st %l0, [ %i0 + 0x30 ] stats->min_free_size = the_size; 20071b4: e0 26 20 34 st %l0, [ %i0 + 0x34 ] stats->free_blocks = 1; stats->max_free_blocks = 1; stats->used_blocks = 0; 20071b8: c0 26 20 40 clr [ %i0 + 0x40 ] stats->max_search = 0; 20071bc: c0 26 20 44 clr [ %i0 + 0x44 ] stats->allocs = 0; 20071c0: c0 26 20 48 clr [ %i0 + 0x48 ] stats->searches = 0; 20071c4: c0 26 20 4c clr [ %i0 + 0x4c ] stats->frees = 0; 20071c8: c0 26 20 50 clr [ %i0 + 0x50 ] stats->resizes = 0; 20071cc: 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; 20071d0: 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++; 20071d4: 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; 20071d8: 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; 20071dc: 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; 20071e0: f6 26 20 08 st %i3, [ %i0 + 8 ] _Heap_Tail(the_heap)->prev = the_block; 20071e4: f6 26 20 0c st %i3, [ %i0 + 0xc ] the_heap->start = the_block; 20071e8: 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 */ 20071ec: 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++; 20071f0: c4 20 e3 10 st %g2, [ %g3 + 0x310 ] return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 20071f4: 81 c7 e0 08 ret 20071f8: 91 ec 3f fc restore %l0, -4, %o0 } 20071fc: 81 c7 e0 08 ret 2007200: 91 e8 20 00 restore %g0, 0, %o0 0200cc9c <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 200cc9c: 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; 200cca0: 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; 200cca4: ea 06 20 14 ld [ %i0 + 0x14 ], %l5 <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; *old_mem_size = 0; 200cca8: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED *avail_mem_size = 0; 200ccac: 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); 200ccb0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200ccb4: 40 00 22 14 call 2015504 <.urem> <== NOT EXECUTED 200ccb8: 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 ); 200ccbc: 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); 200ccc0: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 200ccc4: 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)) 200ccc8: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED 200cccc: 0a 80 00 78 bcs 200ceac <_Heap_Resize_block+0x210> <== NOT EXECUTED 200ccd0: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 <== NOT EXECUTED 200ccd4: 80 a4 80 02 cmp %l2, %g2 <== NOT EXECUTED 200ccd8: 38 80 00 78 bgu,a 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200ccdc: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 200cce0: 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); 200cce4: 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 ); 200cce8: 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) || 200ccec: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 200ccf0: 2a 80 00 72 bcs,a 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200ccf4: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 200ccf8: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 200ccfc: 38 80 00 6f bgu,a 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200cd00: 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); 200cd04: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED 200cd08: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200cd0c: 02 80 00 68 be 200ceac <_Heap_Resize_block+0x210> <== NOT EXECUTED 200cd10: 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) || 200cd14: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 200cd18: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED 200cd1c: 02 80 00 04 be 200cd2c <_Heap_Resize_block+0x90> <== NOT EXECUTED 200cd20: ba 04 40 14 add %l1, %l4, %i5 <== NOT EXECUTED 200cd24: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED 200cd28: 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) 200cd2c: 82 24 40 19 sub %l1, %i1, %g1 <== NOT EXECUTED 200cd30: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 200cd34: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED if (size > old_user_size) { 200cd38: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED 200cd3c: 08 80 00 1f bleu 200cdb8 <_Heap_Resize_block+0x11c> <== NOT EXECUTED 200cd40: 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 */ 200cd44: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 200cd48: 12 80 00 5b bne 200ceb4 <_Heap_Resize_block+0x218> <== NOT EXECUTED 200cd4c: 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; 200cd50: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 200cd54: 40 00 21 ec call 2015504 <.urem> <== NOT EXECUTED 200cd58: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED *value = r ? v - r + a : v; 200cd5c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200cd60: 02 80 00 05 be 200cd74 <_Heap_Resize_block+0xd8> <== NOT EXECUTED 200cd64: 80 a4 00 15 cmp %l0, %l5 <== NOT EXECUTED 200cd68: 82 04 00 13 add %l0, %l3, %g1 <== NOT EXECUTED 200cd6c: a0 20 40 08 sub %g1, %o0, %l0 <== NOT EXECUTED 200cd70: 80 a4 00 15 cmp %l0, %l5 <== NOT EXECUTED 200cd74: 1a 80 00 03 bcc 200cd80 <_Heap_Resize_block+0xe4> <== NOT EXECUTED 200cd78: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 200cd7c: 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) 200cd80: 80 a2 00 14 cmp %o0, %l4 <== NOT EXECUTED 200cd84: 38 80 00 4d bgu,a 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200cd88: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 200cd8c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 200cd90: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 200cd94: 7f ff e8 a8 call 2007034 <_Heap_Block_allocate> <== NOT EXECUTED 200cd98: 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; 200cd9c: 90 02 00 17 add %o0, %l7, %o0 <== NOT EXECUTED 200cda0: 90 12 00 1b or %o0, %i3, %o0 <== NOT EXECUTED 200cda4: d0 24 a0 04 st %o0, [ %l2 + 4 ] <== NOT EXECUTED --stats->used_blocks; 200cda8: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED 200cdac: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200cdb0: 10 80 00 3a b 200ce98 <_Heap_Resize_block+0x1fc> <== NOT EXECUTED 200cdb4: 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; 200cdb8: a0 20 40 1a sub %g1, %i2, %l0 <== NOT EXECUTED uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 200cdbc: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 200cdc0: 40 00 21 d1 call 2015504 <.urem> <== NOT EXECUTED 200cdc4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 200cdc8: a0 a4 00 08 subcc %l0, %o0, %l0 <== NOT EXECUTED 200cdcc: 22 80 00 34 be,a 200ce9c <_Heap_Resize_block+0x200> <== NOT EXECUTED 200cdd0: 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; 200cdd4: 84 25 c0 10 sub %l7, %l0, %g2 <== NOT EXECUTED if (new_block_size < min_block_size) { 200cdd8: 80 a0 80 15 cmp %g2, %l5 <== NOT EXECUTED 200cddc: 1a 80 00 08 bcc 200cdfc <_Heap_Resize_block+0x160> <== NOT EXECUTED 200cde0: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 200cde4: 82 25 40 02 sub %l5, %g2, %g1 <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 200cde8: a0 a4 00 01 subcc %l0, %g1, %l0 <== NOT EXECUTED 200cdec: 22 80 00 2c be,a 200ce9c <_Heap_Resize_block+0x200> <== NOT EXECUTED 200cdf0: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 200cdf4: 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) { 200cdf8: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 200cdfc: 12 80 00 15 bne 200ce50 <_Heap_Resize_block+0x1b4> <== NOT EXECUTED 200ce00: 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; 200ce04: 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; 200ce08: 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; 200ce0c: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED new_next_block->size = new_next_block_size | HEAP_PREV_USED; 200ce10: 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 ); 200ce14: 84 04 80 02 add %l2, %g2, %g2 <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; 200ce18: 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; 200ce1c: 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; 200ce20: 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; 200ce24: 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; 200ce28: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED Heap_Block *prev = block->prev; block = new_block; block->next = next; 200ce2c: c8 20 a0 08 st %g4, [ %g2 + 8 ] <== NOT EXECUTED 200ce30: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED block->prev = prev; 200ce34: da 20 a0 0c st %o5, [ %g2 + 0xc ] <== NOT EXECUTED 200ce38: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 200ce3c: 86 00 ff fc add %g3, -4, %g3 <== NOT EXECUTED next->prev = prev->next = block; 200ce40: c4 21 20 0c st %g2, [ %g4 + 0xc ] <== NOT EXECUTED 200ce44: c4 23 60 08 st %g2, [ %o5 + 8 ] <== NOT EXECUTED 200ce48: 10 80 00 14 b 200ce98 <_Heap_Resize_block+0x1fc> <== NOT EXECUTED 200ce4c: c6 27 00 00 st %g3, [ %i4 ] <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 200ce50: 2a 80 00 13 bcs,a 200ce9c <_Heap_Resize_block+0x200> <== NOT EXECUTED 200ce54: 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; 200ce58: 82 10 80 1b or %g2, %i3, %g1 <== NOT EXECUTED 200ce5c: 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; 200ce60: 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 ); 200ce64: 92 04 80 02 add %l2, %g2, %o1 <== NOT EXECUTED 200ce68: c2 22 60 04 st %g1, [ %o1 + 4 ] <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 200ce6c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200ce70: 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 */ 200ce74: 82 00 60 01 inc %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200ce78: 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 */ 200ce7c: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200ce80: c4 26 20 50 st %g2, [ %i0 + 0x50 ] <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 200ce84: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 200ce88: 7f ff e7 db call 2006df4 <_Heap_Free> <== NOT EXECUTED 200ce8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 200ce90: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED 200ce94: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED } } } ++stats->resizes; 200ce98: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 200ce9c: 84 10 20 00 clr %g2 <== NOT EXECUTED 200cea0: 82 00 60 01 inc %g1 <== NOT EXECUTED 200cea4: 10 80 00 05 b 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200cea8: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; 200ceac: 10 80 00 03 b 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200ceb0: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 200ceb4: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED } 200ceb8: 81 c7 e0 08 ret <== NOT EXECUTED 200cebc: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED 0200cec0 <_Heap_Size_of_user_area>: boolean _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 200cec0: 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( 200cec4: e2 06 20 20 ld [ %i0 + 0x20 ], %l1 <== NOT EXECUTED 200cec8: 80 a6 40 11 cmp %i1, %l1 <== NOT EXECUTED 200cecc: 0a 80 00 1f bcs 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200ced0: e0 06 20 24 ld [ %i0 + 0x24 ], %l0 <== NOT EXECUTED 200ced4: 80 a6 40 10 cmp %i1, %l0 <== NOT EXECUTED 200ced8: 18 80 00 1c bgu 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cedc: 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); 200cee0: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 <== NOT EXECUTED 200cee4: 40 00 21 88 call 2015504 <.urem> <== NOT EXECUTED 200cee8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200ceec: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 200cef0: 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 ) ) 200cef4: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 200cef8: 0a 80 00 14 bcs 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cefc: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 200cf00: 18 80 00 12 bgu 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cf04: 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 ); 200cf08: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 200cf0c: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 200cf10: 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 ( 200cf14: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 200cf18: 0a 80 00 0c bcs 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cf1c: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 200cf20: 18 80 00 0a bgu 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cf24: 01 00 00 00 nop <== NOT EXECUTED 200cf28: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 200cf2c: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200cf30: 02 80 00 06 be 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cf34: 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 ) 200cf38: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED 200cf3c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 200cf40: 81 c7 e0 08 ret <== NOT EXECUTED 200cf44: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); } 200cf48: 81 c7 e0 08 ret <== NOT EXECUTED 200cf4c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 020065c8 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 20065c8: 9d e3 bf 98 save %sp, -104, %sp 20065cc: 23 00 80 65 sethi %hi(0x2019400), %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 ) 20065d0: 80 a6 80 19 cmp %i2, %i1 20065d4: 18 80 00 06 bgu 20065ec <_IO_Manager_initialization+0x24> 20065d8: 25 00 80 65 sethi %hi(0x2019400), %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; 20065dc: f0 24 61 28 st %i0, [ %l1 + 0x128 ] _IO_Number_of_drivers = number_of_drivers; 20065e0: f2 24 a1 24 st %i1, [ %l2 + 0x124 ] 20065e4: 81 c7 e0 08 ret 20065e8: 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 *) 20065ec: 83 2e a0 03 sll %i2, 3, %g1 <== NOT EXECUTED 20065f0: a1 2e a0 05 sll %i2, 5, %l0 <== NOT EXECUTED 20065f4: a0 24 00 01 sub %l0, %g1, %l0 <== NOT EXECUTED 20065f8: 40 00 0f 35 call 200a2cc <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 20065fc: 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( 2006600: 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; 2006604: f4 24 a1 24 st %i2, [ %l2 + 0x124 ] <== 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 *) 2006608: d0 24 61 28 st %o0, [ %l1 + 0x128 ] <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 200660c: 40 00 21 77 call 200ebe8 <== NOT EXECUTED 2006610: 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]; 2006614: e2 04 61 28 ld [ %l1 + 0x128 ], %l1 <== NOT EXECUTED 2006618: b4 10 20 00 clr %i2 <== NOT EXECUTED 200661c: 10 80 00 07 b 2006638 <_IO_Manager_initialization+0x70> <== NOT EXECUTED 2006620: a0 10 20 00 clr %l0 <== NOT EXECUTED 2006624: 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++ ) 2006628: b4 06 a0 01 inc %i2 <== NOT EXECUTED 200662c: a0 04 20 18 add %l0, 0x18, %l0 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 2006630: 40 00 21 41 call 200eb34 <== NOT EXECUTED 2006634: 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++ ) 2006638: 80 a6 80 19 cmp %i2, %i1 <== NOT EXECUTED 200663c: 12 bf ff fa bne 2006624 <_IO_Manager_initialization+0x5c> <== NOT EXECUTED 2006640: 90 04 00 11 add %l0, %l1, %o0 <== NOT EXECUTED 2006644: 81 c7 e0 08 ret <== NOT EXECUTED 2006648: 81 e8 00 00 restore <== NOT EXECUTED 02007244 <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 2007244: 9d e3 bf 98 save %sp, -104, %sp _ISR_Signals_to_thread_executing = FALSE; 2007248: 03 00 80 63 sethi %hi(0x2018c00), %g1 200724c: c0 20 60 78 clr [ %g1 + 0x78 ] ! 2018c78 <_ISR_Signals_to_thread_executing> _ISR_Nest_level = 0; 2007250: 03 00 80 62 sethi %hi(0x2018800), %g1 _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 2007254: 90 10 24 00 mov 0x400, %o0 void _ISR_Handler_initialization( void ) { _ISR_Signals_to_thread_executing = FALSE; _ISR_Nest_level = 0; 2007258: c0 20 63 b8 clr [ %g1 + 0x3b8 ] _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 200725c: 40 00 0c 1c call 200a2cc <_Workspace_Allocate_or_fatal_error> 2007260: 01 00 00 00 nop _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 2007264: 03 00 80 62 sethi %hi(0x2018800), %g1 2007268: a0 10 63 04 or %g1, 0x304, %l0 ! 2018b04 <_CPU_Table> 200726c: 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( 2007270: 03 00 80 62 sethi %hi(0x2018800), %g1 _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 2007274: 80 a0 af ff cmp %g2, 0xfff 2007278: 18 80 00 06 bgu 2007290 <_ISR_Handler_initialization+0x4c> 200727c: d0 20 63 94 st %o0, [ %g1 + 0x394 ] _Internal_error_Occurred( 2007280: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007284: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2007288: 7f ff ff df call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 200728c: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 2007290: 40 00 0c 0f call 200a2cc <_Workspace_Allocate_or_fatal_error> 2007294: 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( 2007298: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 200729c: 03 00 80 62 sethi %hi(0x2018800), %g1 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 20072a0: 84 02 00 02 add %o0, %g2, %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 20072a4: d0 20 63 00 st %o0, [ %g1 + 0x300 ] _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 20072a8: 03 00 80 62 sethi %hi(0x2018800), %g1 20072ac: c4 20 62 4c st %g2, [ %g1 + 0x24c ] ! 2018a4c <_CPU_Interrupt_stack_high> #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 20072b0: 81 c7 e0 08 ret 20072b4: 81 e8 00 00 restore 02016834 <_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; 2016834: 10 80 00 05 b 2016848 <_Objects_Copy_name_raw+0x14> <== NOT EXECUTED 2016838: 95 32 a0 02 srl %o2, 2, %o2 <== NOT EXECUTED while ( tmp_length-- ) *destination_p++ = *source_p++; 201683c: 90 02 20 04 add %o0, 4, %o0 <== NOT EXECUTED 2016840: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED 2016844: 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-- ) 2016848: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED 201684c: 80 a2 bf ff cmp %o2, -1 <== NOT EXECUTED 2016850: 32 bf ff fb bne,a 201683c <_Objects_Copy_name_raw+0x8> <== NOT EXECUTED 2016854: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED *destination_p++ = *source_p++; } 2016858: 81 c3 e0 08 retl <== NOT EXECUTED 201685c: 01 00 00 00 nop 02007394 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 2007394: 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; 2007398: 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 ) 200739c: e0 16 20 10 lduh [ %i0 + 0x10 ], %l0 20073a0: 03 00 00 3f sethi %hi(0xfc00), %g1 20073a4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20073a8: a2 08 80 01 and %g2, %g1, %l1 20073ac: 80 a4 00 11 cmp %l0, %l1 20073b0: 3a 80 00 06 bcc,a 20073c8 <_Objects_Extend_information+0x34> 20073b4: e4 06 20 18 ld [ %i0 + 0x18 ], %l2 20073b8: ac 10 00 11 mov %l1, %l6 20073bc: 90 10 20 00 clr %o0 20073c0: 10 80 00 12 b 2007408 <_Objects_Extend_information+0x74> 20073c4: b8 10 20 00 clr %i4 block_count = 0; else { block_count = information->maximum / information->allocation_size; 20073c8: 90 10 00 10 mov %l0, %o0 20073cc: 92 10 00 12 mov %l2, %o1 20073d0: 40 00 37 a1 call 2015254 <.udiv> 20073d4: ac 10 00 11 mov %l1, %l6 20073d8: 10 80 00 09 b 20073fc <_Objects_Extend_information+0x68> 20073dc: b8 10 20 00 clr %i4 for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 20073e0: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 20073e4: c2 00 40 02 ld [ %g1 + %g2 ], %g1 20073e8: 80 a0 60 00 cmp %g1, 0 20073ec: 02 80 00 08 be 200740c <_Objects_Extend_information+0x78> 20073f0: 80 a5 80 10 cmp %l6, %l0 break; else index_base += information->allocation_size; 20073f4: 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++ ) { 20073f8: b8 07 20 01 inc %i4 20073fc: 80 a7 00 08 cmp %i4, %o0 2007400: 12 bf ff f8 bne 20073e0 <_Objects_Extend_information+0x4c> 2007404: 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 ) { 2007408: 80 a5 80 10 cmp %l6, %l0 200740c: 2a 80 00 63 bcs,a 2007598 <_Objects_Extend_information+0x204> 2007410: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 2007414: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2007418: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 200741c: ae 04 00 01 add %l0, %g1, %l7 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2007420: 80 a0 a0 00 cmp %g2, 0 /* * Up the block count and maximum */ block_count++; 2007424: a0 02 20 01 add %o0, 1, %l0 2007428: 82 05 c0 11 add %l7, %l1, %g1 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 200742c: 02 80 00 0b be 2007458 <_Objects_Extend_information+0xc4> 2007430: 91 2c 20 01 sll %l0, 1, %o0 object_blocks = (void**) 2007434: 90 02 00 10 add %o0, %l0, %o0 2007438: 90 00 40 08 add %g1, %o0, %o0 200743c: 7f ff ff cf call 2007378 <_Workspace_Allocate> 2007440: 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 ) 2007444: a4 92 20 00 orcc %o0, 0, %l2 2007448: 32 80 00 0a bne,a 2007470 <_Objects_Extend_information+0xdc> 200744c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 2007450: 81 c7 e0 08 ret <== NOT EXECUTED 2007454: 81 e8 00 00 restore <== NOT EXECUTED return; } else { object_blocks = (void**) 2007458: 90 02 00 10 add %o0, %l0, %o0 200745c: 90 00 40 08 add %g1, %o0, %o0 2007460: 40 00 0b 9b call 200a2cc <_Workspace_Allocate_or_fatal_error> 2007464: 91 2a 20 02 sll %o0, 2, %o0 2007468: a4 10 00 08 mov %o0, %l2 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 200746c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 /* * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; 2007470: ba 04 3f ff add %l0, -1, %i5 if ( information->maximum > minimum_index ) { 2007474: 80 a0 40 11 cmp %g1, %l1 2007478: 84 10 20 00 clr %g2 200747c: 83 2c 20 02 sll %l0, 2, %g1 /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 2007480: a8 04 80 01 add %l2, %g1, %l4 object_blocks, block_count * sizeof(void*) ); name_table = (Objects_Name *) _Addresses_Add_offset( 2007484: aa 05 00 01 add %l4, %g1, %l5 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 2007488: 08 80 00 19 bleu 20074ec <_Objects_Extend_information+0x158> 200748c: 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, 2007490: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 2007494: a1 2f 60 02 sll %i5, 2, %l0 2007498: 90 10 00 12 mov %l2, %o0 200749c: 40 00 1d a6 call 200eb34 20074a0: 94 10 00 10 mov %l0, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 20074a4: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 20074a8: 94 10 00 10 mov %l0, %o2 20074ac: 40 00 1d a2 call 200eb34 20074b0: 90 10 00 14 mov %l4, %o0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, 20074b4: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 20074b8: 94 10 00 10 mov %l0, %o2 20074bc: 40 00 1d 9e call 200eb34 20074c0: 90 10 00 15 mov %l5, %o0 information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 20074c4: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 20074c8: d2 06 20 20 ld [ %i0 + 0x20 ], %o1 20074cc: 94 02 80 11 add %o2, %l1, %o2 20074d0: 90 10 00 13 mov %l3, %o0 20074d4: 40 00 1d 98 call 200eb34 20074d8: 95 2a a0 02 sll %o2, 2, %o2 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 20074dc: 10 80 00 08 b 20074fc <_Objects_Extend_information+0x168> 20074e0: 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++ ) { 20074e4: 84 00 a0 01 inc %g2 local_table[ index ] = NULL; 20074e8: 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++ ) { 20074ec: 80 a0 80 11 cmp %g2, %l1 20074f0: 32 bf ff fd bne,a 20074e4 <_Objects_Extend_information+0x150> 20074f4: 83 28 a0 02 sll %g2, 2, %g1 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 20074f8: 83 2f 60 02 sll %i5, 2, %g1 inactive_per_block[block_count] = 0; 20074fc: c0 25 00 01 clr [ %l4 + %g1 ] /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 2007500: 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 ); 2007504: 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; 2007508: c0 25 40 01 clr [ %l5 + %g1 ] for ( index=index_base ; index < ( information->allocation_size + index_base ); 200750c: 83 2d a0 02 sll %l6, 2, %g1 2007510: 86 05 80 02 add %l6, %g2, %g3 2007514: 84 04 c0 01 add %l3, %g1, %g2 2007518: 10 80 00 04 b 2007528 <_Objects_Extend_information+0x194> 200751c: 82 10 00 16 mov %l6, %g1 index++ ) { local_table[ index ] = NULL; 2007520: 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++ ) { 2007524: 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 ); 2007528: 80 a0 40 03 cmp %g1, %g3 200752c: 0a bf ff fd bcs 2007520 <_Objects_Extend_information+0x18c> 2007530: 84 00 a0 04 add %g2, 4, %g2 index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 2007534: 7f ff ea 0a call 2001d5c 2007538: 01 00 00 00 nop 200753c: 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( 2007540: d0 06 00 00 ld [ %i0 ], %o0 2007544: 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; 2007548: e8 26 20 38 st %l4, [ %i0 + 0x38 ] information->name_table = name_table; 200754c: ea 26 20 24 st %l5, [ %i0 + 0x24 ] information->local_table = local_table; 2007550: e6 26 20 20 st %l3, [ %i0 + 0x20 ] information->maximum = maximum; 2007554: ee 36 20 10 sth %l7, [ %i0 + 0x10 ] information->maximum_id = _Objects_Build_id( 2007558: 97 2d e0 10 sll %l7, 0x10, %o3 local_table[ index ] = NULL; } _ISR_Disable( level ); old_tables = information->object_blocks; 200755c: 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( 2007560: 97 32 e0 10 srl %o3, 0x10, %o3 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; 2007564: 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( 2007568: 7f ff ff 7d call 200735c <_Objects_Build_id> 200756c: 94 10 20 01 mov 1, %o2 2007570: d0 26 20 0c st %o0, [ %i0 + 0xc ] information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 2007574: 7f ff e9 fe call 2001d6c 2007578: 90 10 00 10 mov %l0, %o0 if ( old_tables ) 200757c: 80 a4 60 00 cmp %l1, 0 2007580: 02 80 00 05 be 2007594 <_Objects_Extend_information+0x200> 2007584: 11 00 80 62 sethi %hi(0x2018800), %o0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2007588: 92 10 00 11 mov %l1, %o1 200758c: 7f ff fe 1a call 2006df4 <_Heap_Free> 2007590: 90 12 23 3c or %o0, 0x33c, %o0 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 2007594: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 2007598: e2 06 20 3c ld [ %i0 + 0x3c ], %l1 200759c: 80 a0 60 00 cmp %g1, 0 20075a0: a1 2f 20 02 sll %i4, 2, %l0 20075a4: d0 16 20 44 lduh [ %i0 + 0x44 ], %o0 20075a8: 02 80 00 11 be 20075ec <_Objects_Extend_information+0x258> 20075ac: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 information->object_blocks[ block ] = 20075b0: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 20075b4: 91 2a 20 10 sll %o0, 0x10, %o0 20075b8: 91 32 20 10 srl %o0, 0x10, %o0 20075bc: 40 00 36 ec call 201516c <.umul> 20075c0: 90 02 00 01 add %o0, %g1, %o0 20075c4: 7f ff ff 6d call 2007378 <_Workspace_Allocate> 20075c8: 01 00 00 00 nop _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 20075cc: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { information->object_blocks[ block ] = 20075d0: 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 ] ) 20075d4: c2 00 40 10 ld [ %g1 + %l0 ], %g1 20075d8: 80 a0 60 00 cmp %g1, 0 20075dc: 32 80 00 0d bne,a 2007610 <_Objects_Extend_information+0x27c> 20075e0: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 20075e4: 81 c7 e0 08 ret <== NOT EXECUTED 20075e8: 81 e8 00 00 restore <== NOT EXECUTED return; } else { information->object_blocks[ block ] = 20075ec: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 20075f0: 91 2a 20 10 sll %o0, 0x10, %o0 20075f4: 91 32 20 10 srl %o0, 0x10, %o0 20075f8: 40 00 36 dd call 201516c <.umul> 20075fc: 90 02 00 01 add %o0, %g1, %o0 2007600: 40 00 0b 33 call 200a2cc <_Workspace_Allocate_or_fatal_error> 2007604: 01 00 00 00 nop 2007608: d0 24 00 11 st %o0, [ %l0 + %l1 ] 200760c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 2007610: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 2007614: 40 00 36 d6 call 201516c <.umul> 2007618: 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( 200761c: a7 2f 20 02 sll %i4, 2, %l3 information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 2007620: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 2007624: c2 04 00 13 ld [ %l0 + %l3 ], %g1 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007628: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 200762c: a2 02 00 01 add %o0, %g1, %l1 2007630: 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; 2007634: e2 20 80 13 st %l1, [ %g2 + %l3 ] /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007638: d2 04 00 13 ld [ %l0 + %l3 ], %o1 200763c: 90 07 bf ec add %fp, -20, %o0 2007640: 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 ) { 2007644: aa 10 00 08 mov %o0, %l5 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007648: 40 00 15 3d call 200cb3c <_Chain_Initialize> 200764c: a8 06 20 28 add %i0, 0x28, %l4 2007650: 30 80 00 0c b,a 2007680 <_Objects_Extend_information+0x2ec> index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 2007654: d2 16 20 04 lduh [ %i0 + 4 ], %o1 2007658: d0 06 00 00 ld [ %i0 ], %o0 200765c: 7f ff ff 40 call 200735c <_Objects_Build_id> 2007660: a4 04 a0 01 inc %l2 2007664: c2 16 20 44 lduh [ %i0 + 0x44 ], %g1 2007668: d0 24 20 08 st %o0, [ %l0 + 8 ] information->the_class, _Objects_Local_node, index ); the_object->name = (void *) name_area; 200766c: 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 ); 2007670: 92 10 00 10 mov %l0, %o1 2007674: a2 04 40 01 add %l1, %g1, %l1 2007678: 7f ff fc 7b call 2006864 <_Chain_Append> 200767c: 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 ) { 2007680: 7f ff fc 85 call 2006894 <_Chain_Get> 2007684: 90 10 00 15 mov %l5, %o0 the_object->id = _Objects_Build_id( 2007688: 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 ) { 200768c: a0 10 00 08 mov %o0, %l0 2007690: 80 a2 20 00 cmp %o0, 0 2007694: 12 bf ff f0 bne 2007654 <_Objects_Extend_information+0x2c0> 2007698: 94 10 20 01 mov 1, %o2 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 200769c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 20076a0: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 information->inactive += information->allocation_size; 20076a4: c6 16 20 34 lduh [ %i0 + 0x34 ], %g3 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 20076a8: c2 20 80 13 st %g1, [ %g2 + %l3 ] information->inactive += information->allocation_size; 20076ac: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 20076b0: 82 00 40 03 add %g1, %g3, %g1 20076b4: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 20076b8: 81 c7 e0 08 ret 20076bc: 81 e8 00 00 restore 0200921c <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 200921c: 9d e3 bf 88 save %sp, -120, %sp 2009220: 92 10 00 18 mov %i0, %o1 uint32_t i; char lname[5]; Objects_Control *the_object; Objects_Locations location; if ( length == 0 ) 2009224: 80 a6 60 00 cmp %i1, 0 2009228: 02 80 00 43 be 2009334 <_Objects_Get_name_as_string+0x118> 200922c: b0 10 00 1a mov %i2, %i0 return NULL; if ( name == NULL ) 2009230: 80 a6 a0 00 cmp %i2, 0 2009234: 02 80 00 3e be 200932c <_Objects_Get_name_as_string+0x110> 2009238: 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 ]; 200923c: 03 00 80 95 sethi %hi(0x2025400), %g1 2009240: 84 08 a0 1c and %g2, 0x1c, %g2 2009244: 82 10 62 60 or %g1, 0x260, %g1 2009248: c4 00 40 02 ld [ %g1 + %g2 ], %g2 200924c: 83 32 60 1b srl %o1, 0x1b, %g1 2009250: 83 28 60 02 sll %g1, 2, %g1 2009254: e0 00 80 01 ld [ %g2 + %g1 ], %l0 return NULL; information = _Objects_Get_information( id ); if ( !information ) 2009258: 80 a4 20 00 cmp %l0, 0 200925c: 22 80 00 34 be,a 200932c <_Objects_Get_name_as_string+0x110> 2009260: b0 10 20 00 clr %i0 <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, id, &location ); 2009264: 90 10 00 10 mov %l0, %o0 2009268: 40 00 00 36 call 2009340 <_Objects_Get> 200926c: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 2009270: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009274: 80 a0 60 00 cmp %g1, 0 2009278: 32 80 00 2d bne,a 200932c <_Objects_Get_name_as_string+0x110> 200927c: b0 10 20 00 clr %i0 <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 2009280: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 2009284: 80 a0 60 00 cmp %g1, 0 2009288: 12 80 00 0b bne 20092b4 <_Objects_Get_name_as_string+0x98> 200928c: 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; 2009290: 83 32 20 18 srl %o0, 0x18, %g1 2009294: c2 2f bf ef stb %g1, [ %fp + -17 ] lname[ 1 ] = (u32_name >> 16) & 0xff; 2009298: 83 32 20 10 srl %o0, 0x10, %g1 lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; 200929c: 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; 20092a0: c2 2f bf f0 stb %g1, [ %fp + -16 ] lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20092a4: 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; 20092a8: 83 32 20 08 srl %o0, 8, %g1 lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20092ac: 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; 20092b0: c2 2f bf f1 stb %g1, [ %fp + -15 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20092b4: 84 10 00 18 mov %i0, %g2 20092b8: 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; 20092bc: 10 80 00 09 b 20092e0 <_Objects_Get_name_as_string+0xc4> 20092c0: 19 00 80 73 sethi %hi(0x201cc00), %o4 20092c4: c2 03 23 98 ld [ %o4 + 0x398 ], %g1 ! 201cf98 <__ctype_ptr> 20092c8: c2 48 40 03 ldsb [ %g1 + %g3 ], %g1 20092cc: 80 88 60 97 btst 0x97, %g1 20092d0: 22 80 00 02 be,a 20092d8 <_Objects_Get_name_as_string+0xbc> 20092d4: 9a 10 20 2a mov 0x2a, %o5 <== NOT EXECUTED 20092d8: 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++ ) { 20092dc: 84 00 a0 01 inc %g2 20092e0: 80 a1 00 19 cmp %g4, %i1 20092e4: 02 80 00 07 be 2009300 <_Objects_Get_name_as_string+0xe4> 20092e8: 82 02 00 04 add %o0, %g4, %g1 20092ec: c6 48 7f ff ldsb [ %g1 + -1 ], %g3 20092f0: 88 01 20 01 inc %g4 20092f4: 80 a0 e0 00 cmp %g3, 0 20092f8: 12 bf ff f3 bne 20092c4 <_Objects_Get_name_as_string+0xa8> 20092fc: da 08 7f ff ldub [ %g1 + -1 ], %o5 *d = (!isprint(*s)) ? '*' : *s; } *d = '\0'; 2009300: 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 ) 2009304: 03 00 80 95 sethi %hi(0x2025400), %g1 2009308: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 2025700 <_Thread_Dispatch_disable_level> 200930c: 84 00 bf ff add %g2, -1, %g2 2009310: c4 20 63 00 st %g2, [ %g1 + 0x300 ] 2009314: c2 00 63 00 ld [ %g1 + 0x300 ], %g1 2009318: 80 a0 60 00 cmp %g1, 0 200931c: 12 80 00 07 bne 2009338 <_Objects_Get_name_as_string+0x11c> 2009320: 01 00 00 00 nop _Thread_Dispatch(); 2009324: 40 00 04 cd call 200a658 <_Thread_Dispatch> 2009328: 01 00 00 00 nop 200932c: 81 c7 e0 08 ret 2009330: 81 e8 00 00 restore 2009334: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 2009338: 81 c7 e0 08 ret <== NOT EXECUTED 200933c: 81 e8 00 00 restore <== NOT EXECUTED 02016860 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 2016860: 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) 2016864: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 2016868: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <== NOT EXECUTED 201686c: 80 8e 40 01 btst %i1, %g1 <== NOT EXECUTED 2016870: 22 80 00 02 be,a 2016878 <_Objects_Get_next+0x18> <== NOT EXECUTED 2016874: 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) 2016878: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 201687c: a0 10 63 ff or %g1, 0x3ff, %l0 ! ffff <== NOT EXECUTED 2016880: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED 2016884: 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); 2016888: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 201688c: 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) 2016890: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2016894: 18 80 00 0a bgu 20168bc <_Objects_Get_next+0x5c> <== NOT EXECUTED 2016898: 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); 201689c: 7f ff d5 e2 call 200c024 <_Objects_Get> <== NOT EXECUTED 20168a0: b2 06 60 01 inc %i1 <== NOT EXECUTED next_id++; } while (*location_p != OBJECTS_LOCAL); 20168a4: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 20168a8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20168ac: 32 bf ff f6 bne,a 2016884 <_Objects_Get_next+0x24> <== NOT EXECUTED 20168b0: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED *next_id_p = next_id; 20168b4: 10 80 00 07 b 20168d0 <_Objects_Get_next+0x70> <== NOT EXECUTED 20168b8: 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; 20168bc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 20168c0: 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; 20168c4: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 20168c8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED 20168cc: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED return 0; } 20168d0: 81 c7 e0 08 ret <== NOT EXECUTED 20168d4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 02014a60 <_Objects_Get_no_protection>: ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 2014a60: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->maximum >= index ) { 2014a64: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 2014a68: 92 22 40 01 sub %o1, %g1, %o1 2014a6c: 82 02 60 01 add %o1, 1, %g1 if ( information->maximum >= index ) { 2014a70: 80 a0 80 01 cmp %g2, %g1 2014a74: 0a 80 00 0b bcs 2014aa0 <_Objects_Get_no_protection+0x40> 2014a78: 83 28 60 02 sll %g1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 2014a7c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2014a80: d0 00 80 01 ld [ %g2 + %g1 ], %o0 2014a84: 80 a2 20 00 cmp %o0, 0 2014a88: 02 80 00 04 be 2014a98 <_Objects_Get_no_protection+0x38> 2014a8c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_LOCAL; 2014a90: 81 c3 e0 08 retl 2014a94: c0 22 80 00 clr [ %o2 ] return the_object; } *location = OBJECTS_ERROR; 2014a98: 81 c3 e0 08 retl <== NOT EXECUTED 2014a9c: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED return NULL; } *location = OBJECTS_ERROR; 2014aa0: 82 10 20 02 mov 2, %g1 2014aa4: 90 10 20 00 clr %o0 /* * Not supported for multiprocessing */ return NULL; } 2014aa8: 81 c3 e0 08 retl 2014aac: c2 22 80 00 st %g1, [ %o2 ] 02007a2c <_Objects_Handler_initialization>: uint32_t node, uint32_t maximum_nodes, uint32_t maximum_global_objects ) { if ( node < 1 || node > maximum_nodes ) 2007a2c: 80 a2 20 00 cmp %o0, 0 2007a30: 22 80 00 05 be,a 2007a44 <_Objects_Handler_initialization+0x18> 2007a34: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007a38: 80 a2 00 09 cmp %o0, %o1 2007a3c: 08 80 00 07 bleu 2007a58 <_Objects_Handler_initialization+0x2c> 2007a40: 90 10 20 00 clr %o0 _Internal_error_Occurred( 2007a44: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2007a48: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED 2007a4c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2007a50: 7f ff fd ed call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2007a54: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2007a58: 81 c3 e0 08 retl 2007a5c: 01 00 00 00 nop 02008e70 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 2008e70: 9d e3 bf 90 save %sp, -112, %sp 2008e74: 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 ) 2008e78: 80 a6 60 00 cmp %i1, 0 2008e7c: 02 80 00 26 be 2008f14 <_Objects_Id_to_name+0xa4> 2008e80: 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); 2008e84: 83 32 60 18 srl %o1, 0x18, %g1 2008e88: 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 ) 2008e8c: 80 a0 60 04 cmp %g1, 4 2008e90: 18 80 00 23 bgu 2008f1c <_Objects_Id_to_name+0xac> 2008e94: 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 ]; 2008e98: 03 00 80 75 sethi %hi(0x201d400), %g1 2008e9c: 82 10 61 70 or %g1, 0x170, %g1 ! 201d570 <_Objects_Information_table> 2008ea0: c4 00 40 02 ld [ %g1 + %g2 ], %g2 2008ea4: 83 32 60 1b srl %o1, 0x1b, %g1 2008ea8: 83 28 60 02 sll %g1, 2, %g1 2008eac: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( !information ) 2008eb0: 80 a2 20 00 cmp %o0, 0 2008eb4: 02 80 00 18 be 2008f14 <_Objects_Id_to_name+0xa4> 2008eb8: b0 10 20 03 mov 3, %i0 return OBJECTS_INVALID_ID; if ( information->is_string ) 2008ebc: c2 02 20 40 ld [ %o0 + 0x40 ], %g1 2008ec0: 80 a0 60 00 cmp %g1, 0 2008ec4: 12 80 00 17 bne 2008f20 <_Objects_Id_to_name+0xb0> 2008ec8: 01 00 00 00 nop return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, id, &ignored_location ); 2008ecc: 7f ff ff c4 call 2008ddc <_Objects_Get> 2008ed0: 94 07 bf f4 add %fp, -12, %o2 if ( !the_object ) 2008ed4: 80 a2 20 00 cmp %o0, 0 2008ed8: 02 80 00 0f be 2008f14 <_Objects_Id_to_name+0xa4> 2008edc: b0 10 20 03 mov 3, %i0 return OBJECTS_INVALID_ID; *name = the_object->name; 2008ee0: c2 02 20 0c ld [ %o0 + 0xc ], %g1 2008ee4: 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 ) 2008ee8: 05 00 80 75 sethi %hi(0x201d400), %g2 2008eec: c2 00 a2 10 ld [ %g2 + 0x210 ], %g1 ! 201d610 <_Thread_Dispatch_disable_level> 2008ef0: b0 10 20 00 clr %i0 2008ef4: 82 00 7f ff add %g1, -1, %g1 2008ef8: c2 20 a2 10 st %g1, [ %g2 + 0x210 ] 2008efc: c2 00 a2 10 ld [ %g2 + 0x210 ], %g1 2008f00: 80 a0 60 00 cmp %g1, 0 2008f04: 12 80 00 07 bne 2008f20 <_Objects_Id_to_name+0xb0> 2008f08: 01 00 00 00 nop _Thread_Dispatch(); 2008f0c: 40 00 04 e7 call 200a2a8 <_Thread_Dispatch> 2008f10: 01 00 00 00 nop 2008f14: 81 c7 e0 08 ret 2008f18: 81 e8 00 00 restore 2008f1c: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 2008f20: 81 c7 e0 08 ret <== NOT EXECUTED 2008f24: 81 e8 00 00 restore <== NOT EXECUTED 02007930 <_Objects_Name_to_id>: Objects_Information *information, Objects_Name name, uint32_t node, Objects_Id *id ) { 2007930: 9d e3 bf 98 save %sp, -104, %sp 2007934: 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 ) 2007938: 80 a6 e0 00 cmp %i3, 0 200793c: 02 80 00 3a be 2007a24 <_Objects_Name_to_id+0xf4> 2007940: b0 10 20 02 mov 2, %i0 return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 2007944: 80 a6 60 00 cmp %i1, 0 2007948: 02 80 00 2d be 20079fc <_Objects_Name_to_id+0xcc> 200794c: 01 00 00 00 nop return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007950: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 2007954: 80 a0 60 00 cmp %g1, 0 2007958: 02 80 00 29 be 20079fc <_Objects_Name_to_id+0xcc> 200795c: 80 a6 a0 00 cmp %i2, 0 2007960: 22 80 00 2a be,a 2007a08 <_Objects_Name_to_id+0xd8> 2007964: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2007968: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 200796c: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff 2007970: 80 a6 80 01 cmp %i2, %g1 2007974: 02 80 00 24 be 2007a04 <_Objects_Name_to_id+0xd4> 2007978: 80 a6 a0 01 cmp %i2, 1 200797c: 22 80 00 23 be,a 2007a08 <_Objects_Name_to_id+0xd8> 2007980: 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++ ) { 2007984: 81 c7 e0 08 ret 2007988: 91 e8 20 01 restore %g0, 1, %o0 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 200798c: a4 10 63 60 or %g1, 0x360, %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 ) ) { 2007990: 83 28 a0 10 sll %g2, 0x10, %g1 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007994: 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 ) ) { 2007998: 10 80 00 15 b 20079ec <_Objects_Name_to_id+0xbc> 200799c: 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 ]; 20079a0: 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++ ) { 20079a4: a0 04 20 01 inc %l0 the_object = information->local_table[ index ]; 20079a8: f4 00 40 02 ld [ %g1 + %g2 ], %i2 if ( !the_object || !the_object->name ) 20079ac: 80 a6 a0 00 cmp %i2, 0 20079b0: 02 80 00 0f be 20079ec <_Objects_Name_to_id+0xbc> 20079b4: 90 10 00 19 mov %i1, %o0 20079b8: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 20079bc: 80 a2 60 00 cmp %o1, 0 20079c0: 02 80 00 0b be 20079ec <_Objects_Name_to_id+0xbc> 20079c4: 94 10 00 18 mov %i0, %o2 continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 20079c8: 9f c4 80 00 call %l2 20079cc: 01 00 00 00 nop 20079d0: 80 a2 20 00 cmp %o0, 0 20079d4: 22 80 00 07 be,a 20079f0 <_Objects_Name_to_id+0xc0> 20079d8: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 *id = the_object->id; 20079dc: c2 06 a0 08 ld [ %i2 + 8 ], %g1 20079e0: c2 26 c0 00 st %g1, [ %i3 ] 20079e4: 81 c7 e0 08 ret 20079e8: 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++ ) { 20079ec: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 20079f0: 80 a4 00 01 cmp %l0, %g1 20079f4: 08 bf ff eb bleu 20079a0 <_Objects_Name_to_id+0x70> 20079f8: 85 2c 20 02 sll %l0, 2, %g2 20079fc: 81 c7 e0 08 ret 2007a00: 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; 2007a04: 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; 2007a08: c4 14 60 44 lduh [ %l1 + 0x44 ], %g2 if ( information->is_string ) compare_them = _Objects_Compare_name_string; 2007a0c: 80 a0 60 00 cmp %g1, 0 2007a10: 03 00 80 33 sethi %hi(0x200cc00), %g1 2007a14: 02 bf ff df be 2007990 <_Objects_Name_to_id+0x60> 2007a18: a4 10 63 50 or %g1, 0x350, %l2 ! 200cf50 <_Objects_Compare_name_raw> if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007a1c: 10 bf ff dc b 200798c <_Objects_Name_to_id+0x5c> 2007a20: 03 00 80 33 sethi %hi(0x200cc00), %g1 return ( _Objects_MP_Global_name_search( information, name, node, id ) ); #else return OBJECTS_INVALID_NAME; #endif } 2007a24: 81 c7 e0 08 ret <== NOT EXECUTED 2007a28: 81 e8 00 00 restore <== NOT EXECUTED 02007a60 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 2007a60: 9d e3 bf 98 save %sp, -104, %sp 2007a64: 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; 2007a68: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 2007a6c: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0 2007a70: 03 00 00 3f sethi %hi(0xfc00), %g1 2007a74: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2007a78: 92 10 00 10 mov %l0, %o1 2007a7c: a2 08 80 01 and %g2, %g1, %l1 2007a80: 40 00 35 f5 call 2015254 <.udiv> 2007a84: 90 22 00 11 sub %o0, %l1, %o0 2007a88: 86 10 20 00 clr %g3 2007a8c: 10 80 00 33 b 2007b58 <_Objects_Shrink_information+0xf8> 2007a90: a4 10 20 00 clr %l2 for ( block = 0; block < block_count; block++ ) { 2007a94: 86 00 e0 01 inc %g3 if ( information->inactive_per_block[ block ] == information->allocation_size ) { 2007a98: c2 00 40 12 ld [ %g1 + %l2 ], %g1 2007a9c: 80 a0 40 10 cmp %g1, %l0 2007aa0: 12 80 00 2c bne 2007b50 <_Objects_Shrink_information+0xf0> 2007aa4: 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; 2007aa8: e0 06 20 28 ld [ %i0 + 0x28 ], %l0 2007aac: 03 00 00 3f sethi %hi(0xfc00), %g1 2007ab0: a6 10 63 ff or %g1, 0x3ff, %l3 ! ffff 2007ab4: c2 04 20 08 ld [ %l0 + 8 ], %g1 2007ab8: 84 08 40 13 and %g1, %l3, %g2 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 2007abc: 80 a0 80 11 cmp %g2, %l1 2007ac0: 2a 80 00 0c bcs,a 2007af0 <_Objects_Shrink_information+0x90> 2007ac4: e0 04 00 00 ld [ %l0 ], %l0 2007ac8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2007acc: 82 04 40 01 add %l1, %g1, %g1 2007ad0: 80 a0 80 01 cmp %g2, %g1 2007ad4: 1a 80 00 06 bcc 2007aec <_Objects_Shrink_information+0x8c> 2007ad8: 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 ); 2007adc: 40 00 14 0e call 200cb14 <_Chain_Extract> 2007ae0: 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 ) ); 2007ae4: 10 80 00 04 b 2007af4 <_Objects_Shrink_information+0x94> 2007ae8: 80 a4 20 00 cmp %l0, 0 the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 2007aec: e0 04 00 00 ld [ %l0 ], %l0 } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 2007af0: 80 a4 20 00 cmp %l0, 0 2007af4: 22 80 00 07 be,a 2007b10 <_Objects_Shrink_information+0xb0> 2007af8: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED 2007afc: c2 04 00 00 ld [ %l0 ], %g1 2007b00: 80 a0 60 00 cmp %g1, 0 2007b04: 32 bf ff ed bne,a 2007ab8 <_Objects_Shrink_information+0x58> 2007b08: c2 04 20 08 ld [ %l0 + 8 ], %g1 2007b0c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 2007b10: 11 00 80 62 sethi %hi(0x2018800), %o0 2007b14: d2 00 40 12 ld [ %g1 + %l2 ], %o1 2007b18: 7f ff fc b7 call 2006df4 <_Heap_Free> 2007b1c: 90 12 23 3c or %o0, 0x33c, %o0 */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 2007b20: 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; 2007b24: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 2007b28: 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; 2007b2c: c8 06 20 3c ld [ %i0 + 0x3c ], %g4 information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2007b30: c2 16 20 34 lduh [ %i0 + 0x34 ], %g1 2007b34: 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; 2007b38: c0 20 c0 12 clr [ %g3 + %l2 ] information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2007b3c: 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; 2007b40: c0 21 00 12 clr [ %g4 + %l2 ] information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2007b44: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 2007b48: 81 c7 e0 08 ret 2007b4c: 81 e8 00 00 restore return; } index_base += information->allocation_size; 2007b50: 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++ ) { 2007b54: a4 10 00 02 mov %g2, %l2 2007b58: 80 a0 c0 08 cmp %g3, %o0 2007b5c: 32 bf ff ce bne,a 2007a94 <_Objects_Shrink_information+0x34> 2007b60: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 2007b64: 81 c7 e0 08 ret 2007b68: 81 e8 00 00 restore 0200664c <_POSIX_API_Initialize>: void _POSIX_API_Initialize( rtems_configuration_table *configuration_table ) { 200664c: 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; 2006650: f0 06 20 30 ld [ %i0 + 0x30 ], %i0 if ( !api_configuration ) 2006654: 80 a6 20 00 cmp %i0, 0 2006658: 32 80 00 05 bne,a 200666c <_POSIX_API_Initialize+0x20> 200665c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 2006660: 03 00 80 61 sethi %hi(0x2018400), %g1 <== NOT EXECUTED 2006664: b0 10 62 dc or %g1, 0x2dc, %i0 ! 20186dc <_POSIX_Default_configuration> <== NOT EXECUTED api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; _POSIX_signals_Manager_Initialization( 2006668: 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; 200666c: 05 00 80 62 sethi %hi(0x2018800), %g2 2006670: 03 00 80 64 sethi %hi(0x2019000), %g1 2006674: 82 10 60 88 or %g1, 0x88, %g1 ! 2019088 <_POSIX_Objects> _POSIX_signals_Manager_Initialization( 2006678: 40 00 16 ab call 200c124 <_POSIX_signals_Manager_Initialization> 200667c: c2 20 a2 5c st %g1, [ %g2 + 0x25c ] api_configuration->maximum_queued_signals ); _POSIX_Threads_Manager_initialization( 2006680: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 2006684: d4 06 20 30 ld [ %i0 + 0x30 ], %o2 2006688: 40 00 17 1b call 200c2f4 <_POSIX_Threads_Manager_initialization> 200668c: 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( 2006690: 40 00 16 53 call 200bfdc <_POSIX_Condition_variables_Manager_initialization> 2006694: d0 06 20 08 ld [ %i0 + 8 ], %o0 api_configuration->maximum_condition_variables ); _POSIX_Key_Manager_initialization( api_configuration->maximum_keys ); 2006698: 40 00 16 5d call 200c00c <_POSIX_Key_Manager_initialization> 200669c: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _POSIX_Mutex_Manager_initialization( 20066a0: 40 00 16 7d call 200c094 <_POSIX_Mutex_Manager_initialization> 20066a4: d0 06 20 04 ld [ %i0 + 4 ], %o0 api_configuration->maximum_mutexes ); _POSIX_Message_queue_Manager_initialization( 20066a8: 40 00 16 65 call 200c03c <_POSIX_Message_queue_Manager_initialization> 20066ac: d0 06 20 18 ld [ %i0 + 0x18 ], %o0 api_configuration->maximum_message_queues ); _POSIX_Semaphore_Manager_initialization( 20066b0: 40 00 17 ce call 200c5e8 <_POSIX_Semaphore_Manager_initialization> 20066b4: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 api_configuration->maximum_semaphores ); _POSIX_Timer_Manager_initialization( api_configuration->maximum_timers ); 20066b8: 40 00 17 bf call 200c5b4 <_POSIX_Timer_Manager_initialization> 20066bc: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); 20066c0: 40 00 16 81 call 200c0c4 <_POSIX_Barrier_Manager_initialization> 20066c4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); 20066c8: 40 00 16 8b call 200c0f4 <_POSIX_RWLock_Manager_initialization> 20066cc: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 20066d0: f0 06 20 28 ld [ %i0 + 0x28 ], %i0 20066d4: 40 00 16 f2 call 200c29c <_POSIX_Spinlock_Manager_initialization> 20066d8: 81 e8 00 00 restore 20066dc: 01 00 00 00 nop 0200d5ac <_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 ) 200d5ac: 80 a2 20 03 cmp %o0, 3 200d5b0: 08 80 00 05 bleu 200d5c4 <_POSIX_Barrier_Translate_core_barrier_return_code+0x18> 200d5b4: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_Barrier_Return_codes[the_barrier_status]; return POSIX_BOTTOM_REACHED(); 200d5b8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 200d5bc: 7f ff e2 a1 call 2006040 <== NOT EXECUTED 200d5c0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED } 200d5c4: 03 00 80 61 sethi %hi(0x2018400), %g1 200d5c8: 82 10 61 f8 or %g1, 0x1f8, %g1 ! 20185f8 <_POSIX_Barrier_Return_codes> 200d5cc: 81 c3 e0 08 retl 200d5d0: d0 00 40 02 ld [ %g1 + %g2 ], %o0 020063bc <_POSIX_Condition_variables_Signal_support>: int _POSIX_Condition_variables_Signal_support( pthread_cond_t *cond, boolean is_broadcast ) { 20063bc: 9d e3 bf 90 save %sp, -112, %sp ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 20063c0: 80 a6 20 00 cmp %i0, 0 20063c4: 02 80 00 0d be 20063f8 <_POSIX_Condition_variables_Signal_support+0x3c> 20063c8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 20063cc: c2 06 00 00 ld [ %i0 ], %g1 20063d0: 80 a0 7f ff cmp %g1, -1 20063d4: 32 80 00 0c bne,a 2006404 <_POSIX_Condition_variables_Signal_support+0x48> 20063d8: d2 06 00 00 ld [ %i0 ], %o1 /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 20063dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20063e0: 7f ff ff ba call 20062c8 <== NOT EXECUTED 20063e4: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 20063e8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20063ec: 22 80 00 06 be,a 2006404 <_POSIX_Condition_variables_Signal_support+0x48> <== NOT EXECUTED 20063f0: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; 20063f4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20063f8: a0 10 20 00 clr %l0 20063fc: 10 80 00 07 b 2006418 <_POSIX_Condition_variables_Signal_support+0x5c> 2006400: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 2006404: 11 00 80 63 sethi %hi(0x2018c00), %o0 2006408: 94 07 bf f4 add %fp, -12, %o2 200640c: 40 00 0e b8 call 2009eec <_Objects_Get> 2006410: 90 12 20 6c or %o0, 0x6c, %o0 2006414: 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 ) { 2006418: c2 07 bf f4 ld [ %fp + -12 ], %g1 200641c: 80 a0 60 00 cmp %g1, 0 2006420: 02 80 00 06 be 2006438 <_POSIX_Condition_variables_Signal_support+0x7c> 2006424: b0 04 20 18 add %l0, 0x18, %i0 2006428: 80 a0 60 02 cmp %g1, 2 200642c: 08 80 00 1c bleu 200649c <_POSIX_Condition_variables_Signal_support+0xe0> 2006430: 90 10 20 16 mov 0x16, %o0 2006434: 30 80 00 18 b,a 2006494 <_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 ); 2006438: 40 00 14 9c call 200b6a8 <_Thread_queue_Dequeue> 200643c: 90 10 00 18 mov %i0, %o0 if ( !the_thread ) 2006440: 80 a2 20 00 cmp %o0, 0 2006444: 22 80 00 02 be,a 200644c <_POSIX_Condition_variables_Signal_support+0x90> 2006448: c0 24 20 14 clr [ %l0 + 0x14 ] the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; } while ( is_broadcast && the_thread ); 200644c: 80 a6 60 00 cmp %i1, 0 2006450: 02 80 00 04 be 2006460 <_POSIX_Condition_variables_Signal_support+0xa4> 2006454: 80 a2 20 00 cmp %o0, 0 2006458: 12 bf ff f8 bne 2006438 <_POSIX_Condition_variables_Signal_support+0x7c> 200645c: 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 ) 2006460: 03 00 80 61 sethi %hi(0x2018400), %g1 2006464: c4 00 63 20 ld [ %g1 + 0x320 ], %g2 ! 2018720 <_Thread_Dispatch_disable_level> 2006468: 90 10 20 00 clr %o0 200646c: 84 00 bf ff add %g2, -1, %g2 2006470: c4 20 63 20 st %g2, [ %g1 + 0x320 ] 2006474: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 2006478: 80 a0 60 00 cmp %g1, 0 200647c: 12 80 00 08 bne 200649c <_POSIX_Condition_variables_Signal_support+0xe0> 2006480: 01 00 00 00 nop _Thread_Dispatch(); 2006484: 40 00 13 60 call 200b204 <_Thread_Dispatch> 2006488: 01 00 00 00 nop 200648c: 10 80 00 04 b 200649c <_POSIX_Condition_variables_Signal_support+0xe0> 2006490: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006494: 40 00 04 47 call 20075b0 <== NOT EXECUTED 2006498: 01 00 00 00 nop <== NOT EXECUTED } 200649c: 81 c7 e0 08 ret 20064a0: 91 e8 00 08 restore %g0, %o0, %o0 0200653c <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, boolean already_timedout ) { 200653c: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2006540: 80 a6 60 00 cmp %i1, 0 2006544: 22 80 00 40 be,a 2006644 <_POSIX_Condition_variables_Wait_support+0x108> 2006548: b0 10 20 16 mov 0x16, %i0 200654c: c2 06 40 00 ld [ %i1 ], %g1 2006550: 80 a0 7f ff cmp %g1, -1 2006554: 32 80 00 09 bne,a 2006578 <_POSIX_Condition_variables_Wait_support+0x3c> 2006558: d2 06 40 00 ld [ %i1 ], %o1 200655c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2006560: 40 00 00 c2 call 2006868 <== NOT EXECUTED 2006564: 92 10 20 00 clr %o1 <== NOT EXECUTED 2006568: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200656c: 32 80 00 36 bne,a 2006644 <_POSIX_Condition_variables_Wait_support+0x108> <== NOT EXECUTED 2006570: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED return (POSIX_Mutex_Control *) 2006574: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED 2006578: 11 00 80 62 sethi %hi(0x2018800), %o0 200657c: 94 07 bf f4 add %fp, -12, %o2 2006580: 40 00 0e 5b call 2009eec <_Objects_Get> 2006584: 90 12 23 84 or %o0, 0x384, %o0 register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 2006588: 80 a2 20 00 cmp %o0, 0 200658c: 22 80 00 2e be,a 2006644 <_POSIX_Condition_variables_Wait_support+0x108> 2006590: 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; 2006594: 05 00 80 61 sethi %hi(0x2018400), %g2 2006598: c2 00 a3 20 ld [ %g2 + 0x320 ], %g1 ! 2018720 <_Thread_Dispatch_disable_level> ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 200659c: 80 a6 20 00 cmp %i0, 0 20065a0: 82 00 7f ff add %g1, -1, %g1 20065a4: c2 20 a3 20 st %g1, [ %g2 + 0x320 ] 20065a8: 02 80 00 0d be 20065dc <_POSIX_Condition_variables_Wait_support+0xa0> 20065ac: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 20065b0: c2 06 00 00 ld [ %i0 ], %g1 20065b4: 80 a0 7f ff cmp %g1, -1 20065b8: 32 80 00 0c bne,a 20065e8 <_POSIX_Condition_variables_Wait_support+0xac> 20065bc: d2 06 00 00 ld [ %i0 ], %o1 /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 20065c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20065c4: 7f ff ff 41 call 20062c8 <== NOT EXECUTED 20065c8: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 20065cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20065d0: 22 80 00 06 be,a 20065e8 <_POSIX_Condition_variables_Wait_support+0xac> <== NOT EXECUTED 20065d4: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; 20065d8: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20065dc: a2 10 20 00 clr %l1 20065e0: 10 80 00 07 b 20065fc <_POSIX_Condition_variables_Wait_support+0xc0> 20065e4: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 20065e8: 11 00 80 63 sethi %hi(0x2018c00), %o0 20065ec: 94 07 bf f4 add %fp, -12, %o2 20065f0: 40 00 0e 3f call 2009eec <_Objects_Get> 20065f4: 90 12 20 6c or %o0, 0x6c, %o0 20065f8: a2 10 00 08 mov %o0, %l1 } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 20065fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006600: 80 a0 60 00 cmp %g1, 0 2006604: 22 80 00 07 be,a 2006620 <_POSIX_Condition_variables_Wait_support+0xe4> 2006608: c4 04 60 14 ld [ %l1 + 0x14 ], %g2 200660c: 80 a0 60 02 cmp %g1, 2 2006610: 18 80 00 36 bgu 20066e8 <_POSIX_Condition_variables_Wait_support+0x1ac> 2006614: 01 00 00 00 nop if ( mutex_status ) return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); 2006618: 81 c7 e0 08 ret 200661c: 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 ) ) { 2006620: 80 a0 a0 00 cmp %g2, 0 2006624: 02 80 00 0a be 200664c <_POSIX_Condition_variables_Wait_support+0x110> 2006628: 01 00 00 00 nop 200662c: c2 06 40 00 ld [ %i1 ], %g1 2006630: 80 a0 80 01 cmp %g2, %g1 2006634: 02 80 00 06 be 200664c <_POSIX_Condition_variables_Wait_support+0x110> 2006638: 01 00 00 00 nop _Thread_Enable_dispatch(); 200663c: 7f ff ff b3 call 2006508 <_Thread_Enable_dispatch> <== NOT EXECUTED 2006640: b0 10 20 16 mov 0x16, %i0 ! 16 <== NOT EXECUTED 2006644: 81 c7 e0 08 ret 2006648: 81 e8 00 00 restore return EINVAL; } (void) pthread_mutex_unlock( mutex ); 200664c: 40 00 01 95 call 2006ca0 2006650: 90 10 00 19 mov %i1, %o0 _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 2006654: 80 a6 e0 00 cmp %i3, 0 2006658: 12 80 00 1b bne 20066c4 <_POSIX_Condition_variables_Wait_support+0x188> 200665c: 21 00 80 62 sethi %hi(0x2018800), %l0 the_cond->Mutex = *mutex; 2006660: c2 06 40 00 ld [ %i1 ], %g1 2006664: c2 24 60 14 st %g1, [ %l1 + 0x14 ] _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 2006668: c2 04 20 00 ld [ %l0 ], %g1 _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; 200666c: 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; 2006670: 84 04 60 18 add %l1, 0x18, %g2 _Thread_Executing->Wait.id = *cond; 2006674: 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; 2006678: c4 20 60 44 st %g2, [ %g1 + 0x44 ] _Thread_Executing->Wait.id = *cond; _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 200667c: 92 10 00 1a mov %i2, %o1 2006680: 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; 2006684: 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 ); 2006688: 15 00 80 2f sethi %hi(0x200bc00), %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; 200668c: 82 10 20 01 mov 1, %g1 2006690: 94 12 a1 80 or %o2, 0x180, %o2 2006694: 40 00 14 73 call 200b860 <_Thread_queue_Enqueue_with_handler> 2006698: c2 24 60 48 st %g1, [ %l1 + 0x48 ] _Thread_Enable_dispatch(); 200669c: 7f ff ff 9b call 2006508 <_Thread_Enable_dispatch> 20066a0: 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; 20066a4: c2 04 20 00 ld [ %l0 ], %g1 20066a8: f0 00 60 34 ld [ %g1 + 0x34 ], %i0 if ( status && status != ETIMEDOUT ) 20066ac: 80 a6 20 00 cmp %i0, 0 20066b0: 02 80 00 07 be 20066cc <_POSIX_Condition_variables_Wait_support+0x190> 20066b4: 80 a6 20 74 cmp %i0, 0x74 20066b8: 12 80 00 0f bne 20066f4 <_POSIX_Condition_variables_Wait_support+0x1b8> 20066bc: 01 00 00 00 nop 20066c0: 30 80 00 03 b,a 20066cc <_POSIX_Condition_variables_Wait_support+0x190> return status; } else { _Thread_Enable_dispatch(); 20066c4: 7f ff ff 91 call 2006508 <_Thread_Enable_dispatch> 20066c8: b0 10 20 74 mov 0x74, %i0 /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 20066cc: 40 00 00 c7 call 20069e8 20066d0: 90 10 00 19 mov %i1, %o0 if ( mutex_status ) 20066d4: 80 a2 20 00 cmp %o0, 0 20066d8: 02 80 00 07 be 20066f4 <_POSIX_Condition_variables_Wait_support+0x1b8> 20066dc: 01 00 00 00 nop return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); 20066e0: 81 c7 e0 08 ret 20066e4: 91 e8 20 16 restore %g0, 0x16, %o0 20066e8: 40 00 03 b2 call 20075b0 <== NOT EXECUTED 20066ec: 01 00 00 00 nop <== NOT EXECUTED 20066f0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED } 20066f4: 81 c7 e0 08 ret 20066f8: 81 e8 00 00 restore 0200da64 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 200da64: 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 ); 200da68: 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 ]; 200da6c: 05 00 00 3f sethi %hi(0xfc00), %g2 200da70: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200da74: 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); 200da78: 83 30 60 16 srl %g1, 0x16, %g1 200da7c: a7 28 a0 02 sll %g2, 2, %l3 200da80: a8 08 60 1c and %g1, 0x1c, %l4 200da84: a4 10 20 00 clr %l2 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 200da88: 03 00 80 63 sethi %hi(0x2018c00), %g1 200da8c: aa 10 63 f0 or %g1, 0x3f0, %l5 ! 2018ff0 <_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 ]; 200da90: a0 10 20 01 mov 1, %l0 200da94: 10 80 00 1b b 200db00 <_POSIX_Keys_Run_destructors+0x9c> 200da98: 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 *) 200da9c: c2 05 60 20 ld [ %l5 + 0x20 ], %g1 200daa0: c4 00 40 02 ld [ %g1 + %g2 ], %g2 _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { 200daa4: 80 a0 a0 00 cmp %g2, 0 200daa8: 02 80 00 16 be 200db00 <_POSIX_Keys_Run_destructors+0x9c> 200daac: a0 04 20 01 inc %l0 200dab0: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 200dab4: 80 a0 60 00 cmp %g1, 0 200dab8: 02 80 00 12 be 200db00 <_POSIX_Keys_Run_destructors+0x9c> 200dabc: b0 05 00 02 add %l4, %g2, %i0 200dac0: c4 00 a0 14 ld [ %g2 + 0x14 ], %g2 200dac4: 80 a0 a0 00 cmp %g2, 0 200dac8: 22 80 00 0f be,a 200db04 <_POSIX_Keys_Run_destructors+0xa0> 200dacc: c2 15 60 10 lduh [ %l5 + 0x10 ], %g1 <== NOT EXECUTED value = the_key->Values[ thread_api ][ thread_index ]; 200dad0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 200dad4: c2 00 40 13 ld [ %g1 + %l3 ], %g1 if ( value ) { 200dad8: 90 90 60 00 orcc %g1, 0, %o0 200dadc: 22 80 00 0a be,a 200db04 <_POSIX_Keys_Run_destructors+0xa0> 200dae0: c2 15 60 10 lduh [ %l5 + 0x10 ], %g1 <== NOT EXECUTED (*the_key->destructor)( value ); 200dae4: 9f c0 80 00 call %g2 200dae8: 01 00 00 00 nop if ( the_key->Values[ thread_api ][ thread_index ] ) 200daec: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 200daf0: c2 00 40 13 ld [ %g1 + %l3 ], %g1 200daf4: 80 a0 00 01 cmp %g0, %g1 200daf8: 82 40 3f ff addx %g0, -1, %g1 200dafc: a2 0c 40 01 and %l1, %g1, %l1 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 200db00: c2 15 60 10 lduh [ %l5 + 0x10 ], %g1 200db04: 80 a4 00 01 cmp %l0, %g1 200db08: 08 bf ff e5 bleu 200da9c <_POSIX_Keys_Run_destructors+0x38> 200db0c: 85 2c 20 02 sll %l0, 2, %g2 are_all_null = FALSE; } } } if ( are_all_null == TRUE ) 200db10: 80 a4 60 01 cmp %l1, 1 200db14: 02 80 00 05 be 200db28 <_POSIX_Keys_Run_destructors+0xc4> 200db18: 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 ) 200db1c: 80 a4 a0 04 cmp %l2, 4 200db20: 12 bf ff dd bne 200da94 <_POSIX_Keys_Run_destructors+0x30> 200db24: a0 10 20 01 mov 1, %l0 200db28: 81 c7 e0 08 ret 200db2c: 81 e8 00 00 restore 02012bb8 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 2012bb8: 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 ); 2012bbc: 92 10 20 ff mov 0xff, %o1 2012bc0: 40 00 11 be call 20172b8 2012bc4: 90 10 00 18 mov %i0, %o0 const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 2012bc8: 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 ); 2012bcc: a0 10 00 08 mov %o0, %l0 const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 2012bd0: 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 ) 2012bd4: 80 a2 20 ff cmp %o0, 0xff 2012bd8: 18 80 00 62 bgu 2012d60 <_POSIX_Message_queue_Create_support+0x1a8> 2012bdc: b0 10 20 5b mov 0x5b, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2012be0: 05 00 80 8e sethi %hi(0x2023800), %g2 2012be4: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 ! 2023950 <_Thread_Dispatch_disable_level> 2012be8: 82 00 60 01 inc %g1 2012bec: c2 20 a1 50 st %g1, [ %g2 + 0x150 ] * 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 ) { 2012bf0: a4 10 20 10 mov 0x10, %l2 2012bf4: 80 a6 a0 00 cmp %i2, 0 2012bf8: 02 80 00 14 be 2012c48 <_POSIX_Message_queue_Create_support+0x90> 2012bfc: a2 10 20 0a mov 0xa, %l1 attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 2012c00: c2 06 a0 04 ld [ %i2 + 4 ], %g1 2012c04: 80 a0 60 00 cmp %g1, 0 2012c08: 04 80 00 06 ble 2012c20 <_POSIX_Message_queue_Create_support+0x68> 2012c0c: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 2012c10: c2 06 a0 08 ld [ %i2 + 8 ], %g1 2012c14: 80 a0 60 00 cmp %g1, 0 2012c18: 34 80 00 08 bg,a 2012c38 <_POSIX_Message_queue_Create_support+0x80> 2012c1c: 90 07 bf e8 add %fp, -24, %o0 _Thread_Enable_dispatch(); 2012c20: 7f ff ff d9 call 2012b84 <_Thread_Enable_dispatch> 2012c24: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); 2012c28: 40 00 0a 5b call 2015594 <__errno> 2012c2c: 01 00 00 00 nop 2012c30: 10 80 00 3a b 2012d18 <_POSIX_Message_queue_Create_support+0x160> 2012c34: 82 10 20 16 mov 0x16, %g1 ! 16 } attr = *attr_ptr; 2012c38: 40 00 0c 3d call 2015d2c 2012c3c: 94 10 20 10 mov 0x10, %o2 2012c40: e4 07 bf f0 ld [ %fp + -16 ], %l2 2012c44: 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 *) 2012c48: 27 00 80 8f sethi %hi(0x2023c00), %l3 2012c4c: 7f ff ec 39 call 200dd30 <_Objects_Allocate> 2012c50: 90 14 e1 68 or %l3, 0x168, %o0 ! 2023d68 <_POSIX_Message_queue_Information> rtems_set_errno_and_return_minus_one( ENFILE ); } #endif the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 2012c54: b4 92 20 00 orcc %o0, 0, %i2 2012c58: 32 80 00 08 bne,a 2012c78 <_POSIX_Message_queue_Create_support+0xc0> 2012c5c: 82 10 20 01 mov 1, %g1 _Thread_Enable_dispatch(); 2012c60: 7f ff ff c9 call 2012b84 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012c64: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENFILE ); 2012c68: 40 00 0a 4b call 2015594 <__errno> <== NOT EXECUTED 2012c6c: 01 00 00 00 nop <== NOT EXECUTED 2012c70: 10 80 00 2a b 2012d18 <_POSIX_Message_queue_Create_support+0x160> <== NOT EXECUTED 2012c74: 82 10 20 17 mov 0x17, %g1 ! 17 <== NOT EXECUTED } the_mq->process_shared = pshared; 2012c78: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] 2012c7c: 92 10 00 10 mov %l0, %o1 the_mq->named = TRUE; the_mq->open_count = 1; the_mq->linked = TRUE; 2012c80: 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; 2012c84: c2 26 a0 14 st %g1, [ %i2 + 0x14 ] the_mq->open_count = 1; 2012c88: c2 26 a0 1c st %g1, [ %i2 + 0x1c ] 2012c8c: 21 00 80 8e sethi %hi(0x2023800), %l0 2012c90: 7f ff ea d0 call 200d7d0 <_Heap_Allocate> 2012c94: 90 14 21 9c or %l0, 0x19c, %o0 ! 202399c <_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) { 2012c98: b2 92 20 00 orcc %o0, 0, %i1 2012c9c: 12 80 00 0a bne 2012cc4 <_POSIX_Message_queue_Create_support+0x10c> 2012ca0: 01 00 00 00 nop _POSIX_Message_queue_Free( the_mq ); 2012ca4: 7f ff ff b1 call 2012b68 <_POSIX_Message_queue_Free> <== NOT EXECUTED 2012ca8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); 2012cac: 7f ff ff b6 call 2012b84 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012cb0: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 2012cb4: 40 00 0a 38 call 2015594 <__errno> <== NOT EXECUTED 2012cb8: 01 00 00 00 nop <== NOT EXECUTED 2012cbc: 10 80 00 17 b 2012d18 <_POSIX_Message_queue_Create_support+0x160> <== NOT EXECUTED 2012cc0: 82 10 20 0c mov 0xc, %g1 ! c <== NOT EXECUTED } strcpy( name, name_arg ); 2012cc4: 40 00 0f 18 call 2016924 2012cc8: 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( 2012ccc: 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; 2012cd0: c0 26 a0 60 clr [ %i2 + 0x60 ] if ( ! _CORE_message_queue_Initialize( 2012cd4: 96 10 00 12 mov %l2, %o3 2012cd8: 90 06 a0 20 add %i2, 0x20, %o0 2012cdc: 40 00 03 56 call 2013a34 <_CORE_message_queue_Initialize> 2012ce0: 92 06 a0 60 add %i2, 0x60, %o1 2012ce4: 80 a2 20 00 cmp %o0, 0 2012ce8: 12 80 00 0f bne 2012d24 <_POSIX_Message_queue_Create_support+0x16c> 2012cec: 90 14 e1 68 or %l3, 0x168, %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 ); 2012cf0: 7f ff ff 9e call 2012b68 <_POSIX_Message_queue_Free> <== NOT EXECUTED 2012cf4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2012cf8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2012cfc: 7f ff ea dc call 200d86c <_Heap_Free> <== NOT EXECUTED 2012d00: 90 14 21 9c or %l0, 0x19c, %o0 <== NOT EXECUTED _Workspace_Free(name); _Thread_Enable_dispatch(); 2012d04: 7f ff ff a0 call 2012b84 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012d08: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 2012d0c: 40 00 0a 22 call 2015594 <__errno> <== NOT EXECUTED 2012d10: 01 00 00 00 nop <== NOT EXECUTED 2012d14: 82 10 20 1c mov 0x1c, %g1 ! 1c <== NOT EXECUTED 2012d18: c2 22 00 00 st %g1, [ %o0 ] 2012d1c: 81 c7 e0 08 ret 2012d20: 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 ); 2012d24: c2 06 a0 08 ld [ %i2 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012d28: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2012d2c: 05 00 00 3f sethi %hi(0xfc00), %g2 2012d30: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2012d34: 82 08 40 02 and %g1, %g2, %g1 2012d38: 80 a0 40 03 cmp %g1, %g3 2012d3c: 38 80 00 06 bgu,a 2012d54 <_POSIX_Message_queue_Create_support+0x19c> 2012d40: f4 26 c0 00 st %i2, [ %i3 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2012d44: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2012d48: 83 28 60 02 sll %g1, 2, %g1 2012d4c: f4 20 80 01 st %i2, [ %g2 + %g1 ] &_POSIX_Message_queue_Information, &the_mq->Object, (char *) name ); *message_queue = the_mq; 2012d50: 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; 2012d54: f2 26 a0 0c st %i1, [ %i2 + 0xc ] (char *) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 2012d58: 7f ff ff 8b call 2012b84 <_Thread_Enable_dispatch> 2012d5c: b0 10 20 00 clr %i0 return 0; } 2012d60: 81 c7 e0 08 ret 2012d64: 81 e8 00 00 restore 02009980 <_POSIX_Message_queue_Delete>: */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq ) { 2009980: 9d e3 bf 98 save %sp, -104, %sp if ( !the_mq->linked && !the_mq->open_count ) { 2009984: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2009988: 80 a0 60 00 cmp %g1, 0 200998c: 12 80 00 1f bne 2009a08 <_POSIX_Message_queue_Delete+0x88> 2009990: b2 10 00 18 mov %i0, %i1 2009994: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 2009998: 80 a0 60 00 cmp %g1, 0 200999c: 12 80 00 1b bne 2009a08 <_POSIX_Message_queue_Delete+0x88> 20099a0: 01 00 00 00 nop /* the name memory may have been freed by unlink. */ if ( the_mq->Object.name ) 20099a4: d2 06 20 0c ld [ %i0 + 0xc ], %o1 20099a8: 80 a2 60 00 cmp %o1, 0 20099ac: 02 80 00 04 be 20099bc <_POSIX_Message_queue_Delete+0x3c> 20099b0: 11 00 80 8e sethi %hi(0x2023800), %o0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 20099b4: 40 00 0f ae call 200d86c <_Heap_Free> <== NOT EXECUTED 20099b8: 90 12 21 9c or %o0, 0x19c, %o0 ! 202399c <_Workspace_Area> <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20099bc: 03 00 80 8f sethi %hi(0x2023c00), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 20099c0: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20099c4: b0 10 61 68 or %g1, 0x168, %i0 20099c8: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 20099cc: 03 00 00 3f sethi %hi(0xfc00), %g1 20099d0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20099d4: 82 08 c0 01 and %g3, %g1, %g1 20099d8: 80 a0 40 02 cmp %g1, %g2 20099dc: 18 80 00 05 bgu 20099f0 <_POSIX_Message_queue_Delete+0x70> 20099e0: 90 06 60 20 add %i1, 0x20, %o0 information->local_table[ index ] = the_object; 20099e4: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 20099e8: 83 28 60 02 sll %g1, 2, %g1 20099ec: 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( 20099f0: 92 10 20 00 clr %o1 20099f4: 94 10 20 05 mov 5, %o2 20099f8: 40 00 0d 7a call 200cfe0 <_CORE_message_queue_Close> 20099fc: 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 ); 2009a00: 40 00 11 ce call 200e138 <_Objects_Free> 2009a04: 81 e8 00 00 restore 2009a08: 81 c7 e0 08 ret 2009a0c: 81 e8 00 00 restore 02012b68 <_POSIX_Message_queue_Free>: */ RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free ( POSIX_Message_queue_Control *the_mq ) { 2012b68: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object ); 2012b6c: 11 00 80 8f sethi %hi(0x2023c00), %o0 <== NOT EXECUTED 2012b70: 90 12 21 68 or %o0, 0x168, %o0 ! 2023d68 <_POSIX_Message_queue_Information> <== NOT EXECUTED 2012b74: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2012b78: 7f ff ed 70 call 200e138 <_Objects_Free> <== NOT EXECUTED 2012b7c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2012b80: 01 00 00 00 nop 02009eb0 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, boolean wait, Watchdog_Interval timeout ) { 2009eb0: 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 *) 2009eb4: 11 00 80 8f sethi %hi(0x2023c00), %o0 2009eb8: 94 07 bf f4 add %fp, -12, %o2 2009ebc: 90 12 23 20 or %o0, 0x320, %o0 2009ec0: 40 00 10 e0 call 200e240 <_Objects_Get> 2009ec4: 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 ) { 2009ec8: c2 07 bf f4 ld [ %fp + -12 ], %g1 size_t msg_len, unsigned int *msg_prio, boolean wait, Watchdog_Interval timeout ) { 2009ecc: 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 ) { 2009ed0: 80 a0 60 01 cmp %g1, 1 2009ed4: 02 80 00 09 be 2009ef8 <_POSIX_Message_queue_Receive_support+0x48> 2009ed8: 9a 10 00 1d mov %i5, %o5 2009edc: 80 a0 60 01 cmp %g1, 1 2009ee0: 2a 80 00 0c bcs,a 2009f10 <_POSIX_Message_queue_Receive_support+0x60> 2009ee4: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 2009ee8: 80 a0 60 02 cmp %g1, 2 2009eec: 12 80 00 3f bne 2009fe8 <_POSIX_Message_queue_Receive_support+0x138> 2009ef0: 01 00 00 00 nop 2009ef4: 30 80 00 0d b,a 2009f28 <_POSIX_Message_queue_Receive_support+0x78> case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 2009ef8: 40 00 15 98 call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 2009efc: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2009f00: 40 00 05 c9 call 200b624 <== NOT EXECUTED 2009f04: 01 00 00 00 nop <== NOT EXECUTED _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); } 2009f08: 81 c7 e0 08 ret <== NOT EXECUTED 2009f0c: 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 ) { 2009f10: 82 08 a0 03 and %g2, 3, %g1 2009f14: 80 a0 60 01 cmp %g1, 1 2009f18: 32 80 00 0a bne,a 2009f40 <_POSIX_Message_queue_Receive_support+0x90> 2009f1c: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 _Thread_Enable_dispatch(); 2009f20: 7f ff ff d7 call 2009e7c <_Thread_Enable_dispatch> 2009f24: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EBADF ); 2009f28: 40 00 2d 9b call 2015594 <__errno> 2009f2c: 01 00 00 00 nop 2009f30: 82 10 20 09 mov 9, %g1 ! 9 2009f34: c2 22 00 00 st %g1, [ %o0 ] 2009f38: 10 80 00 2e b 2009ff0 <_POSIX_Message_queue_Receive_support+0x140> 2009f3c: 90 10 3f ff mov -1, %o0 } the_mq = the_mq_fd->Queue; if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 2009f40: c2 02 20 6c ld [ %o0 + 0x6c ], %g1 2009f44: 80 a6 80 01 cmp %i2, %g1 2009f48: 1a 80 00 08 bcc 2009f68 <_POSIX_Message_queue_Receive_support+0xb8> 2009f4c: 80 a7 20 00 cmp %i4, 0 _Thread_Enable_dispatch(); 2009f50: 7f ff ff cb call 2009e7c <_Thread_Enable_dispatch> 2009f54: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EMSGSIZE ); 2009f58: 40 00 2d 8f call 2015594 <__errno> 2009f5c: 01 00 00 00 nop 2009f60: 10 bf ff f5 b 2009f34 <_POSIX_Message_queue_Receive_support+0x84> 2009f64: 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 ) 2009f68: 02 80 00 05 be 2009f7c <_POSIX_Message_queue_Receive_support+0xcc> 2009f6c: 98 10 20 00 clr %o4 do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 2009f70: 83 30 a0 0e srl %g2, 0xe, %g1 2009f74: 82 18 60 01 xor %g1, 1, %g1 2009f78: 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; 2009f7c: 82 10 3f ff mov -1, %g1 do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 2009f80: 90 02 20 20 add %o0, 0x20, %o0 2009f84: 92 10 00 18 mov %i0, %o1 2009f88: 96 07 bf f0 add %fp, -16, %o3 2009f8c: 40 00 0c 42 call 200d094 <_CORE_message_queue_Seize> 2009f90: c2 27 bf f0 st %g1, [ %fp + -16 ] &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 2009f94: 7f ff ff ba call 2009e7c <_Thread_Enable_dispatch> 2009f98: 3b 00 80 8e sethi %hi(0x2023800), %i5 *msg_prio = 2009f9c: c4 07 62 30 ld [ %i5 + 0x230 ], %g2 ! 2023a30 <_Thread_Executing> 2009fa0: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 2009fa4: c6 00 a0 34 ld [ %g2 + 0x34 ], %g3 do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 2009fa8: 85 38 60 1f sra %g1, 0x1f, %g2 2009fac: 82 18 80 01 xor %g2, %g1, %g1 2009fb0: 82 20 40 02 sub %g1, %g2, %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 2009fb4: 80 a0 e0 00 cmp %g3, 0 2009fb8: 12 80 00 04 bne 2009fc8 <_POSIX_Message_queue_Receive_support+0x118> 2009fbc: c2 26 c0 00 st %g1, [ %i3 ] return length_out; 2009fc0: 10 80 00 0c b 2009ff0 <_POSIX_Message_queue_Receive_support+0x140> 2009fc4: d0 07 bf f0 ld [ %fp + -16 ], %o0 rtems_set_errno_and_return_minus_one( 2009fc8: 40 00 2d 73 call 2015594 <__errno> 2009fcc: 01 00 00 00 nop 2009fd0: c2 07 62 30 ld [ %i5 + 0x230 ], %g1 2009fd4: a0 10 00 08 mov %o0, %l0 2009fd8: 40 00 00 d2 call 200a320 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 2009fdc: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 2009fe0: 10 bf ff d6 b 2009f38 <_POSIX_Message_queue_Receive_support+0x88> 2009fe4: 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(); 2009fe8: 40 00 05 85 call 200b5fc <== NOT EXECUTED 2009fec: 01 00 00 00 nop <== NOT EXECUTED } 2009ff0: b0 10 00 08 mov %o0, %i0 2009ff4: 81 c7 e0 08 ret 2009ff8: 81 e8 00 00 restore 0200a048 <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, boolean wait, Watchdog_Interval timeout ) { 200a048: 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 ) 200a04c: 80 a6 e0 20 cmp %i3, 0x20 200a050: 28 80 00 06 bleu,a 200a068 <_POSIX_Message_queue_Send_support+0x20> 200a054: 11 00 80 8f sethi %hi(0x2023c00), %o0 rtems_set_errno_and_return_minus_one( EINVAL ); 200a058: 40 00 2d 4f call 2015594 <__errno> 200a05c: 01 00 00 00 nop 200a060: 10 80 00 12 b 200a0a8 <_POSIX_Message_queue_Send_support+0x60> 200a064: 82 10 20 16 mov 0x16, %g1 ! 16 200a068: 92 10 00 18 mov %i0, %o1 200a06c: 90 12 23 20 or %o0, 0x320, %o0 200a070: 40 00 10 74 call 200e240 <_Objects_Get> 200a074: 94 07 bf f4 add %fp, -12, %o2 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 200a078: c2 07 bf f4 ld [ %fp + -12 ], %g1 200a07c: 80 a0 60 01 cmp %g1, 1 200a080: 02 80 00 0d be 200a0b4 <_POSIX_Message_queue_Send_support+0x6c> 200a084: 01 00 00 00 nop 200a088: 2a 80 00 11 bcs,a 200a0cc <_POSIX_Message_queue_Send_support+0x84> 200a08c: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 200a090: 80 a0 60 02 cmp %g1, 2 200a094: 12 80 00 35 bne 200a168 <_POSIX_Message_queue_Send_support+0x120> 200a098: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 200a09c: 40 00 2d 3e call 2015594 <__errno> 200a0a0: 01 00 00 00 nop 200a0a4: 82 10 20 09 mov 9, %g1 ! 9 200a0a8: c2 22 00 00 st %g1, [ %o0 ] 200a0ac: 10 80 00 31 b 200a170 <_POSIX_Message_queue_Send_support+0x128> 200a0b0: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 200a0b4: 40 00 15 29 call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 200a0b8: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 200a0bc: 40 00 05 5a call 200b624 <== NOT EXECUTED 200a0c0: 01 00 00 00 nop <== NOT EXECUTED msg_status ) ); } return POSIX_BOTTOM_REACHED(); } 200a0c4: 81 c7 e0 08 ret <== NOT EXECUTED 200a0c8: 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 ) { 200a0cc: 80 88 a0 03 btst 3, %g2 200a0d0: 12 80 00 05 bne 200a0e4 <_POSIX_Message_queue_Send_support+0x9c> 200a0d4: 80 a7 20 00 cmp %i4, 0 _Thread_Enable_dispatch(); 200a0d8: 7f ff ff cf call 200a014 <_Thread_Enable_dispatch> 200a0dc: 01 00 00 00 nop 200a0e0: 30 bf ff ef b,a 200a09c <_POSIX_Message_queue_Send_support+0x54> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 200a0e4: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 200a0e8: 02 80 00 05 be 200a0fc <_POSIX_Message_queue_Send_support+0xb4> 200a0ec: 82 10 20 00 clr %g1 do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 200a0f0: 83 30 a0 0e srl %g2, 0xe, %g1 200a0f4: 82 18 60 01 xor %g1, 1, %g1 200a0f8: 82 08 60 01 and %g1, 1, %g1 do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 200a0fc: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 200a100: fa 23 a0 60 st %i5, [ %sp + 0x60 ] 200a104: 92 10 00 19 mov %i1, %o1 200a108: 94 10 00 1a mov %i2, %o2 200a10c: 96 10 00 18 mov %i0, %o3 200a110: 9a 20 00 1b neg %i3, %o5 200a114: 98 10 20 00 clr %o4 200a118: 40 00 0c 2c call 200d1c8 <_CORE_message_queue_Submit> 200a11c: 90 02 20 20 add %o0, 0x20, %o0 _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout /* no timeout */ ); _Thread_Enable_dispatch(); 200a120: 7f ff ff bd call 200a014 <_Thread_Enable_dispatch> 200a124: 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 ) 200a128: 80 a7 60 07 cmp %i5, 7 200a12c: 12 80 00 06 bne 200a144 <_POSIX_Message_queue_Send_support+0xfc> 200a130: 80 a7 60 00 cmp %i5, 0 msg_status = _Thread_Executing->Wait.return_code; 200a134: 03 00 80 8e sethi %hi(0x2023800), %g1 200a138: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 2023a30 <_Thread_Executing> 200a13c: fa 00 60 34 ld [ %g1 + 0x34 ], %i5 if ( !msg_status ) 200a140: 80 a7 60 00 cmp %i5, 0 200a144: 02 80 00 0b be 200a170 <_POSIX_Message_queue_Send_support+0x128> 200a148: 90 10 20 00 clr %o0 return msg_status; rtems_set_errno_and_return_minus_one( 200a14c: 40 00 2d 12 call 2015594 <__errno> 200a150: 01 00 00 00 nop 200a154: a0 10 00 08 mov %o0, %l0 200a158: 40 00 00 72 call 200a320 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 200a15c: 90 10 00 1d mov %i5, %o0 200a160: 10 bf ff d3 b 200a0ac <_POSIX_Message_queue_Send_support+0x64> 200a164: d0 24 00 00 st %o0, [ %l0 ] _POSIX_Message_queue_Translate_core_message_queue_return_code( msg_status ) ); } return POSIX_BOTTOM_REACHED(); 200a168: 40 00 05 25 call 200b5fc <== NOT EXECUTED 200a16c: 01 00 00 00 nop <== NOT EXECUTED } 200a170: b0 10 00 08 mov %o0, %i0 200a174: 81 c7 e0 08 ret 200a178: 81 e8 00 00 restore 0200a320 <_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 ) { 200a320: 9d e3 bf 98 save %sp, -104, %sp switch ( the_message_queue_status ) { 200a324: 80 a6 20 03 cmp %i0, 3 200a328: 02 80 00 1c be 200a398 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x78> 200a32c: 94 10 00 18 mov %i0, %o2 200a330: 80 a6 20 03 cmp %i0, 3 200a334: 18 80 00 0a bgu 200a35c <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x3c> 200a338: 80 a6 20 05 cmp %i0, 5 200a33c: 80 a6 20 01 cmp %i0, 1 200a340: 02 80 00 1e be 200a3b8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x98> 200a344: b0 10 20 7a mov 0x7a, %i0 200a348: 80 a2 a0 01 cmp %o2, 1 200a34c: 38 80 00 1b bgu,a 200a3b8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x98> 200a350: b0 10 20 0b mov 0xb, %i0 200a354: 81 c7 e0 08 ret <== NOT EXECUTED 200a358: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 200a35c: 02 80 00 11 be 200a3a0 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x80> 200a360: 80 a6 20 05 cmp %i0, 5 200a364: 2a 80 00 15 bcs,a 200a3b8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x98> 200a368: b0 10 20 0b mov 0xb, %i0 200a36c: 80 a6 20 06 cmp %i0, 6 200a370: 02 80 00 08 be 200a390 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x70> 200a374: 03 00 44 44 sethi %hi(0x1111000), %g1 200a378: 82 10 61 11 or %g1, 0x111, %g1 ! 1111111 <== NOT EXECUTED 200a37c: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 200a380: 12 80 00 0a bne 200a3a8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x88> <== NOT EXECUTED 200a384: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED 200a388: 81 c7 e0 08 ret <== NOT EXECUTED 200a38c: 91 e8 20 58 restore %g0, 0x58, %o0 <== NOT EXECUTED 200a390: 81 c7 e0 08 ret 200a394: 91 e8 20 74 restore %g0, 0x74, %o0 /* * Bad message size */ case CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE: return EMSGSIZE; 200a398: 81 c7 e0 08 ret <== NOT EXECUTED 200a39c: 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; 200a3a0: 81 c7 e0 08 ret 200a3a4: 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( 200a3a8: 40 00 0e 35 call 200dc7c <_Internal_error_Occurred> <== NOT EXECUTED 200a3ac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED INTERNAL_ERROR_POSIX_API, TRUE, the_message_queue_status ); return POSIX_BOTTOM_REACHED(); 200a3b0: 40 00 04 93 call 200b5fc <== NOT EXECUTED 200a3b4: 81 e8 00 00 restore <== NOT EXECUTED } 200a3b8: 81 c7 e0 08 ret 200a3bc: 81 e8 00 00 restore 0200f788 <_POSIX_Mutex_From_core_mutex_status>: */ int _POSIX_Mutex_From_core_mutex_status( CORE_mutex_Status status ) { 200f788: 9d e3 bf 98 save %sp, -104, %sp switch ( status ) { 200f78c: 80 a6 20 06 cmp %i0, 6 200f790: 18 80 00 14 bgu 200f7e0 <_POSIX_Mutex_From_core_mutex_status+0x58> 200f794: 92 10 20 32 mov 0x32, %o1 200f798: 83 2e 20 02 sll %i0, 2, %g1 200f79c: 05 00 80 3d sethi %hi(0x200f400), %g2 200f7a0: 84 10 a3 6c or %g2, 0x36c, %g2 ! 200f76c <_POSIX_Message_queue_Manager_initialization+0x58> 200f7a4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 200f7a8: 81 c0 40 00 jmp %g1 200f7ac: 01 00 00 00 nop 200f7b0: 81 c7 e0 08 ret 200f7b4: 91 e8 20 74 restore %g0, 0x74, %o0 200f7b8: 81 c7 e0 08 ret 200f7bc: 91 e8 20 16 restore %g0, 0x16, %o0 200f7c0: 81 c7 e0 08 ret 200f7c4: 91 e8 20 00 restore %g0, 0, %o0 case CORE_MUTEX_STATUS_SUCCESSFUL: return 0; 200f7c8: 81 c7 e0 08 ret 200f7cc: 91 e8 20 10 restore %g0, 0x10, %o0 case CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT: return EBUSY; 200f7d0: 81 c7 e0 08 ret 200f7d4: 91 e8 20 2d restore %g0, 0x2d, %o0 case CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED: return EDEADLK; 200f7d8: 81 c7 e0 08 ret 200f7dc: 91 e8 20 01 restore %g0, 1, %o0 case CORE_MUTEX_STATUS_CEILING_VIOLATED: return EINVAL; default: break; } assert( 0 ); 200f7e0: 11 00 80 62 sethi %hi(0x2018800), %o0 <== NOT EXECUTED 200f7e4: 15 00 80 5b sethi %hi(0x2016c00), %o2 <== NOT EXECUTED 200f7e8: 90 12 22 28 or %o0, 0x228, %o0 <== NOT EXECUTED 200f7ec: 94 12 a3 e0 or %o2, 0x3e0, %o2 <== NOT EXECUTED 200f7f0: 7f ff d1 90 call 2003e30 <__assert> <== NOT EXECUTED 200f7f4: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 200f7f8: 81 c7 e0 08 ret <== NOT EXECUTED 200f7fc: 81 e8 00 00 restore <== NOT EXECUTED 02007440 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, boolean blocking, Watchdog_Interval timeout ) { 2007440: 9d e3 bf 90 save %sp, -112, %sp ISR_Level *level ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007444: 80 a6 20 00 cmp %i0, 0 2007448: 32 80 00 05 bne,a 200745c <_POSIX_Mutex_Lock_support+0x1c> 200744c: c2 06 00 00 ld [ %i0 ], %g1 2007450: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2007454: 10 80 00 15 b 20074a8 <_POSIX_Mutex_Lock_support+0x68> <== NOT EXECUTED 2007458: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED 200745c: 80 a0 7f ff cmp %g1, -1 2007460: 32 80 00 0c bne,a 2007490 <_POSIX_Mutex_Lock_support+0x50> 2007464: d2 06 00 00 ld [ %i0 ], %o1 2007468: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200746c: 7f ff ff 8f call 20072a8 <== NOT EXECUTED 2007470: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007474: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007478: 22 80 00 06 be,a 2007490 <_POSIX_Mutex_Lock_support+0x50> <== NOT EXECUTED 200747c: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 2007480: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2007484: b0 10 20 00 clr %i0 <== NOT EXECUTED 2007488: 10 80 00 08 b 20074a8 <_POSIX_Mutex_Lock_support+0x68> <== NOT EXECUTED 200748c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 2007490: 11 00 80 6a sethi %hi(0x201a800), %o0 2007494: 94 07 bf f4 add %fp, -12, %o2 2007498: 90 12 21 64 or %o0, 0x164, %o0 200749c: 40 00 0e 1d call 200ad10 <_Objects_Get_isr_disable> 20074a0: 96 07 bf f0 add %fp, -16, %o3 20074a4: 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 ) { 20074a8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20074ac: 80 a0 60 00 cmp %g1, 0 20074b0: 22 80 00 06 be,a 20074c8 <_POSIX_Mutex_Lock_support+0x88> 20074b4: 03 00 80 69 sethi %hi(0x201a400), %g1 20074b8: 80 a0 60 02 cmp %g1, 2 20074bc: 08 80 00 86 bleu 20076d4 <_POSIX_Mutex_Lock_support+0x294> 20074c0: 90 10 20 16 mov 0x16, %o0 20074c4: 30 80 00 82 b,a 20076cc <_POSIX_Mutex_Lock_support+0x28c> <== NOT EXECUTED ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 20074c8: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 20074cc: 80 a0 60 00 cmp %g1, 0 20074d0: 02 80 00 0e be 2007508 <_POSIX_Mutex_Lock_support+0xc8> 20074d4: 03 00 80 69 sethi %hi(0x201a400), %g1 20074d8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 20074dc: 02 80 00 0c be 200750c <_POSIX_Mutex_Lock_support+0xcc> <== NOT EXECUTED 20074e0: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 <== NOT EXECUTED 20074e4: 03 00 80 69 sethi %hi(0x201a400), %g1 <== NOT EXECUTED 20074e8: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 ! 201a6e0 <_System_state_Current> <== NOT EXECUTED 20074ec: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20074f0: 08 80 00 05 bleu 2007504 <_POSIX_Mutex_Lock_support+0xc4> <== NOT EXECUTED 20074f4: 90 10 20 00 clr %o0 <== NOT EXECUTED 20074f8: 92 10 20 00 clr %o1 <== NOT EXECUTED 20074fc: 40 00 0c b2 call 200a7c4 <_Internal_error_Occurred> <== NOT EXECUTED 2007500: 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; 2007504: 03 00 80 69 sethi %hi(0x201a400), %g1 <== NOT EXECUTED 2007508: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201a5e0 <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 200750c: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2007510: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2007514: c2 06 20 64 ld [ %i0 + 0x64 ], %g1 2007518: 80 a0 60 00 cmp %g1, 0 200751c: 22 80 00 3a be,a 2007604 <_POSIX_Mutex_Lock_support+0x1c4> 2007520: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 2007524: c0 26 20 64 clr [ %i0 + 0x64 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007528: 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; 200752c: 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; 2007530: 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; 2007534: c4 26 20 70 st %g2, [ %i0 + 0x70 ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2007538: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200753c: 80 a0 e0 02 cmp %g3, 2 2007540: 02 80 00 05 be 2007554 <_POSIX_Mutex_Lock_support+0x114> 2007544: c2 26 20 68 st %g1, [ %i0 + 0x68 ] 2007548: 80 a0 e0 03 cmp %g3, 3 200754c: 32 80 00 06 bne,a 2007564 <_POSIX_Mutex_Lock_support+0x124> 2007550: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2007554: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 2007558: 82 00 60 01 inc %g1 200755c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2007560: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 2007564: 80 a0 60 03 cmp %g1, 3 2007568: 22 80 00 03 be,a 2007574 <_POSIX_Mutex_Lock_support+0x134> 200756c: c6 06 20 60 ld [ %i0 + 0x60 ], %g3 _ISR_Enable( level ); 2007570: 30 80 00 35 b,a 2007644 <_POSIX_Mutex_Lock_support+0x204> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2007574: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 if ( current == ceiling ) { 2007578: 80 a0 40 03 cmp %g1, %g3 200757c: 12 80 00 03 bne 2007588 <_POSIX_Mutex_Lock_support+0x148> 2007580: 01 00 00 00 nop _ISR_Enable( level ); 2007584: 30 80 00 30 b,a 2007644 <_POSIX_Mutex_Lock_support+0x204> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2007588: 08 80 00 17 bleu 20075e4 <_POSIX_Mutex_Lock_support+0x1a4> 200758c: 82 10 20 06 mov 6, %g1 2007590: 21 00 80 69 sethi %hi(0x201a400), %l0 2007594: c2 04 21 00 ld [ %l0 + 0x100 ], %g1 ! 201a500 <_Thread_Dispatch_disable_level> 2007598: 82 00 60 01 inc %g1 200759c: c2 24 21 00 st %g1, [ %l0 + 0x100 ] _Thread_Disable_dispatch(); _ISR_Enable( level ); 20075a0: 7f ff f1 be call 2003c98 20075a4: 01 00 00 00 nop _Thread_Change_priority( 20075a8: d2 06 20 60 ld [ %i0 + 0x60 ], %o1 20075ac: d0 06 20 70 ld [ %i0 + 0x70 ], %o0 20075b0: 40 00 11 7f call 200bbac <_Thread_Change_priority> 20075b4: 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 ) 20075b8: c2 04 21 00 ld [ %l0 + 0x100 ], %g1 20075bc: 82 00 7f ff add %g1, -1, %g1 20075c0: c2 24 21 00 st %g1, [ %l0 + 0x100 ] 20075c4: c2 04 21 00 ld [ %l0 + 0x100 ], %g1 20075c8: 80 a0 60 00 cmp %g1, 0 20075cc: 32 80 00 3b bne,a 20076b8 <_POSIX_Mutex_Lock_support+0x278> 20075d0: 03 00 80 69 sethi %hi(0x201a400), %g1 <== NOT EXECUTED _Thread_Dispatch(); 20075d4: 40 00 12 b3 call 200c0a0 <_Thread_Dispatch> 20075d8: 01 00 00 00 nop the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 20075dc: 10 80 00 37 b 20076b8 <_POSIX_Mutex_Lock_support+0x278> 20075e0: 03 00 80 69 sethi %hi(0x201a400), %g1 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20075e4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] the_mutex->lock = CORE_MUTEX_UNLOCKED; 20075e8: 82 10 20 01 mov 1, %g1 the_mutex->nest_count = 0; /* undo locking above */ 20075ec: 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; 20075f0: c2 26 20 64 st %g1, [ %i0 + 0x64 ] the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 20075f4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 20075f8: 82 00 7f ff add %g1, -1, %g1 20075fc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 2007600: 30 80 00 11 b,a 2007644 <_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 ) ) { 2007604: 80 a0 40 02 cmp %g1, %g2 2007608: 12 80 00 13 bne 2007654 <_POSIX_Mutex_Lock_support+0x214> 200760c: 80 a6 60 00 cmp %i1, 0 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2007610: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 2007614: 80 a0 60 00 cmp %g1, 0 2007618: 22 80 00 07 be,a 2007634 <_POSIX_Mutex_Lock_support+0x1f4> 200761c: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED 2007620: 80 a0 60 01 cmp %g1, 1 2007624: 12 80 00 0c bne 2007654 <_POSIX_Mutex_Lock_support+0x214> 2007628: 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; 200762c: 10 80 00 05 b 2007640 <_POSIX_Mutex_Lock_support+0x200> 2007630: 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++; 2007634: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007638: c2 26 20 68 st %g1, [ %i0 + 0x68 ] <== NOT EXECUTED _ISR_Enable( level ); 200763c: 30 80 00 02 b,a 2007644 <_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; 2007640: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] _ISR_Enable( level ); 2007644: 7f ff f1 95 call 2003c98 2007648: 01 00 00 00 nop 200764c: 10 80 00 1b b 20076b8 <_POSIX_Mutex_Lock_support+0x278> 2007650: 03 00 80 69 sethi %hi(0x201a400), %g1 ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 2007654: 12 80 00 08 bne 2007674 <_POSIX_Mutex_Lock_support+0x234> 2007658: 21 00 80 69 sethi %hi(0x201a400), %l0 200765c: 7f ff f1 8f call 2003c98 2007660: d0 07 bf f0 ld [ %fp + -16 ], %o0 2007664: c4 04 21 e0 ld [ %l0 + 0x1e0 ], %g2 2007668: 82 10 20 01 mov 1, %g1 200766c: 10 80 00 12 b 20076b4 <_POSIX_Mutex_Lock_support+0x274> 2007670: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] 2007674: c8 04 21 e0 ld [ %l0 + 0x1e0 ], %g4 2007678: c6 06 20 08 ld [ %i0 + 8 ], %g3 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200767c: 05 00 80 69 sethi %hi(0x201a400), %g2 2007680: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 ! 201a500 <_Thread_Dispatch_disable_level> 2007684: c6 21 20 20 st %g3, [ %g4 + 0x20 ] 2007688: 82 00 60 01 inc %g1 200768c: a0 06 20 14 add %i0, 0x14, %l0 2007690: c2 20 a1 00 st %g1, [ %g2 + 0x100 ] 2007694: 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; 2007698: 82 10 20 01 mov 1, %g1 200769c: c2 26 20 44 st %g1, [ %i0 + 0x44 ] 20076a0: 7f ff f1 7e call 2003c98 20076a4: d0 07 bf f0 ld [ %fp + -16 ], %o0 20076a8: 90 10 00 10 mov %l0, %o0 20076ac: 40 00 09 fe call 2009ea4 <_CORE_mutex_Seize_interrupt_blocking> 20076b0: 92 10 00 1a mov %i2, %o1 the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 20076b4: 03 00 80 69 sethi %hi(0x201a400), %g1 20076b8: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 ! 201a5e0 <_Thread_Executing> 20076bc: 40 00 20 33 call 200f788 <_POSIX_Mutex_From_core_mutex_status> 20076c0: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_mutex_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20076c4: 81 c7 e0 08 ret 20076c8: 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(); 20076cc: 40 00 03 4b call 20083f8 <== NOT EXECUTED 20076d0: 01 00 00 00 nop <== NOT EXECUTED } 20076d4: b0 10 00 08 mov %o0, %i0 20076d8: 81 c7 e0 08 ret 20076dc: 81 e8 00 00 restore 0200626c <_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 ) 200626c: 80 a2 20 03 cmp %o0, 3 2006270: 08 80 00 05 bleu 2006284 <_POSIX_RWLock_Translate_core_RWLock_return_code+0x18> 2006274: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_RWLock_Return_codes[the_rwlock_status]; return POSIX_BOTTOM_REACHED(); 2006278: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 200627c: 40 00 02 68 call 2006c1c <== NOT EXECUTED 2006280: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED } 2006284: 03 00 80 65 sethi %hi(0x2019400), %g1 2006288: 82 10 62 e4 or %g1, 0x2e4, %g1 ! 20196e4 <_POSIX_RWLock_Return_codes> 200628c: 81 c3 e0 08 retl 2006290: d0 00 40 02 ld [ %g1 + %g2 ], %o0 0200e850 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 200e850: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200e854: 03 00 80 77 sethi %hi(0x201dc00), %g1 200e858: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 201df50 <_Thread_Dispatch_disable_level> 200e85c: 84 00 a0 01 inc %g2 200e860: c4 20 63 50 st %g2, [ %g1 + 0x350 ] char *name_p = (char *)name; _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { 200e864: 80 a6 60 00 cmp %i1, 0 200e868: 02 80 00 08 be 200e888 <_POSIX_Semaphore_Create_support+0x38> 200e86c: 80 a6 20 00 cmp %i0, 0 _Thread_Enable_dispatch(); 200e870: 7f ff ff eb call 200e81c <_Thread_Enable_dispatch> 200e874: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSYS ); 200e878: 40 00 08 a8 call 2010b18 <__errno> 200e87c: 01 00 00 00 nop 200e880: 10 80 00 19 b 200e8e4 <_POSIX_Semaphore_Create_support+0x94> 200e884: 82 10 20 58 mov 0x58, %g1 ! 58 } if ( name ) { 200e888: 02 80 00 0d be 200e8bc <_POSIX_Semaphore_Create_support+0x6c> 200e88c: 11 00 80 78 sethi %hi(0x201e000), %o0 if( strlen(name) > PATH_MAX ) { 200e890: 40 00 0f 1a call 20124f8 200e894: 90 10 00 18 mov %i0, %o0 200e898: 80 a2 20 ff cmp %o0, 0xff 200e89c: 28 80 00 08 bleu,a 200e8bc <_POSIX_Semaphore_Create_support+0x6c> 200e8a0: 11 00 80 78 sethi %hi(0x201e000), %o0 _Thread_Enable_dispatch(); 200e8a4: 7f ff ff de call 200e81c <_Thread_Enable_dispatch> <== NOT EXECUTED 200e8a8: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 200e8ac: 40 00 08 9b call 2010b18 <__errno> <== NOT EXECUTED 200e8b0: 01 00 00 00 nop <== NOT EXECUTED 200e8b4: 10 80 00 0c b 200e8e4 <_POSIX_Semaphore_Create_support+0x94> <== NOT EXECUTED 200e8b8: 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 *) 200e8bc: 7f ff ea 4f call 20091f8 <_Objects_Allocate> 200e8c0: 90 12 22 d0 or %o0, 0x2d0, %o0 } } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 200e8c4: b2 92 20 00 orcc %o0, 0, %i1 200e8c8: 12 80 00 0a bne 200e8f0 <_POSIX_Semaphore_Create_support+0xa0> 200e8cc: 80 a6 20 00 cmp %i0, 0 _Thread_Enable_dispatch(); 200e8d0: 7f ff ff d3 call 200e81c <_Thread_Enable_dispatch> 200e8d4: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSPC ); 200e8d8: 40 00 08 90 call 2010b18 <__errno> 200e8dc: 01 00 00 00 nop 200e8e0: 82 10 20 1c mov 0x1c, %g1 ! 1c 200e8e4: c2 22 00 00 st %g1, [ %o0 ] 200e8e8: 81 c7 e0 08 ret 200e8ec: 91 e8 3f ff restore %g0, -1, %o0 } #endif the_semaphore->process_shared = pshared; if ( name ) { 200e8f0: 02 80 00 07 be 200e90c <_POSIX_Semaphore_Create_support+0xbc> 200e8f4: c0 26 60 10 clr [ %i1 + 0x10 ] the_semaphore->named = TRUE; 200e8f8: 82 10 20 01 mov 1, %g1 the_semaphore->open_count = 1; the_semaphore->linked = TRUE; 200e8fc: c2 26 60 18 st %g1, [ %i1 + 0x18 ] #endif the_semaphore->process_shared = pshared; if ( name ) { the_semaphore->named = TRUE; 200e900: c2 26 60 14 st %g1, [ %i1 + 0x14 ] the_semaphore->open_count = 1; 200e904: 10 80 00 05 b 200e918 <_POSIX_Semaphore_Create_support+0xc8> 200e908: c2 26 60 1c st %g1, [ %i1 + 0x1c ] the_semaphore->linked = TRUE; } else { the_semaphore->named = FALSE; 200e90c: c0 26 60 14 clr [ %i1 + 0x14 ] the_semaphore->open_count = 0; 200e910: c0 26 60 1c clr [ %i1 + 0x1c ] the_semaphore->linked = FALSE; 200e914: c0 26 60 18 clr [ %i1 + 0x18 ] /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 200e918: 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; 200e91c: c0 26 60 64 clr [ %i1 + 0x64 ] /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 200e920: c2 26 60 60 st %g1, [ %i1 + 0x60 ] _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 200e924: 94 10 00 1a mov %i2, %o2 200e928: 90 06 60 20 add %i1, 0x20, %o0 200e92c: 7f ff e8 6d call 2008ae0 <_CORE_semaphore_Initialize> 200e930: 92 06 60 60 add %i1, 0x60, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e934: 03 00 80 78 sethi %hi(0x201e000), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200e938: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e93c: 88 10 62 d0 or %g1, 0x2d0, %g4 200e940: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 200e944: 03 00 00 3f sethi %hi(0xfc00), %g1 200e948: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200e94c: 82 08 c0 01 and %g3, %g1, %g1 200e950: 80 a0 40 02 cmp %g1, %g2 200e954: 38 80 00 06 bgu,a 200e96c <_POSIX_Semaphore_Create_support+0x11c> 200e958: f0 26 60 0c st %i0, [ %i1 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200e95c: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 200e960: 83 28 60 02 sll %g1, 2, %g1 200e964: 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; 200e968: 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; 200e96c: f2 26 c0 00 st %i1, [ %i3 ] name_p, 0 /* proxy id - Not used */ ); #endif _Thread_Enable_dispatch(); 200e970: 7f ff ff ab call 200e81c <_Thread_Enable_dispatch> 200e974: b0 10 20 00 clr %i0 return 0; } 200e978: 81 c7 e0 08 ret 200e97c: 81 e8 00 00 restore 0200ea70 <_POSIX_Semaphore_Wait_support>: int _POSIX_Semaphore_Wait_support( sem_t *sem, boolean blocking, Watchdog_Interval timeout ) { 200ea70: 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 *) 200ea74: d2 06 00 00 ld [ %i0 ], %o1 200ea78: 94 07 bf f4 add %fp, -12, %o2 200ea7c: 11 00 80 78 sethi %hi(0x201e000), %o0 200ea80: 7f ff eb 22 call 2009708 <_Objects_Get> 200ea84: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 201e2d0 <_POSIX_Semaphore_Information> POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 200ea88: c2 07 bf f4 ld [ %fp + -12 ], %g1 int _POSIX_Semaphore_Wait_support( sem_t *sem, boolean blocking, Watchdog_Interval timeout ) { 200ea8c: 94 10 00 19 mov %i1, %o2 POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 200ea90: 80 a0 60 01 cmp %g1, 1 200ea94: 02 80 00 09 be 200eab8 <_POSIX_Semaphore_Wait_support+0x48> 200ea98: 96 10 00 1a mov %i2, %o3 200ea9c: 80 a0 60 01 cmp %g1, 1 200eaa0: 2a 80 00 0c bcs,a 200ead0 <_POSIX_Semaphore_Wait_support+0x60> 200eaa4: d2 02 20 08 ld [ %o0 + 8 ], %o1 200eaa8: 80 a0 60 02 cmp %g1, 2 200eaac: 12 80 00 29 bne 200eb50 <_POSIX_Semaphore_Wait_support+0xe0> 200eab0: 01 00 00 00 nop 200eab4: 30 80 00 03 b,a 200eac0 <_POSIX_Semaphore_Wait_support+0x50> case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 200eab8: 7f ff ef da call 200aa20 <_Thread_Dispatch> <== NOT EXECUTED 200eabc: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 200eac0: 40 00 08 16 call 2010b18 <__errno> 200eac4: 01 00 00 00 nop 200eac8: 10 80 00 1f b 200eb44 <_POSIX_Semaphore_Wait_support+0xd4> 200eacc: 82 10 20 16 mov 0x16, %g1 ! 16 case OBJECTS_LOCAL: _CORE_semaphore_Seize( 200ead0: 40 00 01 78 call 200f0b0 <_CORE_semaphore_Seize> 200ead4: 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 ) 200ead8: 03 00 80 77 sethi %hi(0x201dc00), %g1 200eadc: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 201df50 <_Thread_Dispatch_disable_level> 200eae0: 84 00 bf ff add %g2, -1, %g2 200eae4: c4 20 63 50 st %g2, [ %g1 + 0x350 ] 200eae8: c2 00 63 50 ld [ %g1 + 0x350 ], %g1 200eaec: 80 a0 60 00 cmp %g1, 0 200eaf0: 12 80 00 05 bne 200eb04 <_POSIX_Semaphore_Wait_support+0x94> 200eaf4: 03 00 80 78 sethi %hi(0x201e000), %g1 _Thread_Dispatch(); 200eaf8: 7f ff ef ca call 200aa20 <_Thread_Dispatch> 200eafc: 01 00 00 00 nop the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); switch ( _Thread_Executing->Wait.return_code ) { 200eb00: 03 00 80 78 sethi %hi(0x201e000), %g1 200eb04: c2 00 60 30 ld [ %g1 + 0x30 ], %g1 ! 201e030 <_Thread_Executing> 200eb08: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 200eb0c: 80 a0 60 02 cmp %g1, 2 200eb10: 02 80 00 06 be 200eb28 <_POSIX_Semaphore_Wait_support+0xb8> 200eb14: 80 a0 60 03 cmp %g1, 3 200eb18: 02 80 00 08 be 200eb38 <_POSIX_Semaphore_Wait_support+0xc8> 200eb1c: 80 a0 60 01 cmp %g1, 1 200eb20: 12 80 00 0c bne 200eb50 <_POSIX_Semaphore_Wait_support+0xe0> 200eb24: 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 ); 200eb28: 40 00 07 fc call 2010b18 <__errno> 200eb2c: 01 00 00 00 nop 200eb30: 10 80 00 05 b 200eb44 <_POSIX_Semaphore_Wait_support+0xd4> 200eb34: 82 10 20 0b mov 0xb, %g1 ! b case CORE_SEMAPHORE_TIMEOUT: rtems_set_errno_and_return_minus_one( ETIMEDOUT ); 200eb38: 40 00 07 f8 call 2010b18 <__errno> 200eb3c: 01 00 00 00 nop 200eb40: 82 10 20 74 mov 0x74, %g1 ! 74 200eb44: c2 22 00 00 st %g1, [ %o0 ] 200eb48: 81 c7 e0 08 ret 200eb4c: 91 e8 3f ff restore %g0, -1, %o0 */ break; } } return 0; } 200eb50: 81 c7 e0 08 ret 200eb54: 91 e8 20 00 restore %g0, 0, %o0 02005738 <_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 ) 2005738: 80 a2 20 06 cmp %o0, 6 200573c: 08 80 00 05 bleu 2005750 <_POSIX_Spinlock_Translate_core_spinlock_return_code+0x18> 2005740: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_Spinlock_Return_codes[the_spinlock_status]; return POSIX_BOTTOM_REACHED(); 2005744: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2005748: 40 00 00 6d call 20058fc <== NOT EXECUTED 200574c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED } 2005750: 03 00 80 4a sethi %hi(0x2012800), %g1 2005754: 82 10 62 64 or %g1, 0x264, %g1 ! 2012a64 <_POSIX_Spinlock_Return_codes> 2005758: 81 c3 e0 08 retl 200575c: d0 00 40 02 ld [ %g1 + %g2 ], %o0 0200c3ac <_POSIX_Threads_Create_extension>: boolean _POSIX_Threads_Create_extension( Thread_Control *executing, Thread_Control *created ) { 200c3ac: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 200c3b0: 11 00 80 62 sethi %hi(0x2018800), %o0 200c3b4: 92 10 20 e4 mov 0xe4, %o1 200c3b8: 90 12 23 3c or %o0, 0x33c, %o0 200c3bc: 7f ff ea 67 call 2006d58 <_Heap_Allocate> 200c3c0: b0 10 20 00 clr %i0 POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); if ( !api ) 200c3c4: a2 92 20 00 orcc %o0, 0, %l1 200c3c8: 02 80 00 39 be 200c4ac <_POSIX_Threads_Create_extension+0x100> 200c3cc: 94 10 20 38 mov 0x38, %o2 return FALSE; created->API_Extensions[ THREAD_API_POSIX ] = api; 200c3d0: e2 26 61 74 st %l1, [ %i1 + 0x174 ] /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; 200c3d4: 21 00 80 5b sethi %hi(0x2016c00), %l0 200c3d8: a0 14 22 80 or %l0, 0x280, %l0 ! 2016e80 <_POSIX_Threads_Default_attributes> 200c3dc: 40 00 09 d6 call 200eb34 200c3e0: 92 10 00 10 mov %l0, %o1 api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 200c3e4: c2 04 20 34 ld [ %l0 + 0x34 ], %g1 api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 200c3e8: 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; 200c3ec: c2 24 60 38 st %g1, [ %l1 + 0x38 ] api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 200c3f0: c4 24 60 7c st %g2, [ %l1 + 0x7c ] api->schedparam = _POSIX_Threads_Default_attributes.schedparam; 200c3f4: 92 04 20 18 add %l0, 0x18, %o1 200c3f8: 90 04 60 80 add %l1, 0x80, %o0 200c3fc: 40 00 09 ce call 200eb34 200c400: 94 10 20 18 mov 0x18, %o2 api->schedparam.sched_priority = 200c404: c4 06 60 14 ld [ %i1 + 0x14 ], %g2 200c408: 82 10 20 ff mov 0xff, %g1 200c40c: 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; 200c410: 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 = 200c414: 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 && 200c418: 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); 200c41c: 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; 200c420: c0 24 60 d4 clr [ %l1 + 0xd4 ] 200c424: c2 24 60 d8 st %g1, [ %l1 + 0xd8 ] api->cancelability_state = PTHREAD_CANCEL_ENABLE; 200c428: c0 24 60 cc clr [ %l1 + 0xcc ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 200c42c: 82 04 60 d8 add %l1, 0xd8, %g1 api->cancelability_type = PTHREAD_CANCEL_DEFERRED; 200c430: c0 24 60 d0 clr [ %l1 + 0xd0 ] 200c434: 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 && 200c438: 83 30 e0 18 srl %g3, 0x18, %g1 200c43c: 82 08 60 07 and %g1, 7, %g1 200c440: 80 a0 60 03 cmp %g1, 3 200c444: 12 80 00 0b bne 200c470 <_POSIX_Threads_Create_extension+0xc4> 200c448: c0 24 60 dc clr [ %l1 + 0xdc ] 200c44c: 83 30 e0 1b srl %g3, 0x1b, %g1 200c450: 80 a0 60 01 cmp %g1, 1 200c454: 32 80 00 08 bne,a 200c474 <_POSIX_Threads_Create_extension+0xc8> 200c458: 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; 200c45c: 03 00 80 62 sethi %hi(0x2018800), %g1 200c460: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> 200c464: c2 00 61 74 ld [ %g1 + 0x174 ], %g1 200c468: 10 80 00 03 b 200c474 <_POSIX_Threads_Create_extension+0xc8> 200c46c: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 } else { api->signals_blocked = 0xffffffff; 200c470: 82 10 3f ff mov -1, %g1 200c474: c2 24 60 c4 st %g1, [ %l1 + 0xc4 ] } _Thread_queue_Initialize( 200c478: 90 04 60 3c add %l1, 0x3c, %o0 200c47c: 92 10 20 00 clr %o1 200c480: 15 00 00 04 sethi %hi(0x1000), %o2 200c484: 7f ff f4 54 call 20095d4 <_Thread_queue_Initialize> 200c488: 96 10 20 00 clr %o3 THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_JOIN_AT_EXIT, 0 ); _Watchdog_Initialize( 200c48c: 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; 200c490: f2 24 60 c0 st %i1, [ %l1 + 0xc0 ] void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200c494: c2 24 60 bc st %g1, [ %l1 + 0xbc ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200c498: c0 24 60 a4 clr [ %l1 + 0xa4 ] the_watchdog->routine = routine; 200c49c: 03 00 80 31 sethi %hi(0x200c400), %g1 the_watchdog->id = id; the_watchdog->user_data = user_data; 200c4a0: b0 10 20 01 mov 1, %i0 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 200c4a4: 82 10 61 04 or %g1, 0x104, %g1 200c4a8: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] created->Object.id, created ); return TRUE; } 200c4ac: 81 c7 e0 08 ret 200c4b0: 81 e8 00 00 restore 02006414 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body( void ) { 2006414: 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; 2006418: 03 00 80 73 sethi %hi(0x201cc00), %g1 200641c: e0 00 60 fc ld [ %g1 + 0xfc ], %l0 ! 201ccfc <_POSIX_Threads_User_initialization_threads> maximum = _POSIX_Threads_Number_of_initialization_threads; 2006420: 03 00 80 73 sethi %hi(0x201cc00), %g1 if ( !user_threads || maximum == 0 ) 2006424: 80 a4 20 00 cmp %l0, 0 2006428: 02 80 00 3b be 2006514 <_POSIX_Threads_Initialize_user_threads_body+0x100> 200642c: ec 00 61 cc ld [ %g1 + 0x1cc ], %l6 2006430: 80 a5 a0 00 cmp %l6, 0 2006434: 02 80 00 38 be 2006514 <_POSIX_Threads_Initialize_user_threads_body+0x100> 2006438: 03 00 80 6a sethi %hi(0x201a800), %g1 return; 200643c: 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 ); 2006440: a8 10 60 40 or %g1, 0x40, %l4 user_threads = _POSIX_Threads_User_initialization_threads; maximum = _POSIX_Threads_Number_of_initialization_threads; if ( !user_threads || maximum == 0 ) return; 2006444: 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 ); 2006448: 03 00 80 66 sethi %hi(0x2019800), %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 ); 200644c: a2 07 bf bc add %fp, -68, %l1 assert( !status ); 2006450: a6 10 63 a8 or %g1, 0x3a8, %l3 assert( !status ); status = pthread_attr_setstacksize( &attr, user_threads[ index ].stack_size); assert( !status ); status = pthread_create( 2006454: 10 80 00 2d b 2006508 <_POSIX_Threads_Initialize_user_threads_body+0xf4> 2006458: 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 ); 200645c: 40 00 1f 99 call 200e2c0 2006460: aa 05 60 01 inc %l5 assert( !status ); 2006464: 80 a2 20 00 cmp %o0, 0 2006468: 02 80 00 07 be 2006484 <_POSIX_Threads_Initialize_user_threads_body+0x70> 200646c: 92 10 20 02 mov 2, %o1 2006470: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 2006474: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 2006478: 7f ff f2 3f call 2002d74 <__assert> <== NOT EXECUTED 200647c: 92 10 20 47 mov 0x47, %o1 <== NOT EXECUTED status = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 2006480: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 2006484: 40 00 1f 9a call 200e2ec 2006488: 90 10 00 11 mov %l1, %o0 assert( !status ); 200648c: 80 a2 20 00 cmp %o0, 0 2006490: 02 80 00 07 be 20064ac <_POSIX_Threads_Initialize_user_threads_body+0x98> 2006494: 82 04 00 12 add %l0, %l2, %g1 2006498: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 200649c: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 20064a0: 7f ff f2 35 call 2002d74 <__assert> <== NOT EXECUTED 20064a4: 92 10 20 4a mov 0x4a, %o1 <== NOT EXECUTED status = pthread_attr_setstacksize( &attr, user_threads[ index ].stack_size); 20064a8: 82 04 00 12 add %l0, %l2, %g1 <== NOT EXECUTED 20064ac: d2 00 60 04 ld [ %g1 + 4 ], %o1 20064b0: 40 00 1f 9f call 200e32c 20064b4: 90 10 00 11 mov %l1, %o0 assert( !status ); 20064b8: 80 a2 20 00 cmp %o0, 0 20064bc: 22 80 00 07 be,a 20064d8 <_POSIX_Threads_Initialize_user_threads_body+0xc4> 20064c0: d4 04 80 10 ld [ %l2 + %l0 ], %o2 20064c4: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 20064c8: 92 10 20 4d mov 0x4d, %o1 <== NOT EXECUTED 20064cc: 7f ff f2 2a call 2002d74 <__assert> <== NOT EXECUTED 20064d0: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED status = pthread_create( 20064d4: d4 04 80 10 ld [ %l2 + %l0 ], %o2 <== NOT EXECUTED 20064d8: 92 10 00 11 mov %l1, %o1 20064dc: 96 10 20 00 clr %o3 20064e0: 90 10 00 17 mov %l7, %o0 20064e4: 7f ff fe fe call 20060dc 20064e8: a4 04 a0 08 add %l2, 8, %l2 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); assert( !status ); 20064ec: 80 a2 20 00 cmp %o0, 0 20064f0: 02 80 00 07 be 200650c <_POSIX_Threads_Initialize_user_threads_body+0xf8> 20064f4: 80 a5 40 16 cmp %l5, %l6 20064f8: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 20064fc: 92 10 20 55 mov 0x55, %o1 <== NOT EXECUTED 2006500: 7f ff f2 1d call 2002d74 <__assert> <== NOT EXECUTED 2006504: 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++ ) { 2006508: 80 a5 40 16 cmp %l5, %l6 200650c: 12 bf ff d4 bne 200645c <_POSIX_Threads_Initialize_user_threads_body+0x48> 2006510: 90 10 00 11 mov %l1, %o0 2006514: 81 c7 e0 08 ret 2006518: 81 e8 00 00 restore 0200c504 <_POSIX_Threads_Sporadic_budget_TSR>: void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id, void *argument ) { 200c504: 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 ]; 200c508: f0 06 61 74 ld [ %i1 + 0x174 ], %i0 ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); 200c50c: 40 00 03 da call 200d474 <_Timespec_To_ticks> 200c510: 90 06 20 90 add %i0, 0x90, %o0 if ( !ticks ) 200c514: 80 a2 20 00 cmp %o0, 0 200c518: 22 80 00 02 be,a 200c520 <_POSIX_Threads_Sporadic_budget_TSR+0x1c> 200c51c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 200c520: 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 || 200c524: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 200c528: 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; 200c52c: d0 26 60 84 st %o0, [ %i1 + 0x84 ] 200c530: 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 || 200c534: 80 a0 e0 00 cmp %g3, 0 200c538: 02 80 00 06 be 200c550 <_POSIX_Threads_Sporadic_budget_TSR+0x4c> 200c53c: d2 26 60 18 st %o1, [ %i1 + 0x18 ] 200c540: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 200c544: 80 a0 40 09 cmp %g1, %o1 200c548: 08 80 00 05 bleu 200c55c <_POSIX_Threads_Sporadic_budget_TSR+0x58> 200c54c: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 200c550: 90 10 00 19 mov %i1, %o0 200c554: 7f ff f0 65 call 20086e8 <_Thread_Change_priority> 200c558: 94 10 20 01 mov 1, %o2 ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 200c55c: 40 00 03 c6 call 200d474 <_Timespec_To_ticks> 200c560: 90 06 20 88 add %i0, 0x88, %o0 if ( !ticks ) 200c564: 80 a2 20 00 cmp %o0, 0 200c568: 22 80 00 02 be,a 200c570 <_POSIX_Threads_Sporadic_budget_TSR+0x6c> 200c56c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200c570: d0 26 20 a8 st %o0, [ %i0 + 0xa8 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200c574: b2 06 20 9c add %i0, 0x9c, %i1 200c578: 31 00 80 62 sethi %hi(0x2018800), %i0 200c57c: 7f ff f6 a9 call 200a020 <_Watchdog_Insert> 200c580: 91 ee 23 f0 restore %i0, 0x3f0, %o0 200c584: 01 00 00 00 nop 0200c4b4 <_POSIX_Threads_Sporadic_budget_callout>: ) { POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200c4b4: c2 02 21 74 ld [ %o0 + 0x174 ], %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 || 200c4b8: c6 02 20 1c ld [ %o0 + 0x1c ], %g3 RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (255 - priority); 200c4bc: 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 */ 200c4c0: 82 10 3f ff mov -1, %g1 200c4c4: c2 22 20 84 st %g1, [ %o0 + 0x84 ] 200c4c8: 82 10 20 ff mov 0xff, %g1 200c4cc: 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 || 200c4d0: 80 a0 e0 00 cmp %g3, 0 200c4d4: 02 80 00 06 be 200c4ec <_POSIX_Threads_Sporadic_budget_callout+0x38> 200c4d8: d2 22 20 18 st %o1, [ %o0 + 0x18 ] 200c4dc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED 200c4e0: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED 200c4e4: 08 80 00 06 bleu 200c4fc <_POSIX_Threads_Sporadic_budget_callout+0x48> <== NOT EXECUTED 200c4e8: 01 00 00 00 nop <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 200c4ec: 94 10 20 01 mov 1, %o2 ! 1 200c4f0: 82 13 c0 00 mov %o7, %g1 200c4f4: 7f ff f0 7d call 20086e8 <_Thread_Change_priority> 200c4f8: 9e 10 40 00 mov %g1, %o7 200c4fc: 81 c3 e0 08 retl <== NOT EXECUTED 200c500: 01 00 00 00 nop 02004ffc <_POSIX_Threads_cancel_run>: */ void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 2004ffc: 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 ]; 2005000: f2 06 21 74 ld [ %i0 + 0x174 ], %i1 handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 2005004: 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; 2005008: a2 06 60 dc add %i1, 0xdc, %l1 200500c: c2 26 60 cc st %g1, [ %i1 + 0xcc ] RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2005010: 03 00 80 5c sethi %hi(0x2017000), %g1 2005014: 10 80 00 11 b 2005058 <_POSIX_Threads_cancel_run+0x5c> 2005018: a4 10 62 6c or %g1, 0x26c, %l2 ! 201726c <_Workspace_Area> while ( !_Chain_Is_empty( handler_stack ) ) { _ISR_Disable( level ); 200501c: 7f ff f3 8e call 2001e54 <== NOT EXECUTED 2005020: 01 00 00 00 nop <== NOT EXECUTED handler = (POSIX_Cancel_Handler_control *) 2005024: e0 04 60 04 ld [ %l1 + 4 ], %l0 <== NOT EXECUTED ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 2005028: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED previous = the_node->previous; 200502c: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 2005030: 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; 2005034: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 2005038: 7f ff f3 8b call 2001e64 <== NOT EXECUTED 200503c: 01 00 00 00 nop <== NOT EXECUTED (*handler->routine)( handler->arg ); 2005040: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 2005044: 9f c0 40 00 call %g1 <== NOT EXECUTED 2005048: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED 200504c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2005050: 40 00 0a 49 call 2007974 <_Heap_Free> <== NOT EXECUTED 2005054: 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 ) ) { 2005058: c2 06 60 d8 ld [ %i1 + 0xd8 ], %g1 200505c: 80 a0 40 11 cmp %g1, %l1 2005060: 12 bf ff ef bne 200501c <_POSIX_Threads_cancel_run+0x20> 2005064: 03 00 80 5c sethi %hi(0x2017000), %g1 } /* Now we can delete the thread */ the_thread->Wait.return_argument = PTHREAD_CANCELED; _Thread_Close( 2005068: c6 06 20 08 ld [ %i0 + 8 ], %g3 200506c: 85 30 e0 16 srl %g3, 0x16, %g2 2005070: 82 10 61 80 or %g1, 0x180, %g1 2005074: 84 08 a0 1c and %g2, 0x1c, %g2 2005078: c2 00 40 02 ld [ %g1 + %g2 ], %g1 200507c: 87 30 e0 1b srl %g3, 0x1b, %g3 2005080: 87 28 e0 02 sll %g3, 2, %g3 2005084: d0 00 40 03 ld [ %g1 + %g3 ], %o0 2005088: 92 10 00 18 mov %i0, %o1 _Workspace_Free( handler ); } /* Now we can delete the thread */ the_thread->Wait.return_argument = PTHREAD_CANCELED; 200508c: 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 ); 2005090: b2 10 00 18 mov %i0, %i1 2005094: c2 26 20 28 st %g1, [ %i0 + 0x28 ] _Thread_Close( 2005098: 40 00 10 e3 call 2009424 <_Thread_Close> 200509c: 31 00 80 5d sethi %hi(0x2017400), %i0 20050a0: 40 00 0c 68 call 2008240 <_Objects_Free> 20050a4: 91 ee 21 08 restore %i0, 0x108, %o0 20050a8: 01 00 00 00 nop 0200b170 <_POSIX_Timer_TSR>: * Description: This is the operation that is ran when a timer expires * ***************************************************************************/ void _POSIX_Timer_TSR(Objects_Id timer, void *data) { 200b170: 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; 200b174: c2 06 60 68 ld [ %i1 + 0x68 ], %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 200b178: 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; 200b17c: 82 00 60 01 inc %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 200b180: 80 a0 a0 00 cmp %g2, 0 200b184: 12 80 00 06 bne 200b19c <_POSIX_Timer_TSR+0x2c> 200b188: c2 26 60 68 st %g1, [ %i1 + 0x68 ] 200b18c: c2 06 60 58 ld [ %i1 + 0x58 ], %g1 <== NOT EXECUTED 200b190: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b194: 02 80 00 0f be 200b1d0 <_POSIX_Timer_TSR+0x60> <== NOT EXECUTED 200b198: 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( 200b19c: d2 06 60 64 ld [ %i1 + 0x64 ], %o1 200b1a0: d4 06 60 08 ld [ %i1 + 8 ], %o2 200b1a4: 90 06 60 10 add %i1, 0x10, %o0 200b1a8: 17 00 80 2c sethi %hi(0x200b000), %o3 200b1ac: 98 10 00 19 mov %i1, %o4 200b1b0: 7f ff ff 68 call 200af50 <_Watchdog_Insert_ticks_helper> 200b1b4: 96 12 e1 70 or %o3, 0x170, %o3 ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 200b1b8: 80 a2 20 00 cmp %o0, 0 200b1bc: 02 80 00 0a be 200b1e4 <_POSIX_Timer_TSR+0x74> 200b1c0: 01 00 00 00 nop return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 200b1c4: 40 00 09 20 call 200d644 <_TOD_Get> 200b1c8: 90 06 60 6c add %i1, 0x6c, %o0 200b1cc: 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 ) ) { 200b1d0: d0 06 60 38 ld [ %i1 + 0x38 ], %o0 200b1d4: d2 06 60 44 ld [ %i1 + 0x44 ], %o1 200b1d8: 40 00 20 26 call 2013270 200b1dc: 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; 200b1e0: c0 26 60 68 clr [ %i1 + 0x68 ] 200b1e4: 81 c7 e0 08 ret 200b1e8: 81 e8 00 00 restore 0200c28c <_POSIX_signals_Abnormal_termination_handler>: /*** PROCESS WIDE STUFF ****/ sigset_t _POSIX_signals_Pending; void _POSIX_signals_Abnormal_termination_handler( int signo ) { 200c28c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED exit( 1 ); 200c290: 40 00 08 57 call 200e3ec <== NOT EXECUTED 200c294: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 200c298: 01 00 00 00 nop 0200db30 <_POSIX_signals_Check_signal>: boolean _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, boolean is_global ) { 200db30: 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, 200db34: 98 10 20 01 mov 1, %o4 200db38: 96 10 00 1a mov %i2, %o3 200db3c: a6 07 bf ec add %fp, -20, %l3 200db40: 90 10 00 18 mov %i0, %o0 200db44: 92 10 00 19 mov %i1, %o1 200db48: 40 00 00 2e call 200dc00 <_POSIX_signals_Clear_signals> 200db4c: 94 10 00 13 mov %l3, %o2 200db50: 80 a2 20 00 cmp %o0, 0 200db54: 02 80 00 29 be 200dbf8 <_POSIX_signals_Check_signal+0xc8> 200db58: 03 00 80 64 sethi %hi(0x2019000), %g1 /* * Since we made a union of these, only one test is necessary but this is * safer. */ assert( _POSIX_signals_Vectors[ signo ].sa_handler || 200db5c: a4 10 61 84 or %g1, 0x184, %l2 ! 2019184 <_POSIX_signals_Vectors> 200db60: 83 2e 60 04 sll %i1, 4, %g1 200db64: 85 2e 60 02 sll %i1, 2, %g2 200db68: a2 20 40 02 sub %g1, %g2, %l1 200db6c: b4 04 40 12 add %l1, %l2, %i2 200db70: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200db74: 80 a0 60 00 cmp %g1, 0 200db78: 12 80 00 0a bne 200dba0 <_POSIX_signals_Check_signal+0x70> 200db7c: 80 a0 60 01 cmp %g1, 1 200db80: 11 00 80 5b sethi %hi(0x2016c00), %o0 <== NOT EXECUTED 200db84: 15 00 80 5c sethi %hi(0x2017000), %o2 <== NOT EXECUTED 200db88: 90 12 23 b0 or %o0, 0x3b0, %o0 <== NOT EXECUTED 200db8c: 94 12 a0 00 mov %o2, %o2 <== NOT EXECUTED 200db90: 7f ff d0 dd call 2001f04 <__assert> <== NOT EXECUTED 200db94: 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 ) 200db98: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED 200db9c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200dba0: 02 80 00 16 be 200dbf8 <_POSIX_signals_Check_signal+0xc8> 200dba4: 01 00 00 00 nop /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 200dba8: e0 06 20 c4 ld [ %i0 + 0xc4 ], %l0 api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 200dbac: c2 06 a0 04 ld [ %i2 + 4 ], %g1 /* Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 200dbb0: 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; 200dbb4: 82 10 40 10 or %g1, %l0, %g1 /* Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 200dbb8: 80 a0 a0 02 cmp %g2, 2 200dbbc: 12 80 00 09 bne 200dbe0 <_POSIX_signals_Check_signal+0xb0> 200dbc0: c2 26 20 c4 st %g1, [ %i0 + 0xc4 ] case SA_SIGINFO: /* * * assert( is_global ); */ (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 200dbc4: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200dbc8: 90 10 00 19 mov %i1, %o0 200dbcc: 92 10 00 13 mov %l3, %o1 200dbd0: 9f c0 40 00 call %g1 200dbd4: 94 10 20 00 clr %o2 /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 200dbd8: 10 80 00 06 b 200dbf0 <_POSIX_signals_Check_signal+0xc0> 200dbdc: 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 ); 200dbe0: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200dbe4: 9f c0 40 00 call %g1 200dbe8: 90 10 00 19 mov %i1, %o0 /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 200dbec: e0 26 20 c4 st %l0, [ %i0 + 0xc4 ] 200dbf0: 81 c7 e0 08 ret 200dbf4: 91 e8 20 01 restore %g0, 1, %o0 return TRUE; } 200dbf8: 81 c7 e0 08 ret 200dbfc: 91 e8 20 00 restore %g0, 0, %o0 0200dc00 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, boolean is_global, boolean check_blocked ) { 200dc00: 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 ); 200dc04: 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 ) 200dc08: 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 ); 200dc0c: 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 ) 200dc10: b8 10 3f ff mov -1, %i4 200dc14: 02 80 00 04 be 200dc24 <_POSIX_signals_Clear_signals+0x24> 200dc18: a1 28 40 02 sll %g1, %g2, %l0 signals_blocked = ~api->signals_blocked; 200dc1c: c2 06 20 c4 ld [ %i0 + 0xc4 ], %g1 200dc20: 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 ); 200dc24: 7f ff d0 4e call 2001d5c 200dc28: 01 00 00 00 nop 200dc2c: a2 10 00 08 mov %o0, %l1 if ( is_global ) { 200dc30: 80 a6 e0 00 cmp %i3, 0 200dc34: 22 80 00 35 be,a 200dd08 <_POSIX_signals_Clear_signals+0x108> 200dc38: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0 if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 200dc3c: 03 00 80 64 sethi %hi(0x2019000), %g1 200dc40: c2 00 63 50 ld [ %g1 + 0x350 ], %g1 ! 2019350 <_POSIX_signals_Pending> 200dc44: 82 0c 00 01 and %l0, %g1, %g1 200dc48: 80 88 40 1c btst %g1, %i4 200dc4c: 02 80 00 36 be 200dd24 <_POSIX_signals_Clear_signals+0x124> 200dc50: 83 2e 60 02 sll %i1, 2, %g1 if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 200dc54: 85 2e 60 04 sll %i1, 4, %g2 200dc58: 84 20 80 01 sub %g2, %g1, %g2 200dc5c: 03 00 80 64 sethi %hi(0x2019000), %g1 200dc60: 82 10 61 84 or %g1, 0x184, %g1 ! 2019184 <_POSIX_signals_Vectors> 200dc64: c2 00 40 02 ld [ %g1 + %g2 ], %g1 200dc68: 80 a0 60 02 cmp %g1, 2 200dc6c: 12 80 00 23 bne 200dcf8 <_POSIX_signals_Clear_signals+0xf8> 200dc70: 03 00 80 64 sethi %hi(0x2019000), %g1 psiginfo = (POSIX_signals_Siginfo_node *) 200dc74: 88 10 63 54 or %g1, 0x354, %g4 ! 2019354 <_POSIX_signals_Siginfo> */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 200dc78: f8 00 80 04 ld [ %g2 + %g4 ], %i4 200dc7c: 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; 200dc80: 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)) 200dc84: 80 a7 00 0d cmp %i4, %o5 200dc88: 32 80 00 04 bne,a 200dc98 <_POSIX_signals_Clear_signals+0x98> 200dc8c: c2 07 00 00 ld [ %i4 ], %g1 200dc90: 10 80 00 04 b 200dca0 <_POSIX_signals_Clear_signals+0xa0> <== NOT EXECUTED 200dc94: 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; 200dc98: c2 20 80 04 st %g1, [ %g2 + %g4 ] new_first->previous = _Chain_Head(the_chain); 200dc9c: c6 20 60 04 st %g3, [ %g1 + 4 ] _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 200dca0: c2 00 c0 00 ld [ %g3 ], %g1 200dca4: 80 a0 40 0d cmp %g1, %o5 200dca8: 12 80 00 05 bne 200dcbc <_POSIX_signals_Clear_signals+0xbc> 200dcac: 80 a7 20 00 cmp %i4, 0 _POSIX_signals_Clear_process_signals( mask ); 200dcb0: 40 00 01 b4 call 200e380 <_POSIX_signals_Clear_process_signals> 200dcb4: 90 10 00 10 mov %l0, %o0 if ( psiginfo ) { 200dcb8: 80 a7 20 00 cmp %i4, 0 200dcbc: 02 80 00 1b be 200dd28 <_POSIX_signals_Clear_signals+0x128> 200dcc0: b0 10 20 01 mov 1, %i0 *info = psiginfo->Info; 200dcc4: 90 10 00 1a mov %i2, %o0 200dcc8: 92 07 20 08 add %i4, 8, %o1 200dccc: 40 00 03 9a call 200eb34 200dcd0: 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; 200dcd4: 03 00 80 64 sethi %hi(0x2019000), %g1 200dcd8: 82 10 63 08 or %g1, 0x308, %g1 ! 2019308 <_POSIX_signals_Inactive_siginfo+0x4> Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200dcdc: c2 27 00 00 st %g1, [ %i4 ] old_last_node = the_chain->last; 200dce0: 82 00 7f fc add %g1, -4, %g1 200dce4: c4 00 60 08 ld [ %g1 + 8 ], %g2 the_chain->last = the_node; 200dce8: f8 20 60 08 st %i4, [ %g1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200dcec: 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; 200dcf0: 10 80 00 0e b 200dd28 <_POSIX_signals_Clear_signals+0x128> 200dcf4: f8 20 80 00 st %i4, [ %g2 ] &psiginfo->Node ); } else do_callout = FALSE; } else _POSIX_signals_Clear_process_signals( mask ); 200dcf8: 40 00 01 a2 call 200e380 <_POSIX_signals_Clear_process_signals> 200dcfc: 90 10 00 10 mov %l0, %o0 do_callout = TRUE; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; 200dd00: 10 80 00 0a b 200dd28 <_POSIX_signals_Clear_signals+0x128> 200dd04: 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) ) { 200dd08: 82 0c 00 08 and %l0, %o0, %g1 200dd0c: 80 88 40 1c btst %g1, %i4 200dd10: 02 80 00 05 be 200dd24 <_POSIX_signals_Clear_signals+0x124> 200dd14: 82 2a 00 10 andn %o0, %l0, %g1 api->signals_pending &= ~mask; 200dd18: c2 26 20 c8 st %g1, [ %i0 + 0xc8 ] 200dd1c: 10 80 00 03 b 200dd28 <_POSIX_signals_Clear_signals+0x128> 200dd20: b0 10 20 01 mov 1, %i0 200dd24: b0 10 20 00 clr %i0 do_callout = TRUE; } } _ISR_Enable( level ); 200dd28: 7f ff d0 11 call 2001d6c 200dd2c: 90 10 00 11 mov %l1, %o0 return do_callout; } 200dd30: 81 c7 e0 08 ret 200dd34: 81 e8 00 00 restore 020062bc <_POSIX_signals_Get_highest>: #include int _POSIX_signals_Get_highest( sigset_t set ) { 20062bc: 86 10 00 08 mov %o0, %g3 20062c0: 90 10 20 1b mov 0x1b, %o0 int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) 20062c4: 84 02 3f ff add %o0, -1, %g2 20062c8: 82 10 20 01 mov 1, %g1 20062cc: 83 28 40 02 sll %g1, %g2, %g1 20062d0: 80 88 40 03 btst %g1, %g3 20062d4: 12 80 00 12 bne 200631c <_POSIX_signals_Get_highest+0x60> 20062d8: 01 00 00 00 nop sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 20062dc: 90 02 20 01 inc %o0 20062e0: 80 a2 20 20 cmp %o0, 0x20 20062e4: 12 bf ff f9 bne 20062c8 <_POSIX_signals_Get_highest+0xc> 20062e8: 84 02 3f ff add %o0, -1, %g2 20062ec: 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 ) ) 20062f0: 84 02 3f ff add %o0, -1, %g2 20062f4: 82 10 20 01 mov 1, %g1 20062f8: 83 28 40 02 sll %g1, %g2, %g1 20062fc: 80 88 40 03 btst %g1, %g3 2006300: 12 80 00 07 bne 200631c <_POSIX_signals_Get_highest+0x60> 2006304: 01 00 00 00 nop return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 2006308: 90 02 20 01 inc %o0 200630c: 80 a2 20 1b cmp %o0, 0x1b 2006310: 12 bf ff f9 bne 20062f4 <_POSIX_signals_Get_highest+0x38> 2006314: 84 02 3f ff add %o0, -1, %g2 2006318: 90 10 20 00 clr %o0 <== NOT EXECUTED if ( set & signo_to_mask( signo ) ) return signo; } return 0; } 200631c: 81 c3 e0 08 retl 2006320: 01 00 00 00 nop 0200c1bc <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) { 200c1bc: 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 ]; 200c1c0: e0 06 21 74 ld [ %i0 + 0x174 ], %l0 * processed at all. No point in doing this loop otherwise. */ restart: _ISR_Disable( level ); if ( !(~api->signals_blocked & 200c1c4: 23 00 80 64 sethi %hi(0x2019000), %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 ); 200c1c8: 7f ff d6 e5 call 2001d5c 200c1cc: 01 00 00 00 nop 200c1d0: b0 10 00 08 mov %o0, %i0 if ( !(~api->signals_blocked & 200c1d4: c2 04 63 50 ld [ %l1 + 0x350 ], %g1 200c1d8: c4 04 20 c8 ld [ %l0 + 0xc8 ], %g2 200c1dc: c6 04 20 c4 ld [ %l0 + 0xc4 ], %g3 200c1e0: 82 10 40 02 or %g1, %g2, %g1 200c1e4: 80 a8 40 03 andncc %g1, %g3, %g0 200c1e8: 12 80 00 04 bne 200c1f8 <_POSIX_signals_Post_switch_extension+0x3c> 200c1ec: 01 00 00 00 nop (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); 200c1f0: 7f ff d6 df call 2001d6c 200c1f4: 81 e8 00 00 restore return; } _ISR_Enable( level ); 200c1f8: 7f ff d6 dd call 2001d6c 200c1fc: b0 10 20 1b mov 0x1b, %i0 for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, FALSE ) ) 200c200: 92 10 00 18 mov %i0, %o1 200c204: 94 10 20 00 clr %o2 200c208: 40 00 06 4a call 200db30 <_POSIX_signals_Check_signal> 200c20c: 90 10 00 10 mov %l0, %o0 200c210: 80 a2 20 00 cmp %o0, 0 200c214: 12 bf ff ed bne 200c1c8 <_POSIX_signals_Post_switch_extension+0xc> 200c218: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) 200c21c: 90 10 00 10 mov %l0, %o0 200c220: 94 10 20 01 mov 1, %o2 200c224: 40 00 06 43 call 200db30 <_POSIX_signals_Check_signal> 200c228: b0 06 20 01 inc %i0 200c22c: 80 a2 20 00 cmp %o0, 0 200c230: 12 bf ff e6 bne 200c1c8 <_POSIX_signals_Post_switch_extension+0xc> 200c234: 80 a6 20 20 cmp %i0, 0x20 _ISR_Enable( level ); return; } _ISR_Enable( level ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 200c238: 12 bf ff f3 bne 200c204 <_POSIX_signals_Post_switch_extension+0x48> 200c23c: 92 10 00 18 mov %i0, %o1 200c240: 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 ) ) 200c244: 92 10 00 18 mov %i0, %o1 200c248: 94 10 20 00 clr %o2 200c24c: 40 00 06 39 call 200db30 <_POSIX_signals_Check_signal> 200c250: 90 10 00 10 mov %l0, %o0 200c254: 80 a2 20 00 cmp %o0, 0 200c258: 12 bf ff dc bne 200c1c8 <_POSIX_signals_Post_switch_extension+0xc> 200c25c: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) 200c260: 90 10 00 10 mov %l0, %o0 200c264: 94 10 20 01 mov 1, %o2 200c268: 40 00 06 32 call 200db30 <_POSIX_signals_Check_signal> 200c26c: b0 06 20 01 inc %i0 200c270: 80 a2 20 00 cmp %o0, 0 200c274: 12 bf ff d5 bne 200c1c8 <_POSIX_signals_Post_switch_extension+0xc> 200c278: 80 a6 20 1b cmp %i0, 0x1b } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 200c27c: 12 bf ff f3 bne 200c248 <_POSIX_signals_Post_switch_extension+0x8c> 200c280: 92 10 00 18 mov %i0, %o1 if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) goto restart; } } 200c284: 81 c7 e0 08 ret <== NOT EXECUTED 200c288: 81 e8 00 00 restore <== NOT EXECUTED 020212dc <_POSIX_signals_Unblock_thread>: boolean _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 20212dc: 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 ) ) { 20212e0: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 20212e4: 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 ); 20212e8: 82 06 7f ff add %i1, -1, %g1 20212ec: 9a 10 20 01 mov 1, %o5 boolean _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 20212f0: 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 ); 20212f4: 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 ) ) { 20212f8: 82 09 00 02 and %g4, %g2, %g1 20212fc: 80 a0 40 02 cmp %g1, %g2 2021300: 12 80 00 19 bne 2021364 <_POSIX_signals_Unblock_thread+0x88> 2021304: c4 06 21 74 ld [ %i0 + 0x174 ], %g2 if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 2021308: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 202130c: 80 88 c0 01 btst %g3, %g1 2021310: 12 80 00 06 bne 2021328 <_POSIX_signals_Unblock_thread+0x4c> 2021314: 82 10 20 04 mov 4, %g1 2021318: c2 00 a0 c4 ld [ %g2 + 0xc4 ], %g1 202131c: 80 a8 c0 01 andncc %g3, %g1, %g0 2021320: 02 80 00 31 be 20213e4 <_POSIX_signals_Unblock_thread+0x108> 2021324: 82 10 20 04 mov 4, %g1 the_thread->Wait.return_code = EINTR; 2021328: c2 26 20 34 st %g1, [ %i0 + 0x34 ] the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { 202132c: 80 a2 60 00 cmp %o1, 0 2021330: 12 80 00 06 bne 2021348 <_POSIX_signals_Unblock_thread+0x6c> 2021334: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 the_info->si_signo = signo; 2021338: f2 22 00 00 st %i1, [ %o0 ] the_info->si_code = SI_USER; 202133c: da 22 20 04 st %o5, [ %o0 + 4 ] the_info->si_value.sival_int = 0; 2021340: 10 80 00 04 b 2021350 <_POSIX_signals_Unblock_thread+0x74> 2021344: c0 22 20 08 clr [ %o0 + 8 ] } else { *the_info = *info; 2021348: 7f ff db e3 call 20182d4 202134c: 94 10 20 0c mov 0xc, %o2 } _Thread_queue_Extract_with_proxy( the_thread ); 2021350: 90 10 00 18 mov %i0, %o0 2021354: 7f ff b2 9f call 200ddd0 <_Thread_queue_Extract_with_proxy> 2021358: b0 10 20 01 mov 1, %i0 202135c: 81 c7 e0 08 ret 2021360: 81 e8 00 00 restore */ return FALSE; } if ( ~api->signals_blocked & mask ) { 2021364: c2 00 a0 c4 ld [ %g2 + 0xc4 ], %g1 2021368: 80 a8 c0 01 andncc %g3, %g1, %g0 202136c: 02 80 00 1e be 20213e4 <_POSIX_signals_Unblock_thread+0x108> 2021370: 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 ) { 2021374: 80 89 00 01 btst %g4, %g1 2021378: 02 80 00 1b be 20213e4 <_POSIX_signals_Unblock_thread+0x108> 202137c: da 26 20 78 st %o5, [ %i0 + 0x78 ] the_thread->Wait.return_code = EINTR; 2021380: 82 10 20 04 mov 4, %g1 2021384: c2 26 20 34 st %g1, [ %i0 + 0x34 ] if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) 2021388: 03 00 00 ef sethi %hi(0x3bc00), %g1 202138c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2021390: 80 89 00 01 btst %g4, %g1 2021394: 02 80 00 06 be 20213ac <_POSIX_signals_Unblock_thread+0xd0> 2021398: 80 89 20 08 btst 8, %g4 _Thread_queue_Extract_with_proxy( the_thread ); 202139c: 7f ff b2 8d call 200ddd0 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 20213a0: 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 ); 20213a4: 81 c7 e0 08 ret <== NOT EXECUTED 20213a8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED else if ( _States_Is_delaying(the_thread->current_state)){ 20213ac: 22 bf ff ec be,a 202135c <_POSIX_signals_Unblock_thread+0x80> 20213b0: b0 10 20 00 clr %i0 <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 20213b4: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 20213b8: 80 a0 60 02 cmp %g1, 2 20213bc: 32 80 00 05 bne,a 20213d0 <_POSIX_signals_Unblock_thread+0xf4> 20213c0: 13 04 00 ff sethi %hi(0x1003fc00), %o1 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 20213c4: 7f ff b5 ba call 200eaac <_Watchdog_Remove> 20213c8: 90 06 20 48 add %i0, 0x48, %o0 20213cc: 13 04 00 ff sethi %hi(0x1003fc00), %o1 20213d0: 90 10 00 18 mov %i0, %o0 20213d4: 7f ff af 4e call 200d10c <_Thread_Clear_state> 20213d8: 92 12 63 f8 or %o1, 0x3f8, %o1 20213dc: 81 c7 e0 08 ret 20213e0: 91 e8 20 00 restore %g0, 0, %o0 20213e4: b0 10 20 00 clr %i0 } } } return FALSE; } 20213e8: 81 c7 e0 08 ret 20213ec: 81 e8 00 00 restore 02007ba0 <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 2007ba0: 9d e3 bf 98 save %sp, -104, %sp void *p; _RTEMS_Lock_allocator(); 2007ba4: 7f ff e8 6e call 2001d5c 2007ba8: 01 00 00 00 nop 2007bac: a2 10 00 08 mov %o0, %l1 2007bb0: 03 00 80 62 sethi %hi(0x2018800), %g1 2007bb4: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2007bb8: 80 a0 60 00 cmp %g1, 0 2007bbc: 02 80 00 0b be 2007be8 <_Protected_heap_Allocate+0x48> 2007bc0: 03 00 80 62 sethi %hi(0x2018800), %g1 2007bc4: 03 00 80 63 sethi %hi(0x2018c00), %g1 2007bc8: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> 2007bcc: 80 a0 60 01 cmp %g1, 1 2007bd0: 08 80 00 05 bleu 2007be4 <_Protected_heap_Allocate+0x44> 2007bd4: 90 10 20 00 clr %o0 2007bd8: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007bdc: 7f ff fd 8a call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2007be0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2007be4: 03 00 80 62 sethi %hi(0x2018800), %g1 2007be8: e0 00 63 c8 ld [ %g1 + 0x3c8 ], %l0 ! 2018bc8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2007bec: 03 00 80 62 sethi %hi(0x2018800), %g1 2007bf0: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2007bf4: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2007bf8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2007bfc: 80 a0 60 00 cmp %g1, 0 2007c00: 22 80 00 33 be,a 2007ccc <_Protected_heap_Allocate+0x12c> 2007c04: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2007c08: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007c0c: 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; 2007c10: 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; 2007c14: 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; 2007c18: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2007c1c: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2007c20: 80 a0 e0 02 cmp %g3, 2 2007c24: 02 80 00 05 be 2007c38 <_Protected_heap_Allocate+0x98> 2007c28: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 2007c2c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2007c30: 32 80 00 06 bne,a 2007c48 <_Protected_heap_Allocate+0xa8> <== NOT EXECUTED 2007c34: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2007c38: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 2007c3c: 82 00 60 01 inc %g1 2007c40: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2007c44: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 2007c48: 80 a0 60 03 cmp %g1, 3 2007c4c: 22 80 00 03 be,a 2007c58 <_Protected_heap_Allocate+0xb8> 2007c50: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2007c54: 30 80 00 2c b,a 2007d04 <_Protected_heap_Allocate+0x164> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2007c58: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2007c5c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2007c60: 12 80 00 03 bne 2007c6c <_Protected_heap_Allocate+0xcc> <== NOT EXECUTED 2007c64: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2007c68: 30 80 00 27 b,a 2007d04 <_Protected_heap_Allocate+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2007c6c: 08 80 00 10 bleu 2007cac <_Protected_heap_Allocate+0x10c> <== NOT EXECUTED 2007c70: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007c74: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2007c78: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007c7c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007c80: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2007c84: 7f ff e8 3a call 2001d6c <== NOT EXECUTED 2007c88: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2007c8c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2007c90: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2007c94: 40 00 02 95 call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 2007c98: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2007c9c: 7f ff ff b4 call 2007b6c <_Thread_Enable_dispatch> <== NOT EXECUTED 2007ca0: 01 00 00 00 nop <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 2007ca4: 10 80 00 32 b 2007d6c <_Protected_heap_Allocate+0x1cc> <== NOT EXECUTED 2007ca8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2007cac: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2007cb0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2007cb4: 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; 2007cb8: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2007cbc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2007cc0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2007cc4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2007cc8: 30 80 00 0f b,a 2007d04 <_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 ) ) { 2007ccc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2007cd0: 32 80 00 13 bne,a 2007d1c <_Protected_heap_Allocate+0x17c> <== NOT EXECUTED 2007cd4: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2007cd8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2018850 <== NOT EXECUTED 2007cdc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007ce0: 22 80 00 07 be,a 2007cfc <_Protected_heap_Allocate+0x15c> <== NOT EXECUTED 2007ce4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2007ce8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2007cec: 32 80 00 0c bne,a 2007d1c <_Protected_heap_Allocate+0x17c> <== NOT EXECUTED 2007cf0: 21 00 80 62 sethi %hi(0x2018800), %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; 2007cf4: 10 80 00 08 b 2007d14 <_Protected_heap_Allocate+0x174> <== NOT EXECUTED 2007cf8: 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++; 2007cfc: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007d00: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2007d04: 7f ff e8 1a call 2001d6c 2007d08: 90 10 00 11 mov %l1, %o0 2007d0c: 10 80 00 18 b 2007d6c <_Protected_heap_Allocate+0x1cc> 2007d10: 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; 2007d14: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2007d18: 30 bf ff fb b,a 2007d04 <_Protected_heap_Allocate+0x164> <== NOT EXECUTED size_t size ) { void *p; _RTEMS_Lock_allocator(); 2007d1c: c6 04 23 c8 ld [ %l0 + 0x3c8 ], %g3 <== NOT EXECUTED 2007d20: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007d24: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2007d28: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 <== NOT EXECUTED 2007d2c: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2007d30: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007d34: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 2007d38: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007d3c: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED 2007d40: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2007d44: 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; 2007d48: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2007d4c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2007d50: 7f ff e8 07 call 2001d6c <== NOT EXECUTED 2007d54: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2007d58: d0 04 23 c8 ld [ %l0 + 0x3c8 ], %o0 <== NOT EXECUTED 2007d5c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007d60: 7f ff fb 0f call 200699c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2007d64: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 2007d68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2007d6c: 7f ff fb fb call 2006d58 <_Heap_Allocate> 2007d70: 92 10 00 19 mov %i1, %o1 2007d74: 05 00 80 62 sethi %hi(0x2018800), %g2 2007d78: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2007d7c: b0 10 00 08 mov %o0, %i0 2007d80: 82 00 60 01 inc %g1 2007d84: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] _RTEMS_Unlock_allocator(); 2007d88: 03 00 80 62 sethi %hi(0x2018800), %g1 2007d8c: d0 00 63 c8 ld [ %g1 + 0x3c8 ], %o0 ! 2018bc8 <_RTEMS_Allocator_Mutex> 2007d90: 94 10 20 00 clr %o2 2007d94: d2 02 20 08 ld [ %o0 + 8 ], %o1 2007d98: 7f ff fb 23 call 2006a24 <_CORE_mutex_Surrender> 2007d9c: 90 02 20 10 add %o0, 0x10, %o0 2007da0: 7f ff ff 73 call 2007b6c <_Thread_Enable_dispatch> 2007da4: 01 00 00 00 nop return p; } 2007da8: 81 c7 e0 08 ret 2007dac: 81 e8 00 00 restore 02007de4 <_Protected_heap_Extend>: boolean _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 2007de4: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 2007de8: 7f ff e7 dd call 2001d5c <== NOT EXECUTED 2007dec: 01 00 00 00 nop <== NOT EXECUTED 2007df0: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 2007df4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007df8: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007dfc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007e00: 02 80 00 0b be 2007e2c <_Protected_heap_Extend+0x48> <== NOT EXECUTED 2007e04: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007e08: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 2007e0c: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> <== NOT EXECUTED 2007e10: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2007e14: 08 80 00 05 bleu 2007e28 <_Protected_heap_Extend+0x44> <== NOT EXECUTED 2007e18: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007e1c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007e20: 7f ff fc f9 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2007e24: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2007e28: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007e2c: e0 00 63 c8 ld [ %g1 + 0x3c8 ], %l0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2007e30: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007e34: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2007e38: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2007e3c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2007e40: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007e44: 22 80 00 33 be,a 2007f10 <_Protected_heap_Extend+0x12c> <== NOT EXECUTED 2007e48: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2007e4c: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007e50: 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; 2007e54: 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; 2007e58: 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; 2007e5c: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2007e60: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2007e64: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2007e68: 02 80 00 05 be 2007e7c <_Protected_heap_Extend+0x98> <== NOT EXECUTED 2007e6c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 2007e70: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2007e74: 32 80 00 06 bne,a 2007e8c <_Protected_heap_Extend+0xa8> <== NOT EXECUTED 2007e78: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2007e7c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2007e80: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007e84: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2007e88: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 2007e8c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2007e90: 22 80 00 03 be,a 2007e9c <_Protected_heap_Extend+0xb8> <== NOT EXECUTED 2007e94: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2007e98: 30 80 00 2c b,a 2007f48 <_Protected_heap_Extend+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2007e9c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2007ea0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2007ea4: 12 80 00 03 bne 2007eb0 <_Protected_heap_Extend+0xcc> <== NOT EXECUTED 2007ea8: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2007eac: 30 80 00 27 b,a 2007f48 <_Protected_heap_Extend+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2007eb0: 08 80 00 10 bleu 2007ef0 <_Protected_heap_Extend+0x10c> <== NOT EXECUTED 2007eb4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007eb8: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2007ebc: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007ec0: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007ec4: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2007ec8: 7f ff e7 a9 call 2001d6c <== NOT EXECUTED 2007ecc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2007ed0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2007ed4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2007ed8: 40 00 02 04 call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 2007edc: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2007ee0: 7f ff ff b4 call 2007db0 <_Thread_Enable_dispatch> <== NOT EXECUTED 2007ee4: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 2007ee8: 10 80 00 32 b 2007fb0 <_Protected_heap_Extend+0x1cc> <== NOT EXECUTED 2007eec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2007ef0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2007ef4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2007ef8: 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; 2007efc: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2007f00: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2007f04: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2007f08: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2007f0c: 30 80 00 0f b,a 2007f48 <_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 ) ) { 2007f10: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2007f14: 32 80 00 13 bne,a 2007f60 <_Protected_heap_Extend+0x17c> <== NOT EXECUTED 2007f18: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2007f1c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2018850 <== NOT EXECUTED 2007f20: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007f24: 22 80 00 07 be,a 2007f40 <_Protected_heap_Extend+0x15c> <== NOT EXECUTED 2007f28: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2007f2c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2007f30: 12 80 00 0c bne 2007f60 <_Protected_heap_Extend+0x17c> <== NOT EXECUTED 2007f34: 21 00 80 62 sethi %hi(0x2018800), %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; 2007f38: 10 80 00 08 b 2007f58 <_Protected_heap_Extend+0x174> <== NOT EXECUTED 2007f3c: 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++; 2007f40: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007f44: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2007f48: 7f ff e7 89 call 2001d6c <== NOT EXECUTED 2007f4c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2007f50: 10 80 00 18 b 2007fb0 <_Protected_heap_Extend+0x1cc> <== NOT EXECUTED 2007f54: 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; 2007f58: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2007f5c: 30 bf ff fb b,a 2007f48 <_Protected_heap_Extend+0x164> <== NOT EXECUTED ) { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 2007f60: c6 04 23 c8 ld [ %l0 + 0x3c8 ], %g3 <== NOT EXECUTED 2007f64: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007f68: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2007f6c: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 <== NOT EXECUTED 2007f70: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2007f74: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007f78: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 2007f7c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007f80: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED 2007f84: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2007f88: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 2007f8c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2007f90: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2007f94: 7f ff e7 76 call 2001d6c <== NOT EXECUTED 2007f98: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2007f9c: d0 04 23 c8 ld [ %l0 + 0x3c8 ], %o0 <== NOT EXECUTED 2007fa0: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007fa4: 7f ff fa 7e call 200699c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2007fa8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 2007fac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2007fb0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2007fb4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2007fb8: 40 00 13 08 call 200cbd8 <_Heap_Extend> <== NOT EXECUTED 2007fbc: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 2007fc0: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2007fc4: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007fc8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 2007fcc: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007fd0: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 2007fd4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007fd8: d0 00 63 c8 ld [ %g1 + 0x3c8 ], %o0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 2007fdc: 94 10 20 00 clr %o2 <== NOT EXECUTED 2007fe0: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2007fe4: 7f ff fa 90 call 2006a24 <_CORE_mutex_Surrender> <== NOT EXECUTED 2007fe8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2007fec: 7f ff ff 71 call 2007db0 <_Thread_Enable_dispatch> <== NOT EXECUTED 2007ff0: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 2007ff4: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 2007ff8: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 2007ffc: 81 c7 e0 08 ret <== NOT EXECUTED 2008000: 81 e8 00 00 restore <== NOT EXECUTED 02008038 <_Protected_heap_Free>: boolean _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 2008038: 9d e3 bf 98 save %sp, -104, %sp boolean status; _RTEMS_Lock_allocator(); 200803c: 7f ff e7 48 call 2001d5c 2008040: 01 00 00 00 nop 2008044: a2 10 00 08 mov %o0, %l1 2008048: 03 00 80 62 sethi %hi(0x2018800), %g1 200804c: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2008050: 80 a0 60 00 cmp %g1, 0 2008054: 02 80 00 0b be 2008080 <_Protected_heap_Free+0x48> 2008058: 03 00 80 62 sethi %hi(0x2018800), %g1 200805c: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 2008060: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> <== NOT EXECUTED 2008064: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008068: 08 80 00 05 bleu 200807c <_Protected_heap_Free+0x44> <== NOT EXECUTED 200806c: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008070: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008074: 7f ff fc 64 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2008078: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200807c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008080: e0 00 63 c8 ld [ %g1 + 0x3c8 ], %l0 ! 2018bc8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2008084: 03 00 80 62 sethi %hi(0x2018800), %g1 2008088: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200808c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2008090: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2008094: 80 a0 60 00 cmp %g1, 0 2008098: 22 80 00 33 be,a 2008164 <_Protected_heap_Free+0x12c> 200809c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20080a0: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20080a4: 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; 20080a8: 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; 20080ac: 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; 20080b0: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 20080b4: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20080b8: 80 a0 e0 02 cmp %g3, 2 20080bc: 02 80 00 05 be 20080d0 <_Protected_heap_Free+0x98> 20080c0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 20080c4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20080c8: 32 80 00 06 bne,a 20080e0 <_Protected_heap_Free+0xa8> <== NOT EXECUTED 20080cc: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20080d0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 20080d4: 82 00 60 01 inc %g1 20080d8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20080dc: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 20080e0: 80 a0 60 03 cmp %g1, 3 20080e4: 22 80 00 03 be,a 20080f0 <_Protected_heap_Free+0xb8> 20080e8: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 20080ec: 30 80 00 2c b,a 200819c <_Protected_heap_Free+0x164> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 20080f0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 20080f4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 20080f8: 12 80 00 03 bne 2008104 <_Protected_heap_Free+0xcc> <== NOT EXECUTED 20080fc: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2008100: 30 80 00 27 b,a 200819c <_Protected_heap_Free+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2008104: 08 80 00 10 bleu 2008144 <_Protected_heap_Free+0x10c> <== NOT EXECUTED 2008108: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200810c: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2008110: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008114: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008118: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200811c: 7f ff e7 14 call 2001d6c <== NOT EXECUTED 2008120: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2008124: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2008128: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200812c: 40 00 01 6f call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 2008130: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2008134: 7f ff ff b4 call 2008004 <_Thread_Enable_dispatch> <== NOT EXECUTED 2008138: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 200813c: 10 80 00 32 b 2008204 <_Protected_heap_Free+0x1cc> <== NOT EXECUTED 2008140: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008144: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2008148: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200814c: 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; 2008150: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2008154: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008158: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200815c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008160: 30 80 00 0f b,a 200819c <_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 ) ) { 2008164: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2008168: 32 80 00 13 bne,a 20081b4 <_Protected_heap_Free+0x17c> <== NOT EXECUTED 200816c: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2008170: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2018850 <== NOT EXECUTED 2008174: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008178: 22 80 00 07 be,a 2008194 <_Protected_heap_Free+0x15c> <== NOT EXECUTED 200817c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2008180: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008184: 32 80 00 0c bne,a 20081b4 <_Protected_heap_Free+0x17c> <== NOT EXECUTED 2008188: 21 00 80 62 sethi %hi(0x2018800), %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; 200818c: 10 80 00 08 b 20081ac <_Protected_heap_Free+0x174> <== NOT EXECUTED 2008190: 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++; 2008194: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008198: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200819c: 7f ff e6 f4 call 2001d6c 20081a0: 90 10 00 11 mov %l1, %o0 20081a4: 10 80 00 18 b 2008204 <_Protected_heap_Free+0x1cc> 20081a8: 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; 20081ac: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20081b0: 30 bf ff fb b,a 200819c <_Protected_heap_Free+0x164> <== NOT EXECUTED void *start_address ) { boolean status; _RTEMS_Lock_allocator(); 20081b4: c6 04 23 c8 ld [ %l0 + 0x3c8 ], %g3 <== NOT EXECUTED 20081b8: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20081bc: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 20081c0: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 <== NOT EXECUTED 20081c4: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 20081c8: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20081cc: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 20081d0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20081d4: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED 20081d8: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 20081dc: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 20081e0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20081e4: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 20081e8: 7f ff e6 e1 call 2001d6c <== NOT EXECUTED 20081ec: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20081f0: d0 04 23 c8 ld [ %l0 + 0x3c8 ], %o0 <== NOT EXECUTED 20081f4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20081f8: 7f ff f9 e9 call 200699c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 20081fc: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 2008200: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2008204: 7f ff fa fc call 2006df4 <_Heap_Free> 2008208: 92 10 00 19 mov %i1, %o1 200820c: 05 00 80 62 sethi %hi(0x2018800), %g2 2008210: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2008214: b0 10 00 08 mov %o0, %i0 2008218: 82 00 60 01 inc %g1 200821c: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] _RTEMS_Unlock_allocator(); 2008220: 03 00 80 62 sethi %hi(0x2018800), %g1 2008224: d0 00 63 c8 ld [ %g1 + 0x3c8 ], %o0 ! 2018bc8 <_RTEMS_Allocator_Mutex> 2008228: 94 10 20 00 clr %o2 200822c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2008230: 7f ff f9 fd call 2006a24 <_CORE_mutex_Surrender> 2008234: 90 02 20 10 add %o0, 0x10, %o0 2008238: 7f ff ff 73 call 2008004 <_Thread_Enable_dispatch> 200823c: 01 00 00 00 nop return status; } 2008240: 81 c7 e0 08 ret 2008244: 81 e8 00 00 restore 0200827c <_Protected_heap_Get_block_size>: boolean _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 200827c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED boolean status; _RTEMS_Lock_allocator(); 2008280: 7f ff e6 b7 call 2001d5c <== NOT EXECUTED 2008284: 01 00 00 00 nop <== NOT EXECUTED 2008288: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 200828c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008290: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008294: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008298: 02 80 00 0b be 20082c4 <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 200829c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20082a0: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 20082a4: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> <== NOT EXECUTED 20082a8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20082ac: 08 80 00 05 bleu 20082c0 <_Protected_heap_Get_block_size+0x44> <== NOT EXECUTED 20082b0: 90 10 20 00 clr %o0 <== NOT EXECUTED 20082b4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20082b8: 7f ff fb d3 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 20082bc: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 20082c0: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20082c4: e0 00 63 c8 ld [ %g1 + 0x3c8 ], %l0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 20082c8: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20082cc: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20082d0: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 20082d4: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 20082d8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20082dc: 22 80 00 33 be,a 20083a8 <_Protected_heap_Get_block_size+0x12c> <== NOT EXECUTED 20082e0: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20082e4: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20082e8: 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; 20082ec: 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; 20082f0: 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; 20082f4: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 20082f8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20082fc: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2008300: 02 80 00 05 be 2008314 <_Protected_heap_Get_block_size+0x98> <== NOT EXECUTED 2008304: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 2008308: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200830c: 32 80 00 06 bne,a 2008324 <_Protected_heap_Get_block_size+0xa8> <== NOT EXECUTED 2008310: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008314: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008318: 82 00 60 01 inc %g1 <== NOT EXECUTED 200831c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008320: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 2008324: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2008328: 22 80 00 03 be,a 2008334 <_Protected_heap_Get_block_size+0xb8> <== NOT EXECUTED 200832c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2008330: 30 80 00 2c b,a 20083e0 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2008334: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2008338: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200833c: 12 80 00 03 bne 2008348 <_Protected_heap_Get_block_size+0xcc> <== NOT EXECUTED 2008340: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2008344: 30 80 00 27 b,a 20083e0 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2008348: 08 80 00 10 bleu 2008388 <_Protected_heap_Get_block_size+0x10c> <== NOT EXECUTED 200834c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008350: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2008354: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008358: 82 00 60 01 inc %g1 <== NOT EXECUTED 200835c: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2008360: 7f ff e6 83 call 2001d6c <== NOT EXECUTED 2008364: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2008368: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200836c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008370: 40 00 00 de call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 2008374: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2008378: 7f ff ff b4 call 2008248 <_Thread_Enable_dispatch> <== NOT EXECUTED 200837c: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 2008380: 10 80 00 32 b 2008448 <_Protected_heap_Get_block_size+0x1cc> <== NOT EXECUTED 2008384: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008388: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200838c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2008390: 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; 2008394: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2008398: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200839c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20083a0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20083a4: 30 80 00 0f b,a 20083e0 <_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 ) ) { 20083a8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20083ac: 32 80 00 13 bne,a 20083f8 <_Protected_heap_Get_block_size+0x17c> <== NOT EXECUTED 20083b0: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20083b4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2018850 <== NOT EXECUTED 20083b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20083bc: 22 80 00 07 be,a 20083d8 <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 20083c0: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 20083c4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20083c8: 32 80 00 0c bne,a 20083f8 <_Protected_heap_Get_block_size+0x17c> <== NOT EXECUTED 20083cc: 21 00 80 62 sethi %hi(0x2018800), %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; 20083d0: 10 80 00 08 b 20083f0 <_Protected_heap_Get_block_size+0x174> <== NOT EXECUTED 20083d4: 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++; 20083d8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20083dc: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 20083e0: 7f ff e6 63 call 2001d6c <== NOT EXECUTED 20083e4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20083e8: 10 80 00 18 b 2008448 <_Protected_heap_Get_block_size+0x1cc> <== NOT EXECUTED 20083ec: 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; 20083f0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20083f4: 30 bf ff fb b,a 20083e0 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED size_t *size ) { boolean status; _RTEMS_Lock_allocator(); 20083f8: c6 04 23 c8 ld [ %l0 + 0x3c8 ], %g3 <== NOT EXECUTED 20083fc: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008400: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2008404: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 <== NOT EXECUTED 2008408: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 200840c: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008410: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 2008414: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008418: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED 200841c: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2008420: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 2008424: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2008428: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 200842c: 7f ff e6 50 call 2001d6c <== NOT EXECUTED 2008430: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2008434: d0 04 23 c8 ld [ %l0 + 0x3c8 ], %o0 <== NOT EXECUTED 2008438: 92 10 20 00 clr %o1 <== NOT EXECUTED 200843c: 7f ff f9 58 call 200699c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2008440: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 2008444: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2008448: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200844c: 40 00 12 9d call 200cec0 <_Heap_Size_of_user_area> <== NOT EXECUTED 2008450: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2008454: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2008458: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200845c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 2008460: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008464: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 2008468: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200846c: d0 00 63 c8 ld [ %g1 + 0x3c8 ], %o0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 2008470: 94 10 20 00 clr %o2 <== NOT EXECUTED 2008474: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2008478: 7f ff f9 6b call 2006a24 <_CORE_mutex_Surrender> <== NOT EXECUTED 200847c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2008480: 7f ff ff 72 call 2008248 <_Thread_Enable_dispatch> <== NOT EXECUTED 2008484: 01 00 00 00 nop <== NOT EXECUTED return status; } 2008488: 81 c7 e0 08 ret <== NOT EXECUTED 200848c: 81 e8 00 00 restore <== NOT EXECUTED 0200aa0c <_Protected_heap_Get_free_information>: void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 200aa0c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 200aa10: 7f ff e0 5d call 2002b84 <== NOT EXECUTED 200aa14: 01 00 00 00 nop <== NOT EXECUTED 200aa18: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 200aa1c: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200aa20: c2 00 63 10 ld [ %g1 + 0x310 ], %g1 ! 2039b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200aa24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200aa28: 02 80 00 0b be 200aa54 <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 200aa2c: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200aa30: 03 00 80 e7 sethi %hi(0x2039c00), %g1 <== NOT EXECUTED 200aa34: c2 00 60 f0 ld [ %g1 + 0xf0 ], %g1 ! 2039cf0 <_System_state_Current> <== NOT EXECUTED 200aa38: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200aa3c: 08 80 00 05 bleu 200aa50 <_Protected_heap_Get_free_information+0x44> <== NOT EXECUTED 200aa40: 90 10 20 00 clr %o0 <== NOT EXECUTED 200aa44: 92 10 20 00 clr %o1 <== NOT EXECUTED 200aa48: 7f ff fb 80 call 2009848 <_Internal_error_Occurred> <== NOT EXECUTED 200aa4c: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200aa50: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200aa54: e0 00 63 e8 ld [ %g1 + 0x3e8 ], %l0 ! 2039be8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200aa58: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200aa5c: c4 00 63 f0 ld [ %g1 + 0x3f0 ], %g2 ! 2039bf0 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200aa60: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200aa64: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 200aa68: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200aa6c: 22 80 00 33 be,a 200ab38 <_Protected_heap_Get_free_information+0x12c> <== NOT EXECUTED 200aa70: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200aa74: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200aa78: 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; 200aa7c: 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; 200aa80: 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; 200aa84: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 200aa88: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200aa8c: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 200aa90: 02 80 00 05 be 200aaa4 <_Protected_heap_Get_free_information+0x98> <== NOT EXECUTED 200aa94: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 200aa98: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200aa9c: 32 80 00 06 bne,a 200aab4 <_Protected_heap_Get_free_information+0xa8> <== NOT EXECUTED 200aaa0: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200aaa4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200aaa8: 82 00 60 01 inc %g1 <== NOT EXECUTED 200aaac: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200aab0: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 200aab4: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 200aab8: 22 80 00 03 be,a 200aac4 <_Protected_heap_Get_free_information+0xb8> <== NOT EXECUTED 200aabc: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 200aac0: 30 80 00 2c b,a 200ab70 <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 200aac4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200aac8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200aacc: 12 80 00 03 bne 200aad8 <_Protected_heap_Get_free_information+0xcc> <== NOT EXECUTED 200aad0: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200aad4: 30 80 00 27 b,a 200ab70 <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 200aad8: 08 80 00 10 bleu 200ab18 <_Protected_heap_Get_free_information+0x10c> <== NOT EXECUTED 200aadc: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200aae0: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 200aae4: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2039b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200aae8: 82 00 60 01 inc %g1 <== NOT EXECUTED 200aaec: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200aaf0: 7f ff e0 29 call 2002b94 <== NOT EXECUTED 200aaf4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 200aaf8: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200aafc: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200ab00: 40 00 00 db call 200ae6c <_Thread_Change_priority> <== NOT EXECUTED 200ab04: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 200ab08: 7f ff ff b4 call 200a9d8 <_Thread_Enable_dispatch> <== NOT EXECUTED 200ab0c: 01 00 00 00 nop <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 200ab10: 10 80 00 32 b 200abd8 <_Protected_heap_Get_free_information+0x1cc> <== NOT EXECUTED 200ab14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200ab18: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200ab1c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200ab20: 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; 200ab24: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 200ab28: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200ab2c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200ab30: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200ab34: 30 80 00 0f b,a 200ab70 <_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 ) ) { 200ab38: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200ab3c: 32 80 00 13 bne,a 200ab88 <_Protected_heap_Get_free_information+0x17c> <== NOT EXECUTED 200ab40: 21 00 80 e6 sethi %hi(0x2039800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200ab44: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2039850 <== NOT EXECUTED 200ab48: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200ab4c: 22 80 00 07 be,a 200ab68 <_Protected_heap_Get_free_information+0x15c> <== NOT EXECUTED 200ab50: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200ab54: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200ab58: 32 80 00 0c bne,a 200ab88 <_Protected_heap_Get_free_information+0x17c> <== NOT EXECUTED 200ab5c: 21 00 80 e6 sethi %hi(0x2039800), %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; 200ab60: 10 80 00 08 b 200ab80 <_Protected_heap_Get_free_information+0x174> <== NOT EXECUTED 200ab64: 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++; 200ab68: 82 00 60 01 inc %g1 <== NOT EXECUTED 200ab6c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200ab70: 7f ff e0 09 call 2002b94 <== NOT EXECUTED 200ab74: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200ab78: 10 80 00 18 b 200abd8 <_Protected_heap_Get_free_information+0x1cc> <== NOT EXECUTED 200ab7c: 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; 200ab80: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200ab84: 30 bf ff fb b,a 200ab70 <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); 200ab88: c6 04 23 e8 ld [ %l0 + 0x3e8 ], %g3 <== NOT EXECUTED 200ab8c: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200ab90: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 200ab94: c8 00 63 f0 ld [ %g1 + 0x3f0 ], %g4 <== NOT EXECUTED 200ab98: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 200ab9c: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2039b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200aba0: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 200aba4: 82 00 60 01 inc %g1 <== NOT EXECUTED 200aba8: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] <== NOT EXECUTED 200abac: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 200abb0: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200abb4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200abb8: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 200abbc: 7f ff df f6 call 2002b94 <== NOT EXECUTED 200abc0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200abc4: d0 04 23 e8 ld [ %l0 + 0x3e8 ], %o0 <== NOT EXECUTED 200abc8: 92 10 20 00 clr %o1 <== NOT EXECUTED 200abcc: 7f ff f9 05 call 2008fe0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200abd0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 200abd4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200abd8: 40 00 35 5a call 2018140 <_Heap_Get_free_information> <== NOT EXECUTED 200abdc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200abe0: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 200abe4: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2039b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200abe8: 82 00 60 01 inc %g1 <== NOT EXECUTED 200abec: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 200abf0: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200abf4: d0 00 63 e8 ld [ %g1 + 0x3e8 ], %o0 ! 2039be8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 200abf8: 94 10 20 00 clr %o2 <== NOT EXECUTED 200abfc: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 200ac00: 7f ff f9 1a call 2009068 <_CORE_mutex_Surrender> <== NOT EXECUTED 200ac04: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200ac08: 7f ff ff 74 call 200a9d8 <_Thread_Enable_dispatch> <== NOT EXECUTED 200ac0c: 81 e8 00 00 restore <== NOT EXECUTED 200ac10: 01 00 00 00 nop 020084c4 <_Protected_heap_Resize_block>: boolean _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 20084c4: 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(); 20084c8: 7f ff e6 25 call 2001d5c <== NOT EXECUTED 20084cc: 01 00 00 00 nop <== NOT EXECUTED 20084d0: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 20084d4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20084d8: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20084dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20084e0: 02 80 00 0b be 200850c <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 20084e4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20084e8: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 20084ec: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> <== NOT EXECUTED 20084f0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20084f4: 08 80 00 05 bleu 2008508 <_Protected_heap_Resize_block+0x44> <== NOT EXECUTED 20084f8: 90 10 20 00 clr %o0 <== NOT EXECUTED 20084fc: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008500: 7f ff fb 41 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2008504: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2008508: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200850c: e0 00 63 c8 ld [ %g1 + 0x3c8 ], %l0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2008510: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008514: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2008518: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200851c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2008520: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008524: 22 80 00 33 be,a 20085f0 <_Protected_heap_Resize_block+0x12c> <== NOT EXECUTED 2008528: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200852c: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008530: 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; 2008534: 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; 2008538: 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; 200853c: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2008540: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008544: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2008548: 02 80 00 05 be 200855c <_Protected_heap_Resize_block+0x98> <== NOT EXECUTED 200854c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 2008550: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008554: 32 80 00 06 bne,a 200856c <_Protected_heap_Resize_block+0xa8> <== NOT EXECUTED 2008558: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200855c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008560: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008564: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008568: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 200856c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2008570: 22 80 00 03 be,a 200857c <_Protected_heap_Resize_block+0xb8> <== NOT EXECUTED 2008574: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2008578: 30 80 00 2c b,a 2008628 <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 200857c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2008580: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008584: 12 80 00 03 bne 2008590 <_Protected_heap_Resize_block+0xcc> <== NOT EXECUTED 2008588: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200858c: 30 80 00 27 b,a 2008628 <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2008590: 08 80 00 10 bleu 20085d0 <_Protected_heap_Resize_block+0x10c> <== NOT EXECUTED 2008594: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008598: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 200859c: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20085a0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20085a4: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20085a8: 7f ff e5 f1 call 2001d6c <== NOT EXECUTED 20085ac: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 20085b0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 20085b4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 20085b8: 40 00 00 4c call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 20085bc: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 20085c0: 7f ff ff b4 call 2008490 <_Thread_Enable_dispatch> <== NOT EXECUTED 20085c4: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Resize_block( 20085c8: 10 80 00 32 b 2008690 <_Protected_heap_Resize_block+0x1cc> <== NOT EXECUTED 20085cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20085d0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20085d4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20085d8: 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; 20085dc: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 20085e0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20085e4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20085e8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20085ec: 30 80 00 0f b,a 2008628 <_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 ) ) { 20085f0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20085f4: 32 80 00 13 bne,a 2008640 <_Protected_heap_Resize_block+0x17c> <== NOT EXECUTED 20085f8: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20085fc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2018850 <== NOT EXECUTED 2008600: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008604: 22 80 00 07 be,a 2008620 <_Protected_heap_Resize_block+0x15c> <== NOT EXECUTED 2008608: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200860c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008610: 12 80 00 0c bne 2008640 <_Protected_heap_Resize_block+0x17c> <== NOT EXECUTED 2008614: 21 00 80 62 sethi %hi(0x2018800), %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; 2008618: 10 80 00 08 b 2008638 <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 200861c: 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++; 2008620: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008624: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2008628: 7f ff e5 d1 call 2001d6c <== NOT EXECUTED 200862c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2008630: 10 80 00 18 b 2008690 <_Protected_heap_Resize_block+0x1cc> <== NOT EXECUTED 2008634: 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; 2008638: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200863c: 30 bf ff fb b,a 2008628 <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED { Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 2008640: c6 04 23 c8 ld [ %l0 + 0x3c8 ], %g3 <== NOT EXECUTED 2008644: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008648: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 200864c: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 <== NOT EXECUTED 2008650: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2008654: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008658: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 200865c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008660: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED 2008664: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2008668: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200866c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2008670: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2008674: 7f ff e5 be call 2001d6c <== NOT EXECUTED 2008678: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200867c: d0 04 23 c8 ld [ %l0 + 0x3c8 ], %o0 <== NOT EXECUTED 2008680: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008684: 7f ff f8 c6 call 200699c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2008688: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 200868c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2008690: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2008694: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2008698: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 200869c: 40 00 11 80 call 200cc9c <_Heap_Resize_block> <== NOT EXECUTED 20086a0: 98 07 bf f0 add %fp, -16, %o4 <== NOT EXECUTED 20086a4: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 20086a8: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20086ac: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 20086b0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20086b4: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 20086b8: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20086bc: d0 00 63 c8 ld [ %g1 + 0x3c8 ], %o0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 20086c0: 94 10 20 00 clr %o2 <== NOT EXECUTED 20086c4: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 20086c8: 7f ff f8 d7 call 2006a24 <_CORE_mutex_Surrender> <== NOT EXECUTED 20086cc: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 20086d0: 7f ff ff 70 call 2008490 <_Thread_Enable_dispatch> <== NOT EXECUTED 20086d4: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 20086d8: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 20086dc: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 20086e0: 81 c7 e0 08 ret <== NOT EXECUTED 20086e4: 81 e8 00 00 restore <== NOT EXECUTED 0200c97c <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 200c97c: 9d e3 bf 98 save %sp, -104, %sp /* * Free per task variable memory */ tvp = deleted->task_variables; 200c980: e0 06 61 80 ld [ %i1 + 0x180 ], %l0 deleted->task_variables = NULL; while (tvp) { next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 200c984: 25 00 80 62 sethi %hi(0x2018800), %l2 /* * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; 200c988: 10 80 00 18 b 200c9e8 <_RTEMS_tasks_Delete_extension+0x6c> 200c98c: c0 26 61 80 clr [ %i1 + 0x180 ] 200c990: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED while (tvp) { next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 200c994: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 200c998: 12 80 00 0c bne 200c9c8 <_RTEMS_tasks_Delete_extension+0x4c> <== NOT EXECUTED 200c99c: e2 04 00 00 ld [ %l0 ], %l1 <== NOT EXECUTED if (tvp->dtor) 200c9a0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200c9a4: 22 80 00 06 be,a 200c9bc <_RTEMS_tasks_Delete_extension+0x40> <== NOT EXECUTED 200c9a8: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED (*tvp->dtor)(*tvp->ptr); 200c9ac: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 200c9b0: 9f c0 80 00 call %g2 <== NOT EXECUTED 200c9b4: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 200c9b8: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED 200c9bc: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 200c9c0: 10 80 00 07 b 200c9dc <_RTEMS_tasks_Delete_extension+0x60> <== NOT EXECUTED 200c9c4: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED } else { if (tvp->dtor) 200c9c8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200c9cc: 02 80 00 05 be 200c9e0 <_RTEMS_tasks_Delete_extension+0x64> <== NOT EXECUTED 200c9d0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 200c9d4: 9f c0 80 00 call %g2 <== NOT EXECUTED 200c9d8: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED } _Workspace_Free( tvp ); 200c9dc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 200c9e0: 7f ff ff e0 call 200c960 <_Workspace_Free> <== NOT EXECUTED 200c9e4: a0 10 00 11 mov %l1, %l0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 200c9e8: 80 a4 20 00 cmp %l0, 0 200c9ec: 12 bf ff e9 bne 200c990 <_RTEMS_tasks_Delete_extension+0x14> 200c9f0: c2 04 a3 d0 ld [ %l2 + 0x3d0 ], %g1 /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 200c9f4: 7f ff ff db call 200c960 <_Workspace_Free> 200c9f8: d0 06 61 70 ld [ %i1 + 0x170 ], %o0 deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 200c9fc: c0 26 61 70 clr [ %i1 + 0x170 ] } 200ca00: 81 c7 e0 08 ret 200ca04: 81 e8 00 00 restore 02006084 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 2006084: 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; 2006088: 03 00 80 62 sethi %hi(0x2018800), %g1 200608c: c2 00 63 b4 ld [ %g1 + 0x3b4 ], %g1 ! 2018bb4 <_Configuration_Table> 2006090: 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; 2006094: d0 00 60 28 ld [ %g1 + 0x28 ], %o0 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) 2006098: 80 a2 20 00 cmp %o0, 0 200609c: 02 80 00 25 be 2006130 <_RTEMS_tasks_Initialize_user_tasks_body+0xac> 20060a0: e4 00 60 24 ld [ %g1 + 0x24 ], %l2 20060a4: 80 a4 a0 00 cmp %l2, 0 20060a8: 02 80 00 22 be 2006130 <_RTEMS_tasks_Initialize_user_tasks_body+0xac> 20060ac: a0 10 00 08 mov %o0, %l0 return; 20060b0: a2 10 20 00 clr %l1 for ( index=0 ; index < maximum ; index++ ) { return_value = rtems_task_create( 20060b4: 10 80 00 1c b 2006124 <_RTEMS_tasks_Initialize_user_tasks_body+0xa0> 20060b8: a6 07 bf f4 add %fp, -12, %l3 20060bc: d6 04 20 14 ld [ %l0 + 0x14 ], %o3 20060c0: d8 04 20 0c ld [ %l0 + 0xc ], %o4 20060c4: d2 04 20 08 ld [ %l0 + 8 ], %o1 20060c8: d4 04 20 04 ld [ %l0 + 4 ], %o2 20060cc: d0 04 00 00 ld [ %l0 ], %o0 20060d0: 7f ff ff 35 call 2005da4 20060d4: a2 04 60 01 inc %l1 user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 20060d8: 80 a2 20 00 cmp %o0, 0 20060dc: 22 80 00 07 be,a 20060f8 <_RTEMS_tasks_Initialize_user_tasks_body+0x74> 20060e0: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 20060e4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 20060e8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 20060ec: 40 00 04 46 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 20060f0: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED return_value = rtems_task_start( 20060f4: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED 20060f8: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 20060fc: d0 07 bf f4 ld [ %fp + -12 ], %o0 2006100: 40 00 00 1b call 200616c 2006104: 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 ) ) 2006108: 80 a2 20 00 cmp %o0, 0 200610c: 02 80 00 07 be 2006128 <_RTEMS_tasks_Initialize_user_tasks_body+0xa4> 2006110: 80 a4 40 12 cmp %l1, %l2 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 2006114: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 2006118: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 200611c: 40 00 04 3a call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2006120: 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++ ) { 2006124: 80 a4 40 12 cmp %l1, %l2 2006128: 12 bf ff e5 bne 20060bc <_RTEMS_tasks_Initialize_user_tasks_body+0x38> 200612c: 9a 10 00 13 mov %l3, %o5 2006130: 81 c7 e0 08 ret 2006134: 81 e8 00 00 restore 02006c98 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 2006c98: 9d e3 bf 90 save %sp, -112, %sp 2006c9c: 11 00 80 75 sethi %hi(0x201d400), %o0 2006ca0: 92 10 00 18 mov %i0, %o1 2006ca4: 90 12 23 44 or %o0, 0x344, %o0 2006ca8: 40 00 09 5e call 2009220 <_Objects_Get> 2006cac: 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 ) { 2006cb0: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006cb4: 80 a0 60 00 cmp %g1, 0 2006cb8: 12 80 00 20 bne 2006d38 <_Rate_monotonic_Timeout+0xa0> 2006cbc: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: /* impossible */ case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; 2006cc0: d0 02 20 50 ld [ %o0 + 0x50 ], %o0 if ( _States_Is_waiting_for_period( the_thread->current_state ) && 2006cc4: 03 00 00 10 sethi %hi(0x4000), %g1 2006cc8: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 2006ccc: 80 88 80 01 btst %g2, %g1 2006cd0: 22 80 00 0c be,a 2006d00 <_Rate_monotonic_Timeout+0x68> 2006cd4: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 2006cd8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006cdc: c2 06 20 08 ld [ %i0 + 8 ], %g1 2006ce0: 80 a0 80 01 cmp %g2, %g1 2006ce4: 32 80 00 07 bne,a 2006d00 <_Rate_monotonic_Timeout+0x68> 2006ce8: 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 ); 2006cec: 13 04 00 ff sethi %hi(0x1003fc00), %o1 2006cf0: 40 00 0d 86 call 200a308 <_Thread_Clear_state> 2006cf4: 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 ); 2006cf8: 10 80 00 08 b 2006d18 <_Rate_monotonic_Timeout+0x80> 2006cfc: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 2006d00: 80 a0 60 01 cmp %g1, 1 2006d04: 12 80 00 08 bne 2006d24 <_Rate_monotonic_Timeout+0x8c> 2006d08: 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 ); 2006d0c: 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; 2006d10: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 2006d14: c2 26 20 38 st %g1, [ %i0 + 0x38 ] <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 2006d18: 7f ff ff d8 call 2006c78 <_Watchdog_Insert_ticks> 2006d1c: 90 06 20 10 add %i0, 0x10, %o0 2006d20: 30 80 00 02 b,a 2006d28 <_Rate_monotonic_Timeout+0x90> } else the_period->state = RATE_MONOTONIC_EXPIRED; 2006d24: 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; 2006d28: 05 00 80 76 sethi %hi(0x201d800), %g2 2006d2c: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1 ! 201d8e0 <_Thread_Dispatch_disable_level> 2006d30: 82 00 7f ff add %g1, -1, %g1 2006d34: c2 20 a0 e0 st %g1, [ %g2 + 0xe0 ] 2006d38: 81 c7 e0 08 ret 2006d3c: 81 e8 00 00 restore 02008608 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 2008608: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200860c: 03 00 80 95 sethi %hi(0x2025400), %g1 2008610: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 2025700 <_Thread_Dispatch_disable_level> 2008614: 84 00 a0 01 inc %g2 2008618: c4 20 63 00 st %g2, [ %g1 + 0x300 ] _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 200861c: 03 00 80 95 sethi %hi(0x2025400), %g1 2008620: d2 06 00 00 ld [ %i0 ], %o1 2008624: c2 00 63 bc ld [ %g1 + 0x3bc ], %g1 2008628: 80 a2 40 01 cmp %o1, %g1 200862c: 36 80 00 05 bge,a 2008640 <_TOD_Set+0x38> 2008630: 92 22 40 01 sub %o1, %g1, %o1 _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, 2008634: 92 20 40 09 sub %g1, %o1, %o1 2008638: 10 80 00 03 b 2008644 <_TOD_Set+0x3c> 200863c: 90 10 20 01 mov 1, %o0 _TOD_Seconds_since_epoch - time->tv_sec ); else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, 2008640: 90 10 20 00 clr %o0 2008644: 7f ff ff e9 call 20085e8 <_Watchdog_Adjust_seconds> 2008648: 01 00 00 00 nop time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 200864c: c4 06 00 00 ld [ %i0 ], %g2 2008650: 03 00 80 95 sethi %hi(0x2025400), %g1 2008654: c4 20 63 bc st %g2, [ %g1 + 0x3bc ] ! 20257bc <_TOD_Now> 2008658: c4 06 20 04 ld [ %i0 + 4 ], %g2 200865c: 82 10 63 bc or %g1, 0x3bc, %g1 2008660: c4 20 60 04 st %g2, [ %g1 + 4 ] _TOD_Is_set = TRUE; 2008664: 84 10 20 01 mov 1, %g2 2008668: 03 00 80 95 sethi %hi(0x2025400), %g1 200866c: c4 20 63 3c st %g2, [ %g1 + 0x33c ] ! 202573c <_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 ) 2008670: 05 00 80 95 sethi %hi(0x2025400), %g2 2008674: c2 00 a3 00 ld [ %g2 + 0x300 ], %g1 ! 2025700 <_Thread_Dispatch_disable_level> 2008678: 82 00 7f ff add %g1, -1, %g1 200867c: c2 20 a3 00 st %g1, [ %g2 + 0x300 ] 2008680: c2 00 a3 00 ld [ %g2 + 0x300 ], %g1 2008684: 80 a0 60 00 cmp %g1, 0 2008688: 12 80 00 04 bne 2008698 <_TOD_Set+0x90> 200868c: 01 00 00 00 nop _Thread_Dispatch(); 2008690: 40 00 07 f2 call 200a658 <_Thread_Dispatch> <== NOT EXECUTED 2008694: 81 e8 00 00 restore <== NOT EXECUTED 2008698: 81 c7 e0 08 ret 200869c: 81 e8 00 00 restore 02008a6c <_Thread_Create_idle>: */ const char *_Thread_Idle_name = "IDLE"; void _Thread_Create_idle( void ) { 2008a6c: 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 ); 2008a70: 11 00 80 63 sethi %hi(0x2018c00), %o0 2008a74: 7f ff fa 11 call 20072b8 <_Objects_Allocate> 2008a78: 90 12 20 80 or %o0, 0x80, %o0 ! 2018c80 <_Thread_Internal_information> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 2008a7c: 03 00 80 62 sethi %hi(0x2018800), %g1 2008a80: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 2018b10 <_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(); 2008a84: 03 00 80 63 sethi %hi(0x2018c00), %g1 2008a88: d0 20 60 d8 st %o0, [ %g1 + 0xd8 ] ! 2018cd8 <_Thread_Idle> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 2008a8c: 80 a0 a0 00 cmp %g2, 0 2008a90: 03 00 80 23 sethi %hi(0x2008c00), %g1 2008a94: 02 80 00 03 be 2008aa0 <_Thread_Create_idle+0x34> 2008a98: b4 10 61 54 or %g1, 0x154, %i2 ! 2008d54 <_Thread_Idle_body> idle = _CPU_Table.idle_task; 2008a9c: b4 10 00 02 mov %g2, %i2 <== NOT EXECUTED idle_task_stack_size = _CPU_Table.idle_task_stack_size; 2008aa0: 03 00 80 62 sethi %hi(0x2018800), %g1 2008aa4: d6 00 63 18 ld [ %g1 + 0x318 ], %o3 ! 2018b18 <_CPU_Table+0x14> if ( idle_task_stack_size < STACK_MINIMUM_SIZE ) 2008aa8: 80 a2 ef ff cmp %o3, 0xfff 2008aac: 28 80 00 02 bleu,a 2008ab4 <_Thread_Create_idle+0x48> 2008ab0: 17 00 00 04 sethi %hi(0x1000), %o3 idle_task_stack_size = STACK_MINIMUM_SIZE; _Thread_Initialize( 2008ab4: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008ab8: c2 00 60 f0 ld [ %g1 + 0xf0 ], %g1 ! 2017cf0 <_Thread_Idle_name> 2008abc: 92 10 00 08 mov %o0, %o1 2008ac0: c2 23 a0 6c st %g1, [ %sp + 0x6c ] 2008ac4: 82 10 20 01 mov 1, %g1 2008ac8: c0 23 a0 60 clr [ %sp + 0x60 ] 2008acc: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2008ad0: c0 23 a0 64 clr [ %sp + 0x64 ] 2008ad4: c0 23 a0 68 clr [ %sp + 0x68 ] 2008ad8: 11 00 80 63 sethi %hi(0x2018c00), %o0 2008adc: 94 10 20 00 clr %o2 2008ae0: 90 12 20 80 or %o0, 0x80, %o0 2008ae4: 98 10 20 00 clr %o4 2008ae8: 40 00 00 aa call 2008d90 <_Thread_Initialize> 2008aec: 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 = 2008af0: 03 00 80 63 sethi %hi(0x2018c00), %g1 2008af4: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2 ! 2018cd8 <_Thread_Idle> 2008af8: 03 00 80 62 sethi %hi(0x2018800), %g1 2008afc: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] ! 2018bd0 <_Thread_Executing> 2008b00: 03 00 80 62 sethi %hi(0x2018800), %g1 _Thread_Executing = _Thread_Idle; _Thread_Start( 2008b04: 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 = 2008b08: c4 20 63 a8 st %g2, [ %g1 + 0x3a8 ] _Thread_Executing = _Thread_Idle; _Thread_Start( 2008b0c: b2 10 20 00 clr %i1 2008b10: b6 10 20 00 clr %i3 2008b14: 40 00 04 0c call 2009b44 <_Thread_Start> 2008b18: 99 e8 20 00 restore %g0, 0, %o4 2008b1c: 01 00 00 00 nop 02008b20 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 2008b20: 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 ) ) { 2008b24: 92 96 20 00 orcc %i0, 0, %o1 2008b28: 12 80 00 0a bne 2008b50 <_Thread_Delay_ended+0x30> 2008b2c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008b30: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008b34: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008b38: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2008b3c: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] <== 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; 2008b40: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008b44: d0 00 63 d0 ld [ %g1 + 0x3d0 ], %o0 ! 2018bd0 <_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; 2008b48: 10 80 00 19 b 2008bac <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 2008b4c: 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); 2008b50: 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 ) { 2008b54: 80 a0 a0 04 cmp %g2, 4 2008b58: 18 80 00 06 bgu 2008b70 <_Thread_Delay_ended+0x50> 2008b5c: 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 :) */ 2008b60: 83 32 60 1b srl %o1, 0x1b, %g1 2008b64: 80 a0 60 01 cmp %g1, 1 2008b68: 02 80 00 05 be 2008b7c <_Thread_Delay_ended+0x5c> 2008b6c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2008b70: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008b74: 10 80 00 0e b 2008bac <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 2008b78: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2008b7c: 83 28 a0 02 sll %g2, 2, %g1 2008b80: 05 00 80 62 sethi %hi(0x2018800), %g2 2008b84: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 2008b88: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2008b8c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2008b90: 80 a2 20 00 cmp %o0, 0 2008b94: 12 80 00 04 bne 2008ba4 <_Thread_Delay_ended+0x84> 2008b98: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2008b9c: 10 80 00 04 b 2008bac <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 2008ba0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2008ba4: 7f ff fb 09 call 20077c8 <_Objects_Get> 2008ba8: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2008bac: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008bb0: 80 a0 60 00 cmp %g1, 0 2008bb4: 12 80 00 08 bne 2008bd4 <_Thread_Delay_ended+0xb4> 2008bb8: 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 ); 2008bbc: 7f ff ff 3d call 20088b0 <_Thread_Clear_state> 2008bc0: 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; 2008bc4: 05 00 80 62 sethi %hi(0x2018800), %g2 2008bc8: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2008bcc: 82 00 7f ff add %g1, -1, %g1 2008bd0: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2008bd4: 81 c7 e0 08 ret 2008bd8: 81 e8 00 00 restore 0200e10c <_Thread_Evaluate_mode>: boolean _Thread_Evaluate_mode( void ) { Thread_Control *executing; executing = _Thread_Executing; 200e10c: 03 00 80 62 sethi %hi(0x2018800), %g1 200e110: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> if ( !_States_Is_ready( executing->current_state ) || 200e114: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 200e118: 80 a0 60 00 cmp %g1, 0 200e11c: 32 80 00 0b bne,a 200e148 <_Thread_Evaluate_mode+0x3c> 200e120: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 200e124: 03 00 80 62 sethi %hi(0x2018800), %g1 200e128: c2 00 63 a8 ld [ %g1 + 0x3a8 ], %g1 ! 2018ba8 <_Thread_Heir> 200e12c: 80 a0 80 01 cmp %g2, %g1 200e130: 02 80 00 0b be 200e15c <_Thread_Evaluate_mode+0x50> 200e134: 01 00 00 00 nop 200e138: c2 00 a0 7c ld [ %g2 + 0x7c ], %g1 200e13c: 80 a0 60 00 cmp %g1, 0 200e140: 02 80 00 07 be 200e15c <_Thread_Evaluate_mode+0x50> 200e144: 84 10 20 01 mov 1, %g2 ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 200e148: 03 00 80 62 sethi %hi(0x2018800), %g1 200e14c: 90 10 20 01 mov 1, %o0 200e150: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] 200e154: 81 c3 e0 08 retl 200e158: 01 00 00 00 nop return TRUE; } return FALSE; } 200e15c: 81 c3 e0 08 retl 200e160: 90 10 20 00 clr %o0 ! 0 0200e164 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 200e164: 9d e3 bf 98 save %sp, -104, %sp #endif #if defined(__USE__MAIN__) extern void _main(void); #endif executing = _Thread_Executing; 200e168: 03 00 80 62 sethi %hi(0x2018800), %g1 200e16c: f4 00 63 d0 ld [ %g1 + 0x3d0 ], %i2 ! 2018bd0 <_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(); 200e170: 3f 00 80 38 sethi %hi(0x200e000), %i7 200e174: be 17 e1 64 or %i7, 0x164, %i7 ! 200e164 <_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); 200e178: d0 06 a0 c4 ld [ %i2 + 0xc4 ], %o0 200e17c: 7f ff ce fc call 2001d6c 200e180: 91 2a 20 08 sll %o0, 8, %o0 #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; doneConstructors = 1; 200e184: 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; 200e188: 05 00 80 61 sethi %hi(0x2018400), %g2 200e18c: f0 08 a3 54 ldub [ %g2 + 0x354 ], %i0 ! 2018754 doneConstructors = 1; 200e190: c2 28 a3 54 stb %g1, [ %g2 + 0x354 ] #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && !_Thread_Is_allocated_fp( executing ) ) { 200e194: c2 06 a1 68 ld [ %i2 + 0x168 ], %g1 200e198: 80 a0 60 00 cmp %g1, 0 200e19c: 02 80 00 0b be 200e1c8 <_Thread_Handler+0x64> 200e1a0: 33 00 80 62 sethi %hi(0x2018800), %i1 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE boolean _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 200e1a4: d0 06 63 a0 ld [ %i1 + 0x3a0 ], %o0 ! 2018ba0 <_Thread_Allocated_fp> 200e1a8: 80 a6 80 08 cmp %i2, %o0 200e1ac: 02 80 00 07 be 200e1c8 <_Thread_Handler+0x64> 200e1b0: 80 a2 20 00 cmp %o0, 0 if ( _Thread_Allocated_fp != NULL ) 200e1b4: 22 80 00 05 be,a 200e1c8 <_Thread_Handler+0x64> 200e1b8: f4 26 63 a0 st %i2, [ %i1 + 0x3a0 ] _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 200e1bc: 7f ff f0 75 call 200a390 <_CPU_Context_save_fp> 200e1c0: 90 02 21 68 add %o0, 0x168, %o0 _Thread_Allocated_fp = executing; 200e1c4: f4 26 63 a0 st %i2, [ %i1 + 0x3a0 ] * 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 ); 200e1c8: 7f ff ef 17 call 2009e24 <_User_extensions_Thread_begin> 200e1cc: 90 10 00 1a mov %i2, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200e1d0: 03 00 80 62 sethi %hi(0x2018800), %g1 200e1d4: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> 200e1d8: 84 00 bf ff add %g2, -1, %g2 200e1dc: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] 200e1e0: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 200e1e4: 80 a0 60 00 cmp %g1, 0 200e1e8: 12 80 00 05 bne 200e1fc <_Thread_Handler+0x98> 200e1ec: 83 2e 20 18 sll %i0, 0x18, %g1 _Thread_Dispatch(); 200e1f0: 7f ff ea 7b call 2008bdc <_Thread_Dispatch> 200e1f4: 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) */ 200e1f8: 83 2e 20 18 sll %i0, 0x18, %g1 200e1fc: 80 a0 60 00 cmp %g1, 0 200e200: 32 80 00 05 bne,a 200e214 <_Thread_Handler+0xb0> 200e204: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 _init (); 200e208: 40 00 25 54 call 2017758 <_init> 200e20c: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200e210: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 200e214: 80 a0 60 01 cmp %g1, 1 200e218: 22 80 00 0d be,a 200e24c <_Thread_Handler+0xe8> 200e21c: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 200e220: 2a 80 00 09 bcs,a 200e244 <_Thread_Handler+0xe0> 200e224: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 200e228: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200e22c: 02 80 00 0d be 200e260 <_Thread_Handler+0xfc> <== NOT EXECUTED 200e230: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 200e234: 12 80 00 14 bne 200e284 <_Thread_Handler+0x120> <== NOT EXECUTED 200e238: 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 = 200e23c: 10 80 00 0c b 200e26c <_Thread_Handler+0x108> <== NOT EXECUTED 200e240: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED __main (); #endif switch ( executing->Start.prototype ) { case THREAD_START_NUMERIC: executing->Wait.return_argument = 200e244: 10 80 00 03 b 200e250 <_Thread_Handler+0xec> 200e248: 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 = 200e24c: d0 06 a0 b0 ld [ %i2 + 0xb0 ], %o0 200e250: 9f c0 40 00 call %g1 200e254: 01 00 00 00 nop executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 200e258: 10 80 00 0a b 200e280 <_Thread_Handler+0x11c> 200e25c: 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 = 200e260: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 200e264: 10 80 00 04 b 200e274 <_Thread_Handler+0x110> <== NOT EXECUTED 200e268: 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 = 200e26c: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 <== NOT EXECUTED 200e270: d2 06 a0 b0 ld [ %i2 + 0xb0 ], %o1 <== NOT EXECUTED 200e274: 9f c0 40 00 call %g1 <== NOT EXECUTED 200e278: 01 00 00 00 nop <== NOT EXECUTED 200e27c: 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 ); 200e280: 90 10 00 1a mov %i2, %o0 200e284: 7f ff ef 0b call 2009eb0 <_User_extensions_Thread_exitted> 200e288: b0 10 20 00 clr %i0 _Internal_error_Occurred( 200e28c: b2 10 20 01 mov 1, %i1 200e290: 7f ff e3 dd call 2007204 <_Internal_error_Occurred> 200e294: 95 e8 20 06 restore %g0, 6, %o2 200e298: 01 00 00 00 nop 02008f90 <_Thread_Handler_initialization>: void _Thread_Handler_initialization( uint32_t ticks_per_timeslice, uint32_t maximum_extensions, uint32_t maximum_proxies ) { 2008f90: 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 ) 2008f94: 03 00 80 62 sethi %hi(0x2018800), %g1 2008f98: 82 10 63 04 or %g1, 0x304, %g1 ! 2018b04 <_CPU_Table> 2008f9c: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 2008fa0: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 2008fa4: 80 a0 00 02 cmp %g0, %g2 2008fa8: 84 60 3f ff subx %g0, -1, %g2 2008fac: 80 a0 00 01 cmp %g0, %g1 2008fb0: 82 60 3f ff subx %g0, -1, %g1 2008fb4: 80 a0 80 01 cmp %g2, %g1 2008fb8: 02 80 00 07 be 2008fd4 <_Thread_Handler_initialization+0x44> 2008fbc: 03 00 80 62 sethi %hi(0x2018800), %g1 == ( _CPU_Table.stack_free_hook == 0 ) ) ) _Internal_error_Occurred( 2008fc0: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008fc4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2008fc8: 7f ff f8 8f call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2008fcc: 94 10 20 0f mov 0xf, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 2008fd0: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008fd4: c0 20 63 e0 clr [ %g1 + 0x3e0 ] ! 2018be0 <_Context_Switch_necessary> _Thread_Executing = NULL; 2008fd8: 03 00 80 62 sethi %hi(0x2018800), %g1 2008fdc: c0 20 63 d0 clr [ %g1 + 0x3d0 ] ! 2018bd0 <_Thread_Executing> _Thread_Heir = NULL; 2008fe0: 03 00 80 62 sethi %hi(0x2018800), %g1 2008fe4: c0 20 63 a8 clr [ %g1 + 0x3a8 ] ! 2018ba8 <_Thread_Heir> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 2008fe8: 03 00 80 62 sethi %hi(0x2018800), %g1 2008fec: c0 20 63 a0 clr [ %g1 + 0x3a0 ] ! 2018ba0 <_Thread_Allocated_fp> #endif _Thread_Do_post_task_switch_extension = 0; 2008ff0: 03 00 80 62 sethi %hi(0x2018800), %g1 2008ff4: c0 20 63 c0 clr [ %g1 + 0x3c0 ] ! 2018bc0 <_Thread_Do_post_task_switch_extension> _Thread_Maximum_extensions = maximum_extensions; 2008ff8: 03 00 80 62 sethi %hi(0x2018800), %g1 2008ffc: f2 20 63 bc st %i1, [ %g1 + 0x3bc ] ! 2018bbc <_Thread_Maximum_extensions> _Thread_Ticks_per_timeslice = ticks_per_timeslice; 2009000: 03 00 80 62 sethi %hi(0x2018800), %g1 _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 2009004: 90 10 2c 00 mov 0xc00, %o0 2009008: 40 00 04 b1 call 200a2cc <_Workspace_Allocate_or_fatal_error> 200900c: f0 20 62 48 st %i0, [ %g1 + 0x248 ] 2009010: 03 00 80 62 sethi %hi(0x2018800), %g1 2009014: 84 10 00 08 mov %o0, %g2 2009018: d0 20 62 44 st %o0, [ %g1 + 0x244 ] (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 200901c: 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); 2009020: 82 00 a0 04 add %g2, 4, %g1 the_chain->permanent_null = NULL; 2009024: c0 20 a0 04 clr [ %g2 + 4 ] the_chain->last = _Chain_Head(the_chain); 2009028: 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); 200902c: c2 20 80 00 st %g1, [ %g2 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009030: 84 00 a0 0c add %g2, 0xc, %g2 2009034: 80 a0 80 03 cmp %g2, %g3 2009038: 12 bf ff fb bne 2009024 <_Thread_Handler_initialization+0x94> 200903c: 82 00 a0 04 add %g2, 4, %g1 /* * Initialize this class of objects. */ _Objects_Initialize_information( 2009040: 03 00 80 62 sethi %hi(0x2018800), %g1 2009044: c2 00 63 fc ld [ %g1 + 0x3fc ], %g1 ! 2018bfc <_System_state_Is_multiprocessing> 2009048: 96 10 20 02 mov 2, %o3 200904c: 80 a0 00 01 cmp %g0, %g1 2009050: 82 10 20 08 mov 8, %g1 2009054: 96 42 ff ff addx %o3, -1, %o3 2009058: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 200905c: 11 00 80 63 sethi %hi(0x2018c00), %o0 2009060: 92 10 20 01 mov 1, %o1 2009064: 90 12 20 80 or %o0, 0x80, %o0 2009068: 94 10 20 01 mov 1, %o2 200906c: 98 10 21 88 mov 0x188, %o4 2009070: 7f ff f9 fb call 200785c <_Objects_Initialize_information> 2009074: 9a 10 20 01 mov 1, %o5 FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 2009078: 81 c7 e0 08 ret 200907c: 81 e8 00 00 restore 02008d90 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 2008d90: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the Ada self pointer */ the_thread->rtems_ada_self = NULL; 2008d94: c0 26 60 80 clr [ %i1 + 0x80 ] /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 2008d98: 80 a6 a0 00 cmp %i2, 0 2008d9c: 12 80 00 10 bne 2008ddc <_Thread_Initialize+0x4c> 2008da0: e0 07 a0 60 ld [ %fp + 0x60 ], %l0 if ( !_Stack_Is_enough( stack_size ) ) 2008da4: 80 a6 ef ff cmp %i3, 0xfff 2008da8: 08 80 00 03 bleu 2008db4 <_Thread_Initialize+0x24> 2008dac: 13 00 00 04 sethi %hi(0x1000), %o1 2008db0: 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 ); 2008db4: 40 00 03 26 call 2009a4c <_Thread_Stack_Allocate> 2008db8: 90 10 00 19 mov %i1, %o0 if ( !actual_stack_size || actual_stack_size < stack_size ) 2008dbc: 80 a2 20 00 cmp %o0, 0 2008dc0: 02 80 00 2c be 2008e70 <_Thread_Initialize+0xe0> 2008dc4: 80 a2 00 1b cmp %o0, %i3 2008dc8: 0a 80 00 2a bcs 2008e70 <_Thread_Initialize+0xe0> 2008dcc: 82 10 20 01 mov 1, %g1 return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 2008dd0: f4 06 60 dc ld [ %i1 + 0xdc ], %i2 the_thread->Start.core_allocated_stack = TRUE; 2008dd4: 10 80 00 04 b 2008de4 <_Thread_Initialize+0x54> 2008dd8: c2 26 60 cc st %g1, [ %i1 + 0xcc ] } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 2008ddc: c0 26 60 cc clr [ %i1 + 0xcc ] <== NOT EXECUTED 2008de0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 2008de4: f4 26 60 d4 st %i2, [ %i1 + 0xd4 ] the_stack->size = size; 2008de8: d0 26 60 d0 st %o0, [ %i1 + 0xd0 ] /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 2008dec: 80 a7 20 00 cmp %i4, 0 2008df0: 02 80 00 07 be 2008e0c <_Thread_Initialize+0x7c> 2008df4: b8 10 20 00 clr %i4 fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 2008df8: 7f ff ff d8 call 2008d58 <_Workspace_Allocate> 2008dfc: 90 10 20 88 mov 0x88, %o0 if ( !fp_area ) { 2008e00: b8 92 20 00 orcc %o0, 0, %i4 2008e04: 02 80 00 19 be 2008e68 <_Thread_Initialize+0xd8> 2008e08: 01 00 00 00 nop /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 2008e0c: 03 00 80 62 sethi %hi(0x2018800), %g1 2008e10: d0 00 63 bc ld [ %g1 + 0x3bc ], %o0 ! 2018bbc <_Thread_Maximum_extensions> fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 2008e14: f8 26 61 68 st %i4, [ %i1 + 0x168 ] the_thread->Start.fp_context = fp_area; 2008e18: f8 26 60 d8 st %i4, [ %i1 + 0xd8 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2008e1c: c0 26 60 50 clr [ %i1 + 0x50 ] the_watchdog->routine = routine; 2008e20: c0 26 60 64 clr [ %i1 + 0x64 ] the_watchdog->id = id; 2008e24: c0 26 60 68 clr [ %i1 + 0x68 ] the_watchdog->user_data = user_data; 2008e28: c0 26 60 6c clr [ %i1 + 0x6c ] /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 2008e2c: c0 26 61 6c clr [ %i1 + 0x16c ] /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 2008e30: 80 a2 20 00 cmp %o0, 0 2008e34: 02 80 00 11 be 2008e78 <_Thread_Initialize+0xe8> 2008e38: b6 10 20 00 clr %i3 extensions_area = _Workspace_Allocate( 2008e3c: 90 02 20 01 inc %o0 2008e40: 7f ff ff c6 call 2008d58 <_Workspace_Allocate> 2008e44: 91 2a 20 02 sll %o0, 2, %o0 (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 2008e48: b6 92 20 00 orcc %o0, 0, %i3 2008e4c: 12 80 00 0c bne 2008e7c <_Thread_Initialize+0xec> 2008e50: 80 a6 e0 00 cmp %i3, 0 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2008e54: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 2008e58: 02 80 00 04 be 2008e68 <_Thread_Initialize+0xd8> <== NOT EXECUTED 2008e5c: 01 00 00 00 nop <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 2008e60: 7f ff ff c5 call 2008d74 <_Workspace_Free> <== NOT EXECUTED 2008e64: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 2008e68: 40 00 03 10 call 2009aa8 <_Thread_Stack_Free> <== NOT EXECUTED 2008e6c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2008e70: 81 c7 e0 08 ret 2008e74: 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 ) { 2008e78: 80 a6 e0 00 cmp %i3, 0 2008e7c: 02 80 00 0d be 2008eb0 <_Thread_Initialize+0x120> 2008e80: f6 26 61 7c st %i3, [ %i1 + 0x17c ] int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2008e84: 03 00 80 62 sethi %hi(0x2018800), %g1 2008e88: c2 00 63 bc ld [ %g1 + 0x3bc ], %g1 ! 2018bbc <_Thread_Maximum_extensions> 2008e8c: 86 10 20 00 clr %g3 2008e90: 10 80 00 05 b 2008ea4 <_Thread_Initialize+0x114> 2008e94: 88 00 60 01 add %g1, 1, %g4 the_thread->extensions[i] = NULL; 2008e98: 83 28 e0 02 sll %g3, 2, %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2008e9c: 86 00 e0 01 inc %g3 the_thread->extensions[i] = NULL; 2008ea0: c0 20 80 01 clr [ %g2 + %g1 ] * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2008ea4: 80 a0 c0 04 cmp %g3, %g4 2008ea8: 32 bf ff fc bne,a 2008e98 <_Thread_Initialize+0x108> 2008eac: c4 06 61 7c ld [ %i1 + 0x17c ], %g2 /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 2008eb0: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 the_thread->Start.budget_algorithm = budget_algorithm; 2008eb4: e0 26 60 bc st %l0, [ %i1 + 0xbc ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 2008eb8: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 2008ebc: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 switch ( budget_algorithm ) { 2008ec0: 80 a4 20 02 cmp %l0, 2 2008ec4: 12 80 00 05 bne 2008ed8 <_Thread_Initialize+0x148> 2008ec8: 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; 2008ecc: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008ed0: c2 00 62 48 ld [ %g1 + 0x248 ], %g1 ! 2018a48 <_Thread_Ticks_per_timeslice> <== NOT EXECUTED 2008ed4: 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; 2008ed8: c2 07 a0 68 ld [ %fp + 0x68 ], %g1 the_thread->current_state = STATES_DORMANT; the_thread->Wait.queue = NULL; 2008edc: c0 26 60 44 clr [ %i1 + 0x44 ] break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 2008ee0: c2 26 60 c4 st %g1, [ %i1 + 0xc4 ] the_thread->current_state = STATES_DORMANT; 2008ee4: 82 10 20 01 mov 1, %g1 the_thread->Wait.queue = NULL; the_thread->resource_count = 0; 2008ee8: c0 26 60 1c clr [ %i1 + 0x1c ] break; } the_thread->Start.isr_level = isr_level; the_thread->current_state = STATES_DORMANT; 2008eec: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_thread->Wait.queue = NULL; the_thread->resource_count = 0; the_thread->suspend_count = 0; 2008ef0: c0 26 60 70 clr [ %i1 + 0x70 ] the_thread->real_priority = priority; 2008ef4: fa 26 60 18 st %i5, [ %i1 + 0x18 ] the_thread->Start.initial_priority = priority; 2008ef8: fa 26 60 c8 st %i5, [ %i1 + 0xc8 ] _Thread_Set_priority( the_thread, priority ); 2008efc: 92 10 00 1d mov %i5, %o1 2008f00: 40 00 02 32 call 20097c8 <_Thread_Set_priority> 2008f04: 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 ); 2008f08: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2008f0c: 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; 2008f10: c0 26 60 90 clr [ %i1 + 0x90 ] 2008f14: 03 00 00 3f sethi %hi(0xfc00), %g1 2008f18: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2008f1c: 82 08 80 01 and %g2, %g1, %g1 2008f20: 80 a0 40 03 cmp %g1, %g3 2008f24: 18 80 00 05 bgu 2008f38 <_Thread_Initialize+0x1a8> 2008f28: c0 26 60 94 clr [ %i1 + 0x94 ] information->local_table[ index ] = the_object; 2008f2c: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 2008f30: 83 28 60 02 sll %g1, 2, %g1 2008f34: 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; 2008f38: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 /* * Invoke create extensions */ if ( !_User_extensions_Thread_create( the_thread ) ) { 2008f3c: 90 10 00 19 mov %i1, %o0 2008f40: c2 26 60 0c st %g1, [ %i1 + 0xc ] 2008f44: 40 00 03 ec call 2009ef4 <_User_extensions_Thread_create> 2008f48: b0 10 20 01 mov 1, %i0 2008f4c: 80 a2 20 00 cmp %o0, 0 2008f50: 12 80 00 0e bne 2008f88 <_Thread_Initialize+0x1f8> 2008f54: 80 a6 e0 00 cmp %i3, 0 if ( extensions_area ) 2008f58: 02 80 00 05 be 2008f6c <_Thread_Initialize+0x1dc> <== NOT EXECUTED 2008f5c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); 2008f60: 7f ff ff 85 call 2008d74 <_Workspace_Free> <== NOT EXECUTED 2008f64: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2008f68: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 2008f6c: 02 80 00 05 be 2008f80 <_Thread_Initialize+0x1f0> <== NOT EXECUTED 2008f70: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 2008f74: 7f ff ff 80 call 2008d74 <_Workspace_Free> <== NOT EXECUTED 2008f78: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 2008f7c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2008f80: 40 00 02 ca call 2009aa8 <_Thread_Stack_Free> <== NOT EXECUTED 2008f84: b0 10 20 00 clr %i0 <== NOT EXECUTED return FALSE; } return TRUE; } 2008f88: 81 c7 e0 08 ret 2008f8c: 81 e8 00 00 restore 0200e24c <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { 200e24c: 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; 200e250: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 200e254: c4 06 20 bc ld [ %i0 + 0xbc ], %g2 the_thread->budget_callout = the_thread->Start.budget_callout; 200e258: 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; 200e25c: 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; 200e260: c4 3e 20 88 std %g2, [ %i0 + 0x88 ] the_thread->Start.pointer_argument = pointer_argument; 200e264: f2 26 20 b0 st %i1, [ %i0 + 0xb0 ] the_thread->Start.numeric_argument = numeric_argument; 200e268: f4 26 20 b4 st %i2, [ %i0 + 0xb4 ] Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { the_thread->resource_count = 0; 200e26c: c0 26 20 1c clr [ %i0 + 0x1c ] the_thread->suspend_count = 0; 200e270: 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 ) ) { 200e274: 7f ff ef fc call 200a264 <_Thread_queue_Extract_with_proxy> 200e278: 90 10 00 18 mov %i0, %o0 200e27c: 80 a2 20 00 cmp %o0, 0 200e280: 32 80 00 09 bne,a 200e2a4 <_Thread_Reset+0x58> 200e284: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 if ( _Watchdog_Is_active( &the_thread->Timer ) ) 200e288: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 200e28c: 80 a0 60 02 cmp %g1, 2 200e290: 32 80 00 05 bne,a 200e2a4 <_Thread_Reset+0x58> 200e294: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 (void) _Watchdog_Remove( &the_thread->Timer ); 200e298: 7f ff f3 41 call 200af9c <_Watchdog_Remove> <== NOT EXECUTED 200e29c: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 200e2a0: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 <== NOT EXECUTED 200e2a4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 200e2a8: 80 a0 40 19 cmp %g1, %i1 200e2ac: 02 80 00 05 be 200e2c0 <_Thread_Reset+0x74> 200e2b0: 01 00 00 00 nop the_thread->real_priority = the_thread->Start.initial_priority; 200e2b4: f2 26 20 18 st %i1, [ %i0 + 0x18 ] _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 200e2b8: 7f ff f0 b9 call 200a59c <_Thread_Set_priority> 200e2bc: 81 e8 00 00 restore 200e2c0: 81 c7 e0 08 ret 200e2c4: 81 e8 00 00 restore 0200d3dc <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 200d3dc: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 200d3e0: 03 00 80 62 sethi %hi(0x2018800), %g1 200d3e4: e0 00 63 d0 ld [ %g1 + 0x3d0 ], %l0 ! 2018bd0 <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 200d3e8: 7f ff d2 5d call 2001d5c 200d3ec: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 200d3f0: b0 10 00 08 mov %o0, %i0 if ( _Chain_Has_only_one_node( ready ) ) { 200d3f4: c4 04 40 00 ld [ %l1 ], %g2 200d3f8: c2 04 60 08 ld [ %l1 + 8 ], %g1 200d3fc: 80 a0 80 01 cmp %g2, %g1 200d400: 32 80 00 03 bne,a 200d40c <_Thread_Reset_timeslice+0x30> 200d404: c6 04 00 00 ld [ %l0 ], %g3 _ISR_Enable( level ); 200d408: 30 80 00 18 b,a 200d468 <_Thread_Reset_timeslice+0x8c> { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 200d40c: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200d410: 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; 200d414: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200d418: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200d41c: 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; 200d420: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 200d424: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200d428: 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; 200d42c: e0 20 40 00 st %l0, [ %g1 ] return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 200d430: 7f ff d2 4f call 2001d6c 200d434: 01 00 00 00 nop 200d438: 7f ff d2 49 call 2001d5c 200d43c: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 200d440: 05 00 80 62 sethi %hi(0x2018800), %g2 200d444: c2 00 a3 a8 ld [ %g2 + 0x3a8 ], %g1 ! 2018ba8 <_Thread_Heir> 200d448: 80 a4 00 01 cmp %l0, %g1 200d44c: 32 80 00 05 bne,a 200d460 <_Thread_Reset_timeslice+0x84> 200d450: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 200d454: c2 04 40 00 ld [ %l1 ], %g1 200d458: c2 20 a3 a8 st %g1, [ %g2 + 0x3a8 ] _Context_Switch_necessary = TRUE; 200d45c: 84 10 20 01 mov 1, %g2 200d460: 03 00 80 62 sethi %hi(0x2018800), %g1 200d464: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] ! 2018be0 <_Context_Switch_necessary> _ISR_Enable( level ); 200d468: 7f ff d2 41 call 2001d6c 200d46c: 81 e8 00 00 restore 200d470: 01 00 00 00 nop 0200b29c <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, boolean force ) { 200b29c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; States_Control current_state; _ISR_Disable( level ); 200b2a0: 7f ff dd f8 call 2002a80 200b2a4: 01 00 00 00 nop 200b2a8: a0 10 00 08 mov %o0, %l0 if ( force == TRUE ) 200b2ac: 80 a6 60 01 cmp %i1, 1 200b2b0: 32 80 00 04 bne,a 200b2c0 <_Thread_Resume+0x24> 200b2b4: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED the_thread->suspend_count = 0; 200b2b8: 10 80 00 04 b 200b2c8 <_Thread_Resume+0x2c> 200b2bc: c0 26 20 70 clr [ %i0 + 0x70 ] else the_thread->suspend_count--; 200b2c0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200b2c4: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 200b2c8: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 200b2cc: 80 a0 60 00 cmp %g1, 0 200b2d0: 22 80 00 03 be,a 200b2dc <_Thread_Resume+0x40> 200b2d4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 _ISR_Enable( level ); 200b2d8: 30 80 00 2e b,a 200b390 <_Thread_Resume+0xf4> <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { 200b2dc: 80 88 60 02 btst 2, %g1 200b2e0: 02 80 00 2c be 200b390 <_Thread_Resume+0xf4> 200b2e4: 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 ) ) { 200b2e8: 80 a0 60 00 cmp %g1, 0 200b2ec: 12 80 00 29 bne 200b390 <_Thread_Resume+0xf4> 200b2f0: 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; 200b2f4: c8 06 20 9c ld [ %i0 + 0x9c ], %g4 200b2f8: c4 16 20 a2 lduh [ %i0 + 0xa2 ], %g2 200b2fc: 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); 200b300: c6 06 20 98 ld [ %i0 + 0x98 ], %g3 200b304: 82 10 40 02 or %g1, %g2, %g1 200b308: c2 31 00 00 sth %g1, [ %g4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200b30c: 82 00 e0 04 add %g3, 4, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 200b310: 09 00 80 95 sethi %hi(0x2025400), %g4 200b314: c2 26 00 00 st %g1, [ %i0 ] 200b318: da 16 20 a0 lduh [ %i0 + 0xa0 ], %o5 old_last_node = the_chain->last; 200b31c: c2 00 e0 08 ld [ %g3 + 8 ], %g1 200b320: c4 11 23 d4 lduh [ %g4 + 0x3d4 ], %g2 the_chain->last = the_node; 200b324: f0 20 e0 08 st %i0, [ %g3 + 8 ] 200b328: 84 10 80 0d or %g2, %o5, %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 200b32c: c2 26 20 04 st %g1, [ %i0 + 4 ] 200b330: c4 31 23 d4 sth %g2, [ %g4 + 0x3d4 ] 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; 200b334: f0 20 40 00 st %i0, [ %g1 ] _ISR_Flash( level ); 200b338: 7f ff dd d6 call 2002a90 200b33c: 90 10 00 10 mov %l0, %o0 200b340: 7f ff dd d0 call 2002a80 200b344: 01 00 00 00 nop if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 200b348: 07 00 80 95 sethi %hi(0x2025400), %g3 200b34c: c2 00 e3 b8 ld [ %g3 + 0x3b8 ], %g1 ! 20257b8 <_Thread_Heir> 200b350: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 200b354: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 200b358: 80 a0 80 01 cmp %g2, %g1 200b35c: 1a 80 00 0d bcc 200b390 <_Thread_Resume+0xf4> 200b360: 03 00 80 95 sethi %hi(0x2025400), %g1 _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200b364: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 20257e0 <_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; 200b368: f0 20 e3 b8 st %i0, [ %g3 + 0x3b8 ] if ( _Thread_Executing->is_preemptible || 200b36c: c2 00 60 7c ld [ %g1 + 0x7c ], %g1 200b370: 80 a0 60 00 cmp %g1, 0 200b374: 32 80 00 05 bne,a 200b388 <_Thread_Resume+0xec> 200b378: 84 10 20 01 mov 1, %g2 200b37c: 80 a0 a0 00 cmp %g2, 0 200b380: 12 80 00 04 bne 200b390 <_Thread_Resume+0xf4> 200b384: 84 10 20 01 mov 1, %g2 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 200b388: 03 00 80 95 sethi %hi(0x2025400), %g1 200b38c: c4 20 63 f0 st %g2, [ %g1 + 0x3f0 ] ! 20257f0 <_Context_Switch_necessary> } } } _ISR_Enable( level ); 200b390: 7f ff dd c0 call 2002a90 200b394: 91 e8 00 10 restore %g0, %l0, %o0 200b398: 01 00 00 00 nop 02009a4c <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 2009a4c: 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 ) ) 2009a50: 80 a6 6f ff cmp %i1, 0xfff 2009a54: 28 80 00 02 bleu,a 2009a5c <_Thread_Stack_Allocate+0x10> 2009a58: 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 ) { 2009a5c: 03 00 80 62 sethi %hi(0x2018800), %g1 2009a60: c2 00 63 24 ld [ %g1 + 0x324 ], %g1 ! 2018b24 <_CPU_Table+0x20> 2009a64: 80 a0 60 00 cmp %g1, 0 2009a68: 02 80 00 06 be 2009a80 <_Thread_Stack_Allocate+0x34> 2009a6c: 92 06 60 10 add %i1, 0x10, %o1 stack_addr = (*_CPU_Table.stack_allocate_hook)( the_stack_size ); 2009a70: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009a74: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 2009a78: 10 80 00 07 b 2009a94 <_Thread_Stack_Allocate+0x48> <== NOT EXECUTED 2009a7c: d0 26 20 dc st %o0, [ %i0 + 0xdc ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 2009a80: 11 00 80 62 sethi %hi(0x2018800), %o0 2009a84: b2 10 00 09 mov %o1, %i1 2009a88: 7f ff f4 b4 call 2006d58 <_Heap_Allocate> 2009a8c: 90 12 23 3c or %o0, 0x33c, %o0 2009a90: d0 26 20 dc st %o0, [ %i0 + 0xdc ] the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 2009a94: 80 a0 00 08 cmp %g0, %o0 2009a98: b0 60 20 00 subx %g0, 0, %i0 the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 2009a9c: b0 0e 40 18 and %i1, %i0, %i0 2009aa0: 81 c7 e0 08 ret 2009aa4: 81 e8 00 00 restore 02009aa8 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 2009aa8: 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 ) 2009aac: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 2009ab0: 80 a0 60 00 cmp %g1, 0 2009ab4: 02 80 00 08 be 2009ad4 <_Thread_Stack_Free+0x2c> 2009ab8: 03 00 80 62 sethi %hi(0x2018800), %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 ) 2009abc: c2 00 63 28 ld [ %g1 + 0x328 ], %g1 ! 2018b28 <_CPU_Table+0x24> 2009ac0: 80 a0 60 00 cmp %g1, 0 2009ac4: 02 80 00 06 be 2009adc <_Thread_Stack_Free+0x34> 2009ac8: d0 06 20 d4 ld [ %i0 + 0xd4 ], %o0 (*_CPU_Table.stack_free_hook)( the_thread->Start.Initial_stack.area ); 2009acc: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009ad0: 01 00 00 00 nop <== NOT EXECUTED 2009ad4: 81 c7 e0 08 ret <== NOT EXECUTED 2009ad8: 81 e8 00 00 restore <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2009adc: 31 00 80 62 sethi %hi(0x2018800), %i0 2009ae0: b2 10 00 08 mov %o0, %i1 2009ae4: 7f ff f4 c4 call 2006df4 <_Heap_Free> 2009ae8: 91 ee 23 3c restore %i0, 0x33c, %o0 2009aec: 01 00 00 00 nop 02009080 <_Thread_queue_Dequeue>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 2009080: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 2009084: 80 a0 60 00 cmp %g1, 0 2009088: 02 80 00 05 be 200909c <_Thread_queue_Dequeue+0x1c> 200908c: 80 a0 60 01 cmp %g1, 1 2009090: 12 80 00 09 bne 20090b4 <_Thread_queue_Dequeue+0x34> 2009094: 01 00 00 00 nop 2009098: 30 80 00 04 b,a 20090a8 <_Thread_queue_Dequeue+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); 200909c: 82 13 c0 00 mov %o7, %g1 20090a0: 40 00 0f d9 call 200d004 <_Thread_queue_Dequeue_fifo> 20090a4: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_Dequeue_priority( the_thread_queue ); 20090a8: 82 13 c0 00 mov %o7, %g1 20090ac: 40 00 00 0a call 20090d4 <_Thread_queue_Dequeue_priority> 20090b0: 9e 10 40 00 mov %g1, %o7 the_thread = NULL; break; } return( the_thread ); } 20090b4: 81 c3 e0 08 retl <== NOT EXECUTED 20090b8: 90 10 20 00 clr %o0 <== NOT EXECUTED 0200d004 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 200d004: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 200d008: 7f ff d3 55 call 2001d5c 200d00c: a0 10 00 18 mov %i0, %l0 200d010: 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)); 200d014: f0 06 00 00 ld [ %i0 ], %i0 if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 200d018: 82 04 20 04 add %l0, 4, %g1 200d01c: 80 a6 00 01 cmp %i0, %g1 200d020: 22 80 00 16 be,a 200d078 <_Thread_queue_Dequeue_fifo+0x74> 200d024: 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; 200d028: c2 06 00 00 ld [ %i0 ], %g1 the_chain->first = new_first; 200d02c: 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 ) ) { 200d030: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 new_first->previous = _Chain_Head(the_chain); 200d034: e0 20 60 04 st %l0, [ %g1 + 4 ] 200d038: 80 a0 a0 02 cmp %g2, 2 200d03c: 02 80 00 05 be 200d050 <_Thread_queue_Dequeue_fifo+0x4c> 200d040: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 200d044: 7f ff d3 4a call 2001d6c 200d048: 01 00 00 00 nop 200d04c: 30 80 00 07 b,a 200d068 <_Thread_queue_Dequeue_fifo+0x64> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 200d050: 82 10 20 03 mov 3, %g1 ! 3 200d054: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200d058: 7f ff d3 45 call 2001d6c 200d05c: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 200d060: 7f ff f4 48 call 200a180 <_Watchdog_Remove> 200d064: 90 06 20 48 add %i0, 0x48, %o0 _Thread_Unblock( the_thread ); 200d068: 7f ff ff e1 call 200cfec <_Thread_Unblock> 200d06c: 90 10 00 18 mov %i0, %o0 200d070: 81 c7 e0 08 ret 200d074: 81 e8 00 00 restore #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 200d078: 80 a0 60 02 cmp %g1, 2 200d07c: 18 80 00 06 bgu 200d094 <_Thread_queue_Dequeue_fifo+0x90> 200d080: 80 a0 60 03 cmp %g1, 3 200d084: 80 a0 60 01 cmp %g1, 1 200d088: 1a 80 00 0a bcc 200d0b0 <_Thread_queue_Dequeue_fifo+0xac> 200d08c: 82 10 20 03 mov 3, %g1 200d090: 30 80 00 03 b,a 200d09c <_Thread_queue_Dequeue_fifo+0x98> 200d094: 12 bf ff f7 bne 200d070 <_Thread_queue_Dequeue_fifo+0x6c> <== NOT EXECUTED 200d098: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 200d09c: b0 10 20 00 clr %i0 200d0a0: 7f ff d3 33 call 2001d6c 200d0a4: 90 10 00 02 mov %g2, %o0 200d0a8: 81 c7 e0 08 ret 200d0ac: 81 e8 00 00 restore return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 200d0b0: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 200d0b4: 7f ff d3 2e call 2001d6c <== NOT EXECUTED 200d0b8: 01 00 00 00 nop <== NOT EXECUTED return _Thread_Executing; 200d0bc: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200d0c0: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED } return NULL; /* this is only to prevent warnings */ } 200d0c4: 81 c7 e0 08 ret <== NOT EXECUTED 200d0c8: 81 e8 00 00 restore <== NOT EXECUTED 020090d4 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 20090d4: 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 ); 20090d8: 7f ff e3 21 call 2001d5c 20090dc: 01 00 00 00 nop 20090e0: 98 10 00 08 mov %o0, %o4 20090e4: 86 10 20 00 clr %g3 20090e8: 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)); 20090ec: 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 ] ) ) { 20090f0: 85 28 e0 02 sll %g3, 2, %g2 20090f4: 83 28 e0 04 sll %g3, 4, %g1 20090f8: 82 20 40 02 sub %g1, %g2, %g1 20090fc: 82 06 00 01 add %i0, %g1, %g1 2009100: 82 00 60 04 add %g1, 4, %g1 2009104: 80 a2 00 01 cmp %o0, %g1 2009108: 02 80 00 04 be 2009118 <_Thread_queue_Dequeue_priority+0x44> 200910c: 88 01 20 0c add %g4, 0xc, %g4 the_thread = (Thread_Control *) 2009110: 10 80 00 1c b 2009180 <_Thread_queue_Dequeue_priority+0xac> 2009114: 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++ ) { 2009118: 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 ; 200911c: 80 a0 e0 04 cmp %g3, 4 2009120: 32 bf ff f4 bne,a 20090f0 <_Thread_queue_Dequeue_priority+0x1c> 2009124: d0 01 00 18 ld [ %g4 + %i0 ], %o0 the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 2009128: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 200912c: 80 a0 60 02 cmp %g1, 2 2009130: 18 80 00 06 bgu 2009148 <_Thread_queue_Dequeue_priority+0x74> 2009134: 80 a0 60 03 cmp %g1, 3 2009138: 80 a0 60 01 cmp %g1, 1 200913c: 1a 80 00 0a bcc 2009164 <_Thread_queue_Dequeue_priority+0x90> 2009140: 82 10 20 03 mov 3, %g1 2009144: 30 80 00 03 b,a 2009150 <_Thread_queue_Dequeue_priority+0x7c> 2009148: 12 80 00 0e bne 2009180 <_Thread_queue_Dequeue_priority+0xac> <== NOT EXECUTED 200914c: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 2009150: b0 10 20 00 clr %i0 2009154: 7f ff e3 06 call 2001d6c 2009158: 90 10 00 0c mov %o4, %o0 200915c: 81 c7 e0 08 ret 2009160: 81 e8 00 00 restore return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 2009164: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 2009168: 7f ff e3 01 call 2001d6c <== NOT EXECUTED 200916c: 90 10 00 0c mov %o4, %o0 <== NOT EXECUTED return _Thread_Executing; 2009170: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2009174: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED 2009178: 81 c7 e0 08 ret <== NOT EXECUTED 200917c: 81 e8 00 00 restore <== NOT EXECUTED } dequeue: the_thread->Wait.queue = NULL; new_first_node = the_thread->Wait.Block2n.first; 2009180: 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 ) ) { 2009184: 82 06 20 3c add %i0, 0x3c, %g1 _ISR_Enable( level ); return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; 2009188: 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 ) ) { 200918c: 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; 2009190: c4 06 00 00 ld [ %i0 ], %g2 previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 2009194: 02 80 00 14 be 20091e4 <_Thread_queue_Dequeue_priority+0x110> 2009198: c2 06 20 04 ld [ %i0 + 4 ], %g1 last_node = the_thread->Wait.Block2n.last; 200919c: da 06 20 40 ld [ %i0 + 0x40 ], %o5 new_second_node = new_first_node->next; 20091a0: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 20091a4: 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; 20091a8: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 20091ac: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 20091b0: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 20091b4: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 20091b8: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 20091bc: 80 a0 80 01 cmp %g2, %g1 20091c0: 22 80 00 0c be,a 20091f0 <_Thread_queue_Dequeue_priority+0x11c> 20091c4: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 /* > two threads on 2-n */ new_second_node->previous = 20091c8: 82 00 e0 38 add %g3, 0x38, %g1 20091cc: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 20091d0: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] new_first_thread->Wait.Block2n.last = last_node; 20091d4: da 20 e0 40 st %o5, [ %g3 + 0x40 ] last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 20091d8: 82 00 e0 3c add %g3, 0x3c, %g1 20091dc: 10 80 00 04 b 20091ec <_Thread_queue_Dequeue_priority+0x118> 20091e0: c2 23 40 00 st %g1, [ %o5 ] } } else { previous_node->next = next_node; next_node->previous = previous_node; 20091e4: 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; 20091e8: c4 20 40 00 st %g2, [ %g1 ] next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 20091ec: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 20091f0: 80 a0 60 02 cmp %g1, 2 20091f4: 02 80 00 08 be 2009214 <_Thread_queue_Dequeue_priority+0x140> 20091f8: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 20091fc: 7f ff e2 dc call 2001d6c 2009200: 90 10 00 0c mov %o4, %o0 _Thread_Unblock( the_thread ); 2009204: 7f ff ff ae call 20090bc <_Thread_Unblock> 2009208: 90 10 00 18 mov %i0, %o0 200920c: 81 c7 e0 08 ret 2009210: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 2009214: c2 26 20 50 st %g1, [ %i0 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 2009218: 7f ff e2 d5 call 2001d6c 200921c: 90 10 00 0c mov %o4, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 2009220: 40 00 03 d8 call 200a180 <_Watchdog_Remove> 2009224: 90 06 20 48 add %i0, 0x48, %o0 _Thread_Unblock( the_thread ); 2009228: 7f ff ff a5 call 20090bc <_Thread_Unblock> 200922c: 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 ); } 2009230: 81 c7 e0 08 ret 2009234: 81 e8 00 00 restore 0200d0cc <_Thread_queue_Enqueue_fifo>: void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200d0cc: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); 200d0d0: 7f ff d3 23 call 2001d5c 200d0d4: a0 10 00 18 mov %i0, %l0 void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200d0d8: 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; 200d0dc: c4 04 20 30 ld [ %l0 + 0x30 ], %g2 the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 200d0e0: 80 a0 a0 02 cmp %g2, 2 200d0e4: 02 80 00 10 be 200d124 <_Thread_queue_Enqueue_fifo+0x58> 200d0e8: c0 24 20 30 clr [ %l0 + 0x30 ] 200d0ec: 80 a0 a0 03 cmp %g2, 3 200d0f0: 02 80 00 12 be 200d138 <_Thread_queue_Enqueue_fifo+0x6c> 200d0f4: 80 a0 a0 01 cmp %g2, 1 200d0f8: 32 80 00 1e bne,a 200d170 <_Thread_queue_Enqueue_fifo+0xa4> 200d0fc: 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); 200d100: 82 04 20 04 add %l0, 4, %g1 200d104: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 200d108: c2 04 20 08 ld [ %l0 + 8 ], %g1 the_chain->last = the_node; 200d10c: 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; 200d110: e0 26 60 44 st %l0, [ %i1 + 0x44 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200d114: 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; 200d118: f2 20 40 00 st %i1, [ %g1 ] _ISR_Enable( level ); 200d11c: 7f ff d3 14 call 2001d6c 200d120: 91 e8 00 08 restore %g0, %o0, %o0 return; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 200d124: c2 06 60 44 ld [ %i1 + 0x44 ], %g1 <== NOT EXECUTED the_thread->Wait.queue = NULL; 200d128: 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; 200d12c: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED 200d130: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 200d134: 30 80 00 0d b,a 200d168 <_Thread_queue_Enqueue_fifo+0x9c> <== NOT EXECUTED break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 200d138: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 200d13c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200d140: 12 80 00 0a bne 200d168 <_Thread_queue_Enqueue_fifo+0x9c> <== NOT EXECUTED 200d144: 01 00 00 00 nop <== NOT EXECUTED 200d148: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 200d14c: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 200d150: 7f ff d3 07 call 2001d6c <== NOT EXECUTED 200d154: 01 00 00 00 nop <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 200d158: 7f ff f4 0a call 200a180 <_Watchdog_Remove> <== NOT EXECUTED 200d15c: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 200d160: 10 80 00 04 b 200d170 <_Thread_queue_Enqueue_fifo+0xa4> <== NOT EXECUTED 200d164: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED } else _ISR_Enable( level ); 200d168: 7f ff d3 01 call 2001d6c <== NOT EXECUTED 200d16c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200d170: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 200d174: 7f ff ed cf call 20088b0 <_Thread_Clear_state> <== NOT EXECUTED 200d178: 81 e8 00 00 restore <== NOT EXECUTED 200d17c: 01 00 00 00 nop 020092bc <_Thread_queue_Enqueue_priority>: void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 20092bc: 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; 20092c0: 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); 20092c4: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; 20092c8: 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); 20092cc: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 20092d0: 82 06 60 38 add %i1, 0x38, %g1 20092d4: 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 ) ) 20092d8: 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); 20092dc: 85 34 a0 06 srl %l2, 6, %g2 20092e0: 12 80 00 34 bne 20093b0 <_Thread_queue_Enqueue_priority+0xf4> 20092e4: 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; 20092e8: 83 28 a0 04 sll %g2, 4, %g1 20092ec: 85 28 a0 02 sll %g2, 2, %g2 20092f0: 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; 20092f4: 82 06 00 15 add %i0, %l5, %g1 20092f8: 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 ); 20092fc: 7f ff e2 98 call 2001d5c 2009300: 01 00 00 00 nop 2009304: a2 10 00 08 mov %o0, %l1 search_thread = (Thread_Control *) header->first; 2009308: e0 06 00 15 ld [ %i0 + %l5 ], %l0 200930c: 10 80 00 18 b 200936c <_Thread_queue_Enqueue_priority+0xb0> 2009310: 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 ) 2009314: 80 a4 80 13 cmp %l2, %l3 2009318: 28 80 00 19 bleu,a 200937c <_Thread_queue_Enqueue_priority+0xc0> 200931c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 2009320: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 2009324: 80 a4 00 14 cmp %l0, %l4 2009328: 22 80 00 15 be,a 200937c <_Thread_queue_Enqueue_priority+0xc0> 200932c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 2009330: e6 04 20 14 ld [ %l0 + 0x14 ], %l3 if ( priority <= search_priority ) 2009334: 80 a4 80 13 cmp %l2, %l3 2009338: 28 80 00 11 bleu,a 200937c <_Thread_queue_Enqueue_priority+0xc0> 200933c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #endif _ISR_Flash( level ); 2009340: 7f ff e2 8b call 2001d6c 2009344: 90 10 00 11 mov %l1, %o0 2009348: 7f ff e2 85 call 2001d5c 200934c: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2009350: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2009354: 80 8d 80 01 btst %l6, %g1 2009358: 32 80 00 05 bne,a 200936c <_Thread_queue_Enqueue_priority+0xb0> 200935c: e0 04 00 00 ld [ %l0 ], %l0 _ISR_Enable( level ); 2009360: 7f ff e2 83 call 2001d6c <== NOT EXECUTED 2009364: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2009368: 30 bf ff e5 b,a 20092fc <_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 ) ) { 200936c: 80 a4 00 14 cmp %l0, %l4 2009370: 32 bf ff e9 bne,a 2009314 <_Thread_queue_Enqueue_priority+0x58> 2009374: 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 ) 2009378: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 200937c: 80 a0 60 01 cmp %g1, 1 2009380: 32 80 00 47 bne,a 200949c <_Thread_queue_Enqueue_priority+0x1e0> 2009384: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 <== NOT EXECUTED goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 2009388: 80 a4 80 13 cmp %l2, %l3 200938c: 02 80 00 3c be 200947c <_Thread_queue_Enqueue_priority+0x1c0> 2009390: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 2009394: c2 04 20 04 ld [ %l0 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 2009398: e0 26 40 00 st %l0, [ %i1 ] the_node->previous = previous_node; 200939c: 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; 20093a0: 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; 20093a4: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 20093a8: f2 24 20 04 st %i1, [ %l0 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 20093ac: 30 80 00 32 b,a 2009474 <_Thread_queue_Enqueue_priority+0x1b8> restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 20093b0: 83 28 a0 04 sll %g2, 4, %g1 20093b4: 85 28 a0 02 sll %g2, 2, %g2 20093b8: 82 20 40 02 sub %g1, %g2, %g1 20093bc: a6 00 40 18 add %g1, %i0, %l3 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 20093c0: aa 10 00 13 mov %l3, %l5 return; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); 20093c4: 7f ff e2 66 call 2001d5c 20093c8: 01 00 00 00 nop 20093cc: a2 10 00 08 mov %o0, %l1 search_thread = (Thread_Control *) header->last; 20093d0: e0 05 60 08 ld [ %l5 + 8 ], %l0 20093d4: 10 80 00 18 b 2009434 <_Thread_queue_Enqueue_priority+0x178> 20093d8: 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 ) 20093dc: 80 a4 80 14 cmp %l2, %l4 20093e0: 3a 80 00 19 bcc,a 2009444 <_Thread_queue_Enqueue_priority+0x188> 20093e4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 20093e8: e0 04 20 04 ld [ %l0 + 4 ], %l0 if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 20093ec: 80 a4 00 13 cmp %l0, %l3 20093f0: 22 80 00 15 be,a 2009444 <_Thread_queue_Enqueue_priority+0x188> 20093f4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 20093f8: e8 04 20 14 ld [ %l0 + 0x14 ], %l4 if ( priority >= search_priority ) 20093fc: 80 a4 80 14 cmp %l2, %l4 2009400: 3a 80 00 11 bcc,a 2009444 <_Thread_queue_Enqueue_priority+0x188> 2009404: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED break; #endif _ISR_Flash( level ); 2009408: 7f ff e2 59 call 2001d6c 200940c: 90 10 00 11 mov %l1, %o0 2009410: 7f ff e2 53 call 2001d5c 2009414: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2009418: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 200941c: 80 8d 80 01 btst %l6, %g1 2009420: 32 80 00 05 bne,a 2009434 <_Thread_queue_Enqueue_priority+0x178> 2009424: e0 04 20 04 ld [ %l0 + 4 ], %l0 _ISR_Enable( level ); 2009428: 7f ff e2 51 call 2001d6c <== NOT EXECUTED 200942c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2009430: 30 bf ff e5 b,a 20093c4 <_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 ) ) { 2009434: 80 a4 00 13 cmp %l0, %l3 2009438: 32 bf ff e9 bne,a 20093dc <_Thread_queue_Enqueue_priority+0x120> 200943c: 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 ) 2009440: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2009444: 80 a0 60 01 cmp %g1, 1 2009448: 32 80 00 15 bne,a 200949c <_Thread_queue_Enqueue_priority+0x1e0> 200944c: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 <== NOT EXECUTED goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 2009450: 80 a4 80 14 cmp %l2, %l4 2009454: 02 80 00 0a be 200947c <_Thread_queue_Enqueue_priority+0x1c0> 2009458: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 200945c: c2 04 00 00 ld [ %l0 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 2009460: 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; 2009464: 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; 2009468: 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; 200946c: f2 24 00 00 st %i1, [ %l0 ] next_node->previous = the_node; 2009470: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2009474: 7f ff e2 3e call 2001d6c 2009478: 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; 200947c: 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; 2009480: c4 00 60 04 ld [ %g1 + 4 ], %g2 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 2009484: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = previous_node; 2009488: 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; 200948c: 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; 2009490: f2 20 80 00 st %i1, [ %g2 ] search_node->previous = the_node; 2009494: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2009498: 30 bf ff f7 b,a 2009474 <_Thread_queue_Enqueue_priority+0x1b8> synchronize: sync_state = the_thread_queue->sync_state; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 200949c: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 20094a0: 02 80 00 07 be 20094bc <_Thread_queue_Enqueue_priority+0x200> <== NOT EXECUTED 20094a4: c0 26 20 30 clr [ %i0 + 0x30 ] <== NOT EXECUTED 20094a8: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 20094ac: 12 80 00 17 bne 2009508 <_Thread_queue_Enqueue_priority+0x24c> <== NOT EXECUTED 20094b0: 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 ) ) { 20094b4: 10 80 00 07 b 20094d0 <_Thread_queue_Enqueue_priority+0x214> <== NOT EXECUTED 20094b8: 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; 20094bc: c2 06 60 44 ld [ %i1 + 0x44 ], %g1 <== NOT EXECUTED the_thread->Wait.queue = NULL; 20094c0: 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; 20094c4: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED 20094c8: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 20094cc: 30 80 00 0c b,a 20094fc <_Thread_queue_Enqueue_priority+0x240> <== NOT EXECUTED break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 20094d0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20094d4: 12 80 00 0a bne 20094fc <_Thread_queue_Enqueue_priority+0x240> <== NOT EXECUTED 20094d8: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 20094dc: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 20094e0: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 20094e4: 7f ff e2 22 call 2001d6c <== NOT EXECUTED 20094e8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 20094ec: 40 00 03 25 call 200a180 <_Watchdog_Remove> <== NOT EXECUTED 20094f0: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 20094f4: 10 80 00 05 b 2009508 <_Thread_queue_Enqueue_priority+0x24c> <== NOT EXECUTED 20094f8: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED } else _ISR_Enable( level ); 20094fc: 7f ff e2 1c call 2001d6c <== NOT EXECUTED 2009500: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2009504: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 2009508: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200950c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2009510: 7f ff fc e8 call 20088b0 <_Thread_Clear_state> <== NOT EXECUTED 2009514: 81 e8 00 00 restore <== NOT EXECUTED 2009518: 01 00 00 00 nop 02009238 <_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 ) { 2009238: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; the_thread = _Thread_Executing; 200923c: 03 00 80 62 sethi %hi(0x2018800), %g1 else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 2009240: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 Thread_queue_Timeout_callout handler ) { Thread_Control *the_thread; the_thread = _Thread_Executing; 2009244: e0 00 63 d0 ld [ %g1 + 0x3d0 ], %l0 void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 2009248: 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 ); 200924c: 40 00 01 79 call 2009830 <_Thread_Set_state> 2009250: 90 10 00 10 mov %l0, %o0 /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 2009254: 80 a6 60 00 cmp %i1, 0 2009258: 22 80 00 0d be,a 200928c <_Thread_queue_Enqueue_with_handler+0x54> 200925c: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 _Watchdog_Initialize( 2009260: c2 04 20 08 ld [ %l0 + 8 ], %g1 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2009264: 11 00 80 62 sethi %hi(0x2018800), %o0 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2009268: f4 24 20 64 st %i2, [ %l0 + 0x64 ] the_watchdog->id = id; 200926c: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2009270: f2 24 20 54 st %i1, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2009274: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2009278: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200927c: 90 12 23 f0 or %o0, 0x3f0, %o0 2009280: 40 00 03 68 call 200a020 <_Watchdog_Insert> 2009284: 92 04 20 48 add %l0, 0x48, %o1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 2009288: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 200928c: 80 a0 60 00 cmp %g1, 0 2009290: 02 80 00 05 be 20092a4 <_Thread_queue_Enqueue_with_handler+0x6c> 2009294: 80 a0 60 01 cmp %g1, 1 2009298: 12 80 00 07 bne 20092b4 <_Thread_queue_Enqueue_with_handler+0x7c> 200929c: 01 00 00 00 nop 20092a0: 30 80 00 03 b,a 20092ac <_Thread_queue_Enqueue_with_handler+0x74> case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); 20092a4: 40 00 0f 8a call 200d0cc <_Thread_queue_Enqueue_fifo> 20092a8: 93 e8 00 10 restore %g0, %l0, %o1 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Enqueue_priority( the_thread_queue, the_thread ); 20092ac: 40 00 00 04 call 20092bc <_Thread_queue_Enqueue_priority> 20092b0: 93 e8 00 10 restore %g0, %l0, %o1 20092b4: 81 c7 e0 08 ret <== NOT EXECUTED 20092b8: 81 e8 00 00 restore <== NOT EXECUTED 0200d180 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 200d180: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 200d184: 80 a0 60 00 cmp %g1, 0 200d188: 02 80 00 05 be 200d19c <_Thread_queue_Extract+0x1c> 200d18c: 80 a0 60 01 cmp %g1, 1 200d190: 12 80 00 09 bne 200d1b4 <_Thread_queue_Extract+0x34> 200d194: 94 10 20 00 clr %o2 200d198: 30 80 00 04 b,a 200d1a8 <_Thread_queue_Extract+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 200d19c: 82 13 c0 00 mov %o7, %g1 200d1a0: 40 00 04 3f call 200e29c <_Thread_queue_Extract_fifo> 200d1a4: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 200d1a8: 82 13 c0 00 mov %o7, %g1 200d1ac: 40 00 00 04 call 200d1bc <_Thread_queue_Extract_priority_helper> 200d1b0: 9e 10 40 00 mov %g1, %o7 200d1b4: 81 c3 e0 08 retl <== NOT EXECUTED 200d1b8: 01 00 00 00 nop 0200e29c <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200e29c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 200e2a0: 7f ff ce af call 2001d5c 200e2a4: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200e2a8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200e2ac: 03 00 00 ef sethi %hi(0x3bc00), %g1 200e2b0: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200e2b4: 80 88 80 01 btst %g2, %g1 200e2b8: 32 80 00 04 bne,a 200e2c8 <_Thread_queue_Extract_fifo+0x2c> 200e2bc: c2 06 40 00 ld [ %i1 ], %g1 _ISR_Enable( level ); 200e2c0: 7f ff ce ab call 2001d6c <== NOT EXECUTED 200e2c4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 200e2c8: 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 ) ) { 200e2cc: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 next->previous = previous; previous->next = next; 200e2d0: c2 20 80 00 st %g1, [ %g2 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200e2d4: c4 20 60 04 st %g2, [ %g1 + 4 ] 200e2d8: 80 a0 e0 02 cmp %g3, 2 200e2dc: 02 80 00 06 be 200e2f4 <_Thread_queue_Extract_fifo+0x58> 200e2e0: c0 26 60 44 clr [ %i1 + 0x44 ] _ISR_Enable( level ); 200e2e4: 7f ff ce a2 call 2001d6c 200e2e8: 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 ); 200e2ec: 10 80 00 0a b 200e314 <_Thread_queue_Extract_fifo+0x78> 200e2f0: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200e2f4: 82 10 20 03 mov 3, %g1 200e2f8: c2 26 60 50 st %g1, [ %i1 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200e2fc: 7f ff ce 9c call 2001d6c 200e300: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 200e304: 7f ff ef 9f call 200a180 <_Watchdog_Remove> 200e308: 90 06 60 48 add %i1, 0x48, %o0 200e30c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200e310: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200e314: 7f ff e9 67 call 20088b0 <_Thread_Clear_state> 200e318: 81 e8 00 00 restore 200e31c: 01 00 00 00 nop 0200d1bc <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, boolean requeuing ) { 200d1bc: 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 ); 200d1c0: 7f ff d2 e7 call 2001d5c 200d1c4: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200d1c8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200d1cc: 03 00 00 ef sethi %hi(0x3bc00), %g1 200d1d0: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200d1d4: 80 88 80 01 btst %g2, %g1 200d1d8: 32 80 00 03 bne,a 200d1e4 <_Thread_queue_Extract_priority_helper+0x28> 200d1dc: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 _ISR_Enable( level ); 200d1e0: 30 80 00 1d b,a 200d254 <_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 ) ) { 200d1e4: 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; 200d1e8: c4 06 40 00 ld [ %i1 ], %g2 previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 200d1ec: 80 a0 c0 01 cmp %g3, %g1 200d1f0: 02 80 00 14 be 200d240 <_Thread_queue_Extract_priority_helper+0x84> 200d1f4: 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; 200d1f8: da 06 60 40 ld [ %i1 + 0x40 ], %o5 new_second_node = new_first_node->next; 200d1fc: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 200d200: 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; 200d204: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 200d208: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 200d20c: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 200d210: c4 06 60 38 ld [ %i1 + 0x38 ], %g2 200d214: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 200d218: 80 a0 80 01 cmp %g2, %g1 200d21c: 02 80 00 0c be 200d24c <_Thread_queue_Extract_priority_helper+0x90> 200d220: 80 a6 a0 00 cmp %i2, 0 /* > two threads on 2-n */ new_second_node->previous = 200d224: 82 00 e0 38 add %g3, 0x38, %g1 <== NOT EXECUTED 200d228: 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; 200d22c: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 200d230: da 20 e0 40 st %o5, [ %g3 + 0x40 ] <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 200d234: 82 00 e0 3c add %g3, 0x3c, %g1 <== NOT EXECUTED 200d238: 10 80 00 05 b 200d24c <_Thread_queue_Extract_priority_helper+0x90> <== NOT EXECUTED 200d23c: c2 23 40 00 st %g1, [ %o5 ] <== NOT EXECUTED } } else { previous_node->next = next_node; next_node->previous = previous_node; 200d240: 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; 200d244: c4 20 40 00 st %g2, [ %g1 ] /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 200d248: 80 a6 a0 00 cmp %i2, 0 200d24c: 22 80 00 04 be,a 200d25c <_Thread_queue_Extract_priority_helper+0xa0> 200d250: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 _ISR_Enable( level ); 200d254: 7f ff d2 c6 call 2001d6c 200d258: 91 e8 00 08 restore %g0, %o0, %o0 return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 200d25c: 80 a0 60 02 cmp %g1, 2 200d260: 02 80 00 06 be 200d278 <_Thread_queue_Extract_priority_helper+0xbc> 200d264: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 200d268: 7f ff d2 c1 call 2001d6c 200d26c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200d270: 10 80 00 08 b 200d290 <_Thread_queue_Extract_priority_helper+0xd4> 200d274: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200d278: c2 26 20 50 st %g1, [ %i0 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200d27c: 7f ff d2 bc call 2001d6c 200d280: 33 04 00 ff sethi %hi(0x1003fc00), %i1 (void) _Watchdog_Remove( &the_thread->Timer ); 200d284: 7f ff f3 bf call 200a180 <_Watchdog_Remove> 200d288: 90 06 20 48 add %i0, 0x48, %o0 200d28c: b2 16 63 f8 or %i1, 0x3f8, %i1 200d290: 7f ff ed 88 call 20088b0 <_Thread_Clear_state> 200d294: 81 e8 00 00 restore 200d298: 01 00 00 00 nop 0200951c <_Thread_queue_Extract_with_proxy>: */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 200951c: 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; 2009520: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 2009524: 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 ) ) { 2009528: 03 00 00 ef sethi %hi(0x3bc00), %g1 200952c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2009530: 80 88 80 01 btst %g2, %g1 2009534: 02 80 00 1e be 20095ac <_Thread_queue_Extract_with_proxy+0x90> 2009538: b0 10 20 00 clr %i0 if ( _States_Is_waiting_for_rpc_reply( state ) && 200953c: 03 00 00 08 sethi %hi(0x2000), %g1 2009540: 80 88 80 01 btst %g2, %g1 2009544: 22 80 00 17 be,a 20095a0 <_Thread_queue_Extract_with_proxy+0x84> 2009548: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 200954c: 03 00 00 e7 sethi %hi(0x39c00), %g1 <== NOT EXECUTED 2009550: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 39ee0 <== NOT EXECUTED 2009554: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 2009558: 22 80 00 12 be,a 20095a0 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 200955c: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED _States_Is_locally_blocked( state ) ) { the_information = _Objects_Get_information( the_thread->Wait.id ); 2009560: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED proxy_extract_callout = 2009564: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2009568: 85 30 e0 16 srl %g3, 0x16, %g2 <== NOT EXECUTED 200956c: 82 10 62 50 or %g1, 0x250, %g1 <== NOT EXECUTED 2009570: 84 08 a0 1c and %g2, 0x1c, %g2 <== NOT EXECUTED 2009574: c2 00 40 02 ld [ %g1 + %g2 ], %g1 <== NOT EXECUTED 2009578: 87 30 e0 1b srl %g3, 0x1b, %g3 <== NOT EXECUTED 200957c: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED 2009580: c2 00 40 03 ld [ %g1 + %g3 ], %g1 <== NOT EXECUTED 2009584: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 <== NOT EXECUTED (Objects_Thread_queue_Extract_callout) the_information->extract; if ( proxy_extract_callout ) 2009588: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200958c: 22 80 00 05 be,a 20095a0 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 2009590: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED (*proxy_extract_callout)( the_thread ); 2009594: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009598: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 200959c: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED 20095a0: 92 10 00 10 mov %l0, %o1 20095a4: 40 00 0e f7 call 200d180 <_Thread_queue_Extract> 20095a8: b0 10 20 01 mov 1, %i0 return TRUE; } return FALSE; } 20095ac: 81 c7 e0 08 ret 20095b0: 81 e8 00 00 restore 0200bbdc <_Thread_queue_First>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 200bbdc: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 200bbe0: 80 a0 60 00 cmp %g1, 0 200bbe4: 02 80 00 05 be 200bbf8 <_Thread_queue_First+0x1c> 200bbe8: 80 a0 60 01 cmp %g1, 1 200bbec: 12 80 00 09 bne 200bc10 <_Thread_queue_First+0x34> 200bbf0: 01 00 00 00 nop 200bbf4: 30 80 00 04 b,a 200bc04 <_Thread_queue_First+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); 200bbf8: 82 13 c0 00 mov %o7, %g1 200bbfc: 40 00 0f a2 call 200fa84 <_Thread_queue_First_fifo> 200bc00: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_First_priority( the_thread_queue ); 200bc04: 82 13 c0 00 mov %o7, %g1 200bc08: 40 00 00 04 call 200bc18 <_Thread_queue_First_priority> 200bc0c: 9e 10 40 00 mov %g1, %o7 the_thread = NULL; break; } return the_thread; } 200bc10: 81 c3 e0 08 retl <== NOT EXECUTED 200bc14: 90 10 20 00 clr %o0 <== NOT EXECUTED 02009660 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 2009660: 9d e3 bf 98 save %sp, -104, %sp /* just in case the thread really wasn't blocked here */ if ( !the_thread_queue ) { 2009664: 80 a6 20 00 cmp %i0, 0 2009668: 02 80 00 18 be 20096c8 <_Thread_queue_Requeue+0x68> 200966c: 01 00 00 00 nop return; } switch ( the_thread_queue->discipline ) { 2009670: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 2009674: 80 a4 20 01 cmp %l0, 1 2009678: 12 80 00 14 bne 20096c8 <_Thread_queue_Requeue+0x68> 200967c: 01 00 00 00 nop break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; _ISR_Disable( level ); 2009680: 7f ff e1 b7 call 2001d5c 2009684: 01 00 00 00 nop 2009688: a2 10 00 08 mov %o0, %l1 if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200968c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 2009690: 03 00 00 ef sethi %hi(0x3bc00), %g1 2009694: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2009698: 80 88 80 01 btst %g2, %g1 200969c: 02 80 00 09 be 20096c0 <_Thread_queue_Requeue+0x60> 20096a0: 90 10 00 18 mov %i0, %o0 _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 20096a4: 92 10 00 19 mov %i1, %o1 20096a8: 94 10 20 01 mov 1, %o2 20096ac: 40 00 0e c4 call 200d1bc <_Thread_queue_Extract_priority_helper> 20096b0: e0 26 20 30 st %l0, [ %i0 + 0x30 ] _Thread_queue_Enqueue_priority( tq, the_thread ); 20096b4: 90 10 00 18 mov %i0, %o0 20096b8: 7f ff ff 01 call 20092bc <_Thread_queue_Enqueue_priority> 20096bc: 92 10 00 19 mov %i1, %o1 } _ISR_Enable( level ); 20096c0: 7f ff e1 ab call 2001d6c 20096c4: 91 e8 00 11 restore %g0, %l1, %o0 20096c8: 81 c7 e0 08 ret <== NOT EXECUTED 20096cc: 81 e8 00 00 restore <== NOT EXECUTED 020096d0 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 20096d0: 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 ) ) { 20096d4: 92 96 20 00 orcc %i0, 0, %o1 20096d8: 12 80 00 0a bne 2009700 <_Thread_queue_Timeout+0x30> 20096dc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20096e0: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20096e4: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20096e8: 84 00 a0 01 inc %g2 <== NOT EXECUTED 20096ec: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] <== 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; 20096f0: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20096f4: d2 00 63 d0 ld [ %g1 + 0x3d0 ], %o1 ! 2018bd0 <_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; 20096f8: 10 80 00 18 b 2009758 <_Thread_queue_Timeout+0x88> <== NOT EXECUTED 20096fc: 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); 2009700: 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 ) { 2009704: 80 a0 a0 04 cmp %g2, 4 2009708: 18 80 00 0e bgu 2009740 <_Thread_queue_Timeout+0x70> 200970c: 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 :) */ 2009710: 83 32 60 1b srl %o1, 0x1b, %g1 2009714: 80 a0 60 01 cmp %g1, 1 2009718: 12 80 00 0a bne 2009740 <_Thread_queue_Timeout+0x70> 200971c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2009720: 83 28 a0 02 sll %g2, 2, %g1 2009724: 05 00 80 62 sethi %hi(0x2018800), %g2 2009728: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 200972c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2009730: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2009734: 80 a2 20 00 cmp %o0, 0 2009738: 12 80 00 05 bne 200974c <_Thread_queue_Timeout+0x7c> 200973c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2009740: 92 10 20 00 clr %o1 <== NOT EXECUTED 2009744: 10 80 00 05 b 2009758 <_Thread_queue_Timeout+0x88> <== NOT EXECUTED 2009748: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200974c: 7f ff f8 1f call 20077c8 <_Objects_Get> 2009750: 94 07 bf f4 add %fp, -12, %o2 2009754: 92 10 00 08 mov %o0, %o1 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2009758: c2 07 bf f4 ld [ %fp + -12 ], %g1 200975c: 80 a0 60 00 cmp %g1, 0 2009760: 12 80 00 18 bne 20097c0 <_Thread_queue_Timeout+0xf0> 2009764: 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; 2009768: 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 && 200976c: c6 00 a0 30 ld [ %g2 + 0x30 ], %g3 2009770: 80 a0 e0 00 cmp %g3, 0 2009774: 02 80 00 0b be 20097a0 <_Thread_queue_Timeout+0xd0> 2009778: 03 00 80 62 sethi %hi(0x2018800), %g1 200977c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED 2009780: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED 2009784: 32 80 00 08 bne,a 20097a4 <_Thread_queue_Timeout+0xd4> <== NOT EXECUTED 2009788: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 200978c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2009790: 02 80 00 08 be 20097b0 <_Thread_queue_Timeout+0xe0> <== NOT EXECUTED 2009794: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 2009798: 10 80 00 06 b 20097b0 <_Thread_queue_Timeout+0xe0> <== NOT EXECUTED 200979c: c2 20 a0 30 st %g1, [ %g2 + 0x30 ] <== NOT EXECUTED } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 20097a0: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 20097a4: d0 02 60 44 ld [ %o1 + 0x44 ], %o0 20097a8: 40 00 0e 76 call 200d180 <_Thread_queue_Extract> 20097ac: 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; 20097b0: 05 00 80 62 sethi %hi(0x2018800), %g2 20097b4: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 20097b8: 82 00 7f ff add %g1, -1, %g1 20097bc: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 20097c0: 81 c7 e0 08 ret 20097c4: 81 e8 00 00 restore 02012a34 <_Timer_Server_body>: */ Thread _Timer_Server_body( uint32_t ignored ) { 2012a34: 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; 2012a38: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012a3c: c8 00 63 74 ld [ %g1 + 0x374 ], %g4 ! 2032774 <_Watchdog_Ticks_since_boot> _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2012a40: 03 00 80 c9 sethi %hi(0x2032400), %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2012a44: 07 00 80 c9 sethi %hi(0x2032400), %g3 2012a48: da 00 62 ac ld [ %g1 + 0x2ac ], %o5 2012a4c: c2 00 e1 f0 ld [ %g3 + 0x1f0 ], %g1 /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 2012a50: 05 00 80 c9 sethi %hi(0x2032400), %g2 2012a54: 82 00 60 01 inc %g1 2012a58: c8 20 a1 00 st %g4, [ %g2 + 0x100 ] 2012a5c: c2 20 e1 f0 st %g1, [ %g3 + 0x1f0 ] _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2012a60: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012a64: da 20 60 fc st %o5, [ %g1 + 0xfc ] ! 20324fc <_Timer_Server_seconds_last_time> ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012a68: 03 00 80 c9 sethi %hi(0x2032400), %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2012a6c: 27 00 80 c9 sethi %hi(0x2032400), %l3 2012a70: ba 10 62 f0 or %g1, 0x2f0, %i5 2012a74: 82 14 e0 f0 or %l3, 0xf0, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2012a78: ae 00 60 04 add %g1, 4, %l7 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012a7c: 03 00 80 c9 sethi %hi(0x2032400), %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2012a80: 25 00 80 c9 sethi %hi(0x2032400), %l2 2012a84: a2 10 61 10 or %g1, 0x110, %l1 2012a88: 82 14 a1 04 or %l2, 0x104, %g1 2012a8c: 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; 2012a90: ac 00 60 04 add %g1, 4, %l6 /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 2012a94: 21 00 80 cc sethi %hi(0x2033000), %l0 _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2012a98: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012a9c: aa 10 62 e4 or %g1, 0x2e4, %l5 ! 20326e4 <_Watchdog_Seconds_chain> 2012aa0: d0 04 20 78 ld [ %l0 + 0x78 ], %o0 2012aa4: 40 00 10 80 call 2016ca4 <_Thread_Set_state> 2012aa8: 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)); 2012aac: c2 04 e0 f0 ld [ %l3 + 0xf0 ], %g1 _Timer_Server_reset_ticks_timer(); 2012ab0: 80 a0 40 17 cmp %g1, %l7 2012ab4: 22 80 00 09 be,a 2012ad8 <_Timer_Server_body+0xa4> 2012ab8: c2 04 a1 04 ld [ %l2 + 0x104 ], %g1 2012abc: d2 04 20 78 ld [ %l0 + 0x78 ], %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012ac0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012ac4: 90 10 00 1d mov %i5, %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012ac8: c2 22 60 54 st %g1, [ %o1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012acc: 40 00 13 34 call 201779c <_Watchdog_Insert> 2012ad0: 92 02 60 48 add %o1, 0x48, %o1 2012ad4: c2 04 a1 04 ld [ %l2 + 0x104 ], %g1 _Timer_Server_reset_seconds_timer(); 2012ad8: 80 a0 40 16 cmp %g1, %l6 2012adc: 02 80 00 06 be 2012af4 <_Timer_Server_body+0xc0> 2012ae0: 92 10 00 11 mov %l1, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012ae4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED 2012ae8: c2 24 60 0c st %g1, [ %l1 + 0xc ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2012aec: 40 00 13 2c call 201779c <_Watchdog_Insert> <== NOT EXECUTED 2012af0: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); 2012af4: 7f ff ff c3 call 2012a00 <_Thread_Enable_dispatch> 2012af8: 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(); 2012afc: d0 04 20 78 ld [ %l0 + 0x78 ], %o0 2012b00: 40 00 13 7f call 20178fc <_Watchdog_Remove> 2012b04: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_stop_seconds_timer(); 2012b08: 40 00 13 7d call 20178fc <_Watchdog_Remove> 2012b0c: 90 10 00 11 mov %l1, %o0 2012b10: c2 05 21 f0 ld [ %l4 + 0x1f0 ], %g1 2012b14: 82 00 60 01 inc %g1 2012b18: c2 25 21 f0 st %g1, [ %l4 + 0x1f0 ] * 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(); 2012b1c: 7f ff ff a7 call 20129b8 <_Timer_Server_process_ticks_chain> 2012b20: 01 00 00 00 nop _Timer_Server_process_seconds_chain(); 2012b24: 7f ff ff 8d call 2012958 <_Timer_Server_process_seconds_chain> 2012b28: 01 00 00 00 nop /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 2012b2c: 10 bf ff de b 2012aa4 <_Timer_Server_body+0x70> 2012b30: d0 04 20 78 ld [ %l0 + 0x78 ], %o0 020129b8 <_Timer_Server_process_ticks_chain>: void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 20129b8: 03 00 80 c9 sethi %hi(0x2032400), %g1 20129bc: c4 00 63 74 ld [ %g1 + 0x374 ], %g2 ! 2032774 <_Watchdog_Ticks_since_boot> if ( snapshot >= _Timer_Server_ticks_last_time ) 20129c0: 03 00 80 c9 sethi %hi(0x2032400), %g1 20129c4: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 2032500 <_Timer_Server_ticks_last_time> 20129c8: 80 a0 80 01 cmp %g2, %g1 20129cc: 1a 80 00 04 bcc 20129dc <_Timer_Server_process_ticks_chain+0x24> 20129d0: 94 20 80 01 sub %g2, %g1, %o2 ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 20129d4: 82 38 00 01 xnor %g0, %g1, %g1 <== NOT EXECUTED 20129d8: 94 00 40 02 add %g1, %g2, %o2 <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; 20129dc: 03 00 80 c9 sethi %hi(0x2032400), %g1 _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 20129e0: 11 00 80 c9 sethi %hi(0x2032400), %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; 20129e4: c4 20 61 00 st %g2, [ %g1 + 0x100 ] _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 20129e8: 90 12 20 f0 or %o0, 0xf0, %o0 20129ec: 92 10 20 00 clr %o1 20129f0: 82 13 c0 00 mov %o7, %g1 20129f4: 40 00 13 42 call 20176fc <_Watchdog_Adjust> 20129f8: 9e 10 40 00 mov %g1, %o7 20129fc: 01 00 00 00 nop 0200baa4 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 200baa4: 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; 200baa8: 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; 200baac: de 06 20 04 ld [ %i0 + 4 ], %o7 right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 200bab0: 96 10 00 01 mov %g1, %o3 200bab4: 95 38 60 1f sra %g1, 0x1f, %o2 200bab8: 83 30 60 1d srl %g1, 0x1d, %g1 200babc: 9b 2a e0 03 sll %o3, 3, %o5 200bac0: 99 2a a0 03 sll %o2, 3, %o4 200bac4: 98 10 40 0c or %g1, %o4, %o4 200bac8: 83 33 60 1b srl %o5, 0x1b, %g1 200bacc: 85 2b 20 05 sll %o4, 5, %g2 200bad0: 87 2b 60 05 sll %o5, 5, %g3 200bad4: 84 10 40 02 or %g1, %g2, %g2 200bad8: 86 a0 c0 0d subcc %g3, %o5, %g3 200badc: 83 30 e0 1a srl %g3, 0x1a, %g1 200bae0: 84 60 80 0c subx %g2, %o4, %g2 200bae4: 9b 28 e0 06 sll %g3, 6, %o5 200bae8: 99 28 a0 06 sll %g2, 6, %o4 200baec: 9a a3 40 03 subcc %o5, %g3, %o5 200baf0: 98 10 40 0c or %g1, %o4, %o4 200baf4: 98 63 00 02 subx %o4, %g2, %o4 200baf8: 9a 83 40 0b addcc %o5, %o3, %o5 200bafc: 83 33 60 1e srl %o5, 0x1e, %g1 200bb00: 98 43 00 0a addx %o4, %o2, %o4 200bb04: 87 2b 60 02 sll %o5, 2, %g3 200bb08: 85 2b 20 02 sll %o4, 2, %g2 200bb0c: 9a 83 40 03 addcc %o5, %g3, %o5 200bb10: 84 10 40 02 or %g1, %g2, %g2 200bb14: 83 33 60 1e srl %o5, 0x1e, %g1 200bb18: 98 43 00 02 addx %o4, %g2, %o4 200bb1c: 87 2b 60 02 sll %o5, 2, %g3 200bb20: 85 2b 20 02 sll %o4, 2, %g2 200bb24: 9a 83 40 03 addcc %o5, %g3, %o5 200bb28: 84 10 40 02 or %g1, %g2, %g2 200bb2c: 83 33 60 1e srl %o5, 0x1e, %g1 200bb30: 98 43 00 02 addx %o4, %g2, %o4 200bb34: 85 2b 20 02 sll %o4, 2, %g2 200bb38: 84 10 40 02 or %g1, %g2, %g2 right += rhs->tv_nsec; 200bb3c: 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; 200bb40: 87 2b 60 02 sll %o5, 2, %g3 200bb44: 9a 83 40 03 addcc %o5, %g3, %o5 right += rhs->tv_nsec; 200bb48: 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; 200bb4c: 98 43 00 02 addx %o4, %g2, %o4 200bb50: 89 33 60 17 srl %o5, 0x17, %g4 200bb54: 85 2b 20 09 sll %o4, 9, %g2 200bb58: 87 2b 60 09 sll %o5, 9, %g3 200bb5c: 84 11 00 02 or %g4, %g2, %g2 right += rhs->tv_nsec; 200bb60: 96 80 c0 01 addcc %g3, %g1, %o3 200bb64: 94 40 80 0a addx %g2, %o2, %o2 if ( right == 0 ) { 200bb68: 80 92 80 0b orcc %o2, %o3, %g0 200bb6c: 12 80 00 06 bne 200bb84 <_Timespec_Divide+0xe0> 200bb70: f0 06 00 00 ld [ %i0 ], %i0 *ival_percentage = 0; 200bb74: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED *fval_percentage = 0; 200bb78: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 200bb7c: 81 c7 e0 08 ret <== NOT EXECUTED 200bb80: 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; 200bb84: 83 36 20 1d srl %i0, 0x1d, %g1 200bb88: 9b 2e 20 03 sll %i0, 3, %o5 200bb8c: 91 3e 20 1f sra %i0, 0x1f, %o0 200bb90: 99 2a 20 03 sll %o0, 3, %o4 200bb94: 98 10 40 0c or %g1, %o4, %o4 200bb98: 83 33 60 1b srl %o5, 0x1b, %g1 200bb9c: 85 2b 20 05 sll %o4, 5, %g2 200bba0: 87 2b 60 05 sll %o5, 5, %g3 200bba4: 84 10 40 02 or %g1, %g2, %g2 200bba8: 86 a0 c0 0d subcc %g3, %o5, %g3 200bbac: 83 30 e0 1a srl %g3, 0x1a, %g1 200bbb0: 84 60 80 0c subx %g2, %o4, %g2 200bbb4: 9b 28 e0 06 sll %g3, 6, %o5 200bbb8: 99 28 a0 06 sll %g2, 6, %o4 200bbbc: 9a a3 40 03 subcc %o5, %g3, %o5 200bbc0: 98 10 40 0c or %g1, %o4, %o4 200bbc4: 98 63 00 02 subx %o4, %g2, %o4 200bbc8: 9a 83 40 18 addcc %o5, %i0, %o5 200bbcc: 83 33 60 1e srl %o5, 0x1e, %g1 200bbd0: 98 43 00 08 addx %o4, %o0, %o4 200bbd4: 87 2b 60 02 sll %o5, 2, %g3 200bbd8: 85 2b 20 02 sll %o4, 2, %g2 200bbdc: 9a 83 40 03 addcc %o5, %g3, %o5 200bbe0: 84 10 40 02 or %g1, %g2, %g2 200bbe4: 83 33 60 1e srl %o5, 0x1e, %g1 200bbe8: 98 43 00 02 addx %o4, %g2, %o4 200bbec: 87 2b 60 02 sll %o5, 2, %g3 200bbf0: 85 2b 20 02 sll %o4, 2, %g2 200bbf4: 9a 83 40 03 addcc %o5, %g3, %o5 200bbf8: 84 10 40 02 or %g1, %g2, %g2 200bbfc: 83 33 60 1e srl %o5, 0x1e, %g1 200bc00: 98 43 00 02 addx %o4, %g2, %o4 200bc04: 87 2b 60 02 sll %o5, 2, %g3 200bc08: 85 2b 20 02 sll %o4, 2, %g2 200bc0c: 9a 83 40 03 addcc %o5, %g3, %o5 200bc10: 84 10 40 02 or %g1, %g2, %g2 200bc14: 83 33 60 17 srl %o5, 0x17, %g1 200bc18: 98 43 00 02 addx %o4, %g2, %o4 200bc1c: 93 2b 60 09 sll %o5, 9, %o1 200bc20: 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; 200bc24: 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; 200bc28: 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; 200bc2c: 83 32 60 1e srl %o1, 0x1e, %g1 200bc30: a1 3b e0 1f sra %o7, 0x1f, %l0 200bc34: 87 2a 60 02 sll %o1, 2, %g3 200bc38: 90 42 00 10 addx %o0, %l0, %o0 200bc3c: 85 2a 20 02 sll %o0, 2, %g2 200bc40: 84 10 40 02 or %g1, %g2, %g2 200bc44: 83 30 e0 1b srl %g3, 0x1b, %g1 200bc48: 99 28 a0 05 sll %g2, 5, %o4 200bc4c: 9b 28 e0 05 sll %g3, 5, %o5 200bc50: 98 10 40 0c or %g1, %o4, %o4 200bc54: 9a a3 40 03 subcc %o5, %g3, %o5 200bc58: 98 63 00 02 subx %o4, %g2, %o4 200bc5c: 9a 83 40 09 addcc %o5, %o1, %o5 200bc60: 83 33 60 1e srl %o5, 0x1e, %g1 200bc64: 98 43 00 08 addx %o4, %o0, %o4 200bc68: 87 2b 60 02 sll %o5, 2, %g3 200bc6c: 85 2b 20 02 sll %o4, 2, %g2 200bc70: 9a 83 40 03 addcc %o5, %g3, %o5 200bc74: 84 10 40 02 or %g1, %g2, %g2 200bc78: 83 33 60 1e srl %o5, 0x1e, %g1 200bc7c: 87 2b 60 02 sll %o5, 2, %g3 200bc80: 98 43 00 02 addx %o4, %g2, %o4 200bc84: 9a 83 40 03 addcc %o5, %g3, %o5 200bc88: 85 2b 20 02 sll %o4, 2, %g2 200bc8c: 84 10 40 02 or %g1, %g2, %g2 200bc90: 83 33 60 1b srl %o5, 0x1b, %g1 200bc94: 98 43 00 02 addx %o4, %g2, %o4 200bc98: 93 2b 60 05 sll %o5, 5, %o1 200bc9c: 91 2b 20 05 sll %o4, 5, %o0 200bca0: 40 00 34 dd call 2019014 <__udivdi3> 200bca4: 90 10 40 08 or %g1, %o0, %o0 *ival_percentage = answer / 1000; 200bca8: 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; 200bcac: a0 10 00 08 mov %o0, %l0 200bcb0: a2 10 00 09 mov %o1, %l1 *ival_percentage = answer / 1000; 200bcb4: 96 10 23 e8 mov 0x3e8, %o3 200bcb8: 40 00 34 d7 call 2019014 <__udivdi3> 200bcbc: 90 10 00 10 mov %l0, %o0 *fval_percentage = answer % 1000; 200bcc0: 90 10 00 10 mov %l0, %o0 * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 200bcc4: d2 26 80 00 st %o1, [ %i2 ] *fval_percentage = answer % 1000; 200bcc8: 94 10 20 00 clr %o2 200bccc: 92 10 00 11 mov %l1, %o1 200bcd0: 40 00 35 b0 call 2019390 <__umoddi3> 200bcd4: 96 10 23 e8 mov 0x3e8, %o3 200bcd8: d2 26 c0 00 st %o1, [ %i3 ] 200bcdc: 81 c7 e0 08 ret 200bce0: 81 e8 00 00 restore 02009e68 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, boolean is_internal, uint32_t the_error ) { 2009e68: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 2009e6c: 03 00 80 63 sethi %hi(0x2018c00), %g1 2009e70: 82 10 61 74 or %g1, 0x174, %g1 ! 2018d74 <_User_extensions_List> 2009e74: e0 00 60 08 ld [ %g1 + 8 ], %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 2009e78: 10 80 00 09 b 2009e9c <_User_extensions_Fatal+0x34> 2009e7c: 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 ) 2009e80: 80 a0 60 00 cmp %g1, 0 2009e84: 02 80 00 05 be 2009e98 <_User_extensions_Fatal+0x30> 2009e88: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 2009e8c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2009e90: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009e94: 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 ) { 2009e98: 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 ) ; 2009e9c: 80 a4 00 11 cmp %l0, %l1 2009ea0: 32 bf ff f8 bne,a 2009e80 <_User_extensions_Fatal+0x18> 2009ea4: 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 ); } } 2009ea8: 81 c7 e0 08 ret 2009eac: 81 e8 00 00 restore 0200e724 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 200e724: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 200e728: 40 00 13 61 call 20134ac <_Chain_Extract> <== NOT EXECUTED 200e72c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 200e730: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED 200e734: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200e738: 02 80 00 04 be 200e748 <_User_extensions_Remove_set+0x24> <== NOT EXECUTED 200e73c: 01 00 00 00 nop <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 200e740: 40 00 13 5b call 20134ac <_Chain_Extract> <== NOT EXECUTED 200e744: 91 ee 20 08 restore %i0, 8, %o0 <== NOT EXECUTED 200e748: 81 c7 e0 08 ret <== NOT EXECUTED 200e74c: 81 e8 00 00 restore <== NOT EXECUTED 02009ef4 <_User_extensions_Thread_create>: */ boolean _User_extensions_Thread_create ( Thread_Control *the_thread ) { 2009ef4: 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 ; 2009ef8: 03 00 80 63 sethi %hi(0x2018c00), %g1 2009efc: e0 00 61 74 ld [ %g1 + 0x174 ], %l0 ! 2018d74 <_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)( 2009f00: 23 00 80 62 sethi %hi(0x2018800), %l1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2009f04: 03 00 80 63 sethi %hi(0x2018c00), %g1 2009f08: 10 80 00 0d b 2009f3c <_User_extensions_Thread_create+0x48> 2009f0c: a4 10 61 78 or %g1, 0x178, %l2 ! 2018d78 <_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 ) { 2009f10: 80 a0 60 00 cmp %g1, 0 2009f14: 02 80 00 09 be 2009f38 <_User_extensions_Thread_create+0x44> 2009f18: 92 10 00 18 mov %i0, %o1 status = (*the_extension->Callouts.thread_create)( 2009f1c: 9f c0 40 00 call %g1 2009f20: d0 04 63 d0 ld [ %l1 + 0x3d0 ], %o0 _Thread_Executing, the_thread ); if ( !status ) 2009f24: 80 a2 20 00 cmp %o0, 0 2009f28: 32 80 00 05 bne,a 2009f3c <_User_extensions_Thread_create+0x48> 2009f2c: e0 04 00 00 ld [ %l0 ], %l0 2009f30: 81 c7 e0 08 ret <== NOT EXECUTED 2009f34: 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 ) { 2009f38: 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 ) ; 2009f3c: 80 a4 00 12 cmp %l0, %l2 2009f40: 32 bf ff f4 bne,a 2009f10 <_User_extensions_Thread_create+0x1c> 2009f44: c2 04 20 14 ld [ %l0 + 0x14 ], %g1 return FALSE; } } return TRUE; } 2009f48: 81 c7 e0 08 ret 2009f4c: 91 e8 20 01 restore %g0, 1, %o0 0200a020 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 200a020: 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; 200a024: 03 00 80 62 sethi %hi(0x2018800), %g1 void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 200a028: 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; 200a02c: e6 00 63 b8 ld [ %g1 + 0x3b8 ], %l3 _ISR_Disable( level ); 200a030: 7f ff df 4b call 2001d5c 200a034: 01 00 00 00 nop 200a038: 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 ) { 200a03c: c2 06 60 08 ld [ %i1 + 8 ], %g1 200a040: 80 a0 60 00 cmp %g1, 0 200a044: 02 80 00 03 be 200a050 <_Watchdog_Insert+0x30> 200a048: 03 00 80 63 sethi %hi(0x2018c00), %g1 _ISR_Enable( level ); 200a04c: 30 80 00 37 b,a 200a128 <_Watchdog_Insert+0x108> <== NOT EXECUTED return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 200a050: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 ! 2018c70 <_Watchdog_Sync_count> if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 200a054: 86 10 20 01 mov 1, %g3 _Watchdog_Sync_count++; 200a058: 84 00 a0 01 inc %g2 if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 200a05c: c6 26 60 08 st %g3, [ %i1 + 8 ] _Watchdog_Sync_count++; 200a060: c4 20 60 70 st %g2, [ %g1 + 0x70 ] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 200a064: 29 00 80 62 sethi %hi(0x2018800), %l4 the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 200a068: 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 ; 200a06c: e2 05 40 00 ld [ %l5 ], %l1 ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 200a070: 80 a4 a0 00 cmp %l2, 0 200a074: 22 80 00 1c be,a 200a0e4 <_Watchdog_Insert+0xc4> 200a078: 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 ); 200a07c: c2 04 40 00 ld [ %l1 ], %g1 200a080: 80 a0 60 00 cmp %g1, 0 200a084: 22 80 00 18 be,a 200a0e4 <_Watchdog_Insert+0xc4> 200a088: c4 04 60 04 ld [ %l1 + 4 ], %g2 break; if ( delta_interval < after->delta_interval ) { 200a08c: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 200a090: 80 a4 80 10 cmp %l2, %l0 200a094: 1a 80 00 04 bcc 200a0a4 <_Watchdog_Insert+0x84> 200a098: 82 24 00 12 sub %l0, %l2, %g1 after->delta_interval -= delta_interval; 200a09c: 10 80 00 11 b 200a0e0 <_Watchdog_Insert+0xc0> 200a0a0: 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 ); 200a0a4: 7f ff df 32 call 2001d6c 200a0a8: 90 10 00 18 mov %i0, %o0 200a0ac: 7f ff df 2c call 2001d5c 200a0b0: 01 00 00 00 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 200a0b4: c2 06 60 08 ld [ %i1 + 8 ], %g1 200a0b8: 80 a0 60 01 cmp %g1, 1 200a0bc: 12 80 00 15 bne 200a110 <_Watchdog_Insert+0xf0> 200a0c0: a4 24 80 10 sub %l2, %l0, %l2 goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 200a0c4: c2 05 23 cc ld [ %l4 + 0x3cc ], %g1 200a0c8: 80 a0 40 13 cmp %g1, %l3 200a0cc: 28 bf ff e9 bleu,a 200a070 <_Watchdog_Insert+0x50> 200a0d0: e2 04 40 00 ld [ %l1 ], %l1 _Watchdog_Sync_level = insert_isr_nest_level; 200a0d4: e6 25 23 cc st %l3, [ %l4 + 0x3cc ] the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 200a0d8: 10 bf ff e5 b 200a06c <_Watchdog_Insert+0x4c> 200a0dc: 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 ); 200a0e0: c4 04 60 04 ld [ %l1 + 4 ], %g2 the_watchdog->start_time = _Watchdog_Ticks_since_boot; 200a0e4: 03 00 80 63 sethi %hi(0x2018c00), %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 200a0e8: c6 00 80 00 ld [ %g2 ], %g3 200a0ec: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 after_node->next = the_node; 200a0f0: f2 20 80 00 st %i1, [ %g2 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 200a0f4: c4 26 60 04 st %g2, [ %i1 + 4 ] 200a0f8: c2 26 60 14 st %g1, [ %i1 + 0x14 ] } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 200a0fc: e4 26 60 10 st %l2, [ %i1 + 0x10 ] RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 200a100: 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; 200a104: 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; 200a108: c6 26 40 00 st %g3, [ %i1 ] 200a10c: 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; 200a110: 03 00 80 62 sethi %hi(0x2018800), %g1 _Watchdog_Sync_count--; 200a114: 05 00 80 63 sethi %hi(0x2018c00), %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; 200a118: e6 20 63 cc st %l3, [ %g1 + 0x3cc ] _Watchdog_Sync_count--; 200a11c: c2 00 a0 70 ld [ %g2 + 0x70 ], %g1 200a120: 82 00 7f ff add %g1, -1, %g1 200a124: c2 20 a0 70 st %g1, [ %g2 + 0x70 ] _ISR_Enable( level ); 200a128: 7f ff df 11 call 2001d6c 200a12c: 81 e8 00 00 restore 200a130: 01 00 00 00 nop 0200af50 <_Watchdog_Insert_ticks_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 200af50: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; (void) _Watchdog_Remove( timer ); 200af54: 40 00 17 37 call 2010c30 <_Watchdog_Remove> 200af58: 90 10 00 18 mov %i0, %o0 _ISR_Disable( level ); 200af5c: 7f ff ed ca call 2006684 200af60: 01 00 00 00 nop 200af64: 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 ) { 200af68: c2 06 20 08 ld [ %i0 + 8 ], %g1 200af6c: 80 a0 60 00 cmp %g1, 0 200af70: 22 80 00 06 be,a 200af88 <_Watchdog_Insert_ticks_helper+0x38> 200af74: f6 26 20 1c st %i3, [ %i0 + 0x1c ] _ISR_Enable( level ); 200af78: 7f ff ed c7 call 2006694 <== NOT EXECUTED 200af7c: b0 10 20 00 clr %i0 <== NOT EXECUTED 200af80: 81 c7 e0 08 ret <== NOT EXECUTED 200af84: 81 e8 00 00 restore <== NOT EXECUTED void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200af88: f4 26 20 20 st %i2, [ %i0 + 0x20 ] the_watchdog->user_data = user_data; 200af8c: f8 26 20 24 st %i4, [ %i0 + 0x24 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200af90: f2 26 20 0c st %i1, [ %i0 + 0xc ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200af94: c0 26 20 08 clr [ %i0 + 8 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200af98: 92 10 00 18 mov %i0, %o1 200af9c: 11 00 80 8e sethi %hi(0x2023800), %o0 200afa0: 40 00 16 cc call 2010ad0 <_Watchdog_Insert> 200afa4: 90 12 22 50 or %o0, 0x250, %o0 ! 2023a50 <_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 ); 200afa8: b0 10 20 01 mov 1, %i0 200afac: 7f ff ed ba call 2006694 200afb0: 90 10 00 10 mov %l0, %o0 return TRUE; } 200afb4: 81 c7 e0 08 ret 200afb8: 81 e8 00 00 restore 0200a180 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 200a180: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 200a184: 7f ff de f6 call 2001d5c 200a188: 01 00 00 00 nop previous_state = the_watchdog->state; 200a18c: e0 06 20 08 ld [ %i0 + 8 ], %l0 switch ( previous_state ) { 200a190: 80 a4 20 01 cmp %l0, 1 200a194: 22 80 00 1e be,a 200a20c <_Watchdog_Remove+0x8c> 200a198: c0 26 20 08 clr [ %i0 + 8 ] <== NOT EXECUTED 200a19c: 0a 80 00 1d bcs 200a210 <_Watchdog_Remove+0x90> 200a1a0: 03 00 80 63 sethi %hi(0x2018c00), %g1 200a1a4: 80 a4 20 03 cmp %l0, 3 200a1a8: 18 80 00 1a bgu 200a210 <_Watchdog_Remove+0x90> 200a1ac: 01 00 00 00 nop 200a1b0: c6 06 00 00 ld [ %i0 ], %g3 break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 200a1b4: c0 26 20 08 clr [ %i0 + 8 ] next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 200a1b8: c2 00 c0 00 ld [ %g3 ], %g1 200a1bc: 80 a0 60 00 cmp %g1, 0 200a1c0: 02 80 00 07 be 200a1dc <_Watchdog_Remove+0x5c> 200a1c4: 03 00 80 63 sethi %hi(0x2018c00), %g1 next_watchdog->delta_interval += the_watchdog->delta_interval; 200a1c8: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1 200a1cc: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 200a1d0: 82 00 40 02 add %g1, %g2, %g1 200a1d4: c2 20 e0 10 st %g1, [ %g3 + 0x10 ] if ( _Watchdog_Sync_count ) 200a1d8: 03 00 80 63 sethi %hi(0x2018c00), %g1 200a1dc: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 ! 2018c70 <_Watchdog_Sync_count> 200a1e0: 80 a0 60 00 cmp %g1, 0 200a1e4: 22 80 00 07 be,a 200a200 <_Watchdog_Remove+0x80> 200a1e8: c4 06 00 00 ld [ %i0 ], %g2 _Watchdog_Sync_level = _ISR_Nest_level; 200a1ec: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200a1f0: c4 00 63 b8 ld [ %g1 + 0x3b8 ], %g2 ! 2018bb8 <_ISR_Nest_level> <== NOT EXECUTED 200a1f4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200a1f8: c4 20 63 cc st %g2, [ %g1 + 0x3cc ] ! 2018bcc <_Watchdog_Sync_level> <== NOT EXECUTED ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 200a1fc: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED previous = the_node->previous; 200a200: c2 06 20 04 ld [ %i0 + 4 ], %g1 next->previous = previous; previous->next = next; 200a204: c4 20 40 00 st %g2, [ %g1 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200a208: c2 20 a0 04 st %g1, [ %g2 + 4 ] _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200a20c: 03 00 80 63 sethi %hi(0x2018c00), %g1 200a210: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 2018c74 <_Watchdog_Ticks_since_boot> 200a214: c2 26 20 18 st %g1, [ %i0 + 0x18 ] _ISR_Enable( level ); 200a218: 7f ff de d5 call 2001d6c 200a21c: b0 10 00 10 mov %l0, %i0 return( previous_state ); } 200a220: 81 c7 e0 08 ret 200a224: 81 e8 00 00 restore 0200a2cc <_Workspace_Allocate_or_fatal_error>: */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 200a2cc: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 200a2d0: 11 00 80 62 sethi %hi(0x2018800), %o0 200a2d4: 92 10 00 18 mov %i0, %o1 200a2d8: 7f ff f2 a0 call 2006d58 <_Heap_Allocate> 200a2dc: 90 12 23 3c or %o0, 0x33c, %o0 void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 200a2e0: b0 92 20 00 orcc %o0, 0, %i0 200a2e4: 12 80 00 04 bne 200a2f4 <_Workspace_Allocate_or_fatal_error+0x28> 200a2e8: 92 10 20 01 mov 1, %o1 _Internal_error_Occurred( 200a2ec: 7f ff f3 c6 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 200a2f0: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 200a2f4: 81 c7 e0 08 ret 200a2f8: 81 e8 00 00 restore 0200a2fc <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 200a2fc: 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 ) ) 200a300: 80 a6 20 00 cmp %i0, 0 200a304: 02 80 00 04 be 200a314 <_Workspace_Handler_initialization+0x18> 200a308: 80 8e 20 07 btst 7, %i0 200a30c: 02 80 00 07 be 200a328 <_Workspace_Handler_initialization+0x2c> 200a310: 03 00 80 62 sethi %hi(0x2018800), %g1 _Internal_error_Occurred( 200a314: 90 10 20 00 clr %o0 <== NOT EXECUTED 200a318: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 200a31c: 7f ff f3 ba call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 200a320: 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 ) { 200a324: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200a328: c2 00 63 14 ld [ %g1 + 0x314 ], %g1 ! 2018b14 <_CPU_Table+0x10> 200a32c: 84 10 20 00 clr %g2 200a330: 80 a0 60 00 cmp %g1, 0 200a334: 12 80 00 06 bne 200a34c <_Workspace_Handler_initialization+0x50> 200a338: 87 36 60 02 srl %i1, 2, %g3 index < size / sizeof( uint32_t ) ; index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 200a33c: 10 80 00 08 b 200a35c <_Workspace_Handler_initialization+0x60> 200a340: 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++ ) 200a344: 84 00 a0 01 inc %g2 <== NOT EXECUTED zero_out_array[ index ] = 0; 200a348: 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 ) ; 200a34c: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED 200a350: 0a bf ff fd bcs 200a344 <_Workspace_Handler_initialization+0x48> <== NOT EXECUTED 200a354: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 200a358: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200a35c: 94 10 00 19 mov %i1, %o2 200a360: 11 00 80 62 sethi %hi(0x2018800), %o0 200a364: 96 10 20 08 mov 8, %o3 200a368: 7f ff f3 5d call 20070dc <_Heap_Initialize> 200a36c: 90 12 23 3c or %o0, 0x33c, %o0 starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 200a370: 80 a2 20 00 cmp %o0, 0 200a374: 12 80 00 05 bne 200a388 <_Workspace_Handler_initialization+0x8c> 200a378: b0 10 20 00 clr %i0 _Internal_error_Occurred( 200a37c: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED 200a380: 7f ff f3 a1 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 200a384: 95 e8 20 03 restore %g0, 3, %o2 <== NOT EXECUTED 200a388: 81 c7 e0 08 ret 200a38c: 81 e8 00 00 restore 02020e3c <_kill_r>: struct _reent *ptr, pid_t pid, int sig ) { return kill( pid, sig ); 2020e3c: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 2020e40: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 2020e44: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2020e48: 7f ff ff f8 call 2020e28 <== NOT EXECUTED 2020e4c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2020e50: 01 00 00 00 nop 02005dc4 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 2005dc4: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 2005dc8: 90 96 60 00 orcc %i1, 0, %o0 2005dcc: 12 80 00 08 bne 2005dec 2005dd0: 80 a6 20 02 cmp %i0, 2 rtems_set_errno_and_return_minus_one( EINVAL ); 2005dd4: 40 00 27 fa call 200fdbc <__errno> <== NOT EXECUTED 2005dd8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2005ddc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2005de0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2005de4: 81 c7 e0 08 ret <== NOT EXECUTED 2005de8: 81 e8 00 00 restore <== NOT EXECUTED switch ( clock_id ) { 2005dec: 02 80 00 10 be 2005e2c 2005df0: 80 a6 20 02 cmp %i0, 2 2005df4: 18 80 00 06 bgu 2005e0c 2005df8: 80 a6 20 03 cmp %i0, 3 2005dfc: 80 a6 20 01 cmp %i0, 1 2005e00: 12 80 00 11 bne 2005e44 2005e04: 01 00 00 00 nop 2005e08: 30 80 00 06 b,a 2005e20 2005e0c: 02 80 00 0c be 2005e3c <== NOT EXECUTED 2005e10: 80 a6 20 04 cmp %i0, 4 <== NOT EXECUTED 2005e14: 12 80 00 0c bne 2005e44 <== NOT EXECUTED 2005e18: 01 00 00 00 nop <== NOT EXECUTED 2005e1c: 30 80 00 04 b,a 2005e2c <== NOT EXECUTED case CLOCK_REALTIME: _TOD_Get(tp); 2005e20: 40 00 0a b7 call 20088fc <_TOD_Get> 2005e24: b0 10 20 00 clr %i0 2005e28: 30 80 00 0b b,a 2005e54 break; #endif #ifdef _POSIX_CPUTIME case CLOCK_PROCESS_CPUTIME: _TOD_Get_uptime(tp); 2005e2c: 40 00 0a cd call 2008960 <_TOD_Get_uptime> <== NOT EXECUTED 2005e30: b0 10 20 00 clr %i0 <== NOT EXECUTED 2005e34: 81 c7 e0 08 ret <== NOT EXECUTED 2005e38: 81 e8 00 00 restore <== NOT EXECUTED break; #endif #ifdef _POSIX_THREAD_CPUTIME case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); 2005e3c: 40 00 02 fb call 2006a28 <== NOT EXECUTED 2005e40: 81 e8 00 00 restore <== NOT EXECUTED break; #endif default: rtems_set_errno_and_return_minus_one( EINVAL ); 2005e44: 40 00 27 de call 200fdbc <__errno> <== NOT EXECUTED 2005e48: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2005e4c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2005e50: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return 0; } 2005e54: 81 c7 e0 08 ret 2005e58: 81 e8 00 00 restore 02005e5c : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 2005e5c: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 2005e60: 90 96 60 00 orcc %i1, 0, %o0 2005e64: 02 80 00 0d be 2005e98 2005e68: 80 a6 20 02 cmp %i0, 2 rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 2005e6c: 02 80 00 22 be 2005ef4 2005e70: 80 a6 20 03 cmp %i0, 3 2005e74: 02 80 00 20 be 2005ef4 2005e78: 80 a6 20 01 cmp %i0, 1 2005e7c: 12 80 00 20 bne 2005efc 2005e80: 03 08 76 b9 sethi %hi(0x21dae400), %g1 case CLOCK_REALTIME: if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 2005e84: c4 02 00 00 ld [ %o0 ], %g2 2005e88: 82 10 60 ff or %g1, 0xff, %g1 2005e8c: 80 a0 80 01 cmp %g2, %g1 2005e90: 18 80 00 08 bgu 2005eb0 2005e94: 21 00 80 72 sethi %hi(0x201c800), %l0 rtems_set_errno_and_return_minus_one( EINVAL ); 2005e98: 40 00 27 c9 call 200fdbc <__errno> <== NOT EXECUTED 2005e9c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2005ea0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2005ea4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2005ea8: 81 c7 e0 08 ret <== NOT EXECUTED 2005eac: 81 e8 00 00 restore <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005eb0: c2 04 20 00 ld [ %l0 ], %g1 2005eb4: 82 00 60 01 inc %g1 2005eb8: c2 24 20 00 st %g1, [ %l0 ] _Thread_Disable_dispatch(); _TOD_Set( tp ); 2005ebc: 40 00 0a d9 call 2008a20 <_TOD_Set> 2005ec0: 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 ) 2005ec4: c2 04 20 00 ld [ %l0 ], %g1 2005ec8: b0 10 20 00 clr %i0 2005ecc: 82 00 7f ff add %g1, -1, %g1 2005ed0: c2 24 20 00 st %g1, [ %l0 ] 2005ed4: c2 04 20 00 ld [ %l0 ], %g1 2005ed8: 80 a0 60 00 cmp %g1, 0 2005edc: 12 80 00 0c bne 2005f0c 2005ee0: 01 00 00 00 nop _Thread_Dispatch(); 2005ee4: 40 00 12 79 call 200a8c8 <_Thread_Dispatch> 2005ee8: 01 00 00 00 nop 2005eec: 81 c7 e0 08 ret 2005ef0: 81 e8 00 00 restore break; #endif #ifdef _POSIX_THREAD_CPUTIME case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); 2005ef4: 40 00 02 cd call 2006a28 <== NOT EXECUTED 2005ef8: 81 e8 00 00 restore <== NOT EXECUTED break; #endif default: rtems_set_errno_and_return_minus_one( EINVAL ); 2005efc: 40 00 27 b0 call 200fdbc <__errno> 2005f00: b0 10 3f ff mov -1, %i0 2005f04: 82 10 20 16 mov 0x16, %g1 2005f08: c2 22 00 00 st %g1, [ %o0 ] } return 0; } 2005f0c: 81 c7 e0 08 ret 2005f10: 81 e8 00 00 restore 02020f60 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 2020f60: 9d e3 bf 88 save %sp, -120, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 2020f64: 7f ff ff 15 call 2020bb8 2020f68: 01 00 00 00 nop 2020f6c: 80 a6 00 08 cmp %i0, %o0 2020f70: 02 80 00 06 be 2020f88 2020f74: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 2020f78: 7f ff d6 e5 call 2016b0c <__errno> 2020f7c: 01 00 00 00 nop 2020f80: 10 80 00 07 b 2020f9c 2020f84: 82 10 20 03 mov 3, %g1 ! 3 /* * Validate the signal passed. */ if ( !sig ) 2020f88: 12 80 00 08 bne 2020fa8 2020f8c: 82 06 7f ff add %i1, -1, %g1 rtems_set_errno_and_return_minus_one( EINVAL ); 2020f90: 7f ff d6 df call 2016b0c <__errno> 2020f94: 01 00 00 00 nop 2020f98: 82 10 20 16 mov 0x16, %g1 ! 16 2020f9c: c2 22 00 00 st %g1, [ %o0 ] 2020fa0: 10 80 00 bc b 2021290 2020fa4: 90 10 3f ff mov -1, %o0 if ( !is_valid_signo(sig) ) 2020fa8: 80 a0 60 1f cmp %g1, 0x1f 2020fac: 18 bf ff f9 bgu 2020f90 2020fb0: 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 ) { 2020fb4: 85 2e 60 04 sll %i1, 4, %g2 2020fb8: 84 20 80 01 sub %g2, %g1, %g2 2020fbc: 03 00 80 a0 sethi %hi(0x2028000), %g1 2020fc0: 82 10 61 68 or %g1, 0x168, %g1 ! 2028168 <_POSIX_signals_Vectors> 2020fc4: 84 00 80 01 add %g2, %g1, %g2 2020fc8: c2 00 a0 08 ld [ %g2 + 8 ], %g1 2020fcc: 80 a0 60 01 cmp %g1, 1 2020fd0: 02 80 00 b0 be 2021290 2020fd4: 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 ) { 2020fd8: 80 a6 60 0b cmp %i1, 0xb 2020fdc: 18 80 00 0d bgu 2021010 2020fe0: 84 10 20 01 mov 1, %g2 2020fe4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2020fe8: 83 28 40 19 sll %g1, %i1, %g1 <== NOT EXECUTED 2020fec: 80 88 69 10 btst 0x910, %g1 <== NOT EXECUTED 2020ff0: 22 80 00 09 be,a 2021014 <== NOT EXECUTED 2020ff4: f2 27 bf ec st %i1, [ %fp + -20 ] <== NOT EXECUTED case SIGFPE: case SIGILL: case SIGSEGV: return pthread_kill( pthread_self(), sig ); 2020ff8: 40 00 01 4c call 2021528 <== NOT EXECUTED 2020ffc: 01 00 00 00 nop <== NOT EXECUTED 2021000: 40 00 01 09 call 2021424 <== NOT EXECUTED 2021004: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); return 0; } 2021008: 81 c7 e0 08 ret <== NOT EXECUTED 202100c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 2021010: f2 27 bf ec st %i1, [ %fp + -20 ] siginfo->si_code = SI_USER; 2021014: c4 27 bf f0 st %g2, [ %fp + -16 ] return pthread_kill( pthread_self(), sig ); default: break; } mask = signo_to_mask( sig ); 2021018: 82 06 7f ff add %i1, -1, %g1 */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { 202101c: 80 a6 a0 00 cmp %i2, 0 2021020: 12 80 00 04 bne 2021030 2021024: b1 28 80 01 sll %g2, %g1, %i0 siginfo->si_value.sival_int = 0; 2021028: 10 80 00 04 b 2021038 202102c: c0 27 bf f4 clr [ %fp + -12 ] } else { siginfo->si_value = *value; 2021030: c2 06 80 00 ld [ %i2 ], %g1 2021034: c2 27 bf f4 st %g1, [ %fp + -12 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2021038: 05 00 80 9e sethi %hi(0x2027800), %g2 202103c: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 ! 2027a50 <_Thread_Dispatch_disable_level> 2021040: 82 00 60 01 inc %g1 2021044: c2 20 a2 50 st %g1, [ %g2 + 0x250 ] /* * 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; 2021048: 03 00 80 9e sethi %hi(0x2027800), %g1 202104c: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 ! 2027b30 <_Thread_Executing> api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 2021050: c2 00 a1 74 ld [ %g2 + 0x174 ], %g1 2021054: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 2021058: 80 ae 00 01 andncc %i0, %g1, %g0 202105c: 12 80 00 65 bne 20211f0 2021060: 03 00 80 a0 sethi %hi(0x2028000), %g1 goto process_it; 2021064: 88 10 62 f4 or %g1, 0x2f4, %g4 ! 20282f4 <_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 ; 2021068: 98 01 20 30 add %g4, 0x30, %o4 index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; 202106c: c2 01 00 00 ld [ %g4 ], %g1 !_Chain_Is_tail( the_chain, the_node ) ; 2021070: 10 80 00 0b b 202109c 2021074: 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)) { 2021078: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 202107c: 80 8e 00 01 btst %i0, %g1 2021080: 12 80 00 5c bne 20211f0 2021084: c6 00 a1 74 ld [ %g2 + 0x174 ], %g3 2021088: c2 00 e0 c4 ld [ %g3 + 0xc4 ], %g1 <== NOT EXECUTED 202108c: 80 ae 00 01 andncc %i0, %g1, %g0 <== NOT EXECUTED 2021090: 12 80 00 59 bne 20211f4 <== NOT EXECUTED 2021094: 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 ) { 2021098: 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 ) ; 202109c: 80 a0 40 0d cmp %g1, %o5 20210a0: 12 bf ff f6 bne 2021078 20210a4: 84 10 00 01 mov %g1, %g2 20210a8: 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 ; 20210ac: 80 a1 00 0c cmp %g4, %o4 20210b0: 32 bf ff f0 bne,a 2021070 20210b4: 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 */ 20210b8: 03 00 80 9e sethi %hi(0x2027800), %g1 20210bc: ae 10 61 b0 or %g1, 0x1b0, %l7 ! 20279b0 <_Objects_Information_table> continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 20210c0: 03 00 80 95 sethi %hi(0x2025400), %g1 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 20210c4: 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 */ 20210c8: ac 10 60 00 mov %g1, %l6 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 20210cc: 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 */ 20210d0: 03 00 80 95 sethi %hi(0x2025400), %g1 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 20210d4: 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 */ 20210d8: aa 10 60 48 or %g1, 0x48, %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 ) 20210dc: 10 80 00 04 b 20210ec 20210e0: 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 ) 20210e4: 22 80 00 3d be,a 20211d8 20210e8: b4 06 a0 01 inc %i2 <== NOT EXECUTED continue; if ( !_Objects_Information_table[ the_api ] ) /* API not installed */ 20210ec: 83 2e a0 02 sll %i2, 2, %g1 20210f0: c2 05 c0 01 ld [ %l7 + %g1 ], %g1 20210f4: 80 a0 60 00 cmp %g1, 0 20210f8: 22 80 00 38 be,a 20211d8 20210fc: b4 06 a0 01 inc %i2 continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 2021100: c2 00 60 04 ld [ %g1 + 4 ], %g1 if ( !the_info ) /* manager not installed */ 2021104: 80 a0 60 00 cmp %g1, 0 2021108: 22 80 00 34 be,a 20211d8 202110c: b4 06 a0 01 inc %i2 <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; 2021110: e2 00 60 20 ld [ %g1 + 0x20 ], %l1 assert( object_table ); /* always at least 1 entry */ 2021114: 80 a4 60 00 cmp %l1, 0 2021118: 12 80 00 06 bne 2021130 202111c: e6 10 60 10 lduh [ %g1 + 0x10 ], %l3 2021120: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED 2021124: 92 10 20 c1 mov 0xc1, %o1 <== NOT EXECUTED 2021128: 7f ff 93 a3 call 2005fb4 <__assert> <== NOT EXECUTED 202112c: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED 2021130: 10 80 00 26 b 20211c8 2021134: 9a 10 20 01 mov 1, %o5 for ( index = 1 ; index <= maximum ; index++ ) { the_thread = (Thread_Control *) object_table[ index ]; 2021138: c4 00 40 11 ld [ %g1 + %l1 ], %g2 if ( !the_thread ) 202113c: 80 a0 a0 00 cmp %g2, 0 2021140: 22 80 00 22 be,a 20211c8 2021144: 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 ) 2021148: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4 202114c: 80 a1 00 12 cmp %g4, %l2 2021150: 38 80 00 1e bgu,a 20211c8 2021154: 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 ]; 2021158: c2 00 a1 74 ld [ %g2 + 0x174 ], %g1 if ( !api || !_POSIX_signals_Is_interested( api, mask ) ) 202115c: 80 a0 60 00 cmp %g1, 0 2021160: 22 80 00 1a be,a 20211c8 2021164: 9a 03 60 01 inc %o5 <== NOT EXECUTED 2021168: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 202116c: 80 ae 00 01 andncc %i0, %g1, %g0 2021170: 22 80 00 16 be,a 20211c8 2021174: 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 ) { 2021178: 80 a1 00 12 cmp %g4, %l2 202117c: 2a 80 00 11 bcs,a 20211c0 2021180: 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 ) ) 2021184: c6 04 20 10 ld [ %l0 + 0x10 ], %g3 <== NOT EXECUTED 2021188: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 202118c: 22 80 00 0f be,a 20211c8 <== NOT EXECUTED 2021190: 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 ) ) { 2021194: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 <== NOT EXECUTED 2021198: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 202119c: 22 80 00 09 be,a 20211c0 <== NOT EXECUTED 20211a0: 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 ) 20211a4: 80 88 c0 14 btst %g3, %l4 <== NOT EXECUTED 20211a8: 32 80 00 08 bne,a 20211c8 <== NOT EXECUTED 20211ac: 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 ) { 20211b0: 80 88 40 14 btst %g1, %l4 <== NOT EXECUTED 20211b4: 22 80 00 05 be,a 20211c8 <== NOT EXECUTED 20211b8: 9a 03 60 01 inc %o5 <== NOT EXECUTED 20211bc: a0 10 00 02 mov %g2, %l0 <== NOT EXECUTED 20211c0: 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++ ) { 20211c4: 9a 03 60 01 inc %o5 20211c8: 80 a3 40 13 cmp %o5, %l3 20211cc: 08 bf ff db bleu 2021138 20211d0: 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++ ) { 20211d4: b4 06 a0 01 inc %i2 interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = 2; the_api <= OBJECTS_APIS_LAST; 20211d8: 80 a6 a0 04 cmp %i2, 4 20211dc: 08 bf ff c2 bleu 20210e4 20211e0: 80 a6 a0 01 cmp %i2, 1 interested_priority = the_thread->current_priority; } } } if ( interested_thread ) { 20211e4: 80 a4 20 00 cmp %l0, 0 20211e8: 02 80 00 0b be 2021214 20211ec: 84 10 00 10 mov %l0, %g2 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 20211f0: 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 ) ) { 20211f4: 90 10 00 02 mov %g2, %o0 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 20211f8: 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 ) ) { 20211fc: 92 10 00 19 mov %i1, %o1 2021200: 40 00 00 37 call 20212dc <_POSIX_signals_Unblock_thread> 2021204: 94 07 bf ec add %fp, -20, %o2 2021208: 80 a2 20 00 cmp %o0, 0 202120c: 12 80 00 1e bne 2021284 2021210: 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 ); 2021214: 40 00 00 22 call 202129c <_POSIX_signals_Set_process_signals> 2021218: 90 10 00 18 mov %i0, %o0 if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 202121c: 83 2e 60 02 sll %i1, 2, %g1 2021220: 85 2e 60 04 sll %i1, 4, %g2 2021224: b2 20 80 01 sub %g2, %g1, %i1 2021228: 03 00 80 a0 sethi %hi(0x2028000), %g1 202122c: 82 10 61 68 or %g1, 0x168, %g1 ! 2028168 <_POSIX_signals_Vectors> 2021230: c2 00 40 19 ld [ %g1 + %i1 ], %g1 2021234: 80 a0 60 02 cmp %g1, 2 2021238: 12 80 00 13 bne 2021284 202123c: 11 00 80 a0 sethi %hi(0x2028000), %o0 psiginfo = (POSIX_signals_Siginfo_node *) 2021240: 7f ff a7 ac call 200b0f0 <_Chain_Get> 2021244: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 20282e8 <_POSIX_signals_Inactive_siginfo> _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 2021248: b4 92 20 00 orcc %o0, 0, %i2 202124c: 12 80 00 06 bne 2021264 2021250: 92 07 bf ec add %fp, -20, %o1 rtems_set_errno_and_return_minus_one( EAGAIN ); 2021254: 7f ff d6 2e call 2016b0c <__errno> <== NOT EXECUTED 2021258: 01 00 00 00 nop <== NOT EXECUTED 202125c: 10 bf ff 50 b 2020f9c <== NOT EXECUTED 2021260: 82 10 20 0b mov 0xb, %g1 ! b <== NOT EXECUTED } psiginfo->Info = *siginfo; 2021264: 90 06 a0 08 add %i2, 8, %o0 2021268: 7f ff dc 1b call 20182d4 202126c: 94 10 20 0c mov 0xc, %o2 _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 2021270: 11 00 80 a0 sethi %hi(0x2028000), %o0 2021274: 92 10 00 1a mov %i2, %o1 2021278: 90 12 23 38 or %o0, 0x338, %o0 202127c: 7f ff a7 91 call 200b0c0 <_Chain_Append> 2021280: 90 06 40 08 add %i1, %o0, %o0 } _Thread_Enable_dispatch(); 2021284: 7f ff ff 2a call 2020f2c <_Thread_Enable_dispatch> 2021288: 01 00 00 00 nop 202128c: 90 10 20 00 clr %o0 ! 0 return 0; } 2021290: b0 10 00 08 mov %o0, %i0 2021294: 81 c7 e0 08 ret 2021298: 81 e8 00 00 restore 02009878 : */ int mq_close( mqd_t mqdes ) { 2009878: 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 *) 200987c: 21 00 80 8f sethi %hi(0x2023c00), %l0 2009880: 92 10 00 18 mov %i0, %o1 2009884: 94 07 bf f4 add %fp, -12, %o2 2009888: 40 00 12 6e call 200e240 <_Objects_Get> 200988c: 90 14 23 20 or %l0, 0x320, %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 ) { 2009890: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009894: 80 a0 60 01 cmp %g1, 1 2009898: 02 80 00 0e be 20098d0 200989c: b0 10 00 08 mov %o0, %i0 20098a0: 80 a0 60 01 cmp %g1, 1 20098a4: 2a 80 00 11 bcs,a 20098e8 20098a8: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 20098ac: 80 a0 60 02 cmp %g1, 2 20098b0: 12 80 00 2f bne 200996c 20098b4: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 20098b8: 40 00 2f 37 call 2015594 <__errno> 20098bc: 01 00 00 00 nop 20098c0: 82 10 20 09 mov 9, %g1 ! 9 20098c4: c2 22 00 00 st %g1, [ %o0 ] 20098c8: 10 80 00 2b b 2009974 20098cc: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 20098d0: 40 00 17 22 call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 20098d4: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 20098d8: 40 00 07 53 call 200b624 <== NOT EXECUTED 20098dc: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 20098e0: 81 c7 e0 08 ret <== NOT EXECUTED 20098e4: 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; 20098e8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 _POSIX_Message_queue_Delete( the_mq ); 20098ec: 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; 20098f0: 82 00 7f ff add %g1, -1, %g1 _POSIX_Message_queue_Delete( the_mq ); 20098f4: 40 00 00 23 call 2009980 <_POSIX_Message_queue_Delete> 20098f8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20098fc: 90 14 23 20 or %l0, 0x320, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2009900: c4 06 20 08 ld [ %i0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2009904: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2009908: 03 00 00 3f sethi %hi(0xfc00), %g1 200990c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2009910: 82 08 80 01 and %g2, %g1, %g1 2009914: 80 a0 40 03 cmp %g1, %g3 2009918: 38 80 00 06 bgu,a 2009930 200991c: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2009920: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2009924: 83 28 60 02 sll %g1, 2, %g1 2009928: 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; 200992c: 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 ); 2009930: 40 00 12 02 call 200e138 <_Objects_Free> 2009934: 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 ) 2009938: 03 00 80 8e sethi %hi(0x2023800), %g1 200993c: c4 00 61 50 ld [ %g1 + 0x150 ], %g2 ! 2023950 <_Thread_Dispatch_disable_level> 2009940: 90 10 20 00 clr %o0 2009944: 84 00 bf ff add %g2, -1, %g2 2009948: c4 20 61 50 st %g2, [ %g1 + 0x150 ] 200994c: c2 00 61 50 ld [ %g1 + 0x150 ], %g1 2009950: 80 a0 60 00 cmp %g1, 0 2009954: 32 80 00 09 bne,a 2009978 2009958: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 200995c: 40 00 16 ff call 200f558 <_Thread_Dispatch> 2009960: 01 00 00 00 nop 2009964: 10 80 00 04 b 2009974 2009968: 90 10 20 00 clr %o0 ! 0 _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200996c: 40 00 07 24 call 200b5fc <== NOT EXECUTED 2009970: 01 00 00 00 nop <== NOT EXECUTED } 2009974: b0 10 00 08 mov %o0, %i0 2009978: 81 c7 e0 08 ret 200997c: 81 e8 00 00 restore 02009a10 : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 2009a10: 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 ) 2009a14: 80 a6 60 00 cmp %i1, 0 2009a18: 12 80 00 06 bne 2009a30 2009a1c: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); 2009a20: 40 00 2e dd call 2015594 <__errno> 2009a24: 01 00 00 00 nop 2009a28: 10 80 00 12 b 2009a70 2009a2c: 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 *) 2009a30: 11 00 80 8f sethi %hi(0x2023c00), %o0 2009a34: 94 07 bf f4 add %fp, -12, %o2 2009a38: 40 00 12 02 call 200e240 <_Objects_Get> 2009a3c: 90 12 23 20 or %o0, 0x320, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 2009a40: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009a44: 80 a0 60 01 cmp %g1, 1 2009a48: 02 80 00 0d be 2009a7c 2009a4c: 01 00 00 00 nop 2009a50: 2a 80 00 11 bcs,a 2009a94 2009a54: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 2009a58: 80 a0 60 02 cmp %g1, 2 2009a5c: 12 80 00 23 bne 2009ae8 2009a60: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 2009a64: 40 00 2e cc call 2015594 <__errno> 2009a68: 01 00 00 00 nop 2009a6c: 82 10 20 09 mov 9, %g1 ! 9 2009a70: c2 22 00 00 st %g1, [ %o0 ] 2009a74: 10 80 00 1f b 2009af0 2009a78: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 2009a7c: 40 00 16 b7 call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 2009a80: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2009a84: 40 00 06 e8 call 200b624 <== NOT EXECUTED 2009a88: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2009a8c: 81 c7 e0 08 ret <== NOT EXECUTED 2009a90: 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; 2009a94: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2009a98: c2 26 40 00 st %g1, [ %i1 ] mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 2009a9c: c2 00 a0 6c ld [ %g2 + 0x6c ], %g1 2009aa0: c2 26 60 08 st %g1, [ %i1 + 8 ] mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 2009aa4: c2 00 a0 64 ld [ %g2 + 0x64 ], %g1 2009aa8: c2 26 60 04 st %g1, [ %i1 + 4 ] mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 2009aac: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1 2009ab0: 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 ) 2009ab4: 05 00 80 8e sethi %hi(0x2023800), %g2 2009ab8: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 ! 2023950 <_Thread_Dispatch_disable_level> 2009abc: 90 10 20 00 clr %o0 2009ac0: 82 00 7f ff add %g1, -1, %g1 2009ac4: c2 20 a1 50 st %g1, [ %g2 + 0x150 ] 2009ac8: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 2009acc: 80 a0 60 00 cmp %g1, 0 2009ad0: 32 80 00 09 bne,a 2009af4 2009ad4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2009ad8: 40 00 16 a0 call 200f558 <_Thread_Dispatch> 2009adc: 01 00 00 00 nop 2009ae0: 10 80 00 04 b 2009af0 2009ae4: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2009ae8: 40 00 06 c5 call 200b5fc <== NOT EXECUTED 2009aec: 01 00 00 00 nop <== NOT EXECUTED } 2009af0: b0 10 00 08 mov %o0, %i0 2009af4: 81 c7 e0 08 ret 2009af8: 81 e8 00 00 restore 02009b54 : int mq_notify( mqd_t mqdes, const struct sigevent *notification ) { 2009b54: 9d e3 bf 90 save %sp, -112, %sp 2009b58: 11 00 80 8f sethi %hi(0x2023c00), %o0 2009b5c: 92 10 00 18 mov %i0, %o1 2009b60: 90 12 23 20 or %o0, 0x320, %o0 2009b64: 40 00 11 b7 call 200e240 <_Objects_Get> 2009b68: 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 ) { 2009b6c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009b70: 80 a0 60 01 cmp %g1, 1 2009b74: 02 80 00 0c be 2009ba4 2009b78: 92 10 00 19 mov %i1, %o1 2009b7c: 80 a0 60 01 cmp %g1, 1 2009b80: 0a 80 00 0f bcs 2009bbc 2009b84: 80 a6 60 00 cmp %i1, 0 2009b88: 80 a0 60 02 cmp %g1, 2 2009b8c: 12 80 00 29 bne 2009c30 2009b90: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 2009b94: 40 00 2e 80 call 2015594 <__errno> 2009b98: 01 00 00 00 nop 2009b9c: 10 80 00 13 b 2009be8 2009ba0: 82 10 20 09 mov 9, %g1 ! 9 case OBJECTS_REMOTE: _Thread_Dispatch(); 2009ba4: 40 00 16 6d call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 2009ba8: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2009bac: 40 00 06 9e call 200b624 <== NOT EXECUTED 2009bb0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2009bb4: 81 c7 e0 08 ret <== NOT EXECUTED 2009bb8: 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 ) { 2009bbc: 02 80 00 17 be 2009c18 2009bc0: f0 02 20 10 ld [ %o0 + 0x10 ], %i0 if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { 2009bc4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 2009bc8: 80 a0 60 00 cmp %g1, 0 2009bcc: 22 80 00 0a be,a 2009bf4 2009bd0: c0 26 20 80 clr [ %i0 + 0x80 ] _Thread_Enable_dispatch(); 2009bd4: 7f ff ff ca call 2009afc <_Thread_Enable_dispatch> 2009bd8: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EBUSY ); 2009bdc: 40 00 2e 6e call 2015594 <__errno> 2009be0: 01 00 00 00 nop 2009be4: 82 10 20 10 mov 0x10, %g1 ! 10 2009be8: c2 22 00 00 st %g1, [ %o0 ] 2009bec: 10 80 00 13 b 2009c38 2009bf0: 90 10 3f ff mov -1, %o0 the_message_queue->notify_argument = the_argument; 2009bf4: c0 26 20 84 clr [ %i0 + 0x84 ] } _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); the_mq->notification = *notification; 2009bf8: 90 06 20 94 add %i0, 0x94, %o0 2009bfc: 40 00 30 4c call 2015d2c 2009c00: 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; 2009c04: 03 00 80 26 sethi %hi(0x2009800), %g1 the_message_queue->notify_argument = the_argument; 2009c08: 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; 2009c0c: 82 10 63 30 or %g1, 0x330, %g1 2009c10: 10 80 00 04 b 2009c20 2009c14: c2 26 20 80 st %g1, [ %i0 + 0x80 ] the_message_queue->notify_argument = the_argument; 2009c18: 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; 2009c1c: c0 26 20 80 clr [ %i0 + 0x80 ] _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); } _Thread_Enable_dispatch(); 2009c20: 7f ff ff b7 call 2009afc <_Thread_Enable_dispatch> 2009c24: 01 00 00 00 nop 2009c28: 10 80 00 04 b 2009c38 2009c2c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2009c30: 40 00 06 73 call 200b5fc <== NOT EXECUTED 2009c34: 01 00 00 00 nop <== NOT EXECUTED } 2009c38: b0 10 00 08 mov %o0, %i0 2009c3c: 81 c7 e0 08 ret 2009c40: 81 e8 00 00 restore 02009cc4 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 2009cc4: 9d e3 bf 88 save %sp, -120, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2009cc8: 05 00 80 8e sethi %hi(0x2023800), %g2 2009ccc: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 ! 2023950 <_Thread_Dispatch_disable_level> 2009cd0: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 2009cd4: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 2009cd8: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 2009cdc: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 2009ce0: 82 00 60 01 inc %g1 2009ce4: a0 10 00 18 mov %i0, %l0 2009ce8: c2 20 a1 50 st %g1, [ %g2 + 0x150 ] POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 2009cec: b6 8e 62 00 andcc %i1, 0x200, %i3 2009cf0: 02 80 00 05 be 2009d04 2009cf4: 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 * ); 2009cf8: f4 07 a0 50 ld [ %fp + 0x50 ], %i2 2009cfc: 82 07 a0 54 add %fp, 0x54, %g1 2009d00: 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 *) 2009d04: 39 00 80 8f sethi %hi(0x2023c00), %i4 2009d08: 40 00 10 0a call 200dd30 <_Objects_Allocate> 2009d0c: 90 17 23 20 or %i4, 0x320, %o0 ! 2023f20 <_POSIX_Message_queue_Information_fds> va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 2009d10: b0 92 20 00 orcc %o0, 0, %i0 2009d14: 32 80 00 08 bne,a 2009d34 2009d18: f2 26 20 14 st %i1, [ %i0 + 0x14 ] _Thread_Enable_dispatch(); 2009d1c: 7f ff ff dd call 2009c90 <_Thread_Enable_dispatch> 2009d20: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENFILE ); 2009d24: 40 00 2e 1c call 2015594 <__errno> 2009d28: 01 00 00 00 nop 2009d2c: 10 80 00 20 b 2009dac 2009d30: 82 10 20 17 mov 0x17, %g1 ! 17 } the_mq_fd->oflag = oflag; status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 2009d34: 90 10 00 10 mov %l0, %o0 2009d38: 40 00 24 0c call 2012d68 <_POSIX_Message_queue_Name_to_id> 2009d3c: 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 ) { 2009d40: ba 92 20 00 orcc %o0, 0, %i5 2009d44: 02 80 00 10 be 2009d84 2009d48: 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) ) ) { 2009d4c: 80 a7 60 02 cmp %i5, 2 2009d50: 12 80 00 04 bne 2009d60 2009d54: 80 a6 e0 00 cmp %i3, 0 2009d58: 12 80 00 2c bne 2009e08 2009d5c: 90 10 00 10 mov %l0, %o0 _POSIX_Message_queue_Free_fd( the_mq_fd ); 2009d60: 7f ff ff c5 call 2009c74 <_POSIX_Message_queue_Free_fd> 2009d64: 90 10 00 18 mov %i0, %o0 _Thread_Enable_dispatch(); 2009d68: 7f ff ff ca call 2009c90 <_Thread_Enable_dispatch> 2009d6c: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 2009d70: 40 00 2e 09 call 2015594 <__errno> 2009d74: 01 00 00 00 nop 2009d78: fa 22 00 00 st %i5, [ %o0 ] 2009d7c: 81 c7 e0 08 ret 2009d80: 81 e8 00 00 restore /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 2009d84: 80 a0 6a 00 cmp %g1, 0xa00 2009d88: 12 80 00 0b bne 2009db4 2009d8c: d2 07 bf f0 ld [ %fp + -16 ], %o1 _POSIX_Message_queue_Free_fd( the_mq_fd ); 2009d90: 7f ff ff b9 call 2009c74 <_POSIX_Message_queue_Free_fd> 2009d94: 90 10 00 18 mov %i0, %o0 _Thread_Enable_dispatch(); 2009d98: 7f ff ff be call 2009c90 <_Thread_Enable_dispatch> 2009d9c: 01 00 00 00 nop rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 2009da0: 40 00 2d fd call 2015594 <__errno> 2009da4: 01 00 00 00 nop 2009da8: 82 10 20 11 mov 0x11, %g1 ! 11 2009dac: 10 80 00 22 b 2009e34 2009db0: 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 *) 2009db4: 94 07 bf e8 add %fp, -24, %o2 <== NOT EXECUTED 2009db8: 11 00 80 8f sethi %hi(0x2023c00), %o0 <== NOT EXECUTED 2009dbc: 40 00 11 21 call 200e240 <_Objects_Get> <== NOT EXECUTED 2009dc0: 90 12 21 68 or %o0, 0x168, %o0 ! 2023d68 <_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; 2009dc4: c4 02 20 1c ld [ %o0 + 0x1c ], %g2 <== NOT EXECUTED 2009dc8: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED the_mq_fd->Queue = the_mq; _Objects_Open( 2009dcc: 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 ); 2009dd0: c2 27 bf ec st %g1, [ %fp + -20 ] <== NOT EXECUTED the_mq->open_count += 1; 2009dd4: 84 00 a0 01 inc %g2 <== NOT EXECUTED the_mq_fd->Queue = the_mq; _Objects_Open( 2009dd8: 90 17 23 20 or %i4, 0x320, %o0 <== NOT EXECUTED 2009ddc: 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; 2009de0: c2 26 20 10 st %g1, [ %i0 + 0x10 ] <== NOT EXECUTED _Objects_Open( 2009de4: 7f ff ff 98 call 2009c44 <_Objects_Open> <== NOT EXECUTED 2009de8: c4 20 60 1c st %g2, [ %g1 + 0x1c ] <== NOT EXECUTED &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 2009dec: 7f ff ff a9 call 2009c90 <_Thread_Enable_dispatch> <== NOT EXECUTED 2009df0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); 2009df4: 7f ff ff a7 call 2009c90 <_Thread_Enable_dispatch> <== NOT EXECUTED 2009df8: 01 00 00 00 nop <== NOT EXECUTED return (mqd_t)the_mq_fd->Object.id; 2009dfc: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED 2009e00: 81 c7 e0 08 ret <== NOT EXECUTED 2009e04: 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( 2009e08: 94 10 00 1a mov %i2, %o2 2009e0c: 92 10 20 01 mov 1, %o1 2009e10: 40 00 23 6a call 2012bb8 <_POSIX_Message_queue_Create_support> 2009e14: 96 07 bf ec add %fp, -20, %o3 /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 2009e18: 80 a2 3f ff cmp %o0, -1 2009e1c: 12 80 00 08 bne 2009e3c 2009e20: c2 07 bf ec ld [ %fp + -20 ], %g1 _Thread_Enable_dispatch(); 2009e24: 7f ff ff 9b call 2009c90 <_Thread_Enable_dispatch> 2009e28: 01 00 00 00 nop _POSIX_Message_queue_Free_fd( the_mq_fd ); 2009e2c: 7f ff ff 92 call 2009c74 <_POSIX_Message_queue_Free_fd> 2009e30: 90 10 00 18 mov %i0, %o0 2009e34: 81 c7 e0 08 ret 2009e38: 91 e8 3f ff restore %g0, -1, %o0 return (mqd_t) -1; } the_mq_fd->Queue = the_mq; _Objects_Open( 2009e3c: 92 10 00 18 mov %i0, %o1 2009e40: 90 17 23 20 or %i4, 0x320, %o0 2009e44: 94 10 20 00 clr %o2 2009e48: 7f ff ff 7f call 2009c44 <_Objects_Open> 2009e4c: c2 26 20 10 st %g1, [ %i0 + 0x10 ] &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 2009e50: 7f ff ff 90 call 2009c90 <_Thread_Enable_dispatch> 2009e54: 01 00 00 00 nop return (mqd_t) the_mq_fd->Object.id; 2009e58: f0 06 20 08 ld [ %i0 + 8 ], %i0 } 2009e5c: 81 c7 e0 08 ret 2009e60: 81 e8 00 00 restore 0200a17c : int mq_setattr( mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat ) { 200a17c: 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 ) 200a180: 80 a6 60 00 cmp %i1, 0 200a184: 12 80 00 06 bne 200a19c 200a188: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); 200a18c: 40 00 2d 02 call 2015594 <__errno> 200a190: 01 00 00 00 nop 200a194: 10 80 00 12 b 200a1dc 200a198: 82 10 20 16 mov 0x16, %g1 ! 16 200a19c: 11 00 80 8f sethi %hi(0x2023c00), %o0 200a1a0: 94 07 bf f4 add %fp, -12, %o2 200a1a4: 40 00 10 27 call 200e240 <_Objects_Get> 200a1a8: 90 12 23 20 or %o0, 0x320, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 200a1ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 200a1b0: 80 a0 60 01 cmp %g1, 1 200a1b4: 02 80 00 0d be 200a1e8 200a1b8: 01 00 00 00 nop 200a1bc: 0a 80 00 11 bcs 200a200 200a1c0: 80 a6 a0 00 cmp %i2, 0 200a1c4: 80 a0 60 02 cmp %g1, 2 200a1c8: 12 80 00 27 bne 200a264 200a1cc: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 200a1d0: 40 00 2c f1 call 2015594 <__errno> 200a1d4: 01 00 00 00 nop 200a1d8: 82 10 20 09 mov 9, %g1 ! 9 200a1dc: c2 22 00 00 st %g1, [ %o0 ] 200a1e0: 10 80 00 23 b 200a26c 200a1e4: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 200a1e8: 40 00 14 dc call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 200a1ec: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 200a1f0: 40 00 05 0d call 200b624 <== NOT EXECUTED 200a1f4: 01 00 00 00 nop <== NOT EXECUTED the_mq_fd->oflag = mqstat->mq_flags; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200a1f8: 81 c7 e0 08 ret <== NOT EXECUTED 200a1fc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * Return the old values. */ if ( omqstat ) { 200a200: 02 80 00 0a be 200a228 200a204: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 omqstat->mq_flags = the_mq_fd->oflag; 200a208: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200a20c: c2 26 80 00 st %g1, [ %i2 ] omqstat->mq_msgsize = the_core_mq->maximum_message_size; 200a210: c2 00 a0 6c ld [ %g2 + 0x6c ], %g1 200a214: c2 26 a0 08 st %g1, [ %i2 + 8 ] omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages; 200a218: c2 00 a0 64 ld [ %g2 + 0x64 ], %g1 200a21c: c2 26 a0 04 st %g1, [ %i2 + 4 ] omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages; 200a220: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1 200a224: c2 26 a0 0c st %g1, [ %i2 + 0xc ] } the_mq_fd->oflag = mqstat->mq_flags; 200a228: c2 06 40 00 ld [ %i1 ], %g1 200a22c: 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 ) 200a230: 05 00 80 8e sethi %hi(0x2023800), %g2 200a234: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 ! 2023950 <_Thread_Dispatch_disable_level> 200a238: 90 10 20 00 clr %o0 200a23c: 82 00 7f ff add %g1, -1, %g1 200a240: c2 20 a1 50 st %g1, [ %g2 + 0x150 ] 200a244: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 200a248: 80 a0 60 00 cmp %g1, 0 200a24c: 32 80 00 09 bne,a 200a270 200a250: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 200a254: 40 00 14 c1 call 200f558 <_Thread_Dispatch> 200a258: 01 00 00 00 nop 200a25c: 10 80 00 04 b 200a26c 200a260: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200a264: 40 00 04 e6 call 200b5fc <== NOT EXECUTED 200a268: 01 00 00 00 nop <== NOT EXECUTED } 200a26c: b0 10 00 08 mov %o0, %i0 200a270: 81 c7 e0 08 ret 200a274: 81 e8 00 00 restore 0200a278 : char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 200a278: 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 ) ) { 200a27c: 92 07 bf f4 add %fp, -12, %o1 200a280: 40 00 00 88 call 200a4a0 <_POSIX_Absolute_timeout_to_ticks> 200a284: 90 10 00 1c mov %i4, %o0 char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 200a288: 92 10 00 19 mov %i1, %o1 200a28c: 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 ) ) { 200a290: 80 a2 20 02 cmp %o0, 2 200a294: 08 80 00 07 bleu 200a2b0 200a298: 96 10 00 1b mov %i3, %o3 200a29c: 80 a2 20 03 cmp %o0, 3 200a2a0: 22 80 00 05 be,a 200a2b4 200a2a4: b8 10 20 01 mov 1, %i4 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Receive_support( 200a2a8: 10 80 00 04 b 200a2b8 <== NOT EXECUTED 200a2ac: 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 ) ) { 200a2b0: 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( 200a2b4: da 07 bf f4 ld [ %fp + -12 ], %o5 200a2b8: 90 10 00 18 mov %i0, %o0 200a2bc: 7f ff fe fd call 2009eb0 <_POSIX_Message_queue_Receive_support> 200a2c0: 98 10 00 1c mov %i4, %o4 msg_len, msg_prio, do_wait, ticks ); } 200a2c4: 81 c7 e0 08 ret 200a2c8: 91 e8 00 08 restore %g0, %o0, %o0 0200a2cc : const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 200a2cc: 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 ) ) { 200a2d0: 92 07 bf f4 add %fp, -12, %o1 200a2d4: 40 00 00 73 call 200a4a0 <_POSIX_Absolute_timeout_to_ticks> 200a2d8: 90 10 00 1c mov %i4, %o0 const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 200a2dc: 92 10 00 19 mov %i1, %o1 200a2e0: 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 ) ) { 200a2e4: 80 a2 20 02 cmp %o0, 2 200a2e8: 08 80 00 07 bleu 200a304 200a2ec: 96 10 00 1b mov %i3, %o3 200a2f0: 80 a2 20 03 cmp %o0, 3 200a2f4: 22 80 00 05 be,a 200a308 200a2f8: b8 10 20 01 mov 1, %i4 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Send_support( 200a2fc: 10 80 00 04 b 200a30c <== NOT EXECUTED 200a300: 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 ) ) { 200a304: 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( 200a308: da 07 bf f4 ld [ %fp + -12 ], %o5 200a30c: 90 10 00 18 mov %i0, %o0 200a310: 7f ff ff 4e call 200a048 <_POSIX_Message_queue_Send_support> 200a314: 98 10 00 1c mov %i4, %o4 msg_len, msg_prio, do_wait, ticks ); } 200a318: 81 c7 e0 08 ret 200a31c: 91 e8 00 08 restore %g0, %o0, %o0 020057a8 : */ int pthread_barrier_destroy( pthread_barrier_t *barrier ) { 20057a8: 9d e3 bf 90 save %sp, -112, %sp POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 20057ac: 80 a6 20 00 cmp %i0, 0 20057b0: 02 80 00 2c be 2005860 20057b4: 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( 20057b8: d2 06 00 00 ld [ %i0 ], %o1 20057bc: 31 00 80 69 sethi %hi(0x201a400), %i0 20057c0: 40 00 0c b3 call 2008a8c <_Objects_Get> 20057c4: 90 16 22 d0 or %i0, 0x2d0, %o0 ! 201a6d0 <_POSIX_Barrier_Information> return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 20057c8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20057cc: 80 a0 60 00 cmp %g1, 0 20057d0: 02 80 00 07 be 20057ec 20057d4: 88 10 00 08 mov %o0, %g4 20057d8: 80 a0 60 02 cmp %g1, 2 20057dc: 18 80 00 1d bgu 2005850 20057e0: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 20057e4: 81 c7 e0 08 ret 20057e8: 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 ) { 20057ec: c2 02 20 58 ld [ %o0 + 0x58 ], %g1 20057f0: 80 a0 60 00 cmp %g1, 0 20057f4: 22 80 00 06 be,a 200580c 20057f8: 90 16 22 d0 or %i0, 0x2d0, %o0 _Thread_Enable_dispatch(); 20057fc: 7f ff ff de call 2005774 <_Thread_Enable_dispatch> 2005800: 01 00 00 00 nop 2005804: 10 80 00 18 b 2005864 2005808: 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 ); 200580c: c2 01 20 08 ld [ %g4 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005810: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005814: 05 00 00 3f sethi %hi(0xfc00), %g2 2005818: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200581c: 82 08 40 02 and %g1, %g2, %g1 2005820: 80 a0 40 03 cmp %g1, %g3 2005824: 18 80 00 05 bgu 2005838 2005828: 92 10 00 04 mov %g4, %o1 information->local_table[ index ] = the_object; 200582c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005830: 83 28 60 02 sll %g1, 2, %g1 2005834: 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 ); 2005838: 40 00 0c 53 call 2008984 <_Objects_Free> 200583c: c0 21 20 0c clr [ %g4 + 0xc ] _Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object ); _POSIX_Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 2005840: 7f ff ff cd call 2005774 <_Thread_Enable_dispatch> 2005844: 01 00 00 00 nop 2005848: 10 80 00 07 b 2005864 200584c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2005850: 40 00 01 fc call 2006040 <== NOT EXECUTED 2005854: 01 00 00 00 nop <== NOT EXECUTED } 2005858: 81 c7 e0 08 ret <== NOT EXECUTED 200585c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005860: 90 10 20 16 mov 0x16, %o0 } 2005864: b0 10 00 08 mov %o0, %i0 2005868: 81 c7 e0 08 ret 200586c: 81 e8 00 00 restore 020058a4 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 20058a4: 9d e3 bf 88 save %sp, -120, %sp const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 20058a8: 80 a6 20 00 cmp %i0, 0 20058ac: 02 80 00 36 be 2005984 20058b0: a0 10 00 19 mov %i1, %l0 return EINVAL; if ( count == 0 ) 20058b4: 80 a6 a0 00 cmp %i2, 0 20058b8: 02 80 00 33 be 2005984 20058bc: 80 a6 60 00 cmp %i1, 0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 20058c0: 32 80 00 06 bne,a 20058d8 20058c4: c2 04 00 00 ld [ %l0 ], %g1 the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 20058c8: a0 07 bf e8 add %fp, -24, %l0 20058cc: 7f ff ff 93 call 2005718 20058d0: 90 10 00 10 mov %l0, %o0 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 20058d4: c2 04 00 00 ld [ %l0 ], %g1 20058d8: 80 a0 60 00 cmp %g1, 0 20058dc: 02 80 00 2a be 2005984 20058e0: 01 00 00 00 nop return EINVAL; switch ( the_attr->process_shared ) { 20058e4: c2 04 20 04 ld [ %l0 + 4 ], %g1 20058e8: 80 a0 60 00 cmp %g1, 0 20058ec: 12 80 00 26 bne 2005984 20058f0: 05 00 80 68 sethi %hi(0x201a000), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20058f4: c2 00 a2 20 ld [ %g2 + 0x220 ], %g1 ! 201a220 <_Thread_Dispatch_disable_level> /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; the_attributes.maximum_count = count; 20058f8: f4 27 bf f4 st %i2, [ %fp + -12 ] 20058fc: 82 00 60 01 inc %g1 } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 2005900: c0 27 bf f0 clr [ %fp + -16 ] 2005904: c2 20 a2 20 st %g1, [ %g2 + 0x220 ] * 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 *) 2005908: 35 00 80 69 sethi %hi(0x201a400), %i2 200590c: 40 00 0b 1c call 200857c <_Objects_Allocate> 2005910: 90 16 a2 d0 or %i2, 0x2d0, %o0 ! 201a6d0 <_POSIX_Barrier_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 2005914: a0 92 20 00 orcc %o0, 0, %l0 2005918: 12 80 00 06 bne 2005930 200591c: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); 2005920: 7f ff ff d4 call 2005870 <_Thread_Enable_dispatch> 2005924: b0 10 20 0b mov 0xb, %i0 2005928: 81 c7 e0 08 ret 200592c: 81 e8 00 00 restore return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 2005930: 40 00 08 6a call 2007ad8 <_CORE_barrier_Initialize> 2005934: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005938: 90 16 a2 d0 or %i2, 0x2d0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200593c: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005940: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005944: 05 00 00 3f sethi %hi(0xfc00), %g2 2005948: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200594c: 82 08 40 02 and %g1, %g2, %g1 2005950: 80 a0 40 03 cmp %g1, %g3 2005954: 38 80 00 06 bgu,a 200596c 2005958: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200595c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005960: 83 28 60 02 sll %g1, 2, %g1 2005964: e0 20 80 01 st %l0, [ %g2 + %g1 ] ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 2005968: 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; 200596c: c0 24 20 0c clr [ %l0 + 0xc ] 2005970: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 2005974: 7f ff ff bf call 2005870 <_Thread_Enable_dispatch> 2005978: b0 10 20 00 clr %i0 200597c: 81 c7 e0 08 ret 2005980: 81 e8 00 00 restore return 0; } 2005984: 81 c7 e0 08 ret 2005988: 91 e8 20 16 restore %g0, 0x16, %o0 0200598c : */ int pthread_barrier_wait( pthread_barrier_t *barrier ) { 200598c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 2005990: 80 a6 20 00 cmp %i0, 0 2005994: 02 80 00 28 be 2005a34 2005998: 11 00 80 69 sethi %hi(0x201a400), %o0 RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get ( pthread_barrier_t *barrier, Objects_Locations *location ) { return (POSIX_Barrier_Control *) _Objects_Get( 200599c: d2 06 00 00 ld [ %i0 ], %o1 20059a0: 94 07 bf f4 add %fp, -12, %o2 20059a4: 40 00 0c 3a call 2008a8c <_Objects_Get> 20059a8: 90 12 22 d0 or %o0, 0x2d0, %o0 return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 20059ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 20059b0: 80 a0 60 00 cmp %g1, 0 20059b4: 22 80 00 07 be,a 20059d0 20059b8: d2 02 20 08 ld [ %o0 + 8 ], %o1 20059bc: 80 a0 60 02 cmp %g1, 2 20059c0: 18 80 00 19 bgu 2005a24 20059c4: 90 10 20 16 mov 0x16, %o0 return _POSIX_Barrier_Translate_core_barrier_return_code( _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20059c8: 81 c7 e0 08 ret 20059cc: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_barrier_Wait( 20059d0: 94 10 20 01 mov 1, %o2 20059d4: 90 02 20 10 add %o0, 0x10, %o0 20059d8: 96 10 20 00 clr %o3 20059dc: 40 00 08 4b call 2007b08 <_CORE_barrier_Wait> 20059e0: 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 ) 20059e4: 03 00 80 68 sethi %hi(0x201a000), %g1 20059e8: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 201a220 <_Thread_Dispatch_disable_level> 20059ec: 84 00 bf ff add %g2, -1, %g2 20059f0: c4 20 62 20 st %g2, [ %g1 + 0x220 ] 20059f4: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 20059f8: 80 a0 60 00 cmp %g1, 0 20059fc: 12 80 00 05 bne 2005a10 2005a00: 03 00 80 68 sethi %hi(0x201a000), %g1 _Thread_Dispatch(); 2005a04: 40 00 10 e8 call 2009da4 <_Thread_Dispatch> 2005a08: 01 00 00 00 nop TRUE, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 2005a0c: 03 00 80 68 sethi %hi(0x201a000), %g1 2005a10: c2 00 63 00 ld [ %g1 + 0x300 ], %g1 ! 201a300 <_Thread_Executing> 2005a14: 40 00 1e e6 call 200d5ac <_POSIX_Barrier_Translate_core_barrier_return_code> 2005a18: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2005a1c: 81 c7 e0 08 ret 2005a20: 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(); 2005a24: 40 00 01 87 call 2006040 <== NOT EXECUTED 2005a28: 01 00 00 00 nop <== NOT EXECUTED } 2005a2c: 81 c7 e0 08 ret <== NOT EXECUTED 2005a30: 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(); 2005a34: 90 10 20 16 mov 0x16, %o0 } 2005a38: b0 10 00 08 mov %o0, %i0 2005a3c: 81 c7 e0 08 ret 2005a40: 81 e8 00 00 restore 02004f24 : */ int pthread_cancel( pthread_t thread ) { 2004f24: 9d e3 bf 90 save %sp, -112, %sp /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 2004f28: 03 00 80 5c sethi %hi(0x2017000), %g1 2004f2c: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 20172e8 <_ISR_Nest_level> */ int pthread_cancel( pthread_t thread ) { 2004f30: 92 10 00 18 mov %i0, %o1 /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 2004f34: 80 a0 60 00 cmp %g1, 0 2004f38: 12 80 00 2e bne 2004ff0 2004f3c: 90 10 20 47 mov 0x47, %o0 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 2004f40: 11 00 80 5d sethi %hi(0x2017400), %o0 2004f44: 94 07 bf f4 add %fp, -12, %o2 2004f48: 40 00 0d 00 call 2008348 <_Objects_Get> 2004f4c: 90 12 21 08 or %o0, 0x108, %o0 return EPROTO; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2004f50: c2 07 bf f4 ld [ %fp + -12 ], %g1 2004f54: 80 a0 60 01 cmp %g1, 1 2004f58: 02 80 00 08 be 2004f78 2004f5c: 01 00 00 00 nop 2004f60: 2a 80 00 0a bcs,a 2004f88 2004f64: c6 02 21 74 ld [ %o0 + 0x174 ], %g3 2004f68: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2004f6c: 02 80 00 21 be 2004ff0 <== NOT EXECUTED 2004f70: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 2004f74: 30 80 00 1d b,a 2004fe8 <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_REMOTE: return POSIX_MP_NOT_IMPLEMENTED(); 2004f78: 40 00 02 9b call 20059e4 <== NOT EXECUTED 2004f7c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2004f80: 81 c7 e0 08 ret <== NOT EXECUTED 2004f84: 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; 2004f88: 82 10 20 01 mov 1, %g1 if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2004f8c: c4 00 e0 cc ld [ %g3 + 0xcc ], %g2 2004f90: 80 a0 a0 00 cmp %g2, 0 2004f94: 12 80 00 08 bne 2004fb4 2004f98: c2 20 e0 d4 st %g1, [ %g3 + 0xd4 ] 2004f9c: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 2004fa0: 80 a0 60 01 cmp %g1, 1 2004fa4: 12 80 00 04 bne 2004fb4 2004fa8: 01 00 00 00 nop thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS ) { _POSIX_Threads_cancel_run( the_thread ); 2004fac: 40 00 00 14 call 2004ffc <_POSIX_Threads_cancel_run> 2004fb0: 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 ) 2004fb4: 03 00 80 5c sethi %hi(0x2017000), %g1 2004fb8: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2017220 <_Thread_Dispatch_disable_level> 2004fbc: 90 10 20 00 clr %o0 2004fc0: 84 00 bf ff add %g2, -1, %g2 2004fc4: c4 20 62 20 st %g2, [ %g1 + 0x220 ] 2004fc8: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 2004fcc: 80 a0 60 00 cmp %g1, 0 2004fd0: 32 80 00 09 bne,a 2004ff4 2004fd4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2004fd8: 40 00 11 a2 call 2009660 <_Thread_Dispatch> 2004fdc: 01 00 00 00 nop 2004fe0: 10 80 00 04 b 2004ff0 2004fe4: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2004fe8: 40 00 02 75 call 20059bc <== NOT EXECUTED 2004fec: 01 00 00 00 nop <== NOT EXECUTED } 2004ff0: b0 10 00 08 mov %o0, %i0 2004ff4: 81 c7 e0 08 ret 2004ff8: 81 e8 00 00 restore 02006198 : */ int pthread_cond_destroy( pthread_cond_t *cond ) { 2006198: 9d e3 bf 90 save %sp, -112, %sp ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 200619c: 80 a6 20 00 cmp %i0, 0 20061a0: 32 80 00 05 bne,a 20061b4 20061a4: c2 06 00 00 ld [ %i0 ], %g1 *location = OBJECTS_ERROR; 20061a8: 82 10 20 02 mov 2, %g1 20061ac: 10 80 00 14 b 20061fc 20061b0: c2 27 bf f4 st %g1, [ %fp + -12 ] return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 20061b4: 80 a0 7f ff cmp %g1, -1 20061b8: 32 80 00 0c bne,a 20061e8 20061bc: d2 06 00 00 ld [ %i0 ], %o1 /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 20061c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20061c4: 40 00 00 41 call 20062c8 <== NOT EXECUTED 20061c8: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 20061cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20061d0: 22 80 00 06 be,a 20061e8 <== NOT EXECUTED 20061d4: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; 20061d8: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20061dc: b0 10 20 00 clr %i0 <== NOT EXECUTED 20061e0: 10 80 00 07 b 20061fc <== NOT EXECUTED 20061e4: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 20061e8: 11 00 80 63 sethi %hi(0x2018c00), %o0 20061ec: 94 07 bf f4 add %fp, -12, %o2 20061f0: 40 00 0f 3f call 2009eec <_Objects_Get> 20061f4: 90 12 20 6c or %o0, 0x6c, %o0 20061f8: 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 ) { 20061fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006200: 80 a0 60 00 cmp %g1, 0 2006204: 02 80 00 05 be 2006218 2006208: 80 a0 60 02 cmp %g1, 2 200620c: 08 80 00 20 bleu 200628c 2006210: 90 10 20 16 mov 0x16, %o0 2006214: 30 80 00 1c b,a 2006284 <== NOT EXECUTED return EINVAL; case OBJECTS_LOCAL: if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { 2006218: 40 00 16 71 call 200bbdc <_Thread_queue_First> 200621c: 90 06 20 18 add %i0, 0x18, %o0 2006220: 80 a2 20 00 cmp %o0, 0 2006224: 02 80 00 06 be 200623c 2006228: 03 00 80 63 sethi %hi(0x2018c00), %g1 _Thread_Enable_dispatch(); 200622c: 7f ff ff ce call 2006164 <_Thread_Enable_dispatch> 2006230: 01 00 00 00 nop 2006234: 10 80 00 16 b 200628c 2006238: 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 ); 200623c: c6 06 20 08 ld [ %i0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006240: 90 10 60 6c or %g1, 0x6c, %o0 2006244: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2006248: 03 00 00 3f sethi %hi(0xfc00), %g1 200624c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2006250: 82 08 c0 01 and %g3, %g1, %g1 2006254: 80 a0 40 02 cmp %g1, %g2 2006258: 18 80 00 05 bgu 200626c 200625c: 92 10 00 18 mov %i0, %o1 information->local_table[ index ] = the_object; 2006260: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006264: 83 28 60 02 sll %g1, 2, %g1 2006268: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free ( POSIX_Condition_variables_Control *the_condition_variable ) { _Objects_Free( 200626c: 40 00 0e de call 2009de4 <_Objects_Free> 2006270: c0 26 20 0c clr [ %i0 + 0xc ] 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 2006274: 7f ff ff bc call 2006164 <_Thread_Enable_dispatch> 2006278: 01 00 00 00 nop 200627c: 10 80 00 04 b 200628c 2006280: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2006284: 40 00 04 cb call 20075b0 <== NOT EXECUTED 2006288: 01 00 00 00 nop <== NOT EXECUTED } 200628c: 81 c7 e0 08 ret 2006290: 91 e8 00 08 restore %g0, %o0, %o0 020062c8 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 20062c8: 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; 20062cc: 03 00 80 5a sethi %hi(0x2016800), %g1 int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 20062d0: a4 10 00 18 mov %i0, %l2 POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 20062d4: 80 a6 60 00 cmp %i1, 0 20062d8: 02 80 00 03 be 20062e4 20062dc: a0 10 60 9c or %g1, 0x9c, %l0 20062e0: a0 10 00 19 mov %i1, %l0 /* * XXX: Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 20062e4: c2 04 20 04 ld [ %l0 + 4 ], %g1 20062e8: 80 a0 60 01 cmp %g1, 1 20062ec: 32 80 00 04 bne,a 20062fc 20062f0: c2 04 00 00 ld [ %l0 ], %g1 return POSIX_MP_NOT_IMPLEMENTED(); 20062f4: 40 00 04 b9 call 20075d8 <== NOT EXECUTED 20062f8: 81 e8 00 00 restore <== NOT EXECUTED if ( !the_attr->is_initialized ) 20062fc: 80 a0 60 00 cmp %g1, 0 2006300: 02 80 00 0e be 2006338 2006304: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006308: 05 00 80 61 sethi %hi(0x2018400), %g2 200630c: c2 00 a3 20 ld [ %g2 + 0x320 ], %g1 ! 2018720 <_Thread_Dispatch_disable_level> 2006310: 82 00 60 01 inc %g1 2006314: c2 20 a3 20 st %g1, [ %g2 + 0x320 ] */ RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) 2006318: 23 00 80 63 sethi %hi(0x2018c00), %l1 200631c: 40 00 0d b0 call 20099dc <_Objects_Allocate> 2006320: 90 14 60 6c or %l1, 0x6c, %o0 ! 2018c6c <_POSIX_Condition_variables_Information> _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 2006324: b2 92 20 00 orcc %o0, 0, %i1 2006328: 32 80 00 06 bne,a 2006340 200632c: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Thread_Enable_dispatch(); 2006330: 7f ff ff d9 call 2006294 <_Thread_Enable_dispatch> 2006334: b0 10 20 0c mov 0xc, %i0 2006338: 81 c7 e0 08 ret 200633c: 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( 2006340: 90 06 60 18 add %i1, 0x18, %o0 _Thread_Enable_dispatch(); return EAGAIN; } #endif the_cond->process_shared = the_attr->process_shared; 2006344: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 2006348: c0 26 60 14 clr [ %i1 + 0x14 ] /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 200634c: 92 10 20 00 clr %o1 2006350: 94 10 28 00 mov 0x800, %o2 2006354: 40 00 16 4c call 200bc84 <_Thread_queue_Initialize> 2006358: 96 10 20 74 mov 0x74, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200635c: 90 14 60 6c or %l1, 0x6c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2006360: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006364: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2006368: 03 00 00 3f sethi %hi(0xfc00), %g1 200636c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2006370: 82 08 80 01 and %g2, %g1, %g1 2006374: 80 a0 40 03 cmp %g1, %g3 2006378: 38 80 00 06 bgu,a 2006390 200637c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 2006380: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006384: 83 28 60 02 sll %g1, 2, %g1 2006388: f2 20 80 01 st %i1, [ %g2 + %g1 ] &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 200638c: 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; 2006390: c0 26 60 0c clr [ %i1 + 0xc ] 2006394: c2 24 80 00 st %g1, [ %l2 ] 0, /* Name not used */ 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 2006398: 7f ff ff bf call 2006294 <_Thread_Enable_dispatch> 200639c: b0 10 20 00 clr %i0 return 0; } 20063a0: 81 c7 e0 08 ret 20063a4: 81 e8 00 00 restore 020060dc : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 20060dc: 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; 20060e0: 03 00 80 6a sethi %hi(0x201a800), %g1 pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 20060e4: 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; 20060e8: 80 a6 60 00 cmp %i1, 0 20060ec: 02 80 00 03 be 20060f8 20060f0: a2 10 60 90 or %g1, 0x90, %l1 20060f4: a2 10 00 19 mov %i1, %l1 if ( !the_attr->is_initialized ) 20060f8: c2 04 40 00 ld [ %l1 ], %g1 20060fc: 80 a0 60 00 cmp %g1, 0 2006100: 02 80 00 65 be 2006294 2006104: 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 ) ) 2006108: c2 04 60 04 ld [ %l1 + 4 ], %g1 200610c: 80 a0 60 00 cmp %g1, 0 2006110: 22 80 00 07 be,a 200612c 2006114: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 2006118: c2 04 60 08 ld [ %l1 + 8 ], %g1 200611c: 80 a0 6f ff cmp %g1, 0xfff 2006120: 08 80 00 8b bleu 200634c 2006124: 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 ) { 2006128: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 <== NOT EXECUTED 200612c: 80 a0 60 01 cmp %g1, 1 2006130: 02 80 00 06 be 2006148 2006134: 80 a0 60 02 cmp %g1, 2 2006138: 12 80 00 57 bne 2006294 200613c: b0 10 20 16 mov 0x16, %i0 schedpolicy = api->schedpolicy; schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 2006140: 10 80 00 0a b 2006168 2006144: 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 ]; 2006148: 03 00 80 72 sethi %hi(0x201c800), %g1 200614c: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 ! 201c8e0 <_Thread_Executing> schedpolicy = api->schedpolicy; schedparam = api->schedparam; 2006150: 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 ]; 2006154: d2 00 61 74 ld [ %g1 + 0x174 ], %o1 schedpolicy = api->schedpolicy; schedparam = api->schedparam; 2006158: 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; 200615c: e4 02 60 7c ld [ %o1 + 0x7c ], %l2 schedparam = api->schedparam; 2006160: 10 80 00 05 b 2006174 2006164: 92 02 60 80 add %o1, 0x80, %o1 break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; 2006168: 90 07 bf e0 add %fp, -32, %o0 200616c: 92 04 60 18 add %l1, 0x18, %o1 2006170: 94 10 20 18 mov 0x18, %o2 2006174: 40 00 28 ff call 2010570 2006178: 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 ) 200617c: c2 04 60 0c ld [ %l1 + 0xc ], %g1 2006180: 80 a0 60 00 cmp %g1, 0 2006184: 12 80 00 44 bne 2006294 2006188: ea 07 bf e0 ld [ %fp + -32 ], %l5 /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 200618c: 82 05 7f ff add %l5, -1, %g1 2006190: 80 a0 60 fd cmp %g1, 0xfd 2006194: 18 80 00 6d bgu 2006348 2006198: 80 a4 a0 01 cmp %l2, 1 */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 200619c: 02 80 00 10 be 20061dc 20061a0: a0 10 20 00 clr %l0 20061a4: 14 80 00 08 bg 20061c4 20061a8: 80 a4 a0 02 cmp %l2, 2 20061ac: 80 a4 a0 00 cmp %l2, 0 20061b0: a0 10 20 01 mov 1, %l0 20061b4: 02 80 00 1a be 200621c 20061b8: a8 10 20 00 clr %l4 *thread = the_thread->Object.id; _Thread_Enable_dispatch(); return 0; 20061bc: 81 c7 e0 08 ret 20061c0: 91 e8 20 16 restore %g0, 0x16, %o0 */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 20061c4: 02 80 00 05 be 20061d8 20061c8: 80 a4 a0 03 cmp %l2, 3 20061cc: 12 80 00 32 bne 2006294 20061d0: b0 10 20 16 mov 0x16, %i0 20061d4: 30 80 00 04 b,a 20061e4 20061d8: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED 20061dc: 10 80 00 10 b 200621c 20061e0: 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 ) < 20061e4: 40 00 16 60 call 200bb64 <_Timespec_To_ticks> 20061e8: 90 07 bf e8 add %fp, -24, %o0 20061ec: a0 10 00 08 mov %o0, %l0 20061f0: 40 00 16 5d call 200bb64 <_Timespec_To_ticks> 20061f4: 90 07 bf f0 add %fp, -16, %o0 20061f8: 80 a4 00 08 cmp %l0, %o0 20061fc: 0a 80 00 53 bcs 2006348 2006200: 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 ) ) 2006204: 82 00 7f ff add %g1, -1, %g1 2006208: 80 a0 60 fd cmp %g1, 0xfd 200620c: 18 80 00 4f bgu 2006348 2006210: 03 00 80 19 sethi %hi(0x2006400), %g1 2006214: a0 10 20 03 mov 3, %l0 2006218: a8 10 63 04 or %g1, 0x304, %l4 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200621c: 05 00 80 72 sethi %hi(0x201c800), %g2 2006220: c2 00 a0 00 ld [ %g2 ], %g1 2006224: 82 00 60 01 inc %g1 2006228: c2 20 a0 00 st %g1, [ %g2 ] * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 200622c: 27 00 80 72 sethi %hi(0x201c800), %l3 2006230: 40 00 0b 9c call 20090a0 <_Objects_Allocate> 2006234: 90 14 e2 e8 or %l3, 0x2e8, %o0 ! 201cae8 <_POSIX_Threads_Information> * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 2006238: b2 92 20 00 orcc %o0, 0, %i1 200623c: 02 80 00 14 be 200628c 2006240: 90 14 e2 e8 or %l3, 0x2e8, %o0 /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 2006244: d4 04 60 04 ld [ %l1 + 4 ], %o2 2006248: d6 04 60 08 ld [ %l1 + 8 ], %o3 200624c: e0 23 a0 60 st %l0, [ %sp + 0x60 ] 2006250: e8 23 a0 64 st %l4, [ %sp + 0x64 ] 2006254: c0 23 a0 68 clr [ %sp + 0x68 ] 2006258: c0 23 a0 6c clr [ %sp + 0x6c ] 200625c: 9a 10 20 ff mov 0xff, %o5 2006260: a6 10 20 01 mov 1, %l3 2006264: 9a 23 40 15 sub %o5, %l5, %o5 2006268: e6 23 a0 5c st %l3, [ %sp + 0x5c ] 200626c: 92 10 00 19 mov %i1, %o1 2006270: 40 00 12 19 call 200aad4 <_Thread_Initialize> 2006274: 98 10 20 01 mov 1, %o4 budget_callout, 0, /* isr level */ NULL /* posix threads don't have a name */ ); if ( !status ) { 2006278: 80 a2 20 00 cmp %o0, 0 200627c: 32 80 00 08 bne,a 200629c 2006280: e0 06 61 74 ld [ %i1 + 0x174 ], %l0 _POSIX_Threads_Free( the_thread ); 2006284: 7f ff ff 82 call 200608c <_POSIX_Threads_Free> 2006288: 90 10 00 19 mov %i1, %o0 _Thread_Enable_dispatch(); 200628c: 7f ff ff 87 call 20060a8 <_Thread_Enable_dispatch> 2006290: b0 10 20 0b mov 0xb, %i0 2006294: 81 c7 e0 08 ret 2006298: 81 e8 00 00 restore */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; 200629c: 92 10 00 11 mov %l1, %o1 20062a0: 94 10 20 38 mov 0x38, %o2 20062a4: 40 00 28 b3 call 2010570 20062a8: 90 10 00 10 mov %l0, %o0 api->detachstate = the_attr->detachstate; 20062ac: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 api->schedpolicy = schedpolicy; api->schedparam = schedparam; 20062b0: 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; 20062b4: c2 24 20 38 st %g1, [ %l0 + 0x38 ] api->schedpolicy = schedpolicy; api->schedparam = schedparam; 20062b8: 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; 20062bc: e4 24 20 7c st %l2, [ %l0 + 0x7c ] api->schedparam = schedparam; 20062c0: 40 00 28 ac call 2010570 20062c4: 90 04 20 80 add %l0, 0x80, %o0 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 20062c8: 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; 20062cc: e6 26 60 78 st %l3, [ %i1 + 0x78 ] /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 20062d0: 96 10 00 1b mov %i3, %o3 20062d4: 90 10 00 19 mov %i1, %o0 20062d8: 92 10 20 01 mov 1, %o1 20062dc: 40 00 15 6b call 200b888 <_Thread_Start> 20062e0: 98 10 20 00 clr %o4 start_routine, arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { 20062e4: 80 a4 a0 03 cmp %l2, 3 20062e8: 12 80 00 09 bne 200630c 20062ec: a2 10 00 08 mov %o0, %l1 _Watchdog_Insert_ticks( 20062f0: 40 00 16 1d call 200bb64 <_Timespec_To_ticks> 20062f4: 90 04 20 88 add %l0, 0x88, %o0 20062f8: 92 04 20 9c add %l0, 0x9c, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20062fc: d0 24 20 a8 st %o0, [ %l0 + 0xa8 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006300: 11 00 80 72 sethi %hi(0x201c800), %o0 2006304: 40 00 17 11 call 200bf48 <_Watchdog_Insert> 2006308: 90 12 21 00 or %o0, 0x100, %o0 ! 201c900 <_Watchdog_Ticks_chain> /* * _Thread_Start only fails if the thread was in the incorrect state */ if ( !status ) { 200630c: 80 a4 60 00 cmp %l1, 0 2006310: 12 80 00 08 bne 2006330 2006314: 90 10 00 19 mov %i1, %o0 _POSIX_Threads_Free( the_thread ); 2006318: 7f ff ff 5d call 200608c <_POSIX_Threads_Free> <== NOT EXECUTED 200631c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 2006320: 7f ff ff 62 call 20060a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 2006324: 01 00 00 00 nop <== NOT EXECUTED 2006328: 81 c7 e0 08 ret <== NOT EXECUTED 200632c: 81 e8 00 00 restore <== NOT EXECUTED /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 2006330: c2 06 60 08 ld [ %i1 + 8 ], %g1 _Thread_Enable_dispatch(); 2006334: b0 10 20 00 clr %i0 2006338: 7f ff ff 5c call 20060a8 <_Thread_Enable_dispatch> 200633c: c2 25 80 00 st %g1, [ %l6 ] 2006340: 81 c7 e0 08 ret 2006344: 81 e8 00 00 restore return 0; 2006348: b0 10 20 16 mov 0x16, %i0 } 200634c: 81 c7 e0 08 ret 2006350: 81 e8 00 00 restore 02005790 : #include int pthread_detach( pthread_t thread ) { 2005790: 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 *) 2005794: 11 00 80 5c sethi %hi(0x2017000), %o0 2005798: 92 10 00 18 mov %i0, %o1 200579c: 90 12 22 b8 or %o0, 0x2b8, %o0 20057a0: 40 00 0b fe call 2008798 <_Objects_Get> 20057a4: 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 ) { 20057a8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20057ac: 80 a0 60 00 cmp %g1, 0 20057b0: 22 80 00 06 be,a 20057c8 20057b4: c2 02 21 74 ld [ %o0 + 0x174 ], %g1 20057b8: 80 a0 60 02 cmp %g1, 2 20057bc: 08 80 00 13 bleu 2005808 20057c0: 90 10 20 03 mov 3, %o0 20057c4: 30 80 00 0f b,a 2005800 <== NOT EXECUTED case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->detachstate = PTHREAD_CREATE_DETACHED; 20057c8: 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 ) 20057cc: 05 00 80 5b sethi %hi(0x2016c00), %g2 20057d0: c2 00 a3 d0 ld [ %g2 + 0x3d0 ], %g1 ! 2016fd0 <_Thread_Dispatch_disable_level> 20057d4: 90 10 20 00 clr %o0 20057d8: 82 00 7f ff add %g1, -1, %g1 20057dc: c2 20 a3 d0 st %g1, [ %g2 + 0x3d0 ] 20057e0: c2 00 a3 d0 ld [ %g2 + 0x3d0 ], %g1 20057e4: 80 a0 60 00 cmp %g1, 0 20057e8: 12 80 00 08 bne 2005808 20057ec: 01 00 00 00 nop _Thread_Dispatch(); 20057f0: 40 00 10 b0 call 2009ab0 <_Thread_Dispatch> 20057f4: 01 00 00 00 nop 20057f8: 10 80 00 04 b 2005808 20057fc: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005800: 40 00 01 82 call 2005e08 <== NOT EXECUTED 2005804: 01 00 00 00 nop <== NOT EXECUTED } 2005808: 81 c7 e0 08 ret 200580c: 91 e8 00 08 restore %g0, %o0, %o0 0200dd38 : #include void pthread_exit( void *value_ptr ) { 200dd38: 9d e3 bf 98 save %sp, -104, %sp Objects_Information *the_information; the_information = _Objects_Get_information( _Thread_Executing->Object.id ); 200dd3c: 25 00 80 62 sethi %hi(0x2018800), %l2 200dd40: c2 04 a3 d0 ld [ %l2 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> 200dd44: 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 ]; 200dd48: 03 00 80 62 sethi %hi(0x2018800), %g1 200dd4c: 85 30 e0 16 srl %g3, 0x16, %g2 200dd50: 82 10 62 50 or %g1, 0x250, %g1 200dd54: 84 08 a0 1c and %g2, 0x1c, %g2 200dd58: c2 00 40 02 ld [ %g1 + %g2 ], %g1 200dd5c: 87 30 e0 1b srl %g3, 0x1b, %g3 200dd60: 87 28 e0 02 sll %g3, 2, %g3 200dd64: e2 00 40 03 ld [ %g1 + %g3 ], %l1 /* This should never happen if _Thread_Get() works right */ assert( the_information ); 200dd68: 80 a4 60 00 cmp %l1, 0 200dd6c: 12 80 00 09 bne 200dd90 200dd70: 21 00 80 62 sethi %hi(0x2018800), %l0 200dd74: 11 00 80 5c sethi %hi(0x2017000), %o0 <== NOT EXECUTED 200dd78: 15 00 80 5c sethi %hi(0x2017000), %o2 <== NOT EXECUTED 200dd7c: 90 12 20 60 or %o0, 0x60, %o0 <== NOT EXECUTED 200dd80: 94 12 a0 a8 or %o2, 0xa8, %o2 <== NOT EXECUTED 200dd84: 7f ff d0 60 call 2001f04 <__assert> <== NOT EXECUTED 200dd88: 92 10 20 25 mov 0x25, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200dd8c: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED 200dd90: c2 04 22 f0 ld [ %l0 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 200dd94: 82 00 60 01 inc %g1 200dd98: c2 24 22 f0 st %g1, [ %l0 + 0x2f0 ] _Thread_Disable_dispatch(); _Thread_Executing->Wait.return_argument = value_ptr; 200dd9c: d2 04 a3 d0 ld [ %l2 + 0x3d0 ], %o1 _Thread_Close( the_information, _Thread_Executing ); 200dda0: 90 10 00 11 mov %l1, %o0 200dda4: 7f ff ea ff call 20089a0 <_Thread_Close> 200dda8: 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 ); 200ddac: d2 04 a3 d0 ld [ %l2 + 0x3d0 ], %o1 200ddb0: 11 00 80 63 sethi %hi(0x2018c00), %o0 200ddb4: 7f ff e6 43 call 20076c0 <_Objects_Free> 200ddb8: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 2018dd8 <_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 ) 200ddbc: c2 04 22 f0 ld [ %l0 + 0x2f0 ], %g1 200ddc0: 82 00 7f ff add %g1, -1, %g1 200ddc4: c2 24 22 f0 st %g1, [ %l0 + 0x2f0 ] 200ddc8: c2 04 22 f0 ld [ %l0 + 0x2f0 ], %g1 200ddcc: 80 a0 60 00 cmp %g1, 0 200ddd0: 12 80 00 04 bne 200dde0 200ddd4: 01 00 00 00 nop _Thread_Dispatch(); 200ddd8: 7f ff eb 81 call 2008bdc <_Thread_Dispatch> 200dddc: 81 e8 00 00 restore 200dde0: 81 c7 e0 08 ret <== NOT EXECUTED 200dde4: 81 e8 00 00 restore <== NOT EXECUTED 02007d18 : int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { 2007d18: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 2007d1c: 80 a6 60 00 cmp %i1, 0 2007d20: 02 80 00 05 be 2007d34 2007d24: 92 10 00 18 mov %i0, %o1 2007d28: 80 a6 a0 00 cmp %i2, 0 2007d2c: 32 80 00 04 bne,a 2007d3c 2007d30: 11 00 80 69 sethi %hi(0x201a400), %o0 2007d34: 10 80 00 27 b 2007dd0 2007d38: 90 10 20 16 mov 0x16, %o0 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 2007d3c: 94 07 bf f4 add %fp, -12, %o2 2007d40: 40 00 0c 12 call 200ad88 <_Objects_Get> 2007d44: 90 12 23 e8 or %o0, 0x3e8, %o0 return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2007d48: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007d4c: 80 a0 60 00 cmp %g1, 0 2007d50: 02 80 00 06 be 2007d68 2007d54: b0 10 00 08 mov %o0, %i0 2007d58: 80 a0 60 02 cmp %g1, 2 2007d5c: 08 80 00 1d bleu 2007dd0 2007d60: 90 10 20 03 mov 3, %o0 2007d64: 30 80 00 19 b,a 2007dc8 <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 2007d68: d2 02 21 74 ld [ %o0 + 0x174 ], %o1 if ( policy ) *policy = api->schedpolicy; if ( param ) { *param = api->schedparam; 2007d6c: 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; 2007d70: c2 02 60 7c ld [ %o1 + 0x7c ], %g1 if ( param ) { *param = api->schedparam; 2007d74: 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; 2007d78: c2 26 40 00 st %g1, [ %i1 ] if ( param ) { *param = api->schedparam; 2007d7c: 40 00 28 a2 call 2012004 2007d80: 92 02 60 80 add %o1, 0x80, %o1 param->sched_priority = 2007d84: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 2007d88: 82 10 20 ff mov 0xff, %g1 2007d8c: 82 20 40 02 sub %g1, %g2, %g1 2007d90: 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 ) 2007d94: 05 00 80 69 sethi %hi(0x201a400), %g2 2007d98: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 ! 201a500 <_Thread_Dispatch_disable_level> 2007d9c: 90 10 20 00 clr %o0 2007da0: 82 00 7f ff add %g1, -1, %g1 2007da4: c2 20 a1 00 st %g1, [ %g2 + 0x100 ] 2007da8: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 2007dac: 80 a0 60 00 cmp %g1, 0 2007db0: 12 80 00 08 bne 2007dd0 2007db4: 01 00 00 00 nop _Thread_Dispatch(); 2007db8: 40 00 10 ba call 200c0a0 <_Thread_Dispatch> 2007dbc: 01 00 00 00 nop 2007dc0: 10 80 00 04 b 2007dd0 2007dc4: 90 10 20 00 clr %o0 ! 0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2007dc8: 40 00 01 8c call 20083f8 <== NOT EXECUTED 2007dcc: 01 00 00 00 nop <== NOT EXECUTED } 2007dd0: 81 c7 e0 08 ret 2007dd4: 91 e8 00 08 restore %g0, %o0, %o0 02005798 : */ void *pthread_getspecific( pthread_key_t key ) { 2005798: 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 *) 200579c: 11 00 80 5d sethi %hi(0x2017400), %o0 20057a0: 92 10 00 18 mov %i0, %o1 20057a4: 90 12 22 f0 or %o0, 0x2f0, %o0 20057a8: 40 00 0c a4 call 2008a38 <_Objects_Get> 20057ac: 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 ) { 20057b0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20057b4: 80 a0 60 00 cmp %g1, 0 20057b8: 22 80 00 06 be,a 20057d0 20057bc: 03 00 80 5c sethi %hi(0x2017000), %g1 20057c0: 80 a0 60 02 cmp %g1, 2 20057c4: 08 80 00 18 bleu 2005824 20057c8: b0 10 20 00 clr %i0 20057cc: 30 80 00 18 b,a 200582c <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never happen */ return NULL; case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 20057d0: c2 00 62 d0 ld [ %g1 + 0x2d0 ], %g1 20057d4: c4 00 60 08 ld [ %g1 + 8 ], %g2 index = _Objects_Get_index( _Thread_Executing->Object.id ); key_data = (void *) the_key->Values[ api ][ index ]; 20057d8: 83 30 a0 16 srl %g2, 0x16, %g1 20057dc: 82 08 60 1c and %g1, 0x1c, %g1 20057e0: 82 00 40 08 add %g1, %o0, %g1 20057e4: c6 00 60 18 ld [ %g1 + 0x18 ], %g3 20057e8: 03 00 00 3f sethi %hi(0xfc00), %g1 20057ec: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20057f0: 84 08 80 01 and %g2, %g1, %g2 20057f4: 85 28 a0 02 sll %g2, 2, %g2 20057f8: 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 ) 20057fc: 05 00 80 5c sethi %hi(0x2017000), %g2 2005800: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20171f0 <_Thread_Dispatch_disable_level> 2005804: 82 00 7f ff add %g1, -1, %g1 2005808: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 200580c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 2005810: 80 a0 60 00 cmp %g1, 0 2005814: 12 80 00 08 bne 2005834 2005818: 01 00 00 00 nop _Thread_Dispatch(); 200581c: 40 00 11 4d call 2009d50 <_Thread_Dispatch> 2005820: 01 00 00 00 nop 2005824: 81 c7 e0 08 ret 2005828: 81 e8 00 00 restore _Thread_Enable_dispatch(); return key_data; } (void) POSIX_BOTTOM_REACHED(); 200582c: 40 00 02 1f call 20060a8 <== NOT EXECUTED 2005830: b0 10 20 00 clr %i0 <== NOT EXECUTED return (void *)NULL; } 2005834: 81 c7 e0 08 ret <== NOT EXECUTED 2005838: 81 e8 00 00 restore <== NOT EXECUTED 0200722c : int pthread_join( pthread_t thread, void **value_ptr ) { 200722c: 9d e3 bf 90 save %sp, -112, %sp 2007230: 11 00 80 66 sethi %hi(0x2019800), %o0 2007234: 92 10 00 18 mov %i0, %o1 2007238: 90 12 21 68 or %o0, 0x168, %o0 200723c: 40 00 0b cf call 200a178 <_Objects_Get> 2007240: 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 ) { 2007244: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007248: 80 a0 60 00 cmp %g1, 0 200724c: 22 80 00 06 be,a 2007264 2007250: c4 02 21 74 ld [ %o0 + 0x174 ], %g2 2007254: 80 a0 60 02 cmp %g1, 2 2007258: 08 80 00 25 bleu 20072ec 200725c: 90 10 20 03 mov 3, %o0 2007260: 30 80 00 21 b,a 20072e4 <== NOT EXECUTED case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { 2007264: c2 00 a0 38 ld [ %g2 + 0x38 ], %g1 2007268: 80 a0 60 00 cmp %g1, 0 200726c: 12 80 00 06 bne 2007284 2007270: 03 00 80 65 sethi %hi(0x2019400), %g1 _Thread_Enable_dispatch(); 2007274: 7f ff ff e1 call 20071f8 <_Thread_Enable_dispatch> 2007278: 01 00 00 00 nop 200727c: 10 80 00 1c b 20072ec 2007280: 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 ); 2007284: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { 2007288: 80 a2 00 03 cmp %o0, %g3 200728c: 12 80 00 06 bne 20072a4 2007290: 82 07 bf f0 add %fp, -16, %g1 _Thread_Enable_dispatch(); 2007294: 7f ff ff d9 call 20071f8 <_Thread_Enable_dispatch> 2007298: 01 00 00 00 nop 200729c: 10 80 00 14 b 20072ec 20072a0: 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 ); 20072a4: 90 00 a0 3c add %g2, 0x3c, %o0 /* * Put ourself on the threads join list */ _Thread_Executing->Wait.return_argument = &return_pointer; 20072a8: 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 ); 20072ac: 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; 20072b0: 82 10 20 01 mov 1, %g1 20072b4: 15 00 80 2f sethi %hi(0x200bc00), %o2 20072b8: 94 12 a3 84 or %o2, 0x384, %o2 ! 200bf84 <_Thread_queue_Timeout> 20072bc: 40 00 12 0c call 200baec <_Thread_queue_Enqueue_with_handler> 20072c0: c2 20 a0 6c st %g1, [ %g2 + 0x6c ] _Thread_Enable_dispatch(); 20072c4: 7f ff ff cd call 20071f8 <_Thread_Enable_dispatch> 20072c8: 01 00 00 00 nop if ( value_ptr ) 20072cc: 80 a6 60 00 cmp %i1, 0 20072d0: 02 80 00 07 be 20072ec 20072d4: 90 10 20 00 clr %o0 *value_ptr = return_pointer; 20072d8: c2 07 bf f0 ld [ %fp + -16 ], %g1 20072dc: 10 80 00 04 b 20072ec 20072e0: c2 26 40 00 st %g1, [ %i1 ] return 0; } return POSIX_BOTTOM_REACHED(); 20072e4: 40 00 01 41 call 20077e8 <== NOT EXECUTED 20072e8: 01 00 00 00 nop <== NOT EXECUTED } 20072ec: 81 c7 e0 08 ret 20072f0: 91 e8 00 08 restore %g0, %o0, %o0 02005530 : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 2005530: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005534: 03 00 80 5c sethi %hi(0x2017000), %g1 2005538: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20171f0 <_Thread_Dispatch_disable_level> 200553c: 84 00 a0 01 inc %g2 2005540: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] * _POSIX_Keys_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void ) { return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information ); 2005544: 11 00 80 5d sethi %hi(0x2017400), %o0 2005548: 40 00 0b f8 call 2008528 <_Objects_Allocate> 200554c: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 20176f0 <_POSIX_Keys_Information> _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 2005550: a0 92 20 00 orcc %o0, 0, %l0 2005554: 12 80 00 06 bne 200556c 2005558: 03 00 80 5c sethi %hi(0x2017000), %g1 _Thread_Enable_dispatch(); 200555c: 7f ff ff e8 call 20054fc <_Thread_Enable_dispatch> 2005560: b0 10 20 0b mov 0xb, %i0 2005564: 81 c7 e0 08 ret 2005568: 81 e8 00 00 restore return EAGAIN; } the_key->destructor = destructor; 200556c: 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 ] && 2005570: aa 10 61 50 or %g1, 0x150, %l5 if ( !the_key ) { _Thread_Enable_dispatch(); return EAGAIN; } the_key->destructor = destructor; 2005574: a2 10 00 10 mov %l0, %l1 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 2005578: 03 00 80 5c sethi %hi(0x2017000), %g1 200557c: a6 10 20 01 mov 1, %l3 2005580: a8 10 62 3c or %g1, 0x23c, %l4 for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] && 2005584: a5 2c e0 02 sll %l3, 2, %l2 2005588: c2 04 80 15 ld [ %l2 + %l5 ], %g1 200558c: 80 a0 60 00 cmp %g1, 0 2005590: 02 80 00 29 be 2005634 2005594: 90 10 00 14 mov %l4, %o0 2005598: c2 00 60 04 ld [ %g1 + 4 ], %g1 200559c: 80 a0 60 00 cmp %g1, 0 20055a0: 22 80 00 26 be,a 2005638 20055a4: c0 24 60 1c clr [ %l1 + 0x1c ] <== NOT EXECUTED _Objects_Information_table[ the_api ][ 1 ] ) { bytes_to_allocate = sizeof( void * ) * 20055a8: c2 10 60 10 lduh [ %g1 + 0x10 ], %g1 20055ac: 82 00 60 01 inc %g1 20055b0: b3 28 60 02 sll %g1, 2, %i1 20055b4: 40 00 0a 85 call 2007fc8 <_Heap_Allocate> 20055b8: 92 10 00 19 mov %i1, %o1 (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { 20055bc: 82 92 20 00 orcc %o0, 0, %g1 20055c0: 32 80 00 18 bne,a 2005620 20055c4: c2 24 60 1c st %g1, [ %l1 + 0x1c ] 20055c8: 82 04 a0 14 add %l2, 0x14, %g1 <== NOT EXECUTED 20055cc: b0 10 20 00 clr %i0 <== NOT EXECUTED 20055d0: b2 04 00 01 add %l0, %g1, %i1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 20055d4: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED 20055d8: 10 80 00 05 b 20055ec <== NOT EXECUTED 20055dc: a2 10 62 3c or %g1, 0x23c, %l1 ! 201723c <_Workspace_Area> <== NOT EXECUTED 20055e0: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED 20055e4: 40 00 0a a0 call 2008064 <_Heap_Free> <== NOT EXECUTED 20055e8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20055ec: b0 06 20 01 inc %i0 <== NOT EXECUTED for ( --the_api; the_api >= 1; 20055f0: 80 a6 00 13 cmp %i0, %l3 <== NOT EXECUTED 20055f4: 12 bf ff fb bne 20055e0 <== NOT EXECUTED 20055f8: 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 ); 20055fc: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2005600: 11 00 80 5d sethi %hi(0x2017400), %o0 <== NOT EXECUTED 2005604: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 20176f0 <_POSIX_Keys_Information> <== NOT EXECUTED 2005608: 40 00 0c ca call 2008930 <_Objects_Free> <== NOT EXECUTED 200560c: 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(); 2005610: 7f ff ff bb call 20054fc <_Thread_Enable_dispatch> <== NOT EXECUTED 2005614: 01 00 00 00 nop <== NOT EXECUTED 2005618: 81 c7 e0 08 ret <== NOT EXECUTED 200561c: 81 e8 00 00 restore <== NOT EXECUTED return ENOMEM; } the_key->Values[ the_api ] = table; memset( table, '\0', bytes_to_allocate ); 2005620: 94 10 00 19 mov %i1, %o2 2005624: 40 00 29 be call 200fd1c 2005628: 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++ ) { 200562c: 10 80 00 04 b 200563c 2005630: 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; 2005634: 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++ ) { 2005638: 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; 200563c: 80 a4 e0 05 cmp %l3, 5 2005640: 12 bf ff d1 bne 2005584 2005644: a2 04 60 04 add %l1, 4, %l1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005648: 03 00 80 5d sethi %hi(0x2017400), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200564c: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005650: 88 10 62 f0 or %g1, 0x2f0, %g4 2005654: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 } } the_key->is_active = TRUE; 2005658: 82 10 20 01 mov 1, %g1 200565c: c2 24 20 10 st %g1, [ %l0 + 0x10 ] 2005660: 03 00 00 3f sethi %hi(0xfc00), %g1 2005664: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005668: 82 08 c0 01 and %g3, %g1, %g1 200566c: 80 a0 40 02 cmp %g1, %g2 2005670: 38 80 00 06 bgu,a 2005688 2005674: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 2005678: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 200567c: 83 28 60 02 sll %g1, 2, %g1 2005680: e0 20 80 01 st %l0, [ %g2 + %g1 ] _Objects_Open( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 2005684: 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; 2005688: c0 24 20 0c clr [ %l0 + 0xc ] 200568c: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 2005690: 7f ff ff 9b call 20054fc <_Thread_Enable_dispatch> 2005694: b0 10 20 00 clr %i0 return 0; } 2005698: 81 c7 e0 08 ret 200569c: 81 e8 00 00 restore 020056a0 : */ int pthread_key_delete( pthread_key_t key ) { 20056a0: 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 *) 20056a4: 92 10 00 18 mov %i0, %o1 20056a8: 94 07 bf f4 add %fp, -12, %o2 20056ac: 31 00 80 5d sethi %hi(0x2017400), %i0 20056b0: 40 00 0c e2 call 2008a38 <_Objects_Get> 20056b4: 90 16 22 f0 or %i0, 0x2f0, %o0 ! 20176f0 <_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 ) { 20056b8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20056bc: 80 a0 60 00 cmp %g1, 0 20056c0: 02 80 00 06 be 20056d8 20056c4: a0 10 00 08 mov %o0, %l0 20056c8: 80 a0 60 02 cmp %g1, 2 20056cc: 08 80 00 31 bleu 2005790 20056d0: 90 10 20 16 mov 0x16, %o0 20056d4: 30 80 00 2d b,a 2005788 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20056d8: 90 16 22 f0 or %i0, 0x2f0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 20056dc: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20056e0: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 20056e4: 05 00 00 3f sethi %hi(0xfc00), %g2 20056e8: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 20056ec: 82 08 40 02 and %g1, %g2, %g1 20056f0: 80 a0 40 03 cmp %g1, %g3 20056f4: 38 80 00 06 bgu,a 200570c 20056f8: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 20056fc: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005700: 83 28 60 02 sll %g1, 2, %g1 2005704: c0 20 80 01 clr [ %g2 + %g1 ] 2005708: 03 00 80 5c sethi %hi(0x2017000), %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; 200570c: 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; 2005710: c0 24 20 10 clr [ %l0 + 0x10 ] 2005714: a2 10 62 3c or %g1, 0x23c, %l1 2005718: b0 10 20 00 clr %i0 for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 200571c: 82 04 00 18 add %l0, %i0, %g1 2005720: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 2005724: 80 a2 60 00 cmp %o1, 0 2005728: 02 80 00 04 be 2005738 200572c: b0 06 20 04 add %i0, 4, %i0 2005730: 40 00 0a 4d call 2008064 <_Heap_Free> 2005734: 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; 2005738: 80 a6 20 10 cmp %i0, 0x10 200573c: 12 bf ff f9 bne 2005720 2005740: 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 ); 2005744: 92 10 00 10 mov %l0, %o1 2005748: 11 00 80 5d sethi %hi(0x2017400), %o0 200574c: 40 00 0c 79 call 2008930 <_Objects_Free> 2005750: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 20176f0 <_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 ) 2005754: 05 00 80 5c sethi %hi(0x2017000), %g2 2005758: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20171f0 <_Thread_Dispatch_disable_level> 200575c: 90 10 20 00 clr %o0 2005760: 82 00 7f ff add %g1, -1, %g1 2005764: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 2005768: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 200576c: 80 a0 60 00 cmp %g1, 0 2005770: 12 80 00 08 bne 2005790 2005774: 01 00 00 00 nop _Thread_Dispatch(); 2005778: 40 00 11 76 call 2009d50 <_Thread_Dispatch> 200577c: 01 00 00 00 nop 2005780: 10 80 00 04 b 2005790 2005784: 90 10 20 00 clr %o0 ! 0 _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005788: 40 00 02 48 call 20060a8 <== NOT EXECUTED 200578c: 01 00 00 00 nop <== NOT EXECUTED } 2005790: 81 c7 e0 08 ret 2005794: 91 e8 00 08 restore %g0, %o0, %o0 02021424 : int pthread_kill( pthread_t thread, int sig ) { 2021424: 9d e3 bf 90 save %sp, -112, %sp POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 2021428: 80 a6 60 00 cmp %i1, 0 202142c: 02 80 00 06 be 2021444 2021430: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 2021434: a0 06 7f ff add %i1, -1, %l0 2021438: 80 a4 20 1f cmp %l0, 0x1f 202143c: 28 80 00 06 bleu,a 2021454 2021440: 11 00 80 9f sethi %hi(0x2027c00), %o0 rtems_set_errno_and_return_minus_one( EINVAL ); 2021444: 7f ff d5 b2 call 2016b0c <__errno> 2021448: 01 00 00 00 nop 202144c: 10 80 00 0f b 2021488 2021450: 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 *) 2021454: 94 07 bf f4 add %fp, -12, %o2 2021458: 7f ff aa f3 call 200c024 <_Objects_Get> 202145c: 90 12 21 84 or %o0, 0x184, %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 ) { 2021460: c2 07 bf f4 ld [ %fp + -12 ], %g1 2021464: 80 a0 60 00 cmp %g1, 0 2021468: 02 80 00 0b be 2021494 202146c: b0 10 00 08 mov %o0, %i0 2021470: 80 a0 60 02 cmp %g1, 2 2021474: 18 80 00 29 bgu 2021518 2021478: 01 00 00 00 nop case OBJECTS_ERROR: case OBJECTS_REMOTE: rtems_set_errno_and_return_minus_one( ESRCH ); 202147c: 7f ff d5 a4 call 2016b0c <__errno> 2021480: 01 00 00 00 nop 2021484: 82 10 20 03 mov 3, %g1 ! 3 2021488: c2 22 00 00 st %g1, [ %o0 ] 202148c: 10 80 00 25 b 2021520 2021490: 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 ) { 2021494: 83 2e 60 02 sll %i1, 2, %g1 2021498: 85 2e 60 04 sll %i1, 4, %g2 202149c: 84 20 80 01 sub %g2, %g1, %g2 20214a0: 03 00 80 a0 sethi %hi(0x2028000), %g1 20214a4: 82 10 61 68 or %g1, 0x168, %g1 ! 2028168 <_POSIX_signals_Vectors> 20214a8: 84 00 80 01 add %g2, %g1, %g2 20214ac: c2 00 a0 08 ld [ %g2 + 8 ], %g1 20214b0: 80 a0 60 01 cmp %g1, 1 20214b4: 02 80 00 15 be 2021508 20214b8: c6 02 21 74 ld [ %o0 + 0x174 ], %g3 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 20214bc: c4 00 e0 c8 ld [ %g3 + 0xc8 ], %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 20214c0: 92 10 00 19 mov %i1, %o1 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 20214c4: b2 10 20 01 mov 1, %i1 20214c8: 83 2e 40 10 sll %i1, %l0, %g1 20214cc: 84 10 80 01 or %g2, %g1, %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 20214d0: 94 10 20 00 clr %o2 20214d4: 7f ff ff 82 call 20212dc <_POSIX_signals_Unblock_thread> 20214d8: 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 ) ) 20214dc: 03 00 80 9e sethi %hi(0x2027800), %g1 20214e0: c2 00 63 18 ld [ %g1 + 0x318 ], %g1 ! 2027b18 <_ISR_Nest_level> 20214e4: 80 a0 60 00 cmp %g1, 0 20214e8: 02 80 00 08 be 2021508 20214ec: f2 26 20 78 st %i1, [ %i0 + 0x78 ] 20214f0: 03 00 80 9e sethi %hi(0x2027800), %g1 20214f4: c2 00 63 30 ld [ %g1 + 0x330 ], %g1 ! 2027b30 <_Thread_Executing> 20214f8: 80 a6 00 01 cmp %i0, %g1 20214fc: 12 80 00 03 bne 2021508 2021500: 03 00 80 9e sethi %hi(0x2027800), %g1 _ISR_Signals_to_thread_executing = TRUE; 2021504: f2 20 63 d8 st %i1, [ %g1 + 0x3d8 ] ! 2027bd8 <_ISR_Signals_to_thread_executing> <== NOT EXECUTED } _Thread_Enable_dispatch(); 2021508: 7f ff ff ba call 20213f0 <_Thread_Enable_dispatch> 202150c: 01 00 00 00 nop 2021510: 10 80 00 04 b 2021520 2021514: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2021518: 40 00 00 12 call 2021560 <== NOT EXECUTED 202151c: 01 00 00 00 nop <== NOT EXECUTED } 2021520: 81 c7 e0 08 ret 2021524: 91 e8 00 08 restore %g0, %o0, %o0 0200708c : */ int pthread_mutex_destroy( pthread_mutex_t *mutex ) { 200708c: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007090: 80 a6 20 00 cmp %i0, 0 2007094: 02 80 00 0d be 20070c8 2007098: 82 10 20 02 mov 2, %g1 200709c: c2 06 00 00 ld [ %i0 ], %g1 20070a0: 80 a0 7f ff cmp %g1, -1 20070a4: 32 80 00 0c bne,a 20070d4 20070a8: d2 06 00 00 ld [ %i0 ], %o1 20070ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20070b0: 40 00 00 7e call 20072a8 <== NOT EXECUTED 20070b4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20070b8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20070bc: 22 80 00 06 be,a 20070d4 <== NOT EXECUTED 20070c0: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 20070c4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20070c8: a0 10 20 00 clr %l0 <== NOT EXECUTED 20070cc: 10 80 00 07 b 20070e8 <== NOT EXECUTED 20070d0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 20070d4: 11 00 80 6a sethi %hi(0x201a800), %o0 20070d8: 94 07 bf f4 add %fp, -12, %o2 20070dc: 40 00 0f 2b call 200ad88 <_Objects_Get> 20070e0: 90 12 21 64 or %o0, 0x164, %o0 20070e4: 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 ) { 20070e8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20070ec: 80 a0 60 00 cmp %g1, 0 20070f0: 22 80 00 06 be,a 2007108 20070f4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 20070f8: 80 a0 60 02 cmp %g1, 2 20070fc: 08 80 00 23 bleu 2007188 2007100: 90 10 20 16 mov 0x16, %o0 2007104: 30 80 00 1f b,a 2007180 <== 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 ) ) { 2007108: 80 a0 60 00 cmp %g1, 0 200710c: 12 80 00 06 bne 2007124 2007110: 03 00 80 6a sethi %hi(0x201a800), %g1 _Thread_Enable_dispatch(); 2007114: 7f ff ff d1 call 2007058 <_Thread_Enable_dispatch> 2007118: 01 00 00 00 nop 200711c: 10 80 00 1b b 2007188 2007120: 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 ); 2007124: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2007128: b0 10 61 64 or %g1, 0x164, %i0 200712c: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 2007130: 03 00 00 3f sethi %hi(0xfc00), %g1 2007134: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2007138: 82 08 c0 01 and %g3, %g1, %g1 200713c: 80 a0 40 02 cmp %g1, %g2 2007140: 18 80 00 05 bgu 2007154 2007144: 94 10 20 16 mov 0x16, %o2 information->local_table[ index ] = the_object; 2007148: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 200714c: 83 28 60 02 sll %g1, 2, %g1 2007150: c0 20 80 01 clr [ %g2 + %g1 ] return EBUSY; } _Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object ); _CORE_mutex_Flush( 2007154: 90 04 20 14 add %l0, 0x14, %o0 2007158: 92 10 20 00 clr %o1 200715c: 40 00 0b 20 call 2009ddc <_CORE_mutex_Flush> 2007160: 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 ); 2007164: 90 10 00 18 mov %i0, %o0 2007168: 40 00 0e c6 call 200ac80 <_Objects_Free> 200716c: 92 10 00 10 mov %l0, %o1 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 2007170: 7f ff ff ba call 2007058 <_Thread_Enable_dispatch> 2007174: 01 00 00 00 nop 2007178: 10 80 00 04 b 2007188 200717c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2007180: 40 00 04 9e call 20083f8 <== NOT EXECUTED 2007184: 01 00 00 00 nop <== NOT EXECUTED } 2007188: 81 c7 e0 08 ret 200718c: 91 e8 00 08 restore %g0, %o0, %o0 02007190 : int pthread_mutex_getprioceiling( pthread_mutex_t *mutex, int *prioceiling ) { 2007190: 9d e3 bf 90 save %sp, -112, %sp register POSIX_Mutex_Control *the_mutex; Objects_Locations location; if ( !prioceiling ) 2007194: 80 a6 60 00 cmp %i1, 0 2007198: 02 80 00 33 be 2007264 200719c: 80 a6 20 00 cmp %i0, 0 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 20071a0: 02 80 00 0d be 20071d4 20071a4: 82 10 20 02 mov 2, %g1 20071a8: c2 06 00 00 ld [ %i0 ], %g1 20071ac: 80 a0 7f ff cmp %g1, -1 20071b0: 32 80 00 0c bne,a 20071e0 20071b4: d2 06 00 00 ld [ %i0 ], %o1 20071b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20071bc: 40 00 00 3b call 20072a8 <== NOT EXECUTED 20071c0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20071c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20071c8: 22 80 00 06 be,a 20071e0 <== NOT EXECUTED 20071cc: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 20071d0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20071d4: 90 10 20 00 clr %o0 <== NOT EXECUTED 20071d8: 10 80 00 06 b 20071f0 <== NOT EXECUTED 20071dc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 20071e0: 11 00 80 6a sethi %hi(0x201a800), %o0 20071e4: 94 07 bf f4 add %fp, -12, %o2 20071e8: 40 00 0e e8 call 200ad88 <_Objects_Get> 20071ec: 90 12 21 64 or %o0, 0x164, %o0 return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 20071f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20071f4: 80 a0 60 00 cmp %g1, 0 20071f8: 22 80 00 07 be,a 2007214 20071fc: c4 02 20 60 ld [ %o0 + 0x60 ], %g2 2007200: 80 a0 60 02 cmp %g1, 2 2007204: 18 80 00 14 bgu 2007254 2007208: 90 10 20 16 mov 0x16, %o0 ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200720c: 81 c7 e0 08 ret 2007210: 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( 2007214: 82 10 20 ff mov 0xff, %g1 2007218: 82 20 40 02 sub %g1, %g2, %g1 200721c: 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 ) 2007220: 05 00 80 69 sethi %hi(0x201a400), %g2 2007224: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 ! 201a500 <_Thread_Dispatch_disable_level> 2007228: 90 10 20 00 clr %o0 200722c: 82 00 7f ff add %g1, -1, %g1 2007230: c2 20 a1 00 st %g1, [ %g2 + 0x100 ] 2007234: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 2007238: 80 a0 60 00 cmp %g1, 0 200723c: 32 80 00 0c bne,a 200726c 2007240: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2007244: 40 00 13 97 call 200c0a0 <_Thread_Dispatch> 2007248: 01 00 00 00 nop 200724c: 10 80 00 07 b 2007268 2007250: 90 10 20 00 clr %o0 ! 0 the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2007254: 40 00 04 69 call 20083f8 <== NOT EXECUTED 2007258: 01 00 00 00 nop <== NOT EXECUTED } 200725c: 81 c7 e0 08 ret <== NOT EXECUTED 2007260: 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(); 2007264: 90 10 20 16 mov 0x16, %o0 } 2007268: b0 10 00 08 mov %o0, %i0 200726c: 81 c7 e0 08 ret 2007270: 81 e8 00 00 restore 020072a8 : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 20072a8: 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; 20072ac: 03 00 80 61 sethi %hi(0x2018400), %g1 20072b0: 80 a6 60 00 cmp %i1, 0 20072b4: 02 80 00 03 be 20072c0 20072b8: a0 10 62 2c or %g1, 0x22c, %l0 20072bc: a0 10 00 19 mov %i1, %l0 else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 20072c0: 80 a6 20 00 cmp %i0, 0 20072c4: 22 80 00 2e be,a 200737c 20072c8: b0 10 20 16 mov 0x16, %i0 return EBUSY; } } #endif if ( !the_attr->is_initialized ) 20072cc: c2 04 00 00 ld [ %l0 ], %g1 20072d0: 80 a0 60 00 cmp %g1, 0 20072d4: 22 80 00 2a be,a 200737c 20072d8: b0 10 20 16 mov 0x16, %i0 /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 20072dc: c2 04 20 04 ld [ %l0 + 4 ], %g1 20072e0: 80 a0 60 00 cmp %g1, 0 20072e4: 22 80 00 09 be,a 2007308 20072e8: c2 04 20 0c ld [ %l0 + 0xc ], %g1 20072ec: 11 00 80 61 sethi %hi(0x2018400), %o0 <== NOT EXECUTED 20072f0: 15 00 80 61 sethi %hi(0x2018400), %o2 <== NOT EXECUTED 20072f4: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED 20072f8: 94 12 a2 88 or %o2, 0x288, %o2 <== NOT EXECUTED 20072fc: 7f ff f2 cd call 2003e30 <__assert> <== NOT EXECUTED 2007300: 92 10 20 64 mov 0x64, %o1 <== NOT EXECUTED /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 2007304: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED 2007308: 80 a0 60 01 cmp %g1, 1 200730c: 02 80 00 08 be 200732c 2007310: 80 a0 60 02 cmp %g1, 2 2007314: 02 80 00 08 be 2007334 2007318: 80 a0 60 00 cmp %g1, 0 200731c: 02 80 00 07 be 2007338 2007320: a2 10 20 00 clr %l1 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return 0; 2007324: 81 c7 e0 08 ret 2007328: 91 e8 20 16 restore %g0, 0x16, %o0 /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 200732c: 10 80 00 03 b 2007338 2007330: a2 10 20 02 mov 2, %l1 2007334: a2 10 20 03 mov 3, %l1 break; default: return EINVAL; } if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 2007338: c2 04 20 08 ld [ %l0 + 8 ], %g1 200733c: 82 00 7f ff add %g1, -1, %g1 2007340: 80 a0 60 fd cmp %g1, 0xfd 2007344: 38 80 00 0e bgu,a 200737c 2007348: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200734c: 03 00 80 69 sethi %hi(0x201a400), %g1 2007350: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 201a500 <_Thread_Dispatch_disable_level> 2007354: 84 00 a0 01 inc %g2 2007358: c4 20 61 00 st %g2, [ %g1 + 0x100 ] * _POSIX_Mutex_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void ) { return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information ); 200735c: 11 00 80 6a sethi %hi(0x201a800), %o0 2007360: 40 00 0d 46 call 200a878 <_Objects_Allocate> 2007364: 90 12 21 64 or %o0, 0x164, %o0 ! 201a964 <_POSIX_Mutex_Information> _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 2007368: b2 92 20 00 orcc %o0, 0, %i1 200736c: 32 80 00 06 bne,a 2007384 2007370: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Thread_Enable_dispatch(); 2007374: 7f ff ff c0 call 2007274 <_Thread_Enable_dispatch> 2007378: b0 10 20 0b mov 0xb, %i0 200737c: 81 c7 e0 08 ret 2007380: 81 e8 00 00 restore _Thread_Enable_dispatch(); return EAGAIN; } #endif the_mutex->process_shared = the_attr->process_shared; 2007384: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_mutex_attr = &the_mutex->Mutex.Attributes; if ( the_attr->recursive ) 2007388: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 200738c: 80 a0 60 00 cmp %g1, 0 2007390: 02 80 00 04 be 20073a0 2007394: 82 10 20 01 mov 1, %g1 the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 2007398: 10 80 00 03 b 20073a4 <== NOT EXECUTED 200739c: c0 26 60 54 clr [ %i1 + 0x54 ] <== NOT EXECUTED else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; 20073a0: c2 26 60 54 st %g1, [ %i1 + 0x54 ] the_mutex_attr->only_owner_release = TRUE; the_mutex_attr->priority_ceiling = 20073a4: 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; 20073a8: 82 10 20 01 mov 1, %g1 20073ac: c2 26 60 58 st %g1, [ %i1 + 0x58 ] the_mutex_attr->priority_ceiling = 20073b0: 82 10 20 ff mov 0xff, %g1 20073b4: 82 20 40 02 sub %g1, %g2, %g1 _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 20073b8: 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 = 20073bc: c2 26 60 60 st %g1, [ %i1 + 0x60 ] /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 20073c0: 90 06 60 14 add %i1, 0x14, %o0 20073c4: 92 06 60 54 add %i1, 0x54, %o1 20073c8: 40 00 0a 89 call 2009dec <_CORE_mutex_Initialize> 20073cc: 94 10 20 01 mov 1, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20073d0: 03 00 80 6a sethi %hi(0x201a800), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 20073d4: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20073d8: 88 10 61 64 or %g1, 0x164, %g4 20073dc: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 20073e0: 03 00 00 3f sethi %hi(0xfc00), %g1 20073e4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20073e8: 82 08 c0 01 and %g3, %g1, %g1 20073ec: 80 a0 40 02 cmp %g1, %g2 20073f0: 38 80 00 06 bgu,a 2007408 20073f4: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 20073f8: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 20073fc: 83 28 60 02 sll %g1, 2, %g1 2007400: 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; 2007404: 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; 2007408: c0 26 60 0c clr [ %i1 + 0xc ] 200740c: c2 26 00 00 st %g1, [ %i0 ] 0, /* Name not used */ 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 2007410: 7f ff ff 99 call 2007274 <_Thread_Enable_dispatch> 2007414: b0 10 20 00 clr %i0 2007418: 81 c7 e0 08 ret 200741c: 81 e8 00 00 restore return 0; } 2007420: 81 c7 e0 08 ret <== NOT EXECUTED 2007424: 81 e8 00 00 restore <== NOT EXECUTED 020076e0 : int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { 20076e0: 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 ) 20076e4: 80 a6 a0 00 cmp %i2, 0 20076e8: 02 80 00 3f be 20077e4 20076ec: 82 06 7f ff add %i1, -1, %g1 return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 20076f0: 80 a0 60 fd cmp %g1, 0xfd 20076f4: 18 80 00 3d bgu 20077e8 20076f8: a0 10 20 16 mov 0x16, %l0 /* * Must acquire the mutex before we can change it's ceiling */ status = pthread_mutex_lock( mutex ); 20076fc: 7f ff ff 4b call 2007428 2007700: 90 10 00 18 mov %i0, %o0 if ( status ) 2007704: a0 92 20 00 orcc %o0, 0, %l0 2007708: 12 80 00 38 bne 20077e8 200770c: 80 a6 20 00 cmp %i0, 0 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007710: 02 80 00 0d be 2007744 2007714: 82 10 20 02 mov 2, %g1 2007718: c2 06 00 00 ld [ %i0 ], %g1 200771c: 80 a0 7f ff cmp %g1, -1 2007720: 32 80 00 0c bne,a 2007750 2007724: d2 06 00 00 ld [ %i0 ], %o1 2007728: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200772c: 7f ff fe df call 20072a8 <== NOT EXECUTED 2007730: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007734: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007738: 22 80 00 06 be,a 2007750 <== NOT EXECUTED 200773c: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 2007740: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2007744: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007748: 10 80 00 06 b 2007760 <== NOT EXECUTED 200774c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 2007750: 11 00 80 6a sethi %hi(0x201a800), %o0 2007754: 94 07 bf f4 add %fp, -12, %o2 2007758: 40 00 0d 8c call 200ad88 <_Objects_Get> 200775c: 90 12 21 64 or %o0, 0x164, %o0 return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 2007760: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007764: 80 a0 60 00 cmp %g1, 0 2007768: 22 80 00 07 be,a 2007784 200776c: c6 02 20 60 ld [ %o0 + 0x60 ], %g3 2007770: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2007774: 18 80 00 18 bgu 20077d4 <== NOT EXECUTED 2007778: 01 00 00 00 nop <== NOT EXECUTED #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200777c: 10 80 00 1b b 20077e8 <== NOT EXECUTED 2007780: 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( 2007784: 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( 2007788: 82 10 20 ff mov 0xff, %g1 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 200778c: 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( 2007790: 82 20 40 03 sub %g1, %g3, %g1 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 2007794: 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( 2007798: c2 26 80 00 st %g1, [ %i2 ] the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( 200779c: 94 10 20 00 clr %o2 20077a0: 40 00 09 e3 call 2009f2c <_CORE_mutex_Surrender> 20077a4: 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 ) 20077a8: 05 00 80 69 sethi %hi(0x201a400), %g2 20077ac: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 ! 201a500 <_Thread_Dispatch_disable_level> 20077b0: 82 00 7f ff add %g1, -1, %g1 20077b4: c2 20 a1 00 st %g1, [ %g2 + 0x100 ] 20077b8: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 20077bc: 80 a0 60 00 cmp %g1, 0 20077c0: 12 80 00 0b bne 20077ec 20077c4: b0 10 00 10 mov %l0, %i0 _Thread_Dispatch(); 20077c8: 40 00 12 36 call 200c0a0 <_Thread_Dispatch> 20077cc: 01 00 00 00 nop 20077d0: 30 80 00 07 b,a 20077ec #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20077d4: 40 00 03 09 call 20083f8 <== NOT EXECUTED 20077d8: 01 00 00 00 nop <== NOT EXECUTED 20077dc: 10 80 00 03 b 20077e8 <== NOT EXECUTED 20077e0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 20077e4: a0 10 20 16 mov 0x16, %l0 } 20077e8: b0 10 00 10 mov %l0, %i0 20077ec: 81 c7 e0 08 ret 20077f0: 81 e8 00 00 restore 020077f4 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 20077f4: 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 ); 20077f8: 90 10 00 19 mov %i1, %o0 20077fc: 40 00 00 4b call 2007928 <_POSIX_Absolute_timeout_to_ticks> 2007800: 92 07 bf f4 add %fp, -12, %o1 switch ( status ) { 2007804: 80 a2 20 02 cmp %o0, 2 2007808: 28 80 00 07 bleu,a 2007824 200780c: b2 10 20 00 clr %i1 <== NOT EXECUTED 2007810: 80 a2 20 03 cmp %o0, 3 2007814: 22 80 00 04 be,a 2007824 2007818: b2 10 20 01 mov 1, %i1 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 200781c: 10 80 00 03 b 2007828 <== NOT EXECUTED 2007820: d4 07 bf f4 ld [ %fp + -12 ], %o2 <== NOT EXECUTED 2007824: d4 07 bf f4 ld [ %fp + -12 ], %o2 2007828: 90 10 00 18 mov %i0, %o0 200782c: 7f ff ff 05 call 2007440 <_POSIX_Mutex_Lock_support> 2007830: 92 10 00 19 mov %i1, %o1 break; } } return lock_status; } 2007834: 81 c7 e0 08 ret 2007838: 91 e8 00 08 restore %g0, %o0, %o0 02007854 : */ int pthread_mutex_unlock( pthread_mutex_t *mutex ) { 2007854: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007858: 80 a6 20 00 cmp %i0, 0 200785c: 02 80 00 0d be 2007890 2007860: 82 10 20 02 mov 2, %g1 2007864: c2 06 00 00 ld [ %i0 ], %g1 2007868: 80 a0 7f ff cmp %g1, -1 200786c: 32 80 00 0c bne,a 200789c 2007870: d2 06 00 00 ld [ %i0 ], %o1 2007874: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2007878: 7f ff fe 8c call 20072a8 <== NOT EXECUTED 200787c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007880: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007884: 22 80 00 06 be,a 200789c <== NOT EXECUTED 2007888: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 200788c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2007890: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007894: 10 80 00 06 b 20078ac <== NOT EXECUTED 2007898: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 200789c: 11 00 80 6a sethi %hi(0x201a800), %o0 20078a0: 94 07 bf f4 add %fp, -12, %o2 20078a4: 40 00 0d 39 call 200ad88 <_Objects_Get> 20078a8: 90 12 21 64 or %o0, 0x164, %o0 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 20078ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 20078b0: 80 a0 60 00 cmp %g1, 0 20078b4: 22 80 00 06 be,a 20078cc 20078b8: d2 02 20 08 ld [ %o0 + 8 ], %o1 20078bc: 80 a0 60 02 cmp %g1, 2 20078c0: 08 80 00 17 bleu 200791c 20078c4: 90 10 20 16 mov 0x16, %o0 20078c8: 30 80 00 13 b,a 2007914 <== NOT EXECUTED ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_mutex_Surrender( 20078cc: 94 10 20 00 clr %o2 20078d0: 40 00 09 97 call 2009f2c <_CORE_mutex_Surrender> 20078d4: 90 02 20 14 add %o0, 0x14, %o0 20078d8: 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 ) 20078dc: 03 00 80 69 sethi %hi(0x201a400), %g1 20078e0: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 201a500 <_Thread_Dispatch_disable_level> 20078e4: 84 00 bf ff add %g2, -1, %g2 20078e8: c4 20 61 00 st %g2, [ %g1 + 0x100 ] 20078ec: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 20078f0: 80 a0 60 00 cmp %g1, 0 20078f4: 12 80 00 04 bne 2007904 20078f8: 01 00 00 00 nop _Thread_Dispatch(); 20078fc: 40 00 11 e9 call 200c0a0 <_Thread_Dispatch> 2007900: 01 00 00 00 nop #else NULL #endif ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); 2007904: 40 00 1f a1 call 200f788 <_POSIX_Mutex_From_core_mutex_status> 2007908: 90 10 00 18 mov %i0, %o0 break; } return POSIX_BOTTOM_REACHED(); } 200790c: 81 c7 e0 08 ret 2007910: 91 e8 00 08 restore %g0, %o0, %o0 ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); break; } return POSIX_BOTTOM_REACHED(); 2007914: 40 00 02 b9 call 20083f8 <== NOT EXECUTED 2007918: 01 00 00 00 nop <== NOT EXECUTED } 200791c: b0 10 00 08 mov %o0, %i0 2007920: 81 c7 e0 08 ret 2007924: 81 e8 00 00 restore 02005da4 : */ int pthread_rwlock_destroy( pthread_rwlock_t *rwlock ) { 2005da4: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock = NULL; Objects_Locations location; if ( !rwlock ) 2005da8: 80 a6 20 00 cmp %i0, 0 2005dac: 02 80 00 2d be 2005e60 2005db0: 21 00 80 6e sethi %hi(0x201b800), %l0 RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get ( pthread_rwlock_t *RWLock, Objects_Locations *location ) { return (POSIX_RWLock_Control *) _Objects_Get( 2005db4: d2 06 00 00 ld [ %i0 ], %o1 2005db8: 94 07 bf f4 add %fp, -12, %o2 2005dbc: 40 00 0e f5 call 2009990 <_Objects_Get> 2005dc0: 90 14 20 7c or %l0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2005dc4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005dc8: 80 a0 60 00 cmp %g1, 0 2005dcc: 02 80 00 07 be 2005de8 2005dd0: b0 10 00 08 mov %o0, %i0 2005dd4: 80 a0 60 02 cmp %g1, 2 2005dd8: 18 80 00 1e bgu 2005e50 2005ddc: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2005de0: 81 c7 e0 08 ret 2005de4: 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 ) { 2005de8: 40 00 16 6d call 200b79c <_Thread_queue_First> 2005dec: 90 02 20 10 add %o0, 0x10, %o0 2005df0: 80 a2 20 00 cmp %o0, 0 2005df4: 22 80 00 06 be,a 2005e0c 2005df8: 90 14 20 7c or %l0, 0x7c, %o0 _Thread_Enable_dispatch(); 2005dfc: 7f ff ff dd call 2005d70 <_Thread_Enable_dispatch> 2005e00: 01 00 00 00 nop 2005e04: 10 80 00 18 b 2005e64 2005e08: 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 ); 2005e0c: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005e10: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005e14: 05 00 00 3f sethi %hi(0xfc00), %g2 2005e18: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2005e1c: 82 08 40 02 and %g1, %g2, %g1 2005e20: 80 a0 40 03 cmp %g1, %g3 2005e24: 18 80 00 05 bgu 2005e38 2005e28: 92 10 00 18 mov %i0, %o1 information->local_table[ index ] = the_object; 2005e2c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005e30: 83 28 60 02 sll %g1, 2, %g1 2005e34: 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 ); 2005e38: 40 00 0e 94 call 2009888 <_Objects_Free> 2005e3c: c0 26 20 0c clr [ %i0 + 0xc ] _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object ); _POSIX_RWLock_Free( the_rwlock ); _Thread_Enable_dispatch(); 2005e40: 7f ff ff cc call 2005d70 <_Thread_Enable_dispatch> 2005e44: 01 00 00 00 nop 2005e48: 10 80 00 07 b 2005e64 2005e4c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2005e50: 40 00 03 73 call 2006c1c <== NOT EXECUTED 2005e54: 01 00 00 00 nop <== NOT EXECUTED } 2005e58: 81 c7 e0 08 ret <== NOT EXECUTED 2005e5c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005e60: 90 10 20 16 mov 0x16, %o0 } 2005e64: b0 10 00 08 mov %o0, %i0 2005e68: 81 c7 e0 08 ret 2005e6c: 81 e8 00 00 restore 02005ea4 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 2005ea4: 9d e3 bf 88 save %sp, -120, %sp const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 2005ea8: 80 a6 20 00 cmp %i0, 0 2005eac: 02 80 00 32 be 2005f74 2005eb0: a0 10 00 19 mov %i1, %l0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 2005eb4: 80 a6 60 00 cmp %i1, 0 2005eb8: 32 80 00 06 bne,a 2005ed0 2005ebc: c2 04 00 00 ld [ %l0 ], %g1 the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 2005ec0: a0 07 bf ec add %fp, -20, %l0 <== NOT EXECUTED 2005ec4: 40 00 03 2c call 2006b74 <== NOT EXECUTED 2005ec8: 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 ) 2005ecc: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED 2005ed0: 80 a0 60 00 cmp %g1, 0 2005ed4: 02 80 00 28 be 2005f74 2005ed8: 01 00 00 00 nop return EINVAL; switch ( the_attr->process_shared ) { 2005edc: c2 04 20 04 ld [ %l0 + 4 ], %g1 2005ee0: 80 a0 60 00 cmp %g1, 0 2005ee4: 12 80 00 24 bne 2005f74 2005ee8: 05 00 80 6d sethi %hi(0x201b400), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005eec: c2 00 a1 e0 ld [ %g2 + 0x1e0 ], %g1 ! 201b5e0 <_Thread_Dispatch_disable_level> 2005ef0: 82 00 60 01 inc %g1 2005ef4: c2 20 a1 e0 st %g1, [ %g2 + 0x1e0 ] * 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 *) 2005ef8: 33 00 80 6e sethi %hi(0x201b800), %i1 2005efc: 40 00 0d 61 call 2009480 <_Objects_Allocate> 2005f00: 90 16 60 7c or %i1, 0x7c, %o0 ! 201b87c <_POSIX_RWLock_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 2005f04: a0 92 20 00 orcc %o0, 0, %l0 2005f08: 12 80 00 06 bne 2005f20 2005f0c: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); 2005f10: 7f ff ff d8 call 2005e70 <_Thread_Enable_dispatch> 2005f14: b0 10 20 0b mov 0xb, %i0 2005f18: 81 c7 e0 08 ret 2005f1c: 81 e8 00 00 restore return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 2005f20: 40 00 0a 94 call 2008970 <_CORE_RWLock_Initialize> 2005f24: 92 07 bf f4 add %fp, -12, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005f28: 90 16 60 7c or %i1, 0x7c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2005f2c: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005f30: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005f34: 05 00 00 3f sethi %hi(0xfc00), %g2 2005f38: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2005f3c: 82 08 40 02 and %g1, %g2, %g1 2005f40: 80 a0 40 03 cmp %g1, %g3 2005f44: 38 80 00 06 bgu,a 2005f5c 2005f48: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 2005f4c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005f50: 83 28 60 02 sll %g1, 2, %g1 2005f54: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 2005f58: 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; 2005f5c: c0 24 20 0c clr [ %l0 + 0xc ] 2005f60: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 2005f64: 7f ff ff c3 call 2005e70 <_Thread_Enable_dispatch> 2005f68: b0 10 20 00 clr %i0 2005f6c: 81 c7 e0 08 ret 2005f70: 81 e8 00 00 restore return 0; } 2005f74: 81 c7 e0 08 ret 2005f78: 91 e8 20 16 restore %g0, 0x16, %o0 02005f7c : */ int pthread_rwlock_rdlock( pthread_rwlock_t *rwlock ) { 2005f7c: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 2005f80: 80 a6 20 00 cmp %i0, 0 2005f84: 02 80 00 28 be 2006024 2005f88: 11 00 80 6e sethi %hi(0x201b800), %o0 RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get ( pthread_rwlock_t *RWLock, Objects_Locations *location ) { return (POSIX_RWLock_Control *) _Objects_Get( 2005f8c: d2 06 00 00 ld [ %i0 ], %o1 2005f90: 94 07 bf f4 add %fp, -12, %o2 2005f94: 40 00 0e 7f call 2009990 <_Objects_Get> 2005f98: 90 12 20 7c or %o0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2005f9c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005fa0: 80 a0 60 00 cmp %g1, 0 2005fa4: 22 80 00 07 be,a 2005fc0 2005fa8: d2 06 00 00 ld [ %i0 ], %o1 2005fac: 80 a0 60 02 cmp %g1, 2 2005fb0: 18 80 00 19 bgu 2006014 2005fb4: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2005fb8: 81 c7 e0 08 ret 2005fbc: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 2005fc0: 90 02 20 10 add %o0, 0x10, %o0 2005fc4: 94 10 20 01 mov 1, %o2 2005fc8: 96 10 20 00 clr %o3 2005fcc: 40 00 0a 74 call 200899c <_CORE_RWLock_Obtain_for_reading> 2005fd0: 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 ) 2005fd4: 03 00 80 6d sethi %hi(0x201b400), %g1 2005fd8: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 2005fdc: 84 00 bf ff add %g2, -1, %g2 2005fe0: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 2005fe4: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 2005fe8: 80 a0 60 00 cmp %g1, 0 2005fec: 12 80 00 05 bne 2006000 2005ff0: 03 00 80 6d sethi %hi(0x201b400), %g1 _Thread_Dispatch(); 2005ff4: 40 00 13 2d call 200aca8 <_Thread_Dispatch> 2005ff8: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 2005ffc: 03 00 80 6d sethi %hi(0x201b400), %g1 2006000: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 2006004: 40 00 00 9a call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006008: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 200600c: 81 c7 e0 08 ret 2006010: 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(); 2006014: 40 00 03 02 call 2006c1c <== NOT EXECUTED 2006018: 01 00 00 00 nop <== NOT EXECUTED } 200601c: 81 c7 e0 08 ret <== NOT EXECUTED 2006020: 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(); 2006024: 90 10 20 16 mov 0x16, %o0 } 2006028: b0 10 00 08 mov %o0, %i0 200602c: 81 c7 e0 08 ret 2006030: 81 e8 00 00 restore 02006034 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 2006034: 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 ) 2006038: 80 a6 20 00 cmp %i0, 0 200603c: 02 80 00 41 be 2006140 2006040: 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 ); 2006044: 40 00 21 84 call 200e654 <_POSIX_Absolute_timeout_to_ticks> 2006048: 92 07 bf f0 add %fp, -16, %o1 switch (status) { 200604c: 80 a2 20 02 cmp %o0, 2 2006050: 08 80 00 07 bleu 200606c 2006054: b2 10 00 08 mov %o0, %i1 2006058: 80 a2 20 03 cmp %o0, 3 200605c: 22 80 00 05 be,a 2006070 2006060: a0 10 20 01 mov 1, %l0 2006064: 10 80 00 04 b 2006074 <== NOT EXECUTED 2006068: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 200606c: a0 10 20 00 clr %l0 2006070: d2 06 00 00 ld [ %i0 ], %o1 2006074: 11 00 80 6e sethi %hi(0x201b800), %o0 2006078: 94 07 bf f4 add %fp, -12, %o2 200607c: 40 00 0e 45 call 2009990 <_Objects_Get> 2006080: 90 12 20 7c or %o0, 0x7c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2006084: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006088: 80 a0 60 00 cmp %g1, 0 200608c: 22 80 00 07 be,a 20060a8 2006090: d2 06 00 00 ld [ %i0 ], %o1 2006094: 80 a0 60 02 cmp %g1, 2 2006098: 18 80 00 26 bgu 2006130 200609c: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20060a0: 81 c7 e0 08 ret 20060a4: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 20060a8: d6 07 bf f0 ld [ %fp + -16 ], %o3 20060ac: 90 02 20 10 add %o0, 0x10, %o0 20060b0: 94 10 00 10 mov %l0, %o2 20060b4: 40 00 0a 3a call 200899c <_CORE_RWLock_Obtain_for_reading> 20060b8: 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 ) 20060bc: 03 00 80 6d sethi %hi(0x201b400), %g1 20060c0: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 20060c4: 84 00 bf ff add %g2, -1, %g2 20060c8: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20060cc: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 20060d0: 80 a0 60 00 cmp %g1, 0 20060d4: 12 80 00 05 bne 20060e8 20060d8: 80 a4 20 00 cmp %l0, 0 _Thread_Dispatch(); 20060dc: 40 00 12 f3 call 200aca8 <_Thread_Dispatch> 20060e0: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 20060e4: 80 a4 20 00 cmp %l0, 0 20060e8: 12 80 00 0c bne 2006118 20060ec: 03 00 80 6d sethi %hi(0x201b400), %g1 20060f0: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> <== NOT EXECUTED 20060f4: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 <== NOT EXECUTED 20060f8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20060fc: 12 80 00 07 bne 2006118 <== NOT EXECUTED 2006100: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 2006104: 02 80 00 10 be 2006144 <== NOT EXECUTED 2006108: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 200610c: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED 2006110: 08 80 00 0d bleu 2006144 <== NOT EXECUTED 2006114: 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( 2006118: 03 00 80 6d sethi %hi(0x201b400), %g1 200611c: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 2006120: 40 00 00 53 call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006124: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006128: 81 c7 e0 08 ret 200612c: 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(); 2006130: 40 00 02 bb call 2006c1c <== NOT EXECUTED 2006134: 01 00 00 00 nop <== NOT EXECUTED } 2006138: 81 c7 e0 08 ret <== NOT EXECUTED 200613c: 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(); 2006140: 90 10 20 16 mov 0x16, %o0 } 2006144: b0 10 00 08 mov %o0, %i0 2006148: 81 c7 e0 08 ret 200614c: 81 e8 00 00 restore 02006150 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 2006150: 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 ) 2006154: 80 a6 20 00 cmp %i0, 0 2006158: 02 80 00 41 be 200625c 200615c: 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 ); 2006160: 40 00 21 3d call 200e654 <_POSIX_Absolute_timeout_to_ticks> 2006164: 92 07 bf f0 add %fp, -16, %o1 switch (status) { 2006168: 80 a2 20 02 cmp %o0, 2 200616c: 08 80 00 07 bleu 2006188 2006170: b2 10 00 08 mov %o0, %i1 2006174: 80 a2 20 03 cmp %o0, 3 2006178: 22 80 00 05 be,a 200618c 200617c: a0 10 20 01 mov 1, %l0 2006180: 10 80 00 04 b 2006190 <== NOT EXECUTED 2006184: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 2006188: a0 10 20 00 clr %l0 200618c: d2 06 00 00 ld [ %i0 ], %o1 2006190: 11 00 80 6e sethi %hi(0x201b800), %o0 2006194: 94 07 bf f4 add %fp, -12, %o2 2006198: 40 00 0d fe call 2009990 <_Objects_Get> 200619c: 90 12 20 7c or %o0, 0x7c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20061a0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20061a4: 80 a0 60 00 cmp %g1, 0 20061a8: 22 80 00 07 be,a 20061c4 20061ac: d2 06 00 00 ld [ %i0 ], %o1 20061b0: 80 a0 60 02 cmp %g1, 2 20061b4: 18 80 00 26 bgu 200624c 20061b8: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20061bc: 81 c7 e0 08 ret 20061c0: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 20061c4: d6 07 bf f0 ld [ %fp + -16 ], %o3 20061c8: 90 02 20 10 add %o0, 0x10, %o0 20061cc: 94 10 00 10 mov %l0, %o2 20061d0: 40 00 0a 27 call 2008a6c <_CORE_RWLock_Obtain_for_writing> 20061d4: 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 ) 20061d8: 03 00 80 6d sethi %hi(0x201b400), %g1 20061dc: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 20061e0: 84 00 bf ff add %g2, -1, %g2 20061e4: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20061e8: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 20061ec: 80 a0 60 00 cmp %g1, 0 20061f0: 12 80 00 05 bne 2006204 20061f4: 80 a4 20 00 cmp %l0, 0 _Thread_Dispatch(); 20061f8: 40 00 12 ac call 200aca8 <_Thread_Dispatch> 20061fc: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 2006200: 80 a4 20 00 cmp %l0, 0 2006204: 12 80 00 0c bne 2006234 2006208: 03 00 80 6d sethi %hi(0x201b400), %g1 200620c: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> <== NOT EXECUTED 2006210: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 <== NOT EXECUTED 2006214: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2006218: 12 80 00 07 bne 2006234 <== NOT EXECUTED 200621c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 2006220: 02 80 00 10 be 2006260 <== NOT EXECUTED 2006224: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 2006228: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED 200622c: 08 80 00 0d bleu 2006260 <== NOT EXECUTED 2006230: 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( 2006234: 03 00 80 6d sethi %hi(0x201b400), %g1 2006238: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 200623c: 40 00 00 0c call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006240: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006244: 81 c7 e0 08 ret 2006248: 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(); 200624c: 40 00 02 74 call 2006c1c <== NOT EXECUTED 2006250: 01 00 00 00 nop <== NOT EXECUTED } 2006254: 81 c7 e0 08 ret <== NOT EXECUTED 2006258: 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(); 200625c: 90 10 20 16 mov 0x16, %o0 } 2006260: b0 10 00 08 mov %o0, %i0 2006264: 81 c7 e0 08 ret 2006268: 81 e8 00 00 restore 02006294 : */ int pthread_rwlock_tryrdlock( pthread_rwlock_t *rwlock ) { 2006294: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 2006298: 80 a6 20 00 cmp %i0, 0 200629c: 02 80 00 28 be 200633c 20062a0: 11 00 80 6e sethi %hi(0x201b800), %o0 20062a4: d2 06 00 00 ld [ %i0 ], %o1 20062a8: 94 07 bf f4 add %fp, -12, %o2 20062ac: 40 00 0d b9 call 2009990 <_Objects_Get> 20062b0: 90 12 20 7c or %o0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20062b4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20062b8: 80 a0 60 00 cmp %g1, 0 20062bc: 22 80 00 07 be,a 20062d8 20062c0: d2 06 00 00 ld [ %i0 ], %o1 20062c4: 80 a0 60 02 cmp %g1, 2 20062c8: 18 80 00 19 bgu 200632c 20062cc: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20062d0: 81 c7 e0 08 ret 20062d4: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 20062d8: 90 02 20 10 add %o0, 0x10, %o0 20062dc: 94 10 20 00 clr %o2 20062e0: 96 10 20 00 clr %o3 20062e4: 40 00 09 ae call 200899c <_CORE_RWLock_Obtain_for_reading> 20062e8: 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 ) 20062ec: 03 00 80 6d sethi %hi(0x201b400), %g1 20062f0: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 20062f4: 84 00 bf ff add %g2, -1, %g2 20062f8: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20062fc: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 2006300: 80 a0 60 00 cmp %g1, 0 2006304: 12 80 00 05 bne 2006318 2006308: 03 00 80 6d sethi %hi(0x201b400), %g1 _Thread_Dispatch(); 200630c: 40 00 12 67 call 200aca8 <_Thread_Dispatch> 2006310: 01 00 00 00 nop NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 2006314: 03 00 80 6d sethi %hi(0x201b400), %g1 2006318: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 200631c: 7f ff ff d4 call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006320: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006324: 81 c7 e0 08 ret 2006328: 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(); 200632c: 40 00 02 3c call 2006c1c <== NOT EXECUTED 2006330: 01 00 00 00 nop <== NOT EXECUTED } 2006334: 81 c7 e0 08 ret <== NOT EXECUTED 2006338: 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(); 200633c: 90 10 20 16 mov 0x16, %o0 } 2006340: b0 10 00 08 mov %o0, %i0 2006344: 81 c7 e0 08 ret 2006348: 81 e8 00 00 restore 0200634c : */ int pthread_rwlock_trywrlock( pthread_rwlock_t *rwlock ) { 200634c: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 2006350: 80 a6 20 00 cmp %i0, 0 2006354: 02 80 00 28 be 20063f4 2006358: 11 00 80 6e sethi %hi(0x201b800), %o0 200635c: d2 06 00 00 ld [ %i0 ], %o1 2006360: 94 07 bf f4 add %fp, -12, %o2 2006364: 40 00 0d 8b call 2009990 <_Objects_Get> 2006368: 90 12 20 7c or %o0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 200636c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006370: 80 a0 60 00 cmp %g1, 0 2006374: 22 80 00 07 be,a 2006390 2006378: d2 06 00 00 ld [ %i0 ], %o1 200637c: 80 a0 60 02 cmp %g1, 2 2006380: 18 80 00 19 bgu 20063e4 2006384: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006388: 81 c7 e0 08 ret 200638c: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 2006390: 90 02 20 10 add %o0, 0x10, %o0 2006394: 94 10 20 00 clr %o2 2006398: 96 10 20 00 clr %o3 200639c: 40 00 09 b4 call 2008a6c <_CORE_RWLock_Obtain_for_writing> 20063a0: 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 ) 20063a4: 03 00 80 6d sethi %hi(0x201b400), %g1 20063a8: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 20063ac: 84 00 bf ff add %g2, -1, %g2 20063b0: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20063b4: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 20063b8: 80 a0 60 00 cmp %g1, 0 20063bc: 12 80 00 05 bne 20063d0 20063c0: 03 00 80 6d sethi %hi(0x201b400), %g1 _Thread_Dispatch(); 20063c4: 40 00 12 39 call 200aca8 <_Thread_Dispatch> 20063c8: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 20063cc: 03 00 80 6d sethi %hi(0x201b400), %g1 20063d0: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 20063d4: 7f ff ff a6 call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 20063d8: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20063dc: 81 c7 e0 08 ret 20063e0: 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(); 20063e4: 40 00 02 0e call 2006c1c <== NOT EXECUTED 20063e8: 01 00 00 00 nop <== NOT EXECUTED } 20063ec: 81 c7 e0 08 ret <== NOT EXECUTED 20063f0: 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(); 20063f4: 90 10 20 16 mov 0x16, %o0 } 20063f8: b0 10 00 08 mov %o0, %i0 20063fc: 81 c7 e0 08 ret 2006400: 81 e8 00 00 restore 02006404 : */ int pthread_rwlock_unlock( pthread_rwlock_t *rwlock ) { 2006404: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; CORE_RWLock_Status status; if ( !rwlock ) 2006408: 80 a6 20 00 cmp %i0, 0 200640c: 02 80 00 23 be 2006498 2006410: 11 00 80 6e sethi %hi(0x201b800), %o0 2006414: d2 06 00 00 ld [ %i0 ], %o1 2006418: 94 07 bf f4 add %fp, -12, %o2 200641c: 40 00 0d 5d call 2009990 <_Objects_Get> 2006420: 90 12 20 7c or %o0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2006424: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006428: 80 a0 60 00 cmp %g1, 0 200642c: 02 80 00 06 be 2006444 2006430: 80 a0 60 02 cmp %g1, 2 2006434: 18 80 00 15 bgu 2006488 2006438: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); } return POSIX_BOTTOM_REACHED(); } 200643c: 81 c7 e0 08 ret 2006440: 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 ); 2006444: 40 00 09 ac call 2008af4 <_CORE_RWLock_Release> 2006448: 90 02 20 10 add %o0, 0x10, %o0 200644c: 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 ) 2006450: 03 00 80 6d sethi %hi(0x201b400), %g1 2006454: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 2006458: 84 00 bf ff add %g2, -1, %g2 200645c: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 2006460: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 2006464: 80 a0 60 00 cmp %g1, 0 2006468: 12 80 00 04 bne 2006478 200646c: 01 00 00 00 nop _Thread_Dispatch(); 2006470: 40 00 12 0e call 200aca8 <_Thread_Dispatch> 2006474: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); 2006478: 7f ff ff 7d call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 200647c: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 2006480: 81 c7 e0 08 ret 2006484: 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(); 2006488: 40 00 01 e5 call 2006c1c <== NOT EXECUTED 200648c: 01 00 00 00 nop <== NOT EXECUTED } 2006490: 81 c7 e0 08 ret <== NOT EXECUTED 2006494: 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(); 2006498: 90 10 20 16 mov 0x16, %o0 } 200649c: b0 10 00 08 mov %o0, %i0 20064a0: 81 c7 e0 08 ret 20064a4: 81 e8 00 00 restore 020064a8 : */ int pthread_rwlock_wrlock( pthread_rwlock_t *rwlock ) { 20064a8: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 20064ac: 80 a6 20 00 cmp %i0, 0 20064b0: 02 80 00 28 be 2006550 20064b4: 11 00 80 6e sethi %hi(0x201b800), %o0 20064b8: d2 06 00 00 ld [ %i0 ], %o1 20064bc: 94 07 bf f4 add %fp, -12, %o2 20064c0: 40 00 0d 34 call 2009990 <_Objects_Get> 20064c4: 90 12 20 7c or %o0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20064c8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20064cc: 80 a0 60 00 cmp %g1, 0 20064d0: 22 80 00 07 be,a 20064ec 20064d4: d2 06 00 00 ld [ %i0 ], %o1 20064d8: 80 a0 60 02 cmp %g1, 2 20064dc: 18 80 00 19 bgu 2006540 20064e0: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20064e4: 81 c7 e0 08 ret 20064e8: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 20064ec: 90 02 20 10 add %o0, 0x10, %o0 20064f0: 94 10 20 01 mov 1, %o2 20064f4: 96 10 20 00 clr %o3 20064f8: 40 00 09 5d call 2008a6c <_CORE_RWLock_Obtain_for_writing> 20064fc: 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 ) 2006500: 03 00 80 6d sethi %hi(0x201b400), %g1 2006504: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 2006508: 84 00 bf ff add %g2, -1, %g2 200650c: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 2006510: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 2006514: 80 a0 60 00 cmp %g1, 0 2006518: 12 80 00 05 bne 200652c 200651c: 03 00 80 6d sethi %hi(0x201b400), %g1 _Thread_Dispatch(); 2006520: 40 00 11 e2 call 200aca8 <_Thread_Dispatch> 2006524: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 2006528: 03 00 80 6d sethi %hi(0x201b400), %g1 200652c: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 2006530: 7f ff ff 4f call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006534: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006538: 81 c7 e0 08 ret 200653c: 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(); 2006540: 40 00 01 b7 call 2006c1c <== NOT EXECUTED 2006544: 01 00 00 00 nop <== NOT EXECUTED } 2006548: 81 c7 e0 08 ret <== NOT EXECUTED 200654c: 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(); 2006550: 90 10 20 16 mov 0x16, %o0 } 2006554: b0 10 00 08 mov %o0, %i0 2006558: 81 c7 e0 08 ret 200655c: 81 e8 00 00 restore 02005758 : int pthread_setcancelstate( int state, int *oldstate ) { 2005758: 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() ) 200575c: 03 00 80 5c sethi %hi(0x2017000), %g1 2005760: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 20172e8 <_ISR_Nest_level> int pthread_setcancelstate( int state, int *oldstate ) { 2005764: 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() ) 2005768: 80 a0 60 00 cmp %g1, 0 200576c: 12 80 00 28 bne 200580c 2005770: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldstate ) 2005774: 80 a6 60 00 cmp %i1, 0 2005778: 02 80 00 27 be 2005814 200577c: 80 a1 20 01 cmp %g4, 1 return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 2005780: 38 80 00 23 bgu,a 200580c 2005784: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005788: 07 00 80 5c sethi %hi(0x2017000), %g3 return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 200578c: 1b 00 80 5c sethi %hi(0x2017000), %o5 2005790: c2 00 e2 20 ld [ %g3 + 0x220 ], %g1 2005794: c4 03 63 00 ld [ %o5 + 0x300 ], %g2 2005798: 82 00 60 01 inc %g1 200579c: c4 00 a1 74 ld [ %g2 + 0x174 ], %g2 20057a0: c2 20 e2 20 st %g1, [ %g3 + 0x220 ] _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 20057a4: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 20057a8: 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; 20057ac: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 20057b0: 12 80 00 0c bne 20057e0 20057b4: c8 20 a0 cc st %g4, [ %g2 + 0xcc ] 20057b8: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 20057bc: 80 a0 60 01 cmp %g1, 1 20057c0: 12 80 00 08 bne 20057e0 20057c4: 01 00 00 00 nop 20057c8: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 <== NOT EXECUTED 20057cc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20057d0: 02 80 00 04 be 20057e0 <== NOT EXECUTED 20057d4: 01 00 00 00 nop <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 20057d8: 7f ff fe 09 call 2004ffc <_POSIX_Threads_cancel_run> <== NOT EXECUTED 20057dc: d0 03 63 00 ld [ %o5 + 0x300 ], %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 ) 20057e0: 03 00 80 5c sethi %hi(0x2017000), %g1 20057e4: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2017220 <_Thread_Dispatch_disable_level> 20057e8: b0 10 20 00 clr %i0 20057ec: 84 00 bf ff add %g2, -1, %g2 20057f0: c4 20 62 20 st %g2, [ %g1 + 0x220 ] 20057f4: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 20057f8: 80 a0 60 00 cmp %g1, 0 20057fc: 12 80 00 07 bne 2005818 2005800: 01 00 00 00 nop _Thread_Dispatch(); 2005804: 40 00 0f 97 call 2009660 <_Thread_Dispatch> 2005808: 01 00 00 00 nop 200580c: 81 c7 e0 08 ret 2005810: 81 e8 00 00 restore 2005814: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } 2005818: 81 c7 e0 08 ret <== NOT EXECUTED 200581c: 81 e8 00 00 restore <== NOT EXECUTED 02005820 : int pthread_setcanceltype( int type, int *oldtype ) { 2005820: 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() ) 2005824: 03 00 80 5c sethi %hi(0x2017000), %g1 2005828: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 20172e8 <_ISR_Nest_level> int pthread_setcanceltype( int type, int *oldtype ) { 200582c: 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() ) 2005830: 80 a0 60 00 cmp %g1, 0 2005834: 12 80 00 28 bne 20058d4 2005838: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldtype ) 200583c: 80 a6 60 00 cmp %i1, 0 2005840: 02 80 00 27 be 20058dc 2005844: 80 a1 20 01 cmp %g4, 1 return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 2005848: 38 80 00 23 bgu,a 20058d4 200584c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005850: 07 00 80 5c sethi %hi(0x2017000), %g3 return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2005854: 1b 00 80 5c sethi %hi(0x2017000), %o5 2005858: c2 00 e2 20 ld [ %g3 + 0x220 ], %g1 200585c: c4 03 63 00 ld [ %o5 + 0x300 ], %g2 2005860: 82 00 60 01 inc %g1 2005864: c4 00 a1 74 ld [ %g2 + 0x174 ], %g2 2005868: c2 20 e2 20 st %g1, [ %g3 + 0x220 ] _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 200586c: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 2005870: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_type = type; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2005874: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 2005878: 80 a0 60 00 cmp %g1, 0 200587c: 12 80 00 0b bne 20058a8 2005880: c8 20 a0 d0 st %g4, [ %g2 + 0xd0 ] 2005884: 80 a1 20 01 cmp %g4, 1 2005888: 12 80 00 08 bne 20058a8 200588c: 01 00 00 00 nop 2005890: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 2005894: 80 a0 60 00 cmp %g1, 0 2005898: 02 80 00 04 be 20058a8 200589c: 01 00 00 00 nop thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 20058a0: 7f ff fd d7 call 2004ffc <_POSIX_Threads_cancel_run> <== NOT EXECUTED 20058a4: d0 03 63 00 ld [ %o5 + 0x300 ], %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 ) 20058a8: 03 00 80 5c sethi %hi(0x2017000), %g1 20058ac: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2017220 <_Thread_Dispatch_disable_level> 20058b0: b0 10 20 00 clr %i0 20058b4: 84 00 bf ff add %g2, -1, %g2 20058b8: c4 20 62 20 st %g2, [ %g1 + 0x220 ] 20058bc: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 20058c0: 80 a0 60 00 cmp %g1, 0 20058c4: 12 80 00 07 bne 20058e0 20058c8: 01 00 00 00 nop _Thread_Dispatch(); 20058cc: 40 00 0f 65 call 2009660 <_Thread_Dispatch> 20058d0: 01 00 00 00 nop 20058d4: 81 c7 e0 08 ret 20058d8: 81 e8 00 00 restore 20058dc: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } 20058e0: 81 c7 e0 08 ret <== NOT EXECUTED 20058e4: 81 e8 00 00 restore <== NOT EXECUTED 020081d8 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 20081d8: 9d e3 bf 90 save %sp, -112, %sp /* * Check all the parameters */ if ( !param ) 20081dc: 80 a6 a0 00 cmp %i2, 0 20081e0: 02 80 00 70 be 20083a0 20081e4: 90 10 20 16 mov 0x16, %o0 return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 20081e8: c2 06 80 00 ld [ %i2 ], %g1 20081ec: 82 00 7f ff add %g1, -1, %g1 20081f0: 80 a0 60 fd cmp %g1, 0xfd 20081f4: 18 80 00 6b bgu 20083a0 20081f8: 80 a6 60 01 cmp %i1, 1 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 20081fc: 02 80 00 10 be 200823c 2008200: a2 10 20 00 clr %l1 2008204: 14 80 00 08 bg 2008224 2008208: 80 a6 60 02 cmp %i1, 2 200820c: 80 a6 60 00 cmp %i1, 0 2008210: a2 10 20 01 mov 1, %l1 2008214: 02 80 00 1b be 2008280 2008218: a4 10 20 00 clr %l2 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200821c: 81 c7 e0 08 ret 2008220: 91 e8 00 08 restore %g0, %o0, %o0 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 2008224: 02 80 00 05 be 2008238 2008228: 80 a6 60 03 cmp %i1, 3 200822c: 32 80 00 5d bne,a 20083a0 2008230: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 2008234: 30 80 00 04 b,a 2008244 2008238: a2 10 20 02 mov 2, %l1 200823c: 10 80 00 11 b 2008280 2008240: 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 ) < 2008244: 40 00 14 24 call 200d2d4 <_Timespec_To_ticks> 2008248: 90 06 a0 08 add %i2, 8, %o0 200824c: a0 10 00 08 mov %o0, %l0 2008250: 40 00 14 21 call 200d2d4 <_Timespec_To_ticks> 2008254: 90 06 a0 10 add %i2, 0x10, %o0 2008258: 80 a4 00 08 cmp %l0, %o0 200825c: 2a 80 00 51 bcs,a 20083a0 2008260: 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 ) ) 2008264: c2 06 a0 04 ld [ %i2 + 4 ], %g1 2008268: 82 00 7f ff add %g1, -1, %g1 200826c: 80 a0 60 fd cmp %g1, 0xfd 2008270: 18 80 00 4b bgu 200839c 2008274: 03 00 80 20 sethi %hi(0x2008000), %g1 2008278: a2 10 20 03 mov 3, %l1 200827c: a4 10 60 c8 or %g1, 0xc8, %l2 2008280: 92 10 00 18 mov %i0, %o1 2008284: 11 00 80 69 sethi %hi(0x201a400), %o0 2008288: 94 07 bf f4 add %fp, -12, %o2 200828c: 40 00 0a bf call 200ad88 <_Objects_Get> 2008290: 90 12 23 e8 or %o0, 0x3e8, %o0 /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2008294: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008298: 80 a0 60 00 cmp %g1, 0 200829c: 02 80 00 06 be 20082b4 20082a0: b0 10 00 08 mov %o0, %i0 20082a4: 80 a0 60 02 cmp %g1, 2 20082a8: 08 80 00 3e bleu 20083a0 20082ac: 90 10 20 03 mov 3, %o0 20082b0: 30 80 00 37 b,a 200838c <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 20082b4: e0 02 21 74 ld [ %o0 + 0x174 ], %l0 if ( api->schedpolicy == SCHED_SPORADIC ) 20082b8: c2 04 20 7c ld [ %l0 + 0x7c ], %g1 20082bc: 80 a0 60 03 cmp %g1, 3 20082c0: 32 80 00 05 bne,a 20082d4 20082c4: f2 24 20 7c st %i1, [ %l0 + 0x7c ] (void) _Watchdog_Remove( &api->Sporadic_timer ); 20082c8: 40 00 15 54 call 200d818 <_Watchdog_Remove> 20082cc: 90 04 20 9c add %l0, 0x9c, %o0 api->schedpolicy = policy; 20082d0: f2 24 20 7c st %i1, [ %l0 + 0x7c ] api->schedparam = *param; 20082d4: 92 10 00 1a mov %i2, %o1 20082d8: 90 04 20 80 add %l0, 0x80, %o0 20082dc: 40 00 27 4a call 2012004 20082e0: 94 10 20 18 mov 0x18, %o2 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 20082e4: 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; 20082e8: e2 26 20 88 st %l1, [ %i0 + 0x88 ] the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 20082ec: 80 a0 60 00 cmp %g1, 0 20082f0: 06 80 00 1a bl 2008358 20082f4: e4 26 20 8c st %l2, [ %i0 + 0x8c ] 20082f8: 80 a0 60 02 cmp %g1, 2 20082fc: 24 80 00 07 ble,a 2008318 2008300: c4 04 20 80 ld [ %l0 + 0x80 ], %g2 2008304: 80 a0 60 03 cmp %g1, 3 2008308: 12 80 00 14 bne 2008358 200830c: 01 00 00 00 nop TRUE ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 2008310: 10 80 00 0c b 2008340 2008314: 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; 2008318: 03 00 80 69 sethi %hi(0x201a400), %g1 200831c: c2 00 60 58 ld [ %g1 + 0x58 ], %g1 ! 201a458 <_Thread_Ticks_per_timeslice> the_thread->real_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 2008320: 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; 2008324: c2 26 20 84 st %g1, [ %i0 + 0x84 ] 2008328: 92 10 20 ff mov 0xff, %o1 the_thread->real_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 200832c: 94 10 20 01 mov 1, %o2 2008330: 92 22 40 02 sub %o1, %g2, %o1 2008334: 40 00 0e 1e call 200bbac <_Thread_Change_priority> 2008338: d2 26 20 18 st %o1, [ %i0 + 0x18 ] 200833c: 30 80 00 07 b,a 2008358 ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; _Watchdog_Remove( &api->Sporadic_timer ); 2008340: 90 04 20 9c add %l0, 0x9c, %o0 2008344: 40 00 15 35 call 200d818 <_Watchdog_Remove> 2008348: c2 24 20 98 st %g1, [ %l0 + 0x98 ] _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 200834c: 92 10 00 18 mov %i0, %o1 2008350: 7f ff ff 72 call 2008118 <_POSIX_Threads_Sporadic_budget_TSR> 2008354: 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 ) 2008358: 03 00 80 69 sethi %hi(0x201a400), %g1 200835c: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 201a500 <_Thread_Dispatch_disable_level> 2008360: 90 10 20 00 clr %o0 2008364: 84 00 bf ff add %g2, -1, %g2 2008368: c4 20 61 00 st %g2, [ %g1 + 0x100 ] 200836c: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 2008370: 80 a0 60 00 cmp %g1, 0 2008374: 32 80 00 0c bne,a 20083a4 2008378: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 200837c: 40 00 0f 49 call 200c0a0 <_Thread_Dispatch> 2008380: 01 00 00 00 nop 2008384: 10 80 00 07 b 20083a0 2008388: 90 10 20 00 clr %o0 ! 0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200838c: 40 00 00 1b call 20083f8 <== NOT EXECUTED 2008390: 01 00 00 00 nop <== NOT EXECUTED } 2008394: 81 c7 e0 08 ret <== NOT EXECUTED 2008398: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200839c: 90 10 20 16 mov 0x16, %o0 } 20083a0: b0 10 00 08 mov %o0, %i0 20083a4: 81 c7 e0 08 ret 20083a8: 81 e8 00 00 restore 0200583c : int pthread_setspecific( pthread_key_t key, const void *value ) { 200583c: 9d e3 bf 90 save %sp, -112, %sp 2005840: 11 00 80 5d sethi %hi(0x2017400), %o0 2005844: 92 10 00 18 mov %i0, %o1 2005848: 90 12 22 f0 or %o0, 0x2f0, %o0 200584c: 40 00 0c 7b call 2008a38 <_Objects_Get> 2005850: 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 ) { 2005854: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005858: 80 a0 60 00 cmp %g1, 0 200585c: 22 80 00 06 be,a 2005874 2005860: 03 00 80 5c sethi %hi(0x2017000), %g1 2005864: 80 a0 60 02 cmp %g1, 2 2005868: 08 80 00 1d bleu 20058dc 200586c: 90 10 20 16 mov 0x16, %o0 2005870: 30 80 00 19 b,a 20058d4 <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never happen */ return EINVAL; case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 2005874: c2 00 62 d0 ld [ %g1 + 0x2d0 ], %g1 2005878: c4 00 60 08 ld [ %g1 + 8 ], %g2 index = _Objects_Get_index( _Thread_Executing->Object.id ); the_key->Values[ api ][ index ] = (void *) value; 200587c: 83 30 a0 16 srl %g2, 0x16, %g1 2005880: 82 08 60 1c and %g1, 0x1c, %g1 2005884: 82 00 40 08 add %g1, %o0, %g1 2005888: c6 00 60 18 ld [ %g1 + 0x18 ], %g3 200588c: 03 00 00 3f sethi %hi(0xfc00), %g1 2005890: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005894: 84 08 80 01 and %g2, %g1, %g2 2005898: 85 28 a0 02 sll %g2, 2, %g2 200589c: 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 ) 20058a0: 05 00 80 5c sethi %hi(0x2017000), %g2 20058a4: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20171f0 <_Thread_Dispatch_disable_level> 20058a8: 90 10 20 00 clr %o0 20058ac: 82 00 7f ff add %g1, -1, %g1 20058b0: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 20058b4: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 20058b8: 80 a0 60 00 cmp %g1, 0 20058bc: 12 80 00 08 bne 20058dc 20058c0: 01 00 00 00 nop _Thread_Dispatch(); 20058c4: 40 00 11 23 call 2009d50 <_Thread_Dispatch> 20058c8: 01 00 00 00 nop 20058cc: 10 80 00 04 b 20058dc 20058d0: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20058d4: 40 00 01 f5 call 20060a8 <== NOT EXECUTED 20058d8: 01 00 00 00 nop <== NOT EXECUTED } 20058dc: 81 c7 e0 08 ret 20058e0: 91 e8 00 08 restore %g0, %o0, %o0 020054e8 : */ int pthread_spin_destroy( pthread_spinlock_t *spinlock ) { 20054e8: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; if ( !spinlock ) 20054ec: 80 a6 20 00 cmp %i0, 0 20054f0: 02 80 00 2c be 20055a0 20054f4: 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( 20054f8: d2 06 00 00 ld [ %i0 ], %o1 20054fc: 31 00 80 52 sethi %hi(0x2014800), %i0 2005500: 40 00 0b d9 call 2008464 <_Objects_Get> 2005504: 90 16 21 14 or %i0, 0x114, %o0 ! 2014914 <_POSIX_Spinlock_Information> return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 2005508: c2 07 bf f4 ld [ %fp + -12 ], %g1 200550c: 80 a0 60 00 cmp %g1, 0 2005510: 02 80 00 07 be 200552c 2005514: 88 10 00 08 mov %o0, %g4 2005518: 80 a0 60 02 cmp %g1, 2 200551c: 18 80 00 1d bgu 2005590 2005520: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2005524: 81 c7 e0 08 ret 2005528: 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); 200552c: 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 ) ) { 2005530: 80 a0 60 00 cmp %g1, 0 2005534: 22 80 00 06 be,a 200554c 2005538: 90 16 21 14 or %i0, 0x114, %o0 _Thread_Enable_dispatch(); 200553c: 7f ff ff de call 20054b4 <_Thread_Enable_dispatch> 2005540: 01 00 00 00 nop 2005544: 10 80 00 18 b 20055a4 2005548: 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 ); 200554c: c2 01 20 08 ld [ %g4 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005550: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005554: 05 00 00 3f sethi %hi(0xfc00), %g2 2005558: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200555c: 82 08 40 02 and %g1, %g2, %g1 2005560: 80 a0 40 03 cmp %g1, %g3 2005564: 18 80 00 05 bgu 2005578 2005568: 92 10 00 04 mov %g4, %o1 information->local_table[ index ] = the_object; 200556c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005570: 83 28 60 02 sll %g1, 2, %g1 2005574: 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 ); 2005578: 40 00 0b 79 call 200835c <_Objects_Free> 200557c: c0 21 20 0c clr [ %g4 + 0xc ] _Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object ); _POSIX_Spinlock_Free( the_spinlock ); _Thread_Enable_dispatch(); 2005580: 7f ff ff cd call 20054b4 <_Thread_Enable_dispatch> 2005584: 01 00 00 00 nop 2005588: 10 80 00 07 b 20055a4 200558c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2005590: 40 00 00 db call 20058fc <== NOT EXECUTED 2005594: 01 00 00 00 nop <== NOT EXECUTED } 2005598: 81 c7 e0 08 ret <== NOT EXECUTED 200559c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20055a0: 90 10 20 16 mov 0x16, %o0 } 20055a4: b0 10 00 08 mov %o0, %i0 20055a8: 81 c7 e0 08 ret 20055ac: 81 e8 00 00 restore 020055e4 : int pthread_spin_init( pthread_spinlock_t *spinlock, int pshared ) { 20055e4: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock; CORE_spinlock_Attributes attributes; if ( !spinlock ) 20055e8: 80 a6 20 00 cmp %i0, 0 20055ec: 02 80 00 26 be 2005684 20055f0: 80 a6 60 00 cmp %i1, 0 return EINVAL; switch ( pshared ) { 20055f4: 12 80 00 24 bne 2005684 20055f8: 05 00 80 51 sethi %hi(0x2014400), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20055fc: c2 00 a1 e0 ld [ %g2 + 0x1e0 ], %g1 ! 20145e0 <_Thread_Dispatch_disable_level> 2005600: 82 00 60 01 inc %g1 2005604: c2 20 a1 e0 st %g1, [ %g2 + 0x1e0 ] * 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 *) 2005608: 21 00 80 52 sethi %hi(0x2014800), %l0 200560c: 40 00 0a 52 call 2007f54 <_Objects_Allocate> 2005610: 90 14 21 14 or %l0, 0x114, %o0 ! 2014914 <_POSIX_Spinlock_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_spinlock = _POSIX_Spinlock_Allocate(); if ( !the_spinlock ) { 2005614: b2 92 20 00 orcc %o0, 0, %i1 2005618: 12 80 00 06 bne 2005630 200561c: 90 06 60 10 add %i1, 0x10, %o0 _Thread_Enable_dispatch(); 2005620: 7f ff ff e4 call 20055b0 <_Thread_Enable_dispatch> 2005624: b0 10 20 0b mov 0xb, %i0 2005628: 81 c7 e0 08 ret 200562c: 81 e8 00 00 restore return EAGAIN; } _CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes ); 2005630: 40 00 08 30 call 20076f0 <_CORE_spinlock_Initialize> 2005634: 92 07 bf f4 add %fp, -12, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005638: 90 14 21 14 or %l0, 0x114, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200563c: c2 06 60 08 ld [ %i1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005640: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005644: 05 00 00 3f sethi %hi(0xfc00), %g2 2005648: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200564c: 82 08 40 02 and %g1, %g2, %g1 2005650: 80 a0 40 03 cmp %g1, %g3 2005654: 38 80 00 06 bgu,a 200566c 2005658: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200565c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005660: 83 28 60 02 sll %g1, 2, %g1 2005664: f2 20 80 01 st %i1, [ %g2 + %g1 ] &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 ); *spinlock = the_spinlock->Object.id; 2005668: 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; 200566c: c0 26 60 0c clr [ %i1 + 0xc ] 2005670: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 2005674: 7f ff ff cf call 20055b0 <_Thread_Enable_dispatch> 2005678: b0 10 20 00 clr %i0 200567c: 81 c7 e0 08 ret 2005680: 81 e8 00 00 restore return 0; } 2005684: 81 c7 e0 08 ret 2005688: 91 e8 20 16 restore %g0, 0x16, %o0 0200568c : */ int pthread_spin_lock( pthread_spinlock_t *spinlock ) { 200568c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 2005690: 80 a6 20 00 cmp %i0, 0 2005694: 02 80 00 25 be 2005728 2005698: 11 00 80 52 sethi %hi(0x2014800), %o0 RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get ( pthread_spinlock_t *spinlock, Objects_Locations *location ) { return (POSIX_Spinlock_Control *) _Objects_Get( 200569c: d2 06 00 00 ld [ %i0 ], %o1 20056a0: 94 07 bf f4 add %fp, -12, %o2 20056a4: 40 00 0b 70 call 2008464 <_Objects_Get> 20056a8: 90 12 21 14 or %o0, 0x114, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 20056ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 20056b0: 80 a0 60 00 cmp %g1, 0 20056b4: 02 80 00 07 be 20056d0 20056b8: 92 10 20 01 mov 1, %o1 20056bc: 80 a0 60 02 cmp %g1, 2 20056c0: 18 80 00 16 bgu 2005718 20056c4: 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(); } 20056c8: 81 c7 e0 08 ret 20056cc: 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 ); 20056d0: 94 10 20 00 clr %o2 20056d4: 40 00 08 2c call 2007784 <_CORE_spinlock_Wait> 20056d8: 90 02 20 10 add %o0, 0x10, %o0 20056dc: 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 ) 20056e0: 03 00 80 51 sethi %hi(0x2014400), %g1 20056e4: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 20145e0 <_Thread_Dispatch_disable_level> 20056e8: 84 00 bf ff add %g2, -1, %g2 20056ec: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20056f0: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 20056f4: 80 a0 60 00 cmp %g1, 0 20056f8: 12 80 00 04 bne 2005708 20056fc: 01 00 00 00 nop _Thread_Dispatch(); 2005700: 40 00 10 1f call 200977c <_Thread_Dispatch> 2005704: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 2005708: 40 00 00 0c call 2005738 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 200570c: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 2005710: 81 c7 e0 08 ret 2005714: 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(); 2005718: 40 00 00 79 call 20058fc <== NOT EXECUTED 200571c: 01 00 00 00 nop <== NOT EXECUTED } 2005720: 81 c7 e0 08 ret <== NOT EXECUTED 2005724: 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(); 2005728: 90 10 20 16 mov 0x16, %o0 } 200572c: b0 10 00 08 mov %o0, %i0 2005730: 81 c7 e0 08 ret 2005734: 81 e8 00 00 restore 02005760 : */ int pthread_spin_trylock( pthread_spinlock_t *spinlock ) { 2005760: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 2005764: 80 a6 20 00 cmp %i0, 0 2005768: 02 80 00 25 be 20057fc 200576c: 11 00 80 52 sethi %hi(0x2014800), %o0 2005770: d2 06 00 00 ld [ %i0 ], %o1 2005774: 94 07 bf f4 add %fp, -12, %o2 2005778: 40 00 0b 3b call 2008464 <_Objects_Get> 200577c: 90 12 21 14 or %o0, 0x114, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 2005780: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005784: 80 a0 60 00 cmp %g1, 0 2005788: 02 80 00 07 be 20057a4 200578c: 92 10 20 00 clr %o1 2005790: 80 a0 60 02 cmp %g1, 2 2005794: 18 80 00 16 bgu 20057ec 2005798: 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(); } 200579c: 81 c7 e0 08 ret 20057a0: 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 ); 20057a4: 94 10 20 00 clr %o2 20057a8: 40 00 07 f7 call 2007784 <_CORE_spinlock_Wait> 20057ac: 90 02 20 10 add %o0, 0x10, %o0 20057b0: 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 ) 20057b4: 03 00 80 51 sethi %hi(0x2014400), %g1 20057b8: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 20145e0 <_Thread_Dispatch_disable_level> 20057bc: 84 00 bf ff add %g2, -1, %g2 20057c0: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20057c4: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 20057c8: 80 a0 60 00 cmp %g1, 0 20057cc: 12 80 00 04 bne 20057dc 20057d0: 01 00 00 00 nop _Thread_Dispatch(); 20057d4: 40 00 0f ea call 200977c <_Thread_Dispatch> 20057d8: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 20057dc: 7f ff ff d7 call 2005738 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 20057e0: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 20057e4: 81 c7 e0 08 ret 20057e8: 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(); 20057ec: 40 00 00 44 call 20058fc <== NOT EXECUTED 20057f0: 01 00 00 00 nop <== NOT EXECUTED } 20057f4: 81 c7 e0 08 ret <== NOT EXECUTED 20057f8: 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(); 20057fc: 90 10 20 16 mov 0x16, %o0 } 2005800: b0 10 00 08 mov %o0, %i0 2005804: 81 c7 e0 08 ret 2005808: 81 e8 00 00 restore 0200580c : */ int pthread_spin_unlock( pthread_spinlock_t *spinlock ) { 200580c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 2005810: 80 a6 20 00 cmp %i0, 0 2005814: 02 80 00 23 be 20058a0 2005818: 11 00 80 52 sethi %hi(0x2014800), %o0 200581c: d2 06 00 00 ld [ %i0 ], %o1 2005820: 94 07 bf f4 add %fp, -12, %o2 2005824: 40 00 0b 10 call 2008464 <_Objects_Get> 2005828: 90 12 21 14 or %o0, 0x114, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 200582c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005830: 80 a0 60 00 cmp %g1, 0 2005834: 02 80 00 06 be 200584c 2005838: 80 a0 60 02 cmp %g1, 2 200583c: 18 80 00 15 bgu 2005890 2005840: 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(); } 2005844: 81 c7 e0 08 ret 2005848: 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 ); 200584c: 40 00 07 b0 call 200770c <_CORE_spinlock_Release> 2005850: 90 02 20 10 add %o0, 0x10, %o0 2005854: 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 ) 2005858: 03 00 80 51 sethi %hi(0x2014400), %g1 200585c: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 20145e0 <_Thread_Dispatch_disable_level> 2005860: 84 00 bf ff add %g2, -1, %g2 2005864: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 2005868: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 200586c: 80 a0 60 00 cmp %g1, 0 2005870: 12 80 00 04 bne 2005880 2005874: 01 00 00 00 nop _Thread_Dispatch(); 2005878: 40 00 0f c1 call 200977c <_Thread_Dispatch> 200587c: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 2005880: 7f ff ff ae call 2005738 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 2005884: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 2005888: 81 c7 e0 08 ret 200588c: 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(); 2005890: 40 00 00 1b call 20058fc <== NOT EXECUTED 2005894: 01 00 00 00 nop <== NOT EXECUTED } 2005898: 81 c7 e0 08 ret <== NOT EXECUTED 200589c: 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(); 20058a0: 90 10 20 16 mov 0x16, %o0 } 20058a4: b0 10 00 08 mov %o0, %i0 20058a8: 81 c7 e0 08 ret 20058ac: 81 e8 00 00 restore 0200590c : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 200590c: 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() ) 2005910: 03 00 80 5c sethi %hi(0x2017000), %g1 2005914: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 20172e8 <_ISR_Nest_level> 2005918: 80 a0 60 00 cmp %g1, 0 200591c: 12 80 00 1c bne 200598c 2005920: 07 00 80 5c sethi %hi(0x2017000), %g3 return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2005924: 09 00 80 5c sethi %hi(0x2017000), %g4 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005928: c2 00 e2 20 ld [ %g3 + 0x220 ], %g1 200592c: c4 01 23 00 ld [ %g4 + 0x300 ], %g2 2005930: 82 00 60 01 inc %g1 2005934: c4 00 a1 74 ld [ %g2 + 0x174 ], %g2 2005938: c2 20 e2 20 st %g1, [ %g3 + 0x220 ] _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 200593c: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 2005940: 80 a0 60 00 cmp %g1, 0 2005944: 12 80 00 08 bne 2005964 2005948: 01 00 00 00 nop 200594c: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 2005950: 80 a0 60 00 cmp %g1, 0 2005954: 02 80 00 04 be 2005964 2005958: 01 00 00 00 nop thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 200595c: 7f ff fd a8 call 2004ffc <_POSIX_Threads_cancel_run> 2005960: d0 01 23 00 ld [ %g4 + 0x300 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005964: 03 00 80 5c sethi %hi(0x2017000), %g1 2005968: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2017220 <_Thread_Dispatch_disable_level> 200596c: 84 00 bf ff add %g2, -1, %g2 2005970: c4 20 62 20 st %g2, [ %g1 + 0x220 ] 2005974: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 2005978: 80 a0 60 00 cmp %g1, 0 200597c: 12 80 00 04 bne 200598c 2005980: 01 00 00 00 nop _Thread_Dispatch(); 2005984: 40 00 0f 37 call 2009660 <_Thread_Dispatch> 2005988: 81 e8 00 00 restore 200598c: 81 c7 e0 08 ret <== NOT EXECUTED 2005990: 81 e8 00 00 restore <== NOT EXECUTED 02005d58 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 2005d58: 9d e3 bf 90 save %sp, -112, %sp Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 2005d5c: a2 96 20 00 orcc %i0, 0, %l1 2005d60: 02 80 00 1b be 2005dcc 2005d64: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2005d68: 80 a6 e0 00 cmp %i3, 0 2005d6c: 02 80 00 18 be 2005dcc 2005d70: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 2005d74: 80 8e 60 10 btst 0x10, %i1 2005d78: 02 80 00 06 be 2005d90 2005d7c: 80 a6 a0 00 cmp %i2, 0 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 2005d80: 02 80 00 13 be 2005dcc 2005d84: 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; 2005d88: 10 80 00 04 b 2005d98 2005d8c: c0 27 bf f0 clr [ %fp + -16 ] if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 2005d90: 82 10 20 01 mov 1, %g1 2005d94: c2 27 bf f0 st %g1, [ %fp + -16 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005d98: 05 00 80 74 sethi %hi(0x201d000), %g2 2005d9c: c2 00 a1 10 ld [ %g2 + 0x110 ], %g1 ! 201d110 <_Thread_Dispatch_disable_level> the_attributes.maximum_count = maximum_waiters; 2005da0: f4 27 bf f4 st %i2, [ %fp + -12 ] 2005da4: 82 00 60 01 inc %g1 2005da8: 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 Barrier_Control *_Barrier_Allocate( void ) { return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information ); 2005dac: 21 00 80 73 sethi %hi(0x201cc00), %l0 2005db0: 40 00 09 fb call 200859c <_Objects_Allocate> 2005db4: 90 14 23 70 or %l0, 0x370, %o0 ! 201cf70 <_Barrier_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 2005db8: b4 92 20 00 orcc %o0, 0, %i2 2005dbc: 12 80 00 06 bne 2005dd4 2005dc0: 90 06 a0 14 add %i2, 0x14, %o0 _Thread_Enable_dispatch(); 2005dc4: 7f ff ff d8 call 2005d24 <_Thread_Enable_dispatch> 2005dc8: b0 10 20 05 mov 5, %i0 2005dcc: 81 c7 e0 08 ret 2005dd0: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 2005dd4: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 2005dd8: 40 00 07 3d call 2007acc <_CORE_barrier_Initialize> 2005ddc: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005de0: 90 14 23 70 or %l0, 0x370, %o0 Objects_Name name ) { uint32_t index; index = _Objects_Get_index( the_object->id ); 2005de4: c6 06 a0 08 ld [ %i2 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005de8: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2005dec: 03 00 00 3f sethi %hi(0xfc00), %g1 2005df0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005df4: 82 08 c0 01 and %g3, %g1, %g1 2005df8: 80 a0 40 02 cmp %g1, %g2 2005dfc: 38 80 00 06 bgu,a 2005e14 2005e00: e2 26 a0 0c st %l1, [ %i2 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005e04: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005e08: 83 28 60 02 sll %g1, 2, %g1 2005e0c: 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; 2005e10: e2 26 a0 0c st %l1, [ %i2 + 0xc ] &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 2005e14: c6 26 c0 00 st %g3, [ %i3 ] _Thread_Enable_dispatch(); 2005e18: 7f ff ff c3 call 2005d24 <_Thread_Enable_dispatch> 2005e1c: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 2005e20: 81 c7 e0 08 ret 2005e24: 81 e8 00 00 restore 02005e28 : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 2005e28: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 2005e2c: 21 00 80 73 sethi %hi(0x201cc00), %l0 2005e30: 92 10 00 18 mov %i0, %o1 2005e34: 94 07 bf f4 add %fp, -12, %o2 2005e38: 40 00 0b 1d call 2008aac <_Objects_Get> 2005e3c: 90 14 23 70 or %l0, 0x370, %o0 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2005e40: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005e44: 80 a0 60 00 cmp %g1, 0 2005e48: 02 80 00 07 be 2005e64 2005e4c: b0 10 00 08 mov %o0, %i0 2005e50: 80 a0 60 02 cmp %g1, 2 2005e54: 08 80 00 22 bleu 2005edc 2005e58: b0 10 20 04 mov 4, %i0 2005e5c: 81 c7 e0 08 ret <== NOT EXECUTED 2005e60: 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( 2005e64: 90 02 20 14 add %o0, 0x14, %o0 2005e68: 92 10 20 00 clr %o1 2005e6c: 40 00 12 8b call 200a898 <_Thread_queue_Flush> 2005e70: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005e74: 90 14 23 70 or %l0, 0x370, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2005e78: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005e7c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005e80: 05 00 00 3f sethi %hi(0xfc00), %g2 2005e84: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2005e88: 82 08 40 02 and %g1, %g2, %g1 2005e8c: 80 a0 40 03 cmp %g1, %g3 2005e90: 38 80 00 06 bgu,a 2005ea8 2005e94: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005e98: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005e9c: 83 28 60 02 sll %g1, 2, %g1 2005ea0: 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; 2005ea4: c0 26 20 0c clr [ %i0 + 0xc ] */ RTEMS_INLINE_ROUTINE void _Barrier_Free ( Barrier_Control *the_barrier ) { _Objects_Free( &_Barrier_Information, &the_barrier->Object ); 2005ea8: 40 00 0a bf call 20089a4 <_Objects_Free> 2005eac: 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 ) 2005eb0: 03 00 80 74 sethi %hi(0x201d000), %g1 2005eb4: c4 00 61 10 ld [ %g1 + 0x110 ], %g2 ! 201d110 <_Thread_Dispatch_disable_level> 2005eb8: b0 10 20 00 clr %i0 2005ebc: 84 00 bf ff add %g2, -1, %g2 2005ec0: c4 20 61 10 st %g2, [ %g1 + 0x110 ] 2005ec4: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 2005ec8: 80 a0 60 00 cmp %g1, 0 2005ecc: 12 80 00 04 bne 2005edc 2005ed0: 01 00 00 00 nop _Thread_Dispatch(); 2005ed4: 40 00 0f fb call 2009ec0 <_Thread_Dispatch> 2005ed8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005edc: 81 c7 e0 08 ret 2005ee0: 81 e8 00 00 restore 02005f1c : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 2005f1c: 9d e3 bf 90 save %sp, -112, %sp 2005f20: a0 10 00 18 mov %i0, %l0 Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 2005f24: 80 a6 60 00 cmp %i1, 0 2005f28: 02 80 00 1f be 2005fa4 2005f2c: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 2005f30: 11 00 80 73 sethi %hi(0x201cc00), %o0 2005f34: 92 10 00 10 mov %l0, %o1 2005f38: 90 12 23 70 or %o0, 0x370, %o0 2005f3c: 40 00 0a dc call 2008aac <_Objects_Get> 2005f40: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2005f44: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005f48: 80 a0 60 00 cmp %g1, 0 2005f4c: 02 80 00 07 be 2005f68 2005f50: 92 10 00 10 mov %l0, %o1 2005f54: 80 a0 60 02 cmp %g1, 2 2005f58: 08 80 00 13 bleu 2005fa4 2005f5c: b0 10 20 04 mov 4, %i0 2005f60: 81 c7 e0 08 ret <== NOT EXECUTED 2005f64: 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 ); 2005f68: 94 10 20 00 clr %o2 2005f6c: 40 00 06 e4 call 2007afc <_CORE_barrier_Release> 2005f70: 90 02 20 14 add %o0, 0x14, %o0 2005f74: 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 ) 2005f78: 03 00 80 74 sethi %hi(0x201d000), %g1 2005f7c: c4 00 61 10 ld [ %g1 + 0x110 ], %g2 ! 201d110 <_Thread_Dispatch_disable_level> 2005f80: b0 10 20 00 clr %i0 2005f84: 84 00 bf ff add %g2, -1, %g2 2005f88: c4 20 61 10 st %g2, [ %g1 + 0x110 ] 2005f8c: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 2005f90: 80 a0 60 00 cmp %g1, 0 2005f94: 12 80 00 04 bne 2005fa4 2005f98: 01 00 00 00 nop _Thread_Dispatch(); 2005f9c: 40 00 0f c9 call 2009ec0 <_Thread_Dispatch> 2005fa0: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005fa4: 81 c7 e0 08 ret 2005fa8: 81 e8 00 00 restore 02005fac : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 2005fac: 9d e3 bf 90 save %sp, -112, %sp 2005fb0: 11 00 80 73 sethi %hi(0x201cc00), %o0 2005fb4: 92 10 00 18 mov %i0, %o1 2005fb8: 90 12 23 70 or %o0, 0x370, %o0 2005fbc: 40 00 0a bc call 2008aac <_Objects_Get> 2005fc0: 94 07 bf f4 add %fp, -12, %o2 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2005fc4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005fc8: 80 a0 60 00 cmp %g1, 0 2005fcc: 02 80 00 07 be 2005fe8 2005fd0: 96 10 00 19 mov %i1, %o3 2005fd4: 80 a0 60 02 cmp %g1, 2 2005fd8: 08 80 00 17 bleu 2006034 2005fdc: 90 10 20 04 mov 4, %o0 2005fe0: 10 80 00 15 b 2006034 <== NOT EXECUTED 2005fe4: 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( 2005fe8: 90 02 20 14 add %o0, 0x14, %o0 2005fec: 92 10 00 18 mov %i0, %o1 2005ff0: 94 10 20 01 mov 1, %o2 2005ff4: 40 00 06 cd call 2007b28 <_CORE_barrier_Wait> 2005ff8: 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 ) 2005ffc: 03 00 80 74 sethi %hi(0x201d000), %g1 2006000: c4 00 61 10 ld [ %g1 + 0x110 ], %g2 ! 201d110 <_Thread_Dispatch_disable_level> 2006004: 84 00 bf ff add %g2, -1, %g2 2006008: c4 20 61 10 st %g2, [ %g1 + 0x110 ] 200600c: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 2006010: 80 a0 60 00 cmp %g1, 0 2006014: 12 80 00 05 bne 2006028 2006018: 03 00 80 74 sethi %hi(0x201d000), %g1 _Thread_Dispatch(); 200601c: 40 00 0f a9 call 2009ec0 <_Thread_Dispatch> 2006020: 01 00 00 00 nop TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 2006024: 03 00 80 74 sethi %hi(0x201d000), %g1 2006028: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 201d1f0 <_Thread_Executing> 200602c: 40 00 1e 71 call 200d9f0 <_Barrier_Translate_core_barrier_return_code> 2006030: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006034: 81 c7 e0 08 ret 2006038: 91 e8 00 08 restore %g0, %o0, %o0 02004e80 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 2004e80: 9d e3 bf 68 save %sp, -152, %sp 2004e84: 82 10 00 18 mov %i0, %g1 if ( !time_buffer ) 2004e88: 80 a6 60 00 cmp %i1, 0 2004e8c: 02 80 00 47 be 2004fa8 2004e90: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; switch ( option ) { 2004e94: 80 a0 60 04 cmp %g1, 4 2004e98: 18 80 00 44 bgu 2004fa8 2004e9c: b0 10 20 19 mov 0x19, %i0 2004ea0: 83 28 60 02 sll %g1, 2, %g1 2004ea4: 05 00 80 13 sethi %hi(0x2004c00), %g2 2004ea8: 84 10 a2 2c or %g2, 0x22c, %g2 ! 2004e2c 2004eac: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2004eb0: 81 c0 40 00 jmp %g1 2004eb4: 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 ) 2004eb8: 03 00 80 62 sethi %hi(0x2018800), %g1 2004ebc: c2 00 63 2c ld [ %g1 + 0x32c ], %g1 ! 2018b2c <_TOD_Is_set> 2004ec0: 80 a0 60 00 cmp %g1, 0 2004ec4: 22 80 00 39 be,a 2004fa8 2004ec8: b0 10 20 0b mov 0xb, %i0 return RTEMS_NOT_DEFINED; /* Obtain the current time */ _TOD_Get_timeval( &now ); 2004ecc: a0 07 bf f0 add %fp, -16, %l0 2004ed0: 7f ff ff dc call 2004e40 <_TOD_Get_timeval> 2004ed4: 90 10 00 10 mov %l0, %o0 /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 2004ed8: 92 07 bf cc add %fp, -52, %o1 2004edc: 40 00 27 11 call 200eb20 2004ee0: 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; 2004ee4: 03 00 80 63 sethi %hi(0x2018c00), %g1 2004ee8: d2 00 60 cc ld [ %g1 + 0xcc ], %o1 ! 2018ccc <_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; 2004eec: 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; 2004ef0: 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; 2004ef4: c2 26 60 08 st %g1, [ %i1 + 8 ] tmbuf->hour = time.tm_hour; 2004ef8: c2 07 bf d4 ld [ %fp + -44 ], %g1 2004efc: c2 26 60 0c st %g1, [ %i1 + 0xc ] tmbuf->minute = time.tm_min; 2004f00: c2 07 bf d0 ld [ %fp + -48 ], %g1 2004f04: c2 26 60 10 st %g1, [ %i1 + 0x10 ] tmbuf->second = time.tm_sec; 2004f08: c2 07 bf cc ld [ %fp + -52 ], %g1 2004f0c: 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; 2004f10: c2 07 bf e0 ld [ %fp + -32 ], %g1 2004f14: 82 00 67 6c add %g1, 0x76c, %g1 2004f18: c2 26 40 00 st %g1, [ %i1 ] tmbuf->month = time.tm_mon + 1; 2004f1c: c2 07 bf dc ld [ %fp + -36 ], %g1 2004f20: 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; 2004f24: 40 00 40 cc call 2015254 <.udiv> 2004f28: c2 26 60 04 st %g1, [ %i1 + 4 ] 2004f2c: 10 80 00 1c b 2004f9c 2004f30: 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 ) 2004f34: 03 00 80 62 sethi %hi(0x2018800), %g1 2004f38: c2 00 63 2c ld [ %g1 + 0x32c ], %g1 ! 2018b2c <_TOD_Is_set> 2004f3c: 80 a0 60 00 cmp %g1, 0 2004f40: 02 80 00 19 be 2004fa4 2004f44: 03 00 80 62 sethi %hi(0x2018800), %g1 return RTEMS_NOT_DEFINED; *interval = _TOD_Seconds_since_epoch; 2004f48: 10 80 00 04 b 2004f58 2004f4c: c2 00 63 ac ld [ %g1 + 0x3ac ], %g1 ! 2018bac <_TOD_Now> } case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = _Watchdog_Ticks_since_boot; 2004f50: 03 00 80 63 sethi %hi(0x2018c00), %g1 2004f54: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 2018c74 <_Watchdog_Ticks_since_boot> 2004f58: c2 26 40 00 st %g1, [ %i1 ] 2004f5c: 81 c7 e0 08 ret 2004f60: 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; 2004f64: 03 00 80 63 sethi %hi(0x2018c00), %g1 2004f68: d2 00 60 cc ld [ %g1 + 0xcc ], %o1 ! 2018ccc <_TOD_Microseconds_per_tick> 2004f6c: 11 00 03 d0 sethi %hi(0xf4000), %o0 2004f70: 40 00 40 b9 call 2015254 <.udiv> 2004f74: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 2004f78: 10 80 00 09 b 2004f9c 2004f7c: d0 26 40 00 st %o0, [ %i1 ] } case RTEMS_CLOCK_GET_TIME_VALUE: { struct timeval *time = (struct timeval *)time_buffer; if ( !_TOD_Is_set ) 2004f80: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2004f84: c2 00 63 2c ld [ %g1 + 0x32c ], %g1 ! 2018b2c <_TOD_Is_set> <== NOT EXECUTED 2004f88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004f8c: 22 80 00 07 be,a 2004fa8 <== NOT EXECUTED 2004f90: b0 10 20 0b mov 0xb, %i0 <== NOT EXECUTED return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); 2004f94: 7f ff ff ab call 2004e40 <_TOD_Get_timeval> <== NOT EXECUTED 2004f98: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2004f9c: 81 c7 e0 08 ret 2004fa0: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; 2004fa4: b0 10 20 0b mov 0xb, %i0 <== NOT EXECUTED } } return RTEMS_INTERNAL_ERROR; /* should never get here */ } 2004fa8: 81 c7 e0 08 ret 2004fac: 81 e8 00 00 restore 02004fd0 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 2004fd0: 9d e3 bf 98 save %sp, -104, %sp _TOD_Tickle_ticks(); 2004fd4: 40 00 07 3f call 2006cd0 <_TOD_Tickle_ticks> 2004fd8: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 2004fdc: 11 00 80 62 sethi %hi(0x2018800), %o0 2004fe0: 40 00 14 92 call 200a228 <_Watchdog_Tickle> 2004fe4: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 2018bf0 <_Watchdog_Ticks_chain> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 2004fe8: 40 00 12 e9 call 2009b8c <_Thread_Tickle_timeslice> 2004fec: 01 00 00 00 nop * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_context_switch_necessary( void ) { return ( _Context_Switch_necessary ); 2004ff0: 03 00 80 62 sethi %hi(0x2018800), %g1 2004ff4: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 2018be0 <_Context_Switch_necessary> if ( _Thread_Is_context_switch_necessary() && 2004ff8: 80 a0 60 00 cmp %g1, 0 2004ffc: 02 80 00 08 be 200501c 2005000: 03 00 80 62 sethi %hi(0x2018800), %g1 * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 2005004: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2005008: 80 a0 60 00 cmp %g1, 0 200500c: 12 80 00 04 bne 200501c 2005010: 01 00 00 00 nop _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 2005014: 40 00 0e f2 call 2008bdc <_Thread_Dispatch> <== NOT EXECUTED 2005018: 01 00 00 00 nop <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 200501c: 81 c7 e0 08 ret 2005020: 91 e8 20 00 restore %g0, 0, %o0 02005234 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 2005234: 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 ) ) { 2005238: 92 96 20 00 orcc %i0, 0, %o1 200523c: 12 80 00 0a bne 2005264 2005240: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005244: 03 00 80 62 sethi %hi(0x2018800), %g1 2005248: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> 200524c: 84 00 a0 01 inc %g2 2005250: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] 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; 2005254: 03 00 80 62 sethi %hi(0x2018800), %g1 2005258: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_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; 200525c: 10 80 00 18 b 20052bc 2005260: 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); 2005264: 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 ) { 2005268: 80 a0 a0 04 cmp %g2, 4 200526c: 18 80 00 0e bgu 20052a4 2005270: 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 :) */ 2005274: 83 32 60 1b srl %o1, 0x1b, %g1 2005278: 80 a0 60 01 cmp %g1, 1 200527c: 12 80 00 0a bne 20052a4 2005280: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2005284: 83 28 a0 02 sll %g2, 2, %g1 2005288: 05 00 80 62 sethi %hi(0x2018800), %g2 200528c: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 2005290: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2005294: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2005298: 80 a2 20 00 cmp %o0, 0 200529c: 12 80 00 05 bne 20052b0 20052a0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20052a4: b0 10 20 00 clr %i0 20052a8: 10 80 00 05 b 20052bc 20052ac: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20052b0: 40 00 09 46 call 20077c8 <_Objects_Get> 20052b4: 94 07 bf f4 add %fp, -12, %o2 20052b8: 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 ) { 20052bc: c2 07 bf f4 ld [ %fp + -12 ], %g1 20052c0: 80 a0 60 00 cmp %g1, 0 20052c4: 02 80 00 06 be 20052dc 20052c8: 80 a0 60 02 cmp %g1, 2 20052cc: 08 80 00 18 bleu 200532c 20052d0: b0 10 20 04 mov 4, %i0 20052d4: 81 c7 e0 08 ret <== NOT EXECUTED 20052d8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 20052dc: 7f ff f2 a0 call 2001d5c 20052e0: e0 06 21 70 ld [ %i0 + 0x170 ], %l0 *the_event_set |= the_new_events; 20052e4: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 20052e8: 82 10 40 19 or %g1, %i1, %g1 20052ec: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _ISR_Enable( level ); 20052f0: 7f ff f2 9f call 2001d6c 20052f4: 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 ); 20052f8: 40 00 00 15 call 200534c <_Event_Surrender> 20052fc: 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 ) 2005300: 05 00 80 62 sethi %hi(0x2018800), %g2 2005304: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2005308: b0 10 20 00 clr %i0 200530c: 82 00 7f ff add %g1, -1, %g1 2005310: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2005314: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 2005318: 80 a0 60 00 cmp %g1, 0 200531c: 12 80 00 04 bne 200532c 2005320: 01 00 00 00 nop _Thread_Dispatch(); 2005324: 40 00 0e 2e call 2008bdc <_Thread_Dispatch> 2005328: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200532c: 81 c7 e0 08 ret 2005330: 81 e8 00 00 restore 0200ac40 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 200ac40: 9d e3 bf 98 save %sp, -104, %sp Extension_Control *the_extension; if ( !rtems_is_name_valid( name ) ) 200ac44: a4 96 20 00 orcc %i0, 0, %l2 200ac48: 02 80 00 0e be 200ac80 200ac4c: b0 10 20 03 mov 3, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200ac50: 05 00 80 9e sethi %hi(0x2027800), %g2 200ac54: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 ! 2027a50 <_Thread_Dispatch_disable_level> 200ac58: 82 00 60 01 inc %g1 200ac5c: c2 20 a2 50 st %g1, [ %g2 + 0x250 ] * the inactive chain of free extension control blocks. */ RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void ) { return (Extension_Control *) _Objects_Allocate( &_Extension_Information ); 200ac60: 23 00 80 9f sethi %hi(0x2027c00), %l1 200ac64: 40 00 03 ac call 200bb14 <_Objects_Allocate> 200ac68: 90 14 60 ec or %l1, 0xec, %o0 ! 2027cec <_Extension_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 200ac6c: a0 92 20 00 orcc %o0, 0, %l0 200ac70: 12 80 00 06 bne 200ac88 200ac74: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); 200ac78: 7f ff ff e5 call 200ac0c <_Thread_Enable_dispatch> <== NOT EXECUTED 200ac7c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 200ac80: 81 c7 e0 08 ret <== NOT EXECUTED 200ac84: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 200ac88: 40 00 0e 6d call 200e63c <_User_extensions_Add_set> 200ac8c: 92 10 00 19 mov %i1, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ac90: 90 14 60 ec or %l1, 0xec, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200ac94: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ac98: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200ac9c: 05 00 00 3f sethi %hi(0xfc00), %g2 200aca0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200aca4: 82 08 40 02 and %g1, %g2, %g1 200aca8: 80 a0 40 03 cmp %g1, %g3 200acac: 38 80 00 06 bgu,a 200acc4 200acb0: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200acb4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200acb8: 83 28 60 02 sll %g1, 2, %g1 200acbc: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 200acc0: 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; 200acc4: e4 24 20 0c st %l2, [ %l0 + 0xc ] 200acc8: c2 26 80 00 st %g1, [ %i2 ] _Thread_Enable_dispatch(); 200accc: 7f ff ff d0 call 200ac0c <_Thread_Enable_dispatch> 200acd0: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 200acd4: 81 c7 e0 08 ret 200acd8: 81 e8 00 00 restore 0200acdc : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 200acdc: 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 *) 200ace0: 21 00 80 9f sethi %hi(0x2027c00), %l0 <== NOT EXECUTED 200ace4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200ace8: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 200acec: 40 00 04 ce call 200c024 <_Objects_Get> <== NOT EXECUTED 200acf0: 90 14 20 ec or %l0, 0xec, %o0 <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 200acf4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200acf8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200acfc: 02 80 00 07 be 200ad18 <== NOT EXECUTED 200ad00: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 200ad04: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200ad08: 08 80 00 20 bleu 200ad88 <== NOT EXECUTED 200ad0c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 200ad10: 81 c7 e0 08 ret <== NOT EXECUTED 200ad14: 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 ); 200ad18: 40 00 0e 83 call 200e724 <_User_extensions_Remove_set> <== NOT EXECUTED 200ad1c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ad20: 90 14 20 ec or %l0, 0xec, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200ad24: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ad28: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 <== NOT EXECUTED 200ad2c: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED 200ad30: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <== NOT EXECUTED 200ad34: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 200ad38: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200ad3c: 38 80 00 06 bgu,a 200ad54 <== NOT EXECUTED 200ad40: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200ad44: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 <== NOT EXECUTED 200ad48: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 200ad4c: 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; 200ad50: 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 ); 200ad54: 40 00 04 72 call 200bf1c <_Objects_Free> <== NOT EXECUTED 200ad58: 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 ) 200ad5c: 03 00 80 9e sethi %hi(0x2027800), %g1 <== NOT EXECUTED 200ad60: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 2027a50 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200ad64: b0 10 20 00 clr %i0 <== NOT EXECUTED 200ad68: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 200ad6c: c4 20 62 50 st %g2, [ %g1 + 0x250 ] <== NOT EXECUTED 200ad70: c2 00 62 50 ld [ %g1 + 0x250 ], %g1 <== NOT EXECUTED 200ad74: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200ad78: 12 80 00 04 bne 200ad88 <== NOT EXECUTED 200ad7c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 200ad80: 40 00 09 ae call 200d438 <_Thread_Dispatch> <== NOT EXECUTED 200ad84: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200ad88: 81 c7 e0 08 ret <== NOT EXECUTED 200ad8c: 81 e8 00 00 restore <== NOT EXECUTED 02006584 : #include const char *rtems_get_version_string(void) { return _RTEMS_version; } 2006584: 11 00 80 5d sethi %hi(0x2017400), %o0 <== NOT EXECUTED 2006588: 81 c3 e0 08 retl <== NOT EXECUTED 200658c: 90 12 23 38 or %o0, 0x338, %o0 ! 2017738 <_RTEMS_version> <== NOT EXECUTED 02006324 : rtems_interrupt_level rtems_initialize_executive_early( rtems_configuration_table *configuration_table, rtems_cpu_table *cpu_table ) { 2006324: 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 ); 2006328: 7f ff ee 8d call 2001d5c 200632c: 01 00 00 00 nop 2006330: a4 10 00 08 mov %o0, %l2 if ( configuration_table == NULL ) 2006334: 80 a6 20 00 cmp %i0, 0 2006338: 12 80 00 07 bne 2006354 200633c: 03 00 80 63 sethi %hi(0x2018c00), %g1 _Internal_error_Occurred( 2006340: 90 10 20 00 clr %o0 <== NOT EXECUTED 2006344: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2006348: 40 00 03 af call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 200634c: 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; 2006350: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 2006354: c0 20 60 d0 clr [ %g1 + 0xd0 ] ! 2018cd0 <_System_state_Current> _System_state_Is_multiprocessing = is_multiprocessing; 2006358: 03 00 80 62 sethi %hi(0x2018800), %g1 /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 200635c: 94 10 20 28 mov 0x28, %o2 2006360: 92 10 00 19 mov %i1, %o1 2006364: c0 20 63 fc clr [ %g1 + 0x3fc ] 2006368: 11 00 80 62 sethi %hi(0x2018800), %o0 200636c: 40 00 21 f2 call 200eb34 2006370: 90 12 23 04 or %o0, 0x304, %o0 ! 2018b04 <_CPU_Table> /* * Provided just for user convenience. */ _Configuration_Table = configuration_table; 2006374: 03 00 80 62 sethi %hi(0x2018800), %g1 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_NO_CPU_TABLE ); _CPU_Initialize( cpu_table, _Thread_Dispatch ); 2006378: 90 10 00 19 mov %i1, %o0 200637c: 13 00 80 22 sethi %hi(0x2008800), %o1 2006380: 92 12 63 dc or %o1, 0x3dc, %o1 ! 2008bdc <_Thread_Dispatch> 2006384: 40 00 11 93 call 200a9d0 <_CPU_Initialize> 2006388: f0 20 63 b4 st %i0, [ %g1 + 0x3b4 ] /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 200638c: 40 00 19 ca call 200cab4 <_Debug_Manager_initialization> 2006390: 01 00 00 00 nop _API_extensions_Initialization(); 2006394: 40 00 00 f2 call 200675c <_API_extensions_Initialization> 2006398: 01 00 00 00 nop _Thread_Dispatch_initialization(); _Workspace_Handler_initialization( 200639c: d2 06 20 04 ld [ %i0 + 4 ], %o1 20063a0: 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; 20063a4: 84 10 20 01 mov 1, %g2 20063a8: 03 00 80 62 sethi %hi(0x2018800), %g1 20063ac: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] ! 2018af0 <_Thread_Dispatch_disable_level> 20063b0: 40 00 0f d3 call 200a2fc <_Workspace_Handler_initialization> 20063b4: 23 00 80 63 sethi %hi(0x2018c00), %l1 (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 20063b8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 20063bc: 40 00 0e 73 call 2009d88 <_User_extensions_Handler_initialization> 20063c0: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 20063c4: 40 00 03 a0 call 2007244 <_ISR_Handler_initialization> 20063c8: a0 07 bf e8 add %fp, -24, %l0 _Objects_Handler_initialization( 20063cc: 90 10 20 01 mov 1, %o0 20063d0: 92 10 20 01 mov 1, %o1 20063d4: 40 00 05 96 call 2007a2c <_Objects_Handler_initialization> 20063d8: 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; 20063dc: 05 00 80 62 sethi %hi(0x2018800), %g2 /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20063e0: 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; 20063e4: 03 00 80 62 sethi %hi(0x2018800), %g1 20063e8: 82 10 63 30 or %g1, 0x330, %g1 ! 2018b30 <_Internal_Objects> /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20063ec: 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; 20063f0: c2 20 a2 54 st %g1, [ %g2 + 0x254 ] /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20063f4: 98 10 20 74 mov 0x74, %o4 20063f8: 9a 10 20 00 clr %o5 20063fc: 90 14 60 00 mov %l1, %o0 2006400: 92 10 20 01 mov 1, %o1 2006404: 40 00 05 16 call 200785c <_Objects_Initialize_information> 2006408: 94 10 20 02 mov 2, %o2 _API_Mutex_Allocate( _RTEMS_Allocator_Mutex ); 200640c: 94 10 20 10 mov 0x10, %o2 2006410: 13 00 80 5b sethi %hi(0x2016c00), %o1 2006414: 90 10 00 10 mov %l0, %o0 2006418: 40 00 21 c7 call 200eb34 200641c: 92 12 61 a0 or %o1, 0x1a0, %o1 2006420: 40 00 03 a6 call 20072b8 <_Objects_Allocate> 2006424: 90 14 60 00 mov %l1, %o0 2006428: 03 00 80 62 sethi %hi(0x2018800), %g1 200642c: 84 10 00 08 mov %o0, %g2 2006430: 92 10 00 10 mov %l0, %o1 2006434: c4 20 63 c8 st %g2, [ %g1 + 0x3c8 ] 2006438: 90 02 20 10 add %o0, 0x10, %o0 200643c: 40 00 01 2a call 20068e4 <_CORE_mutex_Initialize> 2006440: 94 10 20 01 mov 1, %o2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 2006444: 03 00 80 62 sethi %hi(0x2018800), %g1 2006448: 84 10 20 00 clr %g2 200644c: c0 30 63 c4 clrh [ %g1 + 0x3c4 ] for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 2006450: 03 00 80 63 sethi %hi(0x2018c00), %g1 2006454: 82 10 60 50 or %g1, 0x50, %g1 ! 2018c50 <_Priority_Bit_map> 2006458: c0 30 80 01 clrh [ %g2 + %g1 ] 200645c: 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++ ) 2006460: 80 a0 a0 20 cmp %g2, 0x20 2006464: 32 bf ff fe bne,a 200645c 2006468: c0 30 80 01 clrh [ %g2 + %g1 ] _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 200646c: 40 00 0f 32 call 200a134 <_Watchdog_Handler_initialization> 2006470: 01 00 00 00 nop _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 2006474: 40 00 02 08 call 2006c94 <_TOD_Handler_initialization> 2006478: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _Thread_Handler_initialization( 200647c: d2 06 20 08 ld [ %i0 + 8 ], %o1 2006480: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 2006484: 40 00 0a c3 call 2008f90 <_Thread_Handler_initialization> 2006488: 94 10 20 00 clr %o2 ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 200648c: 40 00 00 95 call 20066e0 <_RTEMS_API_Initialize> 2006490: 90 10 00 18 mov %i0, %o0 _Extension_Manager_initialization( configuration_table->maximum_extensions ); 2006494: 40 00 00 28 call 2006534 <_Extension_Manager_initialization> 2006498: d0 06 20 08 ld [ %i0 + 8 ], %o0 _IO_Manager_initialization( 200649c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 20064a0: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 20064a4: 40 00 00 49 call 20065c8 <_IO_Manager_initialization> 20064a8: 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 ); 20064ac: 40 00 00 68 call 200664c <_POSIX_API_Initialize> 20064b0: 90 10 00 18 mov %i0, %o0 RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 20064b4: 84 10 20 01 mov 1, %g2 20064b8: 03 00 80 63 sethi %hi(0x2018c00), %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(); 20064bc: 40 00 09 6c call 2008a6c <_Thread_Create_idle> 20064c0: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] ! 2018cd0 <_System_state_Current> /* * Scheduling can properly occur now as long as we avoid dispatching. */ if ( cpu_table->pretasking_hook ) 20064c4: d0 06 40 00 ld [ %i1 ], %o0 20064c8: 80 a2 20 00 cmp %o0, 0 20064cc: 02 80 00 04 be 20064dc 20064d0: 01 00 00 00 nop (*cpu_table->pretasking_hook)(); 20064d4: 9f c2 00 00 call %o0 20064d8: 01 00 00 00 nop /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 20064dc: 40 00 00 bf call 20067d8 <_API_extensions_Run_predriver> 20064e0: 01 00 00 00 nop if ( _CPU_Table.predriver_hook ) 20064e4: 03 00 80 62 sethi %hi(0x2018800), %g1 20064e8: a0 10 63 04 or %g1, 0x304, %l0 ! 2018b04 <_CPU_Table> 20064ec: c2 04 20 04 ld [ %l0 + 4 ], %g1 20064f0: 80 a0 60 00 cmp %g1, 0 20064f4: 02 80 00 04 be 2006504 20064f8: 01 00 00 00 nop (*_CPU_Table.predriver_hook)(); 20064fc: 9f c0 40 00 call %g1 <== NOT EXECUTED 2006500: 01 00 00 00 nop <== NOT EXECUTED * Initialize all the device drivers and initialize the MPCI layer. * * NOTE: The MPCI may be build upon a device driver. */ _IO_Initialize_all_drivers(); 2006504: 40 00 00 23 call 2006590 <_IO_Initialize_all_drivers> 2006508: 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(); 200650c: 40 00 00 9b call 2006778 <_API_extensions_Run_postdriver> 2006510: 01 00 00 00 nop if ( _CPU_Table.postdriver_hook ) 2006514: c2 04 20 08 ld [ %l0 + 8 ], %g1 2006518: 80 a0 60 00 cmp %g1, 0 200651c: 02 80 00 04 be 200652c 2006520: 01 00 00 00 nop (*_CPU_Table.postdriver_hook)(); 2006524: 9f c0 40 00 call %g1 2006528: 01 00 00 00 nop return bsp_level; } 200652c: 81 c7 e0 08 ret 2006530: 91 e8 00 12 restore %g0, %l2, %o0 02007624 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 2007624: 9d e3 bf 98 save %sp, -104, %sp /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 2007628: 92 96 60 00 orcc %i1, 0, %o1 200762c: 02 80 00 40 be 200772c 2007630: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 2007634: 02 80 00 41 be 2007738 2007638: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 200763c: c2 02 40 00 ld [ %o1 ], %g1 2007640: 80 a0 60 00 cmp %g1, 0 2007644: 12 80 00 07 bne 2007660 2007648: 03 00 80 74 sethi %hi(0x201d000), %g1 200764c: c2 02 60 04 ld [ %o1 + 4 ], %g1 2007650: 80 a0 60 00 cmp %g1, 0 2007654: 22 80 00 39 be,a 2007738 2007658: 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 ) 200765c: 03 00 80 74 sethi %hi(0x201d000), %g1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) return RTEMS_INVALID_ADDRESS; *registered_major = 0; 2007660: c0 26 80 00 clr [ %i2 ] /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 2007664: c8 00 60 2c ld [ %g1 + 0x2c ], %g4 2007668: 80 a6 00 04 cmp %i0, %g4 200766c: 1a 80 00 33 bcc 2007738 2007670: 82 10 20 0a mov 0xa, %g1 /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 2007674: 80 a6 20 00 cmp %i0, 0 2007678: 12 80 00 18 bne 20076d8 200767c: 03 00 80 74 sethi %hi(0x201d000), %g1 boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 2007680: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 ! 201d030 <_IO_Driver_address_table> 2007684: 85 29 20 03 sll %g4, 3, %g2 2007688: 83 29 20 05 sll %g4, 5, %g1 200768c: b0 01 3f ff add %g4, -1, %i0 2007690: 82 20 40 02 sub %g1, %g2, %g1 2007694: 82 00 7f e8 add %g1, -24, %g1 2007698: 10 80 00 0b b 20076c4 200769c: 84 00 40 03 add %g1, %g3, %g2 if ( !_IO_Driver_address_table[major].initialization_entry && 20076a0: 80 a0 60 00 cmp %g1, 0 20076a4: 32 80 00 07 bne,a 20076c0 20076a8: b0 06 3f ff add %i0, -1, %i0 20076ac: c2 00 a0 04 ld [ %g2 + 4 ], %g1 20076b0: 80 a0 60 00 cmp %g1, 0 20076b4: 02 80 00 09 be 20076d8 20076b8: 03 00 80 74 sethi %hi(0x201d000), %g1 * in use. */ if ( major == 0 ) { boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 20076bc: b0 06 3f ff add %i0, -1, %i0 <== NOT EXECUTED 20076c0: 84 00 bf e8 add %g2, -24, %g2 20076c4: 80 a6 20 00 cmp %i0, 0 20076c8: 32 bf ff f6 bne,a 20076a0 20076cc: c2 00 80 00 ld [ %g2 ], %g1 20076d0: 10 80 00 1a b 2007738 20076d4: 82 10 20 05 mov 5, %g1 if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 20076d8: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 20076dc: 85 2e 20 03 sll %i0, 3, %g2 20076e0: 83 2e 20 05 sll %i0, 5, %g1 20076e4: 82 20 40 02 sub %g1, %g2, %g1 20076e8: c4 00 40 03 ld [ %g1 + %g3 ], %g2 20076ec: 80 a0 a0 00 cmp %g2, 0 20076f0: 12 80 00 11 bne 2007734 20076f4: 90 00 40 03 add %g1, %g3, %o0 20076f8: c2 02 20 04 ld [ %o0 + 4 ], %g1 20076fc: 80 a0 60 00 cmp %g1, 0 2007700: 32 80 00 0e bne,a 2007738 2007704: 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; 2007708: 40 00 20 cc call 200fa38 200770c: 94 10 20 18 mov 0x18, %o2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 2007710: 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; 2007714: f0 26 80 00 st %i0, [ %i2 ] rtems_io_initialize( major, 0, NULL ); 2007718: 92 10 20 00 clr %o1 200771c: 7f ff ff 52 call 2007464 2007720: 94 10 20 00 clr %o2 2007724: 10 80 00 05 b 2007738 2007728: 82 10 20 00 clr %g1 return RTEMS_SUCCESSFUL; 200772c: 10 80 00 03 b 2007738 2007730: 82 10 20 09 mov 9, %g1 2007734: 82 10 20 0c mov 0xc, %g1 } 2007738: 81 c7 e0 08 ret 200773c: 91 e8 00 01 restore %g0, %g1, %o0 02008c88 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 2008c88: 9d e3 bf 98 save %sp, -104, %sp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 2008c8c: 80 a6 20 00 cmp %i0, 0 2008c90: 02 80 00 1d be 2008d04 2008c94: 03 00 80 95 sethi %hi(0x2025400), %g1 return; 2008c98: a4 10 62 64 or %g1, 0x264, %l2 ! 2025664 <_Objects_Information_table+0x4> for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 2008c9c: a6 04 a0 10 add %l2, 0x10, %l3 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 2008ca0: c2 04 80 00 ld [ %l2 ], %g1 2008ca4: 80 a0 60 00 cmp %g1, 0 2008ca8: 22 80 00 14 be,a 2008cf8 2008cac: a4 04 a0 04 add %l2, 4, %l2 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 2008cb0: e0 00 60 04 ld [ %g1 + 4 ], %l0 if ( information ) { 2008cb4: 80 a4 20 00 cmp %l0, 0 2008cb8: 12 80 00 0b bne 2008ce4 2008cbc: a2 10 20 01 mov 1, %l1 for ( i=1 ; i <= information->maximum ; i++ ) { 2008cc0: 10 80 00 0e b 2008cf8 <== NOT EXECUTED 2008cc4: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED the_thread = (Thread_Control *)information->local_table[ i ]; 2008cc8: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 2008ccc: d0 00 40 08 ld [ %g1 + %o0 ], %o0 if ( !the_thread ) 2008cd0: 80 a2 20 00 cmp %o0, 0 2008cd4: 02 80 00 04 be 2008ce4 2008cd8: a2 04 60 01 inc %l1 continue; (*routine)(the_thread); 2008cdc: 9f c6 00 00 call %i0 2008ce0: 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++ ) { 2008ce4: c2 14 20 10 lduh [ %l0 + 0x10 ], %g1 2008ce8: 80 a4 40 01 cmp %l1, %g1 2008cec: 08 bf ff f7 bleu 2008cc8 2008cf0: 91 2c 60 02 sll %l1, 2, %o0 2008cf4: a4 04 a0 04 add %l2, 4, %l2 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 2008cf8: 80 a4 80 13 cmp %l2, %l3 2008cfc: 32 bf ff ea bne,a 2008ca4 2008d00: c2 04 80 00 ld [ %l2 ], %g1 2008d04: 81 c7 e0 08 ret 2008d08: 81 e8 00 00 restore 0200e7d4 : Objects_Id id, void *buffer, size_t size, uint32_t *count ) { 200e7d4: 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 ) 200e7d8: 80 a6 60 00 cmp %i1, 0 200e7dc: 02 80 00 26 be 200e874 200e7e0: 80 a6 e0 00 cmp %i3, 0 return RTEMS_INVALID_ADDRESS; if ( !count ) 200e7e4: 02 80 00 24 be 200e874 200e7e8: 11 00 80 cb sethi %hi(0x2032c00), %o0 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 200e7ec: 92 10 00 18 mov %i0, %o1 200e7f0: 90 12 23 e0 or %o0, 0x3e0, %o0 200e7f4: 40 00 18 af call 2014ab0 <_Objects_Get> 200e7f8: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200e7fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 200e800: 80 a0 60 00 cmp %g1, 0 200e804: 02 80 00 07 be 200e820 200e808: 9a 10 00 1b mov %i3, %o5 200e80c: 80 a0 60 02 cmp %g1, 2 200e810: 08 80 00 1a bleu 200e878 200e814: 90 10 20 04 mov 4, %o0 200e818: 10 80 00 18 b 200e878 <== NOT EXECUTED 200e81c: 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( 200e820: 92 10 00 19 mov %i1, %o1 200e824: 94 10 00 1a mov %i2, %o2 200e828: 96 10 00 18 mov %i0, %o3 200e82c: 98 10 20 00 clr %o4 200e830: 40 00 13 3d call 2013524 <_CORE_message_queue_Broadcast> 200e834: 90 02 20 14 add %o0, 0x14, %o0 200e838: 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 ) 200e83c: 03 00 80 c9 sethi %hi(0x2032400), %g1 200e840: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20325f0 <_Thread_Dispatch_disable_level> 200e844: 84 00 bf ff add %g2, -1, %g2 200e848: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 200e84c: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 200e850: 80 a0 60 00 cmp %g1, 0 200e854: 12 80 00 04 bne 200e864 200e858: 01 00 00 00 nop _Thread_Dispatch(); 200e85c: 40 00 1d 9a call 2015ec4 <_Thread_Dispatch> 200e860: 01 00 00 00 nop #endif count ); _Thread_Enable_dispatch(); return 200e864: 40 00 01 2e call 200ed1c <_Message_queue_Translate_core_message_queue_return_code> 200e868: 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 */ } 200e86c: 81 c7 e0 08 ret 200e870: 91 e8 00 08 restore %g0, %o0, %o0 #endif count ); _Thread_Enable_dispatch(); return 200e874: 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 */ } 200e878: b0 10 00 08 mov %o0, %i0 200e87c: 81 c7 e0 08 ret 200e880: 81 e8 00 00 restore 0200e8b8 : uint32_t count, uint32_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 200e8b8: 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 ) ) 200e8bc: a2 96 20 00 orcc %i0, 0, %l1 200e8c0: 02 80 00 17 be 200e91c 200e8c4: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 200e8c8: 80 a7 20 00 cmp %i4, 0 200e8cc: 02 80 00 14 be 200e91c 200e8d0: 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 ) 200e8d4: 80 a6 60 00 cmp %i1, 0 200e8d8: 02 80 00 11 be 200e91c 200e8dc: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 200e8e0: 80 a6 a0 00 cmp %i2, 0 200e8e4: 02 80 00 0e be 200e91c 200e8e8: b0 10 20 08 mov 8, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200e8ec: 05 00 80 c9 sethi %hi(0x2032400), %g2 200e8f0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200e8f4: 82 00 60 01 inc %g1 200e8f8: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate( count, max_message_size ); 200e8fc: 90 10 00 19 mov %i1, %o0 200e900: 40 00 2d 82 call 2019f08 <_Message_queue_Allocate> 200e904: 92 10 00 1a mov %i2, %o1 if ( !the_message_queue ) { 200e908: a0 92 20 00 orcc %o0, 0, %l0 200e90c: 12 80 00 06 bne 200e924 200e910: 80 8e e0 04 btst 4, %i3 _Thread_Enable_dispatch(); 200e914: 7f ff ff dc call 200e884 <_Thread_Enable_dispatch> 200e918: b0 10 20 05 mov 5, %i0 200e91c: 81 c7 e0 08 ret 200e920: 81 e8 00 00 restore } #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) 200e924: 02 80 00 05 be 200e938 200e928: f6 24 20 10 st %i3, [ %l0 + 0x10 ] the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 200e92c: 82 10 20 01 mov 1, %g1 200e930: 10 80 00 03 b 200e93c 200e934: c2 27 bf f4 st %g1, [ %fp + -12 ] else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 200e938: c0 27 bf f4 clr [ %fp + -12 ] if ( ! _CORE_message_queue_Initialize( 200e93c: 94 10 00 19 mov %i1, %o2 200e940: 96 10 00 1a mov %i2, %o3 200e944: 90 04 20 14 add %l0, 0x14, %o0 200e948: 40 00 13 43 call 2013654 <_CORE_message_queue_Initialize> 200e94c: 92 07 bf f4 add %fp, -12, %o1 200e950: 80 a2 20 00 cmp %o0, 0 200e954: 12 80 00 0a bne 200e97c 200e958: 11 00 80 cb sethi %hi(0x2032c00), %o0 RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 200e95c: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 2032fe0 <_Message_queue_Information> <== NOT EXECUTED 200e960: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 200e964: 40 00 17 fd call 2014958 <_Objects_Free> <== NOT EXECUTED 200e968: 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(); 200e96c: 7f ff ff c6 call 200e884 <_Thread_Enable_dispatch> <== NOT EXECUTED 200e970: 01 00 00 00 nop <== NOT EXECUTED 200e974: 81 c7 e0 08 ret <== NOT EXECUTED 200e978: 81 e8 00 00 restore <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e97c: 90 12 23 e0 or %o0, 0x3e0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200e980: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e984: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200e988: 05 00 00 3f sethi %hi(0xfc00), %g2 200e98c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200e990: 82 08 40 02 and %g1, %g2, %g1 200e994: 80 a0 40 03 cmp %g1, %g3 200e998: 38 80 00 06 bgu,a 200e9b0 200e99c: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200e9a0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200e9a4: 83 28 60 02 sll %g1, 2, %g1 200e9a8: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 200e9ac: 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; 200e9b0: e2 24 20 0c st %l1, [ %l0 + 0xc ] 200e9b4: c2 27 00 00 st %g1, [ %i4 ] name, 0 ); #endif _Thread_Enable_dispatch(); 200e9b8: 7f ff ff b3 call 200e884 <_Thread_Enable_dispatch> 200e9bc: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 200e9c0: 81 c7 e0 08 ret 200e9c4: 81 e8 00 00 restore 02012e20 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 2012e20: 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 *) 2012e24: 21 00 80 a1 sethi %hi(0x2028400), %l0 2012e28: 92 10 00 18 mov %i0, %o1 2012e2c: 94 07 bf f4 add %fp, -12, %o2 2012e30: 7f ff e4 7d call 200c024 <_Objects_Get> 2012e34: 90 14 20 bc or %l0, 0xbc, %o0 register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 2012e38: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012e3c: 80 a0 60 00 cmp %g1, 0 2012e40: 02 80 00 07 be 2012e5c 2012e44: b0 10 00 08 mov %o0, %i0 2012e48: 80 a0 60 02 cmp %g1, 2 2012e4c: 08 80 00 22 bleu 2012ed4 2012e50: b0 10 20 04 mov 4, %i0 2012e54: 81 c7 e0 08 ret <== NOT EXECUTED 2012e58: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012e5c: a0 14 20 bc or %l0, 0xbc, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2012e60: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012e64: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 2012e68: 05 00 00 3f sethi %hi(0xfc00), %g2 2012e6c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2012e70: 82 08 40 02 and %g1, %g2, %g1 2012e74: 80 a0 40 03 cmp %g1, %g3 2012e78: 18 80 00 05 bgu 2012e8c 2012e7c: 94 10 20 05 mov 5, %o2 information->local_table[ index ] = the_object; 2012e80: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 2012e84: 83 28 60 02 sll %g1, 2, %g1 2012e88: c0 20 80 01 clr [ %g2 + %g1 ] case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, &the_message_queue->Object ); _CORE_message_queue_Close( 2012e8c: 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; 2012e90: c0 26 20 0c clr [ %i0 + 0xc ] 2012e94: 40 00 01 9e call 201350c <_CORE_message_queue_Close> 2012e98: 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 ); 2012e9c: 90 10 00 10 mov %l0, %o0 2012ea0: 7f ff e4 1f call 200bf1c <_Objects_Free> 2012ea4: 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 ) 2012ea8: 03 00 80 9e sethi %hi(0x2027800), %g1 2012eac: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 2027a50 <_Thread_Dispatch_disable_level> 2012eb0: b0 10 20 00 clr %i0 2012eb4: 84 00 bf ff add %g2, -1, %g2 2012eb8: c4 20 62 50 st %g2, [ %g1 + 0x250 ] 2012ebc: c2 00 62 50 ld [ %g1 + 0x250 ], %g1 2012ec0: 80 a0 60 00 cmp %g1, 0 2012ec4: 12 80 00 04 bne 2012ed4 2012ec8: 01 00 00 00 nop _Thread_Dispatch(); 2012ecc: 7f ff e9 5b call 200d438 <_Thread_Dispatch> 2012ed0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012ed4: 81 c7 e0 08 ret 2012ed8: 81 e8 00 00 restore 0200ea84 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 200ea84: 9d e3 bf 90 save %sp, -112, %sp 200ea88: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200ea8c: 80 a6 60 00 cmp %i1, 0 200ea90: 02 80 00 1c be 200eb00 200ea94: 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 *) 200ea98: 11 00 80 cb sethi %hi(0x2032c00), %o0 200ea9c: 94 07 bf f4 add %fp, -12, %o2 200eaa0: 40 00 18 04 call 2014ab0 <_Objects_Get> 200eaa4: 90 12 23 e0 or %o0, 0x3e0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200eaa8: c2 07 bf f4 ld [ %fp + -12 ], %g1 200eaac: 80 a0 60 00 cmp %g1, 0 200eab0: 02 80 00 06 be 200eac8 200eab4: 80 a0 60 02 cmp %g1, 2 200eab8: 08 80 00 12 bleu 200eb00 200eabc: b0 10 20 04 mov 4, %i0 200eac0: 81 c7 e0 08 ret <== NOT EXECUTED 200eac4: 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 ); 200eac8: 40 00 12 c4 call 20135d8 <_CORE_message_queue_Flush> 200eacc: 90 02 20 14 add %o0, 0x14, %o0 200ead0: 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 ) 200ead4: 03 00 80 c9 sethi %hi(0x2032400), %g1 200ead8: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20325f0 <_Thread_Dispatch_disable_level> 200eadc: b0 10 20 00 clr %i0 200eae0: 84 00 bf ff add %g2, -1, %g2 200eae4: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 200eae8: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 200eaec: 80 a0 60 00 cmp %g1, 0 200eaf0: 12 80 00 04 bne 200eb00 200eaf4: 01 00 00 00 nop _Thread_Dispatch(); 200eaf8: 40 00 1c f3 call 2015ec4 <_Thread_Dispatch> 200eafc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200eb00: 81 c7 e0 08 ret 200eb04: 81 e8 00 00 restore 0200eb08 : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 200eb08: 9d e3 bf 90 save %sp, -112, %sp 200eb0c: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200eb10: 80 a6 60 00 cmp %i1, 0 200eb14: 02 80 00 1b be 200eb80 200eb18: b0 10 20 09 mov 9, %i0 200eb1c: 11 00 80 cb sethi %hi(0x2032c00), %o0 200eb20: 94 07 bf f4 add %fp, -12, %o2 200eb24: 40 00 17 e3 call 2014ab0 <_Objects_Get> 200eb28: 90 12 23 e0 or %o0, 0x3e0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200eb2c: c2 07 bf f4 ld [ %fp + -12 ], %g1 200eb30: 80 a0 60 00 cmp %g1, 0 200eb34: 22 80 00 07 be,a 200eb50 200eb38: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 200eb3c: 80 a0 60 02 cmp %g1, 2 200eb40: 08 80 00 10 bleu 200eb80 200eb44: b0 10 20 04 mov 4, %i0 200eb48: 81 c7 e0 08 ret <== NOT EXECUTED 200eb4c: 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; 200eb50: 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 ) 200eb54: 05 00 80 c9 sethi %hi(0x2032400), %g2 200eb58: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200eb5c: b0 10 20 00 clr %i0 200eb60: 82 00 7f ff add %g1, -1, %g1 200eb64: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 200eb68: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 200eb6c: 80 a0 60 00 cmp %g1, 0 200eb70: 12 80 00 04 bne 200eb80 200eb74: 01 00 00 00 nop _Thread_Dispatch(); 200eb78: 40 00 1c d3 call 2015ec4 <_Thread_Dispatch> 200eb7c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200eb80: 81 c7 e0 08 ret 200eb84: 81 e8 00 00 restore 02012f10 : void *buffer, size_t *size, uint32_t option_set, rtems_interval timeout ) { 2012f10: 9d e3 bf 90 save %sp, -112, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; boolean wait; if ( !buffer ) 2012f14: 80 a6 60 00 cmp %i1, 0 2012f18: 02 80 00 28 be 2012fb8 2012f1c: 92 10 00 18 mov %i0, %o1 return RTEMS_INVALID_ADDRESS; if ( !size ) 2012f20: 80 a6 a0 00 cmp %i2, 0 2012f24: 02 80 00 25 be 2012fb8 2012f28: 11 00 80 a1 sethi %hi(0x2028400), %o0 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 2012f2c: 94 07 bf f4 add %fp, -12, %o2 2012f30: 7f ff e4 3d call 200c024 <_Objects_Get> 2012f34: 90 12 20 bc or %o0, 0xbc, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 2012f38: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012f3c: 80 a0 60 00 cmp %g1, 0 2012f40: 22 80 00 07 be,a 2012f5c 2012f44: d2 02 20 08 ld [ %o0 + 8 ], %o1 2012f48: 80 a0 60 02 cmp %g1, 2 2012f4c: 08 80 00 1c bleu 2012fbc 2012f50: 90 10 20 04 mov 4, %o0 2012f54: 10 80 00 1a b 2012fbc <== NOT EXECUTED 2012f58: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED 2012f5c: 98 0e e0 01 and %i3, 1, %o4 if ( _Options_Is_no_wait( option_set ) ) wait = FALSE; else wait = TRUE; _CORE_message_queue_Seize( 2012f60: 94 10 00 19 mov %i1, %o2 2012f64: 96 10 00 1a mov %i2, %o3 2012f68: 98 1b 20 01 xor %o4, 1, %o4 2012f6c: 9a 10 00 1c mov %i4, %o5 2012f70: 40 00 01 94 call 20135c0 <_CORE_message_queue_Seize> 2012f74: 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 ) 2012f78: 05 00 80 9e sethi %hi(0x2027800), %g2 2012f7c: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 ! 2027a50 <_Thread_Dispatch_disable_level> 2012f80: 82 00 7f ff add %g1, -1, %g1 2012f84: c2 20 a2 50 st %g1, [ %g2 + 0x250 ] 2012f88: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 2012f8c: 80 a0 60 00 cmp %g1, 0 2012f90: 12 80 00 05 bne 2012fa4 2012f94: 03 00 80 9e sethi %hi(0x2027800), %g1 _Thread_Dispatch(); 2012f98: 7f ff e9 28 call 200d438 <_Thread_Dispatch> 2012f9c: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 2012fa0: 03 00 80 9e sethi %hi(0x2027800), %g1 2012fa4: c2 00 63 30 ld [ %g1 + 0x330 ], %g1 ! 2027b30 <_Thread_Executing> 2012fa8: 40 00 00 32 call 2013070 <_Message_queue_Translate_core_message_queue_return_code> 2012fac: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012fb0: 81 c7 e0 08 ret 2012fb4: 91 e8 00 08 restore %g0, %o0, %o0 size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 2012fb8: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012fbc: b0 10 00 08 mov %o0, %i0 2012fc0: 81 c7 e0 08 ret 2012fc4: 81 e8 00 00 restore 02012fc8 : rtems_status_code rtems_message_queue_send( Objects_Id id, void *buffer, size_t size ) { 2012fc8: 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 ) 2012fcc: 80 a6 60 00 cmp %i1, 0 2012fd0: 02 80 00 26 be 2013068 2012fd4: 90 10 20 09 mov 9, %o0 2012fd8: 11 00 80 a1 sethi %hi(0x2028400), %o0 2012fdc: 92 10 00 18 mov %i0, %o1 2012fe0: 90 12 20 bc or %o0, 0xbc, %o0 2012fe4: 7f ff e4 10 call 200c024 <_Objects_Get> 2012fe8: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 2012fec: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012ff0: 80 a0 60 00 cmp %g1, 0 2012ff4: 22 80 00 07 be,a 2013010 2012ff8: 94 10 00 1a mov %i2, %o2 2012ffc: 80 a0 60 02 cmp %g1, 2 2013000: 08 80 00 1a bleu 2013068 2013004: 90 10 20 04 mov 4, %o0 2013008: 10 80 00 18 b 2013068 <== NOT EXECUTED 201300c: 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( 2013010: c0 23 a0 5c clr [ %sp + 0x5c ] 2013014: c0 23 a0 60 clr [ %sp + 0x60 ] 2013018: 92 10 00 19 mov %i1, %o1 201301c: 96 10 00 18 mov %i0, %o3 2013020: 98 10 20 00 clr %o4 2013024: 90 02 20 14 add %o0, 0x14, %o0 2013028: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5 201302c: 40 00 01 b2 call 20136f4 <_CORE_message_queue_Submit> 2013030: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff 2013034: 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 ) 2013038: 05 00 80 9e sethi %hi(0x2027800), %g2 201303c: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 ! 2027a50 <_Thread_Dispatch_disable_level> 2013040: 82 00 7f ff add %g1, -1, %g1 2013044: c2 20 a2 50 st %g1, [ %g2 + 0x250 ] 2013048: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 201304c: 80 a0 60 00 cmp %g1, 0 2013050: 12 80 00 04 bne 2013060 2013054: 01 00 00 00 nop _Thread_Dispatch(); 2013058: 7f ff e8 f8 call 200d438 <_Thread_Dispatch> 201305c: 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); 2013060: 40 00 00 04 call 2013070 <_Message_queue_Translate_core_message_queue_return_code> 2013064: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2013068: 81 c7 e0 08 ret 201306c: 91 e8 00 08 restore %g0, %o0, %o0 0200831c : rtems_status_code rtems_message_queue_urgent( Objects_Id id, void *buffer, size_t size ) { 200831c: 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 ) 2008320: 80 a6 60 00 cmp %i1, 0 2008324: 02 80 00 25 be 20083b8 2008328: 90 10 20 09 mov 9, %o0 200832c: 11 00 80 84 sethi %hi(0x2021000), %o0 2008330: 92 10 00 18 mov %i0, %o1 2008334: 90 12 23 c8 or %o0, 0x3c8, %o0 2008338: 40 00 0a 04 call 200ab48 <_Objects_Get> 200833c: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 2008340: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008344: 80 a0 60 00 cmp %g1, 0 2008348: 22 80 00 07 be,a 2008364 200834c: 94 10 00 1a mov %i2, %o2 2008350: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2008354: 08 80 00 19 bleu 20083b8 <== NOT EXECUTED 2008358: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED 200835c: 10 80 00 17 b 20083b8 <== NOT EXECUTED 2008360: 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( 2008364: c0 23 a0 5c clr [ %sp + 0x5c ] 2008368: c0 23 a0 60 clr [ %sp + 0x60 ] 200836c: 92 10 00 19 mov %i1, %o1 2008370: 96 10 00 18 mov %i0, %o3 2008374: 98 10 20 00 clr %o4 2008378: 1b 20 00 00 sethi %hi(0x80000000), %o5 200837c: 40 00 05 ee call 2009b34 <_CORE_message_queue_Submit> 2008380: 90 02 20 14 add %o0, 0x14, %o0 2008384: 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 ) 2008388: 03 00 80 82 sethi %hi(0x2020800), %g1 200838c: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 20209e0 <_Thread_Dispatch_disable_level> 2008390: 84 00 bf ff add %g2, -1, %g2 2008394: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 2008398: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 200839c: 80 a0 60 00 cmp %g1, 0 20083a0: 12 80 00 04 bne 20083b0 20083a4: 01 00 00 00 nop _Thread_Dispatch(); 20083a8: 40 00 0e ed call 200bf5c <_Thread_Dispatch> 20083ac: 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); 20083b0: 7f ff ff d1 call 20082f4 <_Message_queue_Translate_core_message_queue_return_code> 20083b4: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20083b8: 81 c7 e0 08 ret 20083bc: 91 e8 00 08 restore %g0, %o0, %o0 0200ed78 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 200ed78: 9d e3 bf 98 save %sp, -104, %sp register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 200ed7c: a6 96 20 00 orcc %i0, 0, %l3 200ed80: 02 80 00 1e be 200edf8 200ed84: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 200ed88: 80 a6 60 00 cmp %i1, 0 200ed8c: 02 80 00 3d be 200ee80 200ed90: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 200ed94: 02 80 00 3b be 200ee80 200ed98: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 200ed9c: 22 80 00 17 be,a 200edf8 200eda0: b0 10 20 08 mov 8, %i0 200eda4: 80 a6 e0 00 cmp %i3, 0 200eda8: 22 80 00 14 be,a 200edf8 200edac: b0 10 20 08 mov 8, %i0 200edb0: 80 a6 80 1b cmp %i2, %i3 200edb4: 0a 80 00 35 bcs 200ee88 200edb8: 80 8e e0 07 btst 7, %i3 200edbc: 12 80 00 33 bne 200ee88 200edc0: 80 8e 60 07 btst 7, %i1 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 200edc4: 12 80 00 2f bne 200ee80 200edc8: 05 00 80 c9 sethi %hi(0x2032400), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200edcc: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200edd0: 82 00 60 01 inc %g1 200edd4: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 200edd8: 25 00 80 c8 sethi %hi(0x2032000), %l2 200eddc: 40 00 15 dd call 2014550 <_Objects_Allocate> 200ede0: 90 14 a3 74 or %l2, 0x374, %o0 ! 2032374 <_Partition_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 200ede4: a2 92 20 00 orcc %o0, 0, %l1 200ede8: 12 80 00 06 bne 200ee00 200edec: 92 10 00 1b mov %i3, %o1 _Thread_Enable_dispatch(); 200edf0: 7f ff ff d5 call 200ed44 <_Thread_Enable_dispatch> 200edf4: b0 10 20 05 mov 5, %i0 200edf8: 81 c7 e0 08 ret 200edfc: 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; 200ee00: f8 24 60 1c st %i4, [ %l1 + 0x1c ] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 200ee04: f2 24 60 10 st %i1, [ %l1 + 0x10 ] the_partition->length = length; 200ee08: f4 24 60 14 st %i2, [ %l1 + 0x14 ] the_partition->buffer_size = buffer_size; 200ee0c: f6 24 60 18 st %i3, [ %l1 + 0x18 ] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 200ee10: c0 24 60 20 clr [ %l1 + 0x20 ] _Chain_Initialize( &the_partition->Memory, starting_address, 200ee14: 40 00 55 b9 call 20244f8 <.udiv> 200ee18: 90 10 00 1a mov %i2, %o0 200ee1c: a0 04 60 24 add %l1, 0x24, %l0 200ee20: 94 10 00 08 mov %o0, %o2 200ee24: 92 10 00 19 mov %i1, %o1 200ee28: 90 10 00 10 mov %l0, %o0 200ee2c: 40 00 11 b0 call 20134ec <_Chain_Initialize> 200ee30: 96 10 00 1b mov %i3, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ee34: 90 14 a3 74 or %l2, 0x374, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200ee38: c4 04 60 08 ld [ %l1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ee3c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200ee40: 03 00 00 3f sethi %hi(0xfc00), %g1 200ee44: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200ee48: 82 08 80 01 and %g2, %g1, %g1 200ee4c: 80 a0 40 03 cmp %g1, %g3 200ee50: 38 80 00 06 bgu,a 200ee68 200ee54: c2 04 60 08 ld [ %l1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200ee58: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200ee5c: 83 28 60 02 sll %g1, 2, %g1 200ee60: e2 20 80 01 st %l1, [ %g2 + %g1 ] &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 200ee64: 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; 200ee68: e6 24 60 0c st %l3, [ %l1 + 0xc ] 200ee6c: c2 27 40 00 st %g1, [ %i5 ] name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 200ee70: 7f ff ff b5 call 200ed44 <_Thread_Enable_dispatch> 200ee74: b0 10 20 00 clr %i0 200ee78: 81 c7 e0 08 ret 200ee7c: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 200ee80: 81 c7 e0 08 ret 200ee84: 91 e8 20 09 restore %g0, 9, %o0 200ee88: b0 10 20 08 mov 8, %i0 } 200ee8c: 81 c7 e0 08 ret 200ee90: 81 e8 00 00 restore 0200eec8 : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 200eec8: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200eecc: 92 10 00 18 mov %i0, %o1 200eed0: 94 07 bf f4 add %fp, -12, %o2 200eed4: 31 00 80 c8 sethi %hi(0x2032000), %i0 200eed8: 40 00 16 f6 call 2014ab0 <_Objects_Get> 200eedc: 90 16 23 74 or %i0, 0x374, %o0 ! 2032374 <_Partition_Information> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200eee0: c2 07 bf f4 ld [ %fp + -12 ], %g1 200eee4: 80 a0 60 00 cmp %g1, 0 200eee8: 02 80 00 07 be 200ef04 200eeec: 88 10 00 08 mov %o0, %g4 200eef0: 80 a0 60 02 cmp %g1, 2 200eef4: 08 80 00 18 bleu 200ef54 200eef8: b0 10 20 04 mov 4, %i0 200eefc: 81 c7 e0 08 ret <== NOT EXECUTED 200ef00: 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 ) { 200ef04: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 200ef08: 80 a0 60 00 cmp %g1, 0 200ef0c: 12 80 00 14 bne 200ef5c 200ef10: 90 16 23 74 or %i0, 0x374, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200ef14: c2 01 20 08 ld [ %g4 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ef18: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200ef1c: 05 00 00 3f sethi %hi(0xfc00), %g2 200ef20: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200ef24: 82 08 40 02 and %g1, %g2, %g1 200ef28: 80 a0 40 03 cmp %g1, %g3 200ef2c: 18 80 00 05 bgu 200ef40 200ef30: 92 10 00 04 mov %g4, %o1 information->local_table[ index ] = the_object; 200ef34: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200ef38: 83 28 60 02 sll %g1, 2, %g1 200ef3c: 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; 200ef40: c0 21 20 0c clr [ %g4 + 0xc ] RTEMS_INLINE_ROUTINE void _Partition_Free ( Partition_Control *the_partition ) { _Objects_Free( &_Partition_Information, &the_partition->Object ); 200ef44: 40 00 16 85 call 2014958 <_Objects_Free> 200ef48: b0 10 20 00 clr %i0 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 200ef4c: 7f ff ff d2 call 200ee94 <_Thread_Enable_dispatch> 200ef50: 01 00 00 00 nop 200ef54: 81 c7 e0 08 ret 200ef58: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 200ef5c: 7f ff ff ce call 200ee94 <_Thread_Enable_dispatch> 200ef60: b0 10 20 0c mov 0xc, %i0 return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200ef64: 81 c7 e0 08 ret 200ef68: 81 e8 00 00 restore 0200efa0 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 200efa0: 9d e3 bf 90 save %sp, -112, %sp 200efa4: 92 10 00 18 mov %i0, %o1 register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 200efa8: 80 a6 60 00 cmp %i1, 0 200efac: 02 80 00 1a be 200f014 200efb0: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200efb4: 11 00 80 c8 sethi %hi(0x2032000), %o0 200efb8: 94 07 bf f4 add %fp, -12, %o2 200efbc: 40 00 16 bd call 2014ab0 <_Objects_Get> 200efc0: 90 12 23 74 or %o0, 0x374, %o0 return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200efc4: c2 07 bf f4 ld [ %fp + -12 ], %g1 200efc8: 80 a0 60 00 cmp %g1, 0 200efcc: 02 80 00 07 be 200efe8 200efd0: b0 10 00 08 mov %o0, %i0 200efd4: 80 a0 60 02 cmp %g1, 2 200efd8: 08 80 00 0f bleu 200f014 200efdc: b0 10 20 04 mov 4, %i0 200efe0: 81 c7 e0 08 ret <== NOT EXECUTED 200efe4: 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 ); 200efe8: 40 00 11 31 call 20134ac <_Chain_Get> 200efec: 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 ) { 200eff0: a0 92 20 00 orcc %o0, 0, %l0 200eff4: 02 80 00 0a be 200f01c 200eff8: 01 00 00 00 nop the_partition->number_of_used_blocks += 1; 200effc: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 200f000: 82 00 60 01 inc %g1 200f004: c2 26 20 20 st %g1, [ %i0 + 0x20 ] _Thread_Enable_dispatch(); 200f008: 7f ff ff d9 call 200ef6c <_Thread_Enable_dispatch> 200f00c: b0 10 20 00 clr %i0 *buffer = the_buffer; 200f010: e0 26 40 00 st %l0, [ %i1 ] 200f014: 81 c7 e0 08 ret 200f018: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 200f01c: 7f ff ff d4 call 200ef6c <_Thread_Enable_dispatch> 200f020: b0 10 20 0d mov 0xd, %i0 return RTEMS_UNSATISFIED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f024: 81 c7 e0 08 ret 200f028: 81 e8 00 00 restore 0200f094 : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 200f094: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200f098: 11 00 80 c8 sethi %hi(0x2032000), %o0 200f09c: 92 10 00 18 mov %i0, %o1 200f0a0: 90 12 23 74 or %o0, 0x374, %o0 200f0a4: 40 00 16 83 call 2014ab0 <_Objects_Get> 200f0a8: 94 07 bf f4 add %fp, -12, %o2 register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f0ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f0b0: 80 a0 60 00 cmp %g1, 0 200f0b4: 02 80 00 07 be 200f0d0 200f0b8: b0 10 00 08 mov %o0, %i0 200f0bc: 80 a0 60 02 cmp %g1, 2 200f0c0: 08 80 00 1a bleu 200f128 200f0c4: b0 10 20 04 mov 4, %i0 200f0c8: 81 c7 e0 08 ret <== NOT EXECUTED 200f0cc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED ) { void *starting; void *ending; starting = the_partition->starting_address; 200f0d0: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( 200f0d4: 80 a6 40 02 cmp %i1, %g2 200f0d8: 0a 80 00 16 bcs 200f130 200f0dc: 01 00 00 00 nop 200f0e0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200f0e4: 82 00 80 01 add %g2, %g1, %g1 200f0e8: 80 a6 40 01 cmp %i1, %g1 200f0ec: 18 80 00 11 bgu 200f130 200f0f0: 01 00 00 00 nop 200f0f4: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 200f0f8: 40 00 55 ac call 20247a8 <.urem> 200f0fc: 90 26 40 02 sub %i1, %g2, %o0 200f100: 80 a2 20 00 cmp %o0, 0 200f104: 12 80 00 0b bne 200f130 200f108: 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 ); 200f10c: 40 00 10 dc call 201347c <_Chain_Append> 200f110: 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; 200f114: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 200f118: 82 00 7f ff add %g1, -1, %g1 200f11c: c2 26 20 20 st %g1, [ %i0 + 0x20 ] _Thread_Enable_dispatch(); 200f120: 7f ff ff d0 call 200f060 <_Thread_Enable_dispatch> 200f124: b0 10 20 00 clr %i0 200f128: 81 c7 e0 08 ret 200f12c: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 200f130: 7f ff ff cc call 200f060 <_Thread_Enable_dispatch> 200f134: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f138: 81 c7 e0 08 ret 200f13c: 81 e8 00 00 restore 0200df3c : void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) { 200df3c: 9d e3 bf 98 save %sp, -104, %sp register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 200df40: a2 96 20 00 orcc %i0, 0, %l1 200df44: 02 80 00 15 be 200df98 200df48: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 200df4c: 80 a7 20 00 cmp %i4, 0 200df50: 02 80 00 29 be 200dff4 200df54: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 200df58: 12 80 00 27 bne 200dff4 200df5c: 80 8e a0 07 btst 7, %i2 200df60: 32 80 00 0e bne,a 200df98 200df64: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200df68: 05 00 80 c9 sethi %hi(0x2032400), %g2 200df6c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200df70: 82 00 60 01 inc %g1 200df74: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] */ RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Allocate ( void ) { return (Dual_ported_memory_Control *) 200df78: 21 00 80 c8 sethi %hi(0x2032000), %l0 200df7c: 40 00 19 75 call 2014550 <_Objects_Allocate> 200df80: 90 14 23 28 or %l0, 0x328, %o0 ! 2032328 <_Dual_ported_memory_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 200df84: 80 a2 20 00 cmp %o0, 0 200df88: 12 80 00 06 bne 200dfa0 200df8c: 88 14 23 28 or %l0, 0x328, %g4 _Thread_Enable_dispatch(); 200df90: 7f ff ff de call 200df08 <_Thread_Enable_dispatch> 200df94: b0 10 20 05 mov 5, %i0 200df98: 81 c7 e0 08 ret 200df9c: 81 e8 00 00 restore ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200dfa0: c4 02 20 08 ld [ %o0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200dfa4: 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; 200dfa8: 82 06 ff ff add %i3, -1, %g1 if ( !the_port ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 200dfac: f2 22 20 10 st %i1, [ %o0 + 0x10 ] the_port->external_base = external_start; the_port->length = length - 1; 200dfb0: c2 22 20 18 st %g1, [ %o0 + 0x18 ] 200dfb4: 03 00 00 3f sethi %hi(0xfc00), %g1 200dfb8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200dfbc: 82 08 80 01 and %g2, %g1, %g1 200dfc0: 80 a0 40 03 cmp %g1, %g3 200dfc4: 18 80 00 05 bgu 200dfd8 200dfc8: f4 22 20 14 st %i2, [ %o0 + 0x14 ] information->local_table[ index ] = the_object; 200dfcc: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 200dfd0: 83 28 60 02 sll %g1, 2, %g1 200dfd4: d0 20 80 01 st %o0, [ %g2 + %g1 ] &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 200dfd8: 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; 200dfdc: e2 22 20 0c st %l1, [ %o0 + 0xc ] 200dfe0: c2 27 00 00 st %g1, [ %i4 ] _Thread_Enable_dispatch(); 200dfe4: 7f ff ff c9 call 200df08 <_Thread_Enable_dispatch> 200dfe8: b0 10 20 00 clr %i0 200dfec: 81 c7 e0 08 ret 200dff0: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 200dff4: b0 10 20 09 mov 9, %i0 } 200dff8: 81 c7 e0 08 ret 200dffc: 81 e8 00 00 restore 02006444 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) { 2006444: 9d e3 bf 98 save %sp, -104, %sp Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 2006448: a4 96 20 00 orcc %i0, 0, %l2 200644c: 02 80 00 11 be 2006490 2006450: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2006454: 80 a6 60 00 cmp %i1, 0 2006458: 02 80 00 0e be 2006490 200645c: b0 10 20 09 mov 9, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006460: 05 00 80 76 sethi %hi(0x201d800), %g2 2006464: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1 ! 201d8e0 <_Thread_Dispatch_disable_level> 2006468: 82 00 60 01 inc %g1 200646c: c2 20 a0 e0 st %g1, [ %g2 + 0xe0 ] * the inactive chain of free period control blocks. */ RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void ) { return (Rate_monotonic_Control *) 2006470: 23 00 80 75 sethi %hi(0x201d400), %l1 2006474: 40 00 09 de call 2008bec <_Objects_Allocate> 2006478: 90 14 63 44 or %l1, 0x344, %o0 ! 201d744 <_Rate_monotonic_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 200647c: a0 92 20 00 orcc %o0, 0, %l0 2006480: 12 80 00 06 bne 2006498 2006484: 03 00 80 76 sethi %hi(0x201d800), %g1 _Thread_Enable_dispatch(); 2006488: 7f ff ff e2 call 2006410 <_Thread_Enable_dispatch> 200648c: b0 10 20 05 mov 5, %i0 2006490: 81 c7 e0 08 ret 2006494: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 2006498: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 the_period->state = RATE_MONOTONIC_INACTIVE; 200649c: c0 24 20 38 clr [ %l0 + 0x38 ] if ( !the_period ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 20064a0: c2 24 20 50 st %g1, [ %l0 + 0x50 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20064a4: c0 24 20 18 clr [ %l0 + 0x18 ] the_watchdog->routine = routine; 20064a8: c0 24 20 2c clr [ %l0 + 0x2c ] the_watchdog->id = id; 20064ac: c0 24 20 30 clr [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 20064b0: 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 ); 20064b4: 90 04 20 54 add %l0, 0x54, %o0 20064b8: 92 10 20 00 clr %o1 20064bc: 40 00 28 cd call 20107f0 20064c0: 94 10 20 38 mov 0x38, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20064c4: 90 14 63 44 or %l1, 0x344, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 20064c8: c4 04 20 08 ld [ %l0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20064cc: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 20064d0: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 20064d4: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff 20064d8: c2 24 20 78 st %g1, [ %l0 + 0x78 ] 20064dc: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 20064e0: c2 24 20 60 st %g1, [ %l0 + 0x60 ] 20064e4: c2 24 20 74 st %g1, [ %l0 + 0x74 ] 20064e8: 03 00 00 3f sethi %hi(0xfc00), %g1 20064ec: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20064f0: 82 08 80 01 and %g2, %g1, %g1 20064f4: 80 a0 40 03 cmp %g1, %g3 20064f8: 38 80 00 06 bgu,a 2006510 20064fc: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 2006500: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006504: 83 28 60 02 sll %g1, 2, %g1 2006508: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 200650c: 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; 2006510: e4 24 20 0c st %l2, [ %l0 + 0xc ] 2006514: c2 26 40 00 st %g1, [ %i1 ] _Thread_Enable_dispatch(); 2006518: 7f ff ff be call 2006410 <_Thread_Enable_dispatch> 200651c: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 2006520: 81 c7 e0 08 ret 2006524: 81 e8 00 00 restore 0200f310 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 200f310: 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 *) 200f314: 21 00 80 c8 sethi %hi(0x2032000), %l0 200f318: 92 10 00 18 mov %i0, %o1 200f31c: 94 07 bf f4 add %fp, -12, %o2 200f320: 40 00 15 e4 call 2014ab0 <_Objects_Get> 200f324: 90 14 23 c0 or %l0, 0x3c0, %o0 Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200f328: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f32c: 80 a0 60 00 cmp %g1, 0 200f330: 02 80 00 08 be 200f350 200f334: b0 10 00 08 mov %o0, %i0 200f338: 82 18 60 02 xor %g1, 2, %g1 200f33c: 80 a0 00 01 cmp %g0, %g1 200f340: 82 60 20 00 subx %g0, 0, %g1 200f344: b0 08 60 15 and %g1, 0x15, %i0 200f348: 81 c7 e0 08 ret 200f34c: 91 ee 20 04 restore %i0, 4, %o0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f350: a0 14 23 c0 or %l0, 0x3c0, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200f354: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f358: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 200f35c: 05 00 00 3f sethi %hi(0xfc00), %g2 200f360: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200f364: 82 08 40 02 and %g1, %g2, %g1 200f368: 80 a0 40 03 cmp %g1, %g3 200f36c: 38 80 00 06 bgu,a 200f384 200f370: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200f374: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 200f378: 83 28 60 02 sll %g1, 2, %g1 200f37c: 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; 200f380: 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 ); 200f384: 40 00 21 5e call 20178fc <_Watchdog_Remove> 200f388: 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 ); 200f38c: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_INACTIVE; 200f390: c0 26 20 38 clr [ %i0 + 0x38 ] 200f394: 40 00 15 71 call 2014958 <_Objects_Free> 200f398: 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 ) 200f39c: 03 00 80 c9 sethi %hi(0x2032400), %g1 200f3a0: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20325f0 <_Thread_Dispatch_disable_level> 200f3a4: b0 10 20 00 clr %i0 200f3a8: 84 00 bf ff add %g2, -1, %g2 200f3ac: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 200f3b0: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 200f3b4: 80 a0 60 00 cmp %g1, 0 200f3b8: 12 80 00 04 bne 200f3c8 200f3bc: 01 00 00 00 nop _Thread_Dispatch(); 200f3c0: 40 00 1a c1 call 2015ec4 <_Thread_Dispatch> 200f3c4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f3c8: 81 c7 e0 08 ret 200f3cc: 81 e8 00 00 restore 0200e454 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 200e454: 9d e3 bf 88 save %sp, -120, %sp 200e458: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 200e45c: 80 a6 60 00 cmp %i1, 0 200e460: 02 80 00 36 be 200e538 200e464: b0 10 20 09 mov 9, %i0 200e468: 11 00 80 75 sethi %hi(0x201d400), %o0 200e46c: 94 07 bf f4 add %fp, -12, %o2 200e470: 7f ff eb 6c call 2009220 <_Objects_Get> 200e474: 90 12 23 44 or %o0, 0x344, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200e478: c2 07 bf f4 ld [ %fp + -12 ], %g1 200e47c: 80 a0 60 00 cmp %g1, 0 200e480: 02 80 00 08 be 200e4a0 200e484: b0 10 00 08 mov %o0, %i0 200e488: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 200e48c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 200e490: 82 60 20 00 subx %g0, 0, %g1 <== NOT EXECUTED 200e494: b0 08 60 15 and %g1, 0x15, %i0 <== NOT EXECUTED 200e498: 81 c7 e0 08 ret <== NOT EXECUTED 200e49c: 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); 200e4a0: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 200e4a4: 80 a0 60 00 cmp %g1, 0 200e4a8: 02 80 00 03 be 200e4b4 200e4ac: 84 10 20 00 clr %g2 200e4b0: c4 00 60 08 ld [ %g1 + 8 ], %g2 status->state = the_period->state; 200e4b4: 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); 200e4b8: c4 26 40 00 st %g2, [ %i1 ] status->state = the_period->state; if ( status->state == RATE_MONOTONIC_INACTIVE ) { 200e4bc: 80 a0 60 00 cmp %g1, 0 200e4c0: 12 80 00 07 bne 200e4dc 200e4c4: 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; 200e4c8: 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; 200e4cc: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 200e4d0: 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; 200e4d4: 10 80 00 0e b 200e50c <== NOT EXECUTED 200e4d8: 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 ); 200e4dc: a0 07 bf ec add %fp, -20, %l0 200e4e0: 7f ff e8 21 call 2008564 <_TOD_Get_uptime> 200e4e4: 90 10 00 10 mov %l0, %o0 #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 200e4e8: 90 06 20 44 add %i0, 0x44, %o0 200e4ec: 92 10 00 10 mov %l0, %o1 200e4f0: 7f ff f5 07 call 200b90c <_Timespec_Subtract> 200e4f4: 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( 200e4f8: 11 00 80 76 sethi %hi(0x201d800), %o0 200e4fc: 92 10 00 10 mov %l0, %o1 200e500: 94 06 60 10 add %i1, 0x10, %o2 200e504: 7f ff f5 02 call 200b90c <_Timespec_Subtract> 200e508: 90 12 21 c8 or %o0, 0x1c8, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200e50c: 03 00 80 76 sethi %hi(0x201d800), %g1 200e510: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 201d8e0 <_Thread_Dispatch_disable_level> 200e514: b0 10 20 00 clr %i0 200e518: 84 00 bf ff add %g2, -1, %g2 200e51c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 200e520: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 200e524: 80 a0 60 00 cmp %g1, 0 200e528: 12 80 00 04 bne 200e538 200e52c: 01 00 00 00 nop _Thread_Dispatch(); 200e530: 7f ff f0 41 call 200a634 <_Thread_Dispatch> 200e534: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e538: 81 c7 e0 08 ret 200e53c: 81 e8 00 00 restore 02006730 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 2006730: 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 *) 2006734: 11 00 80 75 sethi %hi(0x201d400), %o0 2006738: 92 10 00 18 mov %i0, %o1 200673c: 90 12 23 44 or %o0, 0x344, %o0 2006740: 40 00 0a b8 call 2009220 <_Objects_Get> 2006744: 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 ) { 2006748: c2 07 bf f4 ld [ %fp + -12 ], %g1 200674c: 80 a0 60 00 cmp %g1, 0 2006750: 02 80 00 07 be 200676c 2006754: a2 10 00 08 mov %o0, %l1 2006758: 80 a0 60 02 cmp %g1, 2 200675c: 02 80 00 0c be 200678c 2006760: 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; 2006764: 81 c7 e0 08 ret <== NOT EXECUTED 2006768: 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 ) ) { 200676c: 27 00 80 76 sethi %hi(0x201d800), %l3 2006770: c4 02 20 50 ld [ %o0 + 0x50 ], %g2 2006774: c2 04 e1 c0 ld [ %l3 + 0x1c0 ], %g1 2006778: 80 a0 80 01 cmp %g2, %g1 200677c: 02 80 00 06 be 2006794 2006780: 80 a6 60 00 cmp %i1, 0 _Thread_Enable_dispatch(); 2006784: 7f ff ff 7f call 2006580 <_Thread_Enable_dispatch> 2006788: b0 10 20 17 mov 0x17, %i0 200678c: 81 c7 e0 08 ret 2006790: 81 e8 00 00 restore return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 2006794: 12 80 00 11 bne 20067d8 2006798: 01 00 00 00 nop switch ( the_period->state ) { 200679c: d0 02 20 38 ld [ %o0 + 0x38 ], %o0 20067a0: 80 a2 20 02 cmp %o0, 2 20067a4: 02 80 00 09 be 20067c8 20067a8: b0 10 20 00 clr %i0 20067ac: 80 a2 20 04 cmp %o0, 4 20067b0: 02 80 00 06 be 20067c8 20067b4: b0 10 20 06 mov 6, %i0 20067b8: 80 a2 20 00 cmp %o0, 0 20067bc: 02 80 00 03 be 20067c8 20067c0: b0 10 20 0b mov 0xb, %i0 20067c4: 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(); 20067c8: 7f ff ff 6e call 2006580 <_Thread_Enable_dispatch> 20067cc: 01 00 00 00 nop 20067d0: 81 c7 e0 08 ret 20067d4: 81 e8 00 00 restore return( return_value ); } _ISR_Disable( level ); 20067d8: 7f ff f0 43 call 20028e4 20067dc: 01 00 00 00 nop 20067e0: a0 10 00 08 mov %o0, %l0 switch ( the_period->state ) { 20067e4: e4 04 60 38 ld [ %l1 + 0x38 ], %l2 20067e8: 80 a4 a0 02 cmp %l2, 2 20067ec: 02 80 00 29 be 2006890 20067f0: 80 a4 a0 04 cmp %l2, 4 20067f4: 02 80 00 43 be 2006900 20067f8: 80 a4 a0 00 cmp %l2, 0 20067fc: 32 bf ff e4 bne,a 200678c 2006800: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED /* * No need to update statistics -- there are not a period active */ _ISR_Enable( level ); 2006804: 7f ff f0 3c call 20028f4 2006808: 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 ); 200680c: 40 00 07 56 call 2008564 <_TOD_Get_uptime> 2006810: 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; 2006814: c2 07 bf ec ld [ %fp + -20 ], %g1 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006818: c4 04 e1 c0 ld [ %l3 + 0x1c0 ], %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; 200681c: c2 24 60 44 st %g1, [ %l1 + 0x44 ] 2006820: 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( 2006824: 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; 2006828: c2 24 60 48 st %g1, [ %l1 + 0x48 ] #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 200682c: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006830: a0 07 bf e4 add %fp, -28, %l0 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006834: c2 24 60 3c st %g1, [ %l1 + 0x3c ] 2006838: c2 00 a0 94 ld [ %g2 + 0x94 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 200683c: 94 10 00 10 mov %l0, %o2 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006840: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006844: 11 00 80 76 sethi %hi(0x201d800), %o0 2006848: 40 00 14 31 call 200b90c <_Timespec_Subtract> 200684c: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 201d9c8 <_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 ); 2006850: 92 10 00 10 mov %l0, %o1 2006854: 40 00 13 cd call 200b788 <_Timespec_Add_to> 2006858: 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; 200685c: 82 10 20 02 mov 2, %g1 2006860: c2 24 60 38 st %g1, [ %l1 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2006864: 03 00 80 1b sethi %hi(0x2006c00), %g1 2006868: 82 10 60 98 or %g1, 0x98, %g1 ! 2006c98 <_Rate_monotonic_Timeout> NULL ); the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); 200686c: 90 04 60 10 add %l1, 0x10, %o0 2006870: 92 10 00 19 mov %i1, %o1 the_watchdog->id = id; 2006874: f0 24 60 30 st %i0, [ %l1 + 0x30 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2006878: c0 24 60 18 clr [ %l1 + 0x18 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 200687c: c0 24 60 34 clr [ %l1 + 0x34 ] _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 2006880: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert_ticks( &the_period->Timer, length ); 2006884: 7f ff ff 37 call 2006560 <_Watchdog_Insert_ticks> 2006888: c2 24 60 2c st %g1, [ %l1 + 0x2c ] 200688c: 30 80 00 19 b,a 20068f0 case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 2006890: 7f ff ff 49 call 20065b4 <_Rate_monotonic_Update_statistics> 2006894: 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; 2006898: 82 10 20 01 mov 1, %g1 the_period->next_length = length; 200689c: 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; 20068a0: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; _ISR_Enable( level ); 20068a4: 7f ff f0 14 call 20028f4 20068a8: 90 10 00 10 mov %l0, %o0 _Thread_Executing->Wait.id = the_period->Object.id; 20068ac: c2 04 e1 c0 ld [ %l3 + 0x1c0 ], %g1 20068b0: c4 04 60 08 ld [ %l1 + 8 ], %g2 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 20068b4: 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; 20068b8: c4 20 60 20 st %g2, [ %g1 + 0x20 ] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 20068bc: 40 00 12 89 call 200b2e0 <_Thread_Set_state> 20068c0: 13 00 00 10 sethi %hi(0x4000), %o1 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 20068c4: 7f ff f0 08 call 20028e4 20068c8: 01 00 00 00 nop local_state = the_period->state; 20068cc: e0 04 60 38 ld [ %l1 + 0x38 ], %l0 the_period->state = RATE_MONOTONIC_ACTIVE; 20068d0: e4 24 60 38 st %l2, [ %l1 + 0x38 ] _ISR_Enable( level ); 20068d4: 7f ff f0 08 call 20028f4 20068d8: 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 ) 20068dc: 80 a4 20 03 cmp %l0, 3 20068e0: 12 80 00 04 bne 20068f0 20068e4: d0 04 e1 c0 ld [ %l3 + 0x1c0 ], %o0 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 20068e8: 40 00 0e 88 call 200a308 <_Thread_Clear_state> <== NOT EXECUTED 20068ec: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED _Thread_Enable_dispatch(); 20068f0: 7f ff ff 24 call 2006580 <_Thread_Enable_dispatch> 20068f4: b0 10 20 00 clr %i0 20068f8: 81 c7 e0 08 ret 20068fc: 81 e8 00 00 restore case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 2006900: 7f ff ff 2d call 20065b4 <_Rate_monotonic_Update_statistics> 2006904: 90 10 00 11 mov %l1, %o0 _ISR_Enable( level ); 2006908: 7f ff ef fb call 20028f4 200690c: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 2006910: 82 10 20 02 mov 2, %g1 the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); 2006914: 90 04 60 10 add %l1, 0x10, %o0 2006918: 92 10 00 19 mov %i1, %o1 */ _Rate_monotonic_Update_statistics( the_period ); _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 200691c: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; 2006920: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert_ticks( &the_period->Timer, length ); 2006924: 7f ff ff 0f call 2006560 <_Watchdog_Insert_ticks> 2006928: b0 10 20 06 mov 6, %i0 _Thread_Enable_dispatch(); 200692c: 7f ff ff 15 call 2006580 <_Thread_Enable_dispatch> 2006930: 01 00 00 00 nop 2006934: 81 c7 e0 08 ret 2006938: 81 e8 00 00 restore break; } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200693c: 81 c7 e0 08 ret <== NOT EXECUTED 2006940: 81 e8 00 00 restore <== NOT EXECUTED 02006944 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 2006944: 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 ) 2006948: 80 a6 60 00 cmp %i1, 0 200694c: 02 80 00 7f be 2006b48 2006950: 90 10 00 18 mov %i0, %o0 return; (*print)( context, "Period information by period\n" ); 2006954: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006958: 9f c6 40 00 call %i1 200695c: 92 12 61 60 or %o1, 0x160, %o1 ! 201ad60 #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 2006960: 90 10 00 18 mov %i0, %o0 2006964: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006968: 9f c6 40 00 call %i1 200696c: 92 12 61 80 or %o1, 0x180, %o1 ! 201ad80 #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 2006970: 90 10 00 18 mov %i0, %o0 2006974: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006978: 9f c6 40 00 call %i1 200697c: 92 12 61 a8 or %o1, 0x1a8, %o1 ! 201ada8 Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 2006980: 90 10 00 18 mov %i0, %o0 2006984: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006988: 9f c6 40 00 call %i1 200698c: 92 12 61 d0 or %o1, 0x1d0, %o1 ! 201add0 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 2006990: 90 10 00 18 mov %i0, %o0 2006994: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006998: 9f c6 40 00 call %i1 200699c: 92 12 62 20 or %o1, 0x220, %o1 ! 201ae20 /* * 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 ; 20069a0: 03 00 80 75 sethi %hi(0x201d400), %g1 20069a4: 82 10 63 44 or %g1, 0x344, %g1 ! 201d744 <_Rate_monotonic_Information> 20069a8: e4 00 60 08 ld [ %g1 + 8 ], %l2 _Timespec_Divide_by_integer( &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 20069ac: 03 00 80 6b sethi %hi(0x201ac00), %g1 20069b0: b4 10 62 88 or %g1, 0x288, %i2 ! 201ae88 _Timespec_Divide_by_integer( &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 20069b4: 03 00 80 6b sethi %hi(0x201ac00), %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 ); 20069b8: ba 07 bf 98 add %fp, -104, %i5 _Timespec_Divide_by_integer( &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 20069bc: b6 10 62 a8 or %g1, 0x2a8, %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 ); 20069c0: 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" ); 20069c4: 03 00 80 6b sethi %hi(0x201ac00), %g1 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 20069c8: 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" ); 20069cc: b8 10 61 a0 or %g1, 0x1a0, %i4 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 20069d0: ac 07 bf b0 add %fp, -80, %l6 20069d4: 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( 20069d8: 10 80 00 56 b 2006b30 20069dc: 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 ); 20069e0: 40 00 1e 79 call 200e3c4 20069e4: 92 10 00 1d mov %i5, %o1 if ( status != RTEMS_SUCCESSFUL ) 20069e8: 80 a2 20 00 cmp %o0, 0 20069ec: 32 80 00 51 bne,a 2006b30 20069f0: 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 ); 20069f4: 92 10 00 17 mov %l7, %o1 20069f8: 40 00 1e 97 call 200e454 20069fc: 90 10 00 12 mov %l2, %o0 if ( status != RTEMS_SUCCESSFUL ) 2006a00: 80 a2 20 00 cmp %o0, 0 2006a04: 32 80 00 4b bne,a 2006b30 2006a08: a4 04 a0 01 inc %l2 <== NOT EXECUTED continue; name[ 0 ] = '\0'; if ( the_status.owner ) { 2006a0c: d0 07 bf d0 ld [ %fp + -48 ], %o0 2006a10: 80 a2 20 00 cmp %o0, 0 2006a14: 02 80 00 05 be 2006a28 2006a18: c0 2f bf f3 clrb [ %fp + -13 ] rtems_object_get_name( the_status.owner, sizeof(name), name ); 2006a1c: 94 10 00 14 mov %l4, %o2 2006a20: 40 00 00 c8 call 2006d40 2006a24: 92 10 20 05 mov 5, %o1 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 2006a28: d8 1f bf 98 ldd [ %fp + -104 ], %o4 2006a2c: 94 10 00 12 mov %l2, %o2 2006a30: 96 10 00 14 mov %l4, %o3 2006a34: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006a38: 90 10 00 18 mov %i0, %o0 2006a3c: 9f c6 40 00 call %i1 2006a40: 92 12 62 70 or %o1, 0x270, %o1 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006a44: c2 07 bf 98 ld [ %fp + -104 ], %g1 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006a48: 94 10 00 13 mov %l3, %o2 2006a4c: 90 10 00 16 mov %l6, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006a50: 80 a0 60 00 cmp %g1, 0 2006a54: 12 80 00 06 bne 2006a6c 2006a58: 92 10 00 1c mov %i4, %o1 (*print)( context, "\n" ); 2006a5c: 9f c6 40 00 call %i1 2006a60: 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++ ) { 2006a64: 10 80 00 33 b 2006b30 2006a68: a4 04 a0 01 inc %l2 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006a6c: 40 00 13 5f call 200b7e8 <_Timespec_Divide_by_integer> 2006a70: 92 10 00 01 mov %g1, %o1 &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 2006a74: d0 07 bf a4 ld [ %fp + -92 ], %o0 2006a78: 40 00 47 b6 call 2018950 <.div> 2006a7c: 92 10 23 e8 mov 0x3e8, %o1 2006a80: a2 10 00 08 mov %o0, %l1 2006a84: d0 07 bf ac ld [ %fp + -84 ], %o0 2006a88: 40 00 47 b2 call 2018950 <.div> 2006a8c: 92 10 23 e8 mov 0x3e8, %o1 2006a90: c2 07 bf e8 ld [ %fp + -24 ], %g1 2006a94: a0 10 00 08 mov %o0, %l0 2006a98: d0 07 bf ec ld [ %fp + -20 ], %o0 2006a9c: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2006aa0: 40 00 47 ac call 2018950 <.div> 2006aa4: 92 10 23 e8 mov 0x3e8, %o1 2006aa8: d8 07 bf a8 ld [ %fp + -88 ], %o4 2006aac: d4 07 bf a0 ld [ %fp + -96 ], %o2 2006ab0: 96 10 00 11 mov %l1, %o3 2006ab4: 9a 10 00 10 mov %l0, %o5 2006ab8: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 2006abc: 92 10 00 1a mov %i2, %o1 2006ac0: 9f c6 40 00 call %i1 2006ac4: 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( 2006ac8: d2 07 bf 98 ld [ %fp + -104 ], %o1 2006acc: 94 10 00 13 mov %l3, %o2 2006ad0: 40 00 13 46 call 200b7e8 <_Timespec_Divide_by_integer> 2006ad4: 90 10 00 15 mov %l5, %o0 &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 2006ad8: d0 07 bf bc ld [ %fp + -68 ], %o0 2006adc: 40 00 47 9d call 2018950 <.div> 2006ae0: 92 10 23 e8 mov 0x3e8, %o1 2006ae4: a2 10 00 08 mov %o0, %l1 2006ae8: d0 07 bf c4 ld [ %fp + -60 ], %o0 2006aec: 40 00 47 99 call 2018950 <.div> 2006af0: 92 10 23 e8 mov 0x3e8, %o1 2006af4: c2 07 bf e8 ld [ %fp + -24 ], %g1 2006af8: a0 10 00 08 mov %o0, %l0 2006afc: d0 07 bf ec ld [ %fp + -20 ], %o0 2006b00: 92 10 23 e8 mov 0x3e8, %o1 2006b04: 40 00 47 93 call 2018950 <.div> 2006b08: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2006b0c: d4 07 bf b8 ld [ %fp + -72 ], %o2 2006b10: d8 07 bf c0 ld [ %fp + -64 ], %o4 2006b14: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 2006b18: 96 10 00 11 mov %l1, %o3 2006b1c: 9a 10 00 10 mov %l0, %o5 2006b20: 90 10 00 18 mov %i0, %o0 2006b24: 9f c6 40 00 call %i1 2006b28: 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++ ) { 2006b2c: 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 ; 2006b30: 05 00 80 75 sethi %hi(0x201d400), %g2 2006b34: 84 10 a3 44 or %g2, 0x344, %g2 ! 201d744 <_Rate_monotonic_Information> 2006b38: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 2006b3c: 80 a4 80 01 cmp %l2, %g1 2006b40: 08 bf ff a8 bleu 20069e0 2006b44: 90 10 00 12 mov %l2, %o0 2006b48: 81 c7 e0 08 ret 2006b4c: 81 e8 00 00 restore 02006b6c : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 2006b6c: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006b70: 03 00 80 76 sethi %hi(0x201d800), %g1 2006b74: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 201d8e0 <_Thread_Dispatch_disable_level> 2006b78: 84 00 a0 01 inc %g2 2006b7c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] /* * 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 ; 2006b80: 03 00 80 75 sethi %hi(0x201d400), %g1 2006b84: 82 10 63 44 or %g1, 0x344, %g1 ! 201d744 <_Rate_monotonic_Information> 2006b88: e0 00 60 08 ld [ %g1 + 8 ], %l0 id <= _Rate_monotonic_Information.maximum_id ; 2006b8c: 10 80 00 04 b 2006b9c 2006b90: a2 10 00 01 mov %g1, %l1 id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 2006b94: 40 00 00 12 call 2006bdc 2006b98: 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 ; 2006b9c: c2 04 60 0c ld [ %l1 + 0xc ], %g1 2006ba0: 80 a4 00 01 cmp %l0, %g1 2006ba4: 08 bf ff fc bleu 2006b94 2006ba8: 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 ) 2006bac: 03 00 80 76 sethi %hi(0x201d800), %g1 2006bb0: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 201d8e0 <_Thread_Dispatch_disable_level> 2006bb4: 84 00 bf ff add %g2, -1, %g2 2006bb8: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 2006bbc: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 2006bc0: 80 a0 60 00 cmp %g1, 0 2006bc4: 12 80 00 04 bne 2006bd4 2006bc8: 01 00 00 00 nop _Thread_Dispatch(); 2006bcc: 40 00 0e 9a call 200a634 <_Thread_Dispatch> 2006bd0: 81 e8 00 00 restore 2006bd4: 81 c7 e0 08 ret <== NOT EXECUTED 2006bd8: 81 e8 00 00 restore <== NOT EXECUTED 0200f8e8 : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 200f8e8: 9d e3 bf 98 save %sp, -104, %sp Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 200f8ec: a4 96 20 00 orcc %i0, 0, %l2 200f8f0: 02 80 00 87 be 200fb0c 200f8f4: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 200f8f8: 80 a6 60 00 cmp %i1, 0 200f8fc: 02 80 00 c7 be 200fc18 200f900: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 200f904: 02 80 00 c5 be 200fc18 200f908: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 200f90c: 32 80 00 80 bne,a 200fb0c 200f910: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 200f914: 7f ff eb 8b call 200a740 200f918: 01 00 00 00 nop 200f91c: a2 10 00 08 mov %o0, %l1 200f920: 03 00 80 c9 sethi %hi(0x2032400), %g1 200f924: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200f928: 80 a0 60 00 cmp %g1, 0 200f92c: 02 80 00 0b be 200f958 200f930: 03 00 80 c9 sethi %hi(0x2032400), %g1 200f934: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200f938: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 20327d0 <_System_state_Current> <== NOT EXECUTED 200f93c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200f940: 08 80 00 05 bleu 200f954 <== NOT EXECUTED 200f944: 90 10 20 00 clr %o0 <== NOT EXECUTED 200f948: 92 10 20 00 clr %o1 <== NOT EXECUTED 200f94c: 40 00 12 d4 call 201449c <_Internal_error_Occurred> <== NOT EXECUTED 200f950: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200f954: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200f958: e0 00 62 c8 ld [ %g1 + 0x2c8 ], %l0 ! 20326c8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200f95c: 03 00 80 c9 sethi %hi(0x2032400), %g1 200f960: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 20326d0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200f964: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200f968: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 200f96c: 80 a0 60 00 cmp %g1, 0 200f970: 22 80 00 30 be,a 200fa30 200f974: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200f978: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200f97c: 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; 200f980: 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; 200f984: 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; 200f988: 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; 200f98c: 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 ) || 200f990: 80 a0 e0 02 cmp %g3, 2 200f994: 02 80 00 05 be 200f9a8 200f998: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 200f99c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200f9a0: 12 80 00 07 bne 200f9bc <== NOT EXECUTED 200f9a4: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200f9a8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200f9ac: 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++; 200f9b0: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200f9b4: 02 80 00 03 be 200f9c0 200f9b8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 200f9bc: 30 80 00 2b b,a 200fa68 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 200f9c0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 200f9c4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200f9c8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200f9cc: 12 80 00 03 bne 200f9d8 <== NOT EXECUTED 200f9d0: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200f9d4: 30 80 00 25 b,a 200fa68 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 200f9d8: 08 80 00 0f bleu 200fa14 <== NOT EXECUTED 200f9dc: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200f9e0: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 200f9e4: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200f9e8: 82 00 60 01 inc %g1 <== NOT EXECUTED 200f9ec: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200f9f0: 7f ff eb 58 call 200a750 <== NOT EXECUTED 200f9f4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 200f9f8: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200f9fc: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200fa00: 40 00 17 f4 call 20159d0 <_Thread_Change_priority> <== NOT EXECUTED 200fa04: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 200fa08: 7f ff ff ab call 200f8b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 200fa0c: 23 00 80 c9 sethi %hi(0x2032400), %l1 <== NOT EXECUTED 200fa10: 30 80 00 2f b,a 200facc <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200fa14: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200fa18: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200fa1c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 200fa20: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200fa24: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200fa28: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200fa2c: 30 80 00 0f b,a 200fa68 <== 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 ) ) { 200fa30: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200fa34: 12 80 00 13 bne 200fa80 <== NOT EXECUTED 200fa38: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200fa3c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 200fa40: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200fa44: 22 80 00 07 be,a 200fa60 <== NOT EXECUTED 200fa48: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200fa4c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200fa50: 32 80 00 0c bne,a 200fa80 <== NOT EXECUTED 200fa54: 03 00 80 c9 sethi %hi(0x2032400), %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; 200fa58: 10 80 00 08 b 200fa78 <== NOT EXECUTED 200fa5c: 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++; 200fa60: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fa64: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200fa68: 7f ff eb 3a call 200a750 200fa6c: 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 ); 200fa70: 10 80 00 17 b 200facc 200fa74: 23 00 80 c9 sethi %hi(0x2032400), %l1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200fa78: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200fa7c: 30 bf ff fb b,a 200fa68 <== NOT EXECUTED 200fa80: c6 04 20 08 ld [ %l0 + 8 ], %g3 <== NOT EXECUTED 200fa84: c8 00 62 d0 ld [ %g1 + 0x2d0 ], %g4 <== NOT EXECUTED 200fa88: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 200fa8c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fa90: c6 21 20 20 st %g3, [ %g4 + 0x20 ] <== NOT EXECUTED 200fa94: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fa98: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== 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; 200fa9c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200faa0: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== NOT EXECUTED 200faa4: 82 04 20 10 add %l0, 0x10, %g1 <== NOT EXECUTED 200faa8: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200faac: 7f ff eb 29 call 200a750 <== NOT EXECUTED 200fab0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200fab4: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200fab8: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 200fabc: 92 10 20 00 clr %o1 <== NOT EXECUTED 200fac0: 40 00 0f e5 call 2013a54 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200fac4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200fac8: 23 00 80 c9 sethi %hi(0x2032400), %l1 <== NOT EXECUTED 200facc: 40 00 12 a1 call 2014550 <_Objects_Allocate> 200fad0: 90 14 60 0c or %l1, 0xc, %o0 ! 203240c <_Region_Information> the_region = _Region_Allocate(); if ( !the_region ) { 200fad4: a0 92 20 00 orcc %o0, 0, %l0 200fad8: 12 80 00 0f bne 200fb14 200fadc: 05 00 80 c9 sethi %hi(0x2032400), %g2 200fae0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200fae4: 82 00 60 01 inc %g1 200fae8: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _RTEMS_Unlock_allocator(); 200faec: 03 00 80 c9 sethi %hi(0x2032400), %g1 200faf0: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200faf4: 94 10 20 00 clr %o2 200faf8: d2 02 20 08 ld [ %o0 + 8 ], %o1 200fafc: 40 00 0f f8 call 2013adc <_CORE_mutex_Surrender> 200fb00: 90 02 20 10 add %o0, 0x10, %o0 200fb04: 7f ff ff 6c call 200f8b4 <_Thread_Enable_dispatch> 200fb08: b0 10 20 05 mov 5, %i0 200fb0c: 81 c7 e0 08 ret 200fb10: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_region->maximum_segment_size = 200fb14: 90 04 20 68 add %l0, 0x68, %o0 200fb18: 92 10 00 19 mov %i1, %o1 200fb1c: 94 10 00 1a mov %i2, %o2 200fb20: 40 00 12 15 call 2014374 <_Heap_Initialize> 200fb24: 96 10 00 1b mov %i3, %o3 _Heap_Initialize(&the_region->Memory, starting_address, length, page_size); if ( !the_region->maximum_segment_size ) { 200fb28: 80 a2 20 00 cmp %o0, 0 200fb2c: 12 80 00 13 bne 200fb78 200fb30: 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 ); 200fb34: 90 14 60 0c or %l1, 0xc, %o0 200fb38: 40 00 13 88 call 2014958 <_Objects_Free> 200fb3c: 92 10 00 10 mov %l0, %o1 200fb40: 05 00 80 c9 sethi %hi(0x2032400), %g2 200fb44: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200fb48: 82 00 60 01 inc %g1 200fb4c: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 200fb50: 03 00 80 c9 sethi %hi(0x2032400), %g1 200fb54: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200fb58: 94 10 20 00 clr %o2 200fb5c: d2 02 20 08 ld [ %o0 + 8 ], %o1 200fb60: 40 00 0f df call 2013adc <_CORE_mutex_Surrender> 200fb64: 90 02 20 10 add %o0, 0x10, %o0 200fb68: 7f ff ff 53 call 200f8b4 <_Thread_Enable_dispatch> 200fb6c: b0 10 20 08 mov 8, %i0 200fb70: 81 c7 e0 08 ret 200fb74: 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( 200fb78: 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; 200fb7c: f2 24 20 50 st %i1, [ %l0 + 0x50 ] the_region->length = length; 200fb80: f4 24 20 54 st %i2, [ %l0 + 0x54 ] the_region->page_size = page_size; 200fb84: f6 24 20 58 st %i3, [ %l0 + 0x58 ] the_region->attribute_set = attribute_set; 200fb88: f8 24 20 60 st %i4, [ %l0 + 0x60 ] the_region->number_of_used_blocks = 0; 200fb8c: c0 24 20 64 clr [ %l0 + 0x64 ] _Thread_queue_Initialize( 200fb90: 93 37 20 02 srl %i4, 2, %o1 200fb94: 94 10 20 40 mov 0x40, %o2 200fb98: 92 0a 60 01 and %o1, 1, %o1 200fb9c: 40 00 1b 48 call 20168bc <_Thread_queue_Initialize> 200fba0: 96 10 20 06 mov 6, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fba4: 90 14 60 0c or %l1, 0xc, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200fba8: c4 04 20 08 ld [ %l0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fbac: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200fbb0: 03 00 00 3f sethi %hi(0xfc00), %g1 200fbb4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200fbb8: 82 08 80 01 and %g2, %g1, %g1 200fbbc: 80 a0 40 03 cmp %g1, %g3 200fbc0: 38 80 00 06 bgu,a 200fbd8 200fbc4: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200fbc8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200fbcc: 83 28 60 02 sll %g1, 2, %g1 200fbd0: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 200fbd4: c2 04 20 08 ld [ %l0 + 8 ], %g1 200fbd8: 05 00 80 c9 sethi %hi(0x2032400), %g2 200fbdc: c2 27 40 00 st %g1, [ %i5 ] 200fbe0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %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; 200fbe4: e4 24 20 0c st %l2, [ %l0 + 0xc ] 200fbe8: 82 00 60 01 inc %g1 200fbec: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _RTEMS_Unlock_allocator(); 200fbf0: 03 00 80 c9 sethi %hi(0x2032400), %g1 200fbf4: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200fbf8: 94 10 20 00 clr %o2 200fbfc: d2 02 20 08 ld [ %o0 + 8 ], %o1 200fc00: 40 00 0f b7 call 2013adc <_CORE_mutex_Surrender> 200fc04: 90 02 20 10 add %o0, 0x10, %o0 200fc08: 7f ff ff 2b call 200f8b4 <_Thread_Enable_dispatch> 200fc0c: b0 10 20 00 clr %i0 200fc10: 81 c7 e0 08 ret 200fc14: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 200fc18: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED } 200fc1c: 81 c7 e0 08 ret <== NOT EXECUTED 200fc20: 81 e8 00 00 restore <== NOT EXECUTED 0200fc58 : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 200fc58: 9d e3 bf 90 save %sp, -112, %sp register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 200fc5c: 7f ff ea b9 call 200a740 200fc60: 01 00 00 00 nop 200fc64: a2 10 00 08 mov %o0, %l1 200fc68: 03 00 80 c9 sethi %hi(0x2032400), %g1 200fc6c: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200fc70: 80 a0 60 00 cmp %g1, 0 200fc74: 02 80 00 0b be 200fca0 200fc78: 03 00 80 c9 sethi %hi(0x2032400), %g1 200fc7c: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200fc80: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 20327d0 <_System_state_Current> <== NOT EXECUTED 200fc84: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200fc88: 08 80 00 05 bleu 200fc9c <== NOT EXECUTED 200fc8c: 90 10 20 00 clr %o0 <== NOT EXECUTED 200fc90: 92 10 20 00 clr %o1 <== NOT EXECUTED 200fc94: 40 00 12 02 call 201449c <_Internal_error_Occurred> <== NOT EXECUTED 200fc98: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200fc9c: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200fca0: e0 00 62 c8 ld [ %g1 + 0x2c8 ], %l0 ! 20326c8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200fca4: 03 00 80 c9 sethi %hi(0x2032400), %g1 200fca8: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 20326d0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200fcac: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200fcb0: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 200fcb4: 80 a0 60 00 cmp %g1, 0 200fcb8: 22 80 00 33 be,a 200fd84 200fcbc: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200fcc0: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200fcc4: 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; 200fcc8: 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; 200fccc: 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; 200fcd0: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 200fcd4: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200fcd8: 80 a0 e0 02 cmp %g3, 2 200fcdc: 02 80 00 05 be 200fcf0 200fce0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 200fce4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200fce8: 32 80 00 06 bne,a 200fd00 <== NOT EXECUTED 200fcec: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200fcf0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 200fcf4: 82 00 60 01 inc %g1 200fcf8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200fcfc: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 200fd00: 80 a0 60 03 cmp %g1, 3 200fd04: 22 80 00 03 be,a 200fd10 200fd08: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 200fd0c: 30 80 00 2c b,a 200fdbc { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 200fd10: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200fd14: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200fd18: 12 80 00 03 bne 200fd24 <== NOT EXECUTED 200fd1c: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200fd20: 30 80 00 27 b,a 200fdbc <== NOT EXECUTED return 0; } if ( current > ceiling ) { 200fd24: 08 80 00 10 bleu 200fd64 <== NOT EXECUTED 200fd28: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200fd2c: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 200fd30: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fd34: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fd38: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200fd3c: 7f ff ea 85 call 200a750 <== NOT EXECUTED 200fd40: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 200fd44: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200fd48: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200fd4c: 40 00 17 21 call 20159d0 <_Thread_Change_priority> <== NOT EXECUTED 200fd50: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 200fd54: 7f ff ff b4 call 200fc24 <_Thread_Enable_dispatch> <== NOT EXECUTED 200fd58: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 200fd5c: 10 80 00 32 b 200fe24 <== NOT EXECUTED 200fd60: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200fd64: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200fd68: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200fd6c: 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; 200fd70: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 200fd74: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200fd78: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200fd7c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200fd80: 30 80 00 0f b,a 200fdbc <== 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 ) ) { 200fd84: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200fd88: 32 80 00 13 bne,a 200fdd4 <== NOT EXECUTED 200fd8c: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200fd90: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2032450 <_Region_Information+0x44> <== NOT EXECUTED 200fd94: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200fd98: 22 80 00 07 be,a 200fdb4 <== NOT EXECUTED 200fd9c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200fda0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200fda4: 12 80 00 0c bne 200fdd4 <== NOT EXECUTED 200fda8: 21 00 80 c9 sethi %hi(0x2032400), %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; 200fdac: 10 80 00 08 b 200fdcc <== NOT EXECUTED 200fdb0: 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++; 200fdb4: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fdb8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200fdbc: 7f ff ea 65 call 200a750 200fdc0: 90 10 00 11 mov %l1, %o0 200fdc4: 10 80 00 18 b 200fe24 200fdc8: 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; 200fdcc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200fdd0: 30 bf ff fb b,a 200fdbc <== NOT EXECUTED 200fdd4: c6 04 22 c8 ld [ %l0 + 0x2c8 ], %g3 <== NOT EXECUTED 200fdd8: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200fddc: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 200fde0: c8 00 62 d0 ld [ %g1 + 0x2d0 ], %g4 <== NOT EXECUTED 200fde4: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 200fde8: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fdec: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 200fdf0: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fdf4: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 200fdf8: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 200fdfc: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200fe00: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200fe04: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 200fe08: 7f ff ea 52 call 200a750 <== NOT EXECUTED 200fe0c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200fe10: d0 04 22 c8 ld [ %l0 + 0x2c8 ], %o0 <== NOT EXECUTED 200fe14: 92 10 20 00 clr %o1 <== NOT EXECUTED 200fe18: 40 00 0f 0f call 2013a54 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200fe1c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200fe20: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200fe24: 21 00 80 c9 sethi %hi(0x2032400), %l0 200fe28: 94 07 bf f4 add %fp, -12, %o2 200fe2c: 40 00 13 0d call 2014a60 <_Objects_Get_no_protection> 200fe30: 90 14 20 0c or %l0, 0xc, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 200fe34: c2 07 bf f4 ld [ %fp + -12 ], %g1 200fe38: 80 a0 60 01 cmp %g1, 1 200fe3c: 02 80 00 0a be 200fe64 200fe40: 92 10 00 08 mov %o0, %o1 200fe44: 80 a0 60 01 cmp %g1, 1 200fe48: 2a 80 00 22 bcs,a 200fed0 200fe4c: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 200fe50: 80 a0 60 02 cmp %g1, 2 200fe54: 12 80 00 10 bne 200fe94 200fe58: b0 10 20 19 mov 0x19, %i0 200fe5c: 10 80 00 10 b 200fe9c 200fe60: 05 00 80 c9 sethi %hi(0x2032400), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 200fe64: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 200fe68: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fe6c: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fe70: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 200fe74: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200fe78: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 200fe7c: 94 10 20 00 clr %o2 <== NOT EXECUTED 200fe80: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 200fe84: 40 00 0f 16 call 2013adc <_CORE_mutex_Surrender> <== NOT EXECUTED 200fe88: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200fe8c: 7f ff ff 66 call 200fc24 <_Thread_Enable_dispatch> <== NOT EXECUTED 200fe90: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 200fe94: 81 c7 e0 08 ret <== NOT EXECUTED 200fe98: 81 e8 00 00 restore <== NOT EXECUTED 200fe9c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 200fea0: 82 00 60 01 inc %g1 200fea4: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 200fea8: 03 00 80 c9 sethi %hi(0x2032400), %g1 200feac: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200feb0: 94 10 20 00 clr %o2 200feb4: d2 02 20 08 ld [ %o0 + 8 ], %o1 200feb8: 40 00 0f 09 call 2013adc <_CORE_mutex_Surrender> 200febc: 90 02 20 10 add %o0, 0x10, %o0 200fec0: 7f ff ff 59 call 200fc24 <_Thread_Enable_dispatch> 200fec4: b0 10 20 04 mov 4, %i0 200fec8: 81 c7 e0 08 ret 200fecc: 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 ) { 200fed0: 80 a0 60 00 cmp %g1, 0 200fed4: 12 80 00 1d bne 200ff48 200fed8: 05 00 80 c9 sethi %hi(0x2032400), %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fedc: 90 14 20 0c or %l0, 0xc, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200fee0: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fee4: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200fee8: 05 00 00 3f sethi %hi(0xfc00), %g2 200feec: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200fef0: 82 08 40 02 and %g1, %g2, %g1 200fef4: 80 a0 40 03 cmp %g1, %g3 200fef8: 18 80 00 04 bgu 200ff08 200fefc: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 200ff00: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200ff04: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 200ff08: 40 00 12 94 call 2014958 <_Objects_Free> 200ff0c: c0 22 60 0c clr [ %o1 + 0xc ] 200ff10: 05 00 80 c9 sethi %hi(0x2032400), %g2 200ff14: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200ff18: 82 00 60 01 inc %g1 200ff1c: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 200ff20: 03 00 80 c9 sethi %hi(0x2032400), %g1 200ff24: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200ff28: 94 10 20 00 clr %o2 200ff2c: d2 02 20 08 ld [ %o0 + 8 ], %o1 200ff30: 40 00 0e eb call 2013adc <_CORE_mutex_Surrender> 200ff34: 90 02 20 10 add %o0, 0x10, %o0 200ff38: 7f ff ff 3b call 200fc24 <_Thread_Enable_dispatch> 200ff3c: b0 10 20 00 clr %i0 200ff40: 81 c7 e0 08 ret 200ff44: 81 e8 00 00 restore 200ff48: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 200ff4c: 82 00 60 01 inc %g1 200ff50: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] return RTEMS_SUCCESSFUL; } _RTEMS_Unlock_allocator(); 200ff54: 03 00 80 c9 sethi %hi(0x2032400), %g1 200ff58: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200ff5c: 94 10 20 00 clr %o2 200ff60: d2 02 20 08 ld [ %o0 + 8 ], %o1 200ff64: 40 00 0e de call 2013adc <_CORE_mutex_Surrender> 200ff68: 90 02 20 10 add %o0, 0x10, %o0 200ff6c: 7f ff ff 2e call 200fc24 <_Thread_Enable_dispatch> 200ff70: b0 10 20 0c mov 0xc, %i0 return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200ff74: 81 c7 e0 08 ret 200ff78: 81 e8 00 00 restore 0200ffb0 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 200ffb0: 9d e3 bf 90 save %sp, -112, %sp 200ffb4: 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 ) 200ffb8: 80 a6 60 00 cmp %i1, 0 200ffbc: 02 80 00 90 be 20101fc 200ffc0: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 200ffc4: 7f ff e9 df call 200a740 200ffc8: 01 00 00 00 nop 200ffcc: a2 10 00 08 mov %o0, %l1 200ffd0: 03 00 80 c9 sethi %hi(0x2032400), %g1 200ffd4: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200ffd8: 80 a0 60 00 cmp %g1, 0 200ffdc: 02 80 00 0b be 2010008 200ffe0: 03 00 80 c9 sethi %hi(0x2032400), %g1 200ffe4: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200ffe8: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 20327d0 <_System_state_Current> <== NOT EXECUTED 200ffec: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200fff0: 08 80 00 05 bleu 2010004 <== NOT EXECUTED 200fff4: 90 10 20 00 clr %o0 <== NOT EXECUTED 200fff8: 92 10 20 00 clr %o1 <== NOT EXECUTED 200fffc: 40 00 11 28 call 201449c <_Internal_error_Occurred> <== NOT EXECUTED 2010000: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2010004: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010008: e0 00 62 c8 ld [ %g1 + 0x2c8 ], %l0 ! 20326c8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 201000c: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010010: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 20326d0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2010014: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2010018: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 201001c: 80 a0 60 00 cmp %g1, 0 2010020: 22 80 00 33 be,a 20100ec 2010024: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2010028: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 201002c: 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; 2010030: 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; 2010034: 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; 2010038: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 201003c: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2010040: 80 a0 e0 02 cmp %g3, 2 2010044: 02 80 00 05 be 2010058 2010048: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 201004c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2010050: 32 80 00 06 bne,a 2010068 <== NOT EXECUTED 2010054: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2010058: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 201005c: 82 00 60 01 inc %g1 2010060: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010064: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 2010068: 80 a0 60 03 cmp %g1, 3 201006c: 22 80 00 03 be,a 2010078 2010070: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2010074: 30 80 00 2c b,a 2010124 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2010078: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 201007c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010080: 12 80 00 03 bne 201008c <== NOT EXECUTED 2010084: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2010088: 30 80 00 27 b,a 2010124 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 201008c: 08 80 00 10 bleu 20100cc <== NOT EXECUTED 2010090: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010094: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 2010098: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 201009c: 82 00 60 01 inc %g1 <== NOT EXECUTED 20100a0: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20100a4: 7f ff e9 ab call 200a750 <== NOT EXECUTED 20100a8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 20100ac: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 20100b0: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 20100b4: 40 00 16 47 call 20159d0 <_Thread_Change_priority> <== NOT EXECUTED 20100b8: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 20100bc: 7f ff ff b0 call 200ff7c <_Thread_Enable_dispatch> <== NOT EXECUTED 20100c0: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 20100c4: 10 80 00 32 b 201018c <== NOT EXECUTED 20100c8: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20100cc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20100d0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20100d4: 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; 20100d8: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 20100dc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20100e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20100e4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20100e8: 30 80 00 0f b,a 2010124 <== 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 ) ) { 20100ec: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20100f0: 32 80 00 13 bne,a 201013c <== NOT EXECUTED 20100f4: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20100f8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2032450 <_Region_Information+0x44> <== NOT EXECUTED 20100fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010100: 22 80 00 07 be,a 201011c <== NOT EXECUTED 2010104: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2010108: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 201010c: 12 80 00 0c bne 201013c <== NOT EXECUTED 2010110: 21 00 80 c9 sethi %hi(0x2032400), %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; 2010114: 10 80 00 08 b 2010134 <== NOT EXECUTED 2010118: 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++; 201011c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010120: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010124: 7f ff e9 8b call 200a750 2010128: 90 10 00 11 mov %l1, %o0 201012c: 10 80 00 18 b 201018c 2010130: 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; 2010134: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2010138: 30 bf ff fb b,a 2010124 <== NOT EXECUTED 201013c: c6 04 22 c8 ld [ %l0 + 0x2c8 ], %g3 <== NOT EXECUTED 2010140: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010144: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2010148: c8 00 62 d0 ld [ %g1 + 0x2d0 ], %g4 <== NOT EXECUTED 201014c: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 2010150: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2010154: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 2010158: 82 00 60 01 inc %g1 <== NOT EXECUTED 201015c: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 2010160: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2010164: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 2010168: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 201016c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2010170: 7f ff e9 78 call 200a750 <== NOT EXECUTED 2010174: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010178: d0 04 22 c8 ld [ %l0 + 0x2c8 ], %o0 <== NOT EXECUTED 201017c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010180: 40 00 0e 35 call 2013a54 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010184: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010188: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 201018c: 11 00 80 c9 sethi %hi(0x2032400), %o0 2010190: 94 07 bf f4 add %fp, -12, %o2 2010194: 40 00 12 33 call 2014a60 <_Objects_Get_no_protection> 2010198: 90 12 20 0c or %o0, 0xc, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 201019c: c2 07 bf f4 ld [ %fp + -12 ], %g1 20101a0: 80 a0 60 01 cmp %g1, 1 20101a4: 02 80 00 0a be 20101cc 20101a8: a0 10 00 08 mov %o0, %l0 20101ac: 80 a0 60 01 cmp %g1, 1 20101b0: 0a 80 00 22 bcs 2010238 20101b4: 92 10 00 19 mov %i1, %o1 20101b8: 80 a0 60 02 cmp %g1, 2 20101bc: 12 80 00 10 bne 20101fc 20101c0: b0 10 20 19 mov 0x19, %i0 20101c4: 10 80 00 10 b 2010204 20101c8: 05 00 80 c9 sethi %hi(0x2032400), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 20101cc: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 20101d0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20101d4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20101d8: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 20101dc: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 20101e0: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 20101e4: 94 10 20 00 clr %o2 <== NOT EXECUTED 20101e8: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 20101ec: 40 00 0e 3c call 2013adc <_CORE_mutex_Surrender> <== NOT EXECUTED 20101f0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 20101f4: 7f ff ff 62 call 200ff7c <_Thread_Enable_dispatch> <== NOT EXECUTED 20101f8: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 20101fc: 81 c7 e0 08 ret <== NOT EXECUTED 2010200: 81 e8 00 00 restore <== NOT EXECUTED 2010204: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 2010208: 82 00 60 01 inc %g1 201020c: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2010210: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010214: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 2010218: 94 10 20 00 clr %o2 201021c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010220: 40 00 0e 2f call 2013adc <_CORE_mutex_Surrender> 2010224: 90 02 20 10 add %o0, 0x10, %o0 2010228: 7f ff ff 55 call 200ff7c <_Thread_Enable_dispatch> 201022c: b0 10 20 04 mov 4, %i0 2010230: 81 c7 e0 08 ret 2010234: 81 e8 00 00 restore return RTEMS_INVALID_ID; case OBJECTS_LOCAL: heap_status = _Heap_Extend( 2010238: 94 10 00 1a mov %i2, %o2 201023c: 90 02 20 68 add %o0, 0x68, %o0 2010240: 96 07 bf f0 add %fp, -16, %o3 2010244: 40 00 0f 61 call 2013fc8 <_Heap_Extend> 2010248: b0 10 20 09 mov 9, %i0 starting_address, length, &amount_extended ); switch ( heap_status ) { 201024c: 80 a2 20 01 cmp %o0, 1 2010250: 02 80 00 12 be 2010298 2010254: 05 00 80 c9 sethi %hi(0x2032400), %g2 2010258: 0a 80 00 08 bcs 2010278 201025c: c6 07 bf f0 ld [ %fp + -16 ], %g3 2010260: 82 1a 20 02 xor %o0, 2, %g1 2010264: 80 a0 00 01 cmp %g0, %g1 2010268: 82 60 20 00 subx %g0, 0, %g1 201026c: b0 08 7f e8 and %g1, -24, %i0 2010270: 10 80 00 0a b 2010298 2010274: b0 06 20 18 add %i0, 0x18, %i0 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 2010278: c4 04 20 54 ld [ %l0 + 0x54 ], %g2 the_region->maximum_segment_size += amount_extended; 201027c: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 2010280: 84 00 80 03 add %g2, %g3, %g2 the_region->maximum_segment_size += amount_extended; 2010284: 82 00 40 03 add %g1, %g3, %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 2010288: c4 24 20 54 st %g2, [ %l0 + 0x54 ] the_region->maximum_segment_size += amount_extended; 201028c: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 2010290: b0 10 20 00 clr %i0 2010294: 05 00 80 c9 sethi %hi(0x2032400), %g2 2010298: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 201029c: 82 00 60 01 inc %g1 20102a0: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] break; case HEAP_EXTEND_NOT_IMPLEMENTED: status = RTEMS_NOT_IMPLEMENTED; break; } _RTEMS_Unlock_allocator(); 20102a4: 03 00 80 c9 sethi %hi(0x2032400), %g1 20102a8: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 20102ac: 94 10 20 00 clr %o2 20102b0: d2 02 20 08 ld [ %o0 + 8 ], %o1 20102b4: 40 00 0e 0a call 2013adc <_CORE_mutex_Surrender> 20102b8: 90 02 20 10 add %o0, 0x10, %o0 20102bc: 7f ff ff 30 call 200ff7c <_Thread_Enable_dispatch> 20102c0: 01 00 00 00 nop return( status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20102c4: 81 c7 e0 08 ret 20102c8: 81 e8 00 00 restore 02010300 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 2010300: 9d e3 bf 90 save %sp, -112, %sp 2010304: a4 10 00 18 mov %i0, %l2 register Region_Control *the_region; Objects_Locations location; Thread_Control *executing; void *the_segment; if ( !segment ) 2010308: 80 a7 20 00 cmp %i4, 0 201030c: 02 80 00 96 be 2010564 2010310: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; *segment = NULL; 2010314: c0 27 00 00 clr [ %i4 ] if ( size == 0 ) 2010318: 80 a6 60 00 cmp %i1, 0 201031c: 02 80 00 92 be 2010564 2010320: b0 10 20 08 mov 8, %i0 return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 2010324: 7f ff e9 07 call 200a740 2010328: 01 00 00 00 nop 201032c: a2 10 00 08 mov %o0, %l1 2010330: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010334: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 2010338: 80 a0 60 00 cmp %g1, 0 201033c: 02 80 00 0b be 2010368 2010340: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010344: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010348: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 20327d0 <_System_state_Current> <== NOT EXECUTED 201034c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010350: 08 80 00 05 bleu 2010364 <== NOT EXECUTED 2010354: 90 10 20 00 clr %o0 <== NOT EXECUTED 2010358: 92 10 20 00 clr %o1 <== NOT EXECUTED 201035c: 40 00 10 50 call 201449c <_Internal_error_Occurred> <== NOT EXECUTED 2010360: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2010364: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010368: e0 00 62 c8 ld [ %g1 + 0x2c8 ], %l0 ! 20326c8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 201036c: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010370: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 20326d0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2010374: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2010378: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 201037c: 80 a0 60 00 cmp %g1, 0 2010380: 22 80 00 33 be,a 201044c 2010384: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2010388: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 201038c: 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; 2010390: 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; 2010394: 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; 2010398: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 201039c: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20103a0: 80 a0 e0 02 cmp %g3, 2 20103a4: 02 80 00 05 be 20103b8 20103a8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 20103ac: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20103b0: 32 80 00 06 bne,a 20103c8 <== NOT EXECUTED 20103b4: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20103b8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 20103bc: 82 00 60 01 inc %g1 20103c0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20103c4: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 20103c8: 80 a0 60 03 cmp %g1, 3 20103cc: 22 80 00 03 be,a 20103d8 20103d0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 20103d4: 30 80 00 2c b,a 2010484 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 20103d8: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 20103dc: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 20103e0: 12 80 00 03 bne 20103ec <== NOT EXECUTED 20103e4: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 20103e8: 30 80 00 27 b,a 2010484 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 20103ec: 28 80 00 10 bleu,a 201042c <== NOT EXECUTED 20103f0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20103f4: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 20103f8: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20103fc: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010400: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010404: 7f ff e8 d3 call 200a750 <== NOT EXECUTED 2010408: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 201040c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010410: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010414: 40 00 15 6f call 20159d0 <_Thread_Change_priority> <== NOT EXECUTED 2010418: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 201041c: 7f ff ff ac call 20102cc <_Thread_Enable_dispatch> <== NOT EXECUTED 2010420: 01 00 00 00 nop <== NOT EXECUTED executing = _Thread_Executing; 2010424: 10 80 00 32 b 20104ec <== NOT EXECUTED 2010428: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 201042c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2010430: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2010434: 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; 2010438: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 201043c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2010440: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010444: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2010448: 30 80 00 0f b,a 2010484 <== 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 ) ) { 201044c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2010450: 32 80 00 13 bne,a 201049c <== NOT EXECUTED 2010454: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010458: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2032450 <_Region_Information+0x44> <== NOT EXECUTED 201045c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010460: 22 80 00 07 be,a 201047c <== NOT EXECUTED 2010464: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2010468: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 201046c: 12 80 00 0c bne 201049c <== NOT EXECUTED 2010470: 21 00 80 c9 sethi %hi(0x2032400), %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; 2010474: 10 80 00 08 b 2010494 <== NOT EXECUTED 2010478: 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++; 201047c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010480: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010484: 7f ff e8 b3 call 200a750 2010488: 90 10 00 11 mov %l1, %o0 201048c: 10 80 00 18 b 20104ec 2010490: 03 00 80 c9 sethi %hi(0x2032400), %g1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2010494: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2010498: 30 bf ff fb b,a 2010484 <== NOT EXECUTED *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 201049c: c6 04 22 c8 ld [ %l0 + 0x2c8 ], %g3 <== NOT EXECUTED 20104a0: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 20104a4: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 20104a8: c8 00 62 d0 ld [ %g1 + 0x2d0 ], %g4 <== NOT EXECUTED 20104ac: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 20104b0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20104b4: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 20104b8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20104bc: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 20104c0: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 20104c4: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 20104c8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20104cc: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 20104d0: 7f ff e8 a0 call 200a750 <== NOT EXECUTED 20104d4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20104d8: d0 04 22 c8 ld [ %l0 + 0x2c8 ], %o0 <== NOT EXECUTED 20104dc: 92 10 20 00 clr %o1 <== NOT EXECUTED 20104e0: 40 00 0d 5d call 2013a54 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 20104e4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED executing = _Thread_Executing; 20104e8: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 20104ec: 11 00 80 c9 sethi %hi(0x2032400), %o0 20104f0: f0 00 62 d0 ld [ %g1 + 0x2d0 ], %i0 20104f4: 90 12 20 0c or %o0, 0xc, %o0 20104f8: 92 10 00 12 mov %l2, %o1 20104fc: 40 00 11 59 call 2014a60 <_Objects_Get_no_protection> 2010500: 94 07 bf f4 add %fp, -12, %o2 the_region = _Region_Get( id, &location ); switch ( location ) { 2010504: c2 07 bf f4 ld [ %fp + -12 ], %g1 2010508: 80 a0 60 01 cmp %g1, 1 201050c: 02 80 00 0a be 2010534 2010510: a0 10 00 08 mov %o0, %l0 2010514: 80 a0 60 01 cmp %g1, 1 2010518: 2a 80 00 22 bcs,a 20105a0 201051c: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 2010520: 80 a0 60 02 cmp %g1, 2 2010524: 12 80 00 10 bne 2010564 2010528: b0 10 20 19 mov 0x19, %i0 201052c: 10 80 00 10 b 201056c 2010530: 05 00 80 c9 sethi %hi(0x2032400), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 2010534: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 2010538: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 201053c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010540: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 2010544: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010548: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 201054c: 94 10 20 00 clr %o2 <== NOT EXECUTED 2010550: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2010554: 40 00 0d 62 call 2013adc <_CORE_mutex_Surrender> <== NOT EXECUTED 2010558: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 201055c: 7f ff ff 5c call 20102cc <_Thread_Enable_dispatch> <== NOT EXECUTED 2010560: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 2010564: 81 c7 e0 08 ret <== NOT EXECUTED 2010568: 81 e8 00 00 restore <== NOT EXECUTED 201056c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 2010570: 82 00 60 01 inc %g1 2010574: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2010578: 03 00 80 c9 sethi %hi(0x2032400), %g1 201057c: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 2010580: 94 10 20 00 clr %o2 2010584: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010588: 40 00 0d 55 call 2013adc <_CORE_mutex_Surrender> 201058c: 90 02 20 10 add %o0, 0x10, %o0 2010590: 7f ff ff 4f call 20102cc <_Thread_Enable_dispatch> 2010594: b0 10 20 04 mov 4, %i0 2010598: 81 c7 e0 08 ret 201059c: 81 e8 00 00 restore return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) { 20105a0: 80 a6 40 01 cmp %i1, %g1 20105a4: 08 80 00 0f bleu 20105e0 20105a8: 05 00 80 c9 sethi %hi(0x2032400), %g2 20105ac: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 20105b0: 82 00 60 01 inc %g1 20105b4: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _RTEMS_Unlock_allocator(); 20105b8: 03 00 80 c9 sethi %hi(0x2032400), %g1 20105bc: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 20105c0: 94 10 20 00 clr %o2 20105c4: d2 02 20 08 ld [ %o0 + 8 ], %o1 20105c8: 40 00 0d 45 call 2013adc <_CORE_mutex_Surrender> 20105cc: 90 02 20 10 add %o0, 0x10, %o0 20105d0: 7f ff ff 3f call 20102cc <_Thread_Enable_dispatch> 20105d4: b0 10 20 08 mov 8, %i0 20105d8: 81 c7 e0 08 ret 20105dc: 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 ); 20105e0: 90 02 20 68 add %o0, 0x68, %o0 20105e4: 40 00 0e 52 call 2013f2c <_Heap_Allocate> 20105e8: 92 10 00 19 mov %i1, %o1 the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 20105ec: a2 92 20 00 orcc %o0, 0, %l1 20105f0: 02 80 00 13 be 201063c 20105f4: 07 00 80 c9 sethi %hi(0x2032400), %g3 the_region->number_of_used_blocks += 1; 20105f8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 20105fc: c4 00 e1 f0 ld [ %g3 + 0x1f0 ], %g2 2010600: 82 00 60 01 inc %g1 2010604: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 2010608: 84 00 a0 01 inc %g2 201060c: c4 20 e1 f0 st %g2, [ %g3 + 0x1f0 ] _RTEMS_Unlock_allocator(); 2010610: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010614: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 2010618: 94 10 20 00 clr %o2 201061c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010620: 40 00 0d 2f call 2013adc <_CORE_mutex_Surrender> 2010624: 90 02 20 10 add %o0, 0x10, %o0 2010628: 7f ff ff 29 call 20102cc <_Thread_Enable_dispatch> 201062c: b0 10 20 00 clr %i0 *segment = the_segment; 2010630: e2 27 00 00 st %l1, [ %i4 ] 2010634: 81 c7 e0 08 ret 2010638: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } if ( _Options_Is_no_wait( option_set ) ) { 201063c: 80 8e a0 01 btst 1, %i2 2010640: 05 00 80 c9 sethi %hi(0x2032400), %g2 2010644: 02 80 00 0e be 201067c 2010648: 07 00 80 c9 sethi %hi(0x2032400), %g3 201064c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 2010650: 82 00 60 01 inc %g1 2010654: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _RTEMS_Unlock_allocator(); 2010658: d0 00 e2 c8 ld [ %g3 + 0x2c8 ], %o0 201065c: 94 10 20 00 clr %o2 2010660: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010664: 40 00 0d 1e call 2013adc <_CORE_mutex_Surrender> 2010668: 90 02 20 10 add %o0, 0x10, %o0 201066c: 7f ff ff 18 call 20102cc <_Thread_Enable_dispatch> 2010670: b0 10 20 0d mov 0xd, %i0 2010674: 81 c7 e0 08 ret 2010678: 81 e8 00 00 restore 201067c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 2010680: 82 00 60 01 inc %g1 2010684: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 2010688: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 201068c: 82 00 60 01 inc %g1 2010690: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] * 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(); 2010694: d0 00 e2 c8 ld [ %g3 + 0x2c8 ], %o0 2010698: 94 10 20 00 clr %o2 201069c: d2 02 20 08 ld [ %o0 + 8 ], %o1 20106a0: 40 00 0d 0f call 2013adc <_CORE_mutex_Surrender> 20106a4: 90 02 20 10 add %o0, 0x10, %o0 20106a8: 7f ff ff 09 call 20102cc <_Thread_Enable_dispatch> 20106ac: 01 00 00 00 nop executing->Wait.queue = &the_region->Wait_queue; 20106b0: 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 ); 20106b4: 92 10 00 1b mov %i3, %o1 20106b8: 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; 20106bc: 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 ); 20106c0: 15 00 80 5a sethi %hi(0x2016800), %o2 20106c4: 82 10 20 01 mov 1, %g1 20106c8: 94 12 a1 b8 or %o2, 0x1b8, %o2 */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; executing->Wait.id = id; 20106cc: e4 26 20 20 st %l2, [ %i0 + 0x20 ] executing->Wait.count = size; 20106d0: f2 26 20 24 st %i1, [ %i0 + 0x24 ] executing->Wait.return_argument = segment; 20106d4: 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 ); 20106d8: 40 00 17 92 call 2016520 <_Thread_queue_Enqueue_with_handler> 20106dc: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _Thread_Enable_dispatch(); 20106e0: 7f ff fe fb call 20102cc <_Thread_Enable_dispatch> 20106e4: 01 00 00 00 nop return (rtems_status_code) executing->Wait.return_code; 20106e8: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20106ec: 81 c7 e0 08 ret 20106f0: 81 e8 00 00 restore 02010760 : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 2010760: 9d e3 bf 90 save %sp, -112, %sp #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 2010764: 7f ff e7 f7 call 200a740 2010768: 01 00 00 00 nop 201076c: a2 10 00 08 mov %o0, %l1 2010770: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010774: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 2010778: 80 a0 60 00 cmp %g1, 0 201077c: 02 80 00 0b be 20107a8 2010780: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010784: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010788: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 20327d0 <_System_state_Current> <== NOT EXECUTED 201078c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010790: 08 80 00 05 bleu 20107a4 <== NOT EXECUTED 2010794: 90 10 20 00 clr %o0 <== NOT EXECUTED 2010798: 92 10 20 00 clr %o1 <== NOT EXECUTED 201079c: 40 00 0f 40 call 201449c <_Internal_error_Occurred> <== NOT EXECUTED 20107a0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 20107a4: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 20107a8: e0 00 62 c8 ld [ %g1 + 0x2c8 ], %l0 ! 20326c8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 20107ac: 03 00 80 c9 sethi %hi(0x2032400), %g1 20107b0: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 20326d0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20107b4: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 20107b8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 20107bc: 80 a0 60 00 cmp %g1, 0 20107c0: 22 80 00 33 be,a 201088c 20107c4: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20107c8: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20107cc: 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; 20107d0: 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; 20107d4: 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; 20107d8: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 20107dc: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20107e0: 80 a0 e0 02 cmp %g3, 2 20107e4: 02 80 00 05 be 20107f8 20107e8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 20107ec: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20107f0: 32 80 00 06 bne,a 2010808 <== NOT EXECUTED 20107f4: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20107f8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 20107fc: 82 00 60 01 inc %g1 2010800: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010804: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 2010808: 80 a0 60 03 cmp %g1, 3 201080c: 22 80 00 03 be,a 2010818 2010810: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2010814: 30 80 00 2c b,a 20108c4 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2010818: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 201081c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010820: 12 80 00 03 bne 201082c <== NOT EXECUTED 2010824: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2010828: 30 80 00 27 b,a 20108c4 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 201082c: 08 80 00 10 bleu 201086c <== NOT EXECUTED 2010830: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010834: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 2010838: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 201083c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010840: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010844: 7f ff e7 c3 call 200a750 <== NOT EXECUTED 2010848: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 201084c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010850: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010854: 40 00 14 5f call 20159d0 <_Thread_Change_priority> <== NOT EXECUTED 2010858: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 201085c: 7f ff ff b4 call 201072c <_Thread_Enable_dispatch> <== NOT EXECUTED 2010860: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 2010864: 10 80 00 32 b 201092c <== NOT EXECUTED 2010868: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 201086c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2010870: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2010874: 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; 2010878: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 201087c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2010880: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010884: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2010888: 30 80 00 0f b,a 20108c4 <== 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 ) ) { 201088c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2010890: 32 80 00 13 bne,a 20108dc <== NOT EXECUTED 2010894: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010898: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2032450 <_Region_Information+0x44> <== NOT EXECUTED 201089c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20108a0: 22 80 00 07 be,a 20108bc <== NOT EXECUTED 20108a4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 20108a8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20108ac: 12 80 00 0c bne 20108dc <== NOT EXECUTED 20108b0: 21 00 80 c9 sethi %hi(0x2032400), %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; 20108b4: 10 80 00 08 b 20108d4 <== NOT EXECUTED 20108b8: 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++; 20108bc: 82 00 60 01 inc %g1 <== NOT EXECUTED 20108c0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 20108c4: 7f ff e7 a3 call 200a750 20108c8: 90 10 00 11 mov %l1, %o0 20108cc: 10 80 00 18 b 201092c 20108d0: 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; 20108d4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20108d8: 30 bf ff fb b,a 20108c4 <== NOT EXECUTED 20108dc: c6 04 22 c8 ld [ %l0 + 0x2c8 ], %g3 <== NOT EXECUTED 20108e0: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 20108e4: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 20108e8: c8 00 62 d0 ld [ %g1 + 0x2d0 ], %g4 <== NOT EXECUTED 20108ec: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 20108f0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20108f4: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 20108f8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20108fc: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 2010900: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2010904: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 2010908: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 201090c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2010910: 7f ff e7 90 call 200a750 <== NOT EXECUTED 2010914: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010918: d0 04 22 c8 ld [ %l0 + 0x2c8 ], %o0 <== NOT EXECUTED 201091c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010920: 40 00 0c 4d call 2013a54 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010924: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010928: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 201092c: 11 00 80 c9 sethi %hi(0x2032400), %o0 2010930: 94 07 bf f4 add %fp, -12, %o2 2010934: 40 00 10 4b call 2014a60 <_Objects_Get_no_protection> 2010938: 90 12 20 0c or %o0, 0xc, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 201093c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2010940: 80 a0 60 01 cmp %g1, 1 2010944: 02 80 00 0a be 201096c 2010948: a0 10 00 08 mov %o0, %l0 201094c: 80 a0 60 01 cmp %g1, 1 2010950: 0a 80 00 22 bcs 20109d8 2010954: 92 10 00 19 mov %i1, %o1 2010958: 80 a0 60 02 cmp %g1, 2 201095c: 12 80 00 10 bne 201099c 2010960: b0 10 20 19 mov 0x19, %i0 2010964: 10 80 00 10 b 20109a4 2010968: 05 00 80 c9 sethi %hi(0x2032400), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 201096c: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 2010970: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2010974: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010978: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 201097c: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010980: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 2010984: 94 10 20 00 clr %o2 <== NOT EXECUTED 2010988: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 201098c: 40 00 0c 54 call 2013adc <_CORE_mutex_Surrender> <== NOT EXECUTED 2010990: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010994: 7f ff ff 66 call 201072c <_Thread_Enable_dispatch> <== NOT EXECUTED 2010998: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 201099c: 81 c7 e0 08 ret <== NOT EXECUTED 20109a0: 81 e8 00 00 restore <== NOT EXECUTED 20109a4: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 20109a8: 82 00 60 01 inc %g1 20109ac: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 20109b0: 03 00 80 c9 sethi %hi(0x2032400), %g1 20109b4: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 20109b8: 94 10 20 00 clr %o2 20109bc: d2 02 20 08 ld [ %o0 + 8 ], %o1 20109c0: 40 00 0c 47 call 2013adc <_CORE_mutex_Surrender> 20109c4: 90 02 20 10 add %o0, 0x10, %o0 20109c8: 7f ff ff 59 call 201072c <_Thread_Enable_dispatch> 20109cc: b0 10 20 04 mov 4, %i0 20109d0: 81 c7 e0 08 ret 20109d4: 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 ); 20109d8: 40 00 0d ad call 201408c <_Heap_Free> 20109dc: 90 02 20 68 add %o0, 0x68, %o0 status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) { 20109e0: 80 a2 20 00 cmp %o0, 0 20109e4: 12 80 00 0f bne 2010a20 20109e8: 05 00 80 c9 sethi %hi(0x2032400), %g2 20109ec: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 20109f0: 82 00 60 01 inc %g1 20109f4: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _RTEMS_Unlock_allocator(); 20109f8: 03 00 80 c9 sethi %hi(0x2032400), %g1 20109fc: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 2010a00: 94 10 20 00 clr %o2 2010a04: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010a08: 40 00 0c 35 call 2013adc <_CORE_mutex_Surrender> 2010a0c: 90 02 20 10 add %o0, 0x10, %o0 2010a10: 7f ff ff 47 call 201072c <_Thread_Enable_dispatch> 2010a14: b0 10 20 09 mov 9, %i0 2010a18: 81 c7 e0 08 ret 2010a1c: 81 e8 00 00 restore return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 2010a20: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 2010a24: 90 10 00 10 mov %l0, %o0 if ( !status ) { _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 2010a28: 82 00 7f ff add %g1, -1, %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 2010a2c: b0 10 20 00 clr %i0 2010a30: 40 00 25 70 call 2019ff0 <_Region_Process_queue> 2010a34: c2 24 20 64 st %g1, [ %l0 + 0x64 ] return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2010a38: 81 c7 e0 08 ret 2010a3c: 81 e8 00 00 restore 02005608 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 2005608: 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 ) ) 200560c: a8 96 20 00 orcc %i0, 0, %l4 2005610: 02 80 00 2c be 20056c0 2005614: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2005618: 80 a7 20 00 cmp %i4, 0 200561c: 02 80 00 29 be 20056c0 2005620: b0 10 20 09 mov 9, %i0 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 2005624: a4 8e a0 40 andcc %i2, 0x40, %l2 2005628: 12 80 00 06 bne 2005640 200562c: 82 0e a0 30 and %i2, 0x30, %g1 2005630: 80 8e a0 80 btst 0x80, %i2 2005634: 02 80 00 10 be 2005674 2005638: 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); 200563c: 82 0e a0 30 and %i2, 0x30, %g1 _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 2005640: 80 a0 60 10 cmp %g1, 0x10 2005644: 02 80 00 05 be 2005658 2005648: 80 8e a0 04 btst 4, %i2 200564c: 80 a0 60 20 cmp %g1, 0x20 2005650: 12 80 00 71 bne 2005814 2005654: 80 8e a0 04 btst 4, %i2 2005658: 02 80 00 6f be 2005814 200565c: 80 a4 a0 00 cmp %l2, 0 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 2005660: 02 80 00 04 be 2005670 2005664: 80 8e a0 80 btst 0x80, %i2 2005668: 32 80 00 16 bne,a 20056c0 200566c: 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); 2005670: a6 0e a0 30 and %i2, 0x30, %l3 2005674: 80 a0 00 13 cmp %g0, %l3 2005678: 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 ) ) 200567c: 80 a4 60 00 cmp %l1, 0 2005680: 12 80 00 04 bne 2005690 2005684: 80 a6 60 01 cmp %i1, 1 2005688: 18 80 00 0e bgu 20056c0 200568c: b0 10 20 0a mov 0xa, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005690: 03 00 80 62 sethi %hi(0x2018800), %g1 2005694: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> 2005698: 84 00 a0 01 inc %g2 200569c: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 20056a0: 11 00 80 62 sethi %hi(0x2018800), %o0 20056a4: 40 00 07 05 call 20072b8 <_Objects_Allocate> 20056a8: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 20189a0 <_Semaphore_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 20056ac: a0 92 20 00 orcc %o0, 0, %l0 20056b0: 12 80 00 06 bne 20056c8 20056b4: 80 a4 60 00 cmp %l1, 0 _Thread_Enable_dispatch(); 20056b8: 7f ff ff c7 call 20055d4 <_Thread_Enable_dispatch> 20056bc: b0 10 20 05 mov 5, %i0 20056c0: 81 c7 e0 08 ret 20056c4: 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 ) ) { 20056c8: 12 80 00 32 bne 2005790 20056cc: f4 24 20 10 st %i2, [ %l0 + 0x10 ] CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 20056d0: 80 a4 a0 00 cmp %l2, 0 20056d4: 12 80 00 06 bne 20056ec 20056d8: 82 10 20 02 mov 2, %g1 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 20056dc: 80 8e a0 80 btst 0x80, %i2 20056e0: 02 80 00 05 be 20056f4 20056e4: 80 8e a0 04 btst 4, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 20056e8: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 20056ec: 10 80 00 05 b 2005700 20056f0: c2 27 bf e8 st %g1, [ %fp + -24 ] else if ( _Attributes_Is_priority( attribute_set ) ) 20056f4: 12 bf ff fe bne 20056ec 20056f8: 82 10 20 01 mov 1, %g1 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; 20056fc: c0 27 bf e8 clr [ %fp + -24 ] if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 2005700: 80 a4 e0 10 cmp %l3, 0x10 2005704: 12 80 00 0f bne 2005740 2005708: 82 10 20 02 mov 2, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 200570c: c2 07 bf e8 ld [ %fp + -24 ], %g1 2005710: 80 a0 60 01 cmp %g1, 1 2005714: 08 80 00 07 bleu 2005730 2005718: c0 27 bf e0 clr [ %fp + -32 ] 200571c: 80 a0 60 03 cmp %g1, 3 2005720: 38 80 00 0b bgu,a 200574c 2005724: 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; 2005728: 10 80 00 04 b 2005738 200572c: 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; 2005730: 10 80 00 06 b 2005748 2005734: 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; 2005738: 10 80 00 04 b 2005748 200573c: 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; 2005740: 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; 2005744: 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( 2005748: 82 1e 60 01 xor %i1, 1, %g1 200574c: 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; 2005750: f6 27 bf ec st %i3, [ %fp + -20 ] mutex_status = _CORE_mutex_Initialize( 2005754: 94 60 3f ff subx %g0, -1, %o2 2005758: 90 04 20 14 add %l0, 0x14, %o0 200575c: 40 00 04 62 call 20068e4 <_CORE_mutex_Initialize> 2005760: 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 ) { 2005764: 80 a2 20 06 cmp %o0, 6 2005768: 12 80 00 17 bne 20057c4 200576c: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 2005770: 11 00 80 62 sethi %hi(0x2018800), %o0 <== NOT EXECUTED 2005774: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 20189a0 <_Semaphore_Information> <== NOT EXECUTED 2005778: 40 00 07 d2 call 20076c0 <_Objects_Free> <== NOT EXECUTED 200577c: b0 10 20 13 mov 0x13, %i0 <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 2005780: 7f ff ff 95 call 20055d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 2005784: 01 00 00 00 nop <== NOT EXECUTED 2005788: 81 c7 e0 08 ret <== NOT EXECUTED 200578c: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) 2005790: 80 8e a0 04 btst 4, %i2 2005794: 22 80 00 04 be,a 20057a4 2005798: c0 27 bf f4 clr [ %fp + -12 ] the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 200579c: 82 10 20 01 mov 1, %g1 20057a0: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 20057a4: 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; 20057a8: c0 27 bf e0 clr [ %fp + -32 ] the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 20057ac: c0 27 bf ec clr [ %fp + -20 ] _CORE_semaphore_Initialize( 20057b0: 94 10 00 19 mov %i1, %o2 /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 20057b4: 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( 20057b8: 90 04 20 14 add %l0, 0x14, %o0 20057bc: 40 00 04 f9 call 2006ba0 <_CORE_semaphore_Initialize> 20057c0: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20057c4: 03 00 80 62 sethi %hi(0x2018800), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 20057c8: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20057cc: 88 10 61 a0 or %g1, 0x1a0, %g4 20057d0: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 20057d4: 03 00 00 3f sethi %hi(0xfc00), %g1 20057d8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20057dc: 82 08 c0 01 and %g3, %g1, %g1 20057e0: 80 a0 40 02 cmp %g1, %g2 20057e4: 38 80 00 06 bgu,a 20057fc 20057e8: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 20057ec: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 20057f0: 83 28 60 02 sll %g1, 2, %g1 20057f4: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 20057f8: 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; 20057fc: e8 24 20 0c st %l4, [ %l0 + 0xc ] 2005800: c2 27 00 00 st %g1, [ %i4 ] the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 2005804: 7f ff ff 74 call 20055d4 <_Thread_Enable_dispatch> 2005808: b0 10 20 00 clr %i0 200580c: 81 c7 e0 08 ret 2005810: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 2005814: b0 10 20 0b mov 0xb, %i0 } 2005818: 81 c7 e0 08 ret 200581c: 81 e8 00 00 restore 02005854 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 2005854: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2005858: 11 00 80 62 sethi %hi(0x2018800), %o0 200585c: 92 10 00 18 mov %i0, %o1 2005860: 90 12 21 a0 or %o0, 0x1a0, %o0 2005864: 40 00 07 d9 call 20077c8 <_Objects_Get> 2005868: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 200586c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005870: 80 a0 60 00 cmp %g1, 0 2005874: 02 80 00 07 be 2005890 2005878: b0 10 00 08 mov %o0, %i0 200587c: 80 a0 60 02 cmp %g1, 2 2005880: 08 80 00 10 bleu 20058c0 2005884: b0 10 20 04 mov 4, %i0 2005888: 81 c7 e0 08 ret <== NOT EXECUTED 200588c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 2005890: 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) ) { 2005894: 84 88 60 30 andcc %g1, 0x30, %g2 2005898: 22 80 00 12 be,a 20058e0 200589c: 90 02 20 14 add %o0, 0x14, %o0 if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 20058a0: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 20058a4: 80 a0 60 00 cmp %g1, 0 20058a8: 12 80 00 08 bne 20058c8 20058ac: 80 a0 a0 20 cmp %g2, 0x20 20058b0: 02 80 00 07 be 20058cc 20058b4: 90 06 20 14 add %i0, 0x14, %o0 !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 20058b8: 7f ff ff da call 2005820 <_Thread_Enable_dispatch> 20058bc: b0 10 20 0c mov 0xc, %i0 20058c0: 81 c7 e0 08 ret 20058c4: 81 e8 00 00 restore return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 20058c8: 90 06 20 14 add %i0, 0x14, %o0 20058cc: 92 10 20 00 clr %o1 20058d0: 40 00 04 01 call 20068d4 <_CORE_mutex_Flush> 20058d4: 94 10 20 04 mov 4, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20058d8: 10 80 00 06 b 20058f0 20058dc: 03 00 80 62 sethi %hi(0x2018800), %g1 &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 20058e0: 92 10 20 00 clr %o1 20058e4: 40 00 04 ab call 2006b90 <_CORE_semaphore_Flush> 20058e8: 94 10 20 02 mov 2, %o2 20058ec: 03 00 80 62 sethi %hi(0x2018800), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 20058f0: c6 06 20 08 ld [ %i0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20058f4: 90 10 61 a0 or %g1, 0x1a0, %o0 20058f8: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 20058fc: 03 00 00 3f sethi %hi(0xfc00), %g1 2005900: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005904: 82 08 c0 01 and %g3, %g1, %g1 2005908: 80 a0 40 02 cmp %g1, %g2 200590c: 18 80 00 05 bgu 2005920 2005910: 92 10 00 18 mov %i0, %o1 information->local_table[ index ] = the_object; 2005914: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005918: 83 28 60 02 sll %g1, 2, %g1 200591c: 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; 2005920: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 2005924: 40 00 07 67 call 20076c0 <_Objects_Free> 2005928: b0 10 20 00 clr %i0 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 200592c: 7f ff ff bd call 2005820 <_Thread_Enable_dispatch> 2005930: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005934: 81 c7 e0 08 ret 2005938: 81 e8 00 00 restore 02005d98 : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 2005d98: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2005d9c: 11 00 80 6a sethi %hi(0x201a800), %o0 2005da0: 92 10 00 18 mov %i0, %o1 2005da4: 90 12 23 68 or %o0, 0x368, %o0 2005da8: 40 00 08 56 call 2007f00 <_Objects_Get> 2005dac: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2005db0: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005db4: 80 a0 60 00 cmp %g1, 0 2005db8: 22 80 00 07 be,a 2005dd4 2005dbc: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2005dc0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2005dc4: 08 80 00 19 bleu 2005e28 <== NOT EXECUTED 2005dc8: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2005dcc: 81 c7 e0 08 ret <== NOT EXECUTED 2005dd0: 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) ) { 2005dd4: 80 88 60 30 btst 0x30, %g1 2005dd8: 02 80 00 06 be 2005df0 2005ddc: 90 02 20 14 add %o0, 0x14, %o0 _CORE_mutex_Flush( 2005de0: 92 10 20 00 clr %o1 2005de4: 40 00 04 8a call 200700c <_CORE_mutex_Flush> 2005de8: 94 10 20 01 mov 1, %o2 2005dec: 30 80 00 04 b,a 2005dfc &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 2005df0: 92 10 20 00 clr %o1 <== NOT EXECUTED 2005df4: 40 00 05 35 call 20072c8 <_CORE_semaphore_Flush> <== NOT EXECUTED 2005df8: 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 ) 2005dfc: 03 00 80 6b sethi %hi(0x201ac00), %g1 2005e00: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 201acb0 <_Thread_Dispatch_disable_level> 2005e04: b0 10 20 00 clr %i0 2005e08: 84 00 bf ff add %g2, -1, %g2 2005e0c: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ] 2005e10: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 2005e14: 80 a0 60 00 cmp %g1, 0 2005e18: 12 80 00 04 bne 2005e28 2005e1c: 01 00 00 00 nop _Thread_Dispatch(); 2005e20: 40 00 0c fe call 2009218 <_Thread_Dispatch> 2005e24: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005e28: 81 c7 e0 08 ret 2005e2c: 81 e8 00 00 restore 02005970 : rtems_status_code rtems_semaphore_obtain( rtems_id id, uint32_t option_set, rtems_interval timeout ) { 2005970: 9d e3 bf 90 save %sp, -112, %sp Objects_Id id, Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) 2005974: 11 00 80 62 sethi %hi(0x2018800), %o0 2005978: 92 10 00 18 mov %i0, %o1 200597c: 90 12 21 a0 or %o0, 0x1a0, %o0 2005980: 94 07 bf f4 add %fp, -12, %o2 2005984: 40 00 07 73 call 2007750 <_Objects_Get_isr_disable> 2005988: 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 ) { 200598c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005990: 80 a0 60 00 cmp %g1, 0 2005994: 02 80 00 07 be 20059b0 2005998: a0 10 00 08 mov %o0, %l0 200599c: 80 a0 60 02 cmp %g1, 2 20059a0: 08 80 00 ab bleu 2005c4c 20059a4: 90 10 20 04 mov 4, %o0 20059a8: 10 80 00 a9 b 2005c4c <== NOT EXECUTED 20059ac: 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) ) { 20059b0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 20059b4: 80 88 60 30 btst 0x30, %g1 20059b8: 02 80 00 7c be 2005ba8 20059bc: 03 00 80 62 sethi %hi(0x2018800), %g1 _CORE_mutex_Seize( 20059c0: 03 00 80 62 sethi %hi(0x2018800), %g1 20059c4: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 20059c8: 80 a0 60 00 cmp %g1, 0 20059cc: 02 80 00 0e be 2005a04 20059d0: 03 00 80 62 sethi %hi(0x2018800), %g1 20059d4: 80 8e 60 01 btst 1, %i1 20059d8: 12 80 00 0c bne 2005a08 20059dc: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 20059e0: 03 00 80 63 sethi %hi(0x2018c00), %g1 20059e4: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> 20059e8: 80 a0 60 01 cmp %g1, 1 20059ec: 08 80 00 05 bleu 2005a00 20059f0: 90 10 20 00 clr %o0 20059f4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20059f8: 40 00 06 03 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 20059fc: 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; 2005a00: 03 00 80 62 sethi %hi(0x2018800), %g1 2005a04: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 2005a08: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2005a0c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2005a10: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 2005a14: 80 a0 60 00 cmp %g1, 0 2005a18: 22 80 00 33 be,a 2005ae4 2005a1c: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 2005a20: c0 24 20 64 clr [ %l0 + 0x64 ] the_mutex->holder = executing; 2005a24: c4 24 20 70 st %g2, [ %l0 + 0x70 ] the_mutex->holder_id = executing->Object.id; 2005a28: 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; 2005a2c: 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; 2005a30: c2 24 20 74 st %g1, [ %l0 + 0x74 ] the_mutex->nest_count = 1; 2005a34: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2005a38: 80 a0 e0 02 cmp %g3, 2 2005a3c: 02 80 00 05 be 2005a50 2005a40: c2 24 20 68 st %g1, [ %l0 + 0x68 ] 2005a44: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2005a48: 32 80 00 06 bne,a 2005a60 <== NOT EXECUTED 2005a4c: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2005a50: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 2005a54: 82 00 60 01 inc %g1 2005a58: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2005a5c: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 2005a60: 80 a0 60 03 cmp %g1, 3 2005a64: 22 80 00 03 be,a 2005a70 2005a68: c6 04 20 60 ld [ %l0 + 0x60 ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2005a6c: 30 80 00 2e b,a 2005b24 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2005a70: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2005a74: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2005a78: 12 80 00 03 bne 2005a84 <== NOT EXECUTED 2005a7c: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2005a80: 30 80 00 29 b,a 2005b24 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2005a84: 28 80 00 10 bleu,a 2005ac4 <== NOT EXECUTED 2005a88: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005a8c: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2005a90: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2005a94: 82 00 60 01 inc %g1 <== NOT EXECUTED 2005a98: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2005a9c: 7f ff f0 b4 call 2001d6c <== NOT EXECUTED 2005aa0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Change_priority( 2005aa4: d2 04 20 60 ld [ %l0 + 0x60 ], %o1 <== NOT EXECUTED 2005aa8: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 <== NOT EXECUTED 2005aac: 40 00 0b 0f call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 2005ab0: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2005ab4: 7f ff ff a2 call 200593c <_Thread_Enable_dispatch> <== NOT EXECUTED 2005ab8: 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( 2005abc: 10 80 00 36 b 2005b94 <== NOT EXECUTED 2005ac0: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2005ac4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2005ac8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2005acc: 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; 2005ad0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2005ad4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2005ad8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2005adc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2005ae0: 30 80 00 11 b,a 2005b24 <== 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 ) ) { 2005ae4: 80 a0 40 02 cmp %g1, %g2 2005ae8: 12 80 00 13 bne 2005b34 2005aec: 80 8e 60 01 btst 1, %i1 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2005af0: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 2005af4: 80 a0 60 00 cmp %g1, 0 2005af8: 22 80 00 07 be,a 2005b14 2005afc: c2 04 20 68 ld [ %l0 + 0x68 ], %g1 2005b00: 80 a0 60 01 cmp %g1, 1 2005b04: 12 80 00 0c bne 2005b34 2005b08: 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; 2005b0c: 10 80 00 05 b 2005b20 <== NOT EXECUTED 2005b10: 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++; 2005b14: 82 00 60 01 inc %g1 2005b18: c2 24 20 68 st %g1, [ %l0 + 0x68 ] _ISR_Enable( level ); 2005b1c: 30 80 00 02 b,a 2005b24 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2005b20: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2005b24: 7f ff f0 92 call 2001d6c 2005b28: 01 00 00 00 nop 2005b2c: 10 80 00 1a b 2005b94 2005b30: 03 00 80 62 sethi %hi(0x2018800), %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 2005b34: 02 80 00 08 be 2005b54 2005b38: 23 00 80 62 sethi %hi(0x2018800), %l1 2005b3c: 7f ff f0 8c call 2001d6c 2005b40: d0 07 bf f0 ld [ %fp + -16 ], %o0 2005b44: c4 04 63 d0 ld [ %l1 + 0x3d0 ], %g2 2005b48: 82 10 20 01 mov 1, %g1 2005b4c: 10 80 00 11 b 2005b90 2005b50: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] 2005b54: c6 04 63 d0 ld [ %l1 + 0x3d0 ], %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; 2005b58: 82 10 20 01 mov 1, %g1 2005b5c: 05 00 80 62 sethi %hi(0x2018800), %g2 2005b60: c2 24 20 44 st %g1, [ %l0 + 0x44 ] 2005b64: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 2005b68: f0 20 e0 20 st %i0, [ %g3 + 0x20 ] 2005b6c: 82 00 60 01 inc %g1 2005b70: a0 04 20 14 add %l0, 0x14, %l0 2005b74: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2005b78: e0 20 e0 44 st %l0, [ %g3 + 0x44 ] 2005b7c: 7f ff f0 7c call 2001d6c 2005b80: d0 07 bf f0 ld [ %fp + -16 ], %o0 2005b84: 90 10 00 10 mov %l0, %o0 2005b88: 40 00 03 85 call 200699c <_CORE_mutex_Seize_interrupt_blocking> 2005b8c: 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( 2005b90: 03 00 80 62 sethi %hi(0x2018800), %g1 2005b94: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> 2005b98: 40 00 00 62 call 2005d20 <_Semaphore_Translate_core_mutex_return_code> 2005b9c: 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 */ } 2005ba0: 81 c7 e0 08 ret 2005ba4: 91 e8 00 08 restore %g0, %o0, %o0 Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2005ba8: e2 00 63 d0 ld [ %g1 + 0x3d0 ], %l1 Watchdog_Interval timeout, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 2005bac: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 2005bb0: c0 24 60 34 clr [ %l1 + 0x34 ] if ( the_semaphore->count != 0 ) { 2005bb4: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 2005bb8: 80 a0 60 00 cmp %g1, 0 2005bbc: 02 80 00 08 be 2005bdc 2005bc0: 80 8e 60 01 btst 1, %i1 the_semaphore->count -= 1; 2005bc4: 82 00 7f ff add %g1, -1, %g1 2005bc8: c2 24 20 5c st %g1, [ %l0 + 0x5c ] _ISR_Enable( level ); 2005bcc: 7f ff f0 68 call 2001d6c 2005bd0: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 2005bd4: 10 80 00 1b b 2005c40 2005bd8: 03 00 80 62 sethi %hi(0x2018800), %g1 return; } if ( !wait ) { 2005bdc: 02 80 00 07 be 2005bf8 2005be0: 05 00 80 62 sethi %hi(0x2018800), %g2 _ISR_Enable( level ); 2005be4: 7f ff f0 62 call 2001d6c 2005be8: 01 00 00 00 nop executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 2005bec: 82 10 20 01 mov 1, %g1 ! 1 2005bf0: 10 80 00 13 b 2005c3c 2005bf4: c2 24 60 34 st %g1, [ %l1 + 0x34 ] 2005bf8: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 2005bfc: 82 00 60 01 inc %g1 2005c00: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2005c04: 82 10 20 01 mov 1, %g1 2005c08: 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; 2005c0c: 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; 2005c10: a0 04 20 14 add %l0, 0x14, %l0 2005c14: e0 24 60 44 st %l0, [ %l1 + 0x44 ] executing->Wait.id = id; _ISR_Enable( level ); 2005c18: 7f ff f0 55 call 2001d6c 2005c1c: 01 00 00 00 nop _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 2005c20: 90 10 00 10 mov %l0, %o0 2005c24: 92 10 00 1a mov %i2, %o1 2005c28: 15 00 80 25 sethi %hi(0x2009400), %o2 2005c2c: 40 00 0d 83 call 2009238 <_Thread_queue_Enqueue_with_handler> 2005c30: 94 12 a2 d0 or %o2, 0x2d0, %o2 ! 20096d0 <_Thread_queue_Timeout> _Thread_Enable_dispatch(); 2005c34: 7f ff ff 42 call 200593c <_Thread_Enable_dispatch> 2005c38: 01 00 00 00 nop 2005c3c: 03 00 80 62 sethi %hi(0x2018800), %g1 2005c40: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> 2005c44: 40 00 00 41 call 2005d48 <_Semaphore_Translate_core_semaphore_return_code> 2005c48: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005c4c: b0 10 00 08 mov %o0, %i0 2005c50: 81 c7 e0 08 ret 2005c54: 81 e8 00 00 restore 02005c8c : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 2005c8c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2005c90: 11 00 80 62 sethi %hi(0x2018800), %o0 2005c94: 92 10 00 18 mov %i0, %o1 2005c98: 90 12 21 a0 or %o0, 0x1a0, %o0 2005c9c: 40 00 06 cb call 20077c8 <_Objects_Get> 2005ca0: 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 ) { 2005ca4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005ca8: 80 a0 60 00 cmp %g1, 0 2005cac: 22 80 00 07 be,a 2005cc8 2005cb0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2005cb4: 80 a0 60 02 cmp %g1, 2 2005cb8: 08 80 00 17 bleu 2005d14 2005cbc: 90 10 20 04 mov 4, %o0 2005cc0: 10 80 00 15 b 2005d14 <== NOT EXECUTED 2005cc4: 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) ) { 2005cc8: 80 88 60 30 btst 0x30, %g1 2005ccc: 02 80 00 0b be 2005cf8 2005cd0: 90 02 20 14 add %o0, 0x14, %o0 mutex_status = _CORE_mutex_Surrender( 2005cd4: 92 10 00 18 mov %i0, %o1 2005cd8: 40 00 03 53 call 2006a24 <_CORE_mutex_Surrender> 2005cdc: 94 10 20 00 clr %o2 &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 2005ce0: 7f ff ff de call 2005c58 <_Thread_Enable_dispatch> 2005ce4: a0 10 00 08 mov %o0, %l0 return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 2005ce8: 40 00 00 0e call 2005d20 <_Semaphore_Translate_core_mutex_return_code> 2005cec: 90 10 00 10 mov %l0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005cf0: 81 c7 e0 08 ret 2005cf4: 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( 2005cf8: 92 10 00 18 mov %i0, %o1 2005cfc: 40 00 03 b8 call 2006bdc <_CORE_semaphore_Surrender> 2005d00: 94 10 20 00 clr %o2 &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 2005d04: 7f ff ff d5 call 2005c58 <_Thread_Enable_dispatch> 2005d08: a0 10 00 08 mov %o0, %l0 return 2005d0c: 40 00 00 0f call 2005d48 <_Semaphore_Translate_core_semaphore_return_code> 2005d10: 90 10 00 10 mov %l0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005d14: b0 10 00 08 mov %o0, %i0 2005d18: 81 c7 e0 08 ret 2005d1c: 81 e8 00 00 restore 02016334 : */ void rtems_shutdown_executive( uint32_t result ) { 2016334: 9d e3 bf 98 save %sp, -104, %sp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 2016338: 33 00 80 63 sethi %hi(0x2018c00), %i1 201633c: c2 06 60 d0 ld [ %i1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> 2016340: 80 a0 60 04 cmp %g1, 4 2016344: 02 80 00 0c be 2016374 2016348: 11 00 80 5d sethi %hi(0x2017400), %o0 #if defined(__USE_INIT_FINI__) extern void _fini( void ); atexit( _fini ); 201634c: 7f ff e0 1d call 200e3c0 2016350: 90 12 23 74 or %o0, 0x374, %o0 ! 2017774 <_fini> * routine which initialized the system. */ RTEMS_INLINE_ROUTINE void _Thread_Stop_multitasking( void ) { _Context_Switch( &_Thread_Executing->Registers, &_Thread_BSP_context ); 2016354: 03 00 80 62 sethi %hi(0x2018800), %g1 2016358: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_Thread_Executing> 201635c: 82 10 20 04 mov 4, %g1 2016360: b0 06 20 e0 add %i0, 0xe0, %i0 2016364: c2 26 60 d0 st %g1, [ %i1 + 0xd0 ] 2016368: 33 00 80 62 sethi %hi(0x2018800), %i1 201636c: 7f ff d0 43 call 200a478 <_CPU_Context_switch> 2016370: 93 ee 62 68 restore %i1, 0x268, %o1 2016374: 81 c7 e0 08 ret <== NOT EXECUTED 2016378: 81 e8 00 00 restore <== NOT EXECUTED 02011268 : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 2011268: 9d e3 bf 90 save %sp, -112, %sp 201126c: 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 ) 2011270: 80 a6 60 00 cmp %i1, 0 2011274: 02 80 00 47 be 2011390 2011278: 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 ) ) { 201127c: 80 a2 60 00 cmp %o1, 0 2011280: 12 80 00 0a bne 20112a8 2011284: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2011288: 03 00 80 c9 sethi %hi(0x2032400), %g1 201128c: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20325f0 <_Thread_Dispatch_disable_level> 2011290: 84 00 a0 01 inc %g2 2011294: 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; 2011298: 03 00 80 c9 sethi %hi(0x2032400), %g1 201129c: f0 00 62 d0 ld [ %g1 + 0x2d0 ], %i0 ! 20326d0 <_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; 20112a0: 10 80 00 18 b 2011300 20112a4: 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); 20112a8: 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 ) { 20112ac: 80 a0 a0 04 cmp %g2, 4 20112b0: 18 80 00 0e bgu 20112e8 20112b4: 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 :) */ 20112b8: 83 32 60 1b srl %o1, 0x1b, %g1 20112bc: 80 a0 60 01 cmp %g1, 1 20112c0: 12 80 00 0a bne 20112e8 20112c4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20112c8: 83 28 a0 02 sll %g2, 2, %g1 20112cc: 05 00 80 c9 sethi %hi(0x2032400), %g2 20112d0: 84 10 a1 50 or %g2, 0x150, %g2 ! 2032550 <_Objects_Information_table> 20112d4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20112d8: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20112dc: 80 a2 20 00 cmp %o0, 0 20112e0: 12 80 00 05 bne 20112f4 20112e4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20112e8: b0 10 20 00 clr %i0 20112ec: 10 80 00 05 b 2011300 20112f0: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20112f4: 40 00 0d ef call 2014ab0 <_Objects_Get> 20112f8: 94 07 bf f4 add %fp, -12, %o2 20112fc: b0 10 00 08 mov %o0, %i0 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2011300: c2 07 bf f4 ld [ %fp + -12 ], %g1 2011304: 80 a0 60 00 cmp %g1, 0 2011308: 22 80 00 07 be,a 2011324 201130c: d2 06 21 70 ld [ %i0 + 0x170 ], %o1 2011310: 80 a0 60 02 cmp %g1, 2 2011314: 08 80 00 1f bleu 2011390 2011318: b0 10 20 04 mov 4, %i0 201131c: 81 c7 e0 08 ret <== NOT EXECUTED 2011320: 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 ) ) { 2011324: c2 02 60 4c ld [ %o1 + 0x4c ], %g1 2011328: 80 a0 60 00 cmp %g1, 0 201132c: 02 80 00 1b be 2011398 2011330: 01 00 00 00 nop if ( asr->is_enabled ) { 2011334: c2 02 60 48 ld [ %o1 + 0x48 ], %g1 2011338: 80 a0 60 00 cmp %g1, 0 201133c: 02 80 00 11 be 2011380 2011340: 90 10 00 19 mov %i1, %o0 _ASR_Post_signals( signal_set, &asr->signals_posted ); 2011344: 7f ff ff b3 call 2011210 <_ASR_Post_signals> 2011348: 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 ) ) 201134c: 03 00 80 c9 sethi %hi(0x2032400), %g1 2011350: c2 00 62 b8 ld [ %g1 + 0x2b8 ], %g1 ! 20326b8 <_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; 2011354: 84 10 20 01 mov 1, %g2 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 2011358: 80 a0 60 00 cmp %g1, 0 201135c: 02 80 00 0b be 2011388 2011360: c4 26 20 78 st %g2, [ %i0 + 0x78 ] 2011364: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2011368: c2 00 62 d0 ld [ %g1 + 0x2d0 ], %g1 ! 20326d0 <_Thread_Executing> <== NOT EXECUTED 201136c: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 2011370: 12 80 00 06 bne 2011388 <== NOT EXECUTED 2011374: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 2011378: 10 80 00 04 b 2011388 <== NOT EXECUTED 201137c: c4 20 63 78 st %g2, [ %g1 + 0x378 ] ! 2032778 <_ISR_Signals_to_thread_executing> <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); 2011380: 7f ff ff a4 call 2011210 <_ASR_Post_signals> 2011384: 92 02 60 58 add %o1, 0x58, %o1 } _Thread_Enable_dispatch(); 2011388: 7f ff ff ab call 2011234 <_Thread_Enable_dispatch> 201138c: b0 10 20 00 clr %i0 2011390: 81 c7 e0 08 ret 2011394: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2011398: 7f ff ff a7 call 2011234 <_Thread_Enable_dispatch> 201139c: b0 10 20 0b mov 0xb, %i0 return RTEMS_NOT_DEFINED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20113a0: 81 c7 e0 08 ret 20113a4: 81 e8 00 00 restore 02005f2c : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 2005f2c: 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 ) ) { 2005f30: 92 96 20 00 orcc %i0, 0, %o1 2005f34: 12 80 00 0a bne 2005f5c 2005f38: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005f3c: 03 00 80 62 sethi %hi(0x2018800), %g1 2005f40: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> 2005f44: 84 00 a0 01 inc %g2 2005f48: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] 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; 2005f4c: 03 00 80 62 sethi %hi(0x2018800), %g1 2005f50: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_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; 2005f54: 10 80 00 18 b 2005fb4 2005f58: 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); 2005f5c: 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 ) { 2005f60: 80 a0 a0 04 cmp %g2, 4 2005f64: 18 80 00 0e bgu 2005f9c 2005f68: 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 :) */ 2005f6c: 83 32 60 1b srl %o1, 0x1b, %g1 2005f70: 80 a0 60 01 cmp %g1, 1 2005f74: 12 80 00 0a bne 2005f9c 2005f78: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2005f7c: 83 28 a0 02 sll %g2, 2, %g1 2005f80: 05 00 80 62 sethi %hi(0x2018800), %g2 2005f84: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 2005f88: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2005f8c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2005f90: 80 a2 20 00 cmp %o0, 0 2005f94: 12 80 00 05 bne 2005fa8 2005f98: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2005f9c: b0 10 20 00 clr %i0 2005fa0: 10 80 00 05 b 2005fb4 2005fa4: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2005fa8: 40 00 06 08 call 20077c8 <_Objects_Get> 2005fac: 94 07 bf f4 add %fp, -12, %o2 2005fb0: 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 ) { 2005fb4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005fb8: 80 a0 60 00 cmp %g1, 0 2005fbc: 02 80 00 06 be 2005fd4 2005fc0: 80 a0 60 02 cmp %g1, 2 2005fc4: 08 80 00 0b bleu 2005ff0 2005fc8: b0 10 20 04 mov 4, %i0 2005fcc: 81 c7 e0 08 ret <== NOT EXECUTED 2005fd0: 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 ); 2005fd4: 7f ff ff c0 call 2005ed4 <_Objects_Get_information> 2005fd8: d0 06 20 08 ld [ %i0 + 8 ], %o0 if ( !the_information ) { 2005fdc: 80 a2 20 00 cmp %o0, 0 2005fe0: 12 80 00 06 bne 2005ff8 2005fe4: 01 00 00 00 nop _Thread_Enable_dispatch(); 2005fe8: 7f ff ff c4 call 2005ef8 <_Thread_Enable_dispatch> <== NOT EXECUTED 2005fec: b0 10 20 04 mov 4, %i0 ! 4 <== NOT EXECUTED 2005ff0: 81 c7 e0 08 ret 2005ff4: 81 e8 00 00 restore return RTEMS_INVALID_ID; /* This should never happen if _Thread_Get() works right */ } _Thread_Close( the_information, the_thread ); 2005ff8: 40 00 0a 6a call 20089a0 <_Thread_Close> 2005ffc: 92 10 00 18 mov %i0, %o1 2006000: 7f ff ff b5 call 2005ed4 <_Objects_Get_information> 2006004: d0 06 20 08 ld [ %i0 + 8 ], %o0 2006008: 92 10 00 18 mov %i0, %o1 200600c: 40 00 05 ad call 20076c0 <_Objects_Free> 2006010: b0 10 20 00 clr %i0 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 2006014: 7f ff ff b9 call 2005ef8 <_Thread_Enable_dispatch> 2006018: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200601c: 81 c7 e0 08 ret 2006020: 81 e8 00 00 restore 02007838 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 2007838: 9d e3 bf 90 save %sp, -112, %sp 200783c: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !note ) 2007840: 80 a6 a0 00 cmp %i2, 0 2007844: 02 80 00 43 be 2007950 2007848: 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 ) 200784c: 80 a6 60 0f cmp %i1, 0xf 2007850: 18 80 00 40 bgu 2007950 2007854: 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 ) || 2007858: 80 a2 60 00 cmp %o1, 0 200785c: 02 80 00 08 be 200787c 2007860: 03 00 80 79 sethi %hi(0x201e400), %g1 2007864: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 201e580 <_Thread_Executing> 2007868: c2 00 60 08 ld [ %g1 + 8 ], %g1 200786c: 80 a2 40 01 cmp %o1, %g1 2007870: 12 80 00 0a bne 2007898 2007874: 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 ]; 2007878: 03 00 80 79 sethi %hi(0x201e400), %g1 <== NOT EXECUTED 200787c: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 201e580 <_Thread_Executing> 2007880: 85 2e 60 02 sll %i1, 2, %g2 2007884: c2 00 61 70 ld [ %g1 + 0x170 ], %g1 2007888: c2 00 40 02 ld [ %g1 + %g2 ], %g1 200788c: c2 26 80 00 st %g1, [ %i2 ] 2007890: 81 c7 e0 08 ret 2007894: 91 e8 20 00 restore %g0, 0, %o0 2007898: 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 ) { 200789c: 80 a0 a0 04 cmp %g2, 4 20078a0: 18 80 00 06 bgu 20078b8 20078a4: 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 :) */ 20078a8: 83 32 60 1b srl %o1, 0x1b, %g1 20078ac: 80 a0 60 01 cmp %g1, 1 20078b0: 02 80 00 05 be 20078c4 20078b4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20078b8: 90 10 20 00 clr %o0 20078bc: 10 80 00 0e b 20078f4 20078c0: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20078c4: 83 28 a0 02 sll %g2, 2, %g1 20078c8: 05 00 80 79 sethi %hi(0x201e400), %g2 20078cc: 84 10 a0 00 mov %g2, %g2 ! 201e400 <_Objects_Information_table> 20078d0: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20078d4: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20078d8: 80 a2 20 00 cmp %o0, 0 20078dc: 12 80 00 04 bne 20078ec 20078e0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20078e4: 10 80 00 04 b 20078f4 <== NOT EXECUTED 20078e8: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20078ec: 40 00 07 52 call 2009634 <_Objects_Get> 20078f0: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 20078f4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20078f8: 80 a0 60 00 cmp %g1, 0 20078fc: 22 80 00 07 be,a 2007918 2007900: c4 02 21 70 ld [ %o0 + 0x170 ], %g2 2007904: 80 a0 60 02 cmp %g1, 2 2007908: 08 80 00 12 bleu 2007950 200790c: b0 10 20 04 mov 4, %i0 2007910: 81 c7 e0 08 ret <== NOT EXECUTED 2007914: 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 ]; 2007918: 83 2e 60 02 sll %i1, 2, %g1 200791c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2007920: 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 ) 2007924: 05 00 80 79 sethi %hi(0x201e400), %g2 2007928: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 ! 201e4a0 <_Thread_Dispatch_disable_level> 200792c: b0 10 20 00 clr %i0 2007930: 82 00 7f ff add %g1, -1, %g1 2007934: c2 20 a0 a0 st %g1, [ %g2 + 0xa0 ] 2007938: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 200793c: 80 a0 60 00 cmp %g1, 0 2007940: 12 80 00 04 bne 2007950 2007944: 01 00 00 00 nop _Thread_Dispatch(); 2007948: 40 00 0c 01 call 200a94c <_Thread_Dispatch> 200794c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007950: 81 c7 e0 08 ret 2007954: 81 e8 00 00 restore 020066b8 : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 20066b8: 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 ) ) { 20066bc: 92 96 20 00 orcc %i0, 0, %o1 20066c0: 12 80 00 0a bne 20066e8 20066c4: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20066c8: 03 00 80 70 sethi %hi(0x201c000), %g1 <== NOT EXECUTED 20066cc: c4 00 62 90 ld [ %g1 + 0x290 ], %g2 ! 201c290 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20066d0: 84 00 a0 01 inc %g2 <== NOT EXECUTED 20066d4: c4 20 62 90 st %g2, [ %g1 + 0x290 ] <== 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; 20066d8: 03 00 80 70 sethi %hi(0x201c000), %g1 <== NOT EXECUTED 20066dc: d0 00 63 70 ld [ %g1 + 0x370 ], %o0 ! 201c370 <_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; 20066e0: 10 80 00 19 b 2006744 <== NOT EXECUTED 20066e4: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 20066e8: 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 ) { 20066ec: 80 a0 a0 04 cmp %g2, 4 20066f0: 18 80 00 06 bgu 2006708 20066f4: 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 :) */ 20066f8: 83 32 60 1b srl %o1, 0x1b, %g1 20066fc: 80 a0 60 01 cmp %g1, 1 2006700: 02 80 00 05 be 2006714 2006704: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2006708: 90 10 20 00 clr %o0 <== NOT EXECUTED 200670c: 10 80 00 0e b 2006744 <== NOT EXECUTED 2006710: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2006714: 83 28 a0 02 sll %g2, 2, %g1 2006718: 05 00 80 70 sethi %hi(0x201c000), %g2 200671c: 84 10 a1 f0 or %g2, 0x1f0, %g2 ! 201c1f0 <_Objects_Information_table> 2006720: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2006724: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2006728: 80 a2 20 00 cmp %o0, 0 200672c: 12 80 00 04 bne 200673c 2006730: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2006734: 10 80 00 04 b 2006744 <== NOT EXECUTED 2006738: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200673c: 40 00 06 58 call 200809c <_Objects_Get> 2006740: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006744: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006748: 80 a0 60 00 cmp %g1, 0 200674c: 22 80 00 07 be,a 2006768 2006750: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2006754: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2006758: 08 80 00 09 bleu 200677c <== NOT EXECUTED 200675c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2006760: 81 c7 e0 08 ret <== NOT EXECUTED 2006764: 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 ) ) { 2006768: 80 88 60 02 btst 2, %g1 200676c: 12 80 00 06 bne 2006784 2006770: 01 00 00 00 nop _Thread_Enable_dispatch(); 2006774: 7f ff ff c4 call 2006684 <_Thread_Enable_dispatch> 2006778: b0 10 20 00 clr %i0 ! 0 200677c: 81 c7 e0 08 ret 2006780: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2006784: 7f ff ff c0 call 2006684 <_Thread_Enable_dispatch> 2006788: b0 10 20 0f mov 0xf, %i0 return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200678c: 81 c7 e0 08 ret 2006790: 81 e8 00 00 restore 02006d0c : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 2006d0c: 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 ) ) { 2006d10: 92 96 20 00 orcc %i0, 0, %o1 2006d14: 12 80 00 0a bne 2006d3c 2006d18: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006d1c: 03 00 80 71 sethi %hi(0x201c400), %g1 2006d20: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 201c7d0 <_Thread_Dispatch_disable_level> 2006d24: 84 00 a0 01 inc %g2 2006d28: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 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; 2006d2c: 03 00 80 72 sethi %hi(0x201c800), %g1 2006d30: d0 00 60 b0 ld [ %g1 + 0xb0 ], %o0 ! 201c8b0 <_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; 2006d34: 10 80 00 19 b 2006d98 2006d38: c0 27 bf f4 clr [ %fp + -12 ] 2006d3c: 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 ) { 2006d40: 80 a0 a0 04 cmp %g2, 4 2006d44: 18 80 00 06 bgu 2006d5c 2006d48: 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 :) */ 2006d4c: 83 32 60 1b srl %o1, 0x1b, %g1 2006d50: 80 a0 60 01 cmp %g1, 1 2006d54: 02 80 00 05 be 2006d68 2006d58: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2006d5c: 90 10 20 00 clr %o0 2006d60: 10 80 00 0e b 2006d98 2006d64: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2006d68: 83 28 a0 02 sll %g2, 2, %g1 2006d6c: 05 00 80 71 sethi %hi(0x201c400), %g2 2006d70: 84 10 a3 30 or %g2, 0x330, %g2 ! 201c730 <_Objects_Information_table> 2006d74: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2006d78: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2006d7c: 80 a2 20 00 cmp %o0, 0 2006d80: 12 80 00 04 bne 2006d90 2006d84: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2006d88: 10 80 00 04 b 2006d98 <== NOT EXECUTED 2006d8c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2006d90: 40 00 06 1f call 200860c <_Objects_Get> 2006d94: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006d98: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006d9c: 80 a0 60 00 cmp %g1, 0 2006da0: 22 80 00 07 be,a 2006dbc 2006da4: 94 10 00 19 mov %i1, %o2 2006da8: 80 a0 60 02 cmp %g1, 2 2006dac: 08 80 00 0b bleu 2006dd8 2006db0: b0 10 20 04 mov 4, %i0 2006db4: 81 c7 e0 08 ret <== NOT EXECUTED 2006db8: 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 ) ) { 2006dbc: 40 00 0d d5 call 200a510 <_Thread_Restart> 2006dc0: 92 10 20 00 clr %o1 2006dc4: 80 a2 20 00 cmp %o0, 0 2006dc8: 02 80 00 06 be 2006de0 2006dcc: 01 00 00 00 nop _Thread_Enable_dispatch(); 2006dd0: 7f ff ff c2 call 2006cd8 <_Thread_Enable_dispatch> 2006dd4: b0 10 20 00 clr %i0 ! 0 2006dd8: 81 c7 e0 08 ret 2006ddc: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2006de0: 7f ff ff be call 2006cd8 <_Thread_Enable_dispatch> 2006de4: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006de8: 81 c7 e0 08 ret 2006dec: 81 e8 00 00 restore 020076d8 : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 20076d8: 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 ) ) { 20076dc: 92 96 20 00 orcc %i0, 0, %o1 20076e0: 12 80 00 0a bne 2007708 20076e4: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20076e8: 03 00 80 95 sethi %hi(0x2025400), %g1 20076ec: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 2025700 <_Thread_Dispatch_disable_level> 20076f0: 84 00 a0 01 inc %g2 20076f4: c4 20 63 00 st %g2, [ %g1 + 0x300 ] 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; 20076f8: 03 00 80 95 sethi %hi(0x2025400), %g1 20076fc: d0 00 63 e0 ld [ %g1 + 0x3e0 ], %o0 ! 20257e0 <_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; 2007700: 10 80 00 19 b 2007764 2007704: c0 27 bf f4 clr [ %fp + -12 ] 2007708: 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 ) { 200770c: 80 a0 a0 04 cmp %g2, 4 2007710: 18 80 00 06 bgu 2007728 2007714: 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 :) */ 2007718: 83 32 60 1b srl %o1, 0x1b, %g1 200771c: 80 a0 60 01 cmp %g1, 1 2007720: 02 80 00 05 be 2007734 2007724: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007728: 90 10 20 00 clr %o0 200772c: 10 80 00 0e b 2007764 2007730: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007734: 83 28 a0 02 sll %g2, 2, %g1 2007738: 05 00 80 95 sethi %hi(0x2025400), %g2 200773c: 84 10 a2 60 or %g2, 0x260, %g2 ! 2025660 <_Objects_Information_table> 2007740: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2007744: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2007748: 80 a2 20 00 cmp %o0, 0 200774c: 12 80 00 04 bne 200775c 2007750: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007754: 10 80 00 04 b 2007764 <== NOT EXECUTED 2007758: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200775c: 40 00 06 f9 call 2009340 <_Objects_Get> 2007760: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007764: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007768: 80 a0 60 00 cmp %g1, 0 200776c: 22 80 00 07 be,a 2007788 2007770: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2007774: 80 a0 60 02 cmp %g1, 2 2007778: 08 80 00 0b bleu 20077a4 200777c: b0 10 20 04 mov 4, %i0 2007780: 81 c7 e0 08 ret <== NOT EXECUTED 2007784: 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 ) ) { 2007788: 80 88 60 02 btst 2, %g1 200778c: 02 80 00 08 be 20077ac 2007790: 92 10 20 01 mov 1, %o1 _Thread_Resume( the_thread, TRUE ); 2007794: 40 00 0e c2 call 200b29c <_Thread_Resume> 2007798: b0 10 20 00 clr %i0 _Thread_Enable_dispatch(); 200779c: 7f ff ff c2 call 20076a4 <_Thread_Enable_dispatch> 20077a0: 01 00 00 00 nop 20077a4: 81 c7 e0 08 ret 20077a8: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 20077ac: 7f ff ff be call 20076a4 <_Thread_Enable_dispatch> 20077b0: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20077b4: 81 c7 e0 08 ret 20077b8: 81 e8 00 00 restore 02007b24 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 2007b24: 9d e3 bf 90 save %sp, -112, %sp 2007b28: 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 ) 2007b2c: 80 a6 60 0f cmp %i1, 0xf 2007b30: 18 80 00 3e bgu 2007c28 2007b34: 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 ) || 2007b38: 80 a2 60 00 cmp %o1, 0 2007b3c: 02 80 00 08 be 2007b5c 2007b40: 03 00 80 79 sethi %hi(0x201e400), %g1 2007b44: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 201e580 <_Thread_Executing> 2007b48: c2 00 60 08 ld [ %g1 + 8 ], %g1 2007b4c: 80 a2 40 01 cmp %o1, %g1 2007b50: 12 80 00 09 bne 2007b74 2007b54: 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; 2007b58: 03 00 80 79 sethi %hi(0x201e400), %g1 <== NOT EXECUTED 2007b5c: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 201e580 <_Thread_Executing> <== NOT EXECUTED 2007b60: 85 2e 60 02 sll %i1, 2, %g2 <== NOT EXECUTED 2007b64: c2 00 61 70 ld [ %g1 + 0x170 ], %g1 <== NOT EXECUTED 2007b68: f4 20 40 02 st %i2, [ %g1 + %g2 ] <== NOT EXECUTED 2007b6c: 81 c7 e0 08 ret <== NOT EXECUTED 2007b70: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 2007b74: 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 ) { 2007b78: 80 a0 a0 04 cmp %g2, 4 2007b7c: 18 80 00 06 bgu 2007b94 2007b80: 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 :) */ 2007b84: 83 32 60 1b srl %o1, 0x1b, %g1 2007b88: 80 a0 60 01 cmp %g1, 1 2007b8c: 02 80 00 05 be 2007ba0 2007b90: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007b94: 90 10 20 00 clr %o0 2007b98: 10 80 00 0e b 2007bd0 2007b9c: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007ba0: 83 28 a0 02 sll %g2, 2, %g1 2007ba4: 05 00 80 79 sethi %hi(0x201e400), %g2 2007ba8: 84 10 a0 00 mov %g2, %g2 ! 201e400 <_Objects_Information_table> 2007bac: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2007bb0: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2007bb4: 80 a2 20 00 cmp %o0, 0 2007bb8: 12 80 00 04 bne 2007bc8 2007bbc: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007bc0: 10 80 00 04 b 2007bd0 <== NOT EXECUTED 2007bc4: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007bc8: 40 00 06 9b call 2009634 <_Objects_Get> 2007bcc: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007bd0: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007bd4: 80 a0 60 00 cmp %g1, 0 2007bd8: 22 80 00 07 be,a 2007bf4 2007bdc: c4 02 21 70 ld [ %o0 + 0x170 ], %g2 2007be0: 80 a0 60 02 cmp %g1, 2 2007be4: 08 80 00 11 bleu 2007c28 2007be8: b0 10 20 04 mov 4, %i0 2007bec: 81 c7 e0 08 ret <== NOT EXECUTED 2007bf0: 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; 2007bf4: 83 2e 60 02 sll %i1, 2, %g1 2007bf8: 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 ) 2007bfc: 05 00 80 79 sethi %hi(0x201e400), %g2 2007c00: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 ! 201e4a0 <_Thread_Dispatch_disable_level> 2007c04: b0 10 20 00 clr %i0 2007c08: 82 00 7f ff add %g1, -1, %g1 2007c0c: c2 20 a0 a0 st %g1, [ %g2 + 0xa0 ] 2007c10: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 2007c14: 80 a0 60 00 cmp %g1, 0 2007c18: 12 80 00 04 bne 2007c28 2007c1c: 01 00 00 00 nop _Thread_Dispatch(); 2007c20: 40 00 0b 4b call 200a94c <_Thread_Dispatch> 2007c24: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007c28: 81 c7 e0 08 ret 2007c2c: 81 e8 00 00 restore 0200a684 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 200a684: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 200a688: 80 a6 60 00 cmp %i1, 0 200a68c: 02 80 00 06 be 200a6a4 200a690: 92 10 00 18 mov %i0, %o1 200a694: 82 06 7f ff add %i1, -1, %g1 200a698: 80 a0 60 fe cmp %g1, 0xfe 200a69c: 18 80 00 49 bgu 200a7c0 200a6a0: b0 10 20 13 mov 0x13, %i0 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 200a6a4: 80 a6 a0 00 cmp %i2, 0 200a6a8: 02 80 00 46 be 200a7c0 200a6ac: 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 ) ) { 200a6b0: 80 a2 60 00 cmp %o1, 0 200a6b4: 12 80 00 0a bne 200a6dc 200a6b8: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200a6bc: 03 00 80 9e sethi %hi(0x2027800), %g1 200a6c0: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 2027a50 <_Thread_Dispatch_disable_level> 200a6c4: 84 00 a0 01 inc %g2 200a6c8: c4 20 62 50 st %g2, [ %g1 + 0x250 ] 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; 200a6cc: 03 00 80 9e sethi %hi(0x2027800), %g1 200a6d0: d0 00 63 30 ld [ %g1 + 0x330 ], %o0 ! 2027b30 <_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; 200a6d4: 10 80 00 19 b 200a738 200a6d8: c0 27 bf f4 clr [ %fp + -12 ] 200a6dc: 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 ) { 200a6e0: 80 a0 a0 04 cmp %g2, 4 200a6e4: 18 80 00 06 bgu 200a6fc 200a6e8: 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 :) */ 200a6ec: 83 32 60 1b srl %o1, 0x1b, %g1 200a6f0: 80 a0 60 01 cmp %g1, 1 200a6f4: 02 80 00 05 be 200a708 200a6f8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 200a6fc: 90 10 20 00 clr %o0 200a700: 10 80 00 0e b 200a738 200a704: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 200a708: 83 28 a0 02 sll %g2, 2, %g1 200a70c: 05 00 80 9e sethi %hi(0x2027800), %g2 200a710: 84 10 a1 b0 or %g2, 0x1b0, %g2 ! 20279b0 <_Objects_Information_table> 200a714: c2 00 80 01 ld [ %g2 + %g1 ], %g1 200a718: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 200a71c: 80 a2 20 00 cmp %o0, 0 200a720: 12 80 00 04 bne 200a730 200a724: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 200a728: 10 80 00 04 b 200a738 <== NOT EXECUTED 200a72c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200a730: 40 00 06 3d call 200c024 <_Objects_Get> 200a734: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 200a738: c2 07 bf f4 ld [ %fp + -12 ], %g1 200a73c: 80 a0 60 00 cmp %g1, 0 200a740: 22 80 00 07 be,a 200a75c 200a744: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200a748: 80 a0 60 02 cmp %g1, 2 200a74c: 08 80 00 1d bleu 200a7c0 200a750: b0 10 20 04 mov 4, %i0 200a754: 81 c7 e0 08 ret <== NOT EXECUTED 200a758: 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 ) { 200a75c: 80 a6 60 00 cmp %i1, 0 200a760: 02 80 00 0d be 200a794 200a764: c2 26 80 00 st %g1, [ %i2 ] the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200a768: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 200a76c: 80 a0 60 00 cmp %g1, 0 200a770: 02 80 00 06 be 200a788 200a774: f2 22 20 18 st %i1, [ %o0 + 0x18 ] 200a778: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200a77c: 80 a0 40 19 cmp %g1, %i1 200a780: 08 80 00 05 bleu 200a794 200a784: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 200a788: 92 10 00 19 mov %i1, %o1 200a78c: 40 00 09 ee call 200cf44 <_Thread_Change_priority> 200a790: 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 ) 200a794: 03 00 80 9e sethi %hi(0x2027800), %g1 200a798: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 2027a50 <_Thread_Dispatch_disable_level> 200a79c: b0 10 20 00 clr %i0 200a7a0: 84 00 bf ff add %g2, -1, %g2 200a7a4: c4 20 62 50 st %g2, [ %g1 + 0x250 ] 200a7a8: c2 00 62 50 ld [ %g1 + 0x250 ], %g1 200a7ac: 80 a0 60 00 cmp %g1, 0 200a7b0: 12 80 00 04 bne 200a7c0 200a7b4: 01 00 00 00 nop _Thread_Dispatch(); 200a7b8: 40 00 0b 20 call 200d438 <_Thread_Dispatch> 200a7bc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200a7c0: 81 c7 e0 08 ret 200a7c4: 81 e8 00 00 restore 0200616c : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 200616c: 9d e3 bf 90 save %sp, -112, %sp 2006170: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 2006174: 80 a6 60 00 cmp %i1, 0 2006178: 02 80 00 36 be 2006250 200617c: 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 ) ) { 2006180: 80 a2 60 00 cmp %o1, 0 2006184: 12 80 00 0a bne 20061ac 2006188: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200618c: 03 00 80 62 sethi %hi(0x2018800), %g1 2006190: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> 2006194: 84 00 a0 01 inc %g2 2006198: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] 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; 200619c: 03 00 80 62 sethi %hi(0x2018800), %g1 20061a0: d0 00 63 d0 ld [ %g1 + 0x3d0 ], %o0 ! 2018bd0 <_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; 20061a4: 10 80 00 19 b 2006208 20061a8: c0 27 bf f4 clr [ %fp + -12 ] 20061ac: 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 ) { 20061b0: 80 a0 a0 04 cmp %g2, 4 20061b4: 18 80 00 06 bgu 20061cc 20061b8: 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 :) */ 20061bc: 83 32 60 1b srl %o1, 0x1b, %g1 20061c0: 80 a0 60 01 cmp %g1, 1 20061c4: 02 80 00 05 be 20061d8 20061c8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20061cc: 90 10 20 00 clr %o0 20061d0: 10 80 00 0e b 2006208 20061d4: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20061d8: 83 28 a0 02 sll %g2, 2, %g1 20061dc: 05 00 80 62 sethi %hi(0x2018800), %g2 20061e0: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 20061e4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20061e8: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20061ec: 80 a2 20 00 cmp %o0, 0 20061f0: 12 80 00 04 bne 2006200 20061f4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20061f8: 10 80 00 04 b 2006208 <== NOT EXECUTED 20061fc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2006200: 40 00 05 72 call 20077c8 <_Objects_Get> 2006204: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006208: c2 07 bf f4 ld [ %fp + -12 ], %g1 200620c: 80 a0 60 00 cmp %g1, 0 2006210: 22 80 00 07 be,a 200622c 2006214: 94 10 00 19 mov %i1, %o2 2006218: 80 a0 60 02 cmp %g1, 2 200621c: 08 80 00 0d bleu 2006250 2006220: b0 10 20 04 mov 4, %i0 2006224: 81 c7 e0 08 ret <== NOT EXECUTED 2006228: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Start( 200622c: 98 10 00 1a mov %i2, %o4 2006230: 92 10 20 00 clr %o1 2006234: 40 00 0e 44 call 2009b44 <_Thread_Start> 2006238: 96 10 20 00 clr %o3 200623c: 80 a2 20 00 cmp %o0, 0 2006240: 02 80 00 06 be 2006258 2006244: 01 00 00 00 nop the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 2006248: 7f ff ff bc call 2006138 <_Thread_Enable_dispatch> 200624c: b0 10 20 00 clr %i0 ! 0 2006250: 81 c7 e0 08 ret 2006254: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2006258: 7f ff ff b8 call 2006138 <_Thread_Enable_dispatch> 200625c: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006260: 81 c7 e0 08 ret 2006264: 81 e8 00 00 restore 02007920 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 2007920: 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 ) ) { 2007924: 92 96 20 00 orcc %i0, 0, %o1 2007928: 12 80 00 0a bne 2007950 200792c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007930: 03 00 80 95 sethi %hi(0x2025400), %g1 2007934: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 2025700 <_Thread_Dispatch_disable_level> 2007938: 84 00 a0 01 inc %g2 200793c: c4 20 63 00 st %g2, [ %g1 + 0x300 ] 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; 2007940: 03 00 80 95 sethi %hi(0x2025400), %g1 2007944: d0 00 63 e0 ld [ %g1 + 0x3e0 ], %o0 ! 20257e0 <_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; 2007948: 10 80 00 19 b 20079ac 200794c: c0 27 bf f4 clr [ %fp + -12 ] 2007950: 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 ) { 2007954: 80 a0 a0 04 cmp %g2, 4 2007958: 18 80 00 06 bgu 2007970 200795c: 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 :) */ 2007960: 83 32 60 1b srl %o1, 0x1b, %g1 2007964: 80 a0 60 01 cmp %g1, 1 2007968: 02 80 00 05 be 200797c 200796c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007970: 90 10 20 00 clr %o0 2007974: 10 80 00 0e b 20079ac 2007978: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 200797c: 83 28 a0 02 sll %g2, 2, %g1 2007980: 05 00 80 95 sethi %hi(0x2025400), %g2 2007984: 84 10 a2 60 or %g2, 0x260, %g2 ! 2025660 <_Objects_Information_table> 2007988: c2 00 80 01 ld [ %g2 + %g1 ], %g1 200798c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2007990: 80 a2 20 00 cmp %o0, 0 2007994: 12 80 00 04 bne 20079a4 2007998: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 200799c: 10 80 00 04 b 20079ac <== NOT EXECUTED 20079a0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20079a4: 40 00 06 67 call 2009340 <_Objects_Get> 20079a8: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20079ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 20079b0: 80 a0 60 00 cmp %g1, 0 20079b4: 22 80 00 07 be,a 20079d0 20079b8: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 20079bc: 80 a0 60 02 cmp %g1, 2 20079c0: 08 80 00 0b bleu 20079ec 20079c4: b0 10 20 04 mov 4, %i0 20079c8: 81 c7 e0 08 ret <== NOT EXECUTED 20079cc: 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 ) ) { 20079d0: 80 88 60 02 btst 2, %g1 20079d4: 12 80 00 08 bne 20079f4 20079d8: 01 00 00 00 nop _Thread_Suspend( the_thread ); 20079dc: 40 00 0f 61 call 200b760 <_Thread_Suspend> 20079e0: b0 10 20 00 clr %i0 ! 0 _Thread_Enable_dispatch(); 20079e4: 7f ff ff c2 call 20078ec <_Thread_Enable_dispatch> 20079e8: 01 00 00 00 nop 20079ec: 81 c7 e0 08 ret 20079f0: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 20079f4: 7f ff ff be call 20078ec <_Thread_Enable_dispatch> 20079f8: b0 10 20 0f mov 0xf, %i0 return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20079fc: 81 c7 e0 08 ret 2007a00: 81 e8 00 00 restore 02017aa0 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 2017aa0: 9d e3 bf 90 save %sp, -112, %sp 2017aa4: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 2017aa8: 80 a6 60 00 cmp %i1, 0 2017aac: 02 80 00 32 be 2017b74 2017ab0: 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 ) ) { 2017ab4: 80 a2 60 00 cmp %o1, 0 2017ab8: 12 80 00 0a bne 2017ae0 2017abc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2017ac0: 03 00 80 e6 sethi %hi(0x2039800), %g1 2017ac4: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 2039b10 <_Thread_Dispatch_disable_level> 2017ac8: 84 00 a0 01 inc %g2 2017acc: c4 20 63 10 st %g2, [ %g1 + 0x310 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 2017ad0: 03 00 80 e6 sethi %hi(0x2039800), %g1 2017ad4: f0 00 63 f0 ld [ %g1 + 0x3f0 ], %i0 ! 2039bf0 <_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; 2017ad8: 10 80 00 18 b 2017b38 2017adc: c0 27 bf f4 clr [ %fp + -12 ] 2017ae0: 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 ) { 2017ae4: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2017ae8: 18 80 00 0e bgu 2017b20 <== NOT EXECUTED 2017aec: 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 :) */ 2017af0: 83 32 60 1b srl %o1, 0x1b, %g1 <== NOT EXECUTED 2017af4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2017af8: 12 80 00 0a bne 2017b20 <== NOT EXECUTED 2017afc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2017b00: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 2017b04: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 2017b08: 84 10 a2 70 or %g2, 0x270, %g2 ! 2039a70 <_Objects_Information_table> <== NOT EXECUTED 2017b0c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 2017b10: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 2017b14: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017b18: 12 80 00 05 bne 2017b2c <== NOT EXECUTED 2017b1c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 2017b20: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017b24: 10 80 00 05 b 2017b38 <== NOT EXECUTED 2017b28: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2017b2c: 7f ff c8 b8 call 2009e0c <_Objects_Get> <== NOT EXECUTED 2017b30: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 2017b34: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 2017b38: c2 07 bf f4 ld [ %fp + -12 ], %g1 2017b3c: 80 a0 60 00 cmp %g1, 0 2017b40: 22 80 00 0f be,a 2017b7c 2017b44: c4 06 21 80 ld [ %i0 + 0x180 ], %g2 2017b48: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2017b4c: 08 80 00 0a bleu 2017b74 <== NOT EXECUTED 2017b50: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2017b54: 81 c7 e0 08 ret <== NOT EXECUTED 2017b58: 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) { 2017b5c: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 2017b60: 32 80 00 07 bne,a 2017b7c <== NOT EXECUTED 2017b64: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED tvp->dtor = dtor; 2017b68: f4 20 a0 10 st %i2, [ %g2 + 0x10 ] <== NOT EXECUTED _Thread_Enable_dispatch(); 2017b6c: 7f ff ff c0 call 2017a6c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017b70: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017b74: 81 c7 e0 08 ret <== NOT EXECUTED 2017b78: 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) { 2017b7c: 80 a0 a0 00 cmp %g2, 0 2017b80: 32 bf ff f7 bne,a 2017b5c 2017b84: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 2017b88: 11 00 80 e6 sethi %hi(0x2039800), %o0 2017b8c: 92 10 20 14 mov 0x14, %o1 2017b90: 7f ff c6 03 call 200939c <_Heap_Allocate> 2017b94: 90 12 23 5c or %o0, 0x35c, %o0 * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 2017b98: 80 a2 20 00 cmp %o0, 0 2017b9c: 32 80 00 06 bne,a 2017bb4 2017ba0: c4 06 21 80 ld [ %i0 + 0x180 ], %g2 _Thread_Enable_dispatch(); 2017ba4: 7f ff ff b2 call 2017a6c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017ba8: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED 2017bac: 81 c7 e0 08 ret <== NOT EXECUTED 2017bb0: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_NO_MEMORY; } new->gval = *ptr; 2017bb4: 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; 2017bb8: d0 26 21 80 st %o0, [ %i0 + 0x180 ] _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 2017bbc: c2 22 20 08 st %g1, [ %o0 + 8 ] new->ptr = ptr; 2017bc0: f2 22 20 04 st %i1, [ %o0 + 4 ] new->dtor = dtor; 2017bc4: f4 22 20 10 st %i2, [ %o0 + 0x10 ] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 2017bc8: c4 22 00 00 st %g2, [ %o0 ] the_thread->task_variables = new; _Thread_Enable_dispatch(); 2017bcc: 7f ff ff a8 call 2017a6c <_Thread_Enable_dispatch> 2017bd0: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2017bd4: 81 c7 e0 08 ret 2017bd8: 81 e8 00 00 restore 02017c10 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 2017c10: 9d e3 bf 90 save %sp, -112, %sp 2017c14: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 2017c18: 80 a6 60 00 cmp %i1, 0 2017c1c: 02 80 00 52 be 2017d64 2017c20: 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 ) ) { 2017c24: 80 a2 60 00 cmp %o1, 0 2017c28: 12 80 00 0a bne 2017c50 2017c2c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2017c30: 03 00 80 e6 sethi %hi(0x2039800), %g1 2017c34: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 2039b10 <_Thread_Dispatch_disable_level> 2017c38: 84 00 a0 01 inc %g2 2017c3c: c4 20 63 10 st %g2, [ %g1 + 0x310 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 2017c40: 03 00 80 e6 sethi %hi(0x2039800), %g1 2017c44: d0 00 63 f0 ld [ %g1 + 0x3f0 ], %o0 ! 2039bf0 <_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; 2017c48: 10 80 00 19 b 2017cac 2017c4c: c0 27 bf f4 clr [ %fp + -12 ] 2017c50: 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 ) { 2017c54: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2017c58: 18 80 00 06 bgu 2017c70 <== NOT EXECUTED 2017c5c: 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 :) */ 2017c60: 83 32 60 1b srl %o1, 0x1b, %g1 <== NOT EXECUTED 2017c64: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2017c68: 02 80 00 05 be 2017c7c <== NOT EXECUTED 2017c6c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 2017c70: 90 10 20 00 clr %o0 <== NOT EXECUTED 2017c74: 10 80 00 0e b 2017cac <== NOT EXECUTED 2017c78: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2017c7c: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 2017c80: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 2017c84: 84 10 a2 70 or %g2, 0x270, %g2 ! 2039a70 <_Objects_Information_table> <== NOT EXECUTED 2017c88: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 2017c8c: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 2017c90: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017c94: 12 80 00 04 bne 2017ca4 <== NOT EXECUTED 2017c98: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 2017c9c: 10 80 00 04 b 2017cac <== NOT EXECUTED 2017ca0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2017ca4: 7f ff c8 5a call 2009e0c <_Objects_Get> <== NOT EXECUTED 2017ca8: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 2017cac: c2 07 bf f4 ld [ %fp + -12 ], %g1 2017cb0: 80 a0 60 00 cmp %g1, 0 2017cb4: 22 80 00 07 be,a 2017cd0 2017cb8: f0 02 21 80 ld [ %o0 + 0x180 ], %i0 2017cbc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2017cc0: 08 80 00 29 bleu 2017d64 <== NOT EXECUTED 2017cc4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2017cc8: 81 c7 e0 08 ret <== NOT EXECUTED 2017ccc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; 2017cd0: 10 80 00 28 b 2017d70 2017cd4: 84 10 20 00 clr %g2 while (tvp) { if (tvp->ptr == ptr) { 2017cd8: 80 a0 40 19 cmp %g1, %i1 2017cdc: 32 80 00 24 bne,a 2017d6c 2017ce0: 84 10 00 18 mov %i0, %g2 <== NOT EXECUTED if (prev) 2017ce4: 80 a0 a0 00 cmp %g2, 0 2017ce8: 02 80 00 04 be 2017cf8 2017cec: c2 06 00 00 ld [ %i0 ], %g1 prev->next = tvp->next; 2017cf0: 10 80 00 03 b 2017cfc <== NOT EXECUTED 2017cf4: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 2017cf8: c2 22 21 80 st %g1, [ %o0 + 0x180 ] if (_Thread_Is_executing(the_thread)) { 2017cfc: 03 00 80 e6 sethi %hi(0x2039800), %g1 2017d00: c2 00 63 f0 ld [ %g1 + 0x3f0 ], %g1 ! 2039bf0 <_Thread_Executing> 2017d04: 80 a2 00 01 cmp %o0, %g1 2017d08: 12 80 00 0c bne 2017d38 2017d0c: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 if (tvp->dtor) 2017d10: 80 a0 a0 00 cmp %g2, 0 2017d14: 22 80 00 06 be,a 2017d2c 2017d18: c4 06 20 04 ld [ %i0 + 4 ], %g2 (*tvp->dtor)(*tvp->ptr); 2017d1c: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 2017d20: 9f c0 80 00 call %g2 <== NOT EXECUTED 2017d24: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 2017d28: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED 2017d2c: c2 06 20 08 ld [ %i0 + 8 ], %g1 2017d30: 10 80 00 07 b 2017d4c 2017d34: c2 20 80 00 st %g1, [ %g2 ] } else { if (tvp->dtor) 2017d38: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2017d3c: 02 80 00 05 be 2017d50 <== NOT EXECUTED 2017d40: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 2017d44: 9f c0 80 00 call %g2 <== NOT EXECUTED 2017d48: d0 06 20 0c ld [ %i0 + 0xc ], %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2017d4c: 92 10 00 18 mov %i0, %o1 2017d50: 11 00 80 e6 sethi %hi(0x2039800), %o0 2017d54: 7f ff c5 b9 call 2009438 <_Heap_Free> 2017d58: 90 12 23 5c or %o0, 0x35c, %o0 ! 2039b5c <_Workspace_Area> } _Workspace_Free(tvp); _Thread_Enable_dispatch(); 2017d5c: 7f ff ff a0 call 2017bdc <_Thread_Enable_dispatch> 2017d60: b0 10 20 00 clr %i0 2017d64: 81 c7 e0 08 ret 2017d68: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 2017d6c: f0 06 00 00 ld [ %i0 ], %i0 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 2017d70: 80 a6 20 00 cmp %i0, 0 2017d74: 32 bf ff d9 bne,a 2017cd8 2017d78: c2 06 20 04 ld [ %i0 + 4 ], %g1 return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 2017d7c: 7f ff ff 98 call 2017bdc <_Thread_Enable_dispatch> <== NOT EXECUTED 2017d80: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2017d84: 81 c7 e0 08 ret <== NOT EXECUTED 2017d88: 81 e8 00 00 restore <== NOT EXECUTED 02017dc0 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 2017dc0: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 2017dc4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2017dc8: 02 80 00 3f be 2017ec4 <== NOT EXECUTED 2017dcc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 2017dd0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 2017dd4: 02 80 00 3c be 2017ec4 <== NOT EXECUTED 2017dd8: 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 ) ) { 2017ddc: 12 80 00 0a bne 2017e04 <== NOT EXECUTED 2017de0: 83 36 20 18 srl %i0, 0x18, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2017de4: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 2017de8: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 2039b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2017dec: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2017df0: c4 20 63 10 st %g2, [ %g1 + 0x310 ] <== 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; 2017df4: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 2017df8: d0 00 63 f0 ld [ %g1 + 0x3f0 ], %o0 ! 2039bf0 <_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; 2017dfc: 10 80 00 19 b 2017e60 <== NOT EXECUTED 2017e00: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 2017e04: 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 ) { 2017e08: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2017e0c: 18 80 00 06 bgu 2017e24 <== NOT EXECUTED 2017e10: 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 :) */ 2017e14: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED 2017e18: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2017e1c: 02 80 00 05 be 2017e30 <== NOT EXECUTED 2017e20: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 2017e24: 90 10 20 00 clr %o0 <== NOT EXECUTED 2017e28: 10 80 00 0e b 2017e60 <== NOT EXECUTED 2017e2c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2017e30: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 2017e34: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 2017e38: 84 10 a2 70 or %g2, 0x270, %g2 ! 2039a70 <_Objects_Information_table> <== NOT EXECUTED 2017e3c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 2017e40: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 2017e44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017e48: 12 80 00 04 bne 2017e58 <== NOT EXECUTED 2017e4c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 2017e50: 10 80 00 04 b 2017e60 <== NOT EXECUTED 2017e54: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2017e58: 7f ff c7 ed call 2009e0c <_Objects_Get> <== NOT EXECUTED 2017e5c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 2017e60: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2017e64: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2017e68: 22 80 00 10 be,a 2017ea8 <== NOT EXECUTED 2017e6c: d0 02 21 80 ld [ %o0 + 0x180 ], %o0 <== NOT EXECUTED 2017e70: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2017e74: 08 80 00 0b bleu 2017ea0 <== NOT EXECUTED 2017e78: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2017e7c: 81 c7 e0 08 ret <== NOT EXECUTED 2017e80: 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) { 2017e84: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 2017e88: 32 80 00 08 bne,a 2017ea8 <== NOT EXECUTED 2017e8c: 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; 2017e90: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); 2017e94: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017e98: 7f ff ff bd call 2017d8c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017e9c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 2017ea0: 81 c7 e0 08 ret <== NOT EXECUTED 2017ea4: 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) { 2017ea8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017eac: 32 bf ff f6 bne,a 2017e84 <== NOT EXECUTED 2017eb0: 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(); 2017eb4: 7f ff ff b6 call 2017d8c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017eb8: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED 2017ebc: 81 c7 e0 08 ret <== NOT EXECUTED 2017ec0: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 2017ec4: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2017ec8: 81 c7 e0 08 ret <== NOT EXECUTED 2017ecc: 81 e8 00 00 restore <== NOT EXECUTED 02012254 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 2012254: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2012258: 21 00 80 cc sethi %hi(0x2033000), %l0 201225c: 92 10 00 18 mov %i0, %o1 2012260: 94 07 bf f4 add %fp, -12, %o2 2012264: 40 00 0a 13 call 2014ab0 <_Objects_Get> 2012268: 90 14 20 2c or %l0, 0x2c, %o0 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 201226c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012270: 80 a0 60 00 cmp %g1, 0 2012274: 02 80 00 08 be 2012294 2012278: b0 10 00 08 mov %o0, %i0 201227c: 82 18 60 02 xor %g1, 2, %g1 2012280: 80 a0 00 01 cmp %g0, %g1 2012284: 82 60 20 00 subx %g0, 0, %g1 2012288: b0 08 60 15 and %g1, 0x15, %i0 201228c: 81 c7 e0 08 ret 2012290: 91 ee 20 04 restore %i0, 4, %o0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012294: a0 14 20 2c or %l0, 0x2c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2012298: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 201229c: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 20122a0: 05 00 00 3f sethi %hi(0xfc00), %g2 20122a4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 20122a8: 82 08 40 02 and %g1, %g2, %g1 20122ac: 80 a0 40 03 cmp %g1, %g3 20122b0: 38 80 00 06 bgu,a 20122c8 20122b4: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 20122b8: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 20122bc: 83 28 60 02 sll %g1, 2, %g1 20122c0: 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; 20122c4: 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 ); 20122c8: 40 00 15 8d call 20178fc <_Watchdog_Remove> 20122cc: 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 ); 20122d0: 90 10 00 10 mov %l0, %o0 20122d4: 40 00 09 a1 call 2014958 <_Objects_Free> 20122d8: 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 ) 20122dc: 03 00 80 c9 sethi %hi(0x2032400), %g1 20122e0: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20325f0 <_Thread_Dispatch_disable_level> 20122e4: b0 10 20 00 clr %i0 20122e8: 84 00 bf ff add %g2, -1, %g2 20122ec: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 20122f0: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 20122f4: 80 a0 60 00 cmp %g1, 0 20122f8: 12 80 00 04 bne 2012308 20122fc: 01 00 00 00 nop _Thread_Dispatch(); 2012300: 40 00 0e f1 call 2015ec4 <_Thread_Dispatch> 2012304: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012308: 81 c7 e0 08 ret 201230c: 81 e8 00 00 restore 02012344 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 2012344: 9d e3 bf 90 save %sp, -112, %sp 2012348: a4 10 00 18 mov %i0, %l2 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 201234c: 80 a6 60 00 cmp %i1, 0 2012350: 02 80 00 21 be 20123d4 2012354: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( !routine ) 2012358: 80 a6 a0 00 cmp %i2, 0 201235c: 02 80 00 1e be 20123d4 2012360: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2012364: 11 00 80 cc sethi %hi(0x2033000), %o0 2012368: 92 10 00 12 mov %l2, %o1 201236c: 90 12 20 2c or %o0, 0x2c, %o0 2012370: 40 00 09 d0 call 2014ab0 <_Objects_Get> 2012374: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012378: c2 07 bf f4 ld [ %fp + -12 ], %g1 201237c: 80 a0 60 00 cmp %g1, 0 2012380: 02 80 00 08 be 20123a0 2012384: a0 10 00 08 mov %o0, %l0 2012388: 82 18 60 02 xor %g1, 2, %g1 201238c: 80 a0 00 01 cmp %g0, %g1 2012390: 82 60 20 00 subx %g0, 0, %g1 2012394: b0 08 60 15 and %g1, 0x15, %i0 2012398: 81 c7 e0 08 ret 201239c: 91 ee 20 04 restore %i0, 4, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 20123a0: a2 02 20 10 add %o0, 0x10, %l1 20123a4: 40 00 15 56 call 20178fc <_Watchdog_Remove> 20123a8: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 20123ac: 7f ff e0 e5 call 200a740 20123b0: 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 ) { 20123b4: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 20123b8: 80 a0 60 00 cmp %g1, 0 20123bc: 22 80 00 08 be,a 20123dc 20123c0: f4 24 20 2c st %i2, [ %l0 + 0x2c ] _ISR_Enable( level ); 20123c4: 7f ff e0 e3 call 200a750 <== NOT EXECUTED 20123c8: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 20123cc: 7f ff ff d1 call 2012310 <_Thread_Enable_dispatch> <== NOT EXECUTED 20123d0: 01 00 00 00 nop <== NOT EXECUTED 20123d4: 81 c7 e0 08 ret 20123d8: 81 e8 00 00 restore 20123dc: e4 24 20 30 st %l2, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 20123e0: 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; 20123e4: c0 24 20 38 clr [ %l0 + 0x38 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20123e8: c0 24 20 18 clr [ %l0 + 0x18 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 20123ec: 7f ff e0 d9 call 200a750 20123f0: b0 10 20 00 clr %i0 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20123f4: 92 10 00 11 mov %l1, %o1 20123f8: 11 00 80 c9 sethi %hi(0x2032400), %o0 20123fc: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 20326f0 <_Watchdog_Ticks_chain> 2012400: 40 00 14 e7 call 201779c <_Watchdog_Insert> 2012404: f2 24 20 1c st %i1, [ %l0 + 0x1c ] _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 2012408: 7f ff ff c2 call 2012310 <_Thread_Enable_dispatch> 201240c: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012410: 81 c7 e0 08 ret 2012414: 81 e8 00 00 restore 020080ac : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 20080ac: 9d e3 bf 90 save %sp, -112, %sp 20080b0: 92 10 00 18 mov %i0, %o1 Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 20080b4: 80 a6 60 00 cmp %i1, 0 20080b8: 02 80 00 22 be 2008140 20080bc: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 20080c0: 11 00 80 7a sethi %hi(0x201e800), %o0 20080c4: 94 07 bf f4 add %fp, -12, %o2 20080c8: 40 00 07 66 call 2009e60 <_Objects_Get> 20080cc: 90 12 21 10 or %o0, 0x110, %o0 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20080d0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20080d4: 80 a0 60 00 cmp %g1, 0 20080d8: 22 80 00 08 be,a 20080f8 20080dc: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 20080e0: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 20080e4: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 20080e8: 82 60 20 00 subx %g0, 0, %g1 <== NOT EXECUTED 20080ec: b0 08 60 15 and %g1, 0x15, %i0 <== NOT EXECUTED 20080f0: 81 c7 e0 08 ret <== NOT EXECUTED 20080f4: 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; 20080f8: c4 02 20 38 ld [ %o0 + 0x38 ], %g2 the_info->initial = the_timer->Ticker.initial; 20080fc: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->start_time = the_timer->Ticker.start_time; 2008100: 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; 2008104: c4 26 40 00 st %g2, [ %i1 ] the_info->initial = the_timer->Ticker.initial; the_info->start_time = the_timer->Ticker.start_time; 2008108: c2 26 60 08 st %g1, [ %i1 + 8 ] the_info->stop_time = the_timer->Ticker.stop_time; 200810c: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 2008110: 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 ) 2008114: 05 00 80 7a sethi %hi(0x201e800), %g2 2008118: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 201eaf0 <_Thread_Dispatch_disable_level> 200811c: b0 10 20 00 clr %i0 2008120: 82 00 7f ff add %g1, -1, %g1 2008124: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2008128: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 200812c: 80 a0 60 00 cmp %g1, 0 2008130: 12 80 00 04 bne 2008140 2008134: 01 00 00 00 nop _Thread_Dispatch(); 2008138: 40 00 0c 4f call 200b274 <_Thread_Dispatch> 200813c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2008140: 81 c7 e0 08 ret 2008144: 81 e8 00 00 restore 02012b34 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 2012b34: 9d e3 bf 90 save %sp, -112, %sp /* * Make sure the requested priority is valid. */ _priority = priority; if ( priority == RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 2012b38: 92 10 20 00 clr %o1 2012b3c: 80 a6 3f ff cmp %i0, -1 2012b40: 02 80 00 07 be 2012b5c 2012b44: 94 10 00 19 mov %i1, %o2 _priority = 0; else if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) 2012b48: 82 06 3f ff add %i0, -1, %g1 2012b4c: 80 a0 60 fe cmp %g1, 0xfe 2012b50: 18 80 00 48 bgu 2012c70 2012b54: a0 10 20 13 mov 0x13, %l0 2012b58: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2012b5c: 05 00 80 c9 sethi %hi(0x2032400), %g2 2012b60: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 2012b64: 82 00 60 01 inc %g1 2012b68: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] * Just to make sure the test versus create/start operation are atomic. */ _Thread_Disable_dispatch(); if ( _Timer_Server ) { 2012b6c: 03 00 80 cc sethi %hi(0x2033000), %g1 2012b70: c2 00 60 78 ld [ %g1 + 0x78 ], %g1 ! 2033078 <_Timer_Server> 2012b74: 80 a0 60 00 cmp %g1, 0 2012b78: 02 80 00 06 be 2012b90 2012b7c: 19 00 00 20 sethi %hi(0x8000), %o4 _Thread_Enable_dispatch(); 2012b80: 7f ff ff a0 call 2012a00 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012b84: 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; } 2012b88: 81 c7 e0 08 ret <== NOT EXECUTED 2012b8c: 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( 2012b90: 11 15 12 53 sethi %hi(0x54494c00), %o0 2012b94: 98 16 80 0c or %i2, %o4, %o4 2012b98: 90 12 21 45 or %o0, 0x145, %o0 2012b9c: 96 10 21 00 mov 0x100, %o3 2012ba0: 7f ff fa 0f call 20113dc 2012ba4: 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) { 2012ba8: a0 92 20 00 orcc %o0, 0, %l0 2012bac: 12 80 00 2f bne 2012c68 2012bb0: d0 07 bf f4 ld [ %fp + -12 ], %o0 _Thread_Enable_dispatch(); return status; } status = rtems_task_start( 2012bb4: 13 00 80 4a sethi %hi(0x2012800), %o1 2012bb8: 94 10 20 00 clr %o2 2012bbc: 7f ff fc 62 call 2011d44 2012bc0: 92 12 62 34 or %o1, 0x234, %o1 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 2012bc4: a0 92 20 00 orcc %o0, 0, %l0 2012bc8: 12 80 00 28 bne 2012c68 2012bcc: 03 00 80 c9 sethi %hi(0x2032400), %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( 2012bd0: 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 ) 2012bd4: 9a 10 60 a4 or %g1, 0xa4, %o5 2012bd8: c4 13 60 10 lduh [ %o5 + 0x10 ], %g2 2012bdc: 03 00 00 3f sethi %hi(0xfc00), %g1 2012be0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2012be4: 82 09 00 01 and %g4, %g1, %g1 2012be8: 80 a0 40 02 cmp %g1, %g2 2012bec: 18 80 00 05 bgu 2012c00 2012bf0: 86 10 20 00 clr %g3 return NULL; return information->local_table[ index ]; 2012bf4: c4 03 60 20 ld [ %o5 + 0x20 ], %g2 2012bf8: 83 28 60 02 sll %g1, 2, %g1 2012bfc: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2012c00: 03 00 80 cc sethi %hi(0x2033000), %g1 2012c04: c6 20 60 78 st %g3, [ %g1 + 0x78 ] ! 2033078 <_Timer_Server> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2012c08: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012c0c: 82 10 60 f4 or %g1, 0xf4, %g1 ! 20324f4 <_Timer_Ticks_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2012c10: c2 20 7f fc st %g1, [ %g1 + -4 ] 2012c14: 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; 2012c18: c0 20 e0 6c clr [ %g3 + 0x6c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012c1c: c0 20 e0 50 clr [ %g3 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; 2012c20: c8 20 e0 68 st %g4, [ %g3 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2012c24: 05 00 80 57 sethi %hi(0x2015c00), %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2012c28: c2 20 60 08 st %g1, [ %g1 + 8 ] 2012c2c: 84 10 a2 08 or %g2, 0x208, %g2 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2012c30: c0 20 60 04 clr [ %g1 + 4 ] 2012c34: 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; 2012c38: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012c3c: 82 10 61 08 or %g1, 0x108, %g1 ! 2032508 <_Timer_Seconds_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2012c40: c2 20 7f fc st %g1, [ %g1 + -4 ] 2012c44: 82 00 7f fc add %g1, -4, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2012c48: 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; 2012c4c: c0 20 60 04 clr [ %g1 + 4 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012c50: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012c54: 82 10 61 10 or %g1, 0x110, %g1 ! 2032510 <_Timer_Seconds_timer> the_watchdog->routine = routine; 2012c58: c4 20 60 1c st %g2, [ %g1 + 0x1c ] the_watchdog->id = id; 2012c5c: c8 20 60 20 st %g4, [ %g1 + 0x20 ] the_watchdog->user_data = user_data; 2012c60: c0 20 60 24 clr [ %g1 + 0x24 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012c64: 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(); 2012c68: 7f ff ff 66 call 2012a00 <_Thread_Enable_dispatch> 2012c6c: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } 2012c70: b0 10 00 10 mov %l0, %i0 2012c74: 81 c7 e0 08 ret 2012c78: 81 e8 00 00 restore 020126c4 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 20126c4: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 20126c8: 25 00 80 cc sethi %hi(0x2033000), %l2 20126cc: c2 04 a0 78 ld [ %l2 + 0x78 ], %g1 ! 2033078 <_Timer_Server> Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 20126d0: a6 10 00 18 mov %i0, %l3 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 20126d4: 80 a0 60 00 cmp %g1, 0 20126d8: 02 80 00 24 be 2012768 20126dc: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; if ( !routine ) 20126e0: 80 a6 a0 00 cmp %i2, 0 20126e4: 02 80 00 21 be 2012768 20126e8: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 20126ec: 80 a6 60 00 cmp %i1, 0 20126f0: 02 80 00 1e be 2012768 20126f4: b0 10 20 0a mov 0xa, %i0 20126f8: 11 00 80 cc sethi %hi(0x2033000), %o0 20126fc: 92 10 00 13 mov %l3, %o1 2012700: 90 12 20 2c or %o0, 0x2c, %o0 2012704: 40 00 08 eb call 2014ab0 <_Objects_Get> 2012708: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 201270c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012710: 80 a0 60 00 cmp %g1, 0 2012714: 02 80 00 08 be 2012734 2012718: a0 10 00 08 mov %o0, %l0 201271c: 82 18 60 02 xor %g1, 2, %g1 2012720: 80 a0 00 01 cmp %g0, %g1 2012724: 82 60 20 00 subx %g0, 0, %g1 2012728: b0 08 60 15 and %g1, 0x15, %i0 201272c: 81 c7 e0 08 ret 2012730: 91 ee 20 04 restore %i0, 4, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 2012734: a2 02 20 10 add %o0, 0x10, %l1 2012738: 40 00 14 71 call 20178fc <_Watchdog_Remove> 201273c: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 2012740: 7f ff e0 00 call 200a740 2012744: 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 ) { 2012748: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 201274c: 80 a0 60 00 cmp %g1, 0 2012750: 02 80 00 08 be 2012770 2012754: 82 10 20 01 mov 1, %g1 _ISR_Enable( level ); 2012758: 7f ff df fe call 200a750 <== NOT EXECUTED 201275c: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 2012760: 7f ff ff cc call 2012690 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012764: 01 00 00 00 nop <== NOT EXECUTED 2012768: 81 c7 e0 08 ret 201276c: 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; 2012770: f2 24 20 1c st %i1, [ %l0 + 0x1c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2012774: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 2012778: e6 24 20 30 st %l3, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 201277c: f6 24 20 34 st %i3, [ %l0 + 0x34 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012780: 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; 2012784: 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 ); 2012788: 7f ff df f2 call 200a750 201278c: 21 00 80 c9 sethi %hi(0x2032400), %l0 _Timer_Server_stop_ticks_timer(); 2012790: d0 04 a0 78 ld [ %l2 + 0x78 ], %o0 2012794: 40 00 14 5a call 20178fc <_Watchdog_Remove> 2012798: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_process_ticks_chain(); 201279c: 40 00 00 87 call 20129b8 <_Timer_Server_process_ticks_chain> 20127a0: 01 00 00 00 nop _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 20127a4: 90 14 20 f0 or %l0, 0xf0, %o0 20127a8: 40 00 13 fd call 201779c <_Watchdog_Insert> 20127ac: 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)); 20127b0: c4 04 20 f0 ld [ %l0 + 0xf0 ], %g2 20127b4: a0 14 20 f0 or %l0, 0xf0, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 20127b8: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 20127bc: 80 a0 80 10 cmp %g2, %l0 20127c0: 02 80 00 08 be 20127e0 20127c4: c2 04 a0 78 ld [ %l2 + 0x78 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20127c8: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20127cc: 11 00 80 c9 sethi %hi(0x2032400), %o0 20127d0: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20127d4: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20127d8: 40 00 13 f1 call 201779c <_Watchdog_Insert> 20127dc: 90 12 22 f0 or %o0, 0x2f0, %o0 _Thread_Enable_dispatch(); 20127e0: 7f ff ff ac call 2012690 <_Thread_Enable_dispatch> 20127e4: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20127e8: 81 c7 e0 08 ret 20127ec: 81 e8 00 00 restore 02006900 : */ int sched_get_priority_max( int policy ) { 2006900: 9d e3 bf 98 save %sp, -104, %sp switch ( policy ) { 2006904: 80 a6 20 03 cmp %i0, 3 2006908: 08 80 00 06 bleu 2006920 200690c: b0 10 20 fe mov 0xfe, %i0 case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 2006910: 40 00 25 2b call 200fdbc <__errno> <== NOT EXECUTED 2006914: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006918: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 200691c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 2006920: 81 c7 e0 08 ret 2006924: 81 e8 00 00 restore 02006960 : int sched_getparam( pid_t pid, const struct sched_param *param ) { 2006960: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 2006964: 40 00 25 16 call 200fdbc <__errno> <== NOT EXECUTED 2006968: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200696c: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 2006970: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 2006974: 81 c7 e0 08 ret <== NOT EXECUTED 2006978: 81 e8 00 00 restore <== NOT EXECUTED 02006928 : */ int sched_getscheduler( pid_t pid ) { 2006928: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 200692c: 40 00 25 24 call 200fdbc <__errno> <== NOT EXECUTED 2006930: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006934: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 2006938: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 200693c: 81 c7 e0 08 ret <== NOT EXECUTED 2006940: 81 e8 00 00 restore <== NOT EXECUTED 02006998 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 2006998: 9d e3 bf 98 save %sp, -104, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 200699c: 80 a6 20 00 cmp %i0, 0 20069a0: 02 80 00 0b be 20069cc 20069a4: 80 a6 60 00 cmp %i1, 0 20069a8: 7f ff f1 7c call 2002f98 20069ac: 01 00 00 00 nop 20069b0: 80 a6 00 08 cmp %i0, %o0 20069b4: 02 80 00 06 be 20069cc 20069b8: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 20069bc: 40 00 25 00 call 200fdbc <__errno> <== NOT EXECUTED 20069c0: 01 00 00 00 nop <== NOT EXECUTED 20069c4: 10 80 00 07 b 20069e0 <== NOT EXECUTED 20069c8: 82 10 20 03 mov 3, %g1 ! 3 <== NOT EXECUTED if ( !interval ) 20069cc: 12 80 00 08 bne 20069ec 20069d0: 03 00 80 71 sethi %hi(0x201c400), %g1 rtems_set_errno_and_return_minus_one( EINVAL ); 20069d4: 40 00 24 fa call 200fdbc <__errno> <== NOT EXECUTED 20069d8: 01 00 00 00 nop <== NOT EXECUTED 20069dc: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 20069e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20069e4: 81 c7 e0 08 ret <== NOT EXECUTED 20069e8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 20069ec: d0 00 63 58 ld [ %g1 + 0x358 ], %o0 20069f0: 92 10 00 19 mov %i1, %o1 20069f4: 40 00 14 22 call 200ba7c <_Timespec_From_ticks> 20069f8: b0 10 20 00 clr %i0 return 0; } 20069fc: 81 c7 e0 08 ret 2006a00: 81 e8 00 00 restore 0200697c : int sched_setparam( pid_t pid, const struct sched_param *param ) { 200697c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 2006980: 40 00 25 0f call 200fdbc <__errno> <== NOT EXECUTED 2006984: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006988: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 200698c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 2006990: 81 c7 e0 08 ret <== NOT EXECUTED 2006994: 81 e8 00 00 restore <== NOT EXECUTED 02006944 : int sched_setscheduler( pid_t pid, int policy, const struct sched_param *param ) { 2006944: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 2006948: 40 00 25 1d call 200fdbc <__errno> <== NOT EXECUTED 200694c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006950: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 2006954: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 2006958: 81 c7 e0 08 ret <== NOT EXECUTED 200695c: 81 e8 00 00 restore <== NOT EXECUTED 0200681c : */ int sem_close( sem_t *sem ) { 200681c: 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 *) 2006820: d2 06 00 00 ld [ %i0 ], %o1 2006824: 11 00 80 78 sethi %hi(0x201e000), %o0 2006828: 94 07 bf f4 add %fp, -12, %o2 200682c: 40 00 0b b7 call 2009708 <_Objects_Get> 2006830: 90 12 22 d0 or %o0, 0x2d0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 2006834: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006838: 80 a0 60 01 cmp %g1, 1 200683c: 02 80 00 0d be 2006870 2006840: 01 00 00 00 nop 2006844: 2a 80 00 11 bcs,a 2006888 2006848: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 200684c: 80 a0 60 02 cmp %g1, 2 2006850: 12 80 00 1e bne 20068c8 2006854: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 2006858: 40 00 28 b0 call 2010b18 <__errno> 200685c: 01 00 00 00 nop 2006860: 82 10 20 16 mov 0x16, %g1 ! 16 2006864: c2 22 00 00 st %g1, [ %o0 ] 2006868: 10 80 00 1a b 20068d0 200686c: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 2006870: 40 00 10 6c call 200aa20 <_Thread_Dispatch> <== NOT EXECUTED 2006874: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2006878: 40 00 01 78 call 2006e58 <== NOT EXECUTED 200687c: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2006880: 81 c7 e0 08 ret <== NOT EXECUTED 2006884: 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; 2006888: 82 00 7f ff add %g1, -1, %g1 _POSIX_Semaphore_Delete( the_semaphore ); 200688c: 40 00 20 3d call 200e980 <_POSIX_Semaphore_Delete> 2006890: 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 ) 2006894: 05 00 80 77 sethi %hi(0x201dc00), %g2 2006898: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 ! 201df50 <_Thread_Dispatch_disable_level> 200689c: 90 10 20 00 clr %o0 20068a0: 82 00 7f ff add %g1, -1, %g1 20068a4: c2 20 a3 50 st %g1, [ %g2 + 0x350 ] 20068a8: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 20068ac: 80 a0 60 00 cmp %g1, 0 20068b0: 32 80 00 09 bne,a 20068d4 20068b4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 20068b8: 40 00 10 5a call 200aa20 <_Thread_Dispatch> 20068bc: 01 00 00 00 nop 20068c0: 10 80 00 04 b 20068d0 20068c4: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20068c8: 40 00 01 5a call 2006e30 <== NOT EXECUTED 20068cc: 01 00 00 00 nop <== NOT EXECUTED } 20068d0: b0 10 00 08 mov %o0, %i0 20068d4: 81 c7 e0 08 ret 20068d8: 81 e8 00 00 restore 02006910 : */ int sem_destroy( sem_t *sem ) { 2006910: 9d e3 bf 90 save %sp, -112, %sp 2006914: d2 06 00 00 ld [ %i0 ], %o1 2006918: 11 00 80 78 sethi %hi(0x201e000), %o0 200691c: 94 07 bf f4 add %fp, -12, %o2 2006920: 40 00 0b 7a call 2009708 <_Objects_Get> 2006924: 90 12 22 d0 or %o0, 0x2d0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 2006928: c2 07 bf f4 ld [ %fp + -12 ], %g1 200692c: 80 a0 60 01 cmp %g1, 1 2006930: 02 80 00 08 be 2006950 2006934: 01 00 00 00 nop 2006938: 2a 80 00 0c bcs,a 2006968 200693c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2006940: 80 a0 60 02 cmp %g1, 2 2006944: 12 80 00 1a bne 20069ac 2006948: 01 00 00 00 nop 200694c: 30 80 00 0c b,a 200697c case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 2006950: 40 00 10 34 call 200aa20 <_Thread_Dispatch> <== NOT EXECUTED 2006954: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2006958: 40 00 01 40 call 2006e58 <== NOT EXECUTED 200695c: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2006960: 81 c7 e0 08 ret <== NOT EXECUTED 2006964: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { 2006968: 80 a0 60 01 cmp %g1, 1 200696c: 12 80 00 0a bne 2006994 2006970: 01 00 00 00 nop _Thread_Enable_dispatch(); 2006974: 7f ff ff da call 20068dc <_Thread_Enable_dispatch> <== NOT EXECUTED 2006978: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 200697c: 40 00 28 67 call 2010b18 <__errno> 2006980: 01 00 00 00 nop 2006984: 82 10 20 16 mov 0x16, %g1 ! 16 2006988: c2 22 00 00 st %g1, [ %o0 ] 200698c: 10 80 00 0a b 20069b4 2006990: 90 10 3f ff mov -1, %o0 } _POSIX_Semaphore_Delete( the_semaphore ); 2006994: 40 00 1f fb call 200e980 <_POSIX_Semaphore_Delete> 2006998: 01 00 00 00 nop _Thread_Enable_dispatch(); 200699c: 7f ff ff d0 call 20068dc <_Thread_Enable_dispatch> 20069a0: 01 00 00 00 nop 20069a4: 10 80 00 04 b 20069b4 20069a8: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 20069ac: 40 00 01 21 call 2006e30 <== NOT EXECUTED 20069b0: 01 00 00 00 nop <== NOT EXECUTED } 20069b4: b0 10 00 08 mov %o0, %i0 20069b8: 81 c7 e0 08 ret 20069bc: 81 e8 00 00 restore 020069c0 : int sem_getvalue( sem_t *sem, int *sval ) { 20069c0: 9d e3 bf 90 save %sp, -112, %sp 20069c4: d2 06 00 00 ld [ %i0 ], %o1 20069c8: 11 00 80 78 sethi %hi(0x201e000), %o0 20069cc: 94 07 bf f4 add %fp, -12, %o2 20069d0: 40 00 0b 4e call 2009708 <_Objects_Get> 20069d4: 90 12 22 d0 or %o0, 0x2d0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 20069d8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20069dc: 80 a0 60 01 cmp %g1, 1 20069e0: 02 80 00 0d be 2006a14 20069e4: 01 00 00 00 nop 20069e8: 2a 80 00 11 bcs,a 2006a2c 20069ec: c2 02 20 68 ld [ %o0 + 0x68 ], %g1 20069f0: 80 a0 60 02 cmp %g1, 2 20069f4: 12 80 00 1c bne 2006a64 20069f8: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 20069fc: 40 00 28 47 call 2010b18 <__errno> 2006a00: 01 00 00 00 nop 2006a04: 82 10 20 16 mov 0x16, %g1 ! 16 2006a08: c2 22 00 00 st %g1, [ %o0 ] 2006a0c: 10 80 00 18 b 2006a6c 2006a10: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 2006a14: 40 00 10 03 call 200aa20 <_Thread_Dispatch> <== NOT EXECUTED 2006a18: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2006a1c: 40 00 01 0f call 2006e58 <== NOT EXECUTED 2006a20: 01 00 00 00 nop <== NOT EXECUTED *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2006a24: 81 c7 e0 08 ret <== NOT EXECUTED 2006a28: 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 ); 2006a2c: 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 ) 2006a30: 05 00 80 77 sethi %hi(0x201dc00), %g2 2006a34: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 ! 201df50 <_Thread_Dispatch_disable_level> 2006a38: 90 10 20 00 clr %o0 2006a3c: 82 00 7f ff add %g1, -1, %g1 2006a40: c2 20 a3 50 st %g1, [ %g2 + 0x350 ] 2006a44: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 2006a48: 80 a0 60 00 cmp %g1, 0 2006a4c: 32 80 00 09 bne,a 2006a70 2006a50: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2006a54: 40 00 0f f3 call 200aa20 <_Thread_Dispatch> 2006a58: 01 00 00 00 nop 2006a5c: 10 80 00 04 b 2006a6c 2006a60: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006a64: 40 00 00 f3 call 2006e30 <== NOT EXECUTED 2006a68: 01 00 00 00 nop <== NOT EXECUTED } 2006a6c: b0 10 00 08 mov %o0, %i0 2006a70: 81 c7 e0 08 ret 2006a74: 81 e8 00 00 restore 02006a78 : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 2006a78: 9d e3 bf 90 save %sp, -112, %sp 2006a7c: 92 10 00 19 mov %i1, %o1 int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 2006a80: 80 a6 20 00 cmp %i0, 0 2006a84: 12 80 00 08 bne 2006aa4 2006a88: 94 10 00 1a mov %i2, %o2 rtems_set_errno_and_return_minus_one( EINVAL ); 2006a8c: 40 00 28 23 call 2010b18 <__errno> <== NOT EXECUTED 2006a90: 01 00 00 00 nop <== NOT EXECUTED 2006a94: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 2006a98: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2006a9c: 10 80 00 0a b 2006ac4 <== NOT EXECUTED 2006aa0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED status = _POSIX_Semaphore_Create_support( 2006aa4: 90 10 20 00 clr %o0 2006aa8: 40 00 1f 6a call 200e850 <_POSIX_Semaphore_Create_support> 2006aac: 96 07 bf f4 add %fp, -12, %o3 pshared, value, &the_semaphore ); if ( status != -1 ) 2006ab0: 80 a2 3f ff cmp %o0, -1 2006ab4: 02 80 00 04 be 2006ac4 2006ab8: c2 07 bf f4 ld [ %fp + -12 ], %g1 *sem = the_semaphore->Object.id; 2006abc: c2 00 60 08 ld [ %g1 + 8 ], %g1 2006ac0: c2 26 00 00 st %g1, [ %i0 ] return status; } 2006ac4: 81 c7 e0 08 ret 2006ac8: 91 e8 00 08 restore %g0, %o0, %o0 02006c1c : */ int sem_post( sem_t *sem ) { 2006c1c: 9d e3 bf 90 save %sp, -112, %sp 2006c20: d2 06 00 00 ld [ %i0 ], %o1 2006c24: 11 00 80 78 sethi %hi(0x201e000), %o0 2006c28: 94 07 bf f4 add %fp, -12, %o2 2006c2c: 40 00 0a b7 call 2009708 <_Objects_Get> 2006c30: 90 12 22 d0 or %o0, 0x2d0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 2006c34: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006c38: 80 a0 60 01 cmp %g1, 1 2006c3c: 02 80 00 0d be 2006c70 2006c40: 01 00 00 00 nop 2006c44: 2a 80 00 11 bcs,a 2006c88 2006c48: d2 02 20 08 ld [ %o0 + 8 ], %o1 2006c4c: 80 a0 60 02 cmp %g1, 2 2006c50: 12 80 00 1e bne 2006cc8 2006c54: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 2006c58: 40 00 27 b0 call 2010b18 <__errno> 2006c5c: 01 00 00 00 nop 2006c60: 82 10 20 16 mov 0x16, %g1 ! 16 2006c64: c2 22 00 00 st %g1, [ %o0 ] 2006c68: 10 80 00 1a b 2006cd0 2006c6c: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 2006c70: 40 00 0f 6c call 200aa20 <_Thread_Dispatch> <== NOT EXECUTED 2006c74: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2006c78: 40 00 00 78 call 2006e58 <== NOT EXECUTED 2006c7c: 01 00 00 00 nop <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2006c80: 81 c7 e0 08 ret <== NOT EXECUTED 2006c84: 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( 2006c88: 94 10 20 00 clr %o2 2006c8c: 40 00 07 a4 call 2008b1c <_CORE_semaphore_Surrender> 2006c90: 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 ) 2006c94: 03 00 80 77 sethi %hi(0x201dc00), %g1 2006c98: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 201df50 <_Thread_Dispatch_disable_level> 2006c9c: 90 10 20 00 clr %o0 2006ca0: 84 00 bf ff add %g2, -1, %g2 2006ca4: c4 20 63 50 st %g2, [ %g1 + 0x350 ] 2006ca8: c2 00 63 50 ld [ %g1 + 0x350 ], %g1 2006cac: 80 a0 60 00 cmp %g1, 0 2006cb0: 32 80 00 09 bne,a 2006cd4 2006cb4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2006cb8: 40 00 0f 5a call 200aa20 <_Thread_Dispatch> 2006cbc: 01 00 00 00 nop 2006cc0: 10 80 00 04 b 2006cd0 2006cc4: 90 10 20 00 clr %o0 ! 0 #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006cc8: 40 00 00 5a call 2006e30 <== NOT EXECUTED 2006ccc: 01 00 00 00 nop <== NOT EXECUTED } 2006cd0: b0 10 00 08 mov %o0, %i0 2006cd4: 81 c7 e0 08 ret 2006cd8: 81 e8 00 00 restore 02005ec8 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 2005ec8: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; if ( oact ) 2005ecc: 90 96 a0 00 orcc %i2, 0, %o0 2005ed0: 02 80 00 09 be 2005ef4 2005ed4: 85 2e 20 02 sll %i0, 2, %g2 *oact = _POSIX_signals_Vectors[ sig ]; 2005ed8: 83 2e 20 04 sll %i0, 4, %g1 <== NOT EXECUTED 2005edc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 2005ee0: 13 00 80 70 sethi %hi(0x201c000), %o1 <== NOT EXECUTED 2005ee4: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED 2005ee8: 92 12 60 e4 or %o1, 0xe4, %o1 <== NOT EXECUTED 2005eec: 40 00 27 ba call 200fdd4 <== NOT EXECUTED 2005ef0: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED if ( !sig ) 2005ef4: 80 a6 20 00 cmp %i0, 0 2005ef8: 02 80 00 08 be 2005f18 2005efc: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 2005f00: a0 06 3f ff add %i0, -1, %l0 2005f04: 80 a4 20 1f cmp %l0, 0x1f 2005f08: 18 80 00 04 bgu 2005f18 2005f0c: 80 a6 20 09 cmp %i0, 9 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 2005f10: 12 80 00 08 bne 2005f30 2005f14: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( EINVAL ); 2005f18: 40 00 25 c9 call 200f63c <__errno> 2005f1c: 01 00 00 00 nop 2005f20: 82 10 20 16 mov 0x16, %g1 ! 16 2005f24: c2 22 00 00 st %g1, [ %o0 ] 2005f28: 10 80 00 1f b 2005fa4 2005f2c: 82 10 3f ff mov -1, %g1 /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 2005f30: 02 80 00 1d be 2005fa4 2005f34: 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 ); 2005f38: 7f ff f0 fe call 2002330 2005f3c: 01 00 00 00 nop 2005f40: a4 10 00 08 mov %o0, %l2 if ( act->sa_handler == SIG_DFL ) { 2005f44: c2 06 60 08 ld [ %i1 + 8 ], %g1 2005f48: b5 2e 20 04 sll %i0, 4, %i2 2005f4c: 80 a0 60 00 cmp %g1, 0 2005f50: b1 2e 20 02 sll %i0, 2, %i0 2005f54: 03 00 80 70 sethi %hi(0x201c000), %g1 2005f58: 12 80 00 08 bne 2005f78 2005f5c: a2 10 60 e4 or %g1, 0xe4, %l1 ! 201c0e4 <_POSIX_signals_Vectors> _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 2005f60: 82 26 80 18 sub %i2, %i0, %g1 <== NOT EXECUTED 2005f64: 13 00 80 6b sethi %hi(0x201ac00), %o1 <== NOT EXECUTED 2005f68: 90 00 40 11 add %g1, %l1, %o0 <== NOT EXECUTED 2005f6c: 92 12 61 e4 or %o1, 0x1e4, %o1 <== NOT EXECUTED 2005f70: 10 80 00 08 b 2005f90 <== NOT EXECUTED 2005f74: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED } else { _POSIX_signals_Clear_process_signals( signo_to_mask(sig) ); 2005f78: 90 10 20 01 mov 1, %o0 2005f7c: 40 00 1d 99 call 200d5e0 <_POSIX_signals_Clear_process_signals> 2005f80: 91 2a 00 10 sll %o0, %l0, %o0 _POSIX_signals_Vectors[ sig ] = *act; 2005f84: 90 26 80 18 sub %i2, %i0, %o0 2005f88: 92 10 00 19 mov %i1, %o1 2005f8c: 90 02 00 11 add %o0, %l1, %o0 2005f90: 40 00 27 91 call 200fdd4 2005f94: 94 10 20 0c mov 0xc, %o2 } _ISR_Enable( level ); 2005f98: 7f ff f0 ea call 2002340 2005f9c: 90 10 00 12 mov %l2, %o0 2005fa0: 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; } 2005fa4: 81 c7 e0 08 ret 2005fa8: 91 e8 00 01 restore %g0, %g1, %o0 02006324 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 2006324: 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 ) { 2006328: 80 a6 a0 00 cmp %i2, 0 200632c: 02 80 00 12 be 2006374 2006330: a6 10 20 00 clr %l3 if ( !_Timespec_Is_valid( timeout ) ) 2006334: 40 00 14 12 call 200b37c <_Timespec_Is_valid> 2006338: 90 10 00 1a mov %i2, %o0 200633c: 80 a2 20 00 cmp %o0, 0 2006340: 02 80 00 07 be 200635c 2006344: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 2006348: 40 00 14 32 call 200b410 <_Timespec_To_ticks> 200634c: 90 10 00 1a mov %i2, %o0 if ( !interval ) 2006350: a6 92 20 00 orcc %o0, 0, %l3 2006354: 12 80 00 09 bne 2006378 2006358: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( EINVAL ); 200635c: 40 00 26 71 call 200fd20 <__errno> 2006360: b0 10 3f ff mov -1, %i0 2006364: 82 10 20 16 mov 0x16, %g1 2006368: c2 22 00 00 st %g1, [ %o0 ] 200636c: 81 c7 e0 08 ret 2006370: 81 e8 00 00 restore /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 2006374: 80 a6 60 00 cmp %i1, 0 2006378: 02 80 00 03 be 2006384 200637c: a4 07 bf ec add %fp, -20, %l2 2006380: a4 10 00 19 mov %i1, %l2 the_thread = _Thread_Executing; 2006384: 29 00 80 70 sethi %hi(0x201c000), %l4 2006388: f4 05 23 90 ld [ %l4 + 0x390 ], %i2 ! 201c390 <_Thread_Executing> * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 200638c: 7f ff f0 aa call 2002634 2006390: f2 06 a1 74 ld [ %i2 + 0x174 ], %i1 2006394: a0 10 00 08 mov %o0, %l0 if ( *set & api->signals_pending ) { 2006398: c4 06 00 00 ld [ %i0 ], %g2 200639c: c2 06 60 c8 ld [ %i1 + 0xc8 ], %g1 20063a0: 80 88 80 01 btst %g2, %g1 20063a4: 22 80 00 10 be,a 20063e4 20063a8: 03 00 80 72 sethi %hi(0x201c800), %g1 /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending ); 20063ac: 7f ff ff c4 call 20062bc <_POSIX_signals_Get_highest> 20063b0: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( 20063b4: 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 ); 20063b8: 92 10 00 08 mov %o0, %o1 _POSIX_signals_Clear_signals( 20063bc: 96 10 20 00 clr %o3 20063c0: 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 ); 20063c4: d2 24 80 00 st %o1, [ %l2 ] _POSIX_signals_Clear_signals( 20063c8: 40 00 1e 6b call 200dd74 <_POSIX_signals_Clear_signals> 20063cc: 98 10 20 00 clr %o4 the_info->si_signo, the_info, FALSE, FALSE ); _ISR_Enable( level ); 20063d0: 7f ff f0 9d call 2002644 20063d4: 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; 20063d8: f0 04 80 00 ld [ %l2 ], %i0 FALSE ); _ISR_Enable( level ); the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; 20063dc: 10 80 00 13 b 2006428 20063e0: c0 24 a0 08 clr [ %l2 + 8 ] return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 20063e4: c2 00 63 10 ld [ %g1 + 0x310 ], %g1 20063e8: 80 88 80 01 btst %g2, %g1 20063ec: 02 80 00 13 be 2006438 20063f0: 23 00 80 70 sethi %hi(0x201c000), %l1 signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 20063f4: 7f ff ff b2 call 20062bc <_POSIX_signals_Get_highest> 20063f8: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( api, signo, the_info, TRUE, FALSE ); 20063fc: 94 10 00 12 mov %l2, %o2 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 2006400: b0 10 00 08 mov %o0, %i0 _POSIX_signals_Clear_signals( api, signo, the_info, TRUE, FALSE ); 2006404: 96 10 20 01 mov 1, %o3 2006408: 90 10 00 19 mov %i1, %o0 200640c: 92 10 00 18 mov %i0, %o1 2006410: 40 00 1e 59 call 200dd74 <_POSIX_signals_Clear_signals> 2006414: 98 10 20 00 clr %o4 _ISR_Enable( level ); 2006418: 7f ff f0 8b call 2002644 200641c: 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; 2006420: 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; 2006424: f0 24 80 00 st %i0, [ %l2 ] the_info->si_code = SI_USER; 2006428: 82 10 20 01 mov 1, %g1 200642c: c2 24 a0 04 st %g1, [ %l2 + 4 ] 2006430: 81 c7 e0 08 ret 2006434: 81 e8 00 00 restore rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006438: c2 04 62 b0 ld [ %l1 + 0x2b0 ], %g1 the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 200643c: 84 10 3f ff mov -1, %g2 2006440: 82 00 60 01 inc %g1 2006444: c4 24 80 00 st %g2, [ %l2 ] 2006448: c2 24 62 b0 st %g1, [ %l1 + 0x2b0 ] _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; the_thread->Wait.return_code = EINTR; 200644c: 82 10 20 04 mov 4, %g1 2006450: c2 26 a0 34 st %g1, [ %i2 + 0x34 ] the_thread->Wait.option = *set; 2006454: c2 06 00 00 ld [ %i0 ], %g1 the_thread->Wait.return_argument = the_info; 2006458: 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; 200645c: c2 26 a0 30 st %g1, [ %i2 + 0x30 ] } the_info->si_signo = -1; _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 2006460: 21 00 80 72 sethi %hi(0x201c800), %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; 2006464: 82 10 20 01 mov 1, %g1 2006468: a0 14 22 d0 or %l0, 0x2d0, %l0 200646c: e0 26 a0 44 st %l0, [ %i2 + 0x44 ] 2006470: 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 ); 2006474: 7f ff f0 74 call 2002644 2006478: 01 00 00 00 nop _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 200647c: 90 10 00 10 mov %l0, %o0 2006480: 92 10 00 13 mov %l3, %o1 2006484: 15 00 80 2b sethi %hi(0x200ac00), %o2 2006488: 40 00 10 fd call 200a87c <_Thread_queue_Enqueue_with_handler> 200648c: 94 12 a1 14 or %o2, 0x114, %o2 ! 200ad14 <_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 ) 2006490: c2 04 62 b0 ld [ %l1 + 0x2b0 ], %g1 2006494: 82 00 7f ff add %g1, -1, %g1 2006498: c2 24 62 b0 st %g1, [ %l1 + 0x2b0 ] 200649c: c2 04 62 b0 ld [ %l1 + 0x2b0 ], %g1 20064a0: 80 a0 60 00 cmp %g1, 0 20064a4: 32 80 00 05 bne,a 20064b8 20064a8: d2 04 80 00 ld [ %l2 ], %o1 <== NOT EXECUTED _Thread_Dispatch(); 20064ac: 40 00 0f 5d call 200a220 <_Thread_Dispatch> 20064b0: 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 ); 20064b4: d2 04 80 00 ld [ %l2 ], %o1 20064b8: 94 10 00 12 mov %l2, %o2 20064bc: 96 10 20 00 clr %o3 20064c0: 98 10 20 00 clr %o4 20064c4: 40 00 1e 2c call 200dd74 <_POSIX_signals_Clear_signals> 20064c8: 90 10 00 19 mov %i1, %o0 errno = _Thread_Executing->Wait.return_code; 20064cc: 40 00 26 15 call 200fd20 <__errno> 20064d0: 01 00 00 00 nop 20064d4: c2 05 23 90 ld [ %l4 + 0x390 ], %g1 20064d8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 20064dc: c2 22 00 00 st %g1, [ %o0 ] return the_info->si_signo; 20064e0: f0 04 80 00 ld [ %l2 ], %i0 } 20064e4: 81 c7 e0 08 ret 20064e8: 81 e8 00 00 restore 020080d8 : int sigwait( const sigset_t *set, int *sig ) { 20080d8: 9d e3 bf 98 save %sp, -104, %sp int status; status = sigtimedwait( set, NULL, NULL ); 20080dc: 92 10 20 00 clr %o1 20080e0: 90 10 00 18 mov %i0, %o0 20080e4: 7f ff ff 86 call 2007efc 20080e8: 94 10 20 00 clr %o2 if ( status != -1 ) { 20080ec: 80 a2 3f ff cmp %o0, -1 20080f0: 02 80 00 07 be 200810c 20080f4: 80 a6 60 00 cmp %i1, 0 if ( sig ) 20080f8: 02 80 00 03 be 2008104 20080fc: b0 10 20 00 clr %i0 *sig = status; 2008100: d0 26 40 00 st %o0, [ %i1 ] 2008104: 81 c7 e0 08 ret 2008108: 81 e8 00 00 restore return 0; } return errno; 200810c: 40 00 26 4c call 2011a3c <__errno> <== NOT EXECUTED 2008110: 01 00 00 00 nop <== NOT EXECUTED 2008114: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED } 2008118: 81 c7 e0 08 ret <== NOT EXECUTED 200811c: 81 e8 00 00 restore <== NOT EXECUTED 0200b1ec : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 200b1ec: 9d e3 bf 98 save %sp, -104, %sp POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 200b1f0: 80 a6 20 01 cmp %i0, 1 200b1f4: 12 80 00 11 bne 200b238 200b1f8: 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) { 200b1fc: 02 80 00 13 be 200b248 200b200: 05 00 80 8e sethi %hi(0x2023800), %g2 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 200b204: c2 06 40 00 ld [ %i1 ], %g1 200b208: 82 00 7f ff add %g1, -1, %g1 200b20c: 80 a0 60 01 cmp %g1, 1 200b210: 18 80 00 0a bgu 200b238 200b214: 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 ) 200b218: c2 06 60 04 ld [ %i1 + 4 ], %g1 200b21c: 80 a0 60 00 cmp %g1, 0 200b220: 02 80 00 06 be 200b238 200b224: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 200b228: 82 00 7f ff add %g1, -1, %g1 200b22c: 80 a0 60 1f cmp %g1, 0x1f 200b230: 08 80 00 06 bleu 200b248 200b234: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); 200b238: 40 00 28 d7 call 2015594 <__errno> <== NOT EXECUTED 200b23c: 01 00 00 00 nop <== NOT EXECUTED 200b240: 10 80 00 10 b 200b280 <== NOT EXECUTED 200b244: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200b248: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 200b24c: 82 00 60 01 inc %g1 200b250: c2 20 a1 50 st %g1, [ %g2 + 0x150 ] * 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 ); 200b254: 21 00 80 8f sethi %hi(0x2023c00), %l0 200b258: 40 00 0a b6 call 200dd30 <_Objects_Allocate> 200b25c: 90 14 21 1c or %l0, 0x11c, %o0 ! 2023d1c <_POSIX_Timer_Information> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 200b260: b0 92 20 00 orcc %o0, 0, %i0 200b264: 12 80 00 0a bne 200b28c 200b268: 82 10 20 02 mov 2, %g1 _Thread_Enable_dispatch(); 200b26c: 7f ff fe d1 call 200adb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 200b270: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EAGAIN ); 200b274: 40 00 28 c8 call 2015594 <__errno> <== NOT EXECUTED 200b278: 01 00 00 00 nop <== NOT EXECUTED 200b27c: 82 10 20 0b mov 0xb, %g1 ! b <== NOT EXECUTED 200b280: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b284: 81 c7 e0 08 ret <== NOT EXECUTED 200b288: 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; 200b28c: c2 2e 20 3c stb %g1, [ %i0 + 0x3c ] ptimer->thread_id = _Thread_Executing->Object.id; 200b290: 03 00 80 8e sethi %hi(0x2023800), %g1 200b294: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 2023a30 <_Thread_Executing> if ( evp != NULL ) { 200b298: 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; 200b29c: c2 00 60 08 ld [ %g1 + 8 ], %g1 if ( evp != NULL ) { 200b2a0: 02 80 00 08 be 200b2c0 200b2a4: 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; 200b2a8: 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; 200b2ac: c4 06 40 00 ld [ %i1 ], %g2 ptimer->inf.sigev_signo = evp->sigev_signo; 200b2b0: 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; 200b2b4: c4 26 20 40 st %g2, [ %i0 + 0x40 ] ptimer->inf.sigev_signo = evp->sigev_signo; 200b2b8: c6 26 20 44 st %g3, [ %i0 + 0x44 ] ptimer->inf.sigev_value = evp->sigev_value; 200b2bc: 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 ); 200b2c0: c2 06 20 08 ld [ %i0 + 8 ], %g1 200b2c4: 94 10 00 18 mov %i0, %o2 200b2c8: 90 14 21 1c or %l0, 0x11c, %o0 } ptimer->overrun = 0; 200b2cc: c0 26 20 68 clr [ %i0 + 0x68 ] ptimer->timer_data.it_value.tv_sec = 0; 200b2d0: c0 26 20 5c clr [ %i0 + 0x5c ] ptimer->timer_data.it_value.tv_nsec = 0; 200b2d4: c0 26 20 60 clr [ %i0 + 0x60 ] ptimer->timer_data.it_interval.tv_sec = 0; 200b2d8: c0 26 20 54 clr [ %i0 + 0x54 ] ptimer->timer_data.it_interval.tv_nsec = 0; 200b2dc: c0 26 20 58 clr [ %i0 + 0x58 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200b2e0: c0 26 20 18 clr [ %i0 + 0x18 ] the_watchdog->routine = routine; 200b2e4: c0 26 20 2c clr [ %i0 + 0x2c ] the_watchdog->id = id; 200b2e8: c0 26 20 30 clr [ %i0 + 0x30 ] the_watchdog->user_data = user_data; 200b2ec: c0 26 20 34 clr [ %i0 + 0x34 ] 200b2f0: 13 00 00 3f sethi %hi(0xfc00), %o1 200b2f4: 92 12 63 ff or %o1, 0x3ff, %o1 ! ffff 200b2f8: 7f ff fe 9c call 200ad68 <_Objects_Set_local_object> 200b2fc: 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; 200b300: 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; 200b304: c0 26 20 0c clr [ %i0 + 0xc ] 200b308: c2 26 80 00 st %g1, [ %i2 ] _Thread_Enable_dispatch(); 200b30c: 7f ff fe a9 call 200adb0 <_Thread_Enable_dispatch> 200b310: b0 10 20 00 clr %i0 return 0; } 200b314: 81 c7 e0 08 ret 200b318: 81 e8 00 00 restore 0200aeb8 : */ int timer_delete( timer_t timerid ) { 200aeb8: 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 ); 200aebc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200aec0: 7f ff ff b4 call 200ad90 <_POSIX_Timer_Get> <== NOT EXECUTED 200aec4: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED switch ( location ) { 200aec8: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200aecc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200aed0: 02 80 00 0b be 200aefc <== NOT EXECUTED 200aed4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 200aed8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200aedc: 18 80 00 06 bgu 200aef4 <== NOT EXECUTED 200aee0: 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 ); 200aee4: 40 00 29 ac call 2015594 <__errno> <== NOT EXECUTED 200aee8: 01 00 00 00 nop <== NOT EXECUTED 200aeec: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200aef0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200aef4: 81 c7 e0 08 ret <== NOT EXECUTED 200aef8: 81 e8 00 00 restore <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200aefc: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED 200af00: 94 10 20 00 clr %o2 <== NOT EXECUTED 200af04: 21 00 80 8f sethi %hi(0x2023c00), %l0 <== NOT EXECUTED 200af08: 13 00 00 3f sethi %hi(0xfc00), %o1 <== NOT EXECUTED 200af0c: 90 14 21 1c or %l0, 0x11c, %o0 <== NOT EXECUTED 200af10: 92 12 63 ff or %o1, 0x3ff, %o1 <== NOT EXECUTED 200af14: 7f ff ff 95 call 200ad68 <_Objects_Set_local_object> <== NOT EXECUTED 200af18: 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; 200af1c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 200af20: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED 200af24: c2 2e 20 3c stb %g1, [ %i0 + 0x3c ] <== NOT EXECUTED (void) _Watchdog_Remove( &ptimer->Timer ); 200af28: 40 00 17 42 call 2010c30 <_Watchdog_Remove> <== NOT EXECUTED 200af2c: 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 ); 200af30: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200af34: 90 14 21 1c or %l0, 0x11c, %o0 <== NOT EXECUTED 200af38: 40 00 0c 80 call 200e138 <_Objects_Free> <== NOT EXECUTED 200af3c: b0 10 20 00 clr %i0 <== NOT EXECUTED _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); 200af40: 7f ff ff 9c call 200adb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 200af44: 01 00 00 00 nop <== NOT EXECUTED return 0; } return -1; /* unreached - only to remove warnings */ } 200af48: 81 c7 e0 08 ret <== NOT EXECUTED 200af4c: 81 e8 00 00 restore <== NOT EXECUTED 0200ade4 : */ int timer_getoverrun( timer_t timerid ) { 200ade4: 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 ); 200ade8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200adec: 7f ff ff e9 call 200ad90 <_POSIX_Timer_Get> <== NOT EXECUTED 200adf0: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED switch ( location ) { 200adf4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200adf8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200adfc: 22 80 00 0b be,a 200ae28 <== NOT EXECUTED 200ae00: f0 02 20 68 ld [ %o0 + 0x68 ], %i0 <== NOT EXECUTED 200ae04: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200ae08: 18 80 00 06 bgu 200ae20 <== NOT EXECUTED 200ae0c: 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 ); 200ae10: 40 00 29 e1 call 2015594 <__errno> <== NOT EXECUTED 200ae14: 01 00 00 00 nop <== NOT EXECUTED 200ae18: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200ae1c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200ae20: 81 c7 e0 08 ret <== NOT EXECUTED 200ae24: 81 e8 00 00 restore <== NOT EXECUTED case OBJECTS_LOCAL: overrun = ptimer->overrun; ptimer->overrun = 0; _Thread_Enable_dispatch(); 200ae28: 7f ff ff e2 call 200adb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 200ae2c: c0 22 20 68 clr [ %o0 + 0x68 ] <== NOT EXECUTED return overrun; } return -1; /* unreached - only to remove warnings */ } 200ae30: 81 c7 e0 08 ret <== NOT EXECUTED 200ae34: 81 e8 00 00 restore <== NOT EXECUTED 0200ae38 : int timer_gettime( timer_t timerid, struct itimerspec *value ) { 200ae38: 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 ); 200ae3c: a0 07 bf ec add %fp, -20, %l0 <== NOT EXECUTED 200ae40: 40 00 0a 01 call 200d644 <_TOD_Get> <== NOT EXECUTED 200ae44: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED ptimer = _POSIX_Timer_Get( timerid, &location ); 200ae48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200ae4c: 7f ff ff d1 call 200ad90 <_POSIX_Timer_Get> <== NOT EXECUTED 200ae50: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED switch ( location ) { 200ae54: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200ae58: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200ae5c: 02 80 00 0b be 200ae88 <== NOT EXECUTED 200ae60: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 200ae64: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200ae68: 18 80 00 06 bgu 200ae80 <== NOT EXECUTED 200ae6c: 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 ); 200ae70: 40 00 29 c9 call 2015594 <__errno> <== NOT EXECUTED 200ae74: 01 00 00 00 nop <== NOT EXECUTED 200ae78: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200ae7c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200ae80: 81 c7 e0 08 ret <== NOT EXECUTED 200ae84: 81 e8 00 00 restore <== NOT EXECUTED case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ _Timespec_Subtract( 200ae88: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 200ae8c: 90 02 20 5c add %o0, 0x5c, %o0 <== NOT EXECUTED 200ae90: 40 00 16 2b call 201073c <_Timespec_Subtract> <== NOT EXECUTED 200ae94: 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; 200ae98: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 200ae9c: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED 200aea0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); 200aea4: b0 10 20 00 clr %i0 <== NOT EXECUTED 200aea8: 7f ff ff c2 call 200adb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 200aeac: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED return 0; } return -1; /* unreached - only to remove warnings */ } 200aeb0: 81 c7 e0 08 ret <== NOT EXECUTED 200aeb4: 81 e8 00 00 restore <== NOT EXECUTED 0200afbc : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 200afbc: 9d e3 bf 90 save %sp, -112, %sp POSIX_Timer_Control *ptimer; Objects_Locations location; boolean activated; if ( value == NULL ) { 200afc0: 80 a6 a0 00 cmp %i2, 0 200afc4: 02 80 00 0c be 200aff4 200afc8: 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 ) || 200afcc: c4 06 a0 0c ld [ %i2 + 0xc ], %g2 200afd0: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 200afd4: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 200afd8: 80 a0 80 01 cmp %g2, %g1 200afdc: 18 80 00 06 bgu 200aff4 200afe0: 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 ) { 200afe4: 02 80 00 0a be 200b00c 200afe8: 80 a6 60 00 cmp %i1, 0 200afec: 02 80 00 08 be 200b00c 200aff0: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); 200aff4: 40 00 29 68 call 2015594 <__errno> <== NOT EXECUTED 200aff8: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200affc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 200b000: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b004: 81 c7 e0 08 ret <== NOT EXECUTED 200b008: 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 ); 200b00c: 7f ff ff 61 call 200ad90 <_POSIX_Timer_Get> 200b010: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 200b014: 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 ); 200b018: a0 10 00 08 mov %o0, %l0 switch ( location ) { 200b01c: 80 a0 60 00 cmp %g1, 0 200b020: 12 bf ff f9 bne 200b004 200b024: 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 ) { 200b028: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200b02c: 80 a0 60 00 cmp %g1, 0 200b030: 12 80 00 15 bne 200b084 200b034: 80 a6 60 00 cmp %i1, 0 200b038: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 <== NOT EXECUTED 200b03c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b040: 12 80 00 11 bne 200b084 <== NOT EXECUTED 200b044: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 200b048: 40 00 16 fa call 2010c30 <_Watchdog_Remove> <== NOT EXECUTED 200b04c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED /* The old data of the timer are returned */ if ( ovalue ) 200b050: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 200b054: 02 80 00 05 be 200b068 <== NOT EXECUTED 200b058: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED *ovalue = ptimer->timer_data; 200b05c: 92 04 20 54 add %l0, 0x54, %o1 <== NOT EXECUTED 200b060: 40 00 2b 33 call 2015d2c <== NOT EXECUTED 200b064: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED /* The new data are set */ ptimer->timer_data = *value; 200b068: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 200b06c: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED 200b070: 40 00 2b 2f call 2015d2c <== NOT EXECUTED 200b074: 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; 200b078: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED 200b07c: 10 80 00 31 b 200b140 <== NOT EXECUTED 200b080: c2 2c 20 3c stb %g1, [ %l0 + 0x3c ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* absolute or relative? */ switch (flags) { 200b084: 02 80 00 15 be 200b0d8 200b088: 80 a6 60 04 cmp %i1, 4 200b08c: 12 80 00 31 bne 200b150 <== NOT EXECUTED 200b090: 11 00 80 8e sethi %hi(0x2023800), %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( 200b094: 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; 200b098: c0 24 20 18 clr [ %l0 + 0x18 ] <== NOT EXECUTED the_watchdog->routine = routine; the_watchdog->id = id; 200b09c: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200b0a0: 03 00 80 8e sethi %hi(0x2023800), %g1 <== NOT EXECUTED 200b0a4: c4 00 62 0c ld [ %g1 + 0x20c ], %g2 ! 2023a0c <_TOD_Now> <== NOT EXECUTED 200b0a8: 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; 200b0ac: e0 24 20 34 st %l0, [ %l0 + 0x34 ] <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200b0b0: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 200b0b4: 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; 200b0b8: 03 00 80 2c sethi %hi(0x200b000), %g1 <== NOT EXECUTED 200b0bc: 82 10 61 70 or %g1, 0x170, %g1 ! 200b170 <_POSIX_Timer_TSR> <== NOT EXECUTED 200b0c0: c2 24 20 2c st %g1, [ %l0 + 0x2c ] <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 200b0c4: 90 12 22 44 or %o0, 0x244, %o0 <== NOT EXECUTED 200b0c8: 40 00 16 82 call 2010ad0 <_Watchdog_Insert> <== NOT EXECUTED 200b0cc: 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 ) 200b0d0: 10 80 00 0f b 200b10c <== NOT EXECUTED 200b0d4: 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 ); 200b0d8: 40 00 15 ad call 201078c <_Timespec_To_ticks> 200b0dc: 90 06 a0 08 add %i2, 8, %o0 activated = _Watchdog_Insert_ticks_helper( 200b0e0: 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 ); 200b0e4: 92 10 00 08 mov %o0, %o1 200b0e8: d0 24 20 64 st %o0, [ %l0 + 0x64 ] activated = _Watchdog_Insert_ticks_helper( 200b0ec: 17 00 80 2c sethi %hi(0x200b000), %o3 200b0f0: 90 04 20 10 add %l0, 0x10, %o0 200b0f4: 96 12 e1 70 or %o3, 0x170, %o3 200b0f8: 7f ff ff 96 call 200af50 <_Watchdog_Insert_ticks_helper> 200b0fc: 98 10 00 10 mov %l0, %o4 ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 200b100: 80 a2 20 00 cmp %o0, 0 200b104: 02 80 00 0f be 200b140 200b108: 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 ) 200b10c: 02 80 00 05 be 200b120 200b110: 90 10 00 1b mov %i3, %o0 *ovalue = ptimer->timer_data; 200b114: 92 04 20 54 add %l0, 0x54, %o1 <== NOT EXECUTED 200b118: 40 00 2b 05 call 2015d2c <== NOT EXECUTED 200b11c: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED ptimer->timer_data = *value; 200b120: 92 10 00 1a mov %i2, %o1 200b124: 94 10 20 10 mov 0x10, %o2 200b128: 40 00 2b 01 call 2015d2c 200b12c: 90 04 20 54 add %l0, 0x54, %o0 /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 200b130: 82 10 20 03 mov 3, %g1 _TOD_Get( &ptimer->time ); 200b134: 90 04 20 6c add %l0, 0x6c, %o0 200b138: 40 00 09 43 call 200d644 <_TOD_Get> 200b13c: c2 2c 20 3c stb %g1, [ %l0 + 0x3c ] _Thread_Enable_dispatch(); 200b140: 7f ff ff 1c call 200adb0 <_Thread_Enable_dispatch> 200b144: b0 10 20 00 clr %i0 200b148: 81 c7 e0 08 ret 200b14c: 81 e8 00 00 restore return 0; } _Thread_Enable_dispatch(); 200b150: 7f ff ff 18 call 200adb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 200b154: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 200b158: 40 00 29 0f call 2015594 <__errno> <== NOT EXECUTED 200b15c: 01 00 00 00 nop <== NOT EXECUTED 200b160: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200b164: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return -1; /* unreached - only to remove warnings */ } 200b168: 81 c7 e0 08 ret <== NOT EXECUTED 200b16c: 81 e8 00 00 restore <== NOT EXECUTED 02009190 : int usleep( useconds_t useconds ) { 2009190: 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; 2009194: 21 00 03 d0 sethi %hi(0xf4000), %l0 <== NOT EXECUTED 2009198: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200919c: 7f ff e1 77 call 2001778 <.udiv> <== NOT EXECUTED 20091a0: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 20091a4: 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; 20091a8: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 20091ac: 40 00 5b 7c call 201ff9c <.urem> <== NOT EXECUTED 20091b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20091b4: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED 20091b8: 83 2a 20 07 sll %o0, 7, %g1 <== NOT EXECUTED 20091bc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 20091c0: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 20091c4: 83 28 60 03 sll %g1, 3, %g1 <== NOT EXECUTED nanosleep( &tp, &tm ); 20091c8: 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; 20091cc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED nanosleep( &tp, &tm ); 20091d0: 40 00 25 34 call 20126a0 <== NOT EXECUTED 20091d4: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED remaining = tm.tv_sec * TOD_MICROSECONDS_PER_SECOND; 20091d8: c4 07 bf e8 ld [ %fp + -24 ], %g2 <== NOT EXECUTED 20091dc: d0 07 bf ec ld [ %fp + -20 ], %o0 <== NOT EXECUTED 20091e0: 87 28 a0 03 sll %g2, 3, %g3 <== NOT EXECUTED 20091e4: 83 28 a0 08 sll %g2, 8, %g1 <== NOT EXECUTED 20091e8: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 20091ec: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED 20091f0: b1 28 60 06 sll %g1, 6, %i0 <== NOT EXECUTED 20091f4: b0 26 00 01 sub %i0, %g1, %i0 <== NOT EXECUTED 20091f8: 7f ff e1 62 call 2001780 <.div> <== NOT EXECUTED 20091fc: b0 06 00 02 add %i0, %g2, %i0 <== NOT EXECUTED 2009200: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED remaining += tm.tv_nsec / 1000; return remaining; /* seconds remaining */ } 2009204: 81 c7 e0 08 ret <== NOT EXECUTED 2009208: 91 ea 00 18 restore %o0, %i0, %o0 <== NOT EXECUTED