02006c08 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 2006c08: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 2006c0c: 03 00 80 62 sethi %hi(0x2018800), %g1 2006c10: e0 00 62 70 ld [ %g1 + 0x270 ], %l0 ! 2018a70 <_API_extensions_List> 2006c14: 82 10 62 70 or %g1, 0x270, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2006c18: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 2006c1c: 80 a4 00 11 cmp %l0, %l1 2006c20: 02 80 00 0c be 2006c50 <_API_extensions_Run_postdriver+0x48> 2006c24: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 2006c28: c2 04 20 0c ld [ %l0 + 0xc ], %g1 2006c2c: 80 a0 60 00 cmp %g1, 0 2006c30: 22 80 00 05 be,a 2006c44 <_API_extensions_Run_postdriver+0x3c> 2006c34: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postdriver_hook)(); 2006c38: 9f c0 40 00 call %g1 2006c3c: 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 ) { 2006c40: 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 ) ; 2006c44: 80 a4 00 11 cmp %l0, %l1 2006c48: 32 bf ff f9 bne,a 2006c2c <_API_extensions_Run_postdriver+0x24> 2006c4c: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED 2006c50: 81 c7 e0 08 ret 2006c54: 81 e8 00 00 restore 02006cc4 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 2006cc4: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 2006cc8: 03 00 80 62 sethi %hi(0x2018800), %g1 2006ccc: e0 00 62 70 ld [ %g1 + 0x270 ], %l0 ! 2018a70 <_API_extensions_List> 2006cd0: 82 10 62 70 or %g1, 0x270, %g1 2006cd4: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 2006cd8: 80 a4 00 11 cmp %l0, %l1 2006cdc: 02 80 00 0c be 2006d0c <_API_extensions_Run_postswitch+0x48> 2006ce0: 25 00 80 62 sethi %hi(0x2018800), %l2 the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 2006ce4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2006ce8: 80 a0 60 00 cmp %g1, 0 2006cec: 22 80 00 05 be,a 2006d00 <_API_extensions_Run_postswitch+0x3c> 2006cf0: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 2006cf4: 9f c0 40 00 call %g1 2006cf8: d0 04 a0 c0 ld [ %l2 + 0xc0 ], %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 ) { 2006cfc: 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 ) ; 2006d00: 80 a4 00 11 cmp %l0, %l1 2006d04: 32 bf ff f9 bne,a 2006ce8 <_API_extensions_Run_postswitch+0x24> 2006d08: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 2006d0c: 81 c7 e0 08 ret 2006d10: 81 e8 00 00 restore 02006c74 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 2006c74: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 2006c78: 03 00 80 62 sethi %hi(0x2018800), %g1 2006c7c: e0 00 62 70 ld [ %g1 + 0x270 ], %l0 ! 2018a70 <_API_extensions_List> 2006c80: 82 10 62 70 or %g1, 0x270, %g1 2006c84: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 2006c88: 80 a4 00 11 cmp %l0, %l1 2006c8c: 02 80 00 0c be 2006cbc <_API_extensions_Run_predriver+0x48> 2006c90: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 2006c94: c2 04 20 08 ld [ %l0 + 8 ], %g1 2006c98: 80 a0 60 00 cmp %g1, 0 2006c9c: 22 80 00 05 be,a 2006cb0 <_API_extensions_Run_predriver+0x3c> 2006ca0: e0 04 00 00 ld [ %l0 ], %l0 (*the_extension->predriver_hook)(); 2006ca4: 9f c0 40 00 call %g1 <== NOT EXECUTED 2006ca8: 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 ) { 2006cac: 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 ) ; 2006cb0: 80 a4 00 11 cmp %l0, %l1 2006cb4: 32 bf ff f9 bne,a 2006c98 <_API_extensions_Run_predriver+0x24> 2006cb8: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 2006cbc: 81 c7 e0 08 ret 2006cc0: 81 e8 00 00 restore 02013f70 <_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 ) { 2013f70: 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 ) { 2013f74: 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 ) { 2013f78: 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 ) { 2013f7c: 80 a0 40 1a cmp %g1, %i2 2013f80: 0a 80 00 17 bcs 2013fdc <_CORE_message_queue_Broadcast+0x6c> 2013f84: 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 ) { 2013f88: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1 2013f8c: 80 a0 60 00 cmp %g1, 0 2013f90: 02 80 00 0a be 2013fb8 <_CORE_message_queue_Broadcast+0x48> 2013f94: a2 10 20 00 clr %l1 *count = 0; 2013f98: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED 2013f9c: 81 c7 e0 08 ret <== NOT EXECUTED 2013fa0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 2013fa4: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 2013fa8: 40 00 22 52 call 201c8f0 2013fac: a2 04 60 01 inc %l1 buffer, waitp->return_argument, size ); *(uint32_t *)the_thread->Wait.return_argument_1 = size; 2013fb0: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 2013fb4: 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))) { 2013fb8: 40 00 0b c9 call 2016edc <_Thread_queue_Dequeue> 2013fbc: 90 10 00 12 mov %l2, %o0 2013fc0: 92 10 00 19 mov %i1, %o1 2013fc4: a0 10 00 08 mov %o0, %l0 2013fc8: 80 a2 20 00 cmp %o0, 0 2013fcc: 12 bf ff f6 bne 2013fa4 <_CORE_message_queue_Broadcast+0x34> 2013fd0: 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; 2013fd4: e2 27 40 00 st %l1, [ %i5 ] 2013fd8: b0 10 20 00 clr %i0 return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 2013fdc: 81 c7 e0 08 ret 2013fe0: 81 e8 00 00 restore 020140a4 <_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 ) { 20140a4: 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; 20140a8: 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; 20140ac: 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; 20140b0: 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; 20140b4: c0 26 20 60 clr [ %i0 + 0x60 ] the_message_queue->notify_argument = the_argument; 20140b8: 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)) { 20140bc: 80 8e e0 03 btst 3, %i3 20140c0: 02 80 00 07 be 20140dc <_CORE_message_queue_Initialize+0x38> 20140c4: a0 10 00 1b mov %i3, %l0 allocated_message_size += sizeof(uint32_t); 20140c8: 82 06 e0 04 add %i3, 4, %g1 allocated_message_size &= ~(sizeof(uint32_t) - 1); 20140cc: a0 08 7f fc and %g1, -4, %l0 } if (allocated_message_size < maximum_message_size) 20140d0: 80 a6 c0 10 cmp %i3, %l0 20140d4: 18 80 00 09 bgu 20140f8 <_CORE_message_queue_Initialize+0x54> 20140d8: 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 * 20140dc: b6 04 20 14 add %l0, 0x14, %i3 20140e0: 92 10 00 1a mov %i2, %o1 20140e4: 40 00 42 4c call 2024a14 <.umul> 20140e8: 90 10 00 1b mov %i3, %o0 (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 20140ec: 80 a2 00 10 cmp %o0, %l0 20140f0: 1a 80 00 04 bcc 2014100 <_CORE_message_queue_Initialize+0x5c> 20140f4: 92 10 00 08 mov %o0, %o1 STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return TRUE; } 20140f8: 81 c7 e0 08 ret <== NOT EXECUTED 20140fc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 2014100: 11 00 80 c8 sethi %hi(0x2032000), %o0 2014104: 40 00 02 20 call 2014984 <_Heap_Allocate> 2014108: 90 12 22 0c or %o0, 0x20c, %o0 ! 203220c <_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) 201410c: 80 a2 20 00 cmp %o0, 0 2014110: 02 bf ff fa be 20140f8 <_CORE_message_queue_Initialize+0x54> 2014114: d0 26 20 5c st %o0, [ %i0 + 0x5c ] /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 2014118: 92 10 00 08 mov %o0, %o1 201411c: 94 10 00 1a mov %i2, %o2 2014120: 90 06 20 68 add %i0, 0x68, %o0 2014124: 7f ff ff 7b call 2013f10 <_Chain_Initialize> 2014128: 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( 201412c: c2 06 40 00 ld [ %i1 ], %g1 2014130: 84 06 20 50 add %i0, 0x50, %g2 2014134: 82 18 60 01 xor %g1, 1, %g1 2014138: 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); 201413c: 82 06 20 54 add %i0, 0x54, %g1 the_chain->permanent_null = NULL; 2014140: c0 26 20 54 clr [ %i0 + 0x54 ] 2014144: 90 10 00 18 mov %i0, %o0 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2014148: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 201414c: c4 26 20 58 st %g2, [ %i0 + 0x58 ] 2014150: 92 60 3f ff subx %g0, -1, %o1 2014154: 94 10 20 80 mov 0x80, %o2 2014158: 96 10 20 06 mov 6, %o3 201415c: 40 00 0c dc call 20174cc <_Thread_queue_Initialize> 2014160: b0 10 20 01 mov 1, %i0 2014164: 81 c7 e0 08 ret 2014168: 81 e8 00 00 restore 020194d8 <_CORE_message_queue_Insert_message>: void _CORE_message_queue_Insert_message( CORE_message_queue_Control *the_message_queue, CORE_message_queue_Buffer_control *the_message, CORE_message_queue_Submit_types submit_type ) { 20194d8: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; boolean notify = FALSE; the_message->priority = submit_type; switch ( submit_type ) { 20194dc: 03 20 00 00 sethi %hi(0x80000000), %g1 20194e0: 80 a6 80 01 cmp %i2, %g1 20194e4: 02 80 00 40 be 20195e4 <_CORE_message_queue_Insert_message+0x10c> 20194e8: f4 26 60 08 st %i2, [ %i1 + 8 ] 20194ec: 82 00 7c 00 add %g1, -1024, %g1 20194f0: 82 10 63 ff or %g1, 0x3ff, %g1 20194f4: 80 a6 80 01 cmp %i2, %g1 20194f8: 02 80 00 29 be 201959c <_CORE_message_queue_Insert_message+0xc4> 20194fc: 84 06 20 54 add %i0, 0x54, %g2 CORE_message_queue_Buffer_control *this_message; Chain_Node *the_node; Chain_Control *the_header; the_header = &the_message_queue->Pending_messages; the_node = the_header->first; 2019500: e0 06 20 50 ld [ %i0 + 0x50 ], %l0 <== NOT EXECUTED while ( !_Chain_Is_tail( the_header, the_node ) ) { 2019504: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 2019508: 32 80 00 21 bne,a 201958c <_CORE_message_queue_Insert_message+0xb4> <== NOT EXECUTED 201950c: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 2019510: 7f ff a4 3d call 2002604 <== NOT EXECUTED 2019514: 01 00 00 00 nop <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) notify = TRUE; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 2019518: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED } break; } _ISR_Disable( level ); if ( the_message_queue->number_of_pending_messages++ == 0 ) 201951c: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 2019520: c6 00 40 00 ld [ %g1 ], %g3 <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 2019524: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; 2019528: f2 20 40 00 st %i1, [ %g1 ] <== NOT EXECUTED 201952c: 84 00 a0 01 inc %g2 <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 2019530: f2 20 e0 04 st %i1, [ %g3 + 4 ] <== NOT EXECUTED 2019534: 82 18 a0 01 xor %g2, 1, %g1 <== NOT EXECUTED Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 2019538: c6 26 40 00 st %g3, [ %i1 ] <== NOT EXECUTED 201953c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 2019540: c4 26 20 48 st %g2, [ %i0 + 0x48 ] <== NOT EXECUTED 2019544: a0 60 3f ff subx %g0, -1, %l0 <== NOT EXECUTED notify = TRUE; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); _ISR_Enable( level ); 2019548: 7f ff a4 33 call 2002614 <== NOT EXECUTED 201954c: 01 00 00 00 nop <== NOT EXECUTED * According to POSIX, does this happen before or after the message * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) 2019550: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2019554: 02 80 00 08 be 2019574 <_CORE_message_queue_Insert_message+0x9c> 2019558: 01 00 00 00 nop 201955c: c2 06 20 60 ld [ %i0 + 0x60 ], %g1 2019560: 80 a0 60 00 cmp %g1, 0 2019564: 02 80 00 04 be 2019574 <_CORE_message_queue_Insert_message+0x9c> 2019568: 01 00 00 00 nop (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 201956c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2019570: d0 06 20 64 ld [ %i0 + 0x64 ], %o0 <== NOT EXECUTED 2019574: 81 c7 e0 08 ret 2019578: 81 e8 00 00 restore Chain_Node *the_node; Chain_Control *the_header; the_header = &the_message_queue->Pending_messages; the_node = the_header->first; while ( !_Chain_Is_tail( the_header, the_node ) ) { 201957c: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 2019580: 02 bf ff e4 be 2019510 <_CORE_message_queue_Insert_message+0x38> <== NOT EXECUTED 2019584: 01 00 00 00 nop <== NOT EXECUTED this_message = (CORE_message_queue_Buffer_control *) the_node; if ( this_message->priority <= the_message->priority ) { 2019588: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 201958c: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED 2019590: 36 bf ff fb bge,a 201957c <_CORE_message_queue_Insert_message+0xa4> <== NOT EXECUTED 2019594: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED 2019598: 30 bf ff de b,a 2019510 <_CORE_message_queue_Insert_message+0x38> <== NOT EXECUTED the_message->priority = submit_type; switch ( submit_type ) { case CORE_MESSAGE_QUEUE_SEND_REQUEST: _ISR_Disable( level ); 201959c: 7f ff a4 1a call 2002604 20195a0: 01 00 00 00 nop if ( the_message_queue->number_of_pending_messages++ == 0 ) 20195a4: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 20195a8: 82 06 20 54 add %i0, 0x54, %g1 20195ac: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 20195b0: c6 06 20 58 ld [ %i0 + 0x58 ], %g3 the_chain->last = the_node; 20195b4: f2 26 20 58 st %i1, [ %i0 + 0x58 ] 20195b8: 84 00 a0 01 inc %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 20195bc: c6 26 60 04 st %g3, [ %i1 + 4 ] 20195c0: 82 18 a0 01 xor %g2, 1, %g1 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; 20195c4: f2 20 c0 00 st %i1, [ %g3 ] 20195c8: 80 a0 00 01 cmp %g0, %g1 20195cc: c4 26 20 48 st %g2, [ %i0 + 0x48 ] 20195d0: a0 60 3f ff subx %g0, -1, %l0 notify = TRUE; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 20195d4: 7f ff a4 10 call 2002614 20195d8: 01 00 00 00 nop * According to POSIX, does this happen before or after the message * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) 20195dc: 10 bf ff de b 2019554 <_CORE_message_queue_Insert_message+0x7c> 20195e0: 80 a4 20 00 cmp %l0, 0 notify = TRUE; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); break; case CORE_MESSAGE_QUEUE_URGENT_REQUEST: _ISR_Disable( level ); 20195e4: 7f ff a4 08 call 2002604 20195e8: 01 00 00 00 nop ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 20195ec: c6 06 20 50 ld [ %i0 + 0x50 ], %g3 if ( the_message_queue->number_of_pending_messages++ == 0 ) 20195f0: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 20195f4: 82 06 20 50 add %i0, 0x50, %g1 { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; 20195f8: f2 26 20 50 st %i1, [ %i0 + 0x50 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 20195fc: c2 26 60 04 st %g1, [ %i1 + 4 ] 2019600: 84 00 a0 01 inc %g2 before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; before_node->previous = the_node; 2019604: f2 20 e0 04 st %i1, [ %g3 + 4 ] 2019608: 82 18 a0 01 xor %g2, 1, %g1 Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 201960c: c6 26 40 00 st %g3, [ %i1 ] 2019610: 80 a0 00 01 cmp %g0, %g1 2019614: c4 26 20 48 st %g2, [ %i0 + 0x48 ] 2019618: a0 60 3f ff subx %g0, -1, %l0 notify = TRUE; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 201961c: 7f ff a3 fe call 2002614 2019620: 01 00 00 00 nop * According to POSIX, does this happen before or after the message * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) 2019624: 10 bf ff cc b 2019554 <_CORE_message_queue_Insert_message+0x7c> 2019628: 80 a4 20 00 cmp %l0, 0 020164fc <_CORE_message_queue_Seize>: void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 20164fc: 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; 2016500: 25 00 80 a8 sethi %hi(0x202a000), %l2 2016504: e2 04 a0 20 ld [ %l2 + 0x20 ], %l1 ! 202a020 <_Thread_Executing> void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 2016508: 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 ); 201650c: 7f ff b0 3e call 2002604 2016510: c0 24 60 34 clr [ %l1 + 0x34 ] 2016514: 88 10 00 08 mov %o0, %g4 if ( the_message_queue->number_of_pending_messages != 0 ) { 2016518: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 201651c: 80 a0 60 00 cmp %g1, 0 2016520: 02 80 00 23 be 20165ac <_CORE_message_queue_Seize+0xb0> 2016524: 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)); 2016528: c6 06 20 50 ld [ %i0 + 0x50 ], %g3 the_message_queue->number_of_pending_messages -= 1; 201652c: 82 00 7f ff add %g1, -1, %g1 2016530: 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)) 2016534: 84 06 20 54 add %i0, 0x54, %g2 2016538: 80 a0 c0 02 cmp %g3, %g2 201653c: 12 80 00 24 bne 20165cc <_CORE_message_queue_Seize+0xd0> 2016540: b2 10 20 00 clr %i1 the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); 2016544: 7f ff b0 34 call 2002614 2016548: 90 10 00 04 mov %g4, %o0 *size = the_message->Contents.size; 201654c: d4 06 60 0c ld [ %i1 + 0xc ], %o2 _Thread_Executing->Wait.count = the_message->priority; 2016550: c4 04 a0 20 ld [ %l2 + 0x20 ], %g2 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; 2016554: d4 26 c0 00 st %o2, [ %i3 ] _Thread_Executing->Wait.count = the_message->priority; 2016558: c2 06 60 08 ld [ %i1 + 8 ], %g1 201655c: a2 06 60 10 add %i1, 0x10, %l1 2016560: c2 20 a0 24 st %g1, [ %g2 + 0x24 ] const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 2016564: 92 10 00 11 mov %l1, %o1 2016568: 40 00 13 21 call 201b1ec 201656c: 90 10 00 1a mov %i2, %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 ); 2016570: 7f ff e8 f5 call 2010944 <_Thread_queue_Dequeue> 2016574: 90 10 00 10 mov %l0, %o0 if ( !the_thread ) { 2016578: 80 a2 20 00 cmp %o0, 0 201657c: 02 80 00 24 be 201660c <_CORE_message_queue_Seize+0x110> 2016580: 01 00 00 00 nop * puts the messages in the message queue on behalf of the * waiting task. */ the_message->priority = the_thread->Wait.count; the_message->Contents.size = (uint32_t)the_thread->Wait.option; 2016584: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== NOT EXECUTED * 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; 2016588: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED 201658c: d2 02 20 28 ld [ %o0 + 0x28 ], %o1 <== NOT EXECUTED the_message->Contents.size = (uint32_t)the_thread->Wait.option; 2016590: d4 26 60 0c st %o2, [ %i1 + 0xc ] <== NOT EXECUTED * 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; 2016594: c2 26 60 08 st %g1, [ %i1 + 8 ] <== NOT EXECUTED 2016598: 40 00 13 15 call 201b1ec <== NOT EXECUTED 201659c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED the_thread->Wait.return_argument, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 20165a0: f4 06 60 08 ld [ %i1 + 8 ], %i2 <== NOT EXECUTED 20165a4: 40 00 0b cd call 20194d8 <_CORE_message_queue_Insert_message> <== NOT EXECUTED 20165a8: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 20165ac: 12 80 00 0e bne 20165e4 <_CORE_message_queue_Seize+0xe8> 20165b0: 82 10 20 01 mov 1, %g1 _ISR_Enable( level ); 20165b4: 7f ff b0 18 call 2002614 20165b8: 01 00 00 00 nop executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 20165bc: 82 10 20 04 mov 4, %g1 ! 4 20165c0: 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 ); } 20165c4: 81 c7 e0 08 ret 20165c8: 81 e8 00 00 restore { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 20165cc: c4 00 c0 00 ld [ %g3 ], %g2 the_chain->first = new_first; new_first->previous = _Chain_Head(the_chain); 20165d0: 82 06 20 50 add %i0, 0x50, %g1 Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; 20165d4: c4 26 20 50 st %g2, [ %i0 + 0x50 ] new_first->previous = _Chain_Head(the_chain); 20165d8: b2 10 00 03 mov %g3, %i1 20165dc: 10 bf ff da b 2016544 <_CORE_message_queue_Seize+0x48> 20165e0: c2 20 a0 04 st %g1, [ %g2 + 4 ] _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; 20165e4: 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; 20165e8: f0 24 60 44 st %i0, [ %l1 + 0x44 ] executing->Wait.id = id; 20165ec: f2 24 60 20 st %i1, [ %l1 + 0x20 ] executing->Wait.return_argument = buffer; 20165f0: 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; 20165f4: 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 ); 20165f8: 7f ff b0 07 call 2002614 20165fc: 35 00 80 44 sethi %hi(0x2011000), %i2 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 2016600: b2 10 00 1d mov %i5, %i1 2016604: 7f ff e9 3e call 2010afc <_Thread_queue_Enqueue_with_handler> 2016608: 95 ee a0 3c restore %i2, 0x3c, %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 ); 201660c: 7f ff de 58 call 200df6c <_Chain_Append> 2016610: 91 ec 20 68 restore %l0, 0x68, %o0 2016614: 01 00 00 00 nop 02016618 <_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 ) { 2016618: 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 ) { 201661c: 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 ) { 2016620: 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 ) { 2016624: 80 a0 40 1a cmp %g1, %i2 2016628: 0a 80 00 22 bcs 20166b0 <_CORE_message_queue_Submit+0x98> 201662c: 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 ) { 2016630: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 2016634: 80 a0 a0 00 cmp %g2, 0 2016638: 02 80 00 22 be 20166c0 <_CORE_message_queue_Submit+0xa8> 201663c: 01 00 00 00 nop /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 2016640: c2 04 60 44 ld [ %l1 + 0x44 ], %g1 2016644: 80 a0 40 02 cmp %g1, %g2 2016648: 18 80 00 2b bgu 20166f4 <_CORE_message_queue_Submit+0xdc> 201664c: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { 2016650: 80 a0 60 00 cmp %g1, 0 2016654: 02 80 00 17 be 20166b0 <_CORE_message_queue_Submit+0x98> 2016658: 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() ) { 201665c: 03 00 80 a8 sethi %hi(0x202a000), %g1 <== NOT EXECUTED 2016660: c4 00 60 08 ld [ %g1 + 8 ], %g2 ! 202a008 <_ISR_Nest_level> <== NOT EXECUTED 2016664: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2016668: 12 80 00 14 bne 20166b8 <_CORE_message_queue_Submit+0xa0> <== NOT EXECUTED 201666c: 03 00 80 a8 sethi %hi(0x202a000), %g1 <== NOT EXECUTED */ { Thread_Control *executing = _Thread_Executing; _ISR_Disable( level ); 2016670: 7f ff af e5 call 2002604 <== NOT EXECUTED 2016674: e0 00 60 20 ld [ %g1 + 0x20 ], %l0 ! 202a020 <_Thread_Executing> <== NOT EXECUTED 2016678: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED _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; 201667c: fa 24 20 24 st %i5, [ %l0 + 0x24 ] <== NOT EXECUTED 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; 2016680: f6 24 20 20 st %i3, [ %l0 + 0x20 ] <== NOT EXECUTED executing->Wait.return_argument = buffer; 2016684: f2 24 20 28 st %i1, [ %l0 + 0x28 ] <== NOT EXECUTED executing->Wait.option = size; 2016688: f4 24 20 30 st %i2, [ %l0 + 0x30 ] <== NOT EXECUTED { 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; 201668c: e2 24 20 44 st %l1, [ %l0 + 0x44 ] <== NOT EXECUTED 2016690: c2 24 60 30 st %g1, [ %l1 + 0x30 ] <== NOT EXECUTED executing->Wait.id = id; executing->Wait.return_argument = buffer; executing->Wait.option = size; executing->Wait.count = submit_type; _ISR_Enable( level ); 2016694: 7f ff af e0 call 2002614 <== NOT EXECUTED 2016698: b0 10 20 07 mov 7, %i0 <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 201669c: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 <== NOT EXECUTED 20166a0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20166a4: 15 00 80 44 sethi %hi(0x2011000), %o2 <== NOT EXECUTED 20166a8: 7f ff e9 15 call 2010afc <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 20166ac: 94 12 a0 3c or %o2, 0x3c, %o2 ! 201103c <_Thread_queue_Timeout> <== NOT EXECUTED 20166b0: 81 c7 e0 08 ret 20166b4: 81 e8 00 00 restore } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 20166b8: 81 c7 e0 08 ret <== NOT EXECUTED 20166bc: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 20166c0: 7f ff e8 a1 call 2010944 <_Thread_queue_Dequeue> 20166c4: 90 10 00 11 mov %l1, %o0 if ( the_thread ) { 20166c8: a0 92 20 00 orcc %o0, 0, %l0 20166cc: 02 80 00 1b be 2016738 <_CORE_message_queue_Submit+0x120> 20166d0: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 20166d4: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 20166d8: 40 00 12 c5 call 201b1ec 20166dc: 94 10 00 1a mov %i2, %o2 _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument, size ); *(size_t *)the_thread->Wait.return_argument_1 = size; 20166e0: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 the_thread->Wait.count = submit_type; 20166e4: 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; 20166e8: f4 20 40 00 st %i2, [ %g1 ] the_thread->Wait.count = submit_type; 20166ec: 81 c7 e0 08 ret 20166f0: 91 e8 20 00 restore %g0, 0, %o0 RTEMS_INLINE_ROUTINE CORE_message_queue_Buffer_control * _CORE_message_queue_Allocate_message_buffer ( CORE_message_queue_Control *the_message_queue ) { return (CORE_message_queue_Buffer_control *) 20166f4: 7f ff de 2a call 200df9c <_Chain_Get> 20166f8: 90 04 60 68 add %l1, 0x68, %o0 /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 20166fc: a0 92 20 00 orcc %o0, 0, %l0 2016700: 02 bf ff ee be 20166b8 <_CORE_message_queue_Submit+0xa0> 2016704: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 2016708: 94 10 00 1a mov %i2, %o2 201670c: 40 00 12 b8 call 201b1ec 2016710: 90 04 20 10 add %l0, 0x10, %o0 size ); the_message->Contents.size = size; the_message->priority = submit_type; _CORE_message_queue_Insert_message( 2016714: 90 10 00 11 mov %l1, %o0 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 2016718: f4 24 20 0c st %i2, [ %l0 + 0xc ] the_message->priority = submit_type; 201671c: fa 24 20 08 st %i5, [ %l0 + 8 ] _CORE_message_queue_Insert_message( 2016720: 92 10 00 10 mov %l0, %o1 2016724: 94 10 00 1d mov %i5, %o2 2016728: 40 00 0b 6c call 20194d8 <_CORE_message_queue_Insert_message> 201672c: b0 10 20 00 clr %i0 2016730: 81 c7 e0 08 ret 2016734: 81 e8 00 00 restore * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); if ( the_thread ) { 2016738: 10 bf ff c2 b 2016640 <_CORE_message_queue_Submit+0x28> 201673c: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 02006da0 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 2006da0: 9d e3 bf 98 save %sp, -104, %sp /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006da4: c2 06 40 00 ld [ %i1 ], %g1 CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 2006da8: 90 10 00 18 mov %i0, %o0 /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006dac: c2 26 20 40 st %g1, [ %i0 + 0x40 ] 2006db0: c4 06 60 04 ld [ %i1 + 4 ], %g2 the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 2006db4: 80 a6 a0 00 cmp %i2, 0 /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006db8: c4 26 20 44 st %g2, [ %i0 + 0x44 ] 2006dbc: c8 06 60 08 ld [ %i1 + 8 ], %g4 2006dc0: c8 26 20 48 st %g4, [ %i0 + 0x48 ] 2006dc4: da 06 60 0c ld [ %i1 + 0xc ], %o5 the_mutex->lock = initial_lock; 2006dc8: f4 26 20 50 st %i2, [ %i0 + 0x50 ] /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006dcc: da 26 20 4c st %o5, [ %i0 + 0x4c ] the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 2006dd0: 12 80 00 1c bne 2006e40 <_CORE_mutex_Initialize+0xa0> 2006dd4: c0 26 20 58 clr [ %i0 + 0x58 ] the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; 2006dd8: 19 00 80 62 sethi %hi(0x2018800), %o4 2006ddc: c6 03 20 c0 ld [ %o4 + 0xc0 ], %g3 ! 20188c0 <_Thread_Executing> the_mutex->Attributes = *the_mutex_attributes; the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; 2006de0: 82 10 20 01 mov 1, %g1 2006de4: c2 26 20 54 st %g1, [ %i0 + 0x54 ] the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; 2006de8: c4 00 e0 08 ld [ %g3 + 8 ], %g2 the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; 2006dec: c6 26 20 5c st %g3, [ %i0 + 0x5c ] the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2006df0: 80 a1 20 02 cmp %g4, 2 2006df4: 12 80 00 1f bne 2006e70 <_CORE_mutex_Initialize+0xd0> 2006df8: c4 26 20 60 st %g2, [ %i0 + 0x60 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < 2006dfc: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 2006e00: 80 a0 40 0d cmp %g1, %o5 2006e04: 0a 80 00 0d bcs 2006e38 <_CORE_mutex_Initialize+0x98> 2006e08: b0 10 20 06 mov 6, %i0 the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 2006e0c: c4 03 20 c0 ld [ %o4 + 0xc0 ], %g2 the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 2006e10: 94 10 24 00 mov 0x400, %o2 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 2006e14: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 2006e18: 96 10 20 05 mov 5, %o3 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 2006e1c: 82 00 60 01 inc %g1 2006e20: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 2006e24: c2 06 60 08 ld [ %i1 + 8 ], %g1 2006e28: b0 10 20 00 clr %i0 2006e2c: 80 a0 00 01 cmp %g0, %g1 2006e30: 40 00 0b 95 call 2009c84 <_Thread_queue_Initialize> 2006e34: 92 40 20 00 addx %g0, 0, %o1 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 2006e38: 81 c7 e0 08 ret 2006e3c: 81 e8 00 00 restore the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 2006e40: c2 06 60 08 ld [ %i1 + 8 ], %g1 if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; } else { the_mutex->nest_count = 0; 2006e44: c0 26 20 54 clr [ %i0 + 0x54 ] the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 2006e48: 80 a0 00 01 cmp %g0, %g1 the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; } else { the_mutex->nest_count = 0; the_mutex->holder = NULL; 2006e4c: c0 26 20 5c clr [ %i0 + 0x5c ] the_mutex->holder_id = 0; 2006e50: c0 26 20 60 clr [ %i0 + 0x60 ] } _Thread_queue_Initialize( 2006e54: 92 40 20 00 addx %g0, 0, %o1 2006e58: 94 10 24 00 mov 0x400, %o2 2006e5c: 96 10 20 05 mov 5, %o3 2006e60: 40 00 0b 89 call 2009c84 <_Thread_queue_Initialize> 2006e64: b0 10 20 00 clr %i0 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 2006e68: 81 c7 e0 08 ret 2006e6c: 81 e8 00 00 restore if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2006e70: 80 a1 20 03 cmp %g4, 3 2006e74: 32 bf ff e7 bne,a 2006e10 <_CORE_mutex_Initialize+0x70> 2006e78: c4 03 20 c0 ld [ %o4 + 0xc0 ], %g2 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < 2006e7c: 10 bf ff e1 b 2006e00 <_CORE_mutex_Initialize+0x60> <== NOT EXECUTED 2006e80: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED 02006e84 <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 2006e84: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 2006e88: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 Watchdog_Interval timeout ) { Thread_Control *executing; executing = _Thread_Executing; 2006e8c: 03 00 80 62 sethi %hi(0x2018800), %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 2006e90: 80 a0 a0 02 cmp %g2, 2 2006e94: 12 80 00 08 bne 2006eb4 <_CORE_mutex_Seize_interrupt_blocking+0x30> 2006e98: d2 00 60 c0 ld [ %g1 + 0xc0 ], %o1 if ( the_mutex->holder->current_priority > executing->current_priority ) { 2006e9c: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 2006ea0: d2 02 60 14 ld [ %o1 + 0x14 ], %o1 2006ea4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2006ea8: 80 a0 40 09 cmp %g1, %o1 2006eac: 18 80 00 16 bgu 2006f04 <_CORE_mutex_Seize_interrupt_blocking+0x80> 2006eb0: 01 00 00 00 nop FALSE ); } } the_mutex->blocked_count++; 2006eb4: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 2006eb8: 90 10 00 18 mov %i0, %o0 FALSE ); } } the_mutex->blocked_count++; 2006ebc: 82 00 60 01 inc %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 2006ec0: 92 10 00 19 mov %i1, %o1 FALSE ); } } the_mutex->blocked_count++; 2006ec4: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 2006ec8: 15 00 80 27 sethi %hi(0x2009c00), %o2 2006ecc: 40 00 0a 60 call 200984c <_Thread_queue_Enqueue_with_handler> 2006ed0: 94 12 a1 8c or %o2, 0x18c, %o2 ! 2009d8c <_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 ) 2006ed4: 05 00 80 61 sethi %hi(0x2018400), %g2 2006ed8: c2 00 a3 e0 ld [ %g2 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> 2006edc: 82 00 7f ff add %g1, -1, %g1 2006ee0: c2 20 a3 e0 st %g1, [ %g2 + 0x3e0 ] 2006ee4: c6 00 a3 e0 ld [ %g2 + 0x3e0 ], %g3 2006ee8: 80 a0 e0 00 cmp %g3, 0 2006eec: 02 80 00 04 be 2006efc <_CORE_mutex_Seize_interrupt_blocking+0x78> 2006ef0: 01 00 00 00 nop 2006ef4: 81 c7 e0 08 ret <== NOT EXECUTED 2006ef8: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 2006efc: 40 00 08 bb call 20091e8 <_Thread_Dispatch> 2006f00: 81 e8 00 00 restore Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { if ( the_mutex->holder->current_priority > executing->current_priority ) { _Thread_Change_priority( 2006f04: 40 00 07 89 call 2008d28 <_Thread_Change_priority> 2006f08: 94 10 20 00 clr %o2 FALSE ); } } the_mutex->blocked_count++; 2006f0c: 10 bf ff eb b 2006eb8 <_CORE_mutex_Seize_interrupt_blocking+0x34> 2006f10: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 02006f14 <_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 ) { 2006f14: 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 ) { 2006f18: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 CORE_mutex_Status _CORE_mutex_Surrender( CORE_mutex_Control *the_mutex, Objects_Id id, CORE_mutex_API_mp_support_callout api_mutex_mp_support ) { 2006f1c: a0 10 00 18 mov %i0, %l0 * allowed when the mutex in quetion is FIFO or simple Priority * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) { 2006f20: 80 a0 60 00 cmp %g1, 0 2006f24: 02 80 00 07 be 2006f40 <_CORE_mutex_Surrender+0x2c> 2006f28: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 if ( !_Thread_Is_executing( holder ) ) 2006f2c: 03 00 80 62 sethi %hi(0x2018800), %g1 2006f30: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 20188c0 <_Thread_Executing> 2006f34: 80 a2 00 02 cmp %o0, %g2 2006f38: 12 80 00 49 bne 200705c <_CORE_mutex_Surrender+0x148> 2006f3c: b0 10 20 03 mov 3, %i0 return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 2006f40: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 2006f44: 80 a0 60 00 cmp %g1, 0 2006f48: 22 80 00 45 be,a 200705c <_CORE_mutex_Surrender+0x148> 2006f4c: b0 10 20 00 clr %i0 return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 2006f50: 82 00 7f ff add %g1, -1, %g1 if ( the_mutex->nest_count != 0 ) { 2006f54: 80 a0 60 00 cmp %g1, 0 2006f58: 02 80 00 09 be 2006f7c <_CORE_mutex_Surrender+0x68> 2006f5c: c2 24 20 54 st %g1, [ %l0 + 0x54 ] switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2006f60: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 2006f64: 80 a0 60 00 cmp %g1, 0 2006f68: 02 80 00 3d be 200705c <_CORE_mutex_Surrender+0x148> 2006f6c: b0 10 20 00 clr %i0 2006f70: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2006f74: 02 80 00 3a be 200705c <_CORE_mutex_Surrender+0x148> <== NOT EXECUTED 2006f78: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 2006f7c: c4 04 20 48 ld [ %l0 + 0x48 ], %g2 /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2006f80: 80 a0 a0 02 cmp %g2, 2 2006f84: 22 80 00 2a be,a 200702c <_CORE_mutex_Surrender+0x118> 2006f88: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006f8c: 80 a0 a0 03 cmp %g2, 3 2006f90: 22 80 00 27 be,a 200702c <_CORE_mutex_Surrender+0x118> 2006f94: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; the_mutex->holder = NULL; 2006f98: c0 24 20 5c clr [ %l0 + 0x5c ] /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2006f9c: 80 a0 a0 02 cmp %g2, 2 2006fa0: 02 80 00 17 be 2006ffc <_CORE_mutex_Surrender+0xe8> 2006fa4: c0 24 20 60 clr [ %l0 + 0x60 ] 2006fa8: 80 a0 a0 03 cmp %g2, 3 2006fac: 22 80 00 15 be,a 2007000 <_CORE_mutex_Surrender+0xec> 2006fb0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED /* * 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 ) ) ) { 2006fb4: 40 00 09 b8 call 2009694 <_Thread_queue_Dequeue> 2006fb8: 90 10 00 10 mov %l0, %o0 2006fbc: 86 92 20 00 orcc %o0, 0, %g3 2006fc0: 02 80 00 2e be 2007078 <_CORE_mutex_Surrender+0x164> 2006fc4: 82 10 20 01 mov 1, %g1 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 2006fc8: c2 00 e0 08 ld [ %g3 + 8 ], %g1 the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 2006fcc: c4 04 20 48 ld [ %l0 + 0x48 ], %g2 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 2006fd0: c2 24 20 60 st %g1, [ %l0 + 0x60 ] } else #endif { the_mutex->holder = the_thread; 2006fd4: c6 24 20 5c st %g3, [ %l0 + 0x5c ] the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; 2006fd8: 82 10 20 01 mov 1, %g1 switch ( the_mutex->Attributes.discipline ) { 2006fdc: 80 a0 a0 02 cmp %g2, 2 2006fe0: 02 80 00 21 be 2007064 <_CORE_mutex_Surrender+0x150> 2006fe4: c2 24 20 54 st %g1, [ %l0 + 0x54 ] 2006fe8: 80 a0 a0 03 cmp %g2, 3 2006fec: 22 80 00 13 be,a 2007038 <_CORE_mutex_Surrender+0x124> 2006ff0: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 2006ff4: 81 c7 e0 08 ret 2006ff8: 91 e8 20 00 restore %g0, 0, %o0 * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( holder->resource_count == 0 && 2006ffc: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2007000: 80 a0 60 00 cmp %g1, 0 2007004: 12 bf ff ec bne 2006fb4 <_CORE_mutex_Surrender+0xa0> 2007008: 01 00 00 00 nop 200700c: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 2007010: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2007014: 80 a2 40 01 cmp %o1, %g1 2007018: 02 bf ff e7 be 2006fb4 <_CORE_mutex_Surrender+0xa0> 200701c: 01 00 00 00 nop holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 2007020: 40 00 07 42 call 2008d28 <_Thread_Change_priority> 2007024: 94 10 20 01 mov 1, %o2 ! 1 2007028: 30 bf ff e3 b,a 2006fb4 <_CORE_mutex_Surrender+0xa0> * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; 200702c: 82 00 7f ff add %g1, -1, %g1 2007030: 10 bf ff da b 2006f98 <_CORE_mutex_Surrender+0x84> 2007034: c2 22 20 1c st %g1, [ %o0 + 0x1c ] case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; if (the_mutex->Attributes.priority_ceiling < 2007038: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2 <== NOT EXECUTED break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; 200703c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007040: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 2007044: d2 04 20 4c ld [ %l0 + 0x4c ], %o1 <== NOT EXECUTED 2007048: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED 200704c: 1a 80 00 04 bcc 200705c <_CORE_mutex_Surrender+0x148> <== NOT EXECUTED 2007050: b0 10 20 00 clr %i0 <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 2007054: 40 00 07 35 call 2008d28 <_Thread_Change_priority> <== NOT EXECUTED 2007058: 94 10 20 00 clr %o2 <== NOT EXECUTED 200705c: 81 c7 e0 08 ret 2007060: 81 e8 00 00 restore switch ( the_mutex->Attributes.discipline ) { case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; 2007064: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2007068: 82 00 60 01 inc %g1 200706c: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] 2007070: 81 c7 e0 08 ret 2007074: 91 e8 20 00 restore %g0, 0, %o0 } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 2007078: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 200707c: 81 c7 e0 08 ret 2007080: 91 e8 20 00 restore %g0, 0, %o0 0200cd70 <_Debug_Is_enabled>: */ boolean _Debug_Is_enabled( rtems_debug_control level ) { 200cd70: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200cd74: c4 00 60 c4 ld [ %g1 + 0xc4 ], %g2 ! 20188c4 <_Debug_Level> <== NOT EXECUTED 200cd78: 90 0a 00 02 and %o0, %g2, %o0 <== NOT EXECUTED return (_Debug_Level & level) ? TRUE : FALSE; } 200cd7c: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 200cd80: 81 c3 e0 08 retl <== NOT EXECUTED 200cd84: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED 02005548 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 2005548: 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; 200554c: 03 00 80 62 sethi %hi(0x2018800), %g1 2005550: e0 00 60 c0 ld [ %g1 + 0xc0 ], %l0 ! 20188c0 <_Thread_Executing> executing->Wait.return_code = RTEMS_SUCCESSFUL; 2005554: c0 24 20 34 clr [ %l0 + 0x34 ] api = executing->API_Extensions[ THREAD_API_RTEMS ]; _ISR_Disable( level ); 2005558: 7f ff f2 22 call 2001de0 200555c: e4 04 21 70 ld [ %l0 + 0x170 ], %l2 2005560: 84 10 00 08 mov %o0, %g2 pending_events = api->pending_events; 2005564: c2 04 a0 40 ld [ %l2 + 0x40 ], %g1 seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 2005568: a2 8e 00 01 andcc %i0, %g1, %l1 200556c: 02 80 00 0e be 20055a4 <_Event_Seize+0x5c> 2005570: 80 8e 60 01 btst 1, %i1 2005574: 80 a6 00 11 cmp %i0, %l1 2005578: 02 80 00 04 be 2005588 <_Event_Seize+0x40> 200557c: 80 8e 60 02 btst 2, %i1 2005580: 02 80 00 09 be 20055a4 <_Event_Seize+0x5c> 2005584: 80 8e 60 01 btst 1, %i1 (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 2005588: 82 28 40 11 andn %g1, %l1, %g1 200558c: c2 24 a0 40 st %g1, [ %l2 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 2005590: 7f ff f2 18 call 2001df0 2005594: 01 00 00 00 nop *event_out = seized_events; 2005598: e2 26 c0 00 st %l1, [ %i3 ] 200559c: 81 c7 e0 08 ret 20055a0: 81 e8 00 00 restore return; } if ( _Options_Is_no_wait( option_set ) ) { 20055a4: 12 80 00 1e bne 200561c <_Event_Seize+0xd4> 20055a8: 82 10 20 01 mov 1, %g1 executing->Wait.return_code = RTEMS_UNSATISFIED; *event_out = seized_events; return; } _Event_Sync_state = EVENT_SYNC_NOTHING_HAPPENED; 20055ac: 23 00 80 62 sethi %hi(0x2018800), %l1 executing->Wait.option = (uint32_t ) option_set; 20055b0: f2 24 20 30 st %i1, [ %l0 + 0x30 ] executing->Wait.count = (uint32_t ) event_in; 20055b4: f0 24 20 24 st %i0, [ %l0 + 0x24 ] executing->Wait.return_argument = event_out; 20055b8: 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; 20055bc: c2 24 62 f4 st %g1, [ %l1 + 0x2f4 ] executing->Wait.option = (uint32_t ) option_set; executing->Wait.count = (uint32_t ) event_in; executing->Wait.return_argument = event_out; _ISR_Enable( level ); 20055c0: 7f ff f2 0c call 2001df0 20055c4: 90 10 00 02 mov %g2, %o0 if ( ticks ) { 20055c8: 80 a6 a0 00 cmp %i2, 0 20055cc: 32 80 00 24 bne,a 200565c <_Event_Seize+0x114> 20055d0: c2 04 20 08 ld [ %l0 + 8 ], %g1 NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 20055d4: 90 10 00 10 mov %l0, %o0 20055d8: 40 00 12 3d call 2009ecc <_Thread_Set_state> 20055dc: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 20055e0: 7f ff f2 00 call 2001de0 20055e4: 01 00 00 00 nop 20055e8: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 20055ec: c4 04 62 f4 ld [ %l1 + 0x2f4 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 20055f0: c0 24 62 f4 clr [ %l1 + 0x2f4 ] switch ( sync_state ) { 20055f4: 80 a0 a0 02 cmp %g2, 2 20055f8: 02 80 00 30 be 20056b8 <_Event_Seize+0x170> 20055fc: 82 10 20 06 mov 6, %g1 2005600: 80 a0 a0 03 cmp %g2, 3 2005604: 02 80 00 0d be 2005638 <_Event_Seize+0xf0> 2005608: 80 a0 a0 01 cmp %g2, 1 200560c: 02 80 00 31 be 20056d0 <_Event_Seize+0x188> 2005610: 01 00 00 00 nop 2005614: 81 c7 e0 08 ret <== NOT EXECUTED 2005618: 81 e8 00 00 restore <== NOT EXECUTED *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 200561c: 7f ff f1 f5 call 2001df0 2005620: 90 10 00 02 mov %g2, %o0 executing->Wait.return_code = RTEMS_UNSATISFIED; 2005624: 82 10 20 0d mov 0xd, %g1 2005628: c2 24 20 34 st %g1, [ %l0 + 0x34 ] *event_out = seized_events; 200562c: e2 26 c0 00 st %l1, [ %i3 ] 2005630: 81 c7 e0 08 ret 2005634: 81 e8 00 00 restore _ISR_Enable( level ); _Thread_Unblock( executing ); return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { 2005638: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 200563c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2005640: 22 80 00 26 be,a 20056d8 <_Event_Seize+0x190> <== NOT EXECUTED 2005644: c4 24 20 50 st %g2, [ %l0 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &executing->Timer ); } else _ISR_Enable( level ); 2005648: 7f ff f1 ea call 2001df0 <== NOT EXECUTED 200564c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2005650: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2005654: 40 00 0e 24 call 2008ee4 <_Thread_Clear_state> <== NOT EXECUTED 2005658: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200565c: 92 04 20 48 add %l0, 0x48, %o1 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 2005660: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2005664: 03 00 80 16 sethi %hi(0x2005800), %g1 2005668: 82 10 61 0c or %g1, 0x10c, %g1 ! 200590c <_Event_Timeout> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200566c: f4 24 20 54 st %i2, [ %l0 + 0x54 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2005670: c2 24 20 64 st %g1, [ %l0 + 0x64 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2005674: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2005678: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200567c: 11 00 80 62 sethi %hi(0x2018800), %o0 2005680: 40 00 14 2f call 200a73c <_Watchdog_Insert> 2005684: 90 12 20 e0 or %o0, 0xe0, %o0 ! 20188e0 <_Watchdog_Ticks_chain> NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 2005688: 90 10 00 10 mov %l0, %o0 200568c: 40 00 12 10 call 2009ecc <_Thread_Set_state> 2005690: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 2005694: 7f ff f1 d3 call 2001de0 2005698: 01 00 00 00 nop 200569c: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 20056a0: c4 04 62 f4 ld [ %l1 + 0x2f4 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 20056a4: c0 24 62 f4 clr [ %l1 + 0x2f4 ] switch ( sync_state ) { 20056a8: 80 a0 a0 02 cmp %g2, 2 20056ac: 12 bf ff d6 bne 2005604 <_Event_Seize+0xbc> 20056b0: 80 a0 a0 03 cmp %g2, 3 case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); return; case EVENT_SYNC_TIMEOUT: executing->Wait.return_code = RTEMS_TIMEOUT; 20056b4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 20056b8: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20056bc: 7f ff f1 cd call 2001df0 <== NOT EXECUTED 20056c0: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 20056c4: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 20056c8: 40 00 0e 07 call 2008ee4 <_Thread_Clear_state> <== NOT EXECUTED 20056cc: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED * enter the synchronization states above. */ return; case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); 20056d0: 7f ff f1 c8 call 2001df0 20056d4: 81 e8 00 00 restore return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); 20056d8: 7f ff f1 c6 call 2001df0 <== NOT EXECUTED 20056dc: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED (void) _Watchdog_Remove( &executing->Timer ); 20056e0: 40 00 14 81 call 200a8e4 <_Watchdog_Remove> <== NOT EXECUTED 20056e4: 90 04 20 48 add %l0, 0x48, %o0 <== NOT EXECUTED 20056e8: 10 bf ff db b 2005654 <_Event_Seize+0x10c> <== NOT EXECUTED 20056ec: b2 16 63 f8 or %i1, 0x3f8, %i1 <== NOT EXECUTED 020057ec <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 20057ec: 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 ]; 20057f0: e0 06 21 70 ld [ %i0 + 0x170 ], %l0 option_set = (rtems_option) the_thread->Wait.option; 20057f4: e4 06 20 30 ld [ %i0 + 0x30 ], %l2 _ISR_Disable( level ); 20057f8: 7f ff f1 7a call 2001de0 20057fc: b2 10 00 18 mov %i0, %i1 2005800: a2 10 00 08 mov %o0, %l1 pending_events = api->pending_events; 2005804: c8 04 20 40 ld [ %l0 + 0x40 ], %g4 event_condition = (rtems_event_set) the_thread->Wait.count; 2005808: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { 200580c: 9a 88 c0 04 andcc %g3, %g4, %o5 2005810: 02 80 00 20 be 2005890 <_Event_Surrender+0xa4> 2005814: 01 00 00 00 nop if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 2005818: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 200581c: 80 88 61 00 btst 0x100, %g1 2005820: 02 80 00 08 be 2005840 <_Event_Surrender+0x54> 2005824: 19 00 80 62 sethi %hi(0x2018800), %o4 if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 2005828: 80 a0 c0 0d cmp %g3, %o5 200582c: 02 80 00 1b be 2005898 <_Event_Surrender+0xac> 2005830: 80 8c a0 02 btst 2, %l2 2005834: 12 80 00 1a bne 200589c <_Event_Surrender+0xb0> 2005838: 82 29 00 0d andn %g4, %o5, %g1 } return; } } switch ( _Event_Sync_state ) { 200583c: 19 00 80 62 sethi %hi(0x2018800), %o4 <== NOT EXECUTED 2005840: c2 03 22 f4 ld [ %o4 + 0x2f4 ], %g1 ! 2018af4 <_Event_Sync_state> <== NOT EXECUTED 2005844: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2005848: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200584c: 18 80 00 11 bgu 2005890 <_Event_Surrender+0xa4> <== NOT EXECUTED 2005850: 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 ) ) 2005854: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 20188c0 <_Thread_Executing> <== NOT EXECUTED 2005858: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED 200585c: 12 80 00 0d bne 2005890 <_Event_Surrender+0xa4> <== NOT EXECUTED 2005860: 80 a0 c0 0d cmp %g3, %o5 <== NOT EXECUTED break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 2005864: 02 80 00 04 be 2005874 <_Event_Surrender+0x88> <== NOT EXECUTED 2005868: 80 8c a0 02 btst 2, %l2 <== NOT EXECUTED 200586c: 02 80 00 09 be 2005890 <_Event_Surrender+0xa4> <== NOT EXECUTED 2005870: 01 00 00 00 nop <== NOT EXECUTED api->pending_events = 2005874: 82 29 00 0d andn %g4, %o5, %g1 <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 2005878: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED case EVENT_SYNC_TIMEOUT: if ( !_Thread_Is_executing( the_thread ) ) break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { api->pending_events = 200587c: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 2005880: c0 26 60 24 clr [ %i1 + 0x24 ] <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; _Event_Sync_state = EVENT_SYNC_SATISFIED; 2005884: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED if ( seized_events == event_condition || _Options_Is_any(option_set) ) { api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 2005888: da 20 80 00 st %o5, [ %g2 ] <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_SATISFIED; 200588c: c2 23 22 f4 st %g1, [ %o4 + 0x2f4 ] <== NOT EXECUTED } break; } } _ISR_Enable( level ); 2005890: 7f ff f1 58 call 2001df0 2005894: 91 e8 00 11 restore %g0, %l1, %o0 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { api->pending_events = 2005898: 82 29 00 0d andn %g4, %o5, %g1 _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 200589c: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { api->pending_events = 20058a0: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 20058a4: c0 26 60 24 clr [ %i1 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 20058a8: da 20 80 00 st %o5, [ %g2 ] _ISR_Flash( level ); 20058ac: 7f ff f1 51 call 2001df0 20058b0: 01 00 00 00 nop 20058b4: 7f ff f1 4b call 2001de0 20058b8: 01 00 00 00 nop if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 20058bc: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 20058c0: 80 a0 60 02 cmp %g1, 2 20058c4: 02 80 00 08 be 20058e4 <_Event_Surrender+0xf8> 20058c8: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 20058cc: 90 10 00 11 mov %l1, %o0 20058d0: 7f ff f1 48 call 2001df0 20058d4: 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 ); 20058d8: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 20058dc: 40 00 0d 82 call 2008ee4 <_Thread_Clear_state> 20058e0: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 20058e4: c2 26 60 50 st %g1, [ %i1 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 20058e8: 7f ff f1 42 call 2001df0 20058ec: 90 10 00 11 mov %l1, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 20058f0: 40 00 13 fd call 200a8e4 <_Watchdog_Remove> 20058f4: 90 06 60 48 add %i1, 0x48, %o0 20058f8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 20058fc: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 2005900: 40 00 0d 79 call 2008ee4 <_Thread_Clear_state> 2005904: 81 e8 00 00 restore 2005908: 01 00 00 00 nop 0200590c <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 200590c: 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 ) ) { 2005910: 92 96 20 00 orcc %i0, 0, %o1 2005914: 12 80 00 25 bne 20059a8 <_Event_Timeout+0x9c> 2005918: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200591c: 21 00 80 61 sethi %hi(0x2018400), %l0 <== NOT EXECUTED 2005920: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2005924: 82 00 60 01 inc %g1 <== NOT EXECUTED 2005928: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ] <== 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; 200592c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2005930: f0 00 60 c0 ld [ %g1 + 0xc0 ], %i0 ! 20188c0 <_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; 2005934: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 2005938: 7f ff f1 2a call 2001de0 200593c: 01 00 00 00 nop 2005940: 88 10 00 08 mov %o0, %g4 if ( the_thread->Wait.count ) { /* verify thread is waiting */ 2005944: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 2005948: 80 a0 60 00 cmp %g1, 0 200594c: 02 80 00 3a be 2005a34 <_Event_Timeout+0x128> 2005950: 07 00 80 62 sethi %hi(0x2018800), %g3 the_thread->Wait.count = 0; if ( _Event_Sync_state != EVENT_SYNC_SYNCHRONIZED && 2005954: c2 00 e2 f4 ld [ %g3 + 0x2f4 ], %g1 ! 2018af4 <_Event_Sync_state> 2005958: 80 a0 60 00 cmp %g1, 0 200595c: 02 80 00 29 be 2005a00 <_Event_Timeout+0xf4> 2005960: c0 26 20 24 clr [ %i0 + 0x24 ] 2005964: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2005968: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 20188c0 <_Thread_Executing> <== NOT EXECUTED 200596c: 80 a6 00 02 cmp %i0, %g2 <== NOT EXECUTED 2005970: 12 80 00 25 bne 2005a04 <_Event_Timeout+0xf8> <== NOT EXECUTED 2005974: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { 2005978: c2 00 e2 f4 ld [ %g3 + 0x2f4 ], %g1 <== NOT EXECUTED 200597c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2005980: 02 80 00 03 be 200598c <_Event_Timeout+0x80> <== NOT EXECUTED 2005984: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_TIMEOUT; 2005988: c2 20 e2 f4 st %g1, [ %g3 + 0x2f4 ] <== NOT EXECUTED } _ISR_Enable( level ); 200598c: 7f ff f1 19 call 2001df0 <== NOT EXECUTED 2005990: 01 00 00 00 nop <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2005994: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 <== NOT EXECUTED 2005998: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200599c: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ] <== NOT EXECUTED 20059a0: 81 c7 e0 08 ret <== NOT EXECUTED 20059a4: 81 e8 00 00 restore <== NOT EXECUTED 20059a8: 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 ) { 20059ac: 80 a0 a0 04 cmp %g2, 4 20059b0: 18 bf ff fc bgu 20059a0 <_Event_Timeout+0x94> 20059b4: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20059b8: 80 a0 60 01 cmp %g1, 1 20059bc: 12 bf ff f9 bne 20059a0 <_Event_Timeout+0x94> 20059c0: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20059c4: 05 00 80 61 sethi %hi(0x2018400), %g2 20059c8: 84 10 a3 40 or %g2, 0x340, %g2 ! 2018740 <_Objects_Information_table> 20059cc: c6 00 80 01 ld [ %g2 + %g1 ], %g3 20059d0: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 20059d4: 80 a2 20 00 cmp %o0, 0 20059d8: 02 80 00 15 be 2005a2c <_Event_Timeout+0x120> 20059dc: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20059e0: 40 00 08 ce call 2007d18 <_Objects_Get> 20059e4: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20059e8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20059ec: 80 a0 60 00 cmp %g1, 0 20059f0: 12 bf ff ec bne 20059a0 <_Event_Timeout+0x94> 20059f4: b0 10 00 08 mov %o0, %i0 20059f8: 10 bf ff d0 b 2005938 <_Event_Timeout+0x2c> 20059fc: 21 00 80 61 sethi %hi(0x2018400), %l0 if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { _Event_Sync_state = EVENT_SYNC_TIMEOUT; } _ISR_Enable( level ); } else { the_thread->Wait.return_code = RTEMS_TIMEOUT; 2005a00: 82 10 20 06 mov 6, %g1 2005a04: c2 26 20 34 st %g1, [ %i0 + 0x34 ] _ISR_Enable( level ); 2005a08: 7f ff f0 fa call 2001df0 2005a0c: 90 10 00 04 mov %g4, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2005a10: 13 04 00 ff sethi %hi(0x1003fc00), %o1 2005a14: 90 10 00 18 mov %i0, %o0 2005a18: 40 00 0d 33 call 2008ee4 <_Thread_Clear_state> 2005a1c: 92 12 63 f8 or %o1, 0x3f8, %o1 */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2005a20: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 2005a24: 82 00 7f ff add %g1, -1, %g1 2005a28: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ] 2005a2c: 81 c7 e0 08 ret 2005a30: 81 e8 00 00 restore _Thread_Unblock( the_thread ); } } else { _ISR_Enable( level ); 2005a34: 7f ff f0 ef call 2001df0 <== NOT EXECUTED 2005a38: 01 00 00 00 nop <== NOT EXECUTED 2005a3c: 30 bf ff f9 b,a 2005a20 <_Event_Timeout+0x114> <== NOT EXECUTED 02007258 <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 2007258: 9d e3 bf 98 save %sp, -104, %sp Heap_Block *the_block; void *ptr = NULL; Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); the_size = 200725c: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 2007260: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 2007264: 90 10 00 19 mov %i1, %o0 2007268: 40 00 00 cd call 200759c <_Heap_Calc_block_size> 200726c: a0 10 00 18 mov %i0, %l0 _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 2007270: 80 a2 20 00 cmp %o0, 0 2007274: 22 80 00 1a be,a 20072dc <_Heap_Allocate+0x84> 2007278: b0 10 20 00 clr %i0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 200727c: f0 06 20 08 ld [ %i0 + 8 ], %i0 return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 2007280: 80 a4 00 18 cmp %l0, %i0 2007284: 22 80 00 16 be,a 20072dc <_Heap_Allocate+0x84> 2007288: b0 10 20 00 clr %i0 /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 200728c: c2 06 20 04 ld [ %i0 + 4 ], %g1 2007290: 80 a2 00 01 cmp %o0, %g1 2007294: 08 80 00 16 bleu 20072ec <_Heap_Allocate+0x94> 2007298: b2 10 20 00 clr %i1 return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 200729c: 10 80 00 07 b 20072b8 <_Heap_Allocate+0x60> 20072a0: f0 06 20 08 ld [ %i0 + 8 ], %i0 /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 20072a4: c2 06 20 04 ld [ %i0 + 4 ], %g1 20072a8: 80 a2 00 01 cmp %o0, %g1 20072ac: 08 80 00 11 bleu 20072f0 <_Heap_Allocate+0x98> 20072b0: 94 10 00 08 mov %o0, %o2 return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 20072b4: f0 06 20 08 ld [ %i0 + 8 ], %i0 if(the_size == 0) return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 20072b8: 80 a4 00 18 cmp %l0, %i0 20072bc: 12 bf ff fa bne 20072a4 <_Heap_Allocate+0x4c> 20072c0: b2 06 60 01 inc %i1 20072c4: b0 10 20 00 clr %i0 _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 20072c8: c2 04 20 44 ld [ %l0 + 0x44 ], %g1 20072cc: 80 a6 40 01 cmp %i1, %g1 20072d0: 08 80 00 05 bleu 20072e4 <_Heap_Allocate+0x8c> 20072d4: 01 00 00 00 nop stats->max_search = search_count; 20072d8: f2 24 20 44 st %i1, [ %l0 + 0x44 ] 20072dc: 81 c7 e0 08 ret 20072e0: 81 e8 00 00 restore return ptr; } 20072e4: 81 c7 e0 08 ret 20072e8: 81 e8 00 00 restore _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 20072ec: 94 10 00 08 mov %o0, %o2 20072f0: 92 10 00 18 mov %i0, %o1 20072f4: 40 00 00 7e call 20074ec <_Heap_Block_allocate> 20072f8: 90 10 00 10 mov %l0, %o0 ptr = _Heap_User_area(the_block); stats->allocs += 1; 20072fc: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 stats->searches += search_count + 1; 2007300: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); ptr = _Heap_User_area(the_block); stats->allocs += 1; 2007304: 82 00 60 01 inc %g1 stats->searches += search_count + 1; 2007308: 84 00 a0 01 inc %g2 if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); ptr = _Heap_User_area(the_block); stats->allocs += 1; 200730c: c2 24 20 48 st %g1, [ %l0 + 0x48 ] stats->searches += search_count + 1; 2007310: 84 00 80 19 add %g2, %i1, %g2 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( void *base, uint32_t offset ) { return (void *)((char *)base + offset); 2007314: b0 06 20 08 add %i0, 8, %i0 2007318: 10 bf ff ec b 20072c8 <_Heap_Allocate+0x70> 200731c: c4 24 20 4c st %g2, [ %l0 + 0x4c ] 0200759c <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 200759c: 9d e3 bf 98 save %sp, -104, %sp 20075a0: a0 10 00 19 mov %i1, %l0 uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 20075a4: b2 06 20 04 add %i0, 4, %i1 uint32_t alignment ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; 20075a8: 92 10 00 10 mov %l0, %o1 20075ac: 40 00 37 e1 call 2015530 <.urem> 20075b0: 90 10 00 19 mov %i1, %o0 *value = r ? v - r + a : v; 20075b4: 80 a2 20 00 cmp %o0, 0 20075b8: 02 80 00 04 be 20075c8 <_Heap_Calc_block_size+0x2c> 20075bc: 82 10 00 19 mov %i1, %g1 20075c0: 82 04 00 19 add %l0, %i1, %g1 20075c4: 82 20 40 08 sub %g1, %o0, %g1 20075c8: 80 a0 40 1a cmp %g1, %i2 20075cc: 2a 80 00 02 bcs,a 20075d4 <_Heap_Calc_block_size+0x38> 20075d0: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED _Heap_Align_up(&block_size, page_size); if (block_size < min_size) block_size = min_size; /* 'block_size' becomes <= 'size' if and only if overflow occured. */ return (block_size > size) ? block_size : 0; 20075d4: 80 a6 00 01 cmp %i0, %g1 20075d8: 1a 80 00 03 bcc 20075e4 <_Heap_Calc_block_size+0x48> 20075dc: b0 10 20 00 clr %i0 20075e0: b0 10 00 01 mov %g1, %i0 } 20075e4: 81 c7 e0 08 ret 20075e8: 81 e8 00 00 restore 02019e28 <_Heap_Get_free_information>: */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 2019e28: 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; 2019e2c: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED info->largest = 0; 2019e30: c0 22 60 04 clr [ %o1 + 4 ] <== NOT EXECUTED info->total = 0; 2019e34: c0 22 60 08 clr [ %o1 + 8 ] <== NOT EXECUTED for(the_block = _Heap_First(the_heap); the_block != tail; 2019e38: 80 a2 00 0d cmp %o0, %o5 <== NOT EXECUTED 2019e3c: 02 80 00 12 be 2019e84 <_Heap_Get_free_information+0x5c> <== NOT EXECUTED 2019e40: 98 10 20 00 clr %o4 <== NOT EXECUTED 2019e44: 84 10 00 0c mov %o4, %g2 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 2019e48: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; info->total += the_size; if ( info->largest < the_size ) 2019e4c: c6 02 60 04 ld [ %o1 + 4 ], %g3 <== NOT EXECUTED 2019e50: 88 08 7f fe and %g1, -2, %g4 <== NOT EXECUTED uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 2019e54: 84 00 a0 01 inc %g2 <== NOT EXECUTED info->total += the_size; 2019e58: 82 03 00 04 add %o4, %g4, %g1 <== NOT EXECUTED uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 2019e5c: c4 22 40 00 st %g2, [ %o1 ] <== NOT EXECUTED info->total += the_size; 2019e60: c2 22 60 08 st %g1, [ %o1 + 8 ] <== NOT EXECUTED if ( info->largest < the_size ) 2019e64: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED 2019e68: 08 80 00 03 bleu 2019e74 <_Heap_Get_free_information+0x4c> <== NOT EXECUTED 2019e6c: 98 10 00 01 mov %g1, %o4 <== NOT EXECUTED info->largest = the_size; 2019e70: c8 22 60 04 st %g4, [ %o1 + 4 ] <== NOT EXECUTED info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 2019e74: 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; 2019e78: 80 a2 00 0d cmp %o0, %o5 <== NOT EXECUTED 2019e7c: 32 bf ff f4 bne,a 2019e4c <_Heap_Get_free_information+0x24> <== NOT EXECUTED 2019e80: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED 2019e84: 81 c3 e0 08 retl <== NOT EXECUTED 2019e88: 01 00 00 00 nop 020075ec <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 20075ec: 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) 20075f0: 80 a6 e0 00 cmp %i3, 0 20075f4: 12 80 00 43 bne 2007700 <_Heap_Initialize+0x114> 20075f8: 84 8e e0 07 andcc %i3, 7, %g2 20075fc: b6 10 20 08 mov 8, %i3 <== NOT EXECUTED 2007600: a4 10 20 00 clr %l2 <== NOT EXECUTED /* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET (value of user pointer) is aligned on 'page_size' boundary. Make sure resulting 'aligned_start' is not below 'starting_address'. */ start = _H_p2u(starting_address); aligned_start = start + HEAP_BLOCK_USER_OFFSET; 2007604: a0 06 60 08 add %i1, 8, %l0 uint32_t alignment ) { _H_uptr_t v = *value; uint32_t a = alignment; _H_uptr_t r = v % a; 2007608: 92 10 00 1b mov %i3, %o1 200760c: 40 00 37 c9 call 2015530 <.urem> 2007610: 90 10 00 10 mov %l0, %o0 *value = r ? v - r + a : v; 2007614: 80 a2 20 00 cmp %o0, 0 2007618: 02 80 00 05 be 200762c <_Heap_Initialize+0x40> 200761c: a2 04 3f f8 add %l0, -8, %l1 2007620: 82 06 c0 10 add %i3, %l0, %g1 2007624: a0 20 40 08 sub %g1, %o0, %l0 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 2007628: a2 04 3f f8 add %l0, -8, %l1 ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 200762c: 80 a4 a0 00 cmp %l2, 0 2007630: 02 80 00 04 be 2007640 <_Heap_Initialize+0x54> 2007634: 82 10 20 10 mov 0x10, %g1 2007638: 82 06 e0 10 add %i3, 0x10, %g1 200763c: 82 20 40 12 sub %g1, %l2, %g1 2007640: c2 26 20 14 st %g1, [ %i0 + 0x14 ] /* Calculate 'the_size' -- size of the first block so that there is enough space at the end for the permanent last block. It is equal to 'size' minus total overhead aligned down to the nearest multiple of 'page_size'. */ overhead = HEAP_OVERHEAD + (aligned_start - start); 2007644: 82 24 40 19 sub %l1, %i1, %g1 2007648: 82 00 60 08 add %g1, 8, %g1 if ( size < overhead ) 200764c: 80 a0 40 1a cmp %g1, %i2 2007650: 18 80 00 2a bgu 20076f8 <_Heap_Initialize+0x10c> 2007654: a0 26 80 01 sub %i2, %g1, %l0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 2007658: 92 10 00 1b mov %i3, %o1 200765c: 40 00 37 b5 call 2015530 <.urem> 2007660: 90 10 00 10 mov %l0, %o0 return 0; /* Too small area for the heap */ the_size = size - overhead; _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 2007664: a0 a4 00 08 subcc %l0, %o0, %l0 2007668: 02 80 00 24 be 20076f8 <_Heap_Initialize+0x10c> 200766c: 09 00 80 61 sethi %hi(0x2018400), %g4 return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 2007670: f6 26 20 10 st %i3, [ %i0 + 0x10 ] the_heap->begin = starting_address; the_heap->end = starting_address + size; the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 2007674: f6 24 40 00 st %i3, [ %l1 ] the_block->size = the_size | HEAP_PREV_USED; 2007678: 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++; 200767c: c6 01 20 34 ld [ %g4 + 0x34 ], %g3 the_heap->end = starting_address + size; the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; 2007680: c2 24 60 04 st %g1, [ %l1 + 4 ] _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ 2007684: e0 24 40 10 st %l0, [ %l1 + %l0 ] RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 2007688: 9a 04 40 10 add %l1, %l0, %o5 the_block->size = page_size; 200768c: f6 23 60 04 st %i3, [ %o5 + 4 ] the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; the_block->next = _Heap_Tail( the_heap ); 2007690: f0 24 60 08 st %i0, [ %l1 + 8 ] the_block->prev = _Heap_Head( the_heap ); 2007694: f0 24 60 0c st %i0, [ %l1 + 0xc ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 2007698: c6 26 20 28 st %g3, [ %i0 + 0x28 ] the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ the_block->size = page_size; stats->size = size; 200769c: f4 26 20 2c st %i2, [ %i0 + 0x2c ] stats->free_size = the_size; 20076a0: e0 26 20 30 st %l0, [ %i0 + 0x30 ] stats->min_free_size = the_size; 20076a4: e0 26 20 34 st %l0, [ %i0 + 0x34 ] stats->free_blocks = 1; stats->max_free_blocks = 1; stats->used_blocks = 0; 20076a8: c0 26 20 40 clr [ %i0 + 0x40 ] stats->max_search = 0; 20076ac: c0 26 20 44 clr [ %i0 + 0x44 ] stats->allocs = 0; 20076b0: c0 26 20 48 clr [ %i0 + 0x48 ] stats->searches = 0; 20076b4: c0 26 20 4c clr [ %i0 + 0x4c ] stats->frees = 0; 20076b8: c0 26 20 50 clr [ %i0 + 0x50 ] stats->resizes = 0; 20076bc: c0 26 20 54 clr [ %i0 + 0x54 ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 20076c0: 84 10 20 01 mov 1, %g2 stats->max_free_blocks = 1; 20076c4: c4 26 20 3c st %g2, [ %i0 + 0x3c ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 20076c8: c4 26 20 38 st %g2, [ %i0 + 0x38 ] if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 20076cc: 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++; 20076d0: 86 00 e0 01 inc %g3 if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 20076d4: 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; 20076d8: 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; 20076dc: e2 26 20 08 st %l1, [ %i0 + 8 ] _Heap_Tail(the_heap)->prev = the_block; 20076e0: e2 26 20 0c st %l1, [ %i0 + 0xc ] the_heap->start = the_block; 20076e4: e2 26 20 20 st %l1, [ %i0 + 0x20 ] _HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT)); _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ 20076e8: da 26 20 24 st %o5, [ %i0 + 0x24 ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 20076ec: c6 21 20 34 st %g3, [ %g4 + 0x34 ] return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 20076f0: 81 c7 e0 08 ret 20076f4: 91 ec 3f fc restore %l0, -4, %o0 } 20076f8: 81 c7 e0 08 ret 20076fc: 91 e8 20 00 restore %g0, 0, %o0 ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 2007700: 02 80 00 04 be 2007710 <_Heap_Initialize+0x124> 2007704: 90 10 20 10 mov 0x10, %o0 2007708: 82 06 e0 08 add %i3, 8, %g1 200770c: b6 20 40 02 sub %g1, %g2, %i3 2007710: 40 00 37 88 call 2015530 <.urem> 2007714: 92 10 00 1b mov %i3, %o1 2007718: 10 bf ff bb b 2007604 <_Heap_Initialize+0x18> 200771c: a4 10 00 08 mov %o0, %l2 0200cf94 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 200cf94: 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; 200cf98: 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; 200cf9c: ee 06 20 14 ld [ %i0 + 0x14 ], %l7 <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; *old_mem_size = 0; 200cfa0: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED *avail_mem_size = 0; 200cfa4: 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); 200cfa8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200cfac: 40 00 21 61 call 2015530 <.urem> <== NOT EXECUTED 200cfb0: 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 ); 200cfb4: 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); 200cfb8: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 200cfbc: 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)) 200cfc0: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED 200cfc4: 1a 80 00 05 bcc 200cfd8 <_Heap_Resize_block+0x44> <== NOT EXECUTED 200cfc8: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 200cfcc: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED } 200cfd0: 81 c7 e0 08 ret <== NOT EXECUTED 200cfd4: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED *old_mem_size = 0; *avail_mem_size = 0; _Heap_Start_of_block(the_heap, starting_address, &the_block); _HAssert(_Heap_Is_block_in(the_heap, the_block)); if (!_Heap_Is_block_in(the_heap, the_block)) 200cfd8: 80 a4 80 02 cmp %l2, %g2 <== NOT EXECUTED 200cfdc: 38 bf ff fd bgu,a 200cfd0 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 200cfe0: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 200cfe4: 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); 200cfe8: a8 08 ff fe and %g3, -2, %l4 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200cfec: a2 04 80 14 add %l2, %l4, %l1 <== NOT EXECUTED old_block_size = _Heap_Block_size(the_block); next_block = _Heap_Block_at(the_block, old_block_size); _HAssert(_Heap_Is_block_in(the_heap, next_block)); _HAssert(_Heap_Is_prev_used(next_block)); if ( !_Heap_Is_block_in(the_heap, next_block) || 200cff0: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 200cff4: 2a bf ff f7 bcs,a 200cfd0 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 200cff8: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 200cffc: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 200d000: 38 bf ff f4 bgu,a 200cfd0 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 200d004: 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); 200d008: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED 200d00c: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200d010: 02 bf ff ef be 200cfcc <_Heap_Resize_block+0x38> <== NOT EXECUTED 200d014: aa 08 7f fe and %g1, -2, %l5 <== NOT EXECUTED !_Heap_Is_prev_used(next_block)) return HEAP_RESIZE_FATAL_ERROR; next_block_size = _Heap_Block_size(next_block); next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || 200d018: 80 a0 80 11 cmp %g2, %l1 <== NOT EXECUTED 200d01c: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED 200d020: 02 80 00 04 be 200d030 <_Heap_Resize_block+0x9c> <== NOT EXECUTED 200d024: ba 04 40 15 add %l1, %l5, %i5 <== NOT EXECUTED 200d028: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED 200d02c: 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) 200d030: 82 24 40 19 sub %l1, %i1, %g1 <== NOT EXECUTED 200d034: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 200d038: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED if (size > old_user_size) { 200d03c: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED 200d040: 1a 80 00 16 bcc 200d098 <_Heap_Resize_block+0x104> <== NOT EXECUTED 200d044: 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 */ 200d048: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 200d04c: 12 80 00 10 bne 200d08c <_Heap_Resize_block+0xf8> <== NOT EXECUTED 200d050: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 200d054: 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; 200d058: 40 00 21 36 call 2015530 <.urem> <== NOT EXECUTED 200d05c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED *value = r ? v - r + a : v; 200d060: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200d064: 02 80 00 05 be 200d078 <_Heap_Resize_block+0xe4> <== NOT EXECUTED 200d068: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED 200d06c: 82 04 00 13 add %l0, %l3, %g1 <== NOT EXECUTED 200d070: a0 20 40 08 sub %g1, %o0, %l0 <== NOT EXECUTED 200d074: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED 200d078: 0a 80 00 1d bcs 200d0ec <_Heap_Resize_block+0x158> <== NOT EXECUTED 200d07c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Heap_Align_up(&add_block_size, page_size); if (add_block_size < min_block_size) add_block_size = min_block_size; if (add_block_size > next_block_size) 200d080: 80 a5 40 08 cmp %l5, %o0 <== NOT EXECUTED 200d084: 1a 80 00 1f bcc 200d100 <_Heap_Resize_block+0x16c> <== NOT EXECUTED 200d088: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 200d08c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED } 200d090: 81 c7 e0 08 ret <== NOT EXECUTED 200d094: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED --stats->used_blocks; } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 200d098: a0 20 40 1a sub %g1, %i2, %l0 <== NOT EXECUTED uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 200d09c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 200d0a0: 40 00 21 24 call 2015530 <.urem> <== NOT EXECUTED 200d0a4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 200d0a8: a0 a4 00 08 subcc %l0, %o0, %l0 <== NOT EXECUTED 200d0ac: 22 80 00 0b be,a 200d0d8 <_Heap_Resize_block+0x144> <== NOT EXECUTED 200d0b0: 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; 200d0b4: 86 25 00 10 sub %l4, %l0, %g3 <== NOT EXECUTED if (new_block_size < min_block_size) { 200d0b8: 80 a5 c0 03 cmp %l7, %g3 <== NOT EXECUTED 200d0bc: 08 80 00 1c bleu 200d12c <_Heap_Resize_block+0x198> <== NOT EXECUTED 200d0c0: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 200d0c4: 82 25 c0 03 sub %l7, %g3, %g1 <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 200d0c8: a0 a4 00 01 subcc %l0, %g1, %l0 <== NOT EXECUTED 200d0cc: 32 80 00 17 bne,a 200d128 <_Heap_Resize_block+0x194> <== NOT EXECUTED 200d0d0: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 200d0d4: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 200d0d8: 84 10 20 00 clr %g2 <== NOT EXECUTED 200d0dc: 82 00 60 01 inc %g1 <== NOT EXECUTED 200d0e0: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } 200d0e4: 81 c7 e0 08 ret <== NOT EXECUTED 200d0e8: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 200d0ec: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED else { uint32_t add_block_size = size - old_user_size; _Heap_Align_up(&add_block_size, page_size); if (add_block_size < min_block_size) add_block_size = min_block_size; if (add_block_size > next_block_size) 200d0f0: 80 a5 40 08 cmp %l5, %o0 <== NOT EXECUTED 200d0f4: 0a bf ff e7 bcs 200d090 <_Heap_Resize_block+0xfc> <== NOT EXECUTED 200d0f8: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 200d0fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 200d100: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 200d104: 7f ff e8 fa call 20074ec <_Heap_Block_allocate> <== NOT EXECUTED 200d108: 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; 200d10c: 90 02 00 14 add %o0, %l4, %o0 <== NOT EXECUTED 200d110: 90 12 00 1b or %o0, %i3, %o0 <== NOT EXECUTED 200d114: d0 24 a0 04 st %o0, [ %l2 + 4 ] <== NOT EXECUTED --stats->used_blocks; 200d118: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED 200d11c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200d120: 10 bf ff ed b 200d0d4 <_Heap_Resize_block+0x140> <== NOT EXECUTED 200d124: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED _HAssert(new_block_size >= min_block_size); _HAssert(new_block_size + free_block_size == old_block_size); _HAssert(_Heap_Is_aligned(new_block_size, page_size)); _HAssert(_Heap_Is_aligned(free_block_size, page_size)); if (!next_is_used) { 200d128: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 200d12c: 12 80 00 15 bne 200d180 <_Heap_Resize_block+0x1ec> <== NOT EXECUTED 200d130: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED Heap_Block *const new_next_block = _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 200d134: 82 10 c0 1b or %g3, %i3, %g1 <== NOT EXECUTED 200d138: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200d13c: 86 04 80 03 add %l2, %g3, %g3 <== NOT EXECUTED if (!next_is_used) { /* Extend the next block to the low addresses by 'free_block_size' */ Heap_Block *const new_next_block = _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; 200d140: 88 04 00 15 add %l0, %l5, %g4 <== NOT EXECUTED Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; 200d144: d8 04 60 0c ld [ %l1 + 0xc ], %o4 <== NOT EXECUTED _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; new_next_block->size = new_next_block_size | HEAP_PREV_USED; next_next_block->prev_size = new_next_block_size; 200d148: c8 27 40 00 st %g4, [ %i5 ] <== NOT EXECUTED Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; 200d14c: da 04 60 08 ld [ %l1 + 8 ], %o5 <== NOT EXECUTED _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; new_next_block->size = new_next_block_size | HEAP_PREV_USED; 200d150: 84 11 20 01 or %g4, 1, %g2 <== NOT EXECUTED 200d154: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; _Heap_Block_replace(next_block, new_next_block); the_heap->stats.free_size += free_block_size; 200d158: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED Heap_Block *prev = block->prev; block = new_block; block->next = next; 200d15c: da 20 e0 08 st %o5, [ %g3 + 8 ] <== NOT EXECUTED 200d160: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED block->prev = prev; 200d164: d8 20 e0 0c st %o4, [ %g3 + 0xc ] <== NOT EXECUTED 200d168: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 200d16c: 88 01 3f fc add %g4, -4, %g4 <== NOT EXECUTED next->prev = prev->next = block; 200d170: c6 23 60 0c st %g3, [ %o5 + 0xc ] <== NOT EXECUTED 200d174: c6 23 20 08 st %g3, [ %o4 + 8 ] <== NOT EXECUTED 200d178: 10 bf ff d7 b 200d0d4 <_Heap_Resize_block+0x140> <== NOT EXECUTED 200d17c: c8 27 00 00 st %g4, [ %i4 ] <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 200d180: 2a bf ff d6 bcs,a 200d0d8 <_Heap_Resize_block+0x144> <== NOT EXECUTED 200d184: 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; 200d188: 82 10 c0 1b or %g3, %i3, %g1 <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 200d18c: 84 14 20 01 or %l0, 1, %g2 <== NOT EXECUTED the_heap->stats.free_size += free_block_size; *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; } else if (free_block_size >= min_block_size) { /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; 200d190: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200d194: 92 04 80 03 add %l2, %g3, %o1 <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 200d198: c4 22 60 04 st %g2, [ %o1 + 4 ] <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 200d19c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200d1a0: 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 */ 200d1a4: 82 00 60 01 inc %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200d1a8: 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 */ 200d1ac: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200d1b0: c4 26 20 50 st %g2, [ %i0 + 0x50 ] <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 200d1b4: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 200d1b8: 7f ff e8 5a call 2007320 <_Heap_Free> <== NOT EXECUTED 200d1bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 200d1c0: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED 200d1c4: 10 bf ff c4 b 200d0d4 <_Heap_Resize_block+0x140> <== NOT EXECUTED 200d1c8: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED 0200d1cc <_Heap_Size_of_user_area>: boolean _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 200d1cc: 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( 200d1d0: e0 06 20 20 ld [ %i0 + 0x20 ], %l0 <== NOT EXECUTED 200d1d4: 80 a6 40 10 cmp %i1, %l0 <== NOT EXECUTED 200d1d8: 0a 80 00 05 bcs 200d1ec <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200d1dc: e2 06 20 24 ld [ %i0 + 0x24 ], %l1 <== NOT EXECUTED 200d1e0: 80 a6 40 11 cmp %i1, %l1 <== NOT EXECUTED 200d1e4: 28 80 00 04 bleu,a 200d1f4 <_Heap_Size_of_user_area+0x28> <== NOT EXECUTED 200d1e8: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 <== NOT EXECUTED *size = _Addresses_Subtract ( next_block, starting_address ) + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); } 200d1ec: 81 c7 e0 08 ret <== NOT EXECUTED 200d1f0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED /* The address passed could be greater than the block address plus * HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user * pointers. To get rid of this offset we need to align the address down * to the nearest 'page_size' boundary. */ _Heap_Align_down_uptr ( &addr, the_heap->page_size ); *the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET); 200d1f4: 40 00 20 cf call 2015530 <.urem> <== NOT EXECUTED 200d1f8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200d1fc: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 200d200: 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 ) ) 200d204: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 200d208: 0a bf ff f9 bcs 200d1ec <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200d20c: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 200d210: 18 bf ff f7 bgu 200d1ec <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200d214: 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 ); 200d218: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 200d21c: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 200d220: 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 ( 200d224: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 200d228: 0a bf ff f1 bcs 200d1ec <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200d22c: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 200d230: 18 bf ff ef bgu 200d1ec <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200d234: 01 00 00 00 nop <== NOT EXECUTED 200d238: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 200d23c: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200d240: 02 bf ff eb be 200d1ec <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200d244: 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 ) 200d248: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED 200d24c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 200d250: 81 c7 e0 08 ret <== NOT EXECUTED 200d254: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED 02006ab8 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 2006ab8: 9d e3 bf 98 save %sp, -104, %sp /* * If the user claims there are less drivers than are actually in * the table, then let's just go with the table's count. */ if ( number_of_drivers <= drivers_in_table ) 2006abc: 80 a6 80 19 cmp %i2, %i1 2006ac0: 08 80 00 27 bleu 2006b5c <_IO_Manager_initialization+0xa4> 2006ac4: 03 00 80 62 sethi %hi(0x2018800), %g1 /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 2006ac8: 83 2e a0 03 sll %i2, 3, %g1 <== NOT EXECUTED 2006acc: a1 2e a0 05 sll %i2, 5, %l0 <== NOT EXECUTED 2006ad0: a0 24 00 01 sub %l0, %g1, %l0 <== NOT EXECUTED 2006ad4: 40 00 0f e5 call 200aa68 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 2006ad8: 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; 2006adc: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED memset( 2006ae0: 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; 2006ae4: f4 20 63 44 st %i2, [ %g1 + 0x344 ] <== 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 *) 2006ae8: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 2006aec: 92 10 20 00 clr %o1 <== NOT EXECUTED 2006af0: 40 00 20 49 call 200ec14 <== NOT EXECUTED 2006af4: d0 24 23 48 st %o0, [ %l0 + 0x348 ] <== NOT EXECUTED _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006af8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2006afc: 02 80 00 16 be 2006b54 <_IO_Manager_initialization+0x9c> <== NOT EXECUTED 2006b00: d4 04 23 48 ld [ %l0 + 0x348 ], %o2 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 2006b04: 96 10 20 00 clr %o3 <== NOT EXECUTED 2006b08: 98 10 20 00 clr %o4 <== NOT EXECUTED 2006b0c: c2 03 00 18 ld [ %o4 + %i0 ], %g1 <== NOT EXECUTED 2006b10: 9a 03 00 18 add %o4, %i0, %o5 <== NOT EXECUTED 2006b14: c2 23 00 0a st %g1, [ %o4 + %o2 ] <== NOT EXECUTED 2006b18: c4 03 60 04 ld [ %o5 + 4 ], %g2 <== NOT EXECUTED 2006b1c: 86 03 00 0a add %o4, %o2, %g3 <== NOT EXECUTED 2006b20: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED 2006b24: c2 03 60 08 ld [ %o5 + 8 ], %g1 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006b28: 96 02 e0 01 inc %o3 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 2006b2c: c2 20 e0 08 st %g1, [ %g3 + 8 ] <== NOT EXECUTED 2006b30: c4 03 60 0c ld [ %o5 + 0xc ], %g2 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006b34: 98 03 20 18 add %o4, 0x18, %o4 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 2006b38: c4 20 e0 0c st %g2, [ %g3 + 0xc ] <== NOT EXECUTED 2006b3c: c8 03 60 10 ld [ %o5 + 0x10 ], %g4 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006b40: 80 a2 c0 19 cmp %o3, %i1 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 2006b44: c8 20 e0 10 st %g4, [ %g3 + 0x10 ] <== NOT EXECUTED 2006b48: c2 03 60 14 ld [ %o5 + 0x14 ], %g1 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006b4c: 12 bf ff f0 bne 2006b0c <_IO_Manager_initialization+0x54> <== NOT EXECUTED 2006b50: c2 20 e0 14 st %g1, [ %g3 + 0x14 ] <== NOT EXECUTED 2006b54: 81 c7 e0 08 ret <== NOT EXECUTED 2006b58: 81 e8 00 00 restore <== NOT EXECUTED * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; _IO_Number_of_drivers = number_of_drivers; 2006b5c: 05 00 80 62 sethi %hi(0x2018800), %g2 * If the maximum number of driver is the same as the number in the * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; 2006b60: f0 20 63 48 st %i0, [ %g1 + 0x348 ] _IO_Number_of_drivers = number_of_drivers; 2006b64: f2 20 a3 44 st %i1, [ %g2 + 0x344 ] 2006b68: 81 c7 e0 08 ret 2006b6c: 81 e8 00 00 restore 02007760 <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 2007760: 9d e3 bf 98 save %sp, -104, %sp _ISR_Signals_to_thread_executing = FALSE; 2007764: 03 00 80 62 sethi %hi(0x2018800), %g1 _ISR_Nest_level = 0; 2007768: 05 00 80 62 sethi %hi(0x2018800), %g2 * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { _ISR_Signals_to_thread_executing = FALSE; 200776c: c0 20 61 68 clr [ %g1 + 0x168 ] _ISR_Nest_level = 0; 2007770: c0 20 a0 a8 clr [ %g2 + 0xa8 ] _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 2007774: 40 00 0c bd call 200aa68 <_Workspace_Allocate_or_fatal_error> 2007778: 90 10 24 00 mov 0x400, %o0 _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 200777c: 03 00 80 61 sethi %hi(0x2018400), %g1 2007780: a0 10 63 f4 or %g1, 0x3f4, %l0 ! 20187f4 <_CPU_Table> 2007784: 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( 2007788: 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 ) 200778c: 80 a0 af ff cmp %g2, 0xfff 2007790: 18 80 00 07 bgu 20077ac <_ISR_Handler_initialization+0x4c> 2007794: d0 20 60 84 st %o0, [ %g1 + 0x84 ] _Internal_error_Occurred( 2007798: 90 10 20 00 clr %o0 <== NOT EXECUTED 200779c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 20077a0: 7f ff ff e0 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 20077a4: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED 20077a8: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 20077ac: 40 00 0c af call 200aa68 <_Workspace_Allocate_or_fatal_error> 20077b0: 90 10 00 02 mov %g2, %o0 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 20077b4: c6 04 20 18 ld [ %l0 + 0x18 ], %g3 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 20077b8: 03 00 80 61 sethi %hi(0x2018400), %g1 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 20077bc: 86 02 00 03 add %o0, %g3, %g3 20077c0: 05 00 80 61 sethi %hi(0x2018400), %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 20077c4: d0 20 63 f0 st %o0, [ %g1 + 0x3f0 ] _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 20077c8: c6 20 a3 3c st %g3, [ %g2 + 0x33c ] #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 20077cc: 81 c7 e0 08 ret 20077d0: 81 e8 00 00 restore 0200d268 <_Objects_Compare_name_string>: boolean _Objects_Compare_name_string( void *name_1, void *name_2, uint16_t length ) { 200d268: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if ( !strncmp( name_1, name_2, length ) ) 200d26c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200d270: 95 2e a0 10 sll %i2, 0x10, %o2 <== NOT EXECUTED 200d274: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200d278: 40 00 09 63 call 200f804 <== NOT EXECUTED 200d27c: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED return TRUE; return FALSE; } 200d280: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 200d284: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 200d288: 81 c7 e0 08 ret <== NOT EXECUTED 200d28c: 81 e8 00 00 restore <== NOT EXECUTED 0201962c <_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; 201962c: 95 32 a0 02 srl %o2, 2, %o2 <== NOT EXECUTED while ( tmp_length-- ) 2019630: 80 a2 a0 00 cmp %o2, 0 <== NOT EXECUTED 2019634: 02 80 00 09 be 2019658 <_Objects_Copy_name_raw+0x2c> <== NOT EXECUTED 2019638: 86 10 20 00 clr %g3 <== NOT EXECUTED 201963c: 84 10 20 00 clr %g2 <== NOT EXECUTED *destination_p++ = *source_p++; 2019640: c2 00 80 08 ld [ %g2 + %o0 ], %g1 <== NOT EXECUTED 2019644: 86 00 e0 01 inc %g3 <== NOT EXECUTED 2019648: c2 20 80 09 st %g1, [ %g2 + %o1 ] <== NOT EXECUTED { uint32_t *source_p = (uint32_t *) source; uint32_t *destination_p = (uint32_t *) destination; size_t tmp_length = length / OBJECTS_NAME_ALIGNMENT; while ( tmp_length-- ) 201964c: 80 a0 c0 0a cmp %g3, %o2 <== NOT EXECUTED 2019650: 12 bf ff fc bne 2019640 <_Objects_Copy_name_raw+0x14> <== NOT EXECUTED 2019654: 84 00 a0 04 add %g2, 4, %g2 <== NOT EXECUTED 2019658: 81 c3 e0 08 retl <== NOT EXECUTED 201965c: 01 00 00 00 nop 02007888 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 2007888: 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; 200788c: 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 ) 2007890: e4 16 20 10 lduh [ %i0 + 0x10 ], %l2 2007894: 03 00 00 3f sethi %hi(0xfc00), %g1 2007898: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200789c: a2 08 80 01 and %g2, %g1, %l1 20078a0: 80 a4 40 12 cmp %l1, %l2 20078a4: 08 80 00 8c bleu 2007ad4 <_Objects_Extend_information+0x24c> 20078a8: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 20078ac: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; if ( information->maximum < minimum_index ) 20078b0: a8 10 00 11 mov %l1, %l4 20078b4: ac 10 20 00 clr %l6 20078b8: a6 10 20 01 mov 1, %l3 20078bc: 90 10 20 03 mov 3, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 20078c0: 80 a0 60 00 cmp %g1, 0 20078c4: 12 80 00 a4 bne 2007b54 <_Objects_Extend_information+0x2cc> 20078c8: ba 04 00 12 add %l0, %l2, %i5 if ( !object_blocks ) return; } else { object_blocks = (void**) 20078cc: 90 02 00 11 add %o0, %l1, %o0 20078d0: 90 02 00 1d add %o0, %i5, %o0 20078d4: 40 00 0c 65 call 200aa68 <_Workspace_Allocate_or_fatal_error> 20078d8: 91 2a 20 02 sll %o0, 2, %o0 20078dc: ae 10 00 08 mov %o0, %l7 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 20078e0: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 20078e4: 83 2c e0 02 sll %l3, 2, %g1 /* * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; 20078e8: 86 04 ff ff add %l3, -1, %g3 if ( information->maximum > minimum_index ) { 20078ec: 80 a4 40 02 cmp %l1, %g2 /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 20078f0: a6 05 c0 01 add %l7, %g1, %l3 object_blocks, block_count * sizeof(void*) ); name_table = (Objects_Name *) _Addresses_Add_offset( 20078f4: aa 00 40 13 add %g1, %l3, %l5 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 20078f8: 0a 80 00 ac bcs 2007ba8 <_Objects_Extend_information+0x320> 20078fc: a4 00 40 15 add %g1, %l5, %l2 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 2007900: 80 a4 60 00 cmp %l1, 0 2007904: 02 80 00 09 be 2007928 <_Objects_Extend_information+0xa0> 2007908: a1 28 e0 02 sll %g3, 2, %l0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 200790c: 84 10 20 00 clr %g2 /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 2007910: 83 28 a0 02 sll %g2, 2, %g1 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 2007914: 84 00 a0 01 inc %g2 2007918: 80 a0 80 11 cmp %g2, %l1 200791c: 12 bf ff fd bne 2007910 <_Objects_Extend_information+0x88> 2007920: c0 20 40 12 clr [ %g1 + %l2 ] 2007924: a1 28 e0 02 sll %g3, 2, %l0 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 2007928: c0 24 00 17 clr [ %l0 + %l7 ] inactive_per_block[block_count] = 0; 200792c: c0 24 00 13 clr [ %l0 + %l3 ] name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); 2007930: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2007934: 86 05 00 01 add %l4, %g1, %g3 2007938: 80 a0 c0 14 cmp %g3, %l4 200793c: 08 80 00 0a bleu 2007964 <_Objects_Extend_information+0xdc> 2007940: c0 25 40 10 clr [ %l5 + %l0 ] 2007944: 83 2d 20 02 sll %l4, 2, %g1 2007948: 84 04 80 01 add %l2, %g1, %g2 200794c: 82 10 00 14 mov %l4, %g1 index++ ) { local_table[ index ] = NULL; 2007950: c0 20 80 00 clr [ %g2 ] inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 2007954: 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 ); 2007958: 80 a0 40 03 cmp %g1, %g3 200795c: 12 bf ff fd bne 2007950 <_Objects_Extend_information+0xc8> 2007960: 84 00 a0 04 add %g2, 4, %g2 index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 2007964: 7f ff e9 1f call 2001de0 2007968: 01 00 00 00 nop information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 200796c: c4 06 00 00 ld [ %i0 ], %g2 2007970: c8 16 20 04 lduh [ %i0 + 4 ], %g4 2007974: 87 2f 60 10 sll %i5, 0x10, %g3 2007978: 89 29 20 1b sll %g4, 0x1b, %g4 200797c: 87 30 e0 10 srl %g3, 0x10, %g3 local_table[ index ] = NULL; } _ISR_Disable( level ); old_tables = information->object_blocks; 2007980: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2007984: 03 00 00 40 sethi %hi(0x10000), %g1 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; 2007988: e6 26 20 38 st %l3, [ %i0 + 0x38 ] information->name_table = name_table; 200798c: ea 26 20 24 st %l5, [ %i0 + 0x24 ] information->local_table = local_table; 2007990: e4 26 20 20 st %l2, [ %i0 + 0x20 ] information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2007994: 85 28 a0 18 sll %g2, 0x18, %g2 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; 2007998: fa 36 20 10 sth %i5, [ %i0 + 0x10 ] information->maximum_id = _Objects_Build_id( 200799c: 84 10 80 01 or %g2, %g1, %g2 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; 20079a0: ee 26 20 3c st %l7, [ %i0 + 0x3c ] information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 20079a4: 84 10 80 04 or %g2, %g4, %g2 20079a8: 84 10 80 03 or %g2, %g3, %g2 20079ac: c4 26 20 0c st %g2, [ %i0 + 0xc ] information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 20079b0: 7f ff e9 10 call 2001df0 20079b4: 01 00 00 00 nop if ( old_tables ) 20079b8: 80 a4 20 00 cmp %l0, 0 20079bc: 02 80 00 05 be 20079d0 <_Objects_Extend_information+0x148> 20079c0: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 20079c4: 11 00 80 62 sethi %hi(0x2018800), %o0 20079c8: 7f ff fe 56 call 2007320 <_Heap_Free> 20079cc: 90 12 20 2c or %o0, 0x2c, %o0 ! 201882c <_Workspace_Area> /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 20079d0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 20079d4: 80 a0 60 00 cmp %g1, 0 20079d8: 02 80 00 6a be 2007b80 <_Objects_Extend_information+0x2f8> 20079dc: c2 16 20 44 lduh [ %i0 + 0x44 ], %g1 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 20079e0: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 20079e4: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 information->object_blocks[ block ] = 20079e8: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 20079ec: 40 00 35 eb call 2015198 <.umul> 20079f0: 90 00 40 08 add %g1, %o0, %o0 20079f4: 92 10 00 08 mov %o0, %o1 20079f8: 11 00 80 62 sethi %hi(0x2018800), %o0 20079fc: 7f ff fe 17 call 2007258 <_Heap_Allocate> 2007a00: 90 12 20 2c or %o0, 0x2c, %o0 ! 201882c <_Workspace_Area> _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 2007a04: e4 06 20 3c ld [ %i0 + 0x3c ], %l2 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { information->object_blocks[ block ] = 2007a08: a7 2d a0 02 sll %l6, 2, %l3 2007a0c: d0 24 c0 10 st %o0, [ %l3 + %l0 ] _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 2007a10: c2 04 c0 12 ld [ %l3 + %l2 ], %g1 2007a14: 80 a0 60 00 cmp %g1, 0 2007a18: 02 80 00 7b be 2007c04 <_Objects_Extend_information+0x37c> 2007a1c: 01 00 00 00 nop 2007a20: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 2007a24: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 2007a28: 40 00 35 dc call 2015198 <.umul> 2007a2c: a2 10 00 14 mov %l4, %l1 2007a30: c2 04 80 13 ld [ %l2 + %l3 ], %g1 name_area = (Objects_Name *) _Addresses_Add_offset( information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 2007a34: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 2007a38: a0 02 00 01 add %o0, %g1, %l0 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007a3c: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 name_area = (Objects_Name *) _Addresses_Add_offset( information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 2007a40: e0 20 80 13 st %l0, [ %g2 + %l3 ] /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007a44: d6 06 20 1c ld [ %i0 + 0x1c ], %o3 2007a48: d2 04 80 13 ld [ %l2 + %l3 ], %o1 2007a4c: a8 07 bf ec add %fp, -20, %l4 index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 2007a50: 2b 00 00 40 sethi %hi(0x10000), %l5 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007a54: 90 10 00 14 mov %l4, %o0 2007a58: 40 00 14 eb call 200ce04 <_Chain_Initialize> 2007a5c: a4 06 20 28 add %i0, 0x28, %l2 2007a60: 30 80 00 0f b,a 2007a9c <_Objects_Extend_information+0x214> index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 2007a64: c4 16 20 04 lduh [ %i0 + 4 ], %g2 2007a68: c6 16 20 44 lduh [ %i0 + 0x44 ], %g3 2007a6c: 83 28 60 18 sll %g1, 0x18, %g1 2007a70: 85 28 a0 1b sll %g2, 0x1b, %g2 2007a74: 82 10 40 15 or %g1, %l5, %g1 2007a78: 82 10 40 02 or %g1, %g2, %g1 2007a7c: 82 10 40 11 or %g1, %l1, %g1 information->the_class, _Objects_Local_node, index ); the_object->name = (void *) name_area; 2007a80: e0 22 20 0c st %l0, [ %o0 + 0xc ] index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 2007a84: c2 22 20 08 st %g1, [ %o0 + 8 ] the_object->name = (void *) name_area; name_area = _Addresses_Add_offset( name_area, information->name_length ); _Chain_Append( &information->Inactive, &the_object->Node ); 2007a88: 92 10 00 08 mov %o0, %o1 2007a8c: a0 04 00 03 add %l0, %g3, %l0 index++; 2007a90: a2 04 60 01 inc %l1 the_object->name = (void *) name_area; name_area = _Addresses_Add_offset( name_area, information->name_length ); _Chain_Append( &information->Inactive, &the_object->Node ); 2007a94: 7f ff fc a0 call 2006d14 <_Chain_Append> 2007a98: 90 10 00 12 mov %l2, %o0 * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 2007a9c: 7f ff fc aa call 2006d44 <_Chain_Get> 2007aa0: 90 10 00 14 mov %l4, %o0 2007aa4: 80 a2 20 00 cmp %o0, 0 2007aa8: 32 bf ff ef bne,a 2007a64 <_Objects_Extend_information+0x1dc> 2007aac: c2 06 00 00 ld [ %i0 ], %g1 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 2007ab0: c6 06 20 38 ld [ %i0 + 0x38 ], %g3 2007ab4: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 information->inactive += information->allocation_size; 2007ab8: c8 16 20 34 lduh [ %i0 + 0x34 ], %g4 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 2007abc: c4 20 c0 13 st %g2, [ %g3 + %l3 ] information->inactive += information->allocation_size; 2007ac0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2007ac4: 82 00 40 04 add %g1, %g4, %g1 2007ac8: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 2007acc: 81 c7 e0 08 ret 2007ad0: 81 e8 00 00 restore block = 0; if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; 2007ad4: 90 10 00 12 mov %l2, %o0 2007ad8: 40 00 35 ea call 2015280 <.udiv> 2007adc: 92 10 00 10 mov %l0, %o1 for ( ; block < block_count; block++ ) { 2007ae0: 80 a2 20 00 cmp %o0, 0 2007ae4: 02 80 00 46 be 2007bfc <_Objects_Extend_information+0x374> 2007ae8: a8 10 00 11 mov %l1, %l4 if ( information->object_blocks[ block ] == NULL ) 2007aec: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 2007af0: c2 00 80 00 ld [ %g2 ], %g1 2007af4: 80 a0 60 00 cmp %g1, 0 2007af8: 12 80 00 08 bne 2007b18 <_Objects_Extend_information+0x290> 2007afc: ac 10 20 00 clr %l6 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 2007b00: 10 80 00 0c b 2007b30 <_Objects_Extend_information+0x2a8> <== NOT EXECUTED 2007b04: 80 a5 00 12 cmp %l4, %l2 <== NOT EXECUTED block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 2007b08: c2 00 40 02 ld [ %g1 + %g2 ], %g1 2007b0c: 80 a0 60 00 cmp %g1, 0 2007b10: 02 80 00 08 be 2007b30 <_Objects_Extend_information+0x2a8> 2007b14: 80 a5 00 12 cmp %l4, %l2 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 2007b18: ac 05 a0 01 inc %l6 if ( information->object_blocks[ block ] == NULL ) break; else index_base += information->allocation_size; 2007b1c: a8 05 00 10 add %l4, %l0, %l4 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 2007b20: 80 a5 80 08 cmp %l6, %o0 2007b24: 12 bf ff f9 bne 2007b08 <_Objects_Extend_information+0x280> 2007b28: 83 2d a0 02 sll %l6, 2, %g1 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 2007b2c: 80 a5 00 12 cmp %l4, %l2 2007b30: 2a bf ff a9 bcs,a 20079d4 <_Objects_Extend_information+0x14c> 2007b34: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 2007b38: a6 02 20 01 add %o0, 1, %l3 2007b3c: 83 2c e0 01 sll %l3, 1, %g1 2007b40: 90 00 40 13 add %g1, %l3, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2007b44: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 2007b48: 80 a0 60 00 cmp %g1, 0 2007b4c: 02 bf ff 60 be 20078cc <_Objects_Extend_information+0x44> 2007b50: ba 04 00 12 add %l0, %l2, %i5 2007b54: 92 02 00 11 add %o0, %l1, %o1 2007b58: 11 00 80 62 sethi %hi(0x2018800), %o0 2007b5c: 92 02 40 1d add %o1, %i5, %o1 2007b60: 90 12 20 2c or %o0, 0x2c, %o0 2007b64: 7f ff fd bd call 2007258 <_Heap_Allocate> 2007b68: 93 2a 60 02 sll %o1, 2, %o1 block_count * (sizeof(void *) + sizeof(uint32_t ) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 2007b6c: ae 92 20 00 orcc %o0, 0, %l7 2007b70: 32 bf ff 5d bne,a 20078e4 <_Objects_Extend_information+0x5c> 2007b74: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 2007b78: 81 c7 e0 08 ret <== NOT EXECUTED 2007b7c: 81 e8 00 00 restore <== NOT EXECUTED if ( !information->object_blocks[ block ] ) return; } else { information->object_blocks[ block ] = 2007b80: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 2007b84: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 2007b88: 40 00 35 84 call 2015198 <.umul> 2007b8c: 90 00 40 08 add %g1, %o0, %o0 2007b90: 40 00 0b b6 call 200aa68 <_Workspace_Allocate_or_fatal_error> 2007b94: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 2007b98: e4 06 20 3c ld [ %i0 + 0x3c ], %l2 2007b9c: a7 2d a0 02 sll %l6, 2, %l3 2007ba0: 10 bf ff a0 b 2007a20 <_Objects_Extend_information+0x198> 2007ba4: d0 24 c0 10 st %o0, [ %l3 + %l0 ] /* * Copy each section of the table over. This has to be performed as * separate parts as size of each block has changed. */ memcpy( object_blocks, 2007ba8: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 2007bac: a1 28 e0 02 sll %g3, 2, %l0 2007bb0: 90 10 00 17 mov %l7, %o0 2007bb4: 40 00 1b eb call 200eb60 2007bb8: 94 10 00 10 mov %l0, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 2007bbc: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 2007bc0: 94 10 00 10 mov %l0, %o2 2007bc4: 40 00 1b e7 call 200eb60 2007bc8: 90 10 00 13 mov %l3, %o0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, 2007bcc: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 2007bd0: 94 10 00 10 mov %l0, %o2 2007bd4: 40 00 1b e3 call 200eb60 2007bd8: 90 10 00 15 mov %l5, %o0 information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 2007bdc: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 2007be0: d2 06 20 20 ld [ %i0 + 0x20 ], %o1 2007be4: 94 02 80 11 add %o2, %l1, %o2 2007be8: 90 10 00 12 mov %l2, %o0 2007bec: 40 00 1b dd call 200eb60 2007bf0: 95 2a a0 02 sll %o2, 2, %o2 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 2007bf4: 10 bf ff 4e b 200792c <_Objects_Extend_information+0xa4> 2007bf8: c0 24 00 17 clr [ %l0 + %l7 ] if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 2007bfc: 10 bf ff cc b 2007b2c <_Objects_Extend_information+0x2a4> <== NOT EXECUTED 2007c00: ac 10 20 00 clr %l6 <== NOT EXECUTED 2007c04: 81 c7 e0 08 ret <== NOT EXECUTED 2007c08: 81 e8 00 00 restore <== NOT EXECUTED 02007ca0 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 2007ca0: 9d e3 bf 98 save %sp, -104, %sp Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 2007ca4: c2 06 20 08 ld [ %i0 + 8 ], %g1 _ISR_Disable( level ); 2007ca8: 7f ff e8 4e call 2001de0 2007cac: b2 26 40 01 sub %i1, %g1, %i1 { Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 2007cb0: b2 06 60 01 inc %i1 _ISR_Disable( level ); if ( information->maximum >= index ) { 2007cb4: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 2007cb8: 80 a6 40 01 cmp %i1, %g1 2007cbc: 18 80 00 0b bgu 2007ce8 <_Objects_Get_isr_disable+0x48> 2007cc0: 83 2e 60 02 sll %i1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 2007cc4: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 2007cc8: f0 00 80 01 ld [ %g2 + %g1 ], %i0 2007ccc: 80 a6 20 00 cmp %i0, 0 2007cd0: 02 80 00 0c be 2007d00 <_Objects_Get_isr_disable+0x60> 2007cd4: 01 00 00 00 nop *location = OBJECTS_LOCAL; *level_p = level; 2007cd8: d0 26 c0 00 st %o0, [ %i3 ] index = id - information->minimum_id + 1; _ISR_Disable( level ); if ( information->maximum >= index ) { if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; 2007cdc: c0 26 80 00 clr [ %i2 ] 2007ce0: 81 c7 e0 08 ret 2007ce4: 81 e8 00 00 restore } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 2007ce8: 7f ff e8 42 call 2001df0 2007cec: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; 2007cf0: 82 10 20 02 mov 2, %g1 2007cf4: c2 26 80 00 st %g1, [ %i2 ] _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 2007cf8: 81 c7 e0 08 ret 2007cfc: 81 e8 00 00 restore if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; *level_p = level; return the_object; } _ISR_Enable( level ); 2007d00: 7f ff e8 3c call 2001df0 <== NOT EXECUTED 2007d04: 01 00 00 00 nop <== NOT EXECUTED *location = OBJECTS_ERROR; 2007d08: 82 10 20 02 mov 2, %g1 ! 2 <== NOT EXECUTED 2007d0c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 2007d10: 81 c7 e0 08 ret <== NOT EXECUTED 2007d14: 81 e8 00 00 restore <== NOT EXECUTED 020097b4 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 20097b4: 9d e3 bf 88 save %sp, -120, %sp 20097b8: 92 10 00 18 mov %i0, %o1 uint32_t i; char lname[5]; Objects_Control *the_object; Objects_Locations location; if ( length == 0 ) 20097bc: 80 a6 60 00 cmp %i1, 0 20097c0: 12 80 00 04 bne 20097d0 <_Objects_Get_name_as_string+0x1c> 20097c4: b0 10 00 1a mov %i2, %i0 _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 20097c8: 81 c7 e0 08 ret <== NOT EXECUTED 20097cc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED Objects_Locations location; if ( length == 0 ) return NULL; if ( name == NULL ) 20097d0: 80 a6 a0 00 cmp %i2, 0 20097d4: 02 80 00 40 be 20098d4 <_Objects_Get_name_as_string+0x120> 20097d8: 87 32 60 16 srl %o1, 0x16, %g3 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 20097dc: 03 00 80 93 sethi %hi(0x2024c00), %g1 20097e0: 86 08 e0 1c and %g3, 0x1c, %g3 20097e4: 82 10 61 20 or %g1, 0x120, %g1 20097e8: c8 00 40 03 ld [ %g1 + %g3 ], %g4 20097ec: 85 32 60 1b srl %o1, 0x1b, %g2 20097f0: 85 28 a0 02 sll %g2, 2, %g2 20097f4: f4 01 00 02 ld [ %g4 + %g2 ], %i2 return NULL; information = _Objects_Get_information( id ); if ( !information ) 20097f8: 80 a6 a0 00 cmp %i2, 0 20097fc: 22 80 00 36 be,a 20098d4 <_Objects_Get_name_as_string+0x120> 2009800: b0 10 20 00 clr %i0 <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, id, &location ); 2009804: 90 10 00 1a mov %i2, %o0 2009808: 40 00 00 3f call 2009904 <_Objects_Get> 200980c: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 2009810: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009814: 80 a0 60 00 cmp %g1, 0 2009818: 32 80 00 2f bne,a 20098d4 <_Objects_Get_name_as_string+0x120> 200981c: b0 10 20 00 clr %i0 <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 2009820: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1 2009824: 80 a0 60 00 cmp %g1, 0 2009828: 22 80 00 2d be,a 20098dc <_Objects_Get_name_as_string+0x128> 200982c: c2 02 20 0c ld [ %o0 + 0xc ], %g1 s = the_object->name; 2009830: d0 02 20 0c ld [ %o0 + 0xc ], %o0 lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { 2009834: 80 a6 60 01 cmp %i1, 1 2009838: 02 80 00 1c be 20098a8 <_Objects_Get_name_as_string+0xf4> 200983c: 9a 10 00 18 mov %i0, %o5 2009840: c8 0a 00 00 ldub [ %o0 ], %g4 2009844: 85 29 20 18 sll %g4, 0x18, %g2 2009848: 80 a0 a0 00 cmp %g2, 0 200984c: 22 80 00 18 be,a 20098ac <_Objects_Get_name_as_string+0xf8> 2009850: c0 2b 40 00 clrb [ %o5 ] <== NOT EXECUTED 2009854: b2 06 7f ff add %i1, -1, %i1 2009858: 98 10 20 00 clr %o4 200985c: 10 80 00 07 b 2009878 <_Objects_Get_name_as_string+0xc4> 2009860: 17 00 80 71 sethi %hi(0x201c400), %o3 2009864: c8 0a 00 00 ldub [ %o0 ], %g4 2009868: 85 29 20 18 sll %g4, 0x18, %g2 200986c: 80 a0 a0 00 cmp %g2, 0 2009870: 22 80 00 0f be,a 20098ac <_Objects_Get_name_as_string+0xf8> 2009874: c0 2b 40 00 clrb [ %o5 ] <== NOT EXECUTED *d = (!isprint(*s)) ? '*' : *s; 2009878: c2 02 e2 f0 ld [ %o3 + 0x2f0 ], %g1 200987c: 85 38 a0 18 sra %g2, 0x18, %g2 2009880: c6 48 80 01 ldsb [ %g2 + %g1 ], %g3 2009884: 80 88 e0 97 btst 0x97, %g3 2009888: 12 80 00 03 bne 2009894 <_Objects_Get_name_as_string+0xe0> 200988c: 90 02 20 01 inc %o0 2009890: 88 10 20 2a mov 0x2a, %g4 <== NOT EXECUTED 2009894: c8 2b 40 00 stb %g4, [ %o5 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { 2009898: 98 03 20 01 inc %o4 200989c: 80 a3 00 19 cmp %o4, %i1 20098a0: 12 bf ff f1 bne 2009864 <_Objects_Get_name_as_string+0xb0> 20098a4: 9a 03 60 01 inc %o5 *d = (!isprint(*s)) ? '*' : *s; } *d = '\0'; 20098a8: c0 2b 40 00 clrb [ %o5 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20098ac: 03 00 80 93 sethi %hi(0x2024c00), %g1 20098b0: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 2024dc0 <_Thread_Dispatch_disable_level> 20098b4: 84 00 bf ff add %g2, -1, %g2 20098b8: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 20098bc: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 20098c0: 80 a0 e0 00 cmp %g3, 0 20098c4: 12 80 00 04 bne 20098d4 <_Objects_Get_name_as_string+0x120> 20098c8: 01 00 00 00 nop _Thread_Dispatch(); 20098cc: 40 00 05 06 call 200ace4 <_Thread_Dispatch> 20098d0: 01 00 00 00 nop 20098d4: 81 c7 e0 08 ret 20098d8: 81 e8 00 00 restore lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20098dc: c0 2f bf f3 clrb [ %fp + -13 ] if ( information->is_string ) { s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; 20098e0: 85 30 60 18 srl %g1, 0x18, %g2 lname[ 1 ] = (u32_name >> 16) & 0xff; 20098e4: 87 30 60 10 srl %g1, 0x10, %g3 lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; 20098e8: c2 2f bf f2 stb %g1, [ %fp + -14 ] if ( information->is_string ) { s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; 20098ec: c4 2f bf ef stb %g2, [ %fp + -17 ] lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 20098f0: 83 30 60 08 srl %g1, 8, %g1 s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; 20098f4: c6 2f bf f0 stb %g3, [ %fp + -16 ] lname[ 2 ] = (u32_name >> 8) & 0xff; 20098f8: c2 2f bf f1 stb %g1, [ %fp + -15 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20098fc: 10 bf ff ce b 2009834 <_Objects_Get_name_as_string+0x80> 2009900: 90 07 bf ef add %fp, -17, %o0 02019660 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 2019660: 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) 2019664: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 2019668: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <== NOT EXECUTED 201966c: 80 8e 40 01 btst %i1, %g1 <== NOT EXECUTED 2019670: 22 80 00 02 be,a 2019678 <_Objects_Get_next+0x18> <== NOT EXECUTED 2019674: 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) 2019678: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 201967c: a0 10 63 ff or %g1, 0x3ff, %l0 ! ffff <== NOT EXECUTED 2019680: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED 2019684: 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); 2019688: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 201968c: 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) 2019690: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2019694: 18 80 00 0b bgu 20196c0 <_Objects_Get_next+0x60> <== NOT EXECUTED 2019698: 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); 201969c: 7f ff d6 35 call 200ef70 <_Objects_Get> <== NOT EXECUTED 20196a0: b2 06 60 01 inc %i1 <== NOT EXECUTED next_id++; } while (*location_p != OBJECTS_LOCAL); 20196a4: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 20196a8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20196ac: 32 bf ff f6 bne,a 2019684 <_Objects_Get_next+0x24> <== NOT EXECUTED 20196b0: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED *next_id_p = next_id; 20196b4: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 20196b8: 81 c7 e0 08 ret <== NOT EXECUTED 20196bc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 20196c0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 20196c4: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED 20196c8: 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; 20196cc: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 20196d0: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED return 0; } 20196d4: 81 c7 e0 08 ret <== NOT EXECUTED 20196d8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 02015510 <_Objects_Get_no_protection>: ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 2015510: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->maximum >= index ) { 2015514: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 2015518: 92 22 40 01 sub %o1, %g1, %o1 201551c: 82 02 60 01 add %o1, 1, %g1 if ( information->maximum >= index ) { 2015520: 80 a0 40 02 cmp %g1, %g2 2015524: 18 80 00 09 bgu 2015548 <_Objects_Get_no_protection+0x38> 2015528: 83 28 60 02 sll %g1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 201552c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2015530: d0 00 80 01 ld [ %g2 + %g1 ], %o0 2015534: 80 a2 20 00 cmp %o0, 0 2015538: 02 80 00 08 be 2015558 <_Objects_Get_no_protection+0x48> 201553c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_LOCAL; 2015540: 81 c3 e0 08 retl 2015544: c0 22 80 00 clr [ %o2 ] return the_object; } *location = OBJECTS_ERROR; return NULL; } *location = OBJECTS_ERROR; 2015548: 82 10 20 02 mov 2, %g1 201554c: 90 10 20 00 clr %o0 /* * Not supported for multiprocessing */ return NULL; } 2015550: 81 c3 e0 08 retl 2015554: c2 22 80 00 st %g1, [ %o2 ] if ( information->maximum >= index ) { if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; return the_object; } *location = OBJECTS_ERROR; 2015558: 81 c3 e0 08 retl <== NOT EXECUTED 201555c: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED 02007f7c <_Objects_Handler_initialization>: uint32_t node, uint32_t maximum_nodes, uint32_t maximum_global_objects ) { if ( node < 1 || node > maximum_nodes ) 2007f7c: 80 a2 20 00 cmp %o0, 0 2007f80: 22 80 00 07 be,a 2007f9c <_Objects_Handler_initialization+0x20> 2007f84: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007f88: 80 a2 00 09 cmp %o0, %o1 2007f8c: 18 80 00 04 bgu 2007f9c <_Objects_Handler_initialization+0x20> 2007f90: 90 10 20 00 clr %o0 2007f94: 81 c3 e0 08 retl 2007f98: 01 00 00 00 nop _Internal_error_Occurred( 2007f9c: 92 10 20 01 mov 1, %o1 ! 1 <== NOT EXECUTED 2007fa0: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED 2007fa4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2007fa8: 7f ff fd de call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 2007fac: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2007fb0: 01 00 00 00 nop 020092b0 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 20092b0: 9d e3 bf 90 save %sp, -112, %sp 20092b4: 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 ) 20092b8: 80 a6 60 00 cmp %i1, 0 20092bc: 02 80 00 24 be 200934c <_Objects_Id_to_name+0x9c> 20092c0: 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); 20092c4: 83 32 60 18 srl %o1, 0x18, %g1 20092c8: 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 ) 20092cc: 80 a0 60 04 cmp %g1, 4 20092d0: 18 80 00 25 bgu 2009364 <_Objects_Id_to_name+0xb4> 20092d4: 87 28 60 02 sll %g1, 2, %g3 return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( id ); information = _Objects_Information_table[ the_api ][ the_class ]; 20092d8: 03 00 80 72 sethi %hi(0x201c800), %g1 20092dc: 82 10 62 80 or %g1, 0x280, %g1 ! 201ca80 <_Objects_Information_table> 20092e0: c8 00 40 03 ld [ %g1 + %g3 ], %g4 20092e4: 85 32 60 1b srl %o1, 0x1b, %g2 20092e8: 85 28 a0 02 sll %g2, 2, %g2 20092ec: d0 01 00 02 ld [ %g4 + %g2 ], %o0 if ( !information ) 20092f0: 80 a2 20 00 cmp %o0, 0 20092f4: 02 80 00 1c be 2009364 <_Objects_Id_to_name+0xb4> 20092f8: 01 00 00 00 nop return OBJECTS_INVALID_ID; if ( information->is_string ) 20092fc: c2 02 20 40 ld [ %o0 + 0x40 ], %g1 2009300: 80 a0 60 00 cmp %g1, 0 2009304: 12 80 00 18 bne 2009364 <_Objects_Id_to_name+0xb4> 2009308: 01 00 00 00 nop return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, id, &ignored_location ); 200930c: 7f ff ff c2 call 2009214 <_Objects_Get> 2009310: 94 07 bf f4 add %fp, -12, %o2 if ( !the_object ) 2009314: 80 a2 20 00 cmp %o0, 0 2009318: 02 80 00 13 be 2009364 <_Objects_Id_to_name+0xb4> 200931c: 01 00 00 00 nop return OBJECTS_INVALID_ID; *name = the_object->name; 2009320: c2 02 20 0c ld [ %o0 + 0xc ], %g1 2009324: 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 ) 2009328: 07 00 80 72 sethi %hi(0x201c800), %g3 200932c: c2 00 e3 20 ld [ %g3 + 0x320 ], %g1 ! 201cb20 <_Thread_Dispatch_disable_level> 2009330: b0 10 20 00 clr %i0 2009334: 82 00 7f ff add %g1, -1, %g1 2009338: c2 20 e3 20 st %g1, [ %g3 + 0x320 ] 200933c: c4 00 e3 20 ld [ %g3 + 0x320 ], %g2 2009340: 80 a0 a0 00 cmp %g2, 0 2009344: 02 80 00 04 be 2009354 <_Objects_Id_to_name+0xa4> 2009348: 01 00 00 00 nop _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 200934c: 81 c7 e0 08 ret <== NOT EXECUTED 2009350: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 2009354: 40 00 05 13 call 200a7a0 <_Thread_Dispatch> 2009358: 01 00 00 00 nop 200935c: 81 c7 e0 08 ret 2009360: 81 e8 00 00 restore 2009364: 81 c7 e0 08 ret <== NOT EXECUTED 2009368: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED 02007db4 <_Objects_Initialize_information>: , boolean supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 2007db4: 9d e3 bf 98 save %sp, -104, %sp /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 2007db8: 03 00 80 61 sethi %hi(0x2018400), %g1 2007dbc: 85 2e 60 02 sll %i1, 2, %g2 2007dc0: 82 10 63 40 or %g1, 0x340, %g1 2007dc4: c8 00 40 02 ld [ %g1 + %g2 ], %g4 , boolean supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 2007dc8: de 07 a0 5c ld [ %fp + 0x5c ], %o7 /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; 2007dcc: 83 36 e0 1f srl %i3, 0x1f, %g1 maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 2007dd0: 05 20 00 00 sethi %hi(0x80000000), %g2 /* * Set the size of the object */ information->size = size; 2007dd4: b9 2f 20 10 sll %i4, 0x10, %i4 2007dd8: b9 37 20 10 srl %i4, 0x10, %i4 uint32_t index; #endif information->the_api = the_api; information->the_class = the_class; information->is_string = is_string; 2007ddc: fa 26 20 40 st %i5, [ %i0 + 0x40 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 2007de0: 87 2e 60 18 sll %i1, 0x18, %g3 2007de4: bb 2e a0 1b sll %i2, 0x1b, %i5 /* * Set the size of the object */ information->size = size; 2007de8: f8 26 20 1c st %i4, [ %i0 + 0x1c ] #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; information->the_class = the_class; 2007dec: f4 36 20 04 sth %i2, [ %i0 + 4 ] /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 2007df0: b8 2e c0 02 andn %i3, %g2, %i4 /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 2007df4: b5 2e a0 02 sll %i2, 2, %i2 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 2007df8: 80 a0 00 1c cmp %g0, %i4 /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 2007dfc: f0 21 00 1a st %i0, [ %g4 + %i2 ] /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; 2007e00: c2 26 20 14 st %g1, [ %i0 + 0x14 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 2007e04: 88 40 20 00 addx %g0, 0, %g4 /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 2007e08: 03 00 80 61 sethi %hi(0x2018400), %g1 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 2007e0c: 05 00 00 40 sethi %hi(0x10000), %g2 /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 2007e10: 82 10 60 38 or %g1, 0x38, %g1 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 2007e14: 86 10 c0 02 or %g3, %g2, %g3 /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 2007e18: c2 26 20 20 st %g1, [ %i0 + 0x20 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 2007e1c: 86 10 c0 1d or %g3, %i5, %g3 uint32_t name_length; #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; 2007e20: f2 26 00 00 st %i1, [ %i0 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 2007e24: 86 10 c0 04 or %g3, %g4, %g3 information->the_api = the_api; information->the_class = the_class; information->is_string = is_string; information->local_table = 0; information->name_table = 0; 2007e28: c0 26 20 24 clr [ %i0 + 0x24 ] information->inactive_per_block = 0; 2007e2c: c0 26 20 38 clr [ %i0 + 0x38 ] information->object_blocks = 0; 2007e30: c0 26 20 3c clr [ %i0 + 0x3c ] information->inactive = 0; 2007e34: c0 36 20 34 clrh [ %i0 + 0x34 ] /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 2007e38: f8 26 20 18 st %i4, [ %i0 + 0x18 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 2007e3c: c6 26 20 08 st %g3, [ %i0 + 8 ] * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) 2007e40: 80 8b e0 03 btst 3, %o7 2007e44: 02 80 00 04 be 2007e54 <_Objects_Initialize_information+0xa0> 2007e48: 82 10 00 0f mov %o7, %g1 name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 2007e4c: 82 03 e0 04 add %o7, 4, %g1 <== NOT EXECUTED 2007e50: 82 08 7f fc and %g1, -4, %g1 <== NOT EXECUTED ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 2007e54: c2 36 20 44 sth %g1, [ %i0 + 0x44 ] Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2007e58: 84 06 20 28 add %i0, 0x28, %g2 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2007e5c: 82 06 20 2c add %i0, 0x2c, %g1 the_chain->permanent_null = NULL; 2007e60: c0 26 20 2c clr [ %i0 + 0x2c ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2007e64: c2 26 20 28 st %g1, [ %i0 + 0x28 ] /* * Initialize objects .. if there are any */ if ( maximum ) { 2007e68: 80 a7 20 00 cmp %i4, 0 2007e6c: 12 80 00 04 bne 2007e7c <_Objects_Initialize_information+0xc8> 2007e70: c4 26 20 30 st %g2, [ %i0 + 0x30 ] 2007e74: 81 c7 e0 08 ret 2007e78: 81 e8 00 00 restore /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 2007e7c: c0 36 20 10 clrh [ %i0 + 0x10 ] * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 2007e80: 7f ff fe 82 call 2007888 <_Objects_Extend_information> 2007e84: 81 e8 00 00 restore 2007e88: 01 00 00 00 nop 02007e8c <_Objects_Name_to_id>: Objects_Information *information, Objects_Name name, uint32_t node, Objects_Id *id ) { 2007e8c: 9d e3 bf 98 save %sp, -104, %sp 2007e90: 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 ) 2007e94: 80 a6 e0 00 cmp %i3, 0 2007e98: 02 80 00 2d be 2007f4c <_Objects_Name_to_id+0xc0> 2007e9c: b0 10 20 02 mov 2, %i0 return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 2007ea0: 80 a6 60 00 cmp %i1, 0 2007ea4: 02 80 00 28 be 2007f44 <_Objects_Name_to_id+0xb8> 2007ea8: 01 00 00 00 nop return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007eac: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 2007eb0: 86 90 60 00 orcc %g1, 0, %g3 2007eb4: 02 80 00 24 be 2007f44 <_Objects_Name_to_id+0xb8> 2007eb8: 80 a6 a0 00 cmp %i2, 0 2007ebc: 12 80 00 26 bne 2007f54 <_Objects_Name_to_id+0xc8> 2007ec0: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; 2007ec4: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2007ec8: 05 00 80 34 sethi %hi(0x200d000), %g2 2007ecc: 80 a0 60 00 cmp %g1, 0 2007ed0: a4 10 a2 58 or %g2, 0x258, %l2 2007ed4: 02 80 00 04 be 2007ee4 <_Objects_Name_to_id+0x58> 2007ed8: c8 14 60 44 lduh [ %l1 + 0x44 ], %g4 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007edc: 03 00 80 34 sethi %hi(0x200d000), %g1 <== NOT EXECUTED 2007ee0: a4 10 62 68 or %g1, 0x268, %l2 ! 200d268 <_Objects_Compare_name_string> <== NOT EXECUTED 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 ) ) { 2007ee4: 83 29 20 10 sll %g4, 0x10, %g1 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007ee8: 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 ) ) { 2007eec: 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 ]; 2007ef0: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 2007ef4: 83 2c 20 02 sll %l0, 2, %g1 2007ef8: f4 00 80 01 ld [ %g2 + %g1 ], %i2 if ( !the_object || !the_object->name ) 2007efc: 80 a6 a0 00 cmp %i2, 0 2007f00: 02 80 00 0c be 2007f30 <_Objects_Name_to_id+0xa4> 2007f04: a0 04 20 01 inc %l0 2007f08: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 2007f0c: 80 a2 60 00 cmp %o1, 0 2007f10: 02 80 00 08 be 2007f30 <_Objects_Name_to_id+0xa4> 2007f14: 90 10 00 19 mov %i1, %o0 continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 2007f18: 9f c4 80 00 call %l2 2007f1c: 94 10 00 18 mov %i0, %o2 2007f20: 80 a2 20 00 cmp %o0, 0 2007f24: 32 80 00 13 bne,a 2007f70 <_Objects_Name_to_id+0xe4> 2007f28: c2 06 a0 08 ld [ %i2 + 8 ], %g1 2007f2c: c6 14 60 10 lduh [ %l1 + 0x10 ], %g3 name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; else compare_them = _Objects_Compare_name_raw; for ( index = 1; index <= information->maximum; index++ ) { 2007f30: 83 28 e0 10 sll %g3, 0x10, %g1 2007f34: 83 30 60 10 srl %g1, 0x10, %g1 2007f38: 80 a0 40 10 cmp %g1, %l0 2007f3c: 3a bf ff ee bcc,a 2007ef4 <_Objects_Name_to_id+0x68> 2007f40: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 2007f44: 81 c7 e0 08 ret 2007f48: 91 e8 20 01 restore %g0, 1, %o0 return ( _Objects_MP_Global_name_search( information, name, node, id ) ); #else return OBJECTS_INVALID_NAME; #endif } 2007f4c: 81 c7 e0 08 ret <== NOT EXECUTED 2007f50: 81 e8 00 00 restore <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007f54: 82 10 63 ff or %g1, 0x3ff, %g1 2007f58: 80 a6 80 01 cmp %i2, %g1 2007f5c: 02 bf ff da be 2007ec4 <_Objects_Name_to_id+0x38> 2007f60: 80 a6 a0 01 cmp %i2, 1 2007f64: 22 bf ff d9 be,a 2007ec8 <_Objects_Name_to_id+0x3c> 2007f68: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2007f6c: 30 bf ff f6 b,a 2007f44 <_Objects_Name_to_id+0xb8> the_object = information->local_table[ index ]; if ( !the_object || !the_object->name ) continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { *id = the_object->id; 2007f70: c2 26 c0 00 st %g1, [ %i3 ] 2007f74: 81 c7 e0 08 ret 2007f78: 91 e8 20 00 restore %g0, 0, %o0 02007fb4 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 2007fb4: 9d e3 bf 98 save %sp, -104, %sp 2007fb8: 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; 2007fbc: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 2007fc0: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0 2007fc4: 03 00 00 3f sethi %hi(0xfc00), %g1 2007fc8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2007fcc: 92 10 00 10 mov %l0, %o1 2007fd0: a2 08 80 01 and %g2, %g1, %l1 2007fd4: 40 00 34 ab call 2015280 <.udiv> 2007fd8: 90 22 00 11 sub %o0, %l1, %o0 for ( block = 0; block < block_count; block++ ) { 2007fdc: 80 a2 20 00 cmp %o0, 0 2007fe0: 02 80 00 15 be 2008034 <_Objects_Shrink_information+0x80> 2007fe4: 86 10 20 00 clr %g3 if ( information->inactive_per_block[ block ] == information->allocation_size ) { 2007fe8: c8 06 20 38 ld [ %i0 + 0x38 ], %g4 2007fec: c2 01 00 00 ld [ %g4 ], %g1 2007ff0: 84 10 20 04 mov 4, %g2 2007ff4: 80 a4 00 01 cmp %l0, %g1 2007ff8: a8 10 20 00 clr %l4 2007ffc: 12 80 00 0a bne 2008024 <_Objects_Shrink_information+0x70> 2008000: a4 10 20 00 clr %l2 /* * XXX - Not to sure how to use a chain where you need to iterate and * and remove elements. */ the_object = (Objects_Control *) information->Inactive.first; 2008004: 10 80 00 10 b 2008044 <_Objects_Shrink_information+0x90> <== NOT EXECUTED 2008008: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 <== NOT EXECUTED information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 200800c: a2 04 40 10 add %l1, %l0, %l1 index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == information->allocation_size ) { 2008010: 80 a4 00 01 cmp %l0, %g1 information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 2008014: a4 10 00 02 mov %g2, %l2 index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == information->allocation_size ) { 2008018: 02 80 00 09 be 200803c <_Objects_Shrink_information+0x88> 200801c: 82 00 a0 04 add %g2, 4, %g1 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; return; 2008020: 84 10 00 01 mov %g1, %g2 */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 2008024: 86 00 e0 01 inc %g3 2008028: 80 a0 c0 08 cmp %g3, %o0 200802c: 32 bf ff f8 bne,a 200800c <_Objects_Shrink_information+0x58> 2008030: c2 00 80 04 ld [ %g2 + %g4 ], %g1 2008034: 81 c7 e0 08 ret 2008038: 81 e8 00 00 restore if ( information->inactive_per_block[ block ] == information->allocation_size ) { 200803c: a8 10 00 02 mov %g2, %l4 /* * XXX - Not to sure how to use a chain where you need to iterate and * and remove elements. */ the_object = (Objects_Control *) information->Inactive.first; 2008040: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 2008044: 03 00 00 3f sethi %hi(0xfc00), %g1 2008048: e0 02 00 00 ld [ %o0 ], %l0 200804c: 10 80 00 10 b 200808c <_Objects_Shrink_information+0xd8> 2008050: a6 10 63 ff or %g1, 0x3ff, %l3 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 2008054: 82 04 40 01 add %l1, %g1, %g1 2008058: 80 a0 80 01 cmp %g2, %g1 200805c: 3a 80 00 12 bcc,a 20080a4 <_Objects_Shrink_information+0xf0> 2008060: 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 ); 2008064: 40 00 13 5e call 200cddc <_Chain_Extract> 2008068: 01 00 00 00 nop 200806c: 90 10 00 10 mov %l0, %o0 } else { the_object = (Objects_Control *) the_object->Node.next; } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 2008070: 80 a2 20 00 cmp %o0, 0 2008074: 22 80 00 10 be,a 20080b4 <_Objects_Shrink_information+0x100> 2008078: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_last( const Chain_Node *the_node ) { return (the_node->next == NULL); 200807c: e0 02 00 00 ld [ %o0 ], %l0 2008080: 80 a4 20 00 cmp %l0, 0 2008084: 22 80 00 0c be,a 20080b4 <_Objects_Shrink_information+0x100> 2008088: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 200808c: c2 02 20 08 ld [ %o0 + 8 ], %g1 2008090: 84 08 40 13 and %g1, %l3, %g2 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 2008094: 80 a4 40 02 cmp %l1, %g2 2008098: 28 bf ff ef bleu,a 2008054 <_Objects_Shrink_information+0xa0> 200809c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 20080a0: 90 10 00 10 mov %l0, %o0 } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 20080a4: 80 a2 20 00 cmp %o0, 0 20080a8: 32 bf ff f6 bne,a 2008080 <_Objects_Shrink_information+0xcc> 20080ac: e0 02 00 00 ld [ %o0 ], %l0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 20080b0: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED 20080b4: 11 00 80 62 sethi %hi(0x2018800), %o0 20080b8: d2 00 40 14 ld [ %g1 + %l4 ], %o1 20080bc: 7f ff fc 99 call 2007320 <_Heap_Free> 20080c0: 90 12 20 2c or %o0, 0x2c, %o0 */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 20080c4: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 20080c8: c8 06 20 24 ld [ %i0 + 0x24 ], %g4 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 20080cc: c0 24 80 02 clr [ %l2 + %g2 ] information->inactive -= information->allocation_size; 20080d0: c2 16 20 34 lduh [ %i0 + 0x34 ], %g1 * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; 20080d4: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 20080d8: c6 06 20 18 ld [ %i0 + 0x18 ], %g3 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 20080dc: c0 25 00 04 clr [ %l4 + %g4 ] information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 20080e0: 82 20 40 03 sub %g1, %g3, %g1 * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; 20080e4: c0 25 00 02 clr [ %l4 + %g2 ] information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 20080e8: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 20080ec: 81 c7 e0 08 ret 20080f0: 81 e8 00 00 restore 020080f4 <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 20080f4: 9d e3 bf 98 save %sp, -104, %sp void *p; _RTEMS_Lock_allocator(); 20080f8: 7f ff e7 3a call 2001de0 20080fc: 01 00 00 00 nop 2008100: a4 10 00 08 mov %o0, %l2 2008104: 23 00 80 61 sethi %hi(0x2018400), %l1 2008108: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> 200810c: 80 a0 60 00 cmp %g1, 0 2008110: 02 80 00 0b be 200813c <_Protected_heap_Allocate+0x48> 2008114: 27 00 80 62 sethi %hi(0x2018800), %l3 2008118: 03 00 80 62 sethi %hi(0x2018800), %g1 200811c: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20189c0 <_System_state_Current> 2008120: 80 a0 a0 01 cmp %g2, 1 2008124: 08 80 00 06 bleu 200813c <_Protected_heap_Allocate+0x48> 2008128: 90 10 20 00 clr %o0 200812c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008130: 7f ff fd 7c call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 2008134: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2008138: 27 00 80 62 sethi %hi(0x2018800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200813c: 09 00 80 62 sethi %hi(0x2018800), %g4 2008140: e0 04 e0 b8 ld [ %l3 + 0xb8 ], %l0 2008144: c4 01 20 c0 ld [ %g4 + 0xc0 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2008148: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200814c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2008150: 80 a0 60 00 cmp %g1, 0 2008154: 22 80 00 27 be,a 20081f0 <_Protected_heap_Allocate+0xfc> 2008158: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200815c: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008160: 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; 2008164: 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; 2008168: 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; 200816c: 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; 2008170: 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 ) || 2008174: 80 a0 e0 02 cmp %g3, 2 2008178: 12 80 00 2d bne 200822c <_Protected_heap_Allocate+0x138> 200817c: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008180: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008184: 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++; 2008188: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200818c: 02 80 00 46 be 20082a4 <_Protected_heap_Allocate+0x1b0> 2008190: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 2008194: 7f ff e7 17 call 2001df0 2008198: 90 10 00 12 mov %l2, %o0 p = _Heap_Allocate( the_heap, size ); 200819c: 90 10 00 18 mov %i0, %o0 20081a0: 7f ff fc 2e call 2007258 <_Heap_Allocate> 20081a4: 92 10 00 19 mov %i1, %o1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20081a8: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 20081ac: b0 10 00 08 mov %o0, %i0 20081b0: 82 00 60 01 inc %g1 20081b4: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] _RTEMS_Unlock_allocator(); 20081b8: d0 04 e0 b8 ld [ %l3 + 0xb8 ], %o0 20081bc: 94 10 20 00 clr %o2 20081c0: d2 02 20 08 ld [ %o0 + 8 ], %o1 20081c4: 7f ff fb 54 call 2006f14 <_CORE_mutex_Surrender> 20081c8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20081cc: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 20081d0: 82 00 7f ff add %g1, -1, %g1 20081d4: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] 20081d8: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 20081dc: 80 a0 a0 00 cmp %g2, 0 20081e0: 02 80 00 2d be 2008294 <_Protected_heap_Allocate+0x1a0> 20081e4: 01 00 00 00 nop return p; } 20081e8: 81 c7 e0 08 ret 20081ec: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 20081f0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20081f4: 12 80 00 16 bne 200824c <_Protected_heap_Allocate+0x158> <== NOT EXECUTED 20081f8: c6 04 e0 b8 ld [ %l3 + 0xb8 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20081fc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2008200: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008204: 22 80 00 43 be,a 2008310 <_Protected_heap_Allocate+0x21c> <== NOT EXECUTED 2008208: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200820c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008210: 12 80 00 0f bne 200824c <_Protected_heap_Allocate+0x158> <== NOT EXECUTED 2008214: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2008218: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200821c: 7f ff e6 f5 call 2001df0 <== NOT EXECUTED 2008220: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { void *p; _RTEMS_Lock_allocator(); p = _Heap_Allocate( the_heap, size ); 2008224: 10 bf ff df b 20081a0 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 2008228: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200822c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008230: 12 bf ff d9 bne 2008194 <_Protected_heap_Allocate+0xa0> <== NOT EXECUTED 2008234: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008238: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200823c: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008240: 02 80 00 19 be 20082a4 <_Protected_heap_Allocate+0x1b0> <== NOT EXECUTED 2008244: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 2008248: 30 bf ff d3 b,a 2008194 <_Protected_heap_Allocate+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200824c: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED size_t size ) { void *p; _RTEMS_Lock_allocator(); 2008250: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2008254: c8 01 20 c0 ld [ %g4 + 0xc0 ], %g4 <== NOT EXECUTED 2008258: 82 00 60 01 inc %g1 <== NOT EXECUTED 200825c: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2008260: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 2008264: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2008268: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200826c: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2008270: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2008274: 7f ff e6 df call 2001df0 <== NOT EXECUTED 2008278: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 200827c: d0 04 e0 b8 ld [ %l3 + 0xb8 ], %o0 <== NOT EXECUTED 2008280: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008284: 7f ff fb 00 call 2006e84 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2008288: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 200828c: 10 bf ff c5 b 20081a0 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 2008290: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2008294: 40 00 03 d5 call 20091e8 <_Thread_Dispatch> 2008298: 01 00 00 00 nop 200829c: 81 c7 e0 08 ret 20082a0: 81 e8 00 00 restore */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 20082a4: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 20082a8: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 20082ac: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 20082b0: 02 80 00 28 be 2008350 <_Protected_heap_Allocate+0x25c> <== NOT EXECUTED 20082b4: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 20082b8: 1a 80 00 1c bcc 2008328 <_Protected_heap_Allocate+0x234> <== NOT EXECUTED 20082bc: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20082c0: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 20082c4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20082c8: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20082cc: 7f ff e6 c9 call 2001df0 <== NOT EXECUTED 20082d0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 20082d4: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 20082d8: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 20082dc: 40 00 02 93 call 2008d28 <_Thread_Change_priority> <== NOT EXECUTED 20082e0: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20082e4: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 20082e8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20082ec: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 20082f0: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 <== NOT EXECUTED 20082f4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20082f8: 32 bf ff aa bne,a 20081a0 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 20082fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2008300: 40 00 03 ba call 20091e8 <_Thread_Dispatch> <== NOT EXECUTED 2008304: 01 00 00 00 nop <== NOT EXECUTED 2008308: 10 bf ff a6 b 20081a0 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 200830c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2008310: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008314: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2008318: 7f ff e6 b6 call 2001df0 <== NOT EXECUTED 200831c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008320: 10 bf ff a0 b 20081a0 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 2008324: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008328: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200832c: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2008330: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2008334: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008338: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200833c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008340: 7f ff e6 ac call 2001df0 <== NOT EXECUTED 2008344: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008348: 10 bf ff 96 b 20081a0 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 200834c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2008350: 7f ff e6 a8 call 2001df0 <== NOT EXECUTED 2008354: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008358: 10 bf ff 92 b 20081a0 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 200835c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 02008360 <_Protected_heap_Extend>: boolean _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 2008360: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 2008364: 7f ff e6 9f call 2001de0 <== NOT EXECUTED 2008368: 01 00 00 00 nop <== NOT EXECUTED 200836c: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 2008370: 23 00 80 61 sethi %hi(0x2018400), %l1 <== NOT EXECUTED 2008374: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008378: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200837c: 02 80 00 0b be 20083a8 <_Protected_heap_Extend+0x48> <== NOT EXECUTED 2008380: 27 00 80 62 sethi %hi(0x2018800), %l3 <== NOT EXECUTED 2008384: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008388: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20189c0 <_System_state_Current> <== NOT EXECUTED 200838c: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2008390: 08 80 00 06 bleu 20083a8 <_Protected_heap_Extend+0x48> <== NOT EXECUTED 2008394: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008398: 92 10 20 00 clr %o1 <== NOT EXECUTED 200839c: 7f ff fc e1 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 20083a0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 20083a4: 27 00 80 62 sethi %hi(0x2018800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 20083a8: 09 00 80 62 sethi %hi(0x2018800), %g4 <== NOT EXECUTED 20083ac: e0 04 e0 b8 ld [ %l3 + 0xb8 ], %l0 <== NOT EXECUTED 20083b0: c4 01 20 c0 ld [ %g4 + 0xc0 ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20083b4: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 20083b8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 20083bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20083c0: 22 80 00 2d be,a 2008474 <_Protected_heap_Extend+0x114> <== NOT EXECUTED 20083c4: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20083c8: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20083cc: 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; 20083d0: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 20083d4: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20083d8: 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; 20083dc: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20083e0: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 20083e4: 12 80 00 33 bne 20084b0 <_Protected_heap_Extend+0x150> <== NOT EXECUTED 20083e8: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20083ec: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20083f0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20083f4: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20083f8: 02 80 00 48 be 2008518 <_Protected_heap_Extend+0x1b8> <== NOT EXECUTED 20083fc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008400: 7f ff e6 7c call 2001df0 <== NOT EXECUTED 2008404: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 2008408: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200840c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2008410: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2008414: 40 00 12 ad call 200cec8 <_Heap_Extend> <== NOT EXECUTED 2008418: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200841c: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2008420: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 2008424: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008428: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 200842c: d0 04 e0 b8 ld [ %l3 + 0xb8 ], %o0 <== NOT EXECUTED 2008430: 94 10 20 00 clr %o2 <== NOT EXECUTED 2008434: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2008438: 7f ff fa b7 call 2006f14 <_CORE_mutex_Surrender> <== NOT EXECUTED 200843c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008440: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2008444: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008448: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 200844c: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 <== NOT EXECUTED 2008450: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2008454: 12 80 00 05 bne 2008468 <_Protected_heap_Extend+0x108> <== NOT EXECUTED 2008458: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED _Thread_Dispatch(); 200845c: 40 00 03 63 call 20091e8 <_Thread_Dispatch> <== NOT EXECUTED 2008460: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 2008464: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 2008468: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 200846c: 81 c7 e0 08 ret <== NOT EXECUTED 2008470: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2008474: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2008478: 12 80 00 16 bne 20084d0 <_Protected_heap_Extend+0x170> <== NOT EXECUTED 200847c: c6 04 e0 b8 ld [ %l3 + 0xb8 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2008480: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2008484: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008488: 22 80 00 3f be,a 2008584 <_Protected_heap_Extend+0x224> <== NOT EXECUTED 200848c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2008490: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008494: 12 80 00 0f bne 20084d0 <_Protected_heap_Extend+0x170> <== NOT EXECUTED 2008498: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200849c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20084a0: 7f ff e6 54 call 2001df0 <== NOT EXECUTED 20084a4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 20084a8: 10 bf ff d9 b 200840c <_Protected_heap_Extend+0xac> <== NOT EXECUTED 20084ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20084b0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20084b4: 12 bf ff d3 bne 2008400 <_Protected_heap_Extend+0xa0> <== NOT EXECUTED 20084b8: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20084bc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20084c0: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20084c4: 02 80 00 15 be 2008518 <_Protected_heap_Extend+0x1b8> <== NOT EXECUTED 20084c8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 20084cc: 30 bf ff cd b,a 2008400 <_Protected_heap_Extend+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20084d0: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED ) { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 20084d4: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 20084d8: c8 01 20 c0 ld [ %g4 + 0xc0 ], %g4 <== NOT EXECUTED 20084dc: 82 00 60 01 inc %g1 <== NOT EXECUTED 20084e0: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 20084e4: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 20084e8: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 20084ec: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20084f0: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 20084f4: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 20084f8: 7f ff e6 3e call 2001df0 <== NOT EXECUTED 20084fc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008500: d0 04 e0 b8 ld [ %l3 + 0xb8 ], %o0 <== NOT EXECUTED 2008504: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008508: 7f ff fa 5f call 2006e84 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200850c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 2008510: 10 bf ff bf b 200840c <_Protected_heap_Extend+0xac> <== NOT EXECUTED 2008514: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2008518: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 200851c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2008520: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008524: 02 80 00 28 be 20085c4 <_Protected_heap_Extend+0x264> <== NOT EXECUTED 2008528: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 200852c: 1a 80 00 1c bcc 200859c <_Protected_heap_Extend+0x23c> <== NOT EXECUTED 2008530: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 2008534: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2008538: 82 00 60 01 inc %g1 <== NOT EXECUTED 200853c: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2008540: 7f ff e6 2c call 2001df0 <== NOT EXECUTED 2008544: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 2008548: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200854c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008550: 40 00 01 f6 call 2008d28 <_Thread_Change_priority> <== NOT EXECUTED 2008554: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008558: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 200855c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008560: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 2008564: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 <== NOT EXECUTED 2008568: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200856c: 32 bf ff a8 bne,a 200840c <_Protected_heap_Extend+0xac> <== NOT EXECUTED 2008570: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2008574: 40 00 03 1d call 20091e8 <_Thread_Dispatch> <== NOT EXECUTED 2008578: 01 00 00 00 nop <== NOT EXECUTED 200857c: 10 bf ff a4 b 200840c <_Protected_heap_Extend+0xac> <== NOT EXECUTED 2008580: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2008584: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008588: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200858c: 7f ff e6 19 call 2001df0 <== NOT EXECUTED 2008590: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008594: 10 bf ff 9e b 200840c <_Protected_heap_Extend+0xac> <== NOT EXECUTED 2008598: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200859c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20085a0: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20085a4: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 20085a8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20085ac: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20085b0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20085b4: 7f ff e6 0f call 2001df0 <== NOT EXECUTED 20085b8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20085bc: 10 bf ff 94 b 200840c <_Protected_heap_Extend+0xac> <== NOT EXECUTED 20085c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 20085c4: 7f ff e6 0b call 2001df0 <== NOT EXECUTED 20085c8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20085cc: 10 bf ff 90 b 200840c <_Protected_heap_Extend+0xac> <== NOT EXECUTED 20085d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 020085d4 <_Protected_heap_Free>: boolean _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 20085d4: 9d e3 bf 98 save %sp, -104, %sp boolean status; _RTEMS_Lock_allocator(); 20085d8: 7f ff e6 02 call 2001de0 20085dc: 01 00 00 00 nop 20085e0: a4 10 00 08 mov %o0, %l2 20085e4: 23 00 80 61 sethi %hi(0x2018400), %l1 20085e8: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> 20085ec: 80 a0 60 00 cmp %g1, 0 20085f0: 02 80 00 0b be 200861c <_Protected_heap_Free+0x48> 20085f4: 27 00 80 62 sethi %hi(0x2018800), %l3 20085f8: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20085fc: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20189c0 <_System_state_Current> <== NOT EXECUTED 2008600: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2008604: 08 80 00 06 bleu 200861c <_Protected_heap_Free+0x48> <== NOT EXECUTED 2008608: 90 10 20 00 clr %o0 <== NOT EXECUTED 200860c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008610: 7f ff fc 44 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 2008614: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2008618: 27 00 80 62 sethi %hi(0x2018800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200861c: 09 00 80 62 sethi %hi(0x2018800), %g4 2008620: e0 04 e0 b8 ld [ %l3 + 0xb8 ], %l0 2008624: c4 01 20 c0 ld [ %g4 + 0xc0 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2008628: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200862c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2008630: 80 a0 60 00 cmp %g1, 0 2008634: 22 80 00 27 be,a 20086d0 <_Protected_heap_Free+0xfc> 2008638: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200863c: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008640: 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; 2008644: 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; 2008648: 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; 200864c: 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; 2008650: 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 ) || 2008654: 80 a0 e0 02 cmp %g3, 2 2008658: 12 80 00 2d bne 200870c <_Protected_heap_Free+0x138> 200865c: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008660: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008664: 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++; 2008668: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200866c: 02 80 00 46 be 2008784 <_Protected_heap_Free+0x1b0> 2008670: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 2008674: 7f ff e5 df call 2001df0 2008678: 90 10 00 12 mov %l2, %o0 status = _Heap_Free( the_heap, start_address ); 200867c: 90 10 00 18 mov %i0, %o0 2008680: 7f ff fb 28 call 2007320 <_Heap_Free> 2008684: 92 10 00 19 mov %i1, %o1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008688: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 200868c: b0 10 00 08 mov %o0, %i0 2008690: 82 00 60 01 inc %g1 2008694: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] _RTEMS_Unlock_allocator(); 2008698: d0 04 e0 b8 ld [ %l3 + 0xb8 ], %o0 200869c: 94 10 20 00 clr %o2 20086a0: d2 02 20 08 ld [ %o0 + 8 ], %o1 20086a4: 7f ff fa 1c call 2006f14 <_CORE_mutex_Surrender> 20086a8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20086ac: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 20086b0: 82 00 7f ff add %g1, -1, %g1 20086b4: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] 20086b8: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 20086bc: 80 a0 a0 00 cmp %g2, 0 20086c0: 02 80 00 2d be 2008774 <_Protected_heap_Free+0x1a0> 20086c4: 01 00 00 00 nop return status; } 20086c8: 81 c7 e0 08 ret <== NOT EXECUTED 20086cc: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 20086d0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20086d4: 12 80 00 16 bne 200872c <_Protected_heap_Free+0x158> <== NOT EXECUTED 20086d8: c6 04 e0 b8 ld [ %l3 + 0xb8 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20086dc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 20086e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20086e4: 22 80 00 43 be,a 20087f0 <_Protected_heap_Free+0x21c> <== NOT EXECUTED 20086e8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 20086ec: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20086f0: 12 80 00 0f bne 200872c <_Protected_heap_Free+0x158> <== NOT EXECUTED 20086f4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 20086f8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20086fc: 7f ff e5 bd call 2001df0 <== NOT EXECUTED 2008700: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { boolean status; _RTEMS_Lock_allocator(); status = _Heap_Free( the_heap, start_address ); 2008704: 10 bf ff df b 2008680 <_Protected_heap_Free+0xac> <== NOT EXECUTED 2008708: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200870c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008710: 12 bf ff d9 bne 2008674 <_Protected_heap_Free+0xa0> <== NOT EXECUTED 2008714: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008718: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200871c: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008720: 02 80 00 19 be 2008784 <_Protected_heap_Free+0x1b0> <== NOT EXECUTED 2008724: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 2008728: 30 bf ff d3 b,a 2008674 <_Protected_heap_Free+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200872c: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED void *start_address ) { boolean status; _RTEMS_Lock_allocator(); 2008730: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2008734: c8 01 20 c0 ld [ %g4 + 0xc0 ], %g4 <== NOT EXECUTED 2008738: 82 00 60 01 inc %g1 <== NOT EXECUTED 200873c: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2008740: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 2008744: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 2008748: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200874c: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2008750: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2008754: 7f ff e5 a7 call 2001df0 <== NOT EXECUTED 2008758: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 200875c: d0 04 e0 b8 ld [ %l3 + 0xb8 ], %o0 <== NOT EXECUTED 2008760: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008764: 7f ff f9 c8 call 2006e84 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2008768: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 200876c: 10 bf ff c5 b 2008680 <_Protected_heap_Free+0xac> <== NOT EXECUTED 2008770: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2008774: 40 00 02 9d call 20091e8 <_Thread_Dispatch> 2008778: 01 00 00 00 nop 200877c: 81 c7 e0 08 ret 2008780: 81 e8 00 00 restore */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2008784: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 2008788: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200878c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008790: 02 80 00 28 be 2008830 <_Protected_heap_Free+0x25c> <== NOT EXECUTED 2008794: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2008798: 1a 80 00 1c bcc 2008808 <_Protected_heap_Free+0x234> <== NOT EXECUTED 200879c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20087a0: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 20087a4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20087a8: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20087ac: 7f ff e5 91 call 2001df0 <== NOT EXECUTED 20087b0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 20087b4: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 20087b8: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 20087bc: 40 00 01 5b call 2008d28 <_Thread_Change_priority> <== NOT EXECUTED 20087c0: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20087c4: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 20087c8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20087cc: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 20087d0: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 <== NOT EXECUTED 20087d4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20087d8: 32 bf ff aa bne,a 2008680 <_Protected_heap_Free+0xac> <== NOT EXECUTED 20087dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 20087e0: 40 00 02 82 call 20091e8 <_Thread_Dispatch> <== NOT EXECUTED 20087e4: 01 00 00 00 nop <== NOT EXECUTED 20087e8: 10 bf ff a6 b 2008680 <_Protected_heap_Free+0xac> <== NOT EXECUTED 20087ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 20087f0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20087f4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 20087f8: 7f ff e5 7e call 2001df0 <== NOT EXECUTED 20087fc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008800: 10 bf ff a0 b 2008680 <_Protected_heap_Free+0xac> <== NOT EXECUTED 2008804: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008808: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200880c: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2008810: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2008814: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008818: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200881c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008820: 7f ff e5 74 call 2001df0 <== NOT EXECUTED 2008824: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008828: 10 bf ff 96 b 2008680 <_Protected_heap_Free+0xac> <== NOT EXECUTED 200882c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2008830: 7f ff e5 70 call 2001df0 <== NOT EXECUTED 2008834: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008838: 10 bf ff 92 b 2008680 <_Protected_heap_Free+0xac> <== NOT EXECUTED 200883c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 02008840 <_Protected_heap_Get_block_size>: boolean _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 2008840: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED boolean status; _RTEMS_Lock_allocator(); 2008844: 7f ff e5 67 call 2001de0 <== NOT EXECUTED 2008848: 01 00 00 00 nop <== NOT EXECUTED 200884c: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 2008850: 23 00 80 61 sethi %hi(0x2018400), %l1 <== NOT EXECUTED 2008854: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008858: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200885c: 02 80 00 0b be 2008888 <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 2008860: 27 00 80 62 sethi %hi(0x2018800), %l3 <== NOT EXECUTED 2008864: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008868: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20189c0 <_System_state_Current> <== NOT EXECUTED 200886c: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2008870: 08 80 00 06 bleu 2008888 <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 2008874: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008878: 92 10 20 00 clr %o1 <== NOT EXECUTED 200887c: 7f ff fb a9 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 2008880: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2008884: 27 00 80 62 sethi %hi(0x2018800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2008888: 09 00 80 62 sethi %hi(0x2018800), %g4 <== NOT EXECUTED 200888c: e0 04 e0 b8 ld [ %l3 + 0xb8 ], %l0 <== NOT EXECUTED 2008890: c4 01 20 c0 ld [ %g4 + 0xc0 ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2008894: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2008898: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 200889c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20088a0: 22 80 00 28 be,a 2008940 <_Protected_heap_Get_block_size+0x100> <== NOT EXECUTED 20088a4: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20088a8: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20088ac: 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; 20088b0: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 20088b4: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20088b8: 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; 20088bc: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20088c0: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 20088c4: 12 80 00 2e bne 200897c <_Protected_heap_Get_block_size+0x13c> <== NOT EXECUTED 20088c8: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20088cc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20088d0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20088d4: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20088d8: 02 80 00 47 be 20089f4 <_Protected_heap_Get_block_size+0x1b4> <== NOT EXECUTED 20088dc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20088e0: 7f ff e5 44 call 2001df0 <== NOT EXECUTED 20088e4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 20088e8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20088ec: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 20088f0: 40 00 12 37 call 200d1cc <_Heap_Size_of_user_area> <== NOT EXECUTED 20088f4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20088f8: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 20088fc: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 2008900: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008904: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 2008908: d0 04 e0 b8 ld [ %l3 + 0xb8 ], %o0 <== NOT EXECUTED 200890c: 94 10 20 00 clr %o2 <== NOT EXECUTED 2008910: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2008914: 7f ff f9 80 call 2006f14 <_CORE_mutex_Surrender> <== NOT EXECUTED 2008918: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200891c: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2008920: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008924: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 2008928: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 <== NOT EXECUTED 200892c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2008930: 02 80 00 2d be 20089e4 <_Protected_heap_Get_block_size+0x1a4> <== NOT EXECUTED 2008934: 01 00 00 00 nop <== NOT EXECUTED return status; } 2008938: 81 c7 e0 08 ret <== NOT EXECUTED 200893c: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2008940: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2008944: 12 80 00 16 bne 200899c <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 2008948: c6 04 e0 b8 ld [ %l3 + 0xb8 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200894c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2008950: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008954: 22 80 00 43 be,a 2008a60 <_Protected_heap_Get_block_size+0x220> <== NOT EXECUTED 2008958: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200895c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008960: 12 80 00 0f bne 200899c <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 2008964: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2008968: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200896c: 7f ff e5 21 call 2001df0 <== NOT EXECUTED 2008970: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { boolean status; _RTEMS_Lock_allocator(); status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 2008974: 10 bf ff de b 20088ec <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008978: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200897c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008980: 12 bf ff d8 bne 20088e0 <_Protected_heap_Get_block_size+0xa0> <== NOT EXECUTED 2008984: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008988: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200898c: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008990: 02 80 00 19 be 20089f4 <_Protected_heap_Get_block_size+0x1b4> <== NOT EXECUTED 2008994: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 2008998: 30 bf ff d2 b,a 20088e0 <_Protected_heap_Get_block_size+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200899c: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED size_t *size ) { boolean status; _RTEMS_Lock_allocator(); 20089a0: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 20089a4: c8 01 20 c0 ld [ %g4 + 0xc0 ], %g4 <== NOT EXECUTED 20089a8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20089ac: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 20089b0: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 20089b4: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 20089b8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20089bc: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 20089c0: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 20089c4: 7f ff e5 0b call 2001df0 <== NOT EXECUTED 20089c8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20089cc: d0 04 e0 b8 ld [ %l3 + 0xb8 ], %o0 <== NOT EXECUTED 20089d0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20089d4: 7f ff f9 2c call 2006e84 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 20089d8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 20089dc: 10 bf ff c4 b 20088ec <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 20089e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 20089e4: 40 00 02 01 call 20091e8 <_Thread_Dispatch> <== NOT EXECUTED 20089e8: 01 00 00 00 nop <== NOT EXECUTED 20089ec: 81 c7 e0 08 ret <== NOT EXECUTED 20089f0: 81 e8 00 00 restore <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 20089f4: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 20089f8: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 20089fc: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008a00: 02 80 00 28 be 2008aa0 <_Protected_heap_Get_block_size+0x260> <== NOT EXECUTED 2008a04: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2008a08: 1a 80 00 1c bcc 2008a78 <_Protected_heap_Get_block_size+0x238> <== NOT EXECUTED 2008a0c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008a10: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2008a14: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008a18: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2008a1c: 7f ff e4 f5 call 2001df0 <== NOT EXECUTED 2008a20: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 2008a24: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2008a28: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008a2c: 40 00 00 bf call 2008d28 <_Thread_Change_priority> <== NOT EXECUTED 2008a30: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008a34: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2008a38: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008a3c: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 2008a40: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 <== NOT EXECUTED 2008a44: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2008a48: 32 bf ff a9 bne,a 20088ec <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008a4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2008a50: 40 00 01 e6 call 20091e8 <_Thread_Dispatch> <== NOT EXECUTED 2008a54: 01 00 00 00 nop <== NOT EXECUTED 2008a58: 10 bf ff a5 b 20088ec <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008a5c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2008a60: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008a64: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2008a68: 7f ff e4 e2 call 2001df0 <== NOT EXECUTED 2008a6c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008a70: 10 bf ff 9f b 20088ec <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008a74: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008a78: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2008a7c: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2008a80: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2008a84: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008a88: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008a8c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008a90: 7f ff e4 d8 call 2001df0 <== NOT EXECUTED 2008a94: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008a98: 10 bf ff 95 b 20088ec <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008a9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2008aa0: 7f ff e4 d4 call 2001df0 <== NOT EXECUTED 2008aa4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008aa8: 10 bf ff 91 b 20088ec <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008aac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 0200b2d0 <_Protected_heap_Get_free_information>: void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 200b2d0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 200b2d4: 7f ff de 87 call 2002cf0 <== NOT EXECUTED 200b2d8: 01 00 00 00 nop <== NOT EXECUTED 200b2dc: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 200b2e0: 23 00 80 ef sethi %hi(0x203bc00), %l1 <== NOT EXECUTED 200b2e4: c2 04 60 b0 ld [ %l1 + 0xb0 ], %g1 ! 203bcb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200b2e8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b2ec: 02 80 00 0b be 200b318 <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 200b2f0: 27 00 80 ef sethi %hi(0x203bc00), %l3 <== NOT EXECUTED 200b2f4: 03 00 80 ef sethi %hi(0x203bc00), %g1 <== NOT EXECUTED 200b2f8: c4 00 62 90 ld [ %g1 + 0x290 ], %g2 ! 203be90 <_System_state_Current> <== NOT EXECUTED 200b2fc: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 200b300: 08 80 00 06 bleu 200b318 <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 200b304: 90 10 20 00 clr %o0 <== NOT EXECUTED 200b308: 92 10 20 00 clr %o1 <== NOT EXECUTED 200b30c: 7f ff fb 49 call 200a030 <_Internal_error_Occurred> <== NOT EXECUTED 200b310: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200b314: 27 00 80 ef sethi %hi(0x203bc00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200b318: 09 00 80 ef sethi %hi(0x203bc00), %g4 <== NOT EXECUTED 200b31c: e0 04 e1 88 ld [ %l3 + 0x188 ], %l0 <== NOT EXECUTED 200b320: c4 01 21 90 ld [ %g4 + 0x190 ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200b324: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200b328: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 200b32c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b330: 22 80 00 26 be,a 200b3c8 <_Protected_heap_Get_free_information+0xf8> <== NOT EXECUTED 200b334: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200b338: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200b33c: 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; 200b340: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 200b344: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200b348: 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; 200b34c: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200b350: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 200b354: 12 80 00 2c bne 200b404 <_Protected_heap_Get_free_information+0x134> <== NOT EXECUTED 200b358: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200b35c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200b360: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200b364: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200b368: 02 80 00 43 be 200b474 <_Protected_heap_Get_free_information+0x1a4> <== NOT EXECUTED 200b36c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200b370: 7f ff de 64 call 2002d00 <== NOT EXECUTED 200b374: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 200b378: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200b37c: 40 00 3a ab call 2019e28 <_Heap_Get_free_information> <== NOT EXECUTED 200b380: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200b384: c2 04 60 b0 ld [ %l1 + 0xb0 ], %g1 <== NOT EXECUTED 200b388: 82 00 60 01 inc %g1 <== NOT EXECUTED 200b38c: c2 24 60 b0 st %g1, [ %l1 + 0xb0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 200b390: d0 04 e1 88 ld [ %l3 + 0x188 ], %o0 <== NOT EXECUTED 200b394: 94 10 20 00 clr %o2 <== NOT EXECUTED 200b398: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 200b39c: 7f ff f9 22 call 2009824 <_CORE_mutex_Surrender> <== NOT EXECUTED 200b3a0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200b3a4: c2 04 60 b0 ld [ %l1 + 0xb0 ], %g1 <== NOT EXECUTED 200b3a8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200b3ac: c2 24 60 b0 st %g1, [ %l1 + 0xb0 ] <== NOT EXECUTED 200b3b0: c4 04 60 b0 ld [ %l1 + 0xb0 ], %g2 <== NOT EXECUTED 200b3b4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200b3b8: 02 80 00 2d be 200b46c <_Protected_heap_Get_free_information+0x19c> <== NOT EXECUTED 200b3bc: 01 00 00 00 nop <== NOT EXECUTED 200b3c0: 81 c7 e0 08 ret <== NOT EXECUTED 200b3c4: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 200b3c8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200b3cc: 12 80 00 16 bne 200b424 <_Protected_heap_Get_free_information+0x154> <== NOT EXECUTED 200b3d0: c6 04 e1 88 ld [ %l3 + 0x188 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200b3d4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 200b3d8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b3dc: 22 80 00 41 be,a 200b4e0 <_Protected_heap_Get_free_information+0x210> <== NOT EXECUTED 200b3e0: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200b3e4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200b3e8: 12 80 00 0f bne 200b424 <_Protected_heap_Get_free_information+0x154> <== NOT EXECUTED 200b3ec: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200b3f0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200b3f4: 7f ff de 43 call 2002d00 <== NOT EXECUTED 200b3f8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); _Heap_Get_free_information( the_heap, info ); 200b3fc: 10 bf ff e0 b 200b37c <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b400: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200b404: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200b408: 12 bf ff da bne 200b370 <_Protected_heap_Get_free_information+0xa0> <== NOT EXECUTED 200b40c: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200b410: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200b414: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200b418: 02 80 00 17 be 200b474 <_Protected_heap_Get_free_information+0x1a4> <== NOT EXECUTED 200b41c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 200b420: 30 bf ff d4 b,a 200b370 <_Protected_heap_Get_free_information+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200b424: c2 04 60 b0 ld [ %l1 + 0xb0 ], %g1 <== NOT EXECUTED void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); 200b428: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 200b42c: c8 01 21 90 ld [ %g4 + 0x190 ], %g4 <== NOT EXECUTED 200b430: 82 00 60 01 inc %g1 <== NOT EXECUTED 200b434: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 200b438: c2 24 60 b0 st %g1, [ %l1 + 0xb0 ] <== NOT EXECUTED 200b43c: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 200b440: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200b444: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 200b448: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 200b44c: 7f ff de 2d call 2002d00 <== NOT EXECUTED 200b450: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 200b454: d0 04 e1 88 ld [ %l3 + 0x188 ], %o0 <== NOT EXECUTED 200b458: 92 10 20 00 clr %o1 <== NOT EXECUTED 200b45c: 7f ff f8 ce call 2009794 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200b460: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 200b464: 10 bf ff c6 b 200b37c <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b468: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 200b46c: 40 00 01 ff call 200bc68 <_Thread_Dispatch> <== NOT EXECUTED 200b470: 81 e8 00 00 restore <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 200b474: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 200b478: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200b47c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200b480: 02 80 00 28 be 200b520 <_Protected_heap_Get_free_information+0x250> <== NOT EXECUTED 200b484: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 200b488: 1a 80 00 1c bcc 200b4f8 <_Protected_heap_Get_free_information+0x228> <== NOT EXECUTED 200b48c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200b490: c2 04 60 b0 ld [ %l1 + 0xb0 ], %g1 <== NOT EXECUTED 200b494: 82 00 60 01 inc %g1 <== NOT EXECUTED 200b498: c2 24 60 b0 st %g1, [ %l1 + 0xb0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200b49c: 7f ff de 19 call 2002d00 <== NOT EXECUTED 200b4a0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 200b4a4: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200b4a8: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200b4ac: 40 00 00 bf call 200b7a8 <_Thread_Change_priority> <== NOT EXECUTED 200b4b0: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200b4b4: c2 04 60 b0 ld [ %l1 + 0xb0 ], %g1 <== NOT EXECUTED 200b4b8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200b4bc: c2 24 60 b0 st %g1, [ %l1 + 0xb0 ] <== NOT EXECUTED 200b4c0: c4 04 60 b0 ld [ %l1 + 0xb0 ], %g2 <== NOT EXECUTED 200b4c4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200b4c8: 32 bf ff ad bne,a 200b37c <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b4cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 200b4d0: 40 00 01 e6 call 200bc68 <_Thread_Dispatch> <== NOT EXECUTED 200b4d4: 01 00 00 00 nop <== NOT EXECUTED 200b4d8: 10 bf ff a9 b 200b37c <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b4dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 200b4e0: 82 00 60 01 inc %g1 <== NOT EXECUTED 200b4e4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200b4e8: 7f ff de 06 call 2002d00 <== NOT EXECUTED 200b4ec: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 200b4f0: 10 bf ff a3 b 200b37c <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b4f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200b4f8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200b4fc: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200b500: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 200b504: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200b508: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200b50c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200b510: 7f ff dd fc call 2002d00 <== NOT EXECUTED 200b514: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 200b518: 10 bf ff 99 b 200b37c <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b51c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 200b520: 7f ff dd f8 call 2002d00 <== NOT EXECUTED 200b524: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 200b528: 10 bf ff 95 b 200b37c <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b52c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 02008ab0 <_Protected_heap_Resize_block>: boolean _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 2008ab0: 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(); 2008ab4: 7f ff e4 cb call 2001de0 <== NOT EXECUTED 2008ab8: 01 00 00 00 nop <== NOT EXECUTED 2008abc: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 2008ac0: 23 00 80 61 sethi %hi(0x2018400), %l1 <== NOT EXECUTED 2008ac4: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008ac8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008acc: 02 80 00 0b be 2008af8 <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 2008ad0: 27 00 80 62 sethi %hi(0x2018800), %l3 <== NOT EXECUTED 2008ad4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008ad8: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20189c0 <_System_state_Current> <== NOT EXECUTED 2008adc: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2008ae0: 08 80 00 06 bleu 2008af8 <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 2008ae4: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008ae8: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008aec: 7f ff fb 0d call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 2008af0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2008af4: 27 00 80 62 sethi %hi(0x2018800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2008af8: 09 00 80 62 sethi %hi(0x2018800), %g4 <== NOT EXECUTED 2008afc: e0 04 e0 b8 ld [ %l3 + 0xb8 ], %l0 <== NOT EXECUTED 2008b00: c4 01 20 c0 ld [ %g4 + 0xc0 ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2008b04: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2008b08: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2008b0c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008b10: 22 80 00 2e be,a 2008bc8 <_Protected_heap_Resize_block+0x118> <== NOT EXECUTED 2008b14: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2008b18: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008b1c: 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; 2008b20: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2008b24: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008b28: 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; 2008b2c: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008b30: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2008b34: 12 80 00 34 bne 2008c04 <_Protected_heap_Resize_block+0x154> <== NOT EXECUTED 2008b38: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008b3c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008b40: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008b44: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008b48: 02 80 00 49 be 2008c6c <_Protected_heap_Resize_block+0x1bc> <== NOT EXECUTED 2008b4c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008b50: 7f ff e4 a8 call 2001df0 <== NOT EXECUTED 2008b54: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 2008b58: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2008b5c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2008b60: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2008b64: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 2008b68: 40 00 11 0b call 200cf94 <_Heap_Resize_block> <== NOT EXECUTED 2008b6c: 98 07 bf f0 add %fp, -16, %o4 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008b70: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2008b74: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 2008b78: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008b7c: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 2008b80: d0 04 e0 b8 ld [ %l3 + 0xb8 ], %o0 <== NOT EXECUTED 2008b84: 94 10 20 00 clr %o2 <== NOT EXECUTED 2008b88: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2008b8c: 7f ff f8 e2 call 2006f14 <_CORE_mutex_Surrender> <== NOT EXECUTED 2008b90: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008b94: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2008b98: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008b9c: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 2008ba0: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 <== NOT EXECUTED 2008ba4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2008ba8: 12 80 00 05 bne 2008bbc <_Protected_heap_Resize_block+0x10c> <== NOT EXECUTED 2008bac: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED _Thread_Dispatch(); 2008bb0: 40 00 01 8e call 20091e8 <_Thread_Dispatch> <== NOT EXECUTED 2008bb4: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 2008bb8: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 2008bbc: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 2008bc0: 81 c7 e0 08 ret <== NOT EXECUTED 2008bc4: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2008bc8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2008bcc: 12 80 00 16 bne 2008c24 <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 2008bd0: c6 04 e0 b8 ld [ %l3 + 0xb8 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2008bd4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2008bd8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008bdc: 22 80 00 3f be,a 2008cd8 <_Protected_heap_Resize_block+0x228> <== NOT EXECUTED 2008be0: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2008be4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008be8: 12 80 00 0f bne 2008c24 <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 2008bec: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2008bf0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2008bf4: 7f ff e4 7f call 2001df0 <== NOT EXECUTED 2008bf8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); status = _Heap_Resize_block( 2008bfc: 10 bf ff d8 b 2008b5c <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008c00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008c04: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008c08: 12 bf ff d2 bne 2008b50 <_Protected_heap_Resize_block+0xa0> <== NOT EXECUTED 2008c0c: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008c10: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008c14: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008c18: 02 80 00 15 be 2008c6c <_Protected_heap_Resize_block+0x1bc> <== NOT EXECUTED 2008c1c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 2008c20: 30 bf ff cc b,a 2008b50 <_Protected_heap_Resize_block+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008c24: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED { Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 2008c28: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2008c2c: c8 01 20 c0 ld [ %g4 + 0xc0 ], %g4 <== NOT EXECUTED 2008c30: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008c34: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2008c38: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 2008c3c: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 2008c40: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2008c44: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2008c48: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2008c4c: 7f ff e4 69 call 2001df0 <== NOT EXECUTED 2008c50: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008c54: d0 04 e0 b8 ld [ %l3 + 0xb8 ], %o0 <== NOT EXECUTED 2008c58: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008c5c: 7f ff f8 8a call 2006e84 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2008c60: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 2008c64: 10 bf ff be b 2008b5c <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008c68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2008c6c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 2008c70: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2008c74: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008c78: 02 80 00 28 be 2008d18 <_Protected_heap_Resize_block+0x268> <== NOT EXECUTED 2008c7c: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2008c80: 1a 80 00 1c bcc 2008cf0 <_Protected_heap_Resize_block+0x240> <== NOT EXECUTED 2008c84: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 2008c88: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2008c8c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008c90: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2008c94: 7f ff e4 57 call 2001df0 <== NOT EXECUTED 2008c98: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 2008c9c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2008ca0: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008ca4: 40 00 00 21 call 2008d28 <_Thread_Change_priority> <== NOT EXECUTED 2008ca8: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008cac: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2008cb0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008cb4: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 2008cb8: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 <== NOT EXECUTED 2008cbc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2008cc0: 32 bf ff a7 bne,a 2008b5c <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008cc4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2008cc8: 40 00 01 48 call 20091e8 <_Thread_Dispatch> <== NOT EXECUTED 2008ccc: 01 00 00 00 nop <== NOT EXECUTED 2008cd0: 10 bf ff a3 b 2008b5c <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008cd4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2008cd8: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008cdc: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2008ce0: 7f ff e4 44 call 2001df0 <== NOT EXECUTED 2008ce4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008ce8: 10 bf ff 9d b 2008b5c <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008cec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008cf0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2008cf4: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2008cf8: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2008cfc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008d00: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008d04: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008d08: 7f ff e4 3a call 2001df0 <== NOT EXECUTED 2008d0c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008d10: 10 bf ff 93 b 2008b5c <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008d14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2008d18: 7f ff e4 36 call 2001df0 <== NOT EXECUTED 2008d1c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008d20: 10 bf ff 8f b 2008b5c <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008d24: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 0200cc78 <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 200cc78: 9d e3 bf 98 save %sp, -104, %sp /* * Free per task variable memory */ tvp = deleted->task_variables; 200cc7c: e0 06 61 80 ld [ %i1 + 0x180 ], %l0 deleted->task_variables = NULL; 200cc80: c0 26 61 80 clr [ %i1 + 0x180 ] while (tvp) { 200cc84: 80 a4 20 00 cmp %l0, 0 200cc88: 02 80 00 25 be 200cd1c <_RTEMS_tasks_Delete_extension+0xa4> 200cc8c: 29 00 80 62 sethi %hi(0x2018800), %l4 200cc90: 27 00 80 62 sethi %hi(0x2018800), %l3 <== NOT EXECUTED 200cc94: 10 80 00 12 b 200ccdc <_RTEMS_tasks_Delete_extension+0x64> <== NOT EXECUTED 200cc98: a4 15 20 2c or %l4, 0x2c, %l2 <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { if (tvp->dtor) 200cc9c: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED 200cca0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200cca4: 22 80 00 06 be,a 200ccbc <_RTEMS_tasks_Delete_extension+0x44> <== NOT EXECUTED 200cca8: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED (*tvp->dtor)(*tvp->ptr); 200ccac: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 200ccb0: 9f c0 80 00 call %g2 <== NOT EXECUTED 200ccb4: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 200ccb8: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED 200ccbc: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 200ccc0: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 200ccc4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 200ccc8: 7f ff e9 96 call 2007320 <_Heap_Free> <== NOT EXECUTED 200cccc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 200ccd0: a0 94 60 00 orcc %l1, 0, %l0 <== NOT EXECUTED 200ccd4: 22 80 00 13 be,a 200cd20 <_RTEMS_tasks_Delete_extension+0xa8> <== NOT EXECUTED 200ccd8: d2 06 61 70 ld [ %i1 + 0x170 ], %o1 <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 200ccdc: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 <== NOT EXECUTED 200cce0: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 200cce4: 02 bf ff ee be 200cc9c <_RTEMS_tasks_Delete_extension+0x24> <== NOT EXECUTED 200cce8: e2 04 00 00 ld [ %l0 ], %l1 <== NOT EXECUTED if (tvp->dtor) (*tvp->dtor)(*tvp->ptr); *tvp->ptr = tvp->gval; } else { if (tvp->dtor) 200ccec: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 200ccf0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200ccf4: 02 bf ff f5 be 200ccc8 <_RTEMS_tasks_Delete_extension+0x50> <== NOT EXECUTED 200ccf8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 200ccfc: 9f c0 40 00 call %g1 <== NOT EXECUTED 200cd00: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED 200cd04: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 200cd08: 7f ff e9 86 call 2007320 <_Heap_Free> <== NOT EXECUTED 200cd0c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 200cd10: a0 94 60 00 orcc %l1, 0, %l0 <== NOT EXECUTED 200cd14: 12 bf ff f3 bne 200cce0 <_RTEMS_tasks_Delete_extension+0x68> <== NOT EXECUTED 200cd18: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 <== NOT EXECUTED 200cd1c: d2 06 61 70 ld [ %i1 + 0x170 ], %o1 200cd20: 7f ff e9 80 call 2007320 <_Heap_Free> 200cd24: 90 15 20 2c or %l4, 0x2c, %o0 /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 200cd28: c0 26 61 70 clr [ %i1 + 0x170 ] } 200cd2c: 81 c7 e0 08 ret 200cd30: 81 e8 00 00 restore 02006574 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 2006574: 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; 2006578: 03 00 80 62 sethi %hi(0x2018800), %g1 200657c: c4 00 60 a4 ld [ %g1 + 0xa4 ], %g2 ! 20188a4 <_Configuration_Table> 2006580: c6 00 a0 2c ld [ %g2 + 0x2c ], %g3 /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 2006584: d0 00 e0 28 ld [ %g3 + 0x28 ], %o0 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) 2006588: 80 a2 20 00 cmp %o0, 0 200658c: 02 80 00 2f be 2006648 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 2006590: e4 00 e0 24 ld [ %g3 + 0x24 ], %l2 2006594: 80 a4 a0 00 cmp %l2, 0 2006598: 02 80 00 2c be 2006648 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 200659c: a0 10 00 08 mov %o0, %l0 return; for ( index=0 ; index < maximum ; index++ ) { 20065a0: a2 10 20 00 clr %l1 20065a4: 10 80 00 0c b 20065d4 <_RTEMS_tasks_Initialize_user_tasks_body+0x60> 20065a8: a6 07 bf f4 add %fp, -12, %l3 ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); return_value = rtems_task_start( 20065ac: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 20065b0: d0 07 bf f4 ld [ %fp + -12 ], %o0 20065b4: 40 00 00 27 call 2006650 20065b8: a2 04 60 01 inc %l1 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 20065bc: 80 a2 20 00 cmp %o0, 0 20065c0: 12 80 00 1c bne 2006630 <_RTEMS_tasks_Initialize_user_tasks_body+0xbc> 20065c4: 94 10 00 08 mov %o0, %o2 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 20065c8: 80 a4 40 12 cmp %l1, %l2 20065cc: 02 80 00 1f be 2006648 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 20065d0: a0 04 20 1c add %l0, 0x1c, %l0 return_value = rtems_task_create( 20065d4: d6 04 20 14 ld [ %l0 + 0x14 ], %o3 20065d8: d8 04 20 0c ld [ %l0 + 0xc ], %o4 20065dc: d2 04 20 08 ld [ %l0 + 8 ], %o1 20065e0: d4 04 20 04 ld [ %l0 + 4 ], %o2 20065e4: d0 04 00 00 ld [ %l0 ], %o0 20065e8: 7f ff ff 1b call 2006254 20065ec: 9a 10 00 13 mov %l3, %o5 user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 20065f0: 80 a2 20 00 cmp %o0, 0 20065f4: 22 bf ff ee be,a 20065ac <_RTEMS_tasks_Initialize_user_tasks_body+0x38> 20065f8: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 20065fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 2006600: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2006604: 40 00 04 47 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 2006608: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED return_value = rtems_task_start( 200660c: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED 2006610: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 <== NOT EXECUTED 2006614: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED 2006618: 40 00 00 0e call 2006650 <== NOT EXECUTED 200661c: a2 04 60 01 inc %l1 <== NOT EXECUTED id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 2006620: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2006624: 02 bf ff ea be 20065cc <_RTEMS_tasks_Initialize_user_tasks_body+0x58> <== NOT EXECUTED 2006628: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 200662c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 2006630: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2006634: 40 00 04 3b call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 2006638: 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++ ) { 200663c: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED 2006640: 12 bf ff e5 bne 20065d4 <_RTEMS_tasks_Initialize_user_tasks_body+0x60> <== NOT EXECUTED 2006644: a0 04 20 1c add %l0, 0x1c, %l0 <== NOT EXECUTED 2006648: 81 c7 e0 08 ret 200664c: 81 e8 00 00 restore 0200cb88 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 200cb88: 9d e3 bf 90 save %sp, -112, %sp * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 200cb8c: 7f ff d4 95 call 2001de0 200cb90: f0 06 21 70 ld [ %i0 + 0x170 ], %i0 signal_set = asr->signals_posted; 200cb94: e4 06 20 54 ld [ %i0 + 0x54 ], %l2 asr->signals_posted = 0; 200cb98: c0 26 20 54 clr [ %i0 + 0x54 ] _ISR_Enable( level ); 200cb9c: 7f ff d4 95 call 2001df0 200cba0: 01 00 00 00 nop if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 200cba4: 80 a4 a0 00 cmp %l2, 0 200cba8: 32 80 00 04 bne,a 200cbb8 <_RTEMS_tasks_Post_switch_extension+0x30> 200cbac: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 200cbb0: 81 c7 e0 08 ret <== NOT EXECUTED 200cbb4: 81 e8 00 00 restore <== NOT EXECUTED return; asr->nest_level += 1; rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200cbb8: d0 06 20 50 ld [ %i0 + 0x50 ], %o0 if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ return; asr->nest_level += 1; 200cbbc: 82 00 60 01 inc %g1 rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200cbc0: a2 07 bf f4 add %fp, -12, %l1 if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ return; asr->nest_level += 1; 200cbc4: c2 26 20 5c st %g1, [ %i0 + 0x5c ] rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200cbc8: 94 10 00 11 mov %l1, %o2 200cbcc: 21 00 00 3f sethi %hi(0xfc00), %l0 200cbd0: 40 00 04 62 call 200dd58 200cbd4: 92 14 23 ff or %l0, 0x3ff, %o1 ! ffff (*asr->handler)( signal_set ); 200cbd8: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 200cbdc: 9f c0 40 00 call %g1 200cbe0: 90 10 00 12 mov %l2, %o0 asr->nest_level -= 1; 200cbe4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200cbe8: d0 07 bf f4 ld [ %fp + -12 ], %o0 asr->nest_level += 1; rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); (*asr->handler)( signal_set ); asr->nest_level -= 1; 200cbec: 82 00 7f ff add %g1, -1, %g1 rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200cbf0: 92 14 23 ff or %l0, 0x3ff, %o1 asr->nest_level += 1; rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); (*asr->handler)( signal_set ); asr->nest_level -= 1; 200cbf4: c2 26 20 5c st %g1, [ %i0 + 0x5c ] rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 200cbf8: 40 00 04 58 call 200dd58 200cbfc: 94 10 00 11 mov %l1, %o2 200cc00: 81 c7 e0 08 ret 200cc04: 81 e8 00 00 restore 02007238 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 2007238: 9d e3 bf 90 save %sp, -112, %sp 200723c: 11 00 80 73 sethi %hi(0x201cc00), %o0 2007240: 92 10 00 18 mov %i0, %o1 2007244: 90 12 22 94 or %o0, 0x294, %o0 2007248: 40 00 09 a6 call 20098e0 <_Objects_Get> 200724c: 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 ) { 2007250: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007254: 80 a0 60 00 cmp %g1, 0 2007258: 12 80 00 11 bne 200729c <_Rate_monotonic_Timeout+0x64> 200725c: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: /* impossible */ case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; 2007260: d0 02 20 50 ld [ %o0 + 0x50 ], %o0 if ( _States_Is_waiting_for_period( the_thread->current_state ) && 2007264: 03 00 00 10 sethi %hi(0x4000), %g1 2007268: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 200726c: 80 88 80 01 btst %g2, %g1 2007270: 32 80 00 0d bne,a 20072a4 <_Rate_monotonic_Timeout+0x6c> 2007274: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 2007278: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 200727c: 80 a0 60 01 cmp %g1, 1 2007280: 02 80 00 17 be 20072dc <_Rate_monotonic_Timeout+0xa4> 2007284: 82 10 20 04 mov 4, %g1 the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 2007288: 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; 200728c: 05 00 80 74 sethi %hi(0x201d000), %g2 2007290: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 ! 201d030 <_Thread_Dispatch_disable_level> 2007294: 82 00 7f ff add %g1, -1, %g1 2007298: c2 20 a0 30 st %g1, [ %g2 + 0x30 ] 200729c: 81 c7 e0 08 ret 20072a0: 81 e8 00 00 restore case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; if ( _States_Is_waiting_for_period( the_thread->current_state ) && 20072a4: c2 06 20 08 ld [ %i0 + 8 ], %g1 20072a8: 80 a0 80 01 cmp %g2, %g1 20072ac: 32 bf ff f4 bne,a 200727c <_Rate_monotonic_Timeout+0x44> 20072b0: 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 ); 20072b4: 13 04 00 ff sethi %hi(0x1003fc00), %o1 20072b8: 40 00 0d fd call 200aaac <_Thread_Clear_state> 20072bc: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20072c0: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20072c4: 92 06 20 10 add %i0, 0x10, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20072c8: c2 26 20 1c st %g1, [ %i0 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20072cc: 11 00 80 74 sethi %hi(0x201d000), %o0 20072d0: 40 00 14 6c call 200c480 <_Watchdog_Insert> 20072d4: 90 12 21 30 or %o0, 0x130, %o0 ! 201d130 <_Watchdog_Ticks_chain> 20072d8: 30 bf ff ed b,a 200728c <_Rate_monotonic_Timeout+0x54> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20072dc: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 <== NOT EXECUTED the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 20072e0: 84 10 20 03 mov 3, %g2 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20072e4: 92 06 20 10 add %i0, 0x10, %o1 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20072e8: c2 26 20 1c st %g1, [ %i0 + 0x1c ] <== NOT EXECUTED 20072ec: c4 26 20 38 st %g2, [ %i0 + 0x38 ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20072f0: 11 00 80 74 sethi %hi(0x201d000), %o0 <== NOT EXECUTED 20072f4: 40 00 14 63 call 200c480 <_Watchdog_Insert> <== NOT EXECUTED 20072f8: 90 12 21 30 or %o0, 0x130, %o0 ! 201d130 <_Watchdog_Ticks_chain> <== NOT EXECUTED 20072fc: 30 bf ff e4 b,a 200728c <_Rate_monotonic_Timeout+0x54> <== NOT EXECUTED 0201a848 <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 201a848: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 201a84c: 27 00 80 c8 sethi %hi(0x2032000), %l3 201a850: c2 04 e1 c0 ld [ %l3 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 201a854: 82 00 60 01 inc %g1 201a858: c2 24 e1 c0 st %g1, [ %l3 + 0x1c0 ] 201a85c: c2 04 e1 c0 ld [ %l3 + 0x1c0 ], %g1 201a860: 82 00 60 01 inc %g1 201a864: c2 24 e1 c0 st %g1, [ %l3 + 0x1c0 ] * NOTE: Be sure to disable dispatching before unlocking the mutex * since we do not want to open a window where a context * switch could occur. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 201a868: 03 00 80 c8 sethi %hi(0x2032000), %g1 201a86c: d0 00 62 98 ld [ %g1 + 0x298 ], %o0 ! 2032298 <_RTEMS_Allocator_Mutex> 201a870: 94 10 20 00 clr %o2 201a874: d2 02 20 08 ld [ %o0 + 8 ], %o1 201a878: 7f ff e7 2f call 2014534 <_CORE_mutex_Surrender> 201a87c: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201a880: c2 04 e1 c0 ld [ %l3 + 0x1c0 ], %g1 201a884: a2 06 20 10 add %i0, 0x10, %l1 201a888: 82 00 7f ff add %g1, -1, %g1 201a88c: c2 24 e1 c0 st %g1, [ %l3 + 0x1c0 ] 201a890: c4 04 e1 c0 ld [ %l3 + 0x1c0 ], %g2 201a894: 80 a0 a0 00 cmp %g2, 0 201a898: 02 80 00 21 be 201a91c <_Region_Process_queue+0xd4> 201a89c: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 201a8a0: 10 80 00 10 b 201a8e0 <_Region_Process_queue+0x98> 201a8a4: a4 06 20 68 add %i0, 0x68, %l2 the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 201a8a8: 7f ff e8 37 call 2014984 <_Heap_Allocate> 201a8ac: d2 04 20 24 ld [ %l0 + 0x24 ], %o1 201a8b0: 80 a2 20 00 cmp %o0, 0 201a8b4: 02 80 00 11 be 201a8f8 <_Region_Process_queue+0xb0> 201a8b8: 01 00 00 00 nop break; *(void **)the_thread->Wait.return_argument = the_segment; the_region->number_of_used_blocks += 1; 201a8bc: c2 06 20 64 ld [ %i0 + 0x64 ], %g1 ); if ( the_segment == NULL ) break; *(void **)the_thread->Wait.return_argument = the_segment; 201a8c0: c4 04 20 28 ld [ %l0 + 0x28 ], %g2 the_region->number_of_used_blocks += 1; 201a8c4: 82 00 60 01 inc %g1 ); if ( the_segment == NULL ) break; *(void **)the_thread->Wait.return_argument = the_segment; 201a8c8: d0 20 80 00 st %o0, [ %g2 ] the_region->number_of_used_blocks += 1; 201a8cc: c2 26 20 64 st %g1, [ %i0 + 0x64 ] _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 201a8d0: 90 10 00 11 mov %l1, %o0 201a8d4: 40 00 02 81 call 201b2d8 <_Thread_queue_Extract> 201a8d8: 92 10 00 10 mov %l0, %o1 the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 201a8dc: c0 24 20 34 clr [ %l0 + 0x34 ] /* * NOTE: The following loop is O(n) where n is the number of * threads whose memory request is satisfied. */ for ( ; ; ) { the_thread = _Thread_queue_First( &the_region->Wait_queue ); 201a8e0: 40 00 02 c8 call 201b400 <_Thread_queue_First> 201a8e4: 90 10 00 11 mov %l1, %o0 201a8e8: a0 10 00 08 mov %o0, %l0 if ( the_thread == NULL ) 201a8ec: 80 a4 20 00 cmp %l0, 0 201a8f0: 12 bf ff ee bne 201a8a8 <_Region_Process_queue+0x60> 201a8f4: 90 10 00 12 mov %l2, %o0 201a8f8: c2 04 e1 c0 ld [ %l3 + 0x1c0 ], %g1 201a8fc: 82 00 7f ff add %g1, -1, %g1 201a900: c2 24 e1 c0 st %g1, [ %l3 + 0x1c0 ] 201a904: c4 04 e1 c0 ld [ %l3 + 0x1c0 ], %g2 201a908: 80 a0 a0 00 cmp %g2, 0 201a90c: 02 80 00 07 be 201a928 <_Region_Process_queue+0xe0> 201a910: 01 00 00 00 nop 201a914: 81 c7 e0 08 ret <== NOT EXECUTED 201a918: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 201a91c: 7f ff f0 45 call 2016a30 <_Thread_Dispatch> <== NOT EXECUTED 201a920: a4 06 20 68 add %i0, 0x68, %l2 <== NOT EXECUTED 201a924: 30 bf ff ef b,a 201a8e0 <_Region_Process_queue+0x98> <== NOT EXECUTED 201a928: 7f ff f0 42 call 2016a30 <_Thread_Dispatch> 201a92c: 81 e8 00 00 restore 201a930: 01 00 00 00 nop 02008b28 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 2008b28: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008b2c: 23 00 80 93 sethi %hi(0x2024c00), %l1 2008b30: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 ! 2024dc0 <_Thread_Dispatch_disable_level> 2008b34: 82 00 60 01 inc %g1 2008b38: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 2008b3c: 21 00 80 93 sethi %hi(0x2024c00), %l0 2008b40: c2 06 00 00 ld [ %i0 ], %g1 2008b44: d4 04 22 7c ld [ %l0 + 0x27c ], %o2 2008b48: 80 a0 40 0a cmp %g1, %o2 2008b4c: 36 80 00 18 bge,a 2008bac <_TOD_Set+0x84> 2008b50: 94 20 40 0a sub %g1, %o2, %o2 Watchdog_Adjust_directions direction, Watchdog_Interval units ) { _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units ); 2008b54: 11 00 80 93 sethi %hi(0x2024c00), %o0 2008b58: 94 22 80 01 sub %o2, %g1, %o2 2008b5c: 90 12 22 b4 or %o0, 0x2b4, %o0 2008b60: 40 00 0f 24 call 200c7f0 <_Watchdog_Adjust> 2008b64: 92 10 20 01 mov 1, %o1 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 2008b68: c4 06 00 00 ld [ %i0 ], %g2 2008b6c: 86 14 22 7c or %l0, 0x27c, %g3 2008b70: c4 24 22 7c st %g2, [ %l0 + 0x27c ] 2008b74: c2 06 20 04 ld [ %i0 + 4 ], %g1 _TOD_Is_set = TRUE; 2008b78: 84 10 20 01 mov 1, %g2 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 2008b7c: c2 20 e0 04 st %g1, [ %g3 + 4 ] _TOD_Is_set = TRUE; 2008b80: 03 00 80 93 sethi %hi(0x2024c00), %g1 2008b84: c4 20 61 fc st %g2, [ %g1 + 0x1fc ] ! 2024dfc <_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 ) 2008b88: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2008b8c: 82 00 7f ff add %g1, -1, %g1 2008b90: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 2008b94: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 2008b98: 80 a0 a0 00 cmp %g2, 0 2008b9c: 02 80 00 0a be 2008bc4 <_TOD_Set+0x9c> 2008ba0: 01 00 00 00 nop 2008ba4: 81 c7 e0 08 ret 2008ba8: 81 e8 00 00 restore 2008bac: 11 00 80 93 sethi %hi(0x2024c00), %o0 2008bb0: 92 10 20 00 clr %o1 2008bb4: 40 00 0f 0f call 200c7f0 <_Watchdog_Adjust> 2008bb8: 90 12 22 b4 or %o0, 0x2b4, %o0 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 2008bbc: 10 bf ff ec b 2008b6c <_TOD_Set+0x44> 2008bc0: c4 06 00 00 ld [ %i0 ], %g2 _Thread_Dispatch(); 2008bc4: 40 00 08 48 call 200ace4 <_Thread_Dispatch> <== NOT EXECUTED 2008bc8: 81 e8 00 00 restore <== NOT EXECUTED 2008bcc: 01 00 00 00 nop 02009098 <_Thread_Create_idle>: */ const char *_Thread_Idle_name = "IDLE"; void _Thread_Create_idle( void ) { 2009098: 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 ); 200909c: 39 00 80 62 sethi %hi(0x2018800), %i4 20090a0: 7f ff f9 cd call 20077d4 <_Objects_Allocate> 20090a4: 90 17 21 70 or %i4, 0x170, %o0 ! 2018970 <_Thread_Internal_information> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 20090a8: 03 00 80 61 sethi %hi(0x2018400), %g1 20090ac: 96 10 63 f4 or %g1, 0x3f4, %o3 ! 20187f4 <_CPU_Table> 20090b0: c4 02 e0 0c ld [ %o3 + 0xc ], %g2 * The entire workspace is zeroed during its initialization. Thus, all * fields not explicitly assigned were explicitly zeroed by * _Workspace_Initialization. */ _Thread_Idle = _Thread_Internal_allocate(); 20090b4: 37 00 80 62 sethi %hi(0x2018800), %i3 20090b8: d0 26 e1 c8 st %o0, [ %i3 + 0x1c8 ] ! 20189c8 <_Thread_Idle> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 20090bc: 03 00 80 24 sethi %hi(0x2009000), %g1 20090c0: 92 10 00 08 mov %o0, %o1 20090c4: 80 a0 a0 00 cmp %g2, 0 20090c8: 02 80 00 03 be 20090d4 <_Thread_Create_idle+0x3c> 20090cc: b4 10 63 78 or %g1, 0x378, %i2 idle = _CPU_Table.idle_task; 20090d0: b4 10 00 02 mov %g2, %i2 <== NOT EXECUTED idle_task_stack_size = _CPU_Table.idle_task_stack_size; 20090d4: d6 02 e0 14 ld [ %o3 + 0x14 ], %o3 if ( idle_task_stack_size < STACK_MINIMUM_SIZE ) 20090d8: 80 a2 ef ff cmp %o3, 0xfff 20090dc: 28 80 00 02 bleu,a 20090e4 <_Thread_Create_idle+0x4c> 20090e0: 17 00 00 04 sethi %hi(0x1000), %o3 idle_task_stack_size = STACK_MINIMUM_SIZE; _Thread_Initialize( 20090e4: 03 00 80 5f sethi %hi(0x2017c00), %g1 20090e8: c4 00 60 50 ld [ %g1 + 0x50 ], %g2 ! 2017c50 <_Thread_Idle_name> 20090ec: 82 10 20 01 mov 1, %g1 20090f0: c4 23 a0 6c st %g2, [ %sp + 0x6c ] 20090f4: 90 17 21 70 or %i4, 0x170, %o0 20090f8: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 20090fc: c0 23 a0 60 clr [ %sp + 0x60 ] 2009100: c0 23 a0 64 clr [ %sp + 0x64 ] 2009104: c0 23 a0 68 clr [ %sp + 0x68 ] 2009108: 94 10 20 00 clr %o2 200910c: 98 10 20 00 clr %o4 2009110: 40 00 00 9b call 200937c <_Thread_Initialize> 2009114: 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 = 2009118: c6 06 e1 c8 ld [ %i3 + 0x1c8 ], %g3 200911c: 03 00 80 62 sethi %hi(0x2018800), %g1 2009120: 05 00 80 62 sethi %hi(0x2018800), %g2 _Thread_Executing = _Thread_Idle; _Thread_Start( 2009124: b0 10 00 03 mov %g3, %i0 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 2009128: c6 20 60 c0 st %g3, [ %g1 + 0xc0 ] 200912c: c6 20 a0 98 st %g3, [ %g2 + 0x98 ] _Thread_Executing = _Thread_Idle; _Thread_Start( 2009130: b2 10 20 00 clr %i1 2009134: b6 10 20 00 clr %i3 2009138: 40 00 04 35 call 200a20c <_Thread_Start> 200913c: 99 e8 20 00 restore %g0, 0, %o4 2009140: 01 00 00 00 nop 02009144 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 2009144: 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 ) ) { 2009148: 92 96 20 00 orcc %i0, 0, %o1 200914c: 12 80 00 11 bne 2009190 <_Thread_Delay_ended+0x4c> 2009150: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2009154: 31 00 80 61 sethi %hi(0x2018400), %i0 <== NOT EXECUTED 2009158: c2 06 23 e0 ld [ %i0 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200915c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2009160: c2 26 23 e0 st %g1, [ %i0 + 0x3e0 ] <== 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; 2009164: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2009168: d0 00 60 c0 ld [ %g1 + 0xc0 ], %o0 ! 20188c0 <_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; 200916c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2009170: 13 04 00 ff sethi %hi(0x1003fc00), %o1 <== NOT EXECUTED 2009174: 7f ff ff 5c call 2008ee4 <_Thread_Clear_state> 2009178: 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; 200917c: c2 06 23 e0 ld [ %i0 + 0x3e0 ], %g1 2009180: 82 00 7f ff add %g1, -1, %g1 2009184: c2 26 23 e0 st %g1, [ %i0 + 0x3e0 ] 2009188: 81 c7 e0 08 ret 200918c: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2009190: 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 ) { 2009194: 80 a0 a0 04 cmp %g2, 4 2009198: 18 bf ff fc bgu 2009188 <_Thread_Delay_ended+0x44> 200919c: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20091a0: 80 a0 60 01 cmp %g1, 1 20091a4: 12 bf ff f9 bne 2009188 <_Thread_Delay_ended+0x44> 20091a8: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20091ac: 05 00 80 61 sethi %hi(0x2018400), %g2 20091b0: 84 10 a3 40 or %g2, 0x340, %g2 ! 2018740 <_Objects_Information_table> 20091b4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 20091b8: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 20091bc: 80 a2 20 00 cmp %o0, 0 20091c0: 02 bf ff f2 be 2009188 <_Thread_Delay_ended+0x44> 20091c4: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20091c8: 7f ff fa d4 call 2007d18 <_Objects_Get> 20091cc: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20091d0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20091d4: 80 a0 60 00 cmp %g1, 0 20091d8: 12 bf ff ec bne 2009188 <_Thread_Delay_ended+0x44> 20091dc: 31 00 80 61 sethi %hi(0x2018400), %i0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 20091e0: 10 bf ff e5 b 2009174 <_Thread_Delay_ended+0x30> 20091e4: 13 04 00 ff sethi %hi(0x1003fc00), %o1 0200e10c <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 200e10c: 9d e3 bf 98 save %sp, -104, %sp #endif #if defined(__USE__MAIN__) extern void _main(void); #endif executing = _Thread_Executing; 200e110: 03 00 80 62 sethi %hi(0x2018800), %g1 200e114: f4 00 60 c0 ld [ %g1 + 0xc0 ], %i2 ! 20188c0 <_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(); 200e118: 3f 00 80 38 sethi %hi(0x200e000), %i7 200e11c: be 17 e1 0c or %i7, 0x10c, %i7 ! 200e10c <_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); 200e120: d0 06 a0 c4 ld [ %i2 + 0xc4 ], %o0 200e124: 7f ff cf 33 call 2001df0 200e128: 91 2a 20 08 sll %o0, 8, %o0 #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 200e12c: 07 00 80 61 sethi %hi(0x2018400), %g3 doneConstructors = 1; 200e130: 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; 200e134: f0 08 e0 78 ldub [ %g3 + 0x78 ], %i0 doneConstructors = 1; 200e138: c2 28 e0 78 stb %g1, [ %g3 + 0x78 ] #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 ) ) { 200e13c: c4 06 a1 68 ld [ %i2 + 0x168 ], %g2 200e140: 80 a0 a0 00 cmp %g2, 0 200e144: 02 80 00 07 be 200e160 <_Thread_Handler+0x54> 200e148: 01 00 00 00 nop #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 ); 200e14c: 33 00 80 62 sethi %hi(0x2018800), %i1 200e150: d0 06 60 90 ld [ %i1 + 0x90 ], %o0 ! 2018890 <_Thread_Allocated_fp> 200e154: 80 a6 80 08 cmp %i2, %o0 200e158: 12 80 00 20 bne 200e1d8 <_Thread_Handler+0xcc> 200e15c: 80 a2 20 00 cmp %o0, 0 * 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 ); 200e160: 7f ff f0 e9 call 200a504 <_User_extensions_Thread_begin> 200e164: 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 ) 200e168: 03 00 80 61 sethi %hi(0x2018400), %g1 200e16c: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 20187e0 <_Thread_Dispatch_disable_level> 200e170: 84 00 bf ff add %g2, -1, %g2 200e174: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] 200e178: c6 00 63 e0 ld [ %g1 + 0x3e0 ], %g3 200e17c: 80 a0 e0 00 cmp %g3, 0 200e180: 02 80 00 25 be 200e214 <_Thread_Handler+0x108> 200e184: 83 2e 20 18 sll %i0, 0x18, %g1 /* * _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) */ 200e188: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200e18c: 02 80 00 28 be 200e22c <_Thread_Handler+0x120> <== NOT EXECUTED 200e190: 01 00 00 00 nop <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200e194: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 <== NOT EXECUTED 200e198: 80 a0 60 01 cmp %g1, 1 200e19c: 22 80 00 2b be,a 200e248 <_Thread_Handler+0x13c> 200e1a0: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 200e1a4: 80 a0 60 01 cmp %g1, 1 200e1a8: 3a 80 00 31 bcc,a 200e26c <_Thread_Handler+0x160> 200e1ac: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED case THREAD_START_NUMERIC: executing->Wait.return_argument = 200e1b0: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 200e1b4: 9f c0 40 00 call %g1 200e1b8: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 200e1bc: d0 26 a0 28 st %o0, [ %i2 + 0x28 ] * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 200e1c0: 90 10 00 1a mov %i2, %o0 200e1c4: 7f ff f0 f8 call 200a5a4 <_User_extensions_Thread_exitted> 200e1c8: b0 10 20 00 clr %i0 _Internal_error_Occurred( 200e1cc: b2 10 20 01 mov 1, %i1 200e1d0: 7f ff e5 54 call 2007720 <_Internal_error_Occurred> 200e1d4: 95 e8 20 06 restore %g0, 6, %o2 #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 ) ) { if ( _Thread_Allocated_fp != NULL ) 200e1d8: 22 80 00 05 be,a 200e1ec <_Thread_Handler+0xe0> 200e1dc: f4 26 60 90 st %i2, [ %i1 + 0x90 ] _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 200e1e0: 7f ff f2 57 call 200ab3c <_CPU_Context_save_fp> 200e1e4: 90 02 21 68 add %o0, 0x168, %o0 _Thread_Allocated_fp = executing; 200e1e8: f4 26 60 90 st %i2, [ %i1 + 0x90 ] * 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 ); 200e1ec: 7f ff f0 c6 call 200a504 <_User_extensions_Thread_begin> 200e1f0: 90 10 00 1a mov %i2, %o0 200e1f4: 03 00 80 61 sethi %hi(0x2018400), %g1 200e1f8: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 20187e0 <_Thread_Dispatch_disable_level> 200e1fc: 84 00 bf ff add %g2, -1, %g2 200e200: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] 200e204: c6 00 63 e0 ld [ %g1 + 0x3e0 ], %g3 200e208: 80 a0 e0 00 cmp %g3, 0 200e20c: 12 bf ff df bne 200e188 <_Thread_Handler+0x7c> 200e210: 83 2e 20 18 sll %i0, 0x18, %g1 _Thread_Dispatch(); 200e214: 7f ff eb f5 call 20091e8 <_Thread_Dispatch> 200e218: 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) */ 200e21c: 83 2e 20 18 sll %i0, 0x18, %g1 200e220: 80 a0 60 00 cmp %g1, 0 200e224: 32 bf ff dd bne,a 200e198 <_Thread_Handler+0x8c> 200e228: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 _init (); 200e22c: 40 00 25 23 call 20176b8 <_init> 200e230: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200e234: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 200e238: 80 a0 60 01 cmp %g1, 1 200e23c: 12 bf ff db bne 200e1a8 <_Thread_Handler+0x9c> 200e240: 01 00 00 00 nop (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 200e244: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 200e248: d0 06 a0 b0 ld [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED 200e24c: 9f c0 40 00 call %g1 <== NOT EXECUTED 200e250: b0 10 20 00 clr %i0 <== NOT EXECUTED 200e254: 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 ); 200e258: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 200e25c: 7f ff f0 d2 call 200a5a4 <_User_extensions_Thread_exitted> <== NOT EXECUTED 200e260: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 200e264: 7f ff e5 2f call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 200e268: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200e26c: 02 80 00 0f be 200e2a8 <_Thread_Handler+0x19c> <== NOT EXECUTED 200e270: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 200e274: 12 bf ff d4 bne 200e1c4 <_Thread_Handler+0xb8> <== NOT EXECUTED 200e278: 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 = 200e27c: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 200e280: d2 06 a0 b0 ld [ %i2 + 0xb0 ], %o1 <== NOT EXECUTED 200e284: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 <== NOT EXECUTED 200e288: 9f c0 40 00 call %g1 <== NOT EXECUTED 200e28c: b0 10 20 00 clr %i0 <== NOT EXECUTED 200e290: 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 ); 200e294: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 200e298: 7f ff f0 c3 call 200a5a4 <_User_extensions_Thread_exitted> <== NOT EXECUTED 200e29c: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 200e2a0: 7f ff e5 20 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 200e2a4: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 200e2a8: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 200e2ac: d0 1e a0 b0 ldd [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED 200e2b0: 9f c0 40 00 call %g1 <== NOT EXECUTED 200e2b4: b0 10 20 00 clr %i0 <== NOT EXECUTED 200e2b8: 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 ); 200e2bc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 200e2c0: 7f ff f0 b9 call 200a5a4 <_User_extensions_Thread_exitted> <== NOT EXECUTED 200e2c4: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 200e2c8: 7f ff e5 16 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 200e2cc: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED 200e2d0: 01 00 00 00 nop 020095a0 <_Thread_Handler_initialization>: void _Thread_Handler_initialization( uint32_t ticks_per_timeslice, uint32_t maximum_extensions, uint32_t maximum_proxies ) { 20095a0: 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 ) 20095a4: 03 00 80 61 sethi %hi(0x2018400), %g1 20095a8: 82 10 63 f4 or %g1, 0x3f4, %g1 ! 20187f4 <_CPU_Table> 20095ac: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 20095b0: c6 00 60 24 ld [ %g1 + 0x24 ], %g3 20095b4: 80 a0 00 02 cmp %g0, %g2 20095b8: 88 60 3f ff subx %g0, -1, %g4 20095bc: 80 a0 00 03 cmp %g0, %g3 20095c0: 82 60 3f ff subx %g0, -1, %g1 20095c4: 80 a1 00 01 cmp %g4, %g1 20095c8: 12 80 00 2e bne 2009680 <_Thread_Handler_initialization+0xe0> 20095cc: 90 10 20 00 clr %o0 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 20095d0: 03 00 80 62 sethi %hi(0x2018800), %g1 _Thread_Executing = NULL; 20095d4: 05 00 80 62 sethi %hi(0x2018800), %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 20095d8: c0 20 60 d0 clr [ %g1 + 0xd0 ] _Thread_Executing = NULL; _Thread_Heir = NULL; 20095dc: 03 00 80 62 sethi %hi(0x2018800), %g1 TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; _Thread_Executing = NULL; 20095e0: c0 20 a0 c0 clr [ %g2 + 0xc0 ] _Thread_Heir = NULL; 20095e4: c0 20 60 98 clr [ %g1 + 0x98 ] #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 20095e8: 05 00 80 62 sethi %hi(0x2018800), %g2 #endif _Thread_Do_post_task_switch_extension = 0; 20095ec: 03 00 80 62 sethi %hi(0x2018800), %g1 _Context_Switch_necessary = FALSE; _Thread_Executing = NULL; _Thread_Heir = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 20095f0: c0 20 a0 90 clr [ %g2 + 0x90 ] #endif _Thread_Do_post_task_switch_extension = 0; 20095f4: c0 20 60 b0 clr [ %g1 + 0xb0 ] _Thread_Maximum_extensions = maximum_extensions; 20095f8: 05 00 80 62 sethi %hi(0x2018800), %g2 _Thread_Ticks_per_timeslice = ticks_per_timeslice; 20095fc: 03 00 80 61 sethi %hi(0x2018400), %g1 _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; _Thread_Maximum_extensions = maximum_extensions; 2009600: f2 20 a0 ac st %i1, [ %g2 + 0xac ] _Thread_Ticks_per_timeslice = ticks_per_timeslice; 2009604: f0 20 63 38 st %i0, [ %g1 + 0x338 ] _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 2009608: 40 00 05 18 call 200aa68 <_Workspace_Allocate_or_fatal_error> 200960c: 90 10 2c 00 mov 0xc00, %o0 2009610: 03 00 80 61 sethi %hi(0x2018400), %g1 2009614: 84 10 00 08 mov %o0, %g2 2009618: d0 20 63 34 st %o0, [ %g1 + 0x334 ] 200961c: 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); 2009620: 82 00 a0 04 add %g2, 4, %g1 the_chain->permanent_null = NULL; 2009624: c0 20 a0 04 clr [ %g2 + 4 ] the_chain->last = _Chain_Head(the_chain); 2009628: 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); 200962c: c2 20 80 00 st %g1, [ %g2 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009630: 84 00 a0 0c add %g2, 0xc, %g2 (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 2009634: 80 a0 80 03 cmp %g2, %g3 2009638: 12 bf ff fb bne 2009624 <_Thread_Handler_initialization+0x84> 200963c: 82 00 a0 04 add %g2, 4, %g1 /* * Initialize this class of objects. */ _Objects_Initialize_information( 2009640: 03 00 80 62 sethi %hi(0x2018800), %g1 2009644: c4 00 60 ec ld [ %g1 + 0xec ], %g2 ! 20188ec <_System_state_Is_multiprocessing> 2009648: 82 10 20 08 mov 8, %g1 200964c: 80 a0 00 02 cmp %g0, %g2 2009650: 96 10 20 02 mov 2, %o3 2009654: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2009658: 96 42 ff ff addx %o3, -1, %o3 200965c: 11 00 80 62 sethi %hi(0x2018800), %o0 2009660: 92 10 20 01 mov 1, %o1 2009664: 90 12 21 70 or %o0, 0x170, %o0 2009668: 94 10 20 01 mov 1, %o2 200966c: 98 10 21 88 mov 0x188, %o4 2009670: 7f ff f9 d1 call 2007db4 <_Objects_Initialize_information> 2009674: 9a 10 20 01 mov 1, %o5 FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 2009678: 81 c7 e0 08 ret 200967c: 81 e8 00 00 restore * Do not allow mixture. */ if ( !( ( _CPU_Table.stack_allocate_hook == 0 ) == ( _CPU_Table.stack_free_hook == 0 ) ) ) _Internal_error_Occurred( 2009680: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2009684: 7f ff f8 27 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 2009688: 94 10 20 0f mov 0xf, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 200968c: 10 bf ff d2 b 20095d4 <_Thread_Handler_initialization+0x34> <== NOT EXECUTED 2009690: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 0200937c <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 200937c: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the Ada self pointer */ the_thread->rtems_ada_self = NULL; 2009380: c0 26 60 80 clr [ %i1 + 0x80 ] /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 2009384: 80 a6 a0 00 cmp %i2, 0 2009388: 02 80 00 71 be 200954c <_Thread_Initialize+0x1d0> 200938c: e2 07 a0 60 ld [ %fp + 0x60 ], %l1 stack = the_thread->Start.stack; the_thread->Start.core_allocated_stack = TRUE; } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 2009390: c0 26 60 cc clr [ %i1 + 0xcc ] <== NOT EXECUTED 2009394: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 2009398: f4 26 60 d4 st %i2, [ %i1 + 0xd4 ] the_stack->size = size; 200939c: 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 ) { 20093a0: 80 a7 20 00 cmp %i4, 0 20093a4: b4 10 20 00 clr %i2 20093a8: 12 80 00 49 bne 20094cc <_Thread_Initialize+0x150> 20093ac: 82 10 20 00 clr %g1 /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 20093b0: 37 00 80 62 sethi %hi(0x2018800), %i3 20093b4: d2 06 e0 ac ld [ %i3 + 0xac ], %o1 ! 20188ac <_Thread_Maximum_extensions> } else fp_area = NULL; the_thread->fp_context = fp_area; the_thread->Start.fp_context = fp_area; 20093b8: c2 26 60 d8 st %g1, [ %i1 + 0xd8 ] fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 20093bc: c2 26 61 68 st %g1, [ %i1 + 0x168 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20093c0: c0 26 60 50 clr [ %i1 + 0x50 ] the_watchdog->routine = routine; 20093c4: c0 26 60 64 clr [ %i1 + 0x64 ] the_watchdog->id = id; 20093c8: c0 26 60 68 clr [ %i1 + 0x68 ] the_watchdog->user_data = user_data; 20093cc: c0 26 60 6c clr [ %i1 + 0x6c ] /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 20093d0: 80 a2 60 00 cmp %o1, 0 20093d4: 12 80 00 4a bne 20094fc <_Thread_Initialize+0x180> 20093d8: c0 26 61 6c clr [ %i1 + 0x16c ] return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 20093dc: c0 26 61 7c clr [ %i1 + 0x17c ] 20093e0: b8 10 20 00 clr %i4 /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 20093e4: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 the_thread->Start.budget_algorithm = budget_algorithm; 20093e8: e2 26 60 bc st %l1, [ %i1 + 0xbc ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 20093ec: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 20093f0: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 switch ( budget_algorithm ) { 20093f4: 80 a4 60 02 cmp %l1, 2 20093f8: 12 80 00 05 bne 200940c <_Thread_Initialize+0x90> 20093fc: 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; 2009400: 03 00 80 61 sethi %hi(0x2018400), %g1 <== NOT EXECUTED 2009404: c4 00 63 38 ld [ %g1 + 0x338 ], %g2 ! 2018738 <_Thread_Ticks_per_timeslice> <== NOT EXECUTED 2009408: c4 26 60 84 st %g2, [ %i1 + 0x84 ] <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 200940c: c2 07 a0 68 ld [ %fp + 0x68 ], %g1 the_thread->current_state = STATES_DORMANT; the_thread->Wait.queue = NULL; 2009410: c0 26 60 44 clr [ %i1 + 0x44 ] break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 2009414: c2 26 60 c4 st %g1, [ %i1 + 0xc4 ] the_thread->current_state = STATES_DORMANT; 2009418: 82 10 20 01 mov 1, %g1 the_thread->Wait.queue = NULL; the_thread->resource_count = 0; 200941c: c0 26 60 1c clr [ %i1 + 0x1c ] break; } the_thread->Start.isr_level = isr_level; the_thread->current_state = STATES_DORMANT; 2009420: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_thread->Wait.queue = NULL; the_thread->resource_count = 0; the_thread->suspend_count = 0; 2009424: c0 26 60 70 clr [ %i1 + 0x70 ] the_thread->real_priority = priority; 2009428: fa 26 60 18 st %i5, [ %i1 + 0x18 ] the_thread->Start.initial_priority = priority; 200942c: fa 26 60 c8 st %i5, [ %i1 + 0xc8 ] _Thread_Set_priority( the_thread, priority ); 2009430: 92 10 00 1d mov %i5, %o1 2009434: 40 00 02 8c call 2009e64 <_Thread_Set_priority> 2009438: 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 ); 200943c: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2009440: 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; 2009444: c0 26 60 90 clr [ %i1 + 0x90 ] 2009448: 03 00 00 3f sethi %hi(0xfc00), %g1 200944c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2009450: 82 08 80 01 and %g2, %g1, %g1 2009454: 80 a0 40 03 cmp %g1, %g3 2009458: 08 80 00 19 bleu 20094bc <_Thread_Initialize+0x140> 200945c: c0 26 60 94 clr [ %i1 + 0x94 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 2009460: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 /* * Invoke create extensions */ if ( !_User_extensions_Thread_create( the_thread ) ) { 2009464: 90 10 00 19 mov %i1, %o0 2009468: c2 26 60 0c st %g1, [ %i1 + 0xc ] 200946c: 40 00 04 61 call 200a5f0 <_User_extensions_Thread_create> 2009470: b0 10 20 01 mov 1, %i0 2009474: 80 a2 20 00 cmp %o0, 0 2009478: 12 80 00 1f bne 20094f4 <_Thread_Initialize+0x178> 200947c: 80 a7 20 00 cmp %i4, 0 if ( extensions_area ) 2009480: 02 80 00 05 be 2009494 <_Thread_Initialize+0x118> 2009484: 92 10 00 1c mov %i4, %o1 2009488: 11 00 80 62 sethi %hi(0x2018800), %o0 <== NOT EXECUTED 200948c: 7f ff f7 a5 call 2007320 <_Heap_Free> <== NOT EXECUTED 2009490: 90 12 20 2c or %o0, 0x2c, %o0 ! 201882c <_Workspace_Area> <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2009494: 80 a6 a0 00 cmp %i2, 0 2009498: 02 80 00 05 be 20094ac <_Thread_Initialize+0x130> 200949c: 11 00 80 62 sethi %hi(0x2018800), %o0 20094a0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 20094a4: 7f ff f7 9f call 2007320 <_Heap_Free> <== NOT EXECUTED 20094a8: 90 12 20 2c or %o0, 0x2c, %o0 <== NOT EXECUTED (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); 20094ac: 40 00 03 32 call 200a174 <_Thread_Stack_Free> 20094b0: 90 10 00 19 mov %i1, %o0 20094b4: 81 c7 e0 08 ret 20094b8: 91 e8 20 00 restore %g0, 0, %o0 uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) information->local_table[ index ] = the_object; 20094bc: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 20094c0: 83 28 60 02 sll %g1, 2, %g1 20094c4: 10 bf ff e7 b 2009460 <_Thread_Initialize+0xe4> 20094c8: f2 20 80 01 st %i1, [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 20094cc: 11 00 80 62 sethi %hi(0x2018800), %o0 20094d0: 92 10 20 88 mov 0x88, %o1 20094d4: 7f ff f7 61 call 2007258 <_Heap_Allocate> 20094d8: 90 12 20 2c or %o0, 0x2c, %o0 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) { 20094dc: b4 92 20 00 orcc %o0, 0, %i2 20094e0: 12 bf ff b4 bne 20093b0 <_Thread_Initialize+0x34> 20094e4: 82 10 00 1a mov %i2, %g1 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); 20094e8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 20094ec: 40 00 03 22 call 200a174 <_Thread_Stack_Free> <== NOT EXECUTED 20094f0: b0 10 20 00 clr %i0 <== NOT EXECUTED 20094f4: 81 c7 e0 08 ret 20094f8: 81 e8 00 00 restore 20094fc: 92 02 60 01 inc %o1 2009500: 21 00 80 62 sethi %hi(0x2018800), %l0 2009504: 93 2a 60 02 sll %o1, 2, %o1 2009508: 7f ff f7 54 call 2007258 <_Heap_Allocate> 200950c: 90 14 20 2c or %l0, 0x2c, %o0 if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 2009510: b8 92 20 00 orcc %o0, 0, %i4 2009514: 02 80 00 1c be 2009584 <_Thread_Initialize+0x208> 2009518: c2 06 e0 ac ld [ %i3 + 0xac ], %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 200951c: 80 a0 7f ff cmp %g1, -1 2009520: 02 bf ff b1 be 20093e4 <_Thread_Initialize+0x68> 2009524: f8 26 61 7c st %i4, [ %i1 + 0x17c ] 2009528: 86 00 60 01 add %g1, 1, %g3 200952c: 84 10 20 00 clr %g2 the_thread->extensions[i] = NULL; 2009530: 83 28 a0 02 sll %g2, 2, %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2009534: 84 00 a0 01 inc %g2 2009538: 80 a0 80 03 cmp %g2, %g3 200953c: 12 bf ff fd bne 2009530 <_Thread_Initialize+0x1b4> 2009540: c0 27 00 01 clr [ %i4 + %g1 ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 2009544: 10 bf ff a9 b 20093e8 <_Thread_Initialize+0x6c> 2009548: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { if ( !_Stack_Is_enough( stack_size ) ) 200954c: 80 a6 ef ff cmp %i3, 0xfff 2009550: 08 80 00 03 bleu 200955c <_Thread_Initialize+0x1e0> 2009554: 13 00 00 04 sethi %hi(0x1000), %o1 2009558: 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 ); 200955c: 40 00 02 eb call 200a108 <_Thread_Stack_Allocate> 2009560: 90 10 00 19 mov %i1, %o0 if ( !actual_stack_size || actual_stack_size < stack_size ) 2009564: 80 a2 20 00 cmp %o0, 0 2009568: 02 bf ff d3 be 20094b4 <_Thread_Initialize+0x138> 200956c: 80 a6 c0 08 cmp %i3, %o0 2009570: 18 bf ff d1 bgu 20094b4 <_Thread_Initialize+0x138> 2009574: 82 10 20 01 mov 1, %g1 return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 2009578: f4 06 60 dc ld [ %i1 + 0xdc ], %i2 the_thread->Start.core_allocated_stack = TRUE; 200957c: 10 bf ff 87 b 2009398 <_Thread_Initialize+0x1c> 2009580: c2 26 60 cc st %g1, [ %i1 + 0xcc ] (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2009584: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 2009588: 02 bf ff d8 be 20094e8 <_Thread_Initialize+0x16c> <== NOT EXECUTED 200958c: 90 14 20 2c or %l0, 0x2c, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2009590: 7f ff f7 64 call 2007320 <_Heap_Free> <== NOT EXECUTED 2009594: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); 2009598: 10 bf ff d5 b 20094ec <_Thread_Initialize+0x170> <== NOT EXECUTED 200959c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 0200e52c <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { 200e52c: 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; 200e530: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 200e534: c4 06 20 bc ld [ %i0 + 0xbc ], %g2 the_thread->budget_callout = the_thread->Start.budget_callout; 200e538: 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; 200e53c: 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; 200e540: c4 3e 20 88 std %g2, [ %i0 + 0x88 ] the_thread->Start.pointer_argument = pointer_argument; 200e544: f2 26 20 b0 st %i1, [ %i0 + 0xb0 ] the_thread->Start.numeric_argument = numeric_argument; 200e548: f4 26 20 b4 st %i2, [ %i0 + 0xb4 ] Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { the_thread->resource_count = 0; 200e54c: c0 26 20 1c clr [ %i0 + 0x1c ] the_thread->suspend_count = 0; 200e550: 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 ) ) { 200e554: 7f ff f0 cb call 200a880 <_Thread_queue_Extract_with_proxy> 200e558: 90 10 00 18 mov %i0, %o0 200e55c: 80 a2 20 00 cmp %o0, 0 200e560: 32 80 00 07 bne,a 200e57c <_Thread_Reset+0x50> 200e564: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 if ( _Watchdog_Is_active( &the_thread->Timer ) ) 200e568: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 200e56c: 80 a0 60 02 cmp %g1, 2 200e570: 02 80 00 0c be 200e5a0 <_Thread_Reset+0x74> 200e574: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 200e578: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 200e57c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 200e580: 80 a0 40 19 cmp %g1, %i1 200e584: 02 80 00 05 be 200e598 <_Thread_Reset+0x6c> 200e588: 01 00 00 00 nop the_thread->real_priority = the_thread->Start.initial_priority; 200e58c: f2 26 20 18 st %i1, [ %i0 + 0x18 ] _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 200e590: 7f ff f1 85 call 200aba4 <_Thread_Set_priority> 200e594: 81 e8 00 00 restore 200e598: 81 c7 e0 08 ret 200e59c: 81 e8 00 00 restore the_thread->Start.numeric_argument = numeric_argument; if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 200e5a0: 7f ff f4 35 call 200b674 <_Watchdog_Remove> <== NOT EXECUTED 200e5a4: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 200e5a8: 10 bf ff f5 b 200e57c <_Thread_Reset+0x50> <== NOT EXECUTED 200e5ac: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 <== NOT EXECUTED 0200d714 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 200d714: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 200d718: 03 00 80 62 sethi %hi(0x2018800), %g1 200d71c: e0 00 60 c0 ld [ %g1 + 0xc0 ], %l0 ! 20188c0 <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 200d720: 7f ff d1 b0 call 2001de0 200d724: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 200d728: b0 10 00 08 mov %o0, %i0 if ( _Chain_Has_only_one_node( ready ) ) { 200d72c: c4 04 40 00 ld [ %l1 ], %g2 200d730: c2 04 60 08 ld [ %l1 + 8 ], %g1 200d734: 80 a0 80 01 cmp %g2, %g1 200d738: 32 80 00 04 bne,a 200d748 <_Thread_Reset_timeslice+0x34> 200d73c: c6 04 00 00 ld [ %l0 ], %g3 _ISR_Enable( level ); 200d740: 7f ff d1 ac call 2001df0 200d744: 81 e8 00 00 restore { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 200d748: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200d74c: 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; 200d750: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200d754: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200d758: 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; 200d75c: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 200d760: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200d764: 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; 200d768: e0 20 40 00 st %l0, [ %g1 ] return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 200d76c: 7f ff d1 a1 call 2001df0 200d770: 01 00 00 00 nop 200d774: 7f ff d1 9b call 2001de0 200d778: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 200d77c: 05 00 80 62 sethi %hi(0x2018800), %g2 200d780: c2 00 a0 98 ld [ %g2 + 0x98 ], %g1 ! 2018898 <_Thread_Heir> 200d784: 80 a4 00 01 cmp %l0, %g1 200d788: 32 80 00 05 bne,a 200d79c <_Thread_Reset_timeslice+0x88> 200d78c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 200d790: c2 04 40 00 ld [ %l1 ], %g1 200d794: c2 20 a0 98 st %g1, [ %g2 + 0x98 ] _Context_Switch_necessary = TRUE; 200d798: 84 10 20 01 mov 1, %g2 200d79c: 03 00 80 62 sethi %hi(0x2018800), %g1 200d7a0: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] ! 20188d0 <_Context_Switch_necessary> _ISR_Enable( level ); 200d7a4: 7f ff d1 93 call 2001df0 200d7a8: 81 e8 00 00 restore 200d7ac: 01 00 00 00 nop 0200b9b8 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, boolean force ) { 200b9b8: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; States_Control current_state; _ISR_Disable( level ); 200b9bc: 7f ff dc 51 call 2002b00 200b9c0: 01 00 00 00 nop 200b9c4: a0 10 00 08 mov %o0, %l0 if ( force == TRUE ) 200b9c8: 80 a6 60 01 cmp %i1, 1 200b9cc: 22 80 00 13 be,a 200ba18 <_Thread_Resume+0x60> 200b9d0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 the_thread->suspend_count = 0; else the_thread->suspend_count--; 200b9d4: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED 200b9d8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 200b9dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b9e0: 12 80 00 0c bne 200ba10 <_Thread_Resume+0x58> <== NOT EXECUTED 200b9e4: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED _ISR_Enable( level ); return; } current_state = the_thread->current_state; 200b9e8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 200b9ec: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 200b9f0: 02 80 00 06 be 200ba08 <_Thread_Resume+0x50> <== NOT EXECUTED 200b9f4: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 200b9f8: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 200b9fc: 80 a0 60 00 cmp %g1, 0 200ba00: 02 80 00 0b be 200ba2c <_Thread_Resume+0x74> 200ba04: c2 26 20 10 st %g1, [ %i0 + 0x10 ] _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 200ba08: 7f ff dc 42 call 2002b10 200ba0c: 91 e8 00 10 restore %g0, %l0, %o0 the_thread->suspend_count = 0; else the_thread->suspend_count--; if ( the_thread->suspend_count > 0 ) { _ISR_Enable( level ); 200ba10: 7f ff dc 40 call 2002b10 <== NOT EXECUTED 200ba14: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { 200ba18: 80 88 60 02 btst 2, %g1 200ba1c: 02 bf ff fb be 200ba08 <_Thread_Resume+0x50> 200ba20: c0 26 20 70 clr [ %i0 + 0x70 ] 200ba24: 10 bf ff f6 b 200b9fc <_Thread_Resume+0x44> 200ba28: 82 08 7f fd and %g1, -3, %g1 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 200ba2c: c8 06 20 9c ld [ %i0 + 0x9c ], %g4 200ba30: c4 16 20 a2 lduh [ %i0 + 0xa2 ], %g2 200ba34: c2 11 00 00 lduh [ %g4 ], %g1 if ( _States_Is_ready( current_state ) ) { _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 200ba38: c6 06 20 98 ld [ %i0 + 0x98 ], %g3 200ba3c: 82 10 40 02 or %g1, %g2, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 200ba40: 1b 00 80 93 sethi %hi(0x2024c00), %o5 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 200ba44: c2 31 00 00 sth %g1, [ %g4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200ba48: 82 00 e0 04 add %g3, 4, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 200ba4c: d8 16 20 a0 lduh [ %i0 + 0xa0 ], %o4 200ba50: c2 26 00 00 st %g1, [ %i0 ] 200ba54: c4 13 62 94 lduh [ %o5 + 0x294 ], %g2 old_last_node = the_chain->last; 200ba58: c8 00 e0 08 ld [ %g3 + 8 ], %g4 the_chain->last = the_node; 200ba5c: f0 20 e0 08 st %i0, [ %g3 + 8 ] 200ba60: 84 10 80 0c or %g2, %o4, %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 200ba64: c8 26 20 04 st %g4, [ %i0 + 4 ] 200ba68: c4 33 62 94 sth %g2, [ %o5 + 0x294 ] 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; 200ba6c: f0 21 00 00 st %i0, [ %g4 ] _ISR_Flash( level ); 200ba70: 7f ff dc 28 call 2002b10 200ba74: 90 10 00 10 mov %l0, %o0 200ba78: 7f ff dc 22 call 2002b00 200ba7c: 01 00 00 00 nop if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 200ba80: 09 00 80 93 sethi %hi(0x2024c00), %g4 200ba84: c4 01 22 78 ld [ %g4 + 0x278 ], %g2 ! 2024e78 <_Thread_Heir> 200ba88: c6 06 20 14 ld [ %i0 + 0x14 ], %g3 200ba8c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 200ba90: 80 a0 c0 01 cmp %g3, %g1 200ba94: 1a bf ff dd bcc 200ba08 <_Thread_Resume+0x50> 200ba98: 01 00 00 00 nop _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200ba9c: 03 00 80 93 sethi %hi(0x2024c00), %g1 200baa0: c4 00 62 a0 ld [ %g1 + 0x2a0 ], %g2 ! 2024ea0 <_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; 200baa4: f0 21 22 78 st %i0, [ %g4 + 0x278 ] if ( _Thread_Executing->is_preemptible || 200baa8: c2 00 a0 7c ld [ %g2 + 0x7c ], %g1 200baac: 80 a0 60 00 cmp %g1, 0 200bab0: 02 80 00 06 be 200bac8 <_Thread_Resume+0x110> 200bab4: 80 a0 e0 00 cmp %g3, 0 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 200bab8: 84 10 20 01 mov 1, %g2 200babc: 03 00 80 93 sethi %hi(0x2024c00), %g1 200bac0: c4 20 62 b0 st %g2, [ %g1 + 0x2b0 ] ! 2024eb0 <_Context_Switch_necessary> 200bac4: 30 bf ff d1 b,a 200ba08 <_Thread_Resume+0x50> _ISR_Flash( level ); if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200bac8: 12 bf ff d0 bne 200ba08 <_Thread_Resume+0x50> 200bacc: 84 10 20 01 mov 1, %g2 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 200bad0: 10 bf ff fc b 200bac0 <_Thread_Resume+0x108> <== NOT EXECUTED 200bad4: 03 00 80 93 sethi %hi(0x2024c00), %g1 <== NOT EXECUTED 0200a108 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 200a108: 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 ) ) 200a10c: 80 a6 6f ff cmp %i1, 0xfff 200a110: 28 80 00 02 bleu,a 200a118 <_Thread_Stack_Allocate+0x10> 200a114: 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 ) { 200a118: 03 00 80 62 sethi %hi(0x2018800), %g1 200a11c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 ! 2018814 <_CPU_Table+0x20> 200a120: 80 a0 60 00 cmp %g1, 0 200a124: 02 80 00 0a be 200a14c <_Thread_Stack_Allocate+0x44> 200a128: 92 06 60 10 add %i1, 0x10, %o1 stack_addr = (*_CPU_Table.stack_allocate_hook)( the_stack_size ); 200a12c: 9f c0 40 00 call %g1 <== NOT EXECUTED 200a130: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 200a134: d0 26 20 dc st %o0, [ %i0 + 0xdc ] <== NOT EXECUTED the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 200a138: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 200a13c: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 200a140: b0 0e 40 18 and %i1, %i0, %i0 <== NOT EXECUTED 200a144: 81 c7 e0 08 ret <== NOT EXECUTED 200a148: 81 e8 00 00 restore <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 200a14c: 11 00 80 62 sethi %hi(0x2018800), %o0 200a150: b2 10 00 09 mov %o1, %i1 200a154: 7f ff f4 41 call 2007258 <_Heap_Allocate> 200a158: 90 12 20 2c or %o0, 0x2c, %o0 } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 200a15c: 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 ) 200a160: 80 a0 00 08 cmp %g0, %o0 200a164: b0 60 20 00 subx %g0, 0, %i0 the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 200a168: b0 0e 40 18 and %i1, %i0, %i0 200a16c: 81 c7 e0 08 ret 200a170: 81 e8 00 00 restore 0200a174 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 200a174: 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 ) 200a178: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 200a17c: 80 a0 60 00 cmp %g1, 0 200a180: 02 80 00 08 be 200a1a0 <_Thread_Stack_Free+0x2c> 200a184: 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 ) 200a188: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 ! 2018818 <_CPU_Table+0x24> 200a18c: 80 a0 60 00 cmp %g1, 0 200a190: 22 80 00 06 be,a 200a1a8 <_Thread_Stack_Free+0x34> 200a194: f2 06 20 d4 ld [ %i0 + 0xd4 ], %i1 (*_CPU_Table.stack_free_hook)( the_thread->Start.Initial_stack.area ); 200a198: 9f c0 40 00 call %g1 <== NOT EXECUTED 200a19c: d0 06 20 d4 ld [ %i0 + 0xd4 ], %o0 <== NOT EXECUTED 200a1a0: 81 c7 e0 08 ret <== NOT EXECUTED 200a1a4: 81 e8 00 00 restore <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 200a1a8: 31 00 80 62 sethi %hi(0x2018800), %i0 200a1ac: 7f ff f4 5d call 2007320 <_Heap_Free> 200a1b0: 91 ee 20 2c restore %i0, 0x2c, %o0 200a1b4: 01 00 00 00 nop 0200a254 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 200a254: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; 200a258: 03 00 80 62 sethi %hi(0x2018800), %g1 200a25c: e0 00 60 c0 ld [ %g1 + 0xc0 ], %l0 ! 20188c0 <_Thread_Executing> /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 200a260: c4 04 20 7c ld [ %l0 + 0x7c ], %g2 200a264: 80 a0 a0 00 cmp %g2, 0 200a268: 02 80 00 24 be 200a2f8 <_Thread_Tickle_timeslice+0xa4> 200a26c: 01 00 00 00 nop return; if ( !_States_Is_ready( executing->current_state ) ) 200a270: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 200a274: 80 a0 60 00 cmp %g1, 0 200a278: 12 80 00 20 bne 200a2f8 <_Thread_Tickle_timeslice+0xa4> 200a27c: 01 00 00 00 nop /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 200a280: c2 04 20 88 ld [ %l0 + 0x88 ], %g1 200a284: 80 a0 60 01 cmp %g1, 1 200a288: 0a 80 00 09 bcs 200a2ac <_Thread_Tickle_timeslice+0x58> 200a28c: 80 a0 60 02 cmp %g1, 2 200a290: 18 80 00 09 bgu 200a2b4 <_Thread_Tickle_timeslice+0x60> 200a294: 80 a0 60 03 cmp %g1, 3 case THREAD_CPU_BUDGET_ALGORITHM_NONE: break; case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: if ( (int)(--executing->cpu_time_budget) <= 0 ) { 200a298: c2 04 20 84 ld [ %l0 + 0x84 ], %g1 200a29c: 82 00 7f ff add %g1, -1, %g1 200a2a0: 80 a0 60 00 cmp %g1, 0 200a2a4: 04 80 00 10 ble 200a2e4 <_Thread_Tickle_timeslice+0x90> 200a2a8: c2 24 20 84 st %g1, [ %l0 + 0x84 ] 200a2ac: 81 c7 e0 08 ret 200a2b0: 81 e8 00 00 restore /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 200a2b4: 12 80 00 11 bne 200a2f8 <_Thread_Tickle_timeslice+0xa4> <== NOT EXECUTED 200a2b8: 01 00 00 00 nop <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; } break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 200a2bc: c2 04 20 84 ld [ %l0 + 0x84 ], %g1 <== NOT EXECUTED 200a2c0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200a2c4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200a2c8: 12 bf ff f9 bne 200a2ac <_Thread_Tickle_timeslice+0x58> <== NOT EXECUTED 200a2cc: c2 24 20 84 st %g1, [ %l0 + 0x84 ] <== NOT EXECUTED (*executing->budget_callout)( executing ); 200a2d0: c2 04 20 8c ld [ %l0 + 0x8c ], %g1 <== NOT EXECUTED 200a2d4: 9f c0 40 00 call %g1 <== NOT EXECUTED 200a2d8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 200a2dc: 81 c7 e0 08 ret <== NOT EXECUTED 200a2e0: 81 e8 00 00 restore <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: if ( (int)(--executing->cpu_time_budget) <= 0 ) { _Thread_Reset_timeslice(); 200a2e4: 40 00 0d 0c call 200d714 <_Thread_Reset_timeslice> 200a2e8: 01 00 00 00 nop executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 200a2ec: 03 00 80 61 sethi %hi(0x2018400), %g1 200a2f0: c4 00 63 38 ld [ %g1 + 0x338 ], %g2 ! 2018738 <_Thread_Ticks_per_timeslice> 200a2f4: c4 24 20 84 st %g2, [ %l0 + 0x84 ] 200a2f8: 81 c7 e0 08 ret 200a2fc: 81 e8 00 00 restore 0200a300 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 200a300: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 200a304: 03 00 80 62 sethi %hi(0x2018800), %g1 200a308: e0 00 60 c0 ld [ %g1 + 0xc0 ], %l0 ! 20188c0 <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 200a30c: 7f ff de b5 call 2001de0 200a310: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 200a314: b0 10 00 08 mov %o0, %i0 if ( !_Chain_Has_only_one_node( ready ) ) { 200a318: c4 04 40 00 ld [ %l1 ], %g2 200a31c: c2 04 60 08 ld [ %l1 + 8 ], %g1 200a320: 80 a0 80 01 cmp %g2, %g1 200a324: 12 80 00 0b bne 200a350 <_Thread_Yield_processor+0x50> 200a328: 03 00 80 62 sethi %hi(0x2018800), %g1 if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 200a32c: c4 00 60 98 ld [ %g1 + 0x98 ], %g2 ! 2018898 <_Thread_Heir> 200a330: 80 a4 00 02 cmp %l0, %g2 200a334: 02 80 00 05 be 200a348 <_Thread_Yield_processor+0x48> 200a338: 01 00 00 00 nop _Context_Switch_necessary = TRUE; 200a33c: 84 10 20 01 mov 1, %g2 ! 1 200a340: 03 00 80 62 sethi %hi(0x2018800), %g1 200a344: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] ! 20188d0 <_Context_Switch_necessary> _ISR_Enable( level ); 200a348: 7f ff de aa call 2001df0 200a34c: 81 e8 00 00 restore ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 200a350: c6 04 00 00 ld [ %l0 ], %g3 previous = the_node->previous; 200a354: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200a358: 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; 200a35c: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200a360: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200a364: 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; 200a368: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 200a36c: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200a370: 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; 200a374: e0 20 40 00 st %l0, [ %g1 ] _ISR_Disable( level ); if ( !_Chain_Has_only_one_node( ready ) ) { _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 200a378: 7f ff de 9e call 2001df0 200a37c: 01 00 00 00 nop 200a380: 7f ff de 98 call 2001de0 200a384: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 200a388: 05 00 80 62 sethi %hi(0x2018800), %g2 200a38c: c2 00 a0 98 ld [ %g2 + 0x98 ], %g1 ! 2018898 <_Thread_Heir> 200a390: 80 a4 00 01 cmp %l0, %g1 200a394: 32 bf ff eb bne,a 200a340 <_Thread_Yield_processor+0x40> 200a398: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 200a39c: c2 04 40 00 ld [ %l1 ], %g1 200a3a0: 10 bf ff e7 b 200a33c <_Thread_Yield_processor+0x3c> 200a3a4: c2 20 a0 98 st %g1, [ %g2 + 0x98 ] 02009694 <_Thread_queue_Dequeue>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 2009694: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 2009698: 80 a0 60 00 cmp %g1, 0 200969c: 12 80 00 05 bne 20096b0 <_Thread_queue_Dequeue+0x1c> 20096a0: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); 20096a4: 82 13 c0 00 mov %o7, %g1 20096a8: 40 00 0f 13 call 200d2f4 <_Thread_queue_Dequeue_fifo> 20096ac: 9e 10 40 00 mov %g1, %o7 Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 20096b0: 02 80 00 04 be 20096c0 <_Thread_queue_Dequeue+0x2c> 20096b4: 01 00 00 00 nop the_thread = NULL; break; } return( the_thread ); } 20096b8: 81 c3 e0 08 retl <== NOT EXECUTED 20096bc: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED switch ( the_thread_queue->discipline ) { case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_Dequeue_priority( the_thread_queue ); 20096c0: 82 13 c0 00 mov %o7, %g1 20096c4: 40 00 00 03 call 20096d0 <_Thread_queue_Dequeue_priority> 20096c8: 9e 10 40 00 mov %g1, %o7 20096cc: 01 00 00 00 nop 0200d2f4 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 200d2f4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 200d2f8: 7f ff d2 ba call 2001de0 200d2fc: a0 10 00 18 mov %i0, %l0 200d300: 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)); 200d304: f0 06 00 00 ld [ %i0 ], %i0 if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 200d308: 82 04 20 04 add %l0, 4, %g1 200d30c: 80 a6 00 01 cmp %i0, %g1 200d310: 22 80 00 1d be,a 200d384 <_Thread_queue_Dequeue_fifo+0x90> 200d314: 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; 200d318: c2 06 00 00 ld [ %i0 ], %g1 the_chain->first = new_first; 200d31c: 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 ) ) { 200d320: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 new_first->previous = _Chain_Head(the_chain); 200d324: e0 20 60 04 st %l0, [ %g1 + 4 ] 200d328: 80 a0 a0 02 cmp %g2, 2 200d32c: 02 80 00 0a be 200d354 <_Thread_queue_Dequeue_fifo+0x60> 200d330: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 200d334: 7f ff d2 af call 2001df0 200d338: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 200d33c: 90 10 00 18 mov %i0, %o0 200d340: 13 04 00 ff sethi %hi(0x1003fc00), %o1 200d344: 7f ff ee e8 call 2008ee4 <_Thread_Clear_state> 200d348: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 200d34c: 81 c7 e0 08 ret 200d350: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 200d354: 82 10 20 03 mov 3, %g1 200d358: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200d35c: 7f ff d2 a5 call 2001df0 200d360: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 200d364: 7f ff f5 60 call 200a8e4 <_Watchdog_Remove> 200d368: 90 06 20 48 add %i0, 0x48, %o0 200d36c: 90 10 00 18 mov %i0, %o0 200d370: 13 04 00 ff sethi %hi(0x1003fc00), %o1 200d374: 7f ff ee dc call 2008ee4 <_Thread_Clear_state> 200d378: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 200d37c: 81 c7 e0 08 ret 200d380: 81 e8 00 00 restore #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 200d384: 80 a0 60 02 cmp %g1, 2 200d388: 18 80 00 0c bgu 200d3b8 <_Thread_queue_Dequeue_fifo+0xc4> 200d38c: 80 a0 60 03 cmp %g1, 3 200d390: 80 a0 60 01 cmp %g1, 1 200d394: 0a 80 00 0b bcs 200d3c0 <_Thread_queue_Dequeue_fifo+0xcc> 200d398: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 200d39c: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 200d3a0: 7f ff d2 94 call 2001df0 <== NOT EXECUTED 200d3a4: 01 00 00 00 nop <== NOT EXECUTED return _Thread_Executing; 200d3a8: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200d3ac: f0 00 60 c0 ld [ %g1 + 0xc0 ], %i0 ! 20188c0 <_Thread_Executing> <== NOT EXECUTED } return NULL; /* this is only to prevent warnings */ } 200d3b0: 81 c7 e0 08 ret <== NOT EXECUTED 200d3b4: 81 e8 00 00 restore <== NOT EXECUTED #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 200d3b8: 12 bf ff e5 bne 200d34c <_Thread_queue_Dequeue_fifo+0x58> <== NOT EXECUTED 200d3bc: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 200d3c0: b0 10 20 00 clr %i0 200d3c4: 7f ff d2 8b call 2001df0 200d3c8: 90 10 00 02 mov %g2, %o0 200d3cc: 81 c7 e0 08 ret 200d3d0: 81 e8 00 00 restore 020096d0 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 20096d0: 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 ); 20096d4: 7f ff e1 c3 call 2001de0 20096d8: 01 00 00 00 nop 20096dc: 9a 10 00 08 mov %o0, %o5 20096e0: 86 10 20 00 clr %g3 20096e4: 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)); 20096e8: 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 ] ) ) { 20096ec: 85 28 e0 02 sll %g3, 2, %g2 20096f0: 83 28 e0 04 sll %g3, 4, %g1 20096f4: 82 20 40 02 sub %g1, %g2, %g1 20096f8: 82 06 00 01 add %i0, %g1, %g1 20096fc: 82 00 60 04 add %g1, 4, %g1 2009700: 80 a2 00 01 cmp %o0, %g1 2009704: 12 80 00 50 bne 2009844 <_Thread_queue_Dequeue_priority+0x174> 2009708: 88 01 20 0c add %g4, 0xc, %g4 Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 200970c: 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 ; 2009710: 80 a0 e0 04 cmp %g3, 4 2009714: 32 bf ff f6 bne,a 20096ec <_Thread_queue_Dequeue_priority+0x1c> 2009718: d0 01 00 18 ld [ %g4 + %i0 ], %o0 the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 200971c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2009720: 80 a0 60 02 cmp %g1, 2 2009724: 08 80 00 23 bleu 20097b0 <_Thread_queue_Dequeue_priority+0xe0> 2009728: 80 a0 60 01 cmp %g1, 1 200972c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2009730: 02 80 00 29 be 20097d4 <_Thread_queue_Dequeue_priority+0x104> <== NOT EXECUTED 2009734: b0 10 20 00 clr %i0 <== NOT EXECUTED return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; new_first_node = the_thread->Wait.Block2n.first; 2009738: 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 ) ) { 200973c: 82 06 20 3c add %i0, 0x3c, %g1 _ISR_Enable( level ); return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; 2009740: 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 ) ) { 2009744: 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; 2009748: c4 06 00 00 ld [ %i0 ], %g2 previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 200974c: 02 80 00 27 be 20097e8 <_Thread_queue_Dequeue_priority+0x118> 2009750: c2 06 20 04 ld [ %i0 + 4 ], %g1 last_node = the_thread->Wait.Block2n.last; 2009754: d8 06 20 40 ld [ %i0 + 0x40 ], %o4 new_second_node = new_first_node->next; 2009758: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 200975c: 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; 2009760: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 2009764: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 2009768: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 200976c: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 2009770: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 2009774: 80 a0 80 01 cmp %g2, %g1 2009778: 12 80 00 2d bne 200982c <_Thread_queue_Dequeue_priority+0x15c> 200977c: 82 00 e0 38 add %g3, 0x38, %g1 } else { previous_node->next = next_node; next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 2009780: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 2009784: 80 a0 60 02 cmp %g1, 2 2009788: 02 80 00 1e be 2009800 <_Thread_queue_Dequeue_priority+0x130> 200978c: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 2009790: 7f ff e1 98 call 2001df0 2009794: 90 10 00 0d mov %o5, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2009798: 90 10 00 18 mov %i0, %o0 200979c: 13 04 00 ff sethi %hi(0x1003fc00), %o1 20097a0: 7f ff fd d1 call 2008ee4 <_Thread_Clear_state> 20097a4: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 20097a8: 81 c7 e0 08 ret 20097ac: 81 e8 00 00 restore the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 20097b0: 0a 80 00 09 bcs 20097d4 <_Thread_queue_Dequeue_priority+0x104> 20097b4: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 20097b8: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 20097bc: 7f ff e1 8d call 2001df0 <== NOT EXECUTED 20097c0: 90 10 00 0d mov %o5, %o0 <== NOT EXECUTED return _Thread_Executing; 20097c4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20097c8: f0 00 60 c0 ld [ %g1 + 0xc0 ], %i0 ! 20188c0 <_Thread_Executing> <== NOT EXECUTED 20097cc: 81 c7 e0 08 ret <== NOT EXECUTED 20097d0: 81 e8 00 00 restore <== NOT EXECUTED } switch ( the_thread_queue->sync_state ) { case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 20097d4: b0 10 20 00 clr %i0 20097d8: 7f ff e1 86 call 2001df0 20097dc: 90 10 00 0d mov %o5, %o0 20097e0: 81 c7 e0 08 ret 20097e4: 81 e8 00 00 restore last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; next_node->previous = previous_node; 20097e8: 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; 20097ec: c4 20 40 00 st %g2, [ %g1 ] next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 20097f0: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 20097f4: 80 a0 60 02 cmp %g1, 2 20097f8: 12 bf ff e6 bne 2009790 <_Thread_queue_Dequeue_priority+0xc0> 20097fc: 82 10 20 03 mov 3, %g1 RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 2009800: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 2009804: 7f ff e1 7b call 2001df0 2009808: 90 10 00 0d mov %o5, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 200980c: 40 00 04 36 call 200a8e4 <_Watchdog_Remove> 2009810: 90 06 20 48 add %i0, 0x48, %o0 2009814: 90 10 00 18 mov %i0, %o0 2009818: 13 04 00 ff sethi %hi(0x1003fc00), %o1 200981c: 7f ff fd b2 call 2008ee4 <_Thread_Clear_state> 2009820: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 2009824: 81 c7 e0 08 ret 2009828: 81 e8 00 00 restore new_first_node->next = next_node; new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ new_second_node->previous = 200982c: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 2009830: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] new_first_thread->Wait.Block2n.last = last_node; 2009834: d8 20 e0 40 st %o4, [ %g3 + 0x40 ] last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 2009838: 82 00 e0 3c add %g3, 0x3c, %g1 200983c: 10 bf ff d1 b 2009780 <_Thread_queue_Dequeue_priority+0xb0> 2009840: c2 23 00 00 st %g1, [ %o4 ] _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { the_thread = (Thread_Control *) 2009844: 10 bf ff bd b 2009738 <_Thread_queue_Dequeue_priority+0x68> 2009848: b0 10 00 08 mov %o0, %i0 0200d3d4 <_Thread_queue_Enqueue_fifo>: void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200d3d4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); 200d3d8: 7f ff d2 82 call 2001de0 200d3dc: 01 00 00 00 nop sync_state = the_thread_queue->sync_state; 200d3e0: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 200d3e4: 80 a0 a0 02 cmp %g2, 2 200d3e8: 02 80 00 22 be 200d470 <_Thread_queue_Enqueue_fifo+0x9c> 200d3ec: c0 26 20 30 clr [ %i0 + 0x30 ] 200d3f0: 80 a0 a0 03 cmp %g2, 3 200d3f4: 02 80 00 11 be 200d438 <_Thread_queue_Enqueue_fifo+0x64> 200d3f8: 80 a0 a0 01 cmp %g2, 1 200d3fc: 02 80 00 07 be 200d418 <_Thread_queue_Enqueue_fifo+0x44> 200d400: 82 06 20 04 add %i0, 4, %g1 200d404: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 200d408: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200d40c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 200d410: 7f ff ee b5 call 2008ee4 <_Thread_Clear_state> <== NOT EXECUTED 200d414: 81 e8 00 00 restore <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200d418: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 200d41c: c4 06 20 08 ld [ %i0 + 8 ], %g2 the_chain->last = the_node; 200d420: f2 26 20 08 st %i1, [ %i0 + 8 ] case THREAD_QUEUE_NOTHING_HAPPENED: _Chain_Append_unprotected( &the_thread_queue->Queues.Fifo, &the_thread->Object.Node ); the_thread->Wait.queue = the_thread_queue; 200d424: f0 26 60 44 st %i0, [ %i1 + 0x44 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200d428: c4 26 60 04 st %g2, [ %i1 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 200d42c: f2 20 80 00 st %i1, [ %g2 ] _ISR_Enable( level ); 200d430: 7f ff d2 70 call 2001df0 200d434: 91 e8 00 08 restore %g0, %o0, %o0 the_thread->Wait.queue = NULL; _ISR_Enable( level ); break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 200d438: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 200d43c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200d440: 12 80 00 16 bne 200d498 <_Thread_queue_Enqueue_fifo+0xc4> <== NOT EXECUTED 200d444: 01 00 00 00 nop <== NOT EXECUTED 200d448: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 200d44c: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 200d450: 7f ff d2 68 call 2001df0 <== NOT EXECUTED 200d454: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 200d458: 7f ff f5 23 call 200a8e4 <_Watchdog_Remove> <== NOT EXECUTED 200d45c: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 200d460: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200d464: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 200d468: 7f ff ee 9f call 2008ee4 <_Thread_Clear_state> <== NOT EXECUTED 200d46c: 81 e8 00 00 restore <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 200d470: c4 06 60 44 ld [ %i1 + 0x44 ], %g2 <== NOT EXECUTED the_thread->Wait.queue = NULL; 200d474: 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; 200d478: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED 200d47c: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 200d480: 7f ff d2 5c call 2001df0 <== NOT EXECUTED 200d484: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 200d488: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200d48c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 200d490: 7f ff ee 95 call 2008ee4 <_Thread_Clear_state> <== NOT EXECUTED 200d494: 81 e8 00 00 restore <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); } else _ISR_Enable( level ); 200d498: 7f ff d2 56 call 2001df0 <== NOT EXECUTED 200d49c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 200d4a0: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200d4a4: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 200d4a8: 7f ff ee 8f call 2008ee4 <_Thread_Clear_state> <== NOT EXECUTED 200d4ac: 81 e8 00 00 restore <== NOT EXECUTED 200d4b0: 01 00 00 00 nop 020098d0 <_Thread_queue_Enqueue_priority>: void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 20098d0: 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; 20098d4: 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); 20098d8: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 20098dc: 84 06 60 38 add %i1, 0x38, %g2 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 20098e0: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; 20098e4: c0 26 60 3c clr [ %i1 + 0x3c ] the_chain->last = _Chain_Head(the_chain); 20098e8: c4 26 60 40 st %g2, [ %i1 + 0x40 ] void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 20098ec: aa 10 00 18 mov %i0, %l5 priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 20098f0: 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); 20098f4: 83 34 a0 06 srl %l2, 6, %g1 20098f8: 12 80 00 40 bne 20099f8 <_Thread_queue_Enqueue_priority+0x128> 20098fc: e8 06 20 38 ld [ %i0 + 0x38 ], %l4 2009900: 85 28 60 04 sll %g1, 4, %g2 2009904: 83 28 60 02 sll %g1, 2, %g1 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 2009908: ac 20 80 01 sub %g2, %g1, %l6 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200990c: 82 06 00 16 add %i0, %l6, %g1 2009910: a6 00 60 04 add %g1, 4, %l3 if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 2009914: 7f ff e1 33 call 2001de0 2009918: 01 00 00 00 nop 200991c: b0 10 00 08 mov %o0, %i0 search_thread = (Thread_Control *) header->first; 2009920: e0 05 40 16 ld [ %l5 + %l6 ], %l0 while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 2009924: 80 a4 00 13 cmp %l0, %l3 2009928: 02 80 00 24 be 20099b8 <_Thread_queue_Enqueue_priority+0xe8> 200992c: a2 10 3f ff mov -1, %l1 search_priority = search_thread->current_priority; 2009930: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 2009934: 80 a4 80 11 cmp %l2, %l1 2009938: 28 80 00 21 bleu,a 20099bc <_Thread_queue_Enqueue_priority+0xec> 200993c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 2009940: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 2009944: 80 a4 c0 10 cmp %l3, %l0 2009948: 32 80 00 19 bne,a 20099ac <_Thread_queue_Enqueue_priority+0xdc> 200994c: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 2009950: 10 80 00 1b b 20099bc <_Thread_queue_Enqueue_priority+0xec> 2009954: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 2009958: 7f ff e1 26 call 2001df0 200995c: 90 10 00 18 mov %i0, %o0 2009960: 7f ff e1 20 call 2001de0 2009964: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2009968: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 200996c: 80 8d 00 01 btst %l4, %g1 2009970: 02 80 00 91 be 2009bb4 <_Thread_queue_Enqueue_priority+0x2e4> 2009974: 01 00 00 00 nop _ISR_Enable( level ); goto restart_forward_search; } search_thread = 2009978: e0 04 00 00 ld [ %l0 ], %l0 restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 200997c: 80 a4 00 13 cmp %l0, %l3 2009980: 22 80 00 0f be,a 20099bc <_Thread_queue_Enqueue_priority+0xec> 2009984: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 search_priority = search_thread->current_priority; 2009988: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 200998c: 80 a4 80 11 cmp %l2, %l1 2009990: 28 80 00 0b bleu,a 20099bc <_Thread_queue_Enqueue_priority+0xec> 2009994: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 2009998: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 200999c: 80 a4 00 13 cmp %l0, %l3 20099a0: 22 80 00 07 be,a 20099bc <_Thread_queue_Enqueue_priority+0xec> 20099a4: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 20099a8: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 20099ac: 80 a4 80 11 cmp %l2, %l1 20099b0: 18 bf ff ea bgu 2009958 <_Thread_queue_Enqueue_priority+0x88> 20099b4: 01 00 00 00 nop } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 20099b8: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 20099bc: 80 a0 60 01 cmp %g1, 1 20099c0: 02 80 00 63 be 2009b4c <_Thread_queue_Enqueue_priority+0x27c> 20099c4: 80 a4 80 11 cmp %l2, %l1 return; synchronize: sync_state = the_thread_queue->sync_state; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; 20099c8: c0 25 60 30 clr [ %l5 + 0x30 ] <== NOT EXECUTED switch ( sync_state ) { 20099cc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20099d0: 02 80 00 54 be 2009b20 <_Thread_queue_Enqueue_priority+0x250> <== NOT EXECUTED 20099d4: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED 20099d8: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 20099dc: 22 80 00 43 be,a 2009ae8 <_Thread_queue_Enqueue_priority+0x218> <== NOT EXECUTED 20099e0: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 20099e4: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 20099e8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 20099ec: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 20099f0: 7f ff fd 3d call 2008ee4 <_Thread_Clear_state> <== NOT EXECUTED 20099f4: 81 e8 00 00 restore <== NOT EXECUTED 20099f8: 85 28 60 04 sll %g1, 4, %g2 20099fc: 83 28 60 02 sll %g1, 2, %g1 restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 2009a00: 82 20 80 01 sub %g2, %g1, %g1 2009a04: a6 00 40 18 add %g1, %i0, %l3 return; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); 2009a08: 7f ff e0 f6 call 2001de0 2009a0c: 01 00 00 00 nop 2009a10: b0 10 00 08 mov %o0, %i0 search_thread = (Thread_Control *) header->last; 2009a14: e0 04 e0 08 ld [ %l3 + 8 ], %l0 while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 2009a18: 80 a4 00 13 cmp %l0, %l3 2009a1c: 02 80 00 24 be 2009aac <_Thread_queue_Enqueue_priority+0x1dc> 2009a20: a2 10 21 00 mov 0x100, %l1 search_priority = search_thread->current_priority; 2009a24: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority >= search_priority ) 2009a28: 80 a4 80 11 cmp %l2, %l1 2009a2c: 3a 80 00 21 bcc,a 2009ab0 <_Thread_queue_Enqueue_priority+0x1e0> 2009a30: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 2009a34: e0 04 20 04 ld [ %l0 + 4 ], %l0 if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 2009a38: 80 a4 c0 10 cmp %l3, %l0 2009a3c: 32 80 00 19 bne,a 2009aa0 <_Thread_queue_Enqueue_priority+0x1d0> 2009a40: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 2009a44: 10 80 00 1b b 2009ab0 <_Thread_queue_Enqueue_priority+0x1e0> 2009a48: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 2009a4c: 7f ff e0 e9 call 2001df0 2009a50: 90 10 00 18 mov %i0, %o0 2009a54: 7f ff e0 e3 call 2001de0 2009a58: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2009a5c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2009a60: 80 8d 00 01 btst %l4, %g1 2009a64: 02 80 00 57 be 2009bc0 <_Thread_queue_Enqueue_priority+0x2f0> 2009a68: 01 00 00 00 nop _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 2009a6c: e0 04 20 04 ld [ %l0 + 4 ], %l0 restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 2009a70: 80 a4 00 13 cmp %l0, %l3 2009a74: 22 80 00 0f be,a 2009ab0 <_Thread_queue_Enqueue_priority+0x1e0> 2009a78: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 search_priority = search_thread->current_priority; 2009a7c: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED if ( priority >= search_priority ) 2009a80: 80 a4 80 11 cmp %l2, %l1 <== NOT EXECUTED 2009a84: 3a 80 00 0b bcc,a 2009ab0 <_Thread_queue_Enqueue_priority+0x1e0> <== NOT EXECUTED 2009a88: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 <== NOT EXECUTED break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 2009a8c: e0 04 20 04 ld [ %l0 + 4 ], %l0 <== NOT EXECUTED if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 2009a90: 80 a4 00 13 cmp %l0, %l3 <== NOT EXECUTED 2009a94: 22 80 00 07 be,a 2009ab0 <_Thread_queue_Enqueue_priority+0x1e0> <== NOT EXECUTED 2009a98: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 <== NOT EXECUTED break; search_priority = search_thread->current_priority; 2009a9c: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED if ( priority >= search_priority ) 2009aa0: 80 a4 80 11 cmp %l2, %l1 2009aa4: 0a bf ff ea bcs 2009a4c <_Thread_queue_Enqueue_priority+0x17c> 2009aa8: 01 00 00 00 nop } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 2009aac: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 2009ab0: 80 a0 60 01 cmp %g1, 1 2009ab4: 12 bf ff c6 bne 20099cc <_Thread_queue_Enqueue_priority+0xfc> 2009ab8: c0 25 60 30 clr [ %l5 + 0x30 ] goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 2009abc: 80 a4 80 11 cmp %l2, %l1 2009ac0: 22 80 00 35 be,a 2009b94 <_Thread_queue_Enqueue_priority+0x2c4> 2009ac4: 82 04 20 3c add %l0, 0x3c, %g1 goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 2009ac8: c2 04 00 00 ld [ %l0 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 2009acc: 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; 2009ad0: 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; 2009ad4: ea 26 60 44 st %l5, [ %i1 + 0x44 ] next_node = search_node->next; the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; search_node->next = the_node; 2009ad8: f2 24 00 00 st %i1, [ %l0 ] next_node->previous = the_node; 2009adc: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2009ae0: 7f ff e0 c4 call 2001df0 2009ae4: 81 e8 00 00 restore the_thread->Wait.queue = NULL; _ISR_Enable( level ); break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 2009ae8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2009aec: 12 80 00 22 bne 2009b74 <_Thread_queue_Enqueue_priority+0x2a4> <== NOT EXECUTED 2009af0: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 2009af4: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 2009af8: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 2009afc: 7f ff e0 bd call 2001df0 <== NOT EXECUTED 2009b00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 2009b04: 40 00 03 78 call 200a8e4 <_Watchdog_Remove> <== NOT EXECUTED 2009b08: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 2009b0c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 2009b10: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 2009b14: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2009b18: 7f ff fc f3 call 2008ee4 <_Thread_Clear_state> <== NOT EXECUTED 2009b1c: 81 e8 00 00 restore <== NOT EXECUTED * This should never happen. All of this was dealt with above. */ break; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 2009b20: c4 06 60 44 ld [ %i1 + 0x44 ], %g2 <== NOT EXECUTED the_thread->Wait.queue = NULL; 2009b24: 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; 2009b28: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED 2009b2c: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 2009b30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2009b34: 7f ff e0 af call 2001df0 <== NOT EXECUTED 2009b38: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 2009b3c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 2009b40: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2009b44: 7f ff fc e8 call 2008ee4 <_Thread_Clear_state> <== NOT EXECUTED 2009b48: 81 e8 00 00 restore <== NOT EXECUTED if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 2009b4c: 02 80 00 11 be 2009b90 <_Thread_queue_Enqueue_priority+0x2c0> 2009b50: c0 25 60 30 clr [ %l5 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 2009b54: c2 04 20 04 ld [ %l0 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 2009b58: e0 26 40 00 st %l0, [ %i1 ] the_node->previous = previous_node; 2009b5c: 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; 2009b60: ea 26 60 44 st %l5, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 2009b64: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 2009b68: f2 24 20 04 st %i1, [ %l0 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2009b6c: 7f ff e0 a1 call 2001df0 2009b70: 81 e8 00 00 restore _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); } else _ISR_Enable( level ); 2009b74: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2009b78: 7f ff e0 9e call 2001df0 <== NOT EXECUTED 2009b7c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 2009b80: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 2009b84: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2009b88: 7f ff fc d7 call 2008ee4 <_Thread_Clear_state> <== NOT EXECUTED 2009b8c: 81 e8 00 00 restore <== NOT EXECUTED 2009b90: 82 04 20 3c add %l0, 0x3c, %g1 _ISR_Enable( level ); return; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 2009b94: c4 00 60 04 ld [ %g1 + 4 ], %g2 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 2009b98: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = previous_node; 2009b9c: 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; 2009ba0: ea 26 60 44 st %l5, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 2009ba4: f2 20 80 00 st %i1, [ %g2 ] search_node->previous = the_node; 2009ba8: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2009bac: 7f ff e0 91 call 2001df0 2009bb0: 81 e8 00 00 restore if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 2009bb4: 7f ff e0 8f call 2001df0 <== NOT EXECUTED 2009bb8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2009bbc: 30 bf ff 56 b,a 2009914 <_Thread_queue_Enqueue_priority+0x44> <== NOT EXECUTED if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 2009bc0: 7f ff e0 8c call 2001df0 <== NOT EXECUTED 2009bc4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2009bc8: 30 bf ff 90 b,a 2009a08 <_Thread_queue_Enqueue_priority+0x138> <== NOT EXECUTED 0200984c <_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 ) { 200984c: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; the_thread = _Thread_Executing; 2009850: 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 ); 2009854: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 Thread_queue_Timeout_callout handler ) { Thread_Control *the_thread; the_thread = _Thread_Executing; 2009858: e0 00 60 c0 ld [ %g1 + 0xc0 ], %l0 void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 200985c: 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 ); 2009860: 40 00 01 9b call 2009ecc <_Thread_Set_state> 2009864: 90 10 00 10 mov %l0, %o0 /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 2009868: 80 a6 60 00 cmp %i1, 0 200986c: 32 80 00 0e bne,a 20098a4 <_Thread_queue_Enqueue_with_handler+0x58> 2009870: c2 04 20 08 ld [ %l0 + 8 ], %g1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 2009874: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 2009878: 80 a0 60 00 cmp %g1, 0 200987c: 12 80 00 04 bne 200988c <_Thread_queue_Enqueue_with_handler+0x40> 2009880: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); 2009884: 40 00 0e d4 call 200d3d4 <_Thread_queue_Enqueue_fifo> 2009888: 93 e8 00 10 restore %g0, %l0, %o1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 200988c: 02 80 00 04 be 200989c <_Thread_queue_Enqueue_with_handler+0x50> 2009890: 01 00 00 00 nop 2009894: 81 c7 e0 08 ret <== NOT EXECUTED 2009898: 81 e8 00 00 restore <== NOT EXECUTED case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Enqueue_priority( the_thread_queue, the_thread ); 200989c: 40 00 00 0d call 20098d0 <_Thread_queue_Enqueue_priority> 20098a0: 93 e8 00 10 restore %g0, %l0, %o1 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 20098a4: f4 24 20 64 st %i2, [ %l0 + 0x64 ] the_watchdog->id = id; 20098a8: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20098ac: f2 24 20 54 st %i1, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20098b0: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 20098b4: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20098b8: 11 00 80 62 sethi %hi(0x2018800), %o0 20098bc: 92 04 20 48 add %l0, 0x48, %o1 20098c0: 40 00 03 9f call 200a73c <_Watchdog_Insert> 20098c4: 90 12 20 e0 or %o0, 0xe0, %o0 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 20098c8: 10 bf ff ec b 2009878 <_Thread_queue_Enqueue_with_handler+0x2c> 20098cc: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 0200d4b4 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 200d4b4: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 200d4b8: 80 a0 60 00 cmp %g1, 0 200d4bc: 12 80 00 05 bne 200d4d0 <_Thread_queue_Extract+0x1c> 200d4c0: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 200d4c4: 82 13 c0 00 mov %o7, %g1 200d4c8: 40 00 03 83 call 200e2d4 <_Thread_queue_Extract_fifo> 200d4cc: 9e 10 40 00 mov %g1, %o7 void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 200d4d0: 02 80 00 04 be 200d4e0 <_Thread_queue_Extract+0x2c> 200d4d4: 94 10 20 00 clr %o2 200d4d8: 81 c3 e0 08 retl <== NOT EXECUTED 200d4dc: 01 00 00 00 nop <== NOT EXECUTED case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 200d4e0: 82 13 c0 00 mov %o7, %g1 200d4e4: 40 00 00 03 call 200d4f0 <_Thread_queue_Extract_priority_helper> 200d4e8: 9e 10 40 00 mov %g1, %o7 200d4ec: 01 00 00 00 nop 0200e2d4 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200e2d4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 200e2d8: 7f ff ce c2 call 2001de0 200e2dc: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200e2e0: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200e2e4: 03 00 00 ef sethi %hi(0x3bc00), %g1 200e2e8: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200e2ec: 80 88 80 01 btst %g2, %g1 200e2f0: 02 80 00 19 be 200e354 <_Thread_queue_Extract_fifo+0x80> 200e2f4: 01 00 00 00 nop ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 200e2f8: c2 06 40 00 ld [ %i1 ], %g1 previous = the_node->previous; 200e2fc: 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 ) ) { 200e300: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 next->previous = previous; previous->next = next; 200e304: c2 20 80 00 st %g1, [ %g2 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200e308: c4 20 60 04 st %g2, [ %g1 + 4 ] 200e30c: 80 a0 e0 02 cmp %g3, 2 200e310: 12 80 00 0c bne 200e340 <_Thread_queue_Extract_fifo+0x6c> 200e314: c0 26 60 44 clr [ %i1 + 0x44 ] 200e318: 82 10 20 03 mov 3, %g1 200e31c: c2 26 60 50 st %g1, [ %i1 + 0x50 ] _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200e320: 7f ff ce b4 call 2001df0 200e324: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 200e328: 7f ff f1 6f call 200a8e4 <_Watchdog_Remove> 200e32c: 90 06 60 48 add %i1, 0x48, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 200e330: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200e334: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200e338: 7f ff ea eb call 2008ee4 <_Thread_Clear_state> 200e33c: 81 e8 00 00 restore _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); 200e340: 7f ff ce ac call 2001df0 200e344: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200e348: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200e34c: 7f ff ea e6 call 2008ee4 <_Thread_Clear_state> 200e350: 81 e8 00 00 restore ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 200e354: 7f ff ce a7 call 2001df0 <== NOT EXECUTED 200e358: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 200e35c: 01 00 00 00 nop 0200d4f0 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, boolean requeuing ) { 200d4f0: 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 ); 200d4f4: 7f ff d2 3b call 2001de0 200d4f8: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200d4fc: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200d500: 03 00 00 ef sethi %hi(0x3bc00), %g1 200d504: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200d508: 80 88 80 01 btst %g2, %g1 200d50c: 02 80 00 29 be 200d5b0 <_Thread_queue_Extract_priority_helper+0xc0> 200d510: 82 06 60 3c add %i1, 0x3c, %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 200d514: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 200d518: c4 06 40 00 ld [ %i1 ], %g2 previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 200d51c: 80 a0 c0 01 cmp %g3, %g1 200d520: 12 80 00 10 bne 200d560 <_Thread_queue_Extract_priority_helper+0x70> 200d524: c2 06 60 04 ld [ %i1 + 4 ], %g1 new_first_thread->Wait.Block2n.last = last_node; last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; next_node->previous = previous_node; 200d528: 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; 200d52c: c4 20 40 00 st %g2, [ %g1 ] /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 200d530: 80 a6 a0 00 cmp %i2, 0 200d534: 12 80 00 1d bne 200d5a8 <_Thread_queue_Extract_priority_helper+0xb8> 200d538: 01 00 00 00 nop _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 200d53c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 200d540: 80 a0 60 02 cmp %g1, 2 200d544: 02 80 00 1d be 200d5b8 <_Thread_queue_Extract_priority_helper+0xc8> 200d548: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 200d54c: 7f ff d2 29 call 2001df0 200d550: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200d554: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200d558: 7f ff ee 63 call 2008ee4 <_Thread_Clear_state> 200d55c: 81 e8 00 00 restore previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 200d560: da 06 60 40 ld [ %i1 + 0x40 ], %o5 new_second_node = new_first_node->next; 200d564: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 200d568: 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; 200d56c: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 200d570: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 200d574: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 200d578: c4 06 60 38 ld [ %i1 + 0x38 ], %g2 200d57c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 200d580: 80 a0 80 01 cmp %g2, %g1 200d584: 02 bf ff ec be 200d534 <_Thread_queue_Extract_priority_helper+0x44> 200d588: 80 a6 a0 00 cmp %i2, 0 /* > two threads on 2-n */ new_second_node->previous = 200d58c: 82 00 e0 38 add %g3, 0x38, %g1 <== NOT EXECUTED 200d590: 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; 200d594: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 200d598: da 20 e0 40 st %o5, [ %g3 + 0x40 ] <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 200d59c: 82 00 e0 3c add %g3, 0x3c, %g1 <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 200d5a0: 02 bf ff e7 be 200d53c <_Thread_queue_Extract_priority_helper+0x4c> <== NOT EXECUTED 200d5a4: c2 23 40 00 st %g1, [ %o5 ] <== NOT EXECUTED _ISR_Enable( level ); 200d5a8: 7f ff d2 12 call 2001df0 200d5ac: 91 e8 00 08 restore %g0, %o0, %o0 Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 200d5b0: 7f ff d2 10 call 2001df0 <== NOT EXECUTED 200d5b4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 200d5b8: c2 26 20 50 st %g1, [ %i0 + 0x50 ] <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200d5bc: 7f ff d2 0d call 2001df0 <== NOT EXECUTED 200d5c0: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 200d5c4: 7f ff f4 c8 call 200a8e4 <_Watchdog_Remove> <== NOT EXECUTED 200d5c8: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED 200d5cc: b2 16 63 f8 or %i1, 0x3f8, %i1 <== NOT EXECUTED 200d5d0: 7f ff ee 45 call 2008ee4 <_Thread_Clear_state> <== NOT EXECUTED 200d5d4: 81 e8 00 00 restore <== NOT EXECUTED 200d5d8: 01 00 00 00 nop 02009bcc <_Thread_queue_Extract_with_proxy>: */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 2009bcc: 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; 2009bd0: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 2009bd4: 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 ) ) { 2009bd8: 03 00 00 ef sethi %hi(0x3bc00), %g1 2009bdc: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2009be0: 80 88 80 01 btst %g2, %g1 2009be4: 02 80 00 1e be 2009c5c <_Thread_queue_Extract_with_proxy+0x90> 2009be8: b0 10 20 00 clr %i0 if ( _States_Is_waiting_for_rpc_reply( state ) && 2009bec: 03 00 00 08 sethi %hi(0x2000), %g1 2009bf0: 80 88 80 01 btst %g2, %g1 2009bf4: 22 80 00 17 be,a 2009c50 <_Thread_queue_Extract_with_proxy+0x84> 2009bf8: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 2009bfc: 03 00 00 e7 sethi %hi(0x39c00), %g1 <== NOT EXECUTED 2009c00: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 39ee0 <== NOT EXECUTED 2009c04: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 2009c08: 22 80 00 12 be,a 2009c50 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 2009c0c: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED _States_Is_locally_blocked( state ) ) { the_information = _Objects_Get_information( the_thread->Wait.id ); 2009c10: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED proxy_extract_callout = 2009c14: 03 00 80 61 sethi %hi(0x2018400), %g1 <== NOT EXECUTED 2009c18: 85 30 e0 16 srl %g3, 0x16, %g2 <== NOT EXECUTED 2009c1c: 82 10 63 40 or %g1, 0x340, %g1 <== NOT EXECUTED 2009c20: 84 08 a0 1c and %g2, 0x1c, %g2 <== NOT EXECUTED 2009c24: c8 00 40 02 ld [ %g1 + %g2 ], %g4 <== NOT EXECUTED 2009c28: 87 30 e0 1b srl %g3, 0x1b, %g3 <== NOT EXECUTED 2009c2c: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED 2009c30: c2 01 00 03 ld [ %g4 + %g3 ], %g1 <== NOT EXECUTED 2009c34: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 <== NOT EXECUTED (Objects_Thread_queue_Extract_callout) the_information->extract; if ( proxy_extract_callout ) 2009c38: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2009c3c: 22 80 00 05 be,a 2009c50 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 2009c40: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED (*proxy_extract_callout)( the_thread ); 2009c44: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009c48: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 2009c4c: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED 2009c50: 92 10 00 10 mov %l0, %o1 2009c54: 40 00 0e 18 call 200d4b4 <_Thread_queue_Extract> 2009c58: b0 10 20 01 mov 1, %i0 return TRUE; } return FALSE; } 2009c5c: 81 c7 e0 08 ret 2009c60: 81 e8 00 00 restore 0201b400 <_Thread_queue_First>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 201b400: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 201b404: 80 a0 60 00 cmp %g1, 0 201b408: 12 80 00 05 bne 201b41c <_Thread_queue_First+0x1c> 201b40c: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); 201b410: 82 13 c0 00 mov %o7, %g1 201b414: 40 00 03 34 call 201c0e4 <_Thread_queue_First_fifo> 201b418: 9e 10 40 00 mov %g1, %o7 Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 201b41c: 02 80 00 04 be 201b42c <_Thread_queue_First+0x2c> 201b420: 01 00 00 00 nop the_thread = NULL; break; } return the_thread; } 201b424: 81 c3 e0 08 retl <== NOT EXECUTED 201b428: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED switch ( the_thread_queue->discipline ) { case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_First_priority( the_thread_queue ); 201b42c: 82 13 c0 00 mov %o7, %g1 201b430: 40 00 00 03 call 201b43c <_Thread_queue_First_priority> 201b434: 9e 10 40 00 mov %g1, %o7 201b438: 01 00 00 00 nop 02009c84 <_Thread_queue_Initialize>: uint32_t timeout_status ) { uint32_t index; the_thread_queue->state = state; 2009c84: d4 22 20 38 st %o2, [ %o0 + 0x38 ] the_thread_queue->discipline = the_discipline; the_thread_queue->timeout_status = timeout_status; 2009c88: d6 22 20 3c st %o3, [ %o0 + 0x3c ] the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; 2009c8c: c0 22 20 30 clr [ %o0 + 0x30 ] switch ( the_discipline ) { 2009c90: 80 a2 60 00 cmp %o1, 0 2009c94: 12 80 00 07 bne 2009cb0 <_Thread_queue_Initialize+0x2c> 2009c98: d2 22 20 34 st %o1, [ %o0 + 0x34 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009c9c: 82 02 20 04 add %o0, 4, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009ca0: d0 22 20 08 st %o0, [ %o0 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2009ca4: c0 22 20 04 clr [ %o0 + 4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009ca8: 81 c3 e0 08 retl 2009cac: c2 22 00 00 st %g1, [ %o0 ] 2009cb0: 80 a2 60 01 cmp %o1, 1 2009cb4: 02 80 00 04 be 2009cc4 <_Thread_queue_Initialize+0x40> 2009cb8: 82 02 20 04 add %o0, 4, %g1 2009cbc: 81 c3 e0 08 retl <== NOT EXECUTED 2009cc0: 01 00 00 00 nop <== NOT EXECUTED 2009cc4: 84 02 20 10 add %o0, 0x10, %g2 2009cc8: c2 22 00 00 st %g1, [ %o0 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009ccc: 82 02 20 0c add %o0, 0xc, %g1 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009cd0: c4 22 20 0c st %g2, [ %o0 + 0xc ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009cd4: c2 22 20 14 st %g1, [ %o0 + 0x14 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009cd8: 84 02 20 1c add %o0, 0x1c, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009cdc: 82 02 20 18 add %o0, 0x18, %g1 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009ce0: c4 22 20 18 st %g2, [ %o0 + 0x18 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009ce4: c2 22 20 20 st %g1, [ %o0 + 0x20 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009ce8: 84 02 20 28 add %o0, 0x28, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009cec: 82 02 20 24 add %o0, 0x24, %g1 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2009cf0: c0 22 20 04 clr [ %o0 + 4 ] the_chain->last = _Chain_Head(the_chain); 2009cf4: d0 22 20 08 st %o0, [ %o0 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2009cf8: c0 22 20 10 clr [ %o0 + 0x10 ] 2009cfc: c0 22 20 1c clr [ %o0 + 0x1c ] 2009d00: c0 22 20 28 clr [ %o0 + 0x28 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009d04: c4 22 20 24 st %g2, [ %o0 + 0x24 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009d08: 81 c3 e0 08 retl 2009d0c: c2 22 20 2c st %g1, [ %o0 + 0x2c ] 02009d10 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 2009d10: 9d e3 bf 98 save %sp, -104, %sp /* just in case the thread really wasn't blocked here */ if ( !the_thread_queue ) { 2009d14: 80 a6 20 00 cmp %i0, 0 2009d18: 02 80 00 06 be 2009d30 <_Thread_queue_Requeue+0x20> 2009d1c: 01 00 00 00 nop return; } switch ( the_thread_queue->discipline ) { 2009d20: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 2009d24: 80 a4 20 01 cmp %l0, 1 2009d28: 02 80 00 04 be 2009d38 <_Thread_queue_Requeue+0x28> 2009d2c: 01 00 00 00 nop 2009d30: 81 c7 e0 08 ret <== NOT EXECUTED 2009d34: 81 e8 00 00 restore <== NOT EXECUTED break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; _ISR_Disable( level ); 2009d38: 7f ff e0 2a call 2001de0 2009d3c: 01 00 00 00 nop 2009d40: a2 10 00 08 mov %o0, %l1 if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 2009d44: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 2009d48: 03 00 00 ef sethi %hi(0x3bc00), %g1 2009d4c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2009d50: 80 88 80 01 btst %g2, %g1 2009d54: 12 80 00 04 bne 2009d64 <_Thread_queue_Requeue+0x54> 2009d58: 94 10 20 01 mov 1, %o2 _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); _Thread_queue_Enqueue_priority( tq, the_thread ); } _ISR_Enable( level ); 2009d5c: 7f ff e0 25 call 2001df0 <== NOT EXECUTED 2009d60: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 2009d64: 90 10 00 18 mov %i0, %o0 2009d68: 92 10 00 19 mov %i1, %o1 2009d6c: 40 00 0d e1 call 200d4f0 <_Thread_queue_Extract_priority_helper> 2009d70: e0 26 20 30 st %l0, [ %i0 + 0x30 ] _Thread_queue_Enqueue_priority( tq, the_thread ); 2009d74: 90 10 00 18 mov %i0, %o0 2009d78: 7f ff fe d6 call 20098d0 <_Thread_queue_Enqueue_priority> 2009d7c: 92 10 00 19 mov %i1, %o1 } _ISR_Enable( level ); 2009d80: 7f ff e0 1c call 2001df0 2009d84: 91 e8 00 11 restore %g0, %l1, %o0 2009d88: 01 00 00 00 nop 02009d8c <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 2009d8c: 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 ) ) { 2009d90: 92 96 20 00 orcc %i0, 0, %o1 2009d94: 12 80 00 1a bne 2009dfc <_Thread_queue_Timeout+0x70> 2009d98: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2009d9c: 31 00 80 61 sethi %hi(0x2018400), %i0 <== NOT EXECUTED 2009da0: c2 06 23 e0 ld [ %i0 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2009da4: 82 00 60 01 inc %g1 <== NOT EXECUTED 2009da8: c2 26 23 e0 st %g1, [ %i0 + 0x3e0 ] <== 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; 2009dac: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2009db0: d2 00 60 c0 ld [ %g1 + 0xc0 ], %o1 ! 20188c0 <_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; 2009db4: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED */ static inline void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 2009db8: d0 02 60 44 ld [ %o1 + 0x44 ], %o0 * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && 2009dbc: c6 02 20 30 ld [ %o0 + 0x30 ], %g3 2009dc0: 80 a0 e0 00 cmp %g3, 0 2009dc4: 02 80 00 06 be 2009ddc <_Thread_queue_Timeout+0x50> 2009dc8: 03 00 80 62 sethi %hi(0x2018800), %g1 2009dcc: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 20188c0 <_Thread_Executing> <== NOT EXECUTED 2009dd0: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED 2009dd4: 02 80 00 20 be 2009e54 <_Thread_queue_Timeout+0xc8> <== NOT EXECUTED 2009dd8: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 2009ddc: c2 02 20 3c ld [ %o0 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 2009de0: 40 00 0d b5 call 200d4b4 <_Thread_queue_Extract> 2009de4: 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; 2009de8: c2 06 23 e0 ld [ %i0 + 0x3e0 ], %g1 2009dec: 82 00 7f ff add %g1, -1, %g1 2009df0: c2 26 23 e0 st %g1, [ %i0 + 0x3e0 ] 2009df4: 81 c7 e0 08 ret 2009df8: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2009dfc: 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 ) { 2009e00: 80 a0 a0 04 cmp %g2, 4 2009e04: 18 bf ff fc bgu 2009df4 <_Thread_queue_Timeout+0x68> 2009e08: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2009e0c: 80 a0 60 01 cmp %g1, 1 2009e10: 12 bf ff f9 bne 2009df4 <_Thread_queue_Timeout+0x68> 2009e14: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2009e18: 05 00 80 61 sethi %hi(0x2018400), %g2 2009e1c: 84 10 a3 40 or %g2, 0x340, %g2 ! 2018740 <_Objects_Information_table> 2009e20: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2009e24: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2009e28: 80 a2 20 00 cmp %o0, 0 2009e2c: 02 bf ff f2 be 2009df4 <_Thread_queue_Timeout+0x68> 2009e30: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2009e34: 7f ff f7 b9 call 2007d18 <_Objects_Get> 2009e38: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2009e3c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009e40: 80 a0 60 00 cmp %g1, 0 2009e44: 12 bf ff ec bne 2009df4 <_Thread_queue_Timeout+0x68> 2009e48: 92 10 00 08 mov %o0, %o1 2009e4c: 10 bf ff db b 2009db8 <_Thread_queue_Timeout+0x2c> 2009e50: 31 00 80 61 sethi %hi(0x2018400), %i0 * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 2009e54: 02 bf ff e5 be 2009de8 <_Thread_queue_Timeout+0x5c> <== NOT EXECUTED 2009e58: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 2009e5c: 10 bf ff e3 b 2009de8 <_Thread_queue_Timeout+0x5c> <== NOT EXECUTED 2009e60: c2 22 20 30 st %g1, [ %o0 + 0x30 ] <== NOT EXECUTED 02013418 <_Timer_Server_body>: */ Thread _Timer_Server_body( uint32_t ignored ) { 2013418: 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; 201341c: 03 00 80 c8 sethi %hi(0x2032000), %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2013420: 21 00 80 c8 sethi %hi(0x2032000), %l0 2013424: c6 00 63 44 ld [ %g1 + 0x344 ], %g3 _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2013428: 05 00 80 c8 sethi %hi(0x2032000), %g2 201342c: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 2013430: c8 00 a2 7c ld [ %g2 + 0x27c ], %g4 /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 2013434: 05 00 80 c8 sethi %hi(0x2032000), %g2 2013438: 82 00 60 01 inc %g1 201343c: c6 20 a0 cc st %g3, [ %g2 + 0xcc ] 2013440: c2 24 21 c0 st %g1, [ %l0 + 0x1c0 ] _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2013444: 05 00 80 c8 sethi %hi(0x2032000), %g2 2013448: c8 20 a0 c8 st %g4, [ %g2 + 0xc8 ] ! 20320c8 <_Timer_Server_seconds_last_time> RTEMS_COMPILER_MEMORY_BARRIER(); 201344c: 03 00 80 c8 sethi %hi(0x2032000), %g1 2013450: 05 00 80 c8 sethi %hi(0x2032000), %g2 2013454: ba 10 60 c0 or %g1, 0xc0, %i5 2013458: 03 00 80 c8 sethi %hi(0x2032000), %g1 201345c: 39 00 80 c9 sethi %hi(0x2032400), %i4 /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 2013460: b4 10 a2 c0 or %g2, 0x2c0, %i2 2013464: ae 10 60 d4 or %g1, 0xd4, %l7 2013468: 05 00 80 c8 sethi %hi(0x2032000), %g2 201346c: 03 00 80 c8 sethi %hi(0x2032000), %g1 2013470: a6 10 a0 dc or %g2, 0xdc, %l3 2013474: b6 10 62 b4 or %g1, 0x2b4, %i3 2013478: 2d 00 80 c8 sethi %hi(0x2032000), %l6 201347c: 2b 00 80 c8 sethi %hi(0x2032000), %l5 2013480: a4 10 00 1c mov %i4, %l2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2013484: a2 10 00 10 mov %l0, %l1 2013488: 10 80 00 18 b 20134e8 <_Timer_Server_body+0xd0> 201348c: a8 10 00 13 mov %l3, %l4 _Timer_Server_reset_ticks_timer(); _Timer_Server_reset_seconds_timer(); 2013490: 80 a0 40 17 cmp %g1, %l7 2013494: 32 80 00 27 bne,a 2013530 <_Timer_Server_body+0x118> 2013498: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED 201349c: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 20134a0: 82 00 7f ff add %g1, -1, %g1 20134a4: c2 24 21 c0 st %g1, [ %l0 + 0x1c0 ] 20134a8: c4 04 21 c0 ld [ %l0 + 0x1c0 ], %g2 20134ac: 80 a0 a0 00 cmp %g2, 0 20134b0: 02 80 00 2b be 201355c <_Timer_Server_body+0x144> 20134b4: 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(); 20134b8: d0 04 a1 78 ld [ %l2 + 0x178 ], %o0 <== NOT EXECUTED 20134bc: 40 00 14 5b call 2018628 <_Watchdog_Remove> 20134c0: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_stop_seconds_timer(); 20134c4: 40 00 14 59 call 2018628 <_Watchdog_Remove> 20134c8: 90 10 00 14 mov %l4, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20134cc: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 20134d0: 82 00 60 01 inc %g1 20134d4: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] * 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(); 20134d8: 7f ff ff bf call 20133d4 <_Timer_Server_process_ticks_chain> 20134dc: 01 00 00 00 nop _Timer_Server_process_seconds_chain(); 20134e0: 7f ff ff a2 call 2013368 <_Timer_Server_process_seconds_chain> 20134e4: 01 00 00 00 nop /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 20134e8: d0 07 21 78 ld [ %i4 + 0x178 ], %o0 20134ec: 40 00 10 f5 call 20178c0 <_Thread_Set_state> 20134f0: 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)); 20134f4: c2 05 a0 bc ld [ %l6 + 0xbc ], %g1 _Timer_Server_reset_ticks_timer(); 20134f8: 80 a0 40 1d cmp %g1, %i5 20134fc: 22 bf ff e5 be,a 2013490 <_Timer_Server_body+0x78> 2013500: c2 05 60 d0 ld [ %l5 + 0xd0 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2013504: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 2013508: d2 04 a1 78 ld [ %l2 + 0x178 ], %o1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 201350c: 90 10 00 1a mov %i2, %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2013510: c2 22 60 54 st %g1, [ %o1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2013514: 40 00 13 db call 2018480 <_Watchdog_Insert> 2013518: 92 02 60 48 add %o1, 0x48, %o1 201351c: c2 05 60 d0 ld [ %l5 + 0xd0 ], %g1 _Timer_Server_reset_seconds_timer(); 2013520: 80 a0 40 17 cmp %g1, %l7 2013524: 02 bf ff de be 201349c <_Timer_Server_body+0x84> 2013528: 01 00 00 00 nop Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 201352c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2013530: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2013534: c2 24 e0 0c st %g1, [ %l3 + 0xc ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2013538: 40 00 13 d2 call 2018480 <_Watchdog_Insert> <== NOT EXECUTED 201353c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2013540: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 <== NOT EXECUTED 2013544: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2013548: c2 24 21 c0 st %g1, [ %l0 + 0x1c0 ] <== NOT EXECUTED 201354c: c4 04 21 c0 ld [ %l0 + 0x1c0 ], %g2 <== NOT EXECUTED 2013550: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2013554: 32 bf ff da bne,a 20134bc <_Timer_Server_body+0xa4> <== NOT EXECUTED 2013558: d0 04 a1 78 ld [ %l2 + 0x178 ], %o0 <== NOT EXECUTED _Thread_Dispatch(); 201355c: 40 00 0d 35 call 2016a30 <_Thread_Dispatch> 2013560: 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(); 2013564: 10 bf ff d6 b 20134bc <_Timer_Server_body+0xa4> 2013568: d0 04 a1 78 ld [ %l2 + 0x178 ], %o0 020133d4 <_Timer_Server_process_ticks_chain>: void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 20133d4: 03 00 80 c8 sethi %hi(0x2032000), %g1 if ( snapshot >= _Timer_Server_ticks_last_time ) 20133d8: 07 00 80 c8 sethi %hi(0x2032000), %g3 void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 20133dc: c4 00 63 44 ld [ %g1 + 0x344 ], %g2 if ( snapshot >= _Timer_Server_ticks_last_time ) 20133e0: c2 00 e0 cc ld [ %g3 + 0xcc ], %g1 20133e4: 80 a0 80 01 cmp %g2, %g1 20133e8: 1a 80 00 04 bcc 20133f8 <_Timer_Server_process_ticks_chain+0x24> 20133ec: 94 20 80 01 sub %g2, %g1, %o2 ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 20133f0: 82 38 00 01 xnor %g0, %g1, %g1 <== NOT EXECUTED 20133f4: 94 00 40 02 add %g1, %g2, %o2 <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 20133f8: 11 00 80 c8 sethi %hi(0x2032000), %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; 20133fc: c4 20 e0 cc st %g2, [ %g3 + 0xcc ] _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 2013400: 90 12 20 bc or %o0, 0xbc, %o0 2013404: 92 10 20 00 clr %o1 2013408: 82 13 c0 00 mov %o7, %g1 201340c: 40 00 13 ec call 20183bc <_Watchdog_Adjust> 2013410: 9e 10 40 00 mov %g1, %o7 2013414: 01 00 00 00 nop 0200c238 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 200c238: 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; 200c23c: 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; 200c240: de 06 20 04 ld [ %i0 + 4 ], %o7 right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 200c244: 96 10 00 01 mov %g1, %o3 200c248: 95 38 60 1f sra %g1, 0x1f, %o2 200c24c: 83 30 60 1d srl %g1, 0x1d, %g1 200c250: 9b 2a e0 03 sll %o3, 3, %o5 200c254: 99 2a a0 03 sll %o2, 3, %o4 200c258: 98 10 40 0c or %g1, %o4, %o4 200c25c: 83 33 60 1b srl %o5, 0x1b, %g1 200c260: 85 2b 20 05 sll %o4, 5, %g2 200c264: 87 2b 60 05 sll %o5, 5, %g3 200c268: 84 10 40 02 or %g1, %g2, %g2 200c26c: 86 a0 c0 0d subcc %g3, %o5, %g3 200c270: 83 30 e0 1a srl %g3, 0x1a, %g1 200c274: 84 60 80 0c subx %g2, %o4, %g2 200c278: 9b 28 e0 06 sll %g3, 6, %o5 200c27c: 99 28 a0 06 sll %g2, 6, %o4 200c280: 9a a3 40 03 subcc %o5, %g3, %o5 200c284: 98 10 40 0c or %g1, %o4, %o4 200c288: 98 63 00 02 subx %o4, %g2, %o4 200c28c: 9a 83 40 0b addcc %o5, %o3, %o5 200c290: 83 33 60 1e srl %o5, 0x1e, %g1 200c294: 98 43 00 0a addx %o4, %o2, %o4 200c298: 87 2b 60 02 sll %o5, 2, %g3 200c29c: 85 2b 20 02 sll %o4, 2, %g2 200c2a0: 9a 83 40 03 addcc %o5, %g3, %o5 200c2a4: 84 10 40 02 or %g1, %g2, %g2 200c2a8: 83 33 60 1e srl %o5, 0x1e, %g1 200c2ac: 98 43 00 02 addx %o4, %g2, %o4 200c2b0: 87 2b 60 02 sll %o5, 2, %g3 200c2b4: 85 2b 20 02 sll %o4, 2, %g2 200c2b8: 9a 83 40 03 addcc %o5, %g3, %o5 200c2bc: 84 10 40 02 or %g1, %g2, %g2 200c2c0: 83 33 60 1e srl %o5, 0x1e, %g1 200c2c4: 98 43 00 02 addx %o4, %g2, %o4 200c2c8: 85 2b 20 02 sll %o4, 2, %g2 200c2cc: 84 10 40 02 or %g1, %g2, %g2 right += rhs->tv_nsec; 200c2d0: 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; 200c2d4: 87 2b 60 02 sll %o5, 2, %g3 200c2d8: 9a 83 40 03 addcc %o5, %g3, %o5 right += rhs->tv_nsec; 200c2dc: 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; 200c2e0: 98 43 00 02 addx %o4, %g2, %o4 200c2e4: 89 33 60 17 srl %o5, 0x17, %g4 200c2e8: 85 2b 20 09 sll %o4, 9, %g2 200c2ec: 87 2b 60 09 sll %o5, 9, %g3 200c2f0: 84 11 00 02 or %g4, %g2, %g2 right += rhs->tv_nsec; 200c2f4: 96 80 c0 01 addcc %g3, %g1, %o3 200c2f8: 94 40 80 0a addx %g2, %o2, %o2 if ( right == 0 ) { 200c2fc: 80 92 80 0b orcc %o2, %o3, %g0 200c300: 12 80 00 06 bne 200c318 <_Timespec_Divide+0xe0> 200c304: f0 06 00 00 ld [ %i0 ], %i0 *ival_percentage = 0; 200c308: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED *fval_percentage = 0; 200c30c: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 200c310: 81 c7 e0 08 ret <== NOT EXECUTED 200c314: 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; 200c318: 83 36 20 1d srl %i0, 0x1d, %g1 200c31c: 9b 2e 20 03 sll %i0, 3, %o5 200c320: 91 3e 20 1f sra %i0, 0x1f, %o0 200c324: 99 2a 20 03 sll %o0, 3, %o4 200c328: 98 10 40 0c or %g1, %o4, %o4 200c32c: 83 33 60 1b srl %o5, 0x1b, %g1 200c330: 85 2b 20 05 sll %o4, 5, %g2 200c334: 87 2b 60 05 sll %o5, 5, %g3 200c338: 84 10 40 02 or %g1, %g2, %g2 200c33c: 86 a0 c0 0d subcc %g3, %o5, %g3 200c340: 83 30 e0 1a srl %g3, 0x1a, %g1 200c344: 84 60 80 0c subx %g2, %o4, %g2 200c348: 9b 28 e0 06 sll %g3, 6, %o5 200c34c: 99 28 a0 06 sll %g2, 6, %o4 200c350: 9a a3 40 03 subcc %o5, %g3, %o5 200c354: 98 10 40 0c or %g1, %o4, %o4 200c358: 98 63 00 02 subx %o4, %g2, %o4 200c35c: 9a 83 40 18 addcc %o5, %i0, %o5 200c360: 83 33 60 1e srl %o5, 0x1e, %g1 200c364: 98 43 00 08 addx %o4, %o0, %o4 200c368: 87 2b 60 02 sll %o5, 2, %g3 200c36c: 85 2b 20 02 sll %o4, 2, %g2 200c370: 9a 83 40 03 addcc %o5, %g3, %o5 200c374: 84 10 40 02 or %g1, %g2, %g2 200c378: 83 33 60 1e srl %o5, 0x1e, %g1 200c37c: 98 43 00 02 addx %o4, %g2, %o4 200c380: 87 2b 60 02 sll %o5, 2, %g3 200c384: 85 2b 20 02 sll %o4, 2, %g2 200c388: 9a 83 40 03 addcc %o5, %g3, %o5 200c38c: 84 10 40 02 or %g1, %g2, %g2 200c390: 83 33 60 1e srl %o5, 0x1e, %g1 200c394: 98 43 00 02 addx %o4, %g2, %o4 200c398: 87 2b 60 02 sll %o5, 2, %g3 200c39c: 85 2b 20 02 sll %o4, 2, %g2 200c3a0: 9a 83 40 03 addcc %o5, %g3, %o5 200c3a4: 84 10 40 02 or %g1, %g2, %g2 200c3a8: 83 33 60 17 srl %o5, 0x17, %g1 200c3ac: 98 43 00 02 addx %o4, %g2, %o4 200c3b0: 93 2b 60 09 sll %o5, 9, %o1 200c3b4: 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; 200c3b8: 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; 200c3bc: 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; 200c3c0: 83 32 60 1e srl %o1, 0x1e, %g1 200c3c4: a1 3b e0 1f sra %o7, 0x1f, %l0 200c3c8: 87 2a 60 02 sll %o1, 2, %g3 200c3cc: 90 42 00 10 addx %o0, %l0, %o0 200c3d0: 85 2a 20 02 sll %o0, 2, %g2 200c3d4: 84 10 40 02 or %g1, %g2, %g2 200c3d8: 83 30 e0 1b srl %g3, 0x1b, %g1 200c3dc: 99 28 a0 05 sll %g2, 5, %o4 200c3e0: 9b 28 e0 05 sll %g3, 5, %o5 200c3e4: 98 10 40 0c or %g1, %o4, %o4 200c3e8: 9a a3 40 03 subcc %o5, %g3, %o5 200c3ec: 98 63 00 02 subx %o4, %g2, %o4 200c3f0: 9a 83 40 09 addcc %o5, %o1, %o5 200c3f4: 83 33 60 1e srl %o5, 0x1e, %g1 200c3f8: 98 43 00 08 addx %o4, %o0, %o4 200c3fc: 87 2b 60 02 sll %o5, 2, %g3 200c400: 85 2b 20 02 sll %o4, 2, %g2 200c404: 9a 83 40 03 addcc %o5, %g3, %o5 200c408: 84 10 40 02 or %g1, %g2, %g2 200c40c: 83 33 60 1e srl %o5, 0x1e, %g1 200c410: 87 2b 60 02 sll %o5, 2, %g3 200c414: 98 43 00 02 addx %o4, %g2, %o4 200c418: 9a 83 40 03 addcc %o5, %g3, %o5 200c41c: 85 2b 20 02 sll %o4, 2, %g2 200c420: 84 10 40 02 or %g1, %g2, %g2 200c424: 83 33 60 1b srl %o5, 0x1b, %g1 200c428: 98 43 00 02 addx %o4, %g2, %o4 200c42c: 93 2b 60 05 sll %o5, 5, %o1 200c430: 91 2b 20 05 sll %o4, 5, %o0 200c434: 40 00 33 2f call 20190f0 <__udivdi3> 200c438: 90 10 40 08 or %g1, %o0, %o0 *ival_percentage = answer / 1000; 200c43c: 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; 200c440: a0 10 00 08 mov %o0, %l0 200c444: a2 10 00 09 mov %o1, %l1 *ival_percentage = answer / 1000; 200c448: 96 10 23 e8 mov 0x3e8, %o3 200c44c: 40 00 33 29 call 20190f0 <__udivdi3> 200c450: 90 10 00 10 mov %l0, %o0 *fval_percentage = answer % 1000; 200c454: 90 10 00 10 mov %l0, %o0 * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 200c458: d2 26 80 00 st %o1, [ %i2 ] *fval_percentage = answer % 1000; 200c45c: 94 10 20 00 clr %o2 200c460: 92 10 00 11 mov %l1, %o1 200c464: 40 00 34 02 call 201946c <__umoddi3> 200c468: 96 10 23 e8 mov 0x3e8, %o3 200c46c: d2 26 c0 00 st %o1, [ %i3 ] 200c470: 81 c7 e0 08 ret 200c474: 81 e8 00 00 restore 0201708c <_Timespec_From_ticks>: void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 201708c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 2017090: 03 00 80 a8 sethi %hi(0x202a000), %g1 <== NOT EXECUTED 2017094: d2 00 61 1c ld [ %g1 + 0x11c ], %o1 ! 202a11c <_TOD_Microseconds_per_tick> <== NOT EXECUTED 2017098: 40 00 2f 4d call 2022dcc <.umul> <== NOT EXECUTED 201709c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 20170a0: 21 00 03 d0 sethi %hi(0xf4000), %l0 <== NOT EXECUTED struct timespec *time ) { uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 20170a4: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 20170a8: 7f ff a9 d3 call 20017f4 <.udiv> <== NOT EXECUTED 20170ac: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 20170b0: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED { uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 20170b4: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 20170b8: 40 00 2f 7f call 2022eb4 <.urem> <== NOT EXECUTED 20170bc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20170c0: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED 20170c4: 83 2a 20 07 sll %o0, 7, %g1 <== NOT EXECUTED 20170c8: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 20170cc: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 20170d0: 83 28 60 03 sll %g1, 3, %g1 <== NOT EXECUTED 20170d4: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 20170d8: 81 c7 e0 08 ret <== NOT EXECUTED 20170dc: 81 e8 00 00 restore <== NOT EXECUTED 020170e0 <_Timespec_Is_valid>: boolean _Timespec_Is_valid( const struct timespec *time ) { if ( !time ) 20170e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20170e4: 02 80 00 0e be 201711c <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 20170e8: 01 00 00 00 nop <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) 20170ec: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 20170f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20170f4: 06 80 00 0a bl 201711c <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 20170f8: 01 00 00 00 nop <== NOT EXECUTED return FALSE; if ( time->tv_nsec < 0 ) 20170fc: d0 02 20 04 ld [ %o0 + 4 ], %o0 <== NOT EXECUTED 2017100: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017104: 06 80 00 06 bl 201711c <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 2017108: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 <== NOT EXECUTED 201710c: 82 10 61 ff or %g1, 0x1ff, %g1 ! 3b9ac9ff <== NOT EXECUTED 2017110: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED 2017114: 81 c3 e0 08 retl <== NOT EXECUTED 2017118: 90 60 3f ff subx %g0, -1, %o0 <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 201711c: 81 c3 e0 08 retl <== NOT EXECUTED 2017120: 90 10 20 00 clr %o0 <== NOT EXECUTED 02017124 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 2017124: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 2017128: e0 06 00 00 ld [ %i0 ], %l0 <== NOT EXECUTED 201712c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2017130: 02 80 00 15 be 2017184 <_Timespec_To_ticks+0x60> <== NOT EXECUTED 2017134: e4 06 20 04 ld [ %i0 + 4 ], %l2 <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 2017138: 03 00 80 a8 sethi %hi(0x202a000), %g1 <== NOT EXECUTED 201713c: e2 00 61 1c ld [ %g1 + 0x11c ], %l1 ! 202a11c <_TOD_Microseconds_per_tick> <== NOT EXECUTED 2017140: 11 00 03 d0 sethi %hi(0xf4000), %o0 <== NOT EXECUTED 2017144: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2017148: 7f ff a9 ab call 20017f4 <.udiv> <== NOT EXECUTED 201714c: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED 2017150: 40 00 2f 1f call 2022dcc <.umul> <== NOT EXECUTED 2017154: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 2017158: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 201715c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 2017160: 7f ff a9 a5 call 20017f4 <.udiv> <== NOT EXECUTED 2017164: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2017168: 7f ff a9 a3 call 20017f4 <.udiv> <== NOT EXECUTED 201716c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED _TOD_Microseconds_per_tick; if (ticks) 2017170: b0 82 00 10 addcc %o0, %l0, %i0 <== NOT EXECUTED 2017174: 02 80 00 08 be 2017194 <_Timespec_To_ticks+0x70> <== NOT EXECUTED 2017178: 01 00 00 00 nop <== NOT EXECUTED return ticks; return 1; } 201717c: 81 c7 e0 08 ret <== NOT EXECUTED 2017180: 81 e8 00 00 restore <== NOT EXECUTED const struct timespec *time ) { uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 2017184: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 2017188: 12 bf ff ec bne 2017138 <_Timespec_To_ticks+0x14> <== NOT EXECUTED 201718c: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017190: 30 bf ff fb b,a 201717c <_Timespec_To_ticks+0x58> <== NOT EXECUTED if (ticks) return ticks; return 1; } 2017194: 81 c7 e0 08 ret <== NOT EXECUTED 2017198: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED 0200d7b0 <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 200d7b0: 9d e3 bf 98 save %sp, -104, %sp _Chain_Append( &_User_extensions_List, &the_extension->Node ); 200d7b4: 11 00 80 62 sethi %hi(0x2018800), %o0 200d7b8: 92 10 00 18 mov %i0, %o1 200d7bc: 7f ff e5 56 call 2006d14 <_Chain_Append> 200d7c0: 90 12 22 64 or %o0, 0x264, %o0 /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 200d7c4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 200d7c8: 80 a0 60 00 cmp %g1, 0 200d7cc: 02 80 00 06 be 200d7e4 <_User_extensions_Add_API_set+0x34> 200d7d0: b2 06 20 08 add %i0, 8, %i1 the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 200d7d4: c2 26 20 10 st %g1, [ %i0 + 0x10 ] _Chain_Append( 200d7d8: 31 00 80 61 sethi %hi(0x2018400), %i0 200d7dc: 7f ff e5 4e call 2006d14 <_Chain_Append> 200d7e0: 91 ee 23 e4 restore %i0, 0x3e4, %o0 200d7e4: 81 c7 e0 08 ret <== NOT EXECUTED 200d7e8: 81 e8 00 00 restore <== NOT EXECUTED 0200a554 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, boolean is_internal, uint32_t the_error ) { 200a554: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 200a558: 03 00 80 62 sethi %hi(0x2018800), %g1 200a55c: 82 10 62 64 or %g1, 0x264, %g1 ! 2018a64 <_User_extensions_List> 200a560: e0 00 60 08 ld [ %g1 + 8 ], %l0 !_Chain_Is_head( &_User_extensions_List, the_node ) ; 200a564: 80 a4 00 01 cmp %l0, %g1 200a568: 02 80 00 0d be 200a59c <_User_extensions_Fatal+0x48> 200a56c: a2 10 00 01 mov %g1, %l1 the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 200a570: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 200a574: 80 a0 60 00 cmp %g1, 0 200a578: 02 80 00 05 be 200a58c <_User_extensions_Fatal+0x38> 200a57c: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 200a580: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200a584: 9f c0 40 00 call %g1 <== NOT EXECUTED 200a588: 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 ) { 200a58c: 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 ) ; 200a590: 80 a4 00 11 cmp %l0, %l1 200a594: 32 bf ff f8 bne,a 200a574 <_User_extensions_Fatal+0x20> 200a598: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 <== NOT EXECUTED 200a59c: 81 c7 e0 08 ret 200a5a0: 81 e8 00 00 restore 02011800 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 2011800: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 2011804: 40 00 12 f6 call 20163dc <_Chain_Extract> <== NOT EXECUTED 2011808: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 201180c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED 2011810: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2011814: 02 80 00 04 be 2011824 <_User_extensions_Remove_set+0x24> <== NOT EXECUTED 2011818: 01 00 00 00 nop <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 201181c: 40 00 12 f0 call 20163dc <_Chain_Extract> <== NOT EXECUTED 2011820: 91 ee 20 08 restore %i0, 8, %o0 <== NOT EXECUTED 2011824: 81 c7 e0 08 ret <== NOT EXECUTED 2011828: 81 e8 00 00 restore <== NOT EXECUTED 0200a5a4 <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 200a5a4: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 200a5a8: 03 00 80 62 sethi %hi(0x2018800), %g1 200a5ac: 82 10 62 64 or %g1, 0x264, %g1 ! 2018a64 <_User_extensions_List> 200a5b0: e0 00 60 08 ld [ %g1 + 8 ], %l0 !_Chain_Is_head( &_User_extensions_List, the_node ) ; 200a5b4: 80 a4 00 01 cmp %l0, %g1 200a5b8: 02 80 00 0c be 200a5e8 <_User_extensions_Thread_exitted+0x44> 200a5bc: a2 10 00 01 mov %g1, %l1 the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 200a5c0: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 200a5c4: 80 a0 60 00 cmp %g1, 0 200a5c8: 02 80 00 04 be 200a5d8 <_User_extensions_Thread_exitted+0x34> 200a5cc: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.thread_exitted)( executing ); 200a5d0: 9f c0 40 00 call %g1 200a5d4: 01 00 00 00 nop Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 200a5d8: 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 ) ; 200a5dc: 80 a4 00 11 cmp %l0, %l1 200a5e0: 32 bf ff f9 bne,a 200a5c4 <_User_extensions_Thread_exitted+0x20> 200a5e4: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 <== NOT EXECUTED 200a5e8: 81 c7 e0 08 ret 200a5ec: 81 e8 00 00 restore 0200a73c <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 200a73c: 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; 200a740: 03 00 80 62 sethi %hi(0x2018800), %g1 void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 200a744: ac 10 00 18 mov %i0, %l6 Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 200a748: e6 00 60 a8 ld [ %g1 + 0xa8 ], %l3 _ISR_Disable( level ); 200a74c: 7f ff dd a5 call 2001de0 200a750: 01 00 00 00 nop 200a754: 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 ) { 200a758: c2 06 60 08 ld [ %i1 + 8 ], %g1 200a75c: 80 a0 60 00 cmp %g1, 0 200a760: 12 80 00 49 bne 200a884 <_Watchdog_Insert+0x148> 200a764: 01 00 00 00 nop _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 200a768: 2b 00 80 62 sethi %hi(0x2018800), %l5 200a76c: c2 05 61 60 ld [ %l5 + 0x160 ], %g1 ! 2018960 <_Watchdog_Sync_count> if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 200a770: 84 10 20 01 mov 1, %g2 _Watchdog_Sync_count++; 200a774: 82 00 60 01 inc %g1 200a778: 29 00 80 62 sethi %hi(0x2018800), %l4 if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 200a77c: c4 26 60 08 st %g2, [ %i1 + 8 ] _Watchdog_Sync_count++; 200a780: c2 25 61 60 st %g1, [ %l5 + 0x160 ] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 200a784: ae 10 00 14 mov %l4, %l7 the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 200a788: 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 ; 200a78c: e2 05 80 00 ld [ %l6 ], %l1 ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 200a790: 80 a4 a0 00 cmp %l2, 0 200a794: 02 80 00 2b be 200a840 <_Watchdog_Insert+0x104> 200a798: 03 00 80 62 sethi %hi(0x2018800), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 200a79c: c2 04 40 00 ld [ %l1 ], %g1 200a7a0: 80 a0 60 00 cmp %g1, 0 200a7a4: 02 80 00 27 be 200a840 <_Watchdog_Insert+0x104> 200a7a8: 03 00 80 62 sethi %hi(0x2018800), %g1 break; if ( delta_interval < after->delta_interval ) { 200a7ac: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 200a7b0: 80 a4 80 10 cmp %l2, %l0 200a7b4: 1a 80 00 13 bcc 200a800 <_Watchdog_Insert+0xc4> 200a7b8: 01 00 00 00 nop after->delta_interval -= delta_interval; 200a7bc: 10 80 00 1f b 200a838 <_Watchdog_Insert+0xfc> 200a7c0: a0 24 00 12 sub %l0, %l2, %l0 if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 200a7c4: c2 05 20 bc ld [ %l4 + 0xbc ], %g1 200a7c8: 80 a4 c0 01 cmp %l3, %g1 200a7cc: 0a 80 00 30 bcs 200a88c <_Watchdog_Insert+0x150> 200a7d0: 01 00 00 00 nop */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 200a7d4: a4 a4 80 10 subcc %l2, %l0, %l2 200a7d8: 02 80 00 19 be 200a83c <_Watchdog_Insert+0x100> 200a7dc: e2 04 40 00 ld [ %l1 ], %l1 200a7e0: c2 04 40 00 ld [ %l1 ], %g1 200a7e4: 80 a0 60 00 cmp %g1, 0 200a7e8: 02 80 00 16 be 200a840 <_Watchdog_Insert+0x104> 200a7ec: 03 00 80 62 sethi %hi(0x2018800), %g1 break; if ( delta_interval < after->delta_interval ) { 200a7f0: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 200a7f4: 80 a4 00 12 cmp %l0, %l2 200a7f8: 38 80 00 10 bgu,a 200a838 <_Watchdog_Insert+0xfc> 200a7fc: a0 24 00 12 sub %l0, %l2, %l0 * used around this flash point allowed interrupts to execute * which violated the design assumptions. The critical section * mechanism used here WAS redesigned to address this. */ _ISR_Flash( level ); 200a800: 7f ff dd 7c call 2001df0 200a804: 90 10 00 18 mov %i0, %o0 200a808: 7f ff dd 76 call 2001de0 200a80c: 01 00 00 00 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 200a810: c2 06 60 08 ld [ %i1 + 8 ], %g1 200a814: 80 a0 60 01 cmp %g1, 1 200a818: 02 bf ff eb be 200a7c4 <_Watchdog_Insert+0x88> 200a81c: 01 00 00 00 nop _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 200a820: e6 25 20 bc st %l3, [ %l4 + 0xbc ] <== NOT EXECUTED _Watchdog_Sync_count--; 200a824: c2 05 61 60 ld [ %l5 + 0x160 ], %g1 <== NOT EXECUTED 200a828: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200a82c: c2 25 61 60 st %g1, [ %l5 + 0x160 ] <== NOT EXECUTED _ISR_Enable( level ); 200a830: 7f ff dd 70 call 2001df0 <== NOT EXECUTED 200a834: 81 e8 00 00 restore <== NOT EXECUTED if ( delta_interval == 0 || !_Watchdog_Next( after ) ) break; if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; 200a838: e0 24 60 10 st %l0, [ %l1 + 0x10 ] the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; 200a83c: 03 00 80 62 sethi %hi(0x2018800), %g1 200a840: c6 00 61 64 ld [ %g1 + 0x164 ], %g3 ! 2018964 <_Watchdog_Ticks_since_boot> _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 200a844: c4 04 60 04 ld [ %l1 + 4 ], %g2 the_watchdog->start_time = _Watchdog_Ticks_since_boot; 200a848: c6 26 60 14 st %g3, [ %i1 + 0x14 ] } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 200a84c: e4 26 60 10 st %l2, [ %i1 + 0x10 ] RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 200a850: 82 10 20 02 mov 2, %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 200a854: c8 00 80 00 ld [ %g2 ], %g4 _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 200a858: e6 25 20 bc st %l3, [ %l4 + 0xbc ] 200a85c: c2 26 60 08 st %g1, [ %i1 + 8 ] _Watchdog_Sync_count--; 200a860: c2 05 61 60 ld [ %l5 + 0x160 ], %g1 after_node->next = the_node; 200a864: f2 20 80 00 st %i1, [ %g2 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 200a868: c4 26 60 04 st %g2, [ %i1 + 4 ] 200a86c: 82 00 7f ff add %g1, -1, %g1 before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; before_node->previous = the_node; 200a870: f2 21 20 04 st %i1, [ %g4 + 4 ] Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 200a874: c8 26 40 00 st %g4, [ %i1 ] 200a878: c2 25 61 60 st %g1, [ %l5 + 0x160 ] _ISR_Enable( level ); 200a87c: 7f ff dd 5d call 2001df0 200a880: 81 e8 00 00 restore * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 200a884: 7f ff dd 5b call 2001df0 <== NOT EXECUTED 200a888: 81 e8 00 00 restore <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { _Watchdog_Sync_level = insert_isr_nest_level; 200a88c: e6 25 e0 bc st %l3, [ %l7 + 0xbc ] the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 200a890: 10 bf ff bf b 200a78c <_Watchdog_Insert+0x50> 200a894: e4 06 60 0c ld [ %i1 + 0xc ], %l2 0200a8e4 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 200a8e4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 200a8e8: 7f ff dd 3e call 2001de0 200a8ec: a0 10 00 18 mov %i0, %l0 previous_state = the_watchdog->state; 200a8f0: f0 06 20 08 ld [ %i0 + 8 ], %i0 switch ( previous_state ) { 200a8f4: 80 a6 20 01 cmp %i0, 1 200a8f8: 02 80 00 2a be 200a9a0 <_Watchdog_Remove+0xbc> 200a8fc: 03 00 80 62 sethi %hi(0x2018800), %g1 200a900: 1a 80 00 09 bcc 200a924 <_Watchdog_Remove+0x40> 200a904: 80 a6 20 03 cmp %i0, 3 _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200a908: 03 00 80 62 sethi %hi(0x2018800), %g1 200a90c: c4 00 61 64 ld [ %g1 + 0x164 ], %g2 ! 2018964 <_Watchdog_Ticks_since_boot> 200a910: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 200a914: 7f ff dd 37 call 2001df0 200a918: 01 00 00 00 nop return( previous_state ); } 200a91c: 81 c7 e0 08 ret 200a920: 81 e8 00 00 restore Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 200a924: 18 bf ff fa bgu 200a90c <_Watchdog_Remove+0x28> 200a928: 03 00 80 62 sethi %hi(0x2018800), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 200a92c: c8 04 00 00 ld [ %l0 ], %g4 break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 200a930: c0 24 20 08 clr [ %l0 + 8 ] next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 200a934: c2 01 00 00 ld [ %g4 ], %g1 200a938: 80 a0 60 00 cmp %g1, 0 200a93c: 02 80 00 07 be 200a958 <_Watchdog_Remove+0x74> 200a940: 03 00 80 62 sethi %hi(0x2018800), %g1 next_watchdog->delta_interval += the_watchdog->delta_interval; 200a944: c2 01 20 10 ld [ %g4 + 0x10 ], %g1 200a948: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 200a94c: 82 00 40 02 add %g1, %g2, %g1 200a950: c2 21 20 10 st %g1, [ %g4 + 0x10 ] if ( _Watchdog_Sync_count ) 200a954: 03 00 80 62 sethi %hi(0x2018800), %g1 200a958: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2018960 <_Watchdog_Sync_count> 200a95c: 80 a0 a0 00 cmp %g2, 0 200a960: 22 80 00 07 be,a 200a97c <_Watchdog_Remove+0x98> 200a964: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Watchdog_Sync_level = _ISR_Nest_level; 200a968: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200a96c: c6 00 60 a8 ld [ %g1 + 0xa8 ], %g3 ! 20188a8 <_ISR_Nest_level> <== NOT EXECUTED 200a970: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 200a974: c6 20 a0 bc st %g3, [ %g2 + 0xbc ] ! 20188bc <_Watchdog_Sync_level> <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 200a978: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 200a97c: c8 20 40 00 st %g4, [ %g1 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200a980: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200a984: 03 00 80 62 sethi %hi(0x2018800), %g1 200a988: c4 00 61 64 ld [ %g1 + 0x164 ], %g2 ! 2018964 <_Watchdog_Ticks_since_boot> 200a98c: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 200a990: 7f ff dd 18 call 2001df0 200a994: 01 00 00 00 nop return( previous_state ); } 200a998: 81 c7 e0 08 ret 200a99c: 81 e8 00 00 restore _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200a9a0: c4 00 61 64 ld [ %g1 + 0x164 ], %g2 <== NOT EXECUTED /* * It is not actually on the chain so just change the state and * the Insert operation we interrupted will be aborted. */ the_watchdog->state = WATCHDOG_INACTIVE; 200a9a4: c0 24 20 08 clr [ %l0 + 8 ] <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200a9a8: c4 24 20 18 st %g2, [ %l0 + 0x18 ] <== NOT EXECUTED _ISR_Enable( level ); 200a9ac: 7f ff dd 11 call 2001df0 <== NOT EXECUTED 200a9b0: 01 00 00 00 nop <== NOT EXECUTED return( previous_state ); } 200a9b4: 81 c7 e0 08 ret <== NOT EXECUTED 200a9b8: 81 e8 00 00 restore <== NOT EXECUTED 0200aa68 <_Workspace_Allocate_or_fatal_error>: */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 200aa68: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 200aa6c: 11 00 80 62 sethi %hi(0x2018800), %o0 200aa70: 92 10 00 18 mov %i0, %o1 200aa74: 7f ff f1 f9 call 2007258 <_Heap_Allocate> 200aa78: 90 12 20 2c or %o0, 0x2c, %o0 void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 200aa7c: b0 92 20 00 orcc %o0, 0, %i0 200aa80: 12 80 00 04 bne 200aa90 <_Workspace_Allocate_or_fatal_error+0x28> 200aa84: 92 10 20 01 mov 1, %o1 _Internal_error_Occurred( 200aa88: 7f ff f3 26 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 200aa8c: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 200aa90: 81 c7 e0 08 ret 200aa94: 81 e8 00 00 restore 0200aa98 <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 200aa98: 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 ) ) 200aa9c: 80 a6 20 00 cmp %i0, 0 200aaa0: 02 80 00 1d be 200ab14 <_Workspace_Handler_initialization+0x7c> 200aaa4: 80 8e 20 07 btst 7, %i0 200aaa8: 12 80 00 1c bne 200ab18 <_Workspace_Handler_initialization+0x80> 200aaac: 90 10 20 00 clr %o0 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { 200aab0: 03 00 80 62 sethi %hi(0x2018800), %g1 200aab4: c4 00 60 04 ld [ %g1 + 4 ], %g2 ! 2018804 <_CPU_Table+0x10> 200aab8: 80 a0 a0 00 cmp %g2, 0 200aabc: 02 80 00 0c be 200aaec <_Workspace_Handler_initialization+0x54> 200aac0: 92 10 00 18 mov %i0, %o1 for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; 200aac4: 87 36 60 02 srl %i1, 2, %g3 <== NOT EXECUTED 200aac8: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 200aacc: 02 80 00 08 be 200aaec <_Workspace_Handler_initialization+0x54> <== NOT EXECUTED 200aad0: 84 10 20 00 clr %g2 <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; 200aad4: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; index++ ) 200aad8: 84 00 a0 01 inc %g2 <== NOT EXECUTED INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; 200aadc: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED 200aae0: 12 bf ff fd bne 200aad4 <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED 200aae4: c0 20 40 18 clr [ %g1 + %i0 ] <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 200aae8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200aaec: 94 10 00 19 mov %i1, %o2 200aaf0: 11 00 80 62 sethi %hi(0x2018800), %o0 200aaf4: 96 10 20 08 mov 8, %o3 200aaf8: 7f ff f2 bd call 20075ec <_Heap_Initialize> 200aafc: 90 12 20 2c or %o0, 0x2c, %o0 starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 200ab00: 80 a2 20 00 cmp %o0, 0 200ab04: 02 80 00 0a be 200ab2c <_Workspace_Handler_initialization+0x94> 200ab08: b0 10 20 00 clr %i0 200ab0c: 81 c7 e0 08 ret 200ab10: 81 e8 00 00 restore uint32_t *zero_out_array; uint32_t index; uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) _Internal_error_Occurred( 200ab14: 90 10 20 00 clr %o0 <== NOT EXECUTED 200ab18: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 200ab1c: 7f ff f3 01 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 200ab20: 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 ) { 200ab24: 10 bf ff e4 b 200aab4 <_Workspace_Handler_initialization+0x1c> <== NOT EXECUTED 200ab28: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 200ab2c: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED 200ab30: 7f ff f2 fc call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 200ab34: 95 e8 20 03 restore %g0, 3, %o2 <== NOT EXECUTED 200ab38: 01 00 00 00 nop 0200628c : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 200628c: 9d e3 bf 90 save %sp, -112, %sp Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 2006290: a4 96 20 00 orcc %i0, 0, %l2 2006294: 02 80 00 20 be 2006314 2006298: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 200629c: 80 a6 e0 00 cmp %i3, 0 20062a0: 02 80 00 1d be 2006314 20062a4: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 20062a8: 80 8e 60 10 btst 0x10, %i1 20062ac: 02 80 00 39 be 2006390 20062b0: 80 a6 a0 00 cmp %i2, 0 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 20062b4: 02 80 00 18 be 2006314 20062b8: 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; 20062bc: c0 27 bf f0 clr [ %fp + -16 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20062c0: 21 00 80 72 sethi %hi(0x201c800), %l0 20062c4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 201c850 <_Thread_Dispatch_disable_level> if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 20062c8: f4 27 bf f4 st %i2, [ %fp + -12 ] 20062cc: 82 00 60 01 inc %g1 20062d0: c2 24 20 50 st %g1, [ %l0 + 0x50 ] * 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 ); 20062d4: 23 00 80 71 sethi %hi(0x201c400), %l1 20062d8: 40 00 0a 44 call 2008be8 <_Objects_Allocate> 20062dc: 90 14 62 b0 or %l1, 0x2b0, %o0 ! 201c6b0 <_Barrier_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 20062e0: b4 92 20 00 orcc %o0, 0, %i2 20062e4: 12 80 00 0e bne 200631c 20062e8: 90 06 a0 14 add %i2, 0x14, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20062ec: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 20062f0: b0 10 20 05 mov 5, %i0 20062f4: 82 00 7f ff add %g1, -1, %g1 20062f8: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 20062fc: c4 04 20 50 ld [ %l0 + 0x50 ], %g2 2006300: 80 a0 a0 00 cmp %g2, 0 2006304: 12 80 00 21 bne 2006388 2006308: 01 00 00 00 nop _Thread_Dispatch(); 200630c: 40 00 10 bc call 200a5fc <_Thread_Dispatch> 2006310: 01 00 00 00 nop 2006314: 81 c7 e0 08 ret 2006318: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 200631c: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 2006320: 40 00 07 66 call 20080b8 <_CORE_barrier_Initialize> 2006324: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006328: 90 14 62 b0 or %l1, 0x2b0, %o0 Objects_Name name ) { uint32_t index; index = _Objects_Get_index( the_object->id ); 200632c: c6 06 a0 08 ld [ %i2 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006330: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2006334: 03 00 00 3f sethi %hi(0xfc00), %g1 2006338: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200633c: 82 08 c0 01 and %g3, %g1, %g1 2006340: 80 a0 40 02 cmp %g1, %g2 2006344: 38 80 00 06 bgu,a 200635c 2006348: e4 26 a0 0c st %l2, [ %i2 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200634c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006350: 83 28 60 02 sll %g1, 2, %g1 2006354: 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; 2006358: e4 26 a0 0c st %l2, [ %i2 + 0xc ] &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 200635c: c6 26 c0 00 st %g3, [ %i3 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006360: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 2006364: b0 10 20 00 clr %i0 2006368: 82 00 7f ff add %g1, -1, %g1 200636c: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 2006370: c4 04 20 50 ld [ %l0 + 0x50 ], %g2 2006374: 80 a0 a0 00 cmp %g2, 0 2006378: 12 80 00 04 bne 2006388 200637c: 01 00 00 00 nop _Thread_Dispatch(); 2006380: 40 00 10 9f call 200a5fc <_Thread_Dispatch> 2006384: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 2006388: 81 c7 e0 08 ret 200638c: 81 e8 00 00 restore if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 2006390: 82 10 20 01 mov 1, %g1 2006394: 10 bf ff cb b 20062c0 2006398: c2 27 bf f0 st %g1, [ %fp + -16 ] 0200639c : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 200639c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 20063a0: 21 00 80 71 sethi %hi(0x201c400), %l0 20063a4: 92 10 00 18 mov %i0, %o1 20063a8: 94 07 bf f4 add %fp, -12, %o2 20063ac: 40 00 0b 60 call 200912c <_Objects_Get> 20063b0: 90 14 22 b0 or %l0, 0x2b0, %o0 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 20063b4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20063b8: 80 a0 60 00 cmp %g1, 0 20063bc: 12 80 00 20 bne 200643c 20063c0: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Flush( 20063c4: 90 02 20 14 add %o0, 0x14, %o0 20063c8: 92 10 20 00 clr %o1 20063cc: 40 00 13 2b call 200b078 <_Thread_queue_Flush> 20063d0: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20063d4: 90 14 22 b0 or %l0, 0x2b0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 20063d8: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20063dc: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 20063e0: 05 00 00 3f sethi %hi(0xfc00), %g2 20063e4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 20063e8: 82 08 40 02 and %g1, %g2, %g1 20063ec: 80 a0 40 03 cmp %g1, %g3 20063f0: 38 80 00 06 bgu,a 2006408 20063f4: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 20063f8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 20063fc: 83 28 60 02 sll %g1, 2, %g1 2006400: 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; 2006404: c0 26 20 0c clr [ %i0 + 0xc ] */ RTEMS_INLINE_ROUTINE void _Barrier_Free ( Barrier_Control *the_barrier ) { _Objects_Free( &_Barrier_Information, &the_barrier->Object ); 2006408: 40 00 0b 06 call 2009020 <_Objects_Free> 200640c: 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 ) 2006410: 03 00 80 72 sethi %hi(0x201c800), %g1 2006414: c4 00 60 50 ld [ %g1 + 0x50 ], %g2 ! 201c850 <_Thread_Dispatch_disable_level> 2006418: b0 10 20 00 clr %i0 200641c: 84 00 bf ff add %g2, -1, %g2 2006420: c4 20 60 50 st %g2, [ %g1 + 0x50 ] 2006424: c6 00 60 50 ld [ %g1 + 0x50 ], %g3 2006428: 80 a0 e0 00 cmp %g3, 0 200642c: 02 80 00 09 be 2006450 2006430: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006434: 81 c7 e0 08 ret 2006438: 81 e8 00 00 restore { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 200643c: 80 a0 60 02 cmp %g1, 2 2006440: 08 bf ff fd bleu 2006434 2006444: b0 10 20 04 mov 4, %i0 2006448: 81 c7 e0 08 ret <== NOT EXECUTED 200644c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2006450: 40 00 10 6b call 200a5fc <_Thread_Dispatch> 2006454: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006458: 81 c7 e0 08 ret 200645c: 81 e8 00 00 restore 02006498 : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 2006498: 9d e3 bf 90 save %sp, -112, %sp 200649c: a0 10 00 18 mov %i0, %l0 Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 20064a0: 80 a6 60 00 cmp %i1, 0 20064a4: 02 80 00 1f be 2006520 20064a8: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 20064ac: 11 00 80 71 sethi %hi(0x201c400), %o0 20064b0: 92 10 00 10 mov %l0, %o1 20064b4: 90 12 22 b0 or %o0, 0x2b0, %o0 20064b8: 40 00 0b 1d call 200912c <_Objects_Get> 20064bc: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 20064c0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20064c4: 80 a0 60 00 cmp %g1, 0 20064c8: 02 80 00 07 be 20064e4 20064cc: 92 10 00 10 mov %l0, %o1 20064d0: 80 a0 60 02 cmp %g1, 2 20064d4: 08 80 00 13 bleu 2006520 20064d8: b0 10 20 04 mov 4, %i0 20064dc: 81 c7 e0 08 ret <== NOT EXECUTED 20064e0: 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 ); 20064e4: 94 10 20 00 clr %o2 20064e8: 40 00 07 00 call 20080e8 <_CORE_barrier_Release> 20064ec: 90 02 20 14 add %o0, 0x14, %o0 20064f0: 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 ) 20064f4: 03 00 80 72 sethi %hi(0x201c800), %g1 20064f8: c4 00 60 50 ld [ %g1 + 0x50 ], %g2 ! 201c850 <_Thread_Dispatch_disable_level> 20064fc: b0 10 20 00 clr %i0 2006500: 84 00 bf ff add %g2, -1, %g2 2006504: c4 20 60 50 st %g2, [ %g1 + 0x50 ] 2006508: c6 00 60 50 ld [ %g1 + 0x50 ], %g3 200650c: 80 a0 e0 00 cmp %g3, 0 2006510: 12 80 00 04 bne 2006520 2006514: 01 00 00 00 nop _Thread_Dispatch(); 2006518: 40 00 10 39 call 200a5fc <_Thread_Dispatch> 200651c: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006520: 81 c7 e0 08 ret 2006524: 81 e8 00 00 restore 02006528 : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 2006528: 9d e3 bf 90 save %sp, -112, %sp 200652c: 11 00 80 71 sethi %hi(0x201c400), %o0 2006530: 92 10 00 18 mov %i0, %o1 2006534: 90 12 22 b0 or %o0, 0x2b0, %o0 2006538: 40 00 0a fd call 200912c <_Objects_Get> 200653c: 94 07 bf f4 add %fp, -12, %o2 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2006540: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006544: 80 a0 60 00 cmp %g1, 0 2006548: 12 80 00 14 bne 2006598 200654c: 96 10 00 19 mov %i1, %o3 case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Wait( 2006550: 90 02 20 14 add %o0, 0x14, %o0 2006554: 92 10 00 18 mov %i0, %o1 2006558: 94 10 20 01 mov 1, %o2 200655c: 40 00 06 ee call 2008114 <_CORE_barrier_Wait> 2006560: 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 ) 2006564: 03 00 80 72 sethi %hi(0x201c800), %g1 2006568: c4 00 60 50 ld [ %g1 + 0x50 ], %g2 ! 201c850 <_Thread_Dispatch_disable_level> 200656c: 84 00 bf ff add %g2, -1, %g2 2006570: c4 20 60 50 st %g2, [ %g1 + 0x50 ] 2006574: c6 00 60 50 ld [ %g1 + 0x50 ], %g3 2006578: 80 a0 e0 00 cmp %g3, 0 200657c: 02 80 00 0d be 20065b0 2006580: 03 00 80 72 sethi %hi(0x201c800), %g1 TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 2006584: c4 00 61 30 ld [ %g1 + 0x130 ], %g2 ! 201c930 <_Thread_Executing> <== NOT EXECUTED 2006588: 40 00 1e 17 call 200dde4 <_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 200658c: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 <== NOT EXECUTED _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006590: 81 c7 e0 08 ret 2006594: 91 e8 00 08 restore %g0, %o0, %o0 { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2006598: 80 a0 60 02 cmp %g1, 2 200659c: 08 bf ff fd bleu 2006590 20065a0: 90 10 20 04 mov 4, %o0 20065a4: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20065a8: 81 c7 e0 08 ret <== NOT EXECUTED 20065ac: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 20065b0: 40 00 10 13 call 200a5fc <_Thread_Dispatch> 20065b4: 01 00 00 00 nop TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 20065b8: 03 00 80 72 sethi %hi(0x201c800), %g1 20065bc: c4 00 61 30 ld [ %g1 + 0x130 ], %g2 ! 201c930 <_Thread_Executing> 20065c0: 40 00 1e 09 call 200dde4 <_Barrier_Translate_core_barrier_return_code> 20065c4: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 20065c8: 30 bf ff f2 b,a 2006590 020052a0 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 20052a0: 9d e3 bf 60 save %sp, -160, %sp 20052a4: 82 10 00 18 mov %i0, %g1 if ( !time_buffer ) 20052a8: 80 a6 60 00 cmp %i1, 0 20052ac: 02 80 00 19 be 2005310 20052b0: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; switch ( option ) { 20052b4: 80 a0 60 04 cmp %g1, 4 20052b8: 18 80 00 16 bgu 2005310 20052bc: b0 10 20 19 mov 0x19, %i0 20052c0: 83 28 60 02 sll %g1, 2, %g1 20052c4: 05 00 80 14 sethi %hi(0x2005000), %g2 20052c8: 84 10 a2 8c or %g2, 0x28c, %g2 ! 200528c 20052cc: c6 00 80 01 ld [ %g2 + %g1 ], %g3 20052d0: 81 c0 c0 00 jmp %g3 20052d4: 01 00 00 00 nop } case RTEMS_CLOCK_GET_TIME_VALUE: { struct timeval *time = (struct timeval *)time_buffer; if ( !_TOD_Is_set ) 20052d8: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20052dc: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 ! 201881c <_TOD_Is_set> <== NOT EXECUTED 20052e0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20052e4: 12 80 00 46 bne 20053fc <== NOT EXECUTED 20052e8: 01 00 00 00 nop <== NOT EXECUTED } } return RTEMS_INTERNAL_ERROR; /* should never get here */ } 20052ec: 81 c7 e0 08 ret 20052f0: 91 e8 20 0b restore %g0, 0xb, %o0 } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick; 20052f4: 03 00 80 62 sethi %hi(0x2018800), %g1 20052f8: d2 00 61 bc ld [ %g1 + 0x1bc ], %o1 ! 20189bc <_TOD_Microseconds_per_tick> 20052fc: 11 00 03 d0 sethi %hi(0xf4000), %o0 2005300: b0 10 20 00 clr %i0 2005304: 40 00 3f df call 2015280 <.udiv> 2005308: 90 12 22 40 or %o0, 0x240, %o0 200530c: d0 26 40 00 st %o0, [ %i1 ] 2005310: 81 c7 e0 08 ret 2005314: 81 e8 00 00 restore } case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = _Watchdog_Ticks_since_boot; 2005318: 03 00 80 62 sethi %hi(0x2018800), %g1 200531c: c4 00 61 64 ld [ %g1 + 0x164 ], %g2 ! 2018964 <_Watchdog_Ticks_since_boot> 2005320: c4 26 40 00 st %g2, [ %i1 ] 2005324: 81 c7 e0 08 ret 2005328: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: { rtems_interval *interval = (rtems_interval *)time_buffer; if ( !_TOD_Is_set ) 200532c: 03 00 80 62 sethi %hi(0x2018800), %g1 2005330: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 ! 201881c <_TOD_Is_set> 2005334: 80 a0 a0 00 cmp %g2, 0 2005338: 02 bf ff ed be 20052ec 200533c: 03 00 80 62 sethi %hi(0x2018800), %g1 return RTEMS_NOT_DEFINED; *interval = _TOD_Seconds_since_epoch; 2005340: c4 00 60 9c ld [ %g1 + 0x9c ], %g2 ! 201889c <_TOD_Now> 2005344: c4 26 40 00 st %g2, [ %i1 ] 2005348: 81 c7 e0 08 ret 200534c: 91 e8 20 00 restore %g0, 0, %o0 case RTEMS_CLOCK_GET_TOD: { struct tm time; struct timeval now; rtems_time_of_day *tmbuf = (rtems_time_of_day *)time_buffer; if ( !_TOD_Is_set ) 2005350: 03 00 80 62 sethi %hi(0x2018800), %g1 2005354: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 ! 201881c <_TOD_Is_set> 2005358: 80 a0 a0 00 cmp %g2, 0 200535c: 02 bf ff e4 be 20052ec 2005360: 01 00 00 00 nop ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 2005364: 7f ff f2 9f call 2001de0 2005368: 01 00 00 00 nop 200536c: a0 10 00 08 mov %o0, %l0 _TOD_Get( &now ); 2005370: 40 00 07 70 call 2007130 <_TOD_Get> 2005374: 90 07 bf e8 add %fp, -24, %o0 _ISR_Enable(level); 2005378: 7f ff f2 9e call 2001df0 200537c: 90 10 00 10 mov %l0, %o0 time->tv_sec = now.tv_sec; 2005380: c2 07 bf e8 ld [ %fp + -24 ], %g1 time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 2005384: d0 07 bf ec ld [ %fp + -20 ], %o0 _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 2005388: c2 27 bf f0 st %g1, [ %fp + -16 ] time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 200538c: 40 00 3f bd call 2015280 <.udiv> 2005390: 92 10 23 e8 mov 0x3e8, %o1 /* Obtain the current time */ _TOD_Get_timeval( &now ); /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 2005394: 92 07 bf c4 add %fp, -60, %o1 2005398: d0 27 bf f4 st %o0, [ %fp + -12 ] 200539c: 40 00 25 ec call 200eb4c 20053a0: 90 07 bf f0 add %fp, -16, %o0 /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; 20053a4: c4 07 bf d0 ld [ %fp + -48 ], %g2 tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 20053a8: 03 00 80 62 sethi %hi(0x2018800), %g1 20053ac: d2 00 61 bc ld [ %g1 + 0x1bc ], %o1 ! 20189bc <_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; 20053b0: c4 26 60 08 st %g2, [ %i1 + 8 ] tmbuf->hour = time.tm_hour; 20053b4: c2 07 bf cc ld [ %fp + -52 ], %g1 tmbuf->minute = time.tm_min; 20053b8: c4 07 bf c8 ld [ %fp + -56 ], %g2 /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; 20053bc: c2 26 60 0c st %g1, [ %i1 + 0xc ] tmbuf->minute = time.tm_min; 20053c0: c4 26 60 10 st %g2, [ %i1 + 0x10 ] /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 20053c4: c2 07 bf d8 ld [ %fp + -40 ], %g1 tmbuf->month = time.tm_mon + 1; 20053c8: c4 07 bf d4 ld [ %fp + -44 ], %g2 tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; 20053cc: c6 07 bf c4 ld [ %fp + -60 ], %g3 tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 20053d0: d0 07 bf f4 ld [ %fp + -12 ], %o0 /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 20053d4: 82 00 67 6c add %g1, 0x76c, %g1 tmbuf->month = time.tm_mon + 1; 20053d8: 84 00 a0 01 inc %g2 tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; 20053dc: c6 26 60 14 st %g3, [ %i1 + 0x14 ] /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 20053e0: c2 26 40 00 st %g1, [ %i1 ] tmbuf->month = time.tm_mon + 1; 20053e4: c4 26 60 04 st %g2, [ %i1 + 4 ] tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 20053e8: 40 00 3f a6 call 2015280 <.udiv> 20053ec: b0 10 20 00 clr %i0 20053f0: d0 26 60 18 st %o0, [ %i1 + 0x18 ] 20053f4: 81 c7 e0 08 ret 20053f8: 81 e8 00 00 restore ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 20053fc: 7f ff f2 79 call 2001de0 <== NOT EXECUTED 2005400: 01 00 00 00 nop <== NOT EXECUTED 2005404: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED _TOD_Get( &now ); 2005408: 40 00 07 4a call 2007130 <_TOD_Get> <== NOT EXECUTED 200540c: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED _ISR_Enable(level); 2005410: 7f ff f2 78 call 2001df0 <== NOT EXECUTED 2005414: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED time->tv_sec = now.tv_sec; 2005418: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 200541c: d0 07 bf ec ld [ %fp + -20 ], %o0 <== NOT EXECUTED 2005420: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 2005424: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 2005428: 40 00 3f 96 call 2015280 <.udiv> <== NOT EXECUTED 200542c: b0 10 20 00 clr %i0 <== NOT EXECUTED 2005430: d0 26 60 04 st %o0, [ %i1 + 4 ] <== NOT EXECUTED 2005434: 81 c7 e0 08 ret <== NOT EXECUTED 2005438: 81 e8 00 00 restore <== NOT EXECUTED 0200545c : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 200545c: 9d e3 bf 98 save %sp, -104, %sp _TOD_Tickle_ticks(); 2005460: 40 00 07 5c call 20071d0 <_TOD_Tickle_ticks> 2005464: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 2005468: 11 00 80 62 sethi %hi(0x2018800), %o0 200546c: 40 00 15 54 call 200a9bc <_Watchdog_Tickle> 2005470: 90 12 20 e0 or %o0, 0xe0, %o0 ! 20188e0 <_Watchdog_Ticks_chain> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 2005474: 40 00 13 78 call 200a254 <_Thread_Tickle_timeslice> 2005478: 01 00 00 00 nop * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_context_switch_necessary( void ) { return ( _Context_Switch_necessary ); 200547c: 03 00 80 62 sethi %hi(0x2018800), %g1 2005480: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 20188d0 <_Context_Switch_necessary> if ( _Thread_Is_context_switch_necessary() && 2005484: 80 a0 a0 00 cmp %g2, 0 2005488: 02 80 00 06 be 20054a0 200548c: 03 00 80 61 sethi %hi(0x2018400), %g1 * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 2005490: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 20187e0 <_Thread_Dispatch_disable_level> 2005494: 80 a0 a0 00 cmp %g2, 0 2005498: 02 80 00 04 be 20054a8 200549c: 01 00 00 00 nop _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 20054a0: 81 c7 e0 08 ret 20054a4: 91 e8 20 00 restore %g0, 0, %o0 _Thread_Tickle_timeslice(); if ( _Thread_Is_context_switch_necessary() && _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 20054a8: 40 00 0f 50 call 20091e8 <_Thread_Dispatch> <== NOT EXECUTED 20054ac: b0 10 20 00 clr %i0 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 20054b0: 81 c7 e0 08 ret <== NOT EXECUTED 20054b4: 81 e8 00 00 restore <== NOT EXECUTED 020056f0 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 20056f0: 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 ) ) { 20056f4: 92 96 20 00 orcc %i0, 0, %o1 20056f8: 12 80 00 1c bne 2005768 20056fc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005700: 23 00 80 61 sethi %hi(0x2018400), %l1 2005704: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> 2005708: 82 00 60 01 inc %g1 200570c: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] 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; 2005710: 03 00 80 62 sethi %hi(0x2018800), %g1 2005714: f0 00 60 c0 ld [ %g1 + 0xc0 ], %i0 ! 20188c0 <_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; 2005718: c0 27 bf f4 clr [ %fp + -12 ] rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 200571c: 7f ff f1 b1 call 2001de0 2005720: e0 06 21 70 ld [ %i0 + 0x170 ], %l0 *the_event_set |= the_new_events; 2005724: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 2005728: 82 10 40 19 or %g1, %i1, %g1 200572c: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _ISR_Enable( level ); 2005730: 7f ff f1 b0 call 2001df0 2005734: 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 ); 2005738: 40 00 00 2d call 20057ec <_Event_Surrender> 200573c: 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 ) 2005740: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 2005744: b0 10 20 00 clr %i0 2005748: 82 00 7f ff add %g1, -1, %g1 200574c: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] 2005750: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 2005754: 80 a0 a0 00 cmp %g2, 0 2005758: 02 80 00 0a be 2005780 200575c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005760: 81 c7 e0 08 ret 2005764: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2005768: 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 ) { 200576c: 80 a0 a0 04 cmp %g2, 4 2005770: 08 80 00 08 bleu 2005790 2005774: 83 32 60 1b srl %o1, 0x1b, %g1 2005778: 81 c7 e0 08 ret <== NOT EXECUTED 200577c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2005780: 40 00 0e 9a call 20091e8 <_Thread_Dispatch> 2005784: 01 00 00 00 nop 2005788: 81 c7 e0 08 ret 200578c: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2005790: 80 a0 60 01 cmp %g1, 1 2005794: 12 bf ff f3 bne 2005760 2005798: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 200579c: 83 28 a0 02 sll %g2, 2, %g1 20057a0: 05 00 80 61 sethi %hi(0x2018400), %g2 20057a4: 84 10 a3 40 or %g2, 0x340, %g2 ! 2018740 <_Objects_Information_table> 20057a8: c6 00 80 01 ld [ %g2 + %g1 ], %g3 20057ac: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 20057b0: 80 a2 20 00 cmp %o0, 0 20057b4: 02 bf ff f5 be 2005788 20057b8: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20057bc: 40 00 09 57 call 2007d18 <_Objects_Get> 20057c0: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20057c4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20057c8: b0 10 00 08 mov %o0, %i0 20057cc: 80 a0 60 00 cmp %g1, 0 20057d0: 02 bf ff d3 be 200571c 20057d4: 23 00 80 61 sethi %hi(0x2018400), %l1 20057d8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20057dc: 18 bf ff e1 bgu 2005760 <== NOT EXECUTED 20057e0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 20057e4: 81 c7 e0 08 ret <== NOT EXECUTED 20057e8: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 0200dadc : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 200dadc: 9d e3 bf 98 save %sp, -104, %sp Extension_Control *the_extension; if ( !rtems_is_name_valid( name ) ) 200dae0: a6 96 20 00 orcc %i0, 0, %l3 200dae4: 02 80 00 16 be 200db3c 200dae8: b0 10 20 03 mov 3, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200daec: 23 00 80 a7 sethi %hi(0x2029c00), %l1 200daf0: c2 04 63 40 ld [ %l1 + 0x340 ], %g1 ! 2029f40 <_Thread_Dispatch_disable_level> 200daf4: 82 00 60 01 inc %g1 200daf8: c2 24 63 40 st %g1, [ %l1 + 0x340 ] * the inactive chain of free extension control blocks. */ RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void ) { return (Extension_Control *) _Objects_Allocate( &_Extension_Information ); 200dafc: 25 00 80 a8 sethi %hi(0x202a000), %l2 200db00: 40 00 03 cb call 200ea2c <_Objects_Allocate> 200db04: 90 14 a1 dc or %l2, 0x1dc, %o0 ! 202a1dc <_Extension_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 200db08: a0 92 20 00 orcc %o0, 0, %l0 200db0c: 12 80 00 0e bne 200db44 200db10: 90 04 20 10 add %l0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200db14: c2 04 63 40 ld [ %l1 + 0x340 ], %g1 <== NOT EXECUTED 200db18: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 200db1c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200db20: c2 24 63 40 st %g1, [ %l1 + 0x340 ] <== NOT EXECUTED 200db24: c4 04 63 40 ld [ %l1 + 0x340 ], %g2 <== NOT EXECUTED 200db28: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200db2c: 12 80 00 20 bne 200dbac <== NOT EXECUTED 200db30: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 200db34: 40 00 0a 43 call 2010440 <_Thread_Dispatch> <== NOT EXECUTED 200db38: 01 00 00 00 nop <== NOT EXECUTED 200db3c: 81 c7 e0 08 ret <== NOT EXECUTED 200db40: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 200db44: 40 00 0e f5 call 2011718 <_User_extensions_Add_set> 200db48: 92 10 00 19 mov %i1, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200db4c: 90 14 a1 dc or %l2, 0x1dc, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200db50: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200db54: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 200db58: 03 00 00 3f sethi %hi(0xfc00), %g1 200db5c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200db60: 82 08 c0 01 and %g3, %g1, %g1 200db64: 80 a0 40 02 cmp %g1, %g2 200db68: 38 80 00 06 bgu,a 200db80 200db6c: e6 24 20 0c st %l3, [ %l0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200db70: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200db74: 83 28 60 02 sll %g1, 2, %g1 200db78: e0 20 80 01 st %l0, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200db7c: e6 24 20 0c st %l3, [ %l0 + 0xc ] &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 200db80: c6 26 80 00 st %g3, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200db84: c2 04 63 40 ld [ %l1 + 0x340 ], %g1 200db88: b0 10 20 00 clr %i0 200db8c: 82 00 7f ff add %g1, -1, %g1 200db90: c2 24 63 40 st %g1, [ %l1 + 0x340 ] 200db94: c4 04 63 40 ld [ %l1 + 0x340 ], %g2 200db98: 80 a0 a0 00 cmp %g2, 0 200db9c: 12 80 00 04 bne 200dbac 200dba0: 01 00 00 00 nop _Thread_Dispatch(); 200dba4: 40 00 0a 27 call 2010440 <_Thread_Dispatch> 200dba8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 200dbac: 81 c7 e0 08 ret 200dbb0: 81 e8 00 00 restore 0200dbb4 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 200dbb4: 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 *) 200dbb8: 21 00 80 a8 sethi %hi(0x202a000), %l0 <== NOT EXECUTED 200dbbc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200dbc0: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 200dbc4: 40 00 04 eb call 200ef70 <_Objects_Get> <== NOT EXECUTED 200dbc8: 90 14 21 dc or %l0, 0x1dc, %o0 <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 200dbcc: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200dbd0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200dbd4: 12 80 00 1e bne 200dc4c <== NOT EXECUTED 200dbd8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never return this */ return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 200dbdc: 40 00 0f 09 call 2011800 <_User_extensions_Remove_set> <== NOT EXECUTED 200dbe0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200dbe4: 90 14 21 dc or %l0, 0x1dc, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200dbe8: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200dbec: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 <== NOT EXECUTED 200dbf0: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED 200dbf4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <== NOT EXECUTED 200dbf8: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 200dbfc: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200dc00: 38 80 00 06 bgu,a 200dc18 <== NOT EXECUTED 200dc04: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200dc08: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 <== NOT EXECUTED 200dc0c: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 200dc10: 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; 200dc14: 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 ); 200dc18: 40 00 04 93 call 200ee64 <_Objects_Free> <== NOT EXECUTED 200dc1c: 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 ) 200dc20: 03 00 80 a7 sethi %hi(0x2029c00), %g1 <== NOT EXECUTED 200dc24: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 2029f40 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200dc28: b0 10 20 00 clr %i0 <== NOT EXECUTED 200dc2c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 200dc30: c4 20 63 40 st %g2, [ %g1 + 0x340 ] <== NOT EXECUTED 200dc34: c6 00 63 40 ld [ %g1 + 0x340 ], %g3 <== NOT EXECUTED 200dc38: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 200dc3c: 02 80 00 09 be 200dc60 <== NOT EXECUTED 200dc40: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200dc44: 81 c7 e0 08 ret <== NOT EXECUTED 200dc48: 81 e8 00 00 restore <== NOT EXECUTED { Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 200dc4c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200dc50: 08 bf ff fd bleu 200dc44 <== NOT EXECUTED 200dc54: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 200dc58: 81 c7 e0 08 ret <== NOT EXECUTED 200dc5c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 200dc60: 40 00 09 f8 call 2010440 <_Thread_Dispatch> <== NOT EXECUTED 200dc64: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200dc68: 81 c7 e0 08 ret <== NOT EXECUTED 200dc6c: 81 e8 00 00 restore <== NOT EXECUTED 02006a4c : */ void rtems_fatal_error_occurred( uint32_t the_error ) { 2006a4c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error ); 2006a50: 92 10 20 00 clr %o1 <== NOT EXECUTED 2006a54: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 2006a58: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2006a5c: 40 00 03 31 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 2006a60: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2006a64: 01 00 00 00 nop 02006a68 : #include const char *rtems_get_version_string(void) { return _RTEMS_version; } 2006a68: 11 00 80 5d sethi %hi(0x2017400), %o0 <== NOT EXECUTED 2006a6c: 81 c3 e0 08 retl <== NOT EXECUTED 2006a70: 90 12 22 98 or %o0, 0x298, %o0 ! 2017698 <_RTEMS_version> <== NOT EXECUTED 02006814 : rtems_interrupt_level rtems_initialize_executive_early( rtems_configuration_table *configuration_table, rtems_cpu_table *cpu_table ) { 2006814: 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 ); 2006818: 7f ff ed 72 call 2001de0 200681c: 01 00 00 00 nop 2006820: a6 10 00 08 mov %o0, %l3 if ( configuration_table == NULL ) 2006824: 80 a6 20 00 cmp %i0, 0 2006828: 22 80 00 77 be,a 2006a04 200682c: 90 10 20 00 clr %o0 <== NOT EXECUTED /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 2006830: 05 00 80 61 sethi %hi(0x2018400), %g2 RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; _System_state_Is_multiprocessing = is_multiprocessing; 2006834: 03 00 80 62 sethi %hi(0x2018800), %g1 2006838: a4 10 a3 f4 or %g2, 0x3f4, %l2 200683c: 94 10 20 28 mov 0x28, %o2 2006840: 92 10 00 19 mov %i1, %o1 2006844: c0 20 60 ec clr [ %g1 + 0xec ] RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; 2006848: 29 00 80 62 sethi %hi(0x2018800), %l4 200684c: 90 10 00 12 mov %l2, %o0 2006850: 40 00 20 c4 call 200eb60 2006854: c0 25 21 c0 clr [ %l4 + 0x1c0 ] /* * Provided just for user convenience. */ _Configuration_Table = configuration_table; 2006858: 03 00 80 62 sethi %hi(0x2018800), %g1 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_NO_CPU_TABLE ); _CPU_Initialize( cpu_table, _Thread_Dispatch ); 200685c: 90 10 00 19 mov %i1, %o0 2006860: 13 00 80 24 sethi %hi(0x2009000), %o1 2006864: 92 12 61 e8 or %o1, 0x1e8, %o1 ! 20091e8 <_Thread_Dispatch> 2006868: 40 00 12 43 call 200b174 <_CPU_Initialize> 200686c: f0 20 60 a4 st %i0, [ %g1 + 0xa4 ] /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 2006870: 40 00 19 3b call 200cd5c <_Debug_Manager_initialization> 2006874: a2 10 20 01 mov 1, %l1 _API_extensions_Initialization(); 2006878: 40 00 00 dd call 2006bec <_API_extensions_Initialization> 200687c: 01 00 00 00 nop _Thread_Dispatch_initialization(); _Workspace_Handler_initialization( 2006880: d2 06 20 04 ld [ %i0 + 4 ], %o1 2006884: 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; 2006888: 03 00 80 61 sethi %hi(0x2018400), %g1 200688c: e2 20 63 e0 st %l1, [ %g1 + 0x3e0 ] ! 20187e0 <_Thread_Dispatch_disable_level> 2006890: 40 00 10 82 call 200aa98 <_Workspace_Handler_initialization> 2006894: 21 00 80 62 sethi %hi(0x2018800), %l0 (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 2006898: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 200689c: 40 00 0e f3 call 200a468 <_User_extensions_Handler_initialization> 20068a0: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 20068a4: 40 00 03 af call 2007760 <_ISR_Handler_initialization> 20068a8: 01 00 00 00 nop _Objects_Handler_initialization( 20068ac: 90 10 20 01 mov 1, %o0 ! 1 20068b0: 92 10 20 01 mov 1, %o1 20068b4: 40 00 05 b2 call 2007f7c <_Objects_Handler_initialization> 20068b8: 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; 20068bc: 05 00 80 61 sethi %hi(0x2018400), %g2 /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20068c0: 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; 20068c4: 03 00 80 62 sethi %hi(0x2018800), %g1 20068c8: 82 10 60 20 or %g1, 0x20, %g1 ! 2018820 <_Internal_Objects> /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20068cc: 92 10 20 01 mov 1, %o1 multiprocessing_table->node, multiprocessing_table->maximum_nodes, multiprocessing_table->maximum_global_objects ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 20068d0: c2 20 a3 44 st %g1, [ %g2 + 0x344 ] /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20068d4: 94 10 20 02 mov 2, %o2 20068d8: 96 10 20 01 mov 1, %o3 20068dc: 98 10 20 74 mov 0x74, %o4 20068e0: 9a 10 20 00 clr %o5 20068e4: 40 00 05 34 call 2007db4 <_Objects_Initialize_information> 20068e8: 90 14 20 f0 or %l0, 0xf0, %o0 _API_Mutex_Allocate( _RTEMS_Allocator_Mutex ); 20068ec: 82 10 20 02 mov 2, %g1 20068f0: e2 27 bf e8 st %l1, [ %fp + -24 ] 20068f4: c2 27 bf f0 st %g1, [ %fp + -16 ] 20068f8: c0 27 bf ec clr [ %fp + -20 ] 20068fc: c0 27 bf f4 clr [ %fp + -12 ] 2006900: 40 00 03 b5 call 20077d4 <_Objects_Allocate> 2006904: 90 14 20 f0 or %l0, 0xf0, %o0 2006908: 03 00 80 62 sethi %hi(0x2018800), %g1 200690c: 84 10 00 08 mov %o0, %g2 2006910: 92 07 bf e8 add %fp, -24, %o1 2006914: c4 20 60 b8 st %g2, [ %g1 + 0xb8 ] 2006918: 90 02 20 10 add %o0, 0x10, %o0 200691c: 40 00 01 21 call 2006da0 <_CORE_mutex_Initialize> 2006920: 94 10 20 01 mov 1, %o2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 2006924: 03 00 80 62 sethi %hi(0x2018800), %g1 for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 2006928: 05 00 80 62 sethi %hi(0x2018800), %g2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 200692c: c0 30 60 b4 clrh [ %g1 + 0xb4 ] for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 2006930: c0 30 a1 40 clrh [ %g2 + 0x140 ] 2006934: 82 10 20 02 mov 2, %g1 2006938: 84 10 a1 40 or %g2, 0x140, %g2 200693c: c0 30 40 02 clrh [ %g1 + %g2 ] 2006940: 82 00 60 02 add %g1, 2, %g1 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; for ( index=0 ; index <16 ; index++ ) 2006944: 80 a0 60 20 cmp %g1, 0x20 2006948: 32 bf ff fe bne,a 2006940 200694c: c0 30 40 02 clrh [ %g1 + %g2 ] _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 2006950: 40 00 0f d2 call 200a898 <_Watchdog_Handler_initialization> 2006954: 01 00 00 00 nop _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 2006958: 40 00 02 0f call 2007194 <_TOD_Handler_initialization> 200695c: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _Thread_Handler_initialization( 2006960: d2 06 20 08 ld [ %i0 + 8 ], %o1 2006964: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 2006968: 40 00 0b 0e call 20095a0 <_Thread_Handler_initialization> 200696c: 94 10 20 00 clr %o2 ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 2006970: 40 00 00 80 call 2006b70 <_RTEMS_API_Initialize> 2006974: 90 10 00 18 mov %i0, %o0 _Extension_Manager_initialization( configuration_table->maximum_extensions ); 2006978: 40 00 00 28 call 2006a18 <_Extension_Manager_initialization> 200697c: d0 06 20 08 ld [ %i0 + 8 ], %o0 _IO_Manager_initialization( 2006980: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 2006984: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 2006988: 40 00 00 4c call 2006ab8 <_IO_Manager_initialization> 200698c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 2006990: 82 10 20 01 mov 1, %g1 * * At this point all API extensions are in place. After the call to * _Thread_Create_idle() _Thread_Executing and _Thread_Heir will be set. */ _Thread_Create_idle(); 2006994: 40 00 09 c1 call 2009098 <_Thread_Create_idle> 2006998: c2 25 21 c0 st %g1, [ %l4 + 0x1c0 ] /* * Scheduling can properly occur now as long as we avoid dispatching. */ if ( cpu_table->pretasking_hook ) 200699c: d0 06 40 00 ld [ %i1 ], %o0 20069a0: 80 a2 20 00 cmp %o0, 0 20069a4: 02 80 00 04 be 20069b4 20069a8: 01 00 00 00 nop (*cpu_table->pretasking_hook)(); 20069ac: 9f c2 00 00 call %o0 20069b0: 01 00 00 00 nop /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 20069b4: 40 00 00 b0 call 2006c74 <_API_extensions_Run_predriver> 20069b8: 01 00 00 00 nop if ( _CPU_Table.predriver_hook ) 20069bc: c2 04 a0 04 ld [ %l2 + 4 ], %g1 20069c0: 80 a0 60 00 cmp %g1, 0 20069c4: 02 80 00 04 be 20069d4 20069c8: 01 00 00 00 nop (*_CPU_Table.predriver_hook)(); 20069cc: 9f c0 40 00 call %g1 <== NOT EXECUTED 20069d0: 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(); 20069d4: 40 00 00 28 call 2006a74 <_IO_Initialize_all_drivers> 20069d8: 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(); 20069dc: 40 00 00 8b call 2006c08 <_API_extensions_Run_postdriver> 20069e0: 01 00 00 00 nop if ( _CPU_Table.postdriver_hook ) 20069e4: c4 04 a0 08 ld [ %l2 + 8 ], %g2 20069e8: 80 a0 a0 00 cmp %g2, 0 20069ec: 02 80 00 04 be 20069fc 20069f0: 01 00 00 00 nop (*_CPU_Table.postdriver_hook)(); 20069f4: 9f c0 80 00 call %g2 20069f8: 01 00 00 00 nop return bsp_level; } 20069fc: 81 c7 e0 08 ret 2006a00: 91 e8 00 13 restore %g0, %l3, %o0 */ _ISR_Disable( bsp_level ); if ( configuration_table == NULL ) _Internal_error_Occurred( 2006a04: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2006a08: 40 00 03 46 call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 2006a0c: 94 10 20 00 clr %o2 <== NOT EXECUTED /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 2006a10: 10 bf ff 89 b 2006834 <== NOT EXECUTED 2006a14: 05 00 80 61 sethi %hi(0x2018400), %g2 <== NOT EXECUTED 02007b7c : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 2007b7c: 9d e3 bf 98 save %sp, -104, %sp /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 2007b80: 80 a6 60 00 cmp %i1, 0 2007b84: 02 80 00 3e be 2007c7c 2007b88: 90 10 00 18 mov %i0, %o0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 2007b8c: 80 a6 a0 00 cmp %i2, 0 2007b90: 02 80 00 3b be 2007c7c 2007b94: 01 00 00 00 nop return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 2007b98: c2 06 40 00 ld [ %i1 ], %g1 2007b9c: 80 a0 60 00 cmp %g1, 0 2007ba0: 22 80 00 34 be,a 2007c70 2007ba4: c2 06 60 04 ld [ %i1 + 4 ], %g1 return RTEMS_INVALID_ADDRESS; *registered_major = 0; 2007ba8: c0 26 80 00 clr [ %i2 ] /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 2007bac: 03 00 80 71 sethi %hi(0x201c400), %g1 2007bb0: c6 00 62 9c ld [ %g1 + 0x29c ], %g3 ! 201c69c <_IO_Number_of_drivers> 2007bb4: 80 a0 c0 08 cmp %g3, %o0 2007bb8: 08 80 00 43 bleu 2007cc4 2007bbc: b0 10 20 0a mov 0xa, %i0 /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 2007bc0: 80 a2 20 00 cmp %o0, 0 2007bc4: 12 80 00 1f bne 2007c40 2007bc8: 03 00 80 71 sethi %hi(0x201c400), %g1 boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 2007bcc: 90 80 ff ff addcc %g3, -1, %o0 2007bd0: 02 80 00 26 be 2007c68 2007bd4: c8 00 62 a0 ld [ %g1 + 0x2a0 ], %g4 if ( !_IO_Driver_address_table[major].initialization_entry && 2007bd8: 85 28 e0 05 sll %g3, 5, %g2 2007bdc: 83 28 e0 03 sll %g3, 3, %g1 2007be0: 84 20 80 01 sub %g2, %g1, %g2 2007be4: 84 00 bf e8 add %g2, -24, %g2 2007be8: 10 80 00 04 b 2007bf8 2007bec: 84 00 80 04 add %g2, %g4, %g2 * in use. */ if ( major == 0 ) { boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 2007bf0: 02 80 00 1e be 2007c68 2007bf4: 84 00 bf e8 add %g2, -24, %g2 if ( !_IO_Driver_address_table[major].initialization_entry && 2007bf8: c2 00 80 00 ld [ %g2 ], %g1 2007bfc: 80 a0 60 00 cmp %g1, 0 2007c00: 32 bf ff fc bne,a 2007bf0 2007c04: 90 82 3f ff addcc %o0, -1, %o0 2007c08: c2 00 a0 04 ld [ %g2 + 4 ], %g1 2007c0c: 80 a0 60 00 cmp %g1, 0 2007c10: 32 bf ff f8 bne,a 2007bf0 2007c14: 90 82 3f ff addcc %o0, -1, %o0 <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 2007c18: 85 2a 20 03 sll %o0, 3, %g2 2007c1c: 83 2a 20 05 sll %o0, 5, %g1 2007c20: 82 20 40 02 sub %g1, %g2, %g1 2007c24: 88 01 00 01 add %g4, %g1, %g4 2007c28: c2 01 20 04 ld [ %g4 + 4 ], %g1 2007c2c: 80 a0 60 00 cmp %g1, 0 2007c30: 22 80 00 15 be,a 2007c84 2007c34: c2 06 40 00 ld [ %i1 ], %g1 _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 2007c38: 81 c7 e0 08 ret <== NOT EXECUTED 2007c3c: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 2007c40: c8 00 62 a0 ld [ %g1 + 0x2a0 ], %g4 2007c44: 85 2a 20 03 sll %o0, 3, %g2 2007c48: 83 2a 20 05 sll %o0, 5, %g1 2007c4c: 82 20 40 02 sub %g1, %g2, %g1 2007c50: c6 00 40 04 ld [ %g1 + %g4 ], %g3 2007c54: 80 a0 e0 00 cmp %g3, 0 2007c58: 02 bf ff f4 be 2007c28 2007c5c: 88 00 40 04 add %g1, %g4, %g4 _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 2007c60: 81 c7 e0 08 ret 2007c64: 91 e8 20 0c restore %g0, 0xc, %o0 2007c68: 81 c7 e0 08 ret 2007c6c: 91 e8 20 05 restore %g0, 5, %o0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 2007c70: 80 a0 60 00 cmp %g1, 0 2007c74: 32 bf ff ce bne,a 2007bac 2007c78: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 2007c7c: 81 c7 e0 08 ret 2007c80: 91 e8 20 09 restore %g0, 9, %o0 _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; *registered_major = major; 2007c84: d0 26 80 00 st %o0, [ %i2 ] if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007c88: c2 21 00 00 st %g1, [ %g4 ] 2007c8c: c4 06 60 04 ld [ %i1 + 4 ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 2007c90: 92 10 20 00 clr %o1 if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007c94: c4 21 20 04 st %g2, [ %g4 + 4 ] 2007c98: c2 06 60 08 ld [ %i1 + 8 ], %g1 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 2007c9c: 94 10 20 00 clr %o2 if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007ca0: c2 21 20 08 st %g1, [ %g4 + 8 ] 2007ca4: c4 06 60 0c ld [ %i1 + 0xc ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 2007ca8: b0 10 20 00 clr %i0 if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007cac: c4 21 20 0c st %g2, [ %g4 + 0xc ] 2007cb0: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 2007cb4: c2 21 20 10 st %g1, [ %g4 + 0x10 ] 2007cb8: c4 06 60 14 ld [ %i1 + 0x14 ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 2007cbc: 7f ff ff 30 call 200797c 2007cc0: c4 21 20 14 st %g2, [ %g4 + 0x14 ] 2007cc4: 81 c7 e0 08 ret 2007cc8: 81 e8 00 00 restore 020091d4 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 20091d4: 9d e3 bf 98 save %sp, -104, %sp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 20091d8: 80 a6 20 00 cmp %i0, 0 20091dc: 02 80 00 23 be 2009268 20091e0: 03 00 80 93 sethi %hi(0x2024c00), %g1 return; 20091e4: a4 10 61 24 or %g1, 0x124, %l2 ! 2024d24 <_Objects_Information_table+0x4> 20091e8: a6 04 a0 10 add %l2, 0x10, %l3 for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 20091ec: c2 04 80 00 ld [ %l2 ], %g1 20091f0: 80 a0 60 00 cmp %g1, 0 20091f4: 22 80 00 1a be,a 200925c 20091f8: a4 04 a0 04 add %l2, 4, %l2 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 20091fc: e2 00 60 04 ld [ %g1 + 4 ], %l1 if ( information ) { 2009200: 80 a4 60 00 cmp %l1, 0 2009204: 22 80 00 16 be,a 200925c 2009208: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 200920c: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 2009210: 86 90 60 00 orcc %g1, 0, %g3 2009214: 22 80 00 12 be,a 200925c 2009218: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED 200921c: a0 10 20 01 mov 1, %l0 the_thread = (Thread_Control *)information->local_table[ i ]; 2009220: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 2009224: 83 2c 20 02 sll %l0, 2, %g1 2009228: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( !the_thread ) 200922c: 80 a2 20 00 cmp %o0, 0 2009230: 02 80 00 05 be 2009244 2009234: a0 04 20 01 inc %l0 continue; (*routine)(the_thread); 2009238: 9f c6 00 00 call %i0 200923c: 01 00 00 00 nop 2009240: c6 14 60 10 lduh [ %l1 + 0x10 ], %g3 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 2009244: 83 28 e0 10 sll %g3, 0x10, %g1 2009248: 83 30 60 10 srl %g1, 0x10, %g1 200924c: 80 a0 40 10 cmp %g1, %l0 2009250: 3a bf ff f5 bcc,a 2009224 2009254: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 2009258: a4 04 a0 04 add %l2, 4, %l2 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 200925c: 80 a4 80 13 cmp %l2, %l3 2009260: 32 bf ff e4 bne,a 20091f0 2009264: c2 04 80 00 ld [ %l2 ], %g1 2009268: 81 c7 e0 08 ret 200926c: 81 e8 00 00 restore 0200efcc : Objects_Id id, void *buffer, size_t size, uint32_t *count ) { 200efcc: 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 ) 200efd0: 80 a6 60 00 cmp %i1, 0 200efd4: 02 80 00 28 be 200f074 200efd8: 80 a6 e0 00 cmp %i3, 0 return RTEMS_INVALID_ADDRESS; if ( !count ) 200efdc: 02 80 00 26 be 200f074 200efe0: 92 10 00 18 mov %i0, %o1 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 200efe4: 11 00 80 c9 sethi %hi(0x2032400), %o0 200efe8: 90 12 20 e0 or %o0, 0xe0, %o0 ! 20324e0 <_Message_queue_Information> 200efec: 40 00 19 5d call 2015560 <_Objects_Get> 200eff0: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200eff4: c2 07 bf f4 ld [ %fp + -12 ], %g1 200eff8: 80 a0 60 00 cmp %g1, 0 200effc: 02 80 00 08 be 200f01c 200f000: 9a 10 00 1b mov %i3, %o5 200f004: 80 a0 60 02 cmp %g1, 2 200f008: 08 80 00 03 bleu 200f014 200f00c: 90 10 20 04 mov 4, %o0 200f010: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code( core_status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f014: 81 c7 e0 08 ret 200f018: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 200f01c: 92 10 00 19 mov %i1, %o1 200f020: 94 10 00 1a mov %i2, %o2 200f024: 96 10 00 18 mov %i0, %o3 200f028: 98 10 20 00 clr %o4 200f02c: 40 00 13 d1 call 2013f70 <_CORE_message_queue_Broadcast> 200f030: 90 02 20 14 add %o0, 0x14, %o0 200f034: 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 ) 200f038: 03 00 80 c8 sethi %hi(0x2032000), %g1 200f03c: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 200f040: 84 00 bf ff add %g2, -1, %g2 200f044: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 200f048: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 200f04c: 80 a0 e0 00 cmp %g3, 0 200f050: 02 80 00 06 be 200f068 200f054: 01 00 00 00 nop #endif count ); _Thread_Enable_dispatch(); return 200f058: 40 00 01 35 call 200f52c <_Message_queue_Translate_core_message_queue_return_code> 200f05c: 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 */ } 200f060: 81 c7 e0 08 ret 200f064: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 200f068: 40 00 1e 72 call 2016a30 <_Thread_Dispatch> 200f06c: 01 00 00 00 nop 200f070: 30 bf ff fa b,a 200f058 #endif count ); _Thread_Enable_dispatch(); return 200f074: 10 bf ff e8 b 200f014 <== NOT EXECUTED 200f078: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED 0200f07c : uint32_t count, uint32_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 200f07c: 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 ) ) 200f080: a4 96 20 00 orcc %i0, 0, %l2 200f084: 02 80 00 1f be 200f100 200f088: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 200f08c: 80 a7 20 00 cmp %i4, 0 200f090: 02 80 00 1c be 200f100 200f094: 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 ) 200f098: 80 a6 60 00 cmp %i1, 0 200f09c: 02 80 00 19 be 200f100 200f0a0: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 200f0a4: 80 a6 a0 00 cmp %i2, 0 200f0a8: 02 80 00 16 be 200f100 200f0ac: b0 10 20 08 mov 8, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200f0b0: 23 00 80 c8 sethi %hi(0x2032000), %l1 200f0b4: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 200f0b8: 82 00 60 01 inc %g1 200f0bc: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate( count, max_message_size ); 200f0c0: 90 10 00 19 mov %i1, %o0 200f0c4: 40 00 2d b4 call 201a794 <_Message_queue_Allocate> 200f0c8: 92 10 00 1a mov %i2, %o1 if ( !the_message_queue ) { 200f0cc: a0 92 20 00 orcc %o0, 0, %l0 200f0d0: 12 80 00 0e bne 200f108 200f0d4: 80 8e e0 04 btst 4, %i3 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f0d8: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 200f0dc: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 200f0e0: 82 00 7f ff add %g1, -1, %g1 200f0e4: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 200f0e8: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 200f0ec: 80 a0 a0 00 cmp %g2, 0 200f0f0: 12 80 00 33 bne 200f1bc 200f0f4: 01 00 00 00 nop 200f0f8: 40 00 1e 4e call 2016a30 <_Thread_Dispatch> 200f0fc: 01 00 00 00 nop 200f100: 81 c7 e0 08 ret 200f104: 81 e8 00 00 restore } #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) 200f108: 12 80 00 11 bne 200f14c 200f10c: f6 24 20 10 st %i3, [ %l0 + 0x10 ] the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 200f110: c0 27 bf f4 clr [ %fp + -12 ] if ( ! _CORE_message_queue_Initialize( 200f114: 94 10 00 19 mov %i1, %o2 200f118: 96 10 00 1a mov %i2, %o3 200f11c: 90 04 20 14 add %l0, 0x14, %o0 200f120: 40 00 13 e1 call 20140a4 <_CORE_message_queue_Initialize> 200f124: 92 07 bf f4 add %fp, -12, %o1 200f128: 80 a2 20 00 cmp %o0, 0 200f12c: 12 80 00 0b bne 200f158 200f130: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 200f134: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED 200f138: 40 00 18 b3 call 2015404 <_Objects_Free> <== NOT EXECUTED 200f13c: 90 12 20 e0 or %o0, 0xe0, %o0 ! 20324e0 <_Message_queue_Information> <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f140: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 200f144: 10 bf ff e7 b 200f0e0 <== NOT EXECUTED 200f148: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 200f14c: 82 10 20 01 mov 1, %g1 200f150: 10 bf ff f1 b 200f114 200f154: c2 27 bf f4 st %g1, [ %fp + -12 ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f158: 03 00 80 c9 sethi %hi(0x2032400), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200f15c: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f160: 88 10 60 e0 or %g1, 0xe0, %g4 200f164: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 200f168: 03 00 00 3f sethi %hi(0xfc00), %g1 200f16c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200f170: 82 08 c0 01 and %g3, %g1, %g1 200f174: 80 a0 40 02 cmp %g1, %g2 200f178: 38 80 00 06 bgu,a 200f190 200f17c: e4 24 20 0c st %l2, [ %l0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200f180: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 200f184: 83 28 60 02 sll %g1, 2, %g1 200f188: e0 20 80 01 st %l0, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200f18c: e4 24 20 0c st %l2, [ %l0 + 0xc ] &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 200f190: c6 27 00 00 st %g3, [ %i4 ] 200f194: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 200f198: b0 10 20 00 clr %i0 200f19c: 82 00 7f ff add %g1, -1, %g1 200f1a0: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 200f1a4: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 200f1a8: 80 a0 a0 00 cmp %g2, 0 200f1ac: 12 80 00 04 bne 200f1bc 200f1b0: 01 00 00 00 nop _Thread_Dispatch(); 200f1b4: 40 00 1e 1f call 2016a30 <_Thread_Dispatch> 200f1b8: 01 00 00 00 nop ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 200f1bc: 81 c7 e0 08 ret 200f1c0: 81 e8 00 00 restore 02015d04 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 2015d04: 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 *) 2015d08: 21 00 80 a8 sethi %hi(0x202a000), %l0 2015d0c: 92 10 00 18 mov %i0, %o1 2015d10: 94 07 bf f4 add %fp, -12, %o2 2015d14: 7f ff e4 97 call 200ef70 <_Objects_Get> 2015d18: 90 14 22 dc or %l0, 0x2dc, %o0 register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 2015d1c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2015d20: 80 a0 60 00 cmp %g1, 0 2015d24: 12 80 00 20 bne 2015da4 2015d28: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2015d2c: a0 14 22 dc or %l0, 0x2dc, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2015d30: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2015d34: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 2015d38: 05 00 00 3f sethi %hi(0xfc00), %g2 2015d3c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2015d40: 82 08 40 02 and %g1, %g2, %g1 2015d44: 80 a0 40 03 cmp %g1, %g3 2015d48: 18 80 00 05 bgu 2015d5c 2015d4c: 94 10 20 05 mov 5, %o2 information->local_table[ index ] = the_object; 2015d50: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 2015d54: 83 28 60 02 sll %g1, 2, %g1 2015d58: c0 20 80 01 clr [ %g2 + %g1 ] case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, &the_message_queue->Object ); _CORE_message_queue_Close( 2015d5c: 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; 2015d60: c0 26 20 0c clr [ %i0 + 0xc ] 2015d64: 40 00 01 c0 call 2016464 <_CORE_message_queue_Close> 2015d68: 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 ); 2015d6c: 90 10 00 10 mov %l0, %o0 2015d70: 7f ff e4 3d call 200ee64 <_Objects_Free> 2015d74: 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 ) 2015d78: 03 00 80 a7 sethi %hi(0x2029c00), %g1 2015d7c: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 2029f40 <_Thread_Dispatch_disable_level> 2015d80: b0 10 20 00 clr %i0 2015d84: 84 00 bf ff add %g2, -1, %g2 2015d88: c4 20 63 40 st %g2, [ %g1 + 0x340 ] 2015d8c: c6 00 63 40 ld [ %g1 + 0x340 ], %g3 2015d90: 80 a0 e0 00 cmp %g3, 0 2015d94: 02 80 00 09 be 2015db8 2015d98: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2015d9c: 81 c7 e0 08 ret 2015da0: 81 e8 00 00 restore { register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 2015da4: 80 a0 60 02 cmp %g1, 2 2015da8: 08 bf ff fd bleu 2015d9c 2015dac: b0 10 20 04 mov 4, %i0 2015db0: 81 c7 e0 08 ret <== NOT EXECUTED 2015db4: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2015db8: 7f ff e9 a2 call 2010440 <_Thread_Dispatch> 2015dbc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2015dc0: 81 c7 e0 08 ret 2015dc4: 81 e8 00 00 restore 0200f288 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 200f288: 9d e3 bf 90 save %sp, -112, %sp 200f28c: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200f290: 80 a6 60 00 cmp %i1, 0 200f294: 02 80 00 1c be 200f304 200f298: 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 *) 200f29c: 11 00 80 c9 sethi %hi(0x2032400), %o0 200f2a0: 94 07 bf f4 add %fp, -12, %o2 200f2a4: 40 00 18 af call 2015560 <_Objects_Get> 200f2a8: 90 12 20 e0 or %o0, 0xe0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200f2ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f2b0: 80 a0 60 00 cmp %g1, 0 200f2b4: 02 80 00 06 be 200f2cc 200f2b8: 80 a0 60 02 cmp %g1, 2 200f2bc: 08 80 00 12 bleu 200f304 200f2c0: b0 10 20 04 mov 4, %i0 200f2c4: 81 c7 e0 08 ret <== NOT EXECUTED 200f2c8: 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 ); 200f2cc: 40 00 13 56 call 2014024 <_CORE_message_queue_Flush> 200f2d0: 90 02 20 14 add %o0, 0x14, %o0 200f2d4: 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 ) 200f2d8: 03 00 80 c8 sethi %hi(0x2032000), %g1 200f2dc: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 200f2e0: b0 10 20 00 clr %i0 200f2e4: 84 00 bf ff add %g2, -1, %g2 200f2e8: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 200f2ec: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 200f2f0: 80 a0 e0 00 cmp %g3, 0 200f2f4: 12 80 00 04 bne 200f304 200f2f8: 01 00 00 00 nop _Thread_Dispatch(); 200f2fc: 40 00 1d cd call 2016a30 <_Thread_Dispatch> 200f300: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f304: 81 c7 e0 08 ret 200f308: 81 e8 00 00 restore 0200f30c : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 200f30c: 9d e3 bf 90 save %sp, -112, %sp 200f310: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200f314: 80 a6 60 00 cmp %i1, 0 200f318: 02 80 00 1b be 200f384 200f31c: b0 10 20 09 mov 9, %i0 200f320: 11 00 80 c9 sethi %hi(0x2032400), %o0 200f324: 94 07 bf f4 add %fp, -12, %o2 200f328: 40 00 18 8e call 2015560 <_Objects_Get> 200f32c: 90 12 20 e0 or %o0, 0xe0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200f330: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f334: 80 a0 60 00 cmp %g1, 0 200f338: 22 80 00 07 be,a 200f354 200f33c: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 200f340: 80 a0 60 02 cmp %g1, 2 200f344: 08 80 00 10 bleu 200f384 200f348: b0 10 20 04 mov 4, %i0 200f34c: 81 c7 e0 08 ret <== NOT EXECUTED 200f350: 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; 200f354: 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 ) 200f358: 07 00 80 c8 sethi %hi(0x2032000), %g3 200f35c: c2 00 e1 c0 ld [ %g3 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 200f360: b0 10 20 00 clr %i0 200f364: 82 00 7f ff add %g1, -1, %g1 200f368: c2 20 e1 c0 st %g1, [ %g3 + 0x1c0 ] 200f36c: c4 00 e1 c0 ld [ %g3 + 0x1c0 ], %g2 200f370: 80 a0 a0 00 cmp %g2, 0 200f374: 12 80 00 04 bne 200f384 200f378: 01 00 00 00 nop _Thread_Dispatch(); 200f37c: 40 00 1d ad call 2016a30 <_Thread_Dispatch> 200f380: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f384: 81 c7 e0 08 ret 200f388: 81 e8 00 00 restore 02015dfc : void *buffer, size_t *size, uint32_t option_set, rtems_interval timeout ) { 2015dfc: 9d e3 bf 90 save %sp, -112, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; boolean wait; if ( !buffer ) 2015e00: 80 a6 60 00 cmp %i1, 0 2015e04: 02 80 00 2b be 2015eb0 2015e08: 92 10 00 18 mov %i0, %o1 return RTEMS_INVALID_ADDRESS; if ( !size ) 2015e0c: 80 a6 a0 00 cmp %i2, 0 2015e10: 02 80 00 28 be 2015eb0 2015e14: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 2015e18: 11 00 80 a8 sethi %hi(0x202a000), %o0 2015e1c: 7f ff e4 55 call 200ef70 <_Objects_Get> 2015e20: 90 12 22 dc or %o0, 0x2dc, %o0 ! 202a2dc <_Message_queue_Information> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 2015e24: c2 07 bf f4 ld [ %fp + -12 ], %g1 2015e28: 80 a0 60 00 cmp %g1, 0 2015e2c: 22 80 00 08 be,a 2015e4c 2015e30: d2 02 20 08 ld [ %o0 + 8 ], %o1 2015e34: 80 a0 60 02 cmp %g1, 2 2015e38: 08 80 00 03 bleu 2015e44 2015e3c: 90 10 20 04 mov 4, %o0 2015e40: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2015e44: 81 c7 e0 08 ret 2015e48: 91 e8 00 08 restore %g0, %o0, %o0 2015e4c: 98 0e e0 01 and %i3, 1, %o4 if ( _Options_Is_no_wait( option_set ) ) wait = FALSE; else wait = TRUE; _CORE_message_queue_Seize( 2015e50: 94 10 00 19 mov %i1, %o2 2015e54: 96 10 00 1a mov %i2, %o3 2015e58: 98 1b 20 01 xor %o4, 1, %o4 2015e5c: 9a 10 00 1c mov %i4, %o5 2015e60: 40 00 01 a7 call 20164fc <_CORE_message_queue_Seize> 2015e64: 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 ) 2015e68: 05 00 80 a7 sethi %hi(0x2029c00), %g2 2015e6c: c2 00 a3 40 ld [ %g2 + 0x340 ], %g1 ! 2029f40 <_Thread_Dispatch_disable_level> 2015e70: 82 00 7f ff add %g1, -1, %g1 2015e74: c2 20 a3 40 st %g1, [ %g2 + 0x340 ] 2015e78: c6 00 a3 40 ld [ %g2 + 0x340 ], %g3 2015e7c: 80 a0 e0 00 cmp %g3, 0 2015e80: 02 80 00 08 be 2015ea0 2015e84: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 2015e88: 03 00 80 a8 sethi %hi(0x202a000), %g1 <== NOT EXECUTED 2015e8c: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 ! 202a020 <_Thread_Executing> 2015e90: 40 00 00 36 call 2015f68 <_Message_queue_Translate_core_message_queue_return_code> 2015e94: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2015e98: 81 c7 e0 08 ret 2015e9c: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 2015ea0: 7f ff e9 68 call 2010440 <_Thread_Dispatch> 2015ea4: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 2015ea8: 10 bf ff f9 b 2015e8c 2015eac: 03 00 80 a8 sethi %hi(0x202a000), %g1 2015eb0: 10 bf ff e5 b 2015e44 <== NOT EXECUTED 2015eb4: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED 02015eb8 : rtems_status_code rtems_message_queue_send( Objects_Id id, void *buffer, size_t size ) { 2015eb8: 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 ) 2015ebc: 80 a6 60 00 cmp %i1, 0 2015ec0: 02 80 00 20 be 2015f40 2015ec4: 90 10 20 09 mov 9, %o0 2015ec8: 11 00 80 a8 sethi %hi(0x202a000), %o0 2015ecc: 92 10 00 18 mov %i0, %o1 2015ed0: 90 12 22 dc or %o0, 0x2dc, %o0 2015ed4: 7f ff e4 27 call 200ef70 <_Objects_Get> 2015ed8: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 2015edc: c2 07 bf f4 ld [ %fp + -12 ], %g1 2015ee0: 80 a0 60 00 cmp %g1, 0 2015ee4: 12 80 00 19 bne 2015f48 2015ee8: 80 a0 60 02 cmp %g1, 2 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 2015eec: 94 10 00 1a mov %i2, %o2 2015ef0: c0 23 a0 5c clr [ %sp + 0x5c ] 2015ef4: c0 23 a0 60 clr [ %sp + 0x60 ] 2015ef8: 92 10 00 19 mov %i1, %o1 2015efc: 96 10 00 18 mov %i0, %o3 2015f00: 98 10 20 00 clr %o4 2015f04: 90 02 20 14 add %o0, 0x14, %o0 2015f08: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5 2015f0c: 40 00 01 c3 call 2016618 <_CORE_message_queue_Submit> 2015f10: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff 2015f14: 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 ) 2015f18: 05 00 80 a7 sethi %hi(0x2029c00), %g2 2015f1c: c2 00 a3 40 ld [ %g2 + 0x340 ], %g1 ! 2029f40 <_Thread_Dispatch_disable_level> 2015f20: 82 00 7f ff add %g1, -1, %g1 2015f24: c2 20 a3 40 st %g1, [ %g2 + 0x340 ] 2015f28: c6 00 a3 40 ld [ %g2 + 0x340 ], %g3 2015f2c: 80 a0 e0 00 cmp %g3, 0 2015f30: 02 80 00 0b be 2015f5c 2015f34: 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); 2015f38: 40 00 00 0c call 2015f68 <_Message_queue_Translate_core_message_queue_return_code> 2015f3c: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2015f40: 81 c7 e0 08 ret 2015f44: 91 e8 00 08 restore %g0, %o0, %o0 if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 2015f48: 08 bf ff fe bleu 2015f40 2015f4c: 90 10 20 04 mov 4, %o0 2015f50: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code(status); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2015f54: 81 c7 e0 08 ret <== NOT EXECUTED 2015f58: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2015f5c: 7f ff e9 39 call 2010440 <_Thread_Dispatch> 2015f60: 01 00 00 00 nop 2015f64: 30 bf ff f5 b,a 2015f38 020088cc : rtems_status_code rtems_message_queue_urgent( Objects_Id id, void *buffer, size_t size ) { 20088cc: 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 ) 20088d0: 80 a6 60 00 cmp %i1, 0 20088d4: 02 80 00 1f be 2008950 20088d8: 90 10 20 09 mov 9, %o0 20088dc: 11 00 80 80 sethi %hi(0x2020000), %o0 20088e0: 92 10 00 18 mov %i0, %o1 20088e4: 90 12 23 e8 or %o0, 0x3e8, %o0 20088e8: 40 00 0a 20 call 200b168 <_Objects_Get> 20088ec: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 20088f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20088f4: 80 a0 60 00 cmp %g1, 0 20088f8: 12 80 00 18 bne 2008958 20088fc: 80 a0 60 02 cmp %g1, 2 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 2008900: 94 10 00 1a mov %i2, %o2 2008904: c0 23 a0 5c clr [ %sp + 0x5c ] 2008908: c0 23 a0 60 clr [ %sp + 0x60 ] 200890c: 92 10 00 19 mov %i1, %o1 2008910: 96 10 00 18 mov %i0, %o3 2008914: 98 10 20 00 clr %o4 2008918: 1b 20 00 00 sethi %hi(0x80000000), %o5 200891c: 40 00 05 e7 call 200a0b8 <_CORE_message_queue_Submit> 2008920: 90 02 20 14 add %o0, 0x14, %o0 2008924: 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 ) 2008928: 03 00 80 80 sethi %hi(0x2020000), %g1 200892c: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 20200d0 <_Thread_Dispatch_disable_level> 2008930: 84 00 bf ff add %g2, -1, %g2 2008934: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 2008938: c6 00 60 d0 ld [ %g1 + 0xd0 ], %g3 200893c: 80 a0 e0 00 cmp %g3, 0 2008940: 02 80 00 0b be 200896c 2008944: 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); 2008948: 7f ff ff d7 call 20088a4 <_Message_queue_Translate_core_message_queue_return_code> 200894c: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2008950: 81 c7 e0 08 ret 2008954: 91 e8 00 08 restore %g0, %o0, %o0 if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 2008958: 08 bf ff fe bleu 2008950 <== NOT EXECUTED 200895c: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED 2008960: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code(status); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2008964: 81 c7 e0 08 ret <== NOT EXECUTED 2008968: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 200896c: 40 00 0f 33 call 200c638 <_Thread_Dispatch> 2008970: 01 00 00 00 nop 2008974: 30 bf ff f5 b,a 2008948 0200f554 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 200f554: 9d e3 bf 98 save %sp, -104, %sp register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 200f558: a8 96 20 00 orcc %i0, 0, %l4 200f55c: 02 80 00 29 be 200f600 200f560: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 200f564: 80 a6 60 00 cmp %i1, 0 200f568: 02 80 00 11 be 200f5ac 200f56c: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 200f570: 02 80 00 0f be 200f5ac 200f574: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 200f578: 12 80 00 04 bne 200f588 200f57c: 80 a6 e0 00 cmp %i3, 0 ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 200f580: 81 c7 e0 08 ret 200f584: 91 e8 20 08 restore %g0, 8, %o0 return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 200f588: 02 80 00 1e be 200f600 200f58c: b0 10 20 08 mov 8, %i0 200f590: 80 a6 80 1b cmp %i2, %i3 200f594: 0a 80 00 1b bcs 200f600 200f598: 80 8e e0 07 btst 7, %i3 200f59c: 12 80 00 19 bne 200f600 200f5a0: 80 8e 60 07 btst 7, %i1 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 200f5a4: 02 80 00 04 be 200f5b4 200f5a8: 25 00 80 c8 sethi %hi(0x2032000), %l2 200f5ac: 81 c7 e0 08 ret 200f5b0: 91 e8 20 09 restore %g0, 9, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200f5b4: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 200f5b8: 82 00 60 01 inc %g1 200f5bc: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 200f5c0: 27 00 80 c7 sethi %hi(0x2031c00), %l3 200f5c4: 40 00 16 82 call 2014fcc <_Objects_Allocate> 200f5c8: 90 14 e3 40 or %l3, 0x340, %o0 ! 2031f40 <_Partition_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 200f5cc: a2 92 20 00 orcc %o0, 0, %l1 200f5d0: 12 80 00 0e bne 200f608 200f5d4: 92 10 00 1b mov %i3, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f5d8: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 200f5dc: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 200f5e0: 82 00 7f ff add %g1, -1, %g1 200f5e4: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] 200f5e8: c4 04 a1 c0 ld [ %l2 + 0x1c0 ], %g2 200f5ec: 80 a0 a0 00 cmp %g2, 0 200f5f0: 12 80 00 04 bne 200f600 200f5f4: 01 00 00 00 nop 200f5f8: 40 00 1d 0e call 2016a30 <_Thread_Dispatch> 200f5fc: 01 00 00 00 nop 200f600: 81 c7 e0 08 ret 200f604: 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; 200f608: f8 24 60 1c st %i4, [ %l1 + 0x1c ] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 200f60c: f2 24 60 10 st %i1, [ %l1 + 0x10 ] the_partition->length = length; 200f610: f4 24 60 14 st %i2, [ %l1 + 0x14 ] the_partition->buffer_size = buffer_size; 200f614: f6 24 60 18 st %i3, [ %l1 + 0x18 ] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 200f618: c0 24 60 20 clr [ %l1 + 0x20 ] _Chain_Initialize( &the_partition->Memory, starting_address, 200f61c: 40 00 55 38 call 2024afc <.udiv> 200f620: 90 10 00 1a mov %i2, %o0 200f624: a0 04 60 24 add %l1, 0x24, %l0 200f628: 94 10 00 08 mov %o0, %o2 200f62c: 92 10 00 19 mov %i1, %o1 200f630: 90 10 00 10 mov %l0, %o0 200f634: 40 00 12 37 call 2013f10 <_Chain_Initialize> 200f638: 96 10 00 1b mov %i3, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f63c: 90 14 e3 40 or %l3, 0x340, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200f640: c6 04 60 08 ld [ %l1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f644: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 200f648: 03 00 00 3f sethi %hi(0xfc00), %g1 200f64c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200f650: 82 08 c0 01 and %g3, %g1, %g1 200f654: 80 a0 40 02 cmp %g1, %g2 200f658: 38 80 00 06 bgu,a 200f670 200f65c: e8 24 60 0c st %l4, [ %l1 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200f660: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200f664: 83 28 60 02 sll %g1, 2, %g1 200f668: e2 20 80 01 st %l1, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200f66c: e8 24 60 0c st %l4, [ %l1 + 0xc ] &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 200f670: c6 27 40 00 st %g3, [ %i5 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f674: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 200f678: 10 bf ff da b 200f5e0 200f67c: b0 10 20 00 clr %i0 0200f680 : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 200f680: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200f684: 92 10 00 18 mov %i0, %o1 200f688: 94 07 bf f4 add %fp, -12, %o2 200f68c: 31 00 80 c7 sethi %hi(0x2031c00), %i0 200f690: 40 00 17 b4 call 2015560 <_Objects_Get> 200f694: 90 16 23 40 or %i0, 0x340, %o0 ! 2031f40 <_Partition_Information> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f698: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f69c: 80 a0 60 00 cmp %g1, 0 200f6a0: 12 80 00 13 bne 200f6ec 200f6a4: 92 10 00 08 mov %o0, %o1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 200f6a8: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 200f6ac: 80 a0 60 00 cmp %g1, 0 200f6b0: 02 80 00 14 be 200f700 200f6b4: 90 16 23 40 or %i0, 0x340, %o0 200f6b8: 03 00 80 c8 sethi %hi(0x2032000), %g1 200f6bc: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 200f6c0: b0 10 20 0c mov 0xc, %i0 200f6c4: 84 00 bf ff add %g2, -1, %g2 200f6c8: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 200f6cc: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 200f6d0: 80 a0 e0 00 cmp %g3, 0 200f6d4: 12 80 00 22 bne 200f75c 200f6d8: 01 00 00 00 nop _Thread_Dispatch(); 200f6dc: 40 00 1c d5 call 2016a30 <_Thread_Dispatch> 200f6e0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f6e4: 81 c7 e0 08 ret 200f6e8: 81 e8 00 00 restore { register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f6ec: 80 a0 60 02 cmp %g1, 2 200f6f0: 08 bf ff fd bleu 200f6e4 200f6f4: b0 10 20 04 mov 4, %i0 200f6f8: 81 c7 e0 08 ret <== NOT EXECUTED 200f6fc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200f700: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f704: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200f708: 05 00 00 3f sethi %hi(0xfc00), %g2 200f70c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200f710: 82 08 40 02 and %g1, %g2, %g1 200f714: 80 a0 40 03 cmp %g1, %g3 200f718: 18 80 00 04 bgu 200f728 200f71c: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 200f720: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200f724: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Partition_Free ( Partition_Control *the_partition ) { _Objects_Free( &_Partition_Information, &the_partition->Object ); 200f728: 40 00 17 37 call 2015404 <_Objects_Free> 200f72c: c0 22 60 0c clr [ %o1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f730: 03 00 80 c8 sethi %hi(0x2032000), %g1 200f734: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 200f738: b0 10 20 00 clr %i0 200f73c: 84 00 bf ff add %g2, -1, %g2 200f740: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 200f744: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 200f748: 80 a0 e0 00 cmp %g3, 0 200f74c: 12 80 00 04 bne 200f75c 200f750: 01 00 00 00 nop _Thread_Dispatch(); 200f754: 40 00 1c b7 call 2016a30 <_Thread_Dispatch> 200f758: 01 00 00 00 nop 200f75c: 81 c7 e0 08 ret 200f760: 81 e8 00 00 restore 0200f764 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 200f764: 9d e3 bf 90 save %sp, -112, %sp 200f768: 92 10 00 18 mov %i0, %o1 register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 200f76c: 80 a6 60 00 cmp %i1, 0 200f770: 02 80 00 1a be 200f7d8 200f774: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200f778: 11 00 80 c7 sethi %hi(0x2031c00), %o0 200f77c: 94 07 bf f4 add %fp, -12, %o2 200f780: 40 00 17 78 call 2015560 <_Objects_Get> 200f784: 90 12 23 40 or %o0, 0x340, %o0 return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f788: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f78c: 80 a0 60 00 cmp %g1, 0 200f790: 12 80 00 14 bne 200f7e0 200f794: b0 10 00 08 mov %o0, %i0 RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 200f798: 40 00 11 cb call 2013ec4 <_Chain_Get> 200f79c: 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 ) { 200f7a0: a0 92 20 00 orcc %o0, 0, %l0 200f7a4: 32 80 00 14 bne,a 200f7f4 200f7a8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f7ac: 03 00 80 c8 sethi %hi(0x2032000), %g1 200f7b0: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 200f7b4: b0 10 20 0d mov 0xd, %i0 200f7b8: 84 00 bf ff add %g2, -1, %g2 200f7bc: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 200f7c0: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 200f7c4: 80 a0 e0 00 cmp %g3, 0 200f7c8: 12 80 00 04 bne 200f7d8 200f7cc: 01 00 00 00 nop _Thread_Dispatch(); 200f7d0: 40 00 1c 98 call 2016a30 <_Thread_Dispatch> 200f7d4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_UNSATISFIED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f7d8: 81 c7 e0 08 ret 200f7dc: 81 e8 00 00 restore if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f7e0: 80 a0 60 02 cmp %g1, 2 200f7e4: 08 bf ff fd bleu 200f7d8 200f7e8: b0 10 20 04 mov 4, %i0 200f7ec: 81 c7 e0 08 ret <== NOT EXECUTED 200f7f0: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { the_partition->number_of_used_blocks += 1; 200f7f4: 82 00 60 01 inc %g1 200f7f8: c2 26 20 20 st %g1, [ %i0 + 0x20 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f7fc: 05 00 80 c8 sethi %hi(0x2032000), %g2 200f800: c2 00 a1 c0 ld [ %g2 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 200f804: 82 00 7f ff add %g1, -1, %g1 200f808: c2 20 a1 c0 st %g1, [ %g2 + 0x1c0 ] 200f80c: c6 00 a1 c0 ld [ %g2 + 0x1c0 ], %g3 200f810: 80 a0 e0 00 cmp %g3, 0 200f814: 02 80 00 05 be 200f828 200f818: 01 00 00 00 nop _Thread_Enable_dispatch(); *buffer = the_buffer; 200f81c: e0 26 40 00 st %l0, [ %i1 ] <== NOT EXECUTED 200f820: 81 c7 e0 08 ret 200f824: 91 e8 20 00 restore %g0, 0, %o0 _Thread_Dispatch(); 200f828: 40 00 1c 82 call 2016a30 <_Thread_Dispatch> 200f82c: 01 00 00 00 nop 200f830: 10 bf ff fc b 200f820 200f834: e0 26 40 00 st %l0, [ %i1 ] 0200f86c : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 200f86c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200f870: 11 00 80 c7 sethi %hi(0x2031c00), %o0 200f874: 92 10 00 18 mov %i0, %o1 200f878: 90 12 23 40 or %o0, 0x340, %o0 200f87c: 40 00 17 39 call 2015560 <_Objects_Get> 200f880: 94 07 bf f4 add %fp, -12, %o2 register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f884: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f888: 80 a0 60 00 cmp %g1, 0 200f88c: 12 80 00 12 bne 200f8d4 200f890: b0 10 00 08 mov %o0, %i0 ) { void *starting; void *ending; starting = the_partition->starting_address; 200f894: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( 200f898: 80 a0 80 19 cmp %g2, %i1 200f89c: 28 80 00 13 bleu,a 200f8e8 200f8a0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f8a4: 03 00 80 c8 sethi %hi(0x2032000), %g1 200f8a8: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 200f8ac: 84 00 bf ff add %g2, -1, %g2 200f8b0: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 200f8b4: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 200f8b8: 80 a0 e0 00 cmp %g3, 0 200f8bc: 12 80 00 27 bne 200f958 200f8c0: 01 00 00 00 nop _Thread_Dispatch(); 200f8c4: 40 00 1c 5b call 2016a30 <_Thread_Dispatch> 200f8c8: b0 10 20 09 mov 9, %i0 ! 9 200f8cc: 81 c7 e0 08 ret 200f8d0: 81 e8 00 00 restore 200f8d4: 80 a0 60 02 cmp %g1, 2 200f8d8: 08 bf ff fd bleu 200f8cc 200f8dc: b0 10 20 04 mov 4, %i0 200f8e0: 81 c7 e0 08 ret <== NOT EXECUTED 200f8e4: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 200f8e8: 82 00 80 01 add %g2, %g1, %g1 200f8ec: 80 a0 40 19 cmp %g1, %i1 200f8f0: 0a bf ff ed bcs 200f8a4 200f8f4: 01 00 00 00 nop 200f8f8: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 200f8fc: 40 00 55 2c call 2024dac <.urem> 200f900: 90 26 40 02 sub %i1, %g2, %o0 200f904: 80 a2 20 00 cmp %o0, 0 200f908: 12 bf ff e7 bne 200f8a4 200f90c: 92 10 00 19 mov %i1, %o1 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 200f910: 40 00 11 61 call 2013e94 <_Chain_Append> 200f914: 90 06 20 24 add %i0, 0x24, %o0 return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 200f918: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 200f91c: 82 00 7f ff add %g1, -1, %g1 200f920: c2 26 20 20 st %g1, [ %i0 + 0x20 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f924: 07 00 80 c8 sethi %hi(0x2032000), %g3 200f928: c2 00 e1 c0 ld [ %g3 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 200f92c: b0 10 20 00 clr %i0 200f930: 82 00 7f ff add %g1, -1, %g1 200f934: c2 20 e1 c0 st %g1, [ %g3 + 0x1c0 ] 200f938: c4 00 e1 c0 ld [ %g3 + 0x1c0 ], %g2 200f93c: 80 a0 a0 00 cmp %g2, 0 200f940: 12 80 00 04 bne 200f950 200f944: 01 00 00 00 nop _Thread_Dispatch(); 200f948: 40 00 1c 3a call 2016a30 <_Thread_Dispatch> 200f94c: 01 00 00 00 nop 200f950: 81 c7 e0 08 ret 200f954: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f958: 81 c7 e0 08 ret <== NOT EXECUTED 200f95c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED 0200e7d8 : */ rtems_status_code rtems_port_delete( Objects_Id id ) { 200e7d8: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Get ( Objects_Id id, Objects_Locations *location ) { return (Dual_ported_memory_Control *) 200e7dc: 92 10 00 18 mov %i0, %o1 200e7e0: 94 07 bf f4 add %fp, -12, %o2 200e7e4: 31 00 80 c7 sethi %hi(0x2031c00), %i0 200e7e8: 40 00 1b 5e call 2015560 <_Objects_Get> 200e7ec: 90 16 22 f4 or %i0, 0x2f4, %o0 ! 2031ef4 <_Dual_ported_memory_Information> register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 200e7f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 200e7f4: 80 a0 60 00 cmp %g1, 0 200e7f8: 12 80 00 1a bne 200e860 200e7fc: 92 10 00 08 mov %o0, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e800: 90 16 22 f4 or %i0, 0x2f4, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200e804: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e808: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200e80c: 05 00 00 3f sethi %hi(0xfc00), %g2 200e810: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200e814: 82 08 40 02 and %g1, %g2, %g1 200e818: 80 a0 40 03 cmp %g1, %g3 200e81c: 18 80 00 04 bgu 200e82c 200e820: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 200e824: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200e828: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Dual_ported_memory_Free ( Dual_ported_memory_Control *the_port ) { _Objects_Free( &_Dual_ported_memory_Information, &the_port->Object ); 200e82c: 40 00 1a f6 call 2015404 <_Objects_Free> 200e830: c0 22 60 0c clr [ %o1 + 0xc ] 200e834: 03 00 80 c8 sethi %hi(0x2032000), %g1 200e838: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 200e83c: b0 10 20 00 clr %i0 200e840: 84 00 bf ff add %g2, -1, %g2 200e844: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 200e848: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 200e84c: 80 a0 e0 00 cmp %g3, 0 200e850: 02 80 00 0a be 200e878 200e854: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e858: 81 c7 e0 08 ret <== NOT EXECUTED 200e85c: 81 e8 00 00 restore <== NOT EXECUTED { register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 200e860: 82 18 60 02 xor %g1, 2, %g1 200e864: 80 a0 00 01 cmp %g0, %g1 200e868: 84 60 20 00 subx %g0, 0, %g2 200e86c: b0 08 a0 15 and %g2, 0x15, %i0 200e870: 81 c7 e0 08 ret 200e874: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 200e878: 40 00 20 6e call 2016a30 <_Thread_Dispatch> 200e87c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e880: 81 c7 e0 08 ret 200e884: 81 e8 00 00 restore 0200fb74 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 200fb74: 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 *) 200fb78: 21 00 80 c7 sethi %hi(0x2031c00), %l0 200fb7c: 92 10 00 18 mov %i0, %o1 200fb80: 94 07 bf f4 add %fp, -12, %o2 200fb84: 40 00 16 77 call 2015560 <_Objects_Get> 200fb88: 90 14 23 8c or %l0, 0x38c, %o0 Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200fb8c: c2 07 bf f4 ld [ %fp + -12 ], %g1 200fb90: 80 a0 60 00 cmp %g1, 0 200fb94: 12 80 00 20 bne 200fc14 200fb98: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fb9c: a0 14 23 8c or %l0, 0x38c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200fba0: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fba4: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 200fba8: 05 00 00 3f sethi %hi(0xfc00), %g2 200fbac: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200fbb0: 82 08 40 02 and %g1, %g2, %g1 200fbb4: 80 a0 40 03 cmp %g1, %g3 200fbb8: 38 80 00 06 bgu,a 200fbd0 200fbbc: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200fbc0: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 200fbc4: 83 28 60 02 sll %g1, 2, %g1 200fbc8: 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; 200fbcc: 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 ); 200fbd0: 40 00 22 96 call 2018628 <_Watchdog_Remove> 200fbd4: 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 ); 200fbd8: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_INACTIVE; 200fbdc: c0 26 20 38 clr [ %i0 + 0x38 ] 200fbe0: 40 00 16 09 call 2015404 <_Objects_Free> 200fbe4: 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 ) 200fbe8: 03 00 80 c8 sethi %hi(0x2032000), %g1 200fbec: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 200fbf0: b0 10 20 00 clr %i0 200fbf4: 84 00 bf ff add %g2, -1, %g2 200fbf8: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 200fbfc: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 200fc00: 80 a0 e0 00 cmp %g3, 0 200fc04: 02 80 00 0a be 200fc2c 200fc08: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200fc0c: 81 c7 e0 08 ret <== NOT EXECUTED 200fc10: 81 e8 00 00 restore <== NOT EXECUTED { Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200fc14: 82 18 60 02 xor %g1, 2, %g1 200fc18: 80 a0 00 01 cmp %g0, %g1 200fc1c: 84 60 20 00 subx %g0, 0, %g2 200fc20: b0 08 a0 15 and %g2, 0x15, %i0 200fc24: 81 c7 e0 08 ret 200fc28: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 200fc2c: 40 00 1b 81 call 2016a30 <_Thread_Dispatch> 200fc30: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200fc34: 81 c7 e0 08 ret 200fc38: 81 e8 00 00 restore 0200e7f8 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 200e7f8: 9d e3 bf 90 save %sp, -112, %sp 200e7fc: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 200e800: 80 a6 60 00 cmp %i1, 0 200e804: 02 80 00 17 be 200e860 200e808: b0 10 20 09 mov 9, %i0 200e80c: 11 00 80 73 sethi %hi(0x201cc00), %o0 200e810: 94 07 bf f4 add %fp, -12, %o2 200e814: 7f ff ec 33 call 20098e0 <_Objects_Get> 200e818: 90 12 22 94 or %o0, 0x294, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200e81c: c2 07 bf f4 ld [ %fp + -12 ], %g1 200e820: 80 a0 60 00 cmp %g1, 0 200e824: 12 80 00 11 bne 200e868 200e828: 92 10 00 08 mov %o0, %o1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: *statistics = the_period->Statistics; 200e82c: 90 10 00 19 mov %i1, %o0 200e830: 92 02 60 54 add %o1, 0x54, %o1 200e834: 40 00 08 21 call 20108b8 200e838: 94 10 20 38 mov 0x38, %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200e83c: 03 00 80 74 sethi %hi(0x201d000), %g1 200e840: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 ! 201d030 <_Thread_Dispatch_disable_level> 200e844: b0 10 20 00 clr %i0 200e848: 84 00 bf ff add %g2, -1, %g2 200e84c: c4 20 60 30 st %g2, [ %g1 + 0x30 ] 200e850: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 200e854: 80 a0 e0 00 cmp %g3, 0 200e858: 02 80 00 0a be 200e880 200e85c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e860: 81 c7 e0 08 ret <== NOT EXECUTED 200e864: 81 e8 00 00 restore <== NOT EXECUTED if ( !statistics ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200e868: 82 18 60 02 xor %g1, 2, %g1 200e86c: 80 a0 00 01 cmp %g0, %g1 200e870: 84 60 20 00 subx %g0, 0, %g2 200e874: b0 08 a0 15 and %g2, 0x15, %i0 200e878: 81 c7 e0 08 ret 200e87c: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 200e880: 7f ff f1 4c call 200adb0 <_Thread_Dispatch> 200e884: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e888: 81 c7 e0 08 ret 200e88c: 81 e8 00 00 restore 0200e890 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 200e890: 9d e3 bf 88 save %sp, -120, %sp 200e894: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 200e898: 80 a6 60 00 cmp %i1, 0 200e89c: 02 80 00 21 be 200e920 200e8a0: b0 10 20 09 mov 9, %i0 200e8a4: 11 00 80 73 sethi %hi(0x201cc00), %o0 200e8a8: 94 07 bf f4 add %fp, -12, %o2 200e8ac: 7f ff ec 0d call 20098e0 <_Objects_Get> 200e8b0: 90 12 22 94 or %o0, 0x294, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200e8b4: c2 07 bf f4 ld [ %fp + -12 ], %g1 200e8b8: 80 a0 60 00 cmp %g1, 0 200e8bc: 12 80 00 1b bne 200e928 200e8c0: b0 10 00 08 mov %o0, %i0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 200e8c4: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 200e8c8: 80 a0 60 00 cmp %g1, 0 200e8cc: 02 80 00 03 be 200e8d8 200e8d0: 84 10 20 00 clr %g2 200e8d4: c4 00 60 08 ld [ %g1 + 8 ], %g2 status->state = the_period->state; 200e8d8: 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); 200e8dc: c4 26 40 00 st %g2, [ %i1 ] status->state = the_period->state; if ( status->state == RATE_MONOTONIC_INACTIVE ) { 200e8e0: 80 a0 60 00 cmp %g1, 0 200e8e4: 12 80 00 1b bne 200e950 200e8e8: 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; 200e8ec: 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; 200e8f0: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 200e8f4: 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; 200e8f8: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200e8fc: 03 00 80 74 sethi %hi(0x201d000), %g1 200e900: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 ! 201d030 <_Thread_Dispatch_disable_level> 200e904: b0 10 20 00 clr %i0 200e908: 84 00 bf ff add %g2, -1, %g2 200e90c: c4 20 60 30 st %g2, [ %g1 + 0x30 ] 200e910: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 200e914: 80 a0 e0 00 cmp %g3, 0 200e918: 02 80 00 0a be 200e940 200e91c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e920: 81 c7 e0 08 ret <== NOT EXECUTED 200e924: 81 e8 00 00 restore <== NOT EXECUTED if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200e928: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 200e92c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 200e930: 84 60 20 00 subx %g0, 0, %g2 <== NOT EXECUTED 200e934: b0 08 a0 15 and %g2, 0x15, %i0 <== NOT EXECUTED 200e938: 81 c7 e0 08 ret <== NOT EXECUTED 200e93c: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED _Thread_Dispatch(); 200e940: 7f ff f1 1c call 200adb0 <_Thread_Dispatch> 200e944: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e948: 81 c7 e0 08 ret 200e94c: 81 e8 00 00 restore * This lets them share one single invocation of _TOD_Get_uptime(). */ #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 200e950: a0 07 bf ec add %fp, -20, %l0 200e954: 7f ff e8 95 call 2008ba8 <_TOD_Get_uptime> 200e958: 90 10 00 10 mov %l0, %o0 #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 200e95c: 90 06 20 44 add %i0, 0x44, %o0 200e960: 92 10 00 10 mov %l0, %o1 200e964: 7f ff f5 fc call 200c154 <_Timespec_Subtract> 200e968: 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( 200e96c: 92 10 00 10 mov %l0, %o1 200e970: 94 06 60 10 add %i1, 0x10, %o2 200e974: 11 00 80 74 sethi %hi(0x201d000), %o0 200e978: 7f ff f5 f7 call 200c154 <_Timespec_Subtract> 200e97c: 90 12 21 18 or %o0, 0x118, %o0 ! 201d118 <_Thread_Time_of_last_context_switch> 200e980: 30 bf ff df b,a 200e8fc 02006c10 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 2006c10: 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 *) 2006c14: 11 00 80 73 sethi %hi(0x201cc00), %o0 2006c18: 92 10 00 18 mov %i0, %o1 2006c1c: 90 12 22 94 or %o0, 0x294, %o0 2006c20: 40 00 0b 30 call 20098e0 <_Objects_Get> 2006c24: 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 ) { 2006c28: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006c2c: 80 a0 60 00 cmp %g1, 0 2006c30: 12 80 00 15 bne 2006c84 2006c34: a2 10 00 08 mov %o0, %l1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 2006c38: 25 00 80 74 sethi %hi(0x201d000), %l2 2006c3c: c4 02 20 50 ld [ %o0 + 0x50 ], %g2 2006c40: c2 04 a1 10 ld [ %l2 + 0x110 ], %g1 2006c44: 80 a0 80 01 cmp %g2, %g1 2006c48: 02 80 00 14 be 2006c98 2006c4c: 80 a6 60 00 cmp %i1, 0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006c50: 03 00 80 74 sethi %hi(0x201d000), %g1 2006c54: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 ! 201d030 <_Thread_Dispatch_disable_level> 2006c58: b0 10 20 17 mov 0x17, %i0 _Thread_Dispatch(); 2006c5c: 84 00 bf ff add %g2, -1, %g2 2006c60: c4 20 60 30 st %g2, [ %g1 + 0x30 ] 2006c64: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 2006c68: 80 a0 e0 00 cmp %g3, 0 2006c6c: 12 80 00 66 bne 2006e04 2006c70: 01 00 00 00 nop 2006c74: 40 00 10 4f call 200adb0 <_Thread_Dispatch> 2006c78: 01 00 00 00 nop 2006c7c: 81 c7 e0 08 ret 2006c80: 81 e8 00 00 restore rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 2006c84: 80 a0 60 02 cmp %g1, 2 2006c88: 02 bf ff fd be 2006c7c 2006c8c: b0 10 20 04 mov 4, %i0 break; } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006c90: 81 c7 e0 08 ret <== NOT EXECUTED 2006c94: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 2006c98: 22 80 00 73 be,a 2006e64 2006c9c: d0 02 20 38 ld [ %o0 + 0x38 ], %o0 } _Thread_Enable_dispatch(); return( return_value ); } _ISR_Disable( level ); 2006ca0: 7f ff ef 42 call 20029a8 2006ca4: 01 00 00 00 nop 2006ca8: a0 10 00 08 mov %o0, %l0 switch ( the_period->state ) { 2006cac: e6 04 60 38 ld [ %l1 + 0x38 ], %l3 2006cb0: 80 a4 e0 02 cmp %l3, 2 2006cb4: 02 80 00 34 be 2006d84 2006cb8: 80 a4 e0 04 cmp %l3, 4 2006cbc: 02 80 00 54 be 2006e0c 2006cc0: 80 a4 e0 00 cmp %l3, 0 2006cc4: 32 bf ff ee bne,a 2006c7c 2006cc8: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED /* * No need to update statistics -- there are not a period active */ _ISR_Enable( level ); 2006ccc: 7f ff ef 3b call 20029b8 2006cd0: 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 ); 2006cd4: 40 00 07 b5 call 2008ba8 <_TOD_Get_uptime> 2006cd8: 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; 2006cdc: c2 07 bf ec ld [ %fp + -20 ], %g1 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006ce0: c6 04 a1 10 ld [ %l2 + 0x110 ], %g3 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS /* * Since the statistics didn't update the starting time, * we do it here. */ the_period->time_at_period = uptime; 2006ce4: c2 24 60 44 st %g1, [ %l1 + 0x44 ] 2006ce8: 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( 2006cec: 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; 2006cf0: c2 24 60 48 st %g1, [ %l1 + 0x48 ] #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006cf4: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006cf8: a0 07 bf e4 add %fp, -28, %l0 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006cfc: c4 24 60 3c st %g2, [ %l1 + 0x3c ] 2006d00: c2 00 e0 94 ld [ %g3 + 0x94 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006d04: 94 10 00 10 mov %l0, %o2 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006d08: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006d0c: 11 00 80 74 sethi %hi(0x201d000), %o0 2006d10: 40 00 15 11 call 200c154 <_Timespec_Subtract> 2006d14: 90 12 21 18 or %o0, 0x118, %o0 ! 201d118 <_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 ); 2006d18: 92 10 00 10 mov %l0, %o1 2006d1c: 40 00 14 ab call 200bfc8 <_Timespec_Add_to> 2006d20: 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; 2006d24: 84 10 20 02 mov 2, %g2 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2006d28: 03 00 80 1c sethi %hi(0x2007000), %g1 2006d2c: 82 10 62 38 or %g1, 0x238, %g1 ! 2007238 <_Rate_monotonic_Timeout> the_watchdog->id = id; 2006d30: f0 24 60 30 st %i0, [ %l1 + 0x30 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2006d34: f2 24 60 1c st %i1, [ %l1 + 0x1c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2006d38: c0 24 60 18 clr [ %l1 + 0x18 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2006d3c: c0 24 60 34 clr [ %l1 + 0x34 ] _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 2006d40: f2 24 60 4c st %i1, [ %l1 + 0x4c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006d44: 92 04 60 10 add %l1, 0x10, %o1 #else the_period->owner_ticks_executed_at_period = _Thread_Executing->ticks_executed; #endif the_period->state = RATE_MONOTONIC_ACTIVE; 2006d48: c4 24 60 38 st %g2, [ %l1 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2006d4c: c2 24 60 2c st %g1, [ %l1 + 0x2c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006d50: 11 00 80 74 sethi %hi(0x201d000), %o0 2006d54: 40 00 15 cb call 200c480 <_Watchdog_Insert> 2006d58: 90 12 21 30 or %o0, 0x130, %o0 ! 201d130 <_Watchdog_Ticks_chain> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006d5c: 05 00 80 74 sethi %hi(0x201d000), %g2 2006d60: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 ! 201d030 <_Thread_Dispatch_disable_level> 2006d64: 82 00 7f ff add %g1, -1, %g1 2006d68: c2 20 a0 30 st %g1, [ %g2 + 0x30 ] 2006d6c: c6 00 a0 30 ld [ %g2 + 0x30 ], %g3 2006d70: 80 a0 e0 00 cmp %g3, 0 2006d74: 02 80 00 22 be 2006dfc 2006d78: 01 00 00 00 nop _Thread_Dispatch(); 2006d7c: 81 c7 e0 08 ret <== NOT EXECUTED 2006d80: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 2006d84: 7f ff ff 43 call 2006a90 <_Rate_monotonic_Update_statistics> 2006d88: 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; 2006d8c: 82 10 20 01 mov 1, %g1 the_period->next_length = length; 2006d90: 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; 2006d94: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; _ISR_Enable( level ); 2006d98: 7f ff ef 08 call 20029b8 2006d9c: 90 10 00 10 mov %l0, %o0 _Thread_Executing->Wait.id = the_period->Object.id; 2006da0: c2 04 a1 10 ld [ %l2 + 0x110 ], %g1 2006da4: c4 04 60 08 ld [ %l1 + 8 ], %g2 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 2006da8: 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; 2006dac: c4 20 60 20 st %g2, [ %g1 + 0x20 ] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 2006db0: 40 00 13 4f call 200baec <_Thread_Set_state> 2006db4: 13 00 00 10 sethi %hi(0x4000), %o1 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 2006db8: 7f ff ee fc call 20029a8 2006dbc: 01 00 00 00 nop local_state = the_period->state; 2006dc0: e0 04 60 38 ld [ %l1 + 0x38 ], %l0 the_period->state = RATE_MONOTONIC_ACTIVE; 2006dc4: e6 24 60 38 st %l3, [ %l1 + 0x38 ] _ISR_Enable( level ); 2006dc8: 7f ff ee fc call 20029b8 2006dcc: 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 ) 2006dd0: 80 a4 20 03 cmp %l0, 3 2006dd4: 02 80 00 32 be 2006e9c 2006dd8: d0 04 a1 10 ld [ %l2 + 0x110 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006ddc: 03 00 80 74 sethi %hi(0x201d000), %g1 2006de0: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 ! 201d030 <_Thread_Dispatch_disable_level> 2006de4: 84 00 bf ff add %g2, -1, %g2 2006de8: c4 20 60 30 st %g2, [ %g1 + 0x30 ] 2006dec: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 2006df0: 80 a0 e0 00 cmp %g3, 0 2006df4: 12 bf ff e2 bne 2006d7c 2006df8: 01 00 00 00 nop _Thread_Dispatch(); 2006dfc: 40 00 0f ed call 200adb0 <_Thread_Dispatch> 2006e00: b0 10 20 00 clr %i0 ! 0 2006e04: 81 c7 e0 08 ret 2006e08: 81 e8 00 00 restore case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 2006e0c: 7f ff ff 21 call 2006a90 <_Rate_monotonic_Update_statistics> 2006e10: 90 10 00 11 mov %l1, %o0 _ISR_Enable( level ); 2006e14: 7f ff ee e9 call 20029b8 2006e18: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 2006e1c: 82 10 20 02 mov 2, %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2006e20: f2 24 60 1c st %i1, [ %l1 + 0x1c ] the_period->next_length = length; 2006e24: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006e28: 92 04 60 10 add %l1, 0x10, %o1 */ _Rate_monotonic_Update_statistics( the_period ); _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 2006e2c: c2 24 60 38 st %g1, [ %l1 + 0x38 ] 2006e30: 11 00 80 74 sethi %hi(0x201d000), %o0 2006e34: 40 00 15 93 call 200c480 <_Watchdog_Insert> 2006e38: 90 12 21 30 or %o0, 0x130, %o0 ! 201d130 <_Watchdog_Ticks_chain> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006e3c: 07 00 80 74 sethi %hi(0x201d000), %g3 2006e40: c2 00 e0 30 ld [ %g3 + 0x30 ], %g1 ! 201d030 <_Thread_Dispatch_disable_level> 2006e44: b0 10 20 06 mov 6, %i0 2006e48: 82 00 7f ff add %g1, -1, %g1 2006e4c: c2 20 e0 30 st %g1, [ %g3 + 0x30 ] 2006e50: c4 00 e0 30 ld [ %g3 + 0x30 ], %g2 2006e54: 80 a0 a0 00 cmp %g2, 0 2006e58: 02 bf ff 87 be 2006c74 2006e5c: 01 00 00 00 nop 2006e60: 30 bf ff e9 b,a 2006e04 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 2006e64: 80 a2 20 02 cmp %o0, 2 2006e68: 02 80 00 09 be 2006e8c 2006e6c: b0 10 20 00 clr %i0 2006e70: 80 a2 20 04 cmp %o0, 4 2006e74: 02 80 00 06 be 2006e8c 2006e78: b0 10 20 06 mov 6, %i0 2006e7c: 80 a2 20 00 cmp %o0, 0 2006e80: 02 80 00 03 be 2006e8c 2006e84: b0 10 20 0b mov 0xb, %i0 2006e88: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 2006e8c: 03 00 80 74 sethi %hi(0x201d000), %g1 2006e90: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 ! 201d030 <_Thread_Dispatch_disable_level> 2006e94: 10 bf ff 73 b 2006c60 2006e98: 84 00 bf ff add %g2, -1, %g2 * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 2006e9c: 40 00 0f 04 call 200aaac <_Thread_Clear_state> <== NOT EXECUTED 2006ea0: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED 2006ea4: 30 bf ff ce b,a 2006ddc <== NOT EXECUTED 02006ea8 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 2006ea8: 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 ) 2006eac: 80 a6 60 00 cmp %i1, 0 2006eb0: 02 80 00 4e be 2006fe8 2006eb4: 90 10 00 18 mov %i0, %o0 return; (*print)( context, "Period information by period\n" ); 2006eb8: 13 00 80 6a sethi %hi(0x201a800), %o1 2006ebc: 9f c6 40 00 call %i1 2006ec0: 92 12 61 00 or %o1, 0x100, %o1 ! 201a900 #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 2006ec4: 90 10 00 18 mov %i0, %o0 2006ec8: 13 00 80 6a sethi %hi(0x201a800), %o1 2006ecc: 9f c6 40 00 call %i1 2006ed0: 92 12 61 20 or %o1, 0x120, %o1 ! 201a920 #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 2006ed4: 90 10 00 18 mov %i0, %o0 2006ed8: 13 00 80 6a sethi %hi(0x201a800), %o1 2006edc: 9f c6 40 00 call %i1 2006ee0: 92 12 61 48 or %o1, 0x148, %o1 ! 201a948 Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 2006ee4: 90 10 00 18 mov %i0, %o0 2006ee8: 13 00 80 6a sethi %hi(0x201a800), %o1 2006eec: 9f c6 40 00 call %i1 2006ef0: 92 12 61 70 or %o1, 0x170, %o1 ! 201a970 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 2006ef4: 90 10 00 18 mov %i0, %o0 2006ef8: 13 00 80 6a sethi %hi(0x201a800), %o1 2006efc: 9f c6 40 00 call %i1 2006f00: 92 12 61 c0 or %o1, 0x1c0, %o1 ! 201a9c0 /* * 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 ; 2006f04: 03 00 80 73 sethi %hi(0x201cc00), %g1 2006f08: a6 10 62 94 or %g1, 0x294, %l3 ! 201ce94 <_Rate_monotonic_Information> 2006f0c: e4 04 e0 08 ld [ %l3 + 8 ], %l2 id <= _Rate_monotonic_Information.maximum_id ; 2006f10: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 2006f14: 80 a4 80 01 cmp %l2, %g1 2006f18: 18 80 00 34 bgu 2006fe8 2006f1c: 03 00 80 6a sethi %hi(0x201a800), %g1 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 2006f20: 05 00 80 6a sethi %hi(0x201a800), %g2 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 2006f24: b6 10 62 10 or %g1, 0x210, %i3 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 2006f28: b8 10 a1 40 or %g2, 0x140, %i4 2006f2c: a8 07 bf 98 add %fp, -104, %l4 status = rtems_rate_monotonic_get_statistics( id, &the_stats ); if ( status != RTEMS_SUCCESSFUL ) continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 2006f30: aa 07 bf d0 add %fp, -48, %l5 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006f34: ba 07 bf b0 add %fp, -80, %i5 2006f38: ac 07 bf e8 add %fp, -24, %l6 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 2006f3c: b4 07 bf c8 add %fp, -56, %i2 2006f40: 10 80 00 06 b 2006f58 2006f44: ae 07 bf f3 add %fp, -13, %l7 * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 2006f48: 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 ; 2006f4c: 80 a0 40 12 cmp %g1, %l2 2006f50: 0a 80 00 26 bcs 2006fe8 2006f54: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 2006f58: 90 10 00 12 mov %l2, %o0 2006f5c: 40 00 1e 27 call 200e7f8 2006f60: 92 10 00 14 mov %l4, %o1 if ( status != RTEMS_SUCCESSFUL ) 2006f64: 80 a2 20 00 cmp %o0, 0 2006f68: 32 bf ff f8 bne,a 2006f48 2006f6c: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 2006f70: 92 10 00 15 mov %l5, %o1 2006f74: 40 00 1e 47 call 200e890 2006f78: 90 10 00 12 mov %l2, %o0 if ( status != RTEMS_SUCCESSFUL ) 2006f7c: 80 a2 20 00 cmp %o0, 0 2006f80: 32 bf ff f2 bne,a 2006f48 2006f84: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 <== NOT EXECUTED continue; name[ 0 ] = '\0'; if ( the_status.owner ) { 2006f88: d0 07 bf d0 ld [ %fp + -48 ], %o0 /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); if ( status != RTEMS_SUCCESSFUL ) continue; name[ 0 ] = '\0'; 2006f8c: c0 2f bf f3 clrb [ %fp + -13 ] if ( the_status.owner ) { 2006f90: 80 a2 20 00 cmp %o0, 0 2006f94: 12 80 00 4b bne 20070c0 2006f98: a0 10 00 17 mov %l7, %l0 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 2006f9c: d8 1f bf 98 ldd [ %fp + -104 ], %o4 <== NOT EXECUTED 2006fa0: 94 10 00 12 mov %l2, %o2 2006fa4: 92 10 00 1b mov %i3, %o1 2006fa8: 96 10 00 10 mov %l0, %o3 2006fac: 9f c6 40 00 call %i1 2006fb0: 90 10 00 18 mov %i0, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006fb4: c2 07 bf 98 ld [ %fp + -104 ], %g1 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006fb8: 94 10 00 16 mov %l6, %o2 2006fbc: 90 10 00 1d mov %i5, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006fc0: 80 a0 60 00 cmp %g1, 0 2006fc4: 12 80 00 0b bne 2006ff0 2006fc8: 92 10 00 1c mov %i4, %o1 (*print)( context, "\n" ); 2006fcc: 9f c6 40 00 call %i1 2006fd0: 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 ; 2006fd4: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 id++ ) { 2006fd8: 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 ; 2006fdc: 80 a0 40 12 cmp %g1, %l2 2006fe0: 1a bf ff df bcc 2006f5c 2006fe4: 90 10 00 12 mov %l2, %o0 2006fe8: 81 c7 e0 08 ret 2006fec: 81 e8 00 00 restore */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006ff0: 40 00 14 10 call 200c030 <_Timespec_Divide_by_integer> 2006ff4: 92 10 00 01 mov %g1, %o1 &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 2006ff8: d0 07 bf a4 ld [ %fp + -92 ], %o0 2006ffc: 40 00 46 b4 call 2018acc <.div> 2007000: 92 10 23 e8 mov 0x3e8, %o1 2007004: a2 10 00 08 mov %o0, %l1 2007008: d0 07 bf ac ld [ %fp + -84 ], %o0 200700c: 40 00 46 b0 call 2018acc <.div> 2007010: 92 10 23 e8 mov 0x3e8, %o1 2007014: c2 07 bf e8 ld [ %fp + -24 ], %g1 2007018: a0 10 00 08 mov %o0, %l0 200701c: d0 07 bf ec ld [ %fp + -20 ], %o0 2007020: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2007024: 40 00 46 aa call 2018acc <.div> 2007028: 92 10 23 e8 mov 0x3e8, %o1 200702c: d8 07 bf a8 ld [ %fp + -88 ], %o4 2007030: d4 07 bf a0 ld [ %fp + -96 ], %o2 2007034: 96 10 00 11 mov %l1, %o3 2007038: 9a 10 00 10 mov %l0, %o5 200703c: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 2007040: 13 00 80 6a sethi %hi(0x201a800), %o1 2007044: 90 10 00 18 mov %i0, %o0 2007048: 9f c6 40 00 call %i1 200704c: 92 12 62 28 or %o1, 0x228, %o1 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 2007050: d2 07 bf 98 ld [ %fp + -104 ], %o1 2007054: 94 10 00 16 mov %l6, %o2 2007058: 40 00 13 f6 call 200c030 <_Timespec_Divide_by_integer> 200705c: 90 10 00 1a mov %i2, %o0 &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 2007060: d0 07 bf bc ld [ %fp + -68 ], %o0 2007064: 40 00 46 9a call 2018acc <.div> 2007068: 92 10 23 e8 mov 0x3e8, %o1 200706c: a2 10 00 08 mov %o0, %l1 2007070: d0 07 bf c4 ld [ %fp + -60 ], %o0 2007074: 40 00 46 96 call 2018acc <.div> 2007078: 92 10 23 e8 mov 0x3e8, %o1 200707c: c2 07 bf e8 ld [ %fp + -24 ], %g1 2007080: a0 10 00 08 mov %o0, %l0 2007084: d0 07 bf ec ld [ %fp + -20 ], %o0 2007088: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 200708c: 40 00 46 90 call 2018acc <.div> 2007090: 92 10 23 e8 mov 0x3e8, %o1 2007094: d4 07 bf b8 ld [ %fp + -72 ], %o2 2007098: d8 07 bf c0 ld [ %fp + -64 ], %o4 200709c: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 20070a0: 96 10 00 11 mov %l1, %o3 20070a4: 9a 10 00 10 mov %l0, %o5 20070a8: 90 10 00 18 mov %i0, %o0 20070ac: 13 00 80 6a sethi %hi(0x201a800), %o1 20070b0: 9f c6 40 00 call %i1 20070b4: 92 12 62 48 or %o1, 0x248, %o1 ! 201aa48 /* * 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 ; 20070b8: 10 bf ff a4 b 2006f48 20070bc: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 continue; name[ 0 ] = '\0'; if ( the_status.owner ) { rtems_object_get_name( the_status.owner, sizeof(name), name ); 20070c0: 92 10 20 05 mov 5, %o1 20070c4: 40 00 00 8f call 2007300 20070c8: 94 10 00 17 mov %l7, %o2 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 20070cc: 10 bf ff b5 b 2006fa0 20070d0: d8 1f bf 98 ldd [ %fp + -104 ], %o4 020070f0 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 20070f0: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20070f4: 25 00 80 74 sethi %hi(0x201d000), %l2 20070f8: c2 04 a0 30 ld [ %l2 + 0x30 ], %g1 ! 201d030 <_Thread_Dispatch_disable_level> 20070fc: 82 00 60 01 inc %g1 2007100: c2 24 a0 30 st %g1, [ %l2 + 0x30 ] /* * 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 ; 2007104: 03 00 80 73 sethi %hi(0x201cc00), %g1 2007108: a2 10 62 94 or %g1, 0x294, %l1 ! 201ce94 <_Rate_monotonic_Information> 200710c: e0 04 60 08 ld [ %l1 + 8 ], %l0 id <= _Rate_monotonic_Information.maximum_id ; 2007110: c2 04 60 0c ld [ %l1 + 0xc ], %g1 2007114: 80 a4 00 01 cmp %l0, %g1 2007118: 18 80 00 09 bgu 200713c 200711c: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 2007120: 40 00 00 13 call 200716c 2007124: 90 10 00 10 mov %l0, %o0 /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 2007128: c2 04 60 0c ld [ %l1 + 0xc ], %g1 id++ ) { 200712c: 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 ; 2007130: 80 a0 40 10 cmp %g1, %l0 2007134: 1a bf ff fb bcc 2007120 2007138: 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 ) 200713c: c2 04 a0 30 ld [ %l2 + 0x30 ], %g1 2007140: 82 00 7f ff add %g1, -1, %g1 2007144: c2 24 a0 30 st %g1, [ %l2 + 0x30 ] 2007148: c4 04 a0 30 ld [ %l2 + 0x30 ], %g2 200714c: 80 a0 a0 00 cmp %g2, 0 2007150: 02 80 00 04 be 2007160 2007154: 01 00 00 00 nop 2007158: 81 c7 e0 08 ret <== NOT EXECUTED 200715c: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 2007160: 40 00 0f 14 call 200adb0 <_Thread_Dispatch> 2007164: 81 e8 00 00 restore 2007168: 01 00 00 00 nop 02010154 : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 2010154: 9d e3 bf 98 save %sp, -104, %sp Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 2010158: a8 96 20 00 orcc %i0, 0, %l4 201015c: 02 80 00 58 be 20102bc 2010160: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 2010164: 80 a6 60 00 cmp %i1, 0 2010168: 02 80 00 06 be 2010180 201016c: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 2010170: 02 80 00 04 be 2010180 2010174: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 2010178: 02 80 00 04 be 2010188 201017c: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2010180: 81 c7 e0 08 ret 2010184: 91 e8 20 09 restore %g0, 9, %o0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 2010188: 7f ff ea 5e call 200ab00 201018c: 01 00 00 00 nop 2010190: a2 10 00 08 mov %o0, %l1 2010194: 25 00 80 c8 sethi %hi(0x2032000), %l2 2010198: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 201019c: 80 a0 60 00 cmp %g1, 0 20101a0: 02 80 00 0b be 20101cc 20101a4: 03 00 80 c8 sethi %hi(0x2032000), %g1 20101a8: 03 00 80 c8 sethi %hi(0x2032000), %g1 <== NOT EXECUTED 20101ac: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20323a0 <_System_state_Current> <== NOT EXECUTED 20101b0: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 20101b4: 08 80 00 05 bleu 20101c8 <== NOT EXECUTED 20101b8: 90 10 20 00 clr %o0 <== NOT EXECUTED 20101bc: 92 10 20 00 clr %o1 <== NOT EXECUTED 20101c0: 40 00 13 56 call 2014f18 <_Internal_error_Occurred> <== NOT EXECUTED 20101c4: 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; 20101c8: 03 00 80 c8 sethi %hi(0x2032000), %g1 <== NOT EXECUTED 20101cc: 27 00 80 c8 sethi %hi(0x2032000), %l3 20101d0: c6 00 62 a0 ld [ %g1 + 0x2a0 ], %g3 20101d4: e0 04 e2 98 ld [ %l3 + 0x298 ], %l0 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20101d8: c0 20 e0 34 clr [ %g3 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 20101dc: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 20101e0: 80 a0 60 00 cmp %g1, 0 20101e4: 22 80 00 12 be,a 201022c 20101e8: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20101ec: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20101f0: c2 00 e0 08 ld [ %g3 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 20101f4: c4 04 20 58 ld [ %l0 + 0x58 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 20101f8: 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; 20101fc: 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; 2010200: c6 24 20 6c st %g3, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2010204: 80 a0 a0 02 cmp %g2, 2 2010208: 12 80 00 2f bne 20102c4 201020c: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2010210: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2010214: 82 00 60 01 inc %g1 2010218: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 201021c: 7f ff ea 3d call 200ab10 2010220: 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 ); 2010224: 10 80 00 0f b 2010260 2010228: 23 00 80 c7 sethi %hi(0x2031c00), %l1 /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 201022c: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 2010230: 32 80 00 48 bne,a 2010350 <== NOT EXECUTED 2010234: c4 04 20 08 ld [ %l0 + 8 ], %g2 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010238: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 201023c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010240: 12 80 00 41 bne 2010344 <== NOT EXECUTED 2010244: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2010248: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 201024c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010250: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010254: 7f ff ea 2f call 200ab10 <== NOT EXECUTED 2010258: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 201025c: 23 00 80 c7 sethi %hi(0x2031c00), %l1 <== NOT EXECUTED 2010260: 40 00 13 5b call 2014fcc <_Objects_Allocate> 2010264: 90 14 63 d8 or %l1, 0x3d8, %o0 ! 2031fd8 <_Region_Information> the_region = _Region_Allocate(); if ( !the_region ) { 2010268: a0 92 20 00 orcc %o0, 0, %l0 201026c: 32 80 00 4e bne,a 20103a4 2010270: 90 04 20 68 add %l0, 0x68, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010274: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 2010278: 82 00 60 01 inc %g1 201027c: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] _RTEMS_Unlock_allocator(); 2010280: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 2010284: 94 10 20 00 clr %o2 2010288: d2 02 20 08 ld [ %o0 + 8 ], %o1 201028c: 40 00 10 aa call 2014534 <_CORE_mutex_Surrender> 2010290: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010294: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 2010298: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 201029c: 82 00 7f ff add %g1, -1, %g1 20102a0: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] 20102a4: c4 04 a1 c0 ld [ %l2 + 0x1c0 ], %g2 20102a8: 80 a0 a0 00 cmp %g2, 0 20102ac: 12 80 00 04 bne 20102bc 20102b0: 01 00 00 00 nop 20102b4: 40 00 19 df call 2016a30 <_Thread_Dispatch> 20102b8: 01 00 00 00 nop 20102bc: 81 c7 e0 08 ret 20102c0: 81 e8 00 00 restore if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20102c4: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 20102c8: 12 bf ff d5 bne 201021c <== NOT EXECUTED 20102cc: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20102d0: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 20102d4: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20102d8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20102dc: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 20102e0: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED current = executing->current_priority; if ( current == ceiling ) { 20102e4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 20102e8: 02 80 00 4e be 2010420 <== NOT EXECUTED 20102ec: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 20102f0: 1a 80 00 42 bcc 20103f8 <== NOT EXECUTED 20102f4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20102f8: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 <== NOT EXECUTED 20102fc: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010300: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010304: 7f ff ea 03 call 200ab10 <== NOT EXECUTED 2010308: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 201030c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010310: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010314: 40 00 18 97 call 2016570 <_Thread_Change_priority> <== NOT EXECUTED 2010318: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201031c: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 <== NOT EXECUTED 2010320: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010324: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] <== NOT EXECUTED 2010328: c4 04 a1 c0 ld [ %l2 + 0x1c0 ], %g2 <== NOT EXECUTED 201032c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2010330: 12 bf ff cc bne 2010260 <== NOT EXECUTED 2010334: 23 00 80 c7 sethi %hi(0x2031c00), %l1 <== NOT EXECUTED _Thread_Dispatch(); 2010338: 40 00 19 be call 2016a30 <_Thread_Dispatch> <== NOT EXECUTED 201033c: 01 00 00 00 nop <== NOT EXECUTED 2010340: 30 bf ff c8 b,a 2010260 <== NOT EXECUTED * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010344: 02 80 00 13 be 2010390 <== NOT EXECUTED 2010348: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 201034c: c4 04 20 08 ld [ %l0 + 8 ], %g2 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010350: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 <== NOT EXECUTED 2010354: c4 20 e0 20 st %g2, [ %g3 + 0x20 ] <== NOT EXECUTED 2010358: 82 00 60 01 inc %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 201035c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 2010360: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] <== NOT EXECUTED 2010364: c4 24 20 40 st %g2, [ %l0 + 0x40 ] <== NOT EXECUTED 2010368: 82 04 20 10 add %l0, 0x10, %g1 <== NOT EXECUTED 201036c: c2 20 e0 44 st %g1, [ %g3 + 0x44 ] <== NOT EXECUTED 2010370: 7f ff e9 e8 call 200ab10 <== NOT EXECUTED 2010374: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010378: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 <== NOT EXECUTED 201037c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010380: 40 00 10 49 call 20144a4 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010384: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010388: 10 bf ff b6 b 2010260 <== NOT EXECUTED 201038c: 23 00 80 c7 sethi %hi(0x2031c00), %l1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2010390: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2010394: 7f ff e9 df call 200ab10 <== NOT EXECUTED 2010398: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 201039c: 10 bf ff b1 b 2010260 <== NOT EXECUTED 20103a0: 23 00 80 c7 sethi %hi(0x2031c00), %l1 <== NOT EXECUTED if ( !the_region ) { _RTEMS_Unlock_allocator(); return RTEMS_TOO_MANY; } the_region->maximum_segment_size = 20103a4: 92 10 00 19 mov %i1, %o1 20103a8: 94 10 00 1a mov %i2, %o2 20103ac: 40 00 12 8e call 2014de4 <_Heap_Initialize> 20103b0: 96 10 00 1b mov %i3, %o3 _Heap_Initialize(&the_region->Memory, starting_address, length, page_size); if ( !the_region->maximum_segment_size ) { 20103b4: 80 a2 20 00 cmp %o0, 0 20103b8: 12 80 00 1e bne 2010430 20103bc: 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 ); 20103c0: 90 14 63 d8 or %l1, 0x3d8, %o0 20103c4: 40 00 14 10 call 2015404 <_Objects_Free> 20103c8: 92 10 00 10 mov %l0, %o1 20103cc: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 20103d0: 82 00 60 01 inc %g1 20103d4: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 20103d8: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 20103dc: 94 10 20 00 clr %o2 20103e0: d2 02 20 08 ld [ %o0 + 8 ], %o1 20103e4: 40 00 10 54 call 2014534 <_CORE_mutex_Surrender> 20103e8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20103ec: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 20103f0: 10 bf ff ab b 201029c 20103f4: b0 10 20 08 mov 8, %i0 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20103f8: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20103fc: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2010400: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2010404: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 2010408: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 201040c: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2010410: 7f ff e9 c0 call 200ab10 <== NOT EXECUTED 2010414: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED * the inactive chain of free region control blocks. */ RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void ) { return (Region_Control *) _Objects_Allocate( &_Region_Information ); 2010418: 10 bf ff 92 b 2010260 <== NOT EXECUTED 201041c: 23 00 80 c7 sethi %hi(0x2031c00), %l1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2010420: 7f ff e9 bc call 200ab10 <== NOT EXECUTED 2010424: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010428: 10 bf ff 8e b 2010260 <== NOT EXECUTED 201042c: 23 00 80 c7 sethi %hi(0x2031c00), %l1 <== NOT EXECUTED the_region->length = length; the_region->page_size = page_size; the_region->attribute_set = attribute_set; the_region->number_of_used_blocks = 0; _Thread_queue_Initialize( 2010430: 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; 2010434: f2 24 20 50 st %i1, [ %l0 + 0x50 ] the_region->length = length; 2010438: f4 24 20 54 st %i2, [ %l0 + 0x54 ] the_region->page_size = page_size; 201043c: f6 24 20 58 st %i3, [ %l0 + 0x58 ] the_region->attribute_set = attribute_set; 2010440: f8 24 20 60 st %i4, [ %l0 + 0x60 ] the_region->number_of_used_blocks = 0; 2010444: c0 24 20 64 clr [ %l0 + 0x64 ] _Thread_queue_Initialize( 2010448: 93 37 20 02 srl %i4, 2, %o1 201044c: 94 10 20 40 mov 0x40, %o2 2010450: 92 0a 60 01 and %o1, 1, %o1 2010454: 40 00 1c 1e call 20174cc <_Thread_queue_Initialize> 2010458: 96 10 20 06 mov 6, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 201045c: 90 14 63 d8 or %l1, 0x3d8, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2010460: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2010464: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2010468: 03 00 00 3f sethi %hi(0xfc00), %g1 201046c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2010470: 82 08 c0 01 and %g3, %g1, %g1 2010474: 80 a0 40 02 cmp %g1, %g2 2010478: 38 80 00 06 bgu,a 2010490 201047c: c6 27 40 00 st %g3, [ %i5 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2010480: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2010484: 83 28 60 02 sll %g1, 2, %g1 2010488: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 201048c: c6 27 40 00 st %g3, [ %i5 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010490: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %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; 2010494: e8 24 20 0c st %l4, [ %l0 + 0xc ] 2010498: 82 00 60 01 inc %g1 201049c: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] _RTEMS_Unlock_allocator(); 20104a0: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 20104a4: 94 10 20 00 clr %o2 20104a8: d2 02 20 08 ld [ %o0 + 8 ], %o1 20104ac: 40 00 10 22 call 2014534 <_CORE_mutex_Surrender> 20104b0: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20104b4: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 20104b8: 10 bf ff 79 b 201029c 20104bc: b0 10 20 00 clr %i0 020104c0 : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 20104c0: 9d e3 bf 90 save %sp, -112, %sp register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 20104c4: 7f ff e9 8f call 200ab00 20104c8: 01 00 00 00 nop 20104cc: a2 10 00 08 mov %o0, %l1 20104d0: 25 00 80 c8 sethi %hi(0x2032000), %l2 20104d4: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 20104d8: 80 a0 60 00 cmp %g1, 0 20104dc: 02 80 00 0b be 2010508 20104e0: 27 00 80 c8 sethi %hi(0x2032000), %l3 20104e4: 03 00 80 c8 sethi %hi(0x2032000), %g1 <== NOT EXECUTED 20104e8: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20323a0 <_System_state_Current> <== NOT EXECUTED 20104ec: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 20104f0: 08 80 00 06 bleu 2010508 <== NOT EXECUTED 20104f4: 90 10 20 00 clr %o0 <== NOT EXECUTED 20104f8: 92 10 20 00 clr %o1 <== NOT EXECUTED 20104fc: 40 00 12 87 call 2014f18 <_Internal_error_Occurred> <== NOT EXECUTED 2010500: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2010504: 27 00 80 c8 sethi %hi(0x2032000), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2010508: 09 00 80 c8 sethi %hi(0x2032000), %g4 201050c: e0 04 e2 98 ld [ %l3 + 0x298 ], %l0 2010510: c4 01 22 a0 ld [ %g4 + 0x2a0 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2010514: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2010518: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 201051c: 80 a0 60 00 cmp %g1, 0 2010520: 22 80 00 36 be,a 20105f8 2010524: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2010528: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 201052c: 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; 2010530: 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; 2010534: 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; 2010538: 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; 201053c: 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 ) || 2010540: 80 a0 e0 02 cmp %g3, 2 2010544: 12 80 00 56 bne 201069c 2010548: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 201054c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010550: 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++; 2010554: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010558: 02 80 00 7c be 2010748 201055c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 2010560: 7f ff e9 6c call 200ab10 2010564: 90 10 00 11 mov %l1, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 2010568: 92 10 00 18 mov %i0, %o1 201056c: 21 00 80 c7 sethi %hi(0x2031c00), %l0 2010570: 94 07 bf f4 add %fp, -12, %o2 2010574: 40 00 13 e7 call 2015510 <_Objects_Get_no_protection> 2010578: 90 14 23 d8 or %l0, 0x3d8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 201057c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2010580: 80 a0 60 01 cmp %g1, 1 2010584: 02 80 00 33 be 2010650 2010588: 92 10 00 08 mov %o0, %o1 201058c: 80 a0 60 01 cmp %g1, 1 2010590: 1a 80 00 5f bcc 201070c 2010594: 80 a0 60 02 cmp %g1, 2 _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks == 0 ) { 2010598: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 201059c: 80 a0 60 00 cmp %g1, 0 20105a0: 22 80 00 99 be,a 2010804 20105a4: 90 14 23 d8 or %l0, 0x3d8, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20105a8: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 20105ac: 82 00 60 01 inc %g1 20105b0: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } _RTEMS_Unlock_allocator(); 20105b4: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 20105b8: 94 10 20 00 clr %o2 20105bc: d2 02 20 08 ld [ %o0 + 8 ], %o1 20105c0: 40 00 0f dd call 2014534 <_CORE_mutex_Surrender> 20105c4: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20105c8: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 20105cc: b0 10 20 0c mov 0xc, %i0 20105d0: 82 00 7f ff add %g1, -1, %g1 20105d4: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] 20105d8: c4 04 a1 c0 ld [ %l2 + 0x1c0 ], %g2 20105dc: 80 a0 a0 00 cmp %g2, 0 20105e0: 12 80 00 49 bne 2010704 20105e4: 01 00 00 00 nop _Thread_Dispatch(); 20105e8: 40 00 19 12 call 2016a30 <_Thread_Dispatch> 20105ec: 01 00 00 00 nop 20105f0: 81 c7 e0 08 ret 20105f4: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 20105f8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20105fc: 12 80 00 30 bne 20106bc <== NOT EXECUTED 2010600: c6 04 e2 98 ld [ %l3 + 0x298 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010604: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2010608: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201060c: 22 80 00 6a be,a 20107b4 <== NOT EXECUTED 2010610: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2010614: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010618: 12 80 00 29 bne 20106bc <== NOT EXECUTED 201061c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2010620: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2010624: 7f ff e9 3b call 200ab10 <== NOT EXECUTED 2010628: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 201062c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2010630: 21 00 80 c7 sethi %hi(0x2031c00), %l0 <== NOT EXECUTED 2010634: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 2010638: 40 00 13 b6 call 2015510 <_Objects_Get_no_protection> <== NOT EXECUTED 201063c: 90 14 23 d8 or %l0, 0x3d8, %o0 <== NOT EXECUTED register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 2010640: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2010644: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010648: 12 bf ff d2 bne 2010590 <== NOT EXECUTED 201064c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010650: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 <== NOT EXECUTED 2010654: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010658: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 201065c: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 <== NOT EXECUTED 2010660: 94 10 20 00 clr %o2 <== NOT EXECUTED 2010664: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2010668: 40 00 0f b3 call 2014534 <_CORE_mutex_Surrender> <== NOT EXECUTED 201066c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010670: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 <== NOT EXECUTED 2010674: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010678: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] <== NOT EXECUTED 201067c: c4 04 a1 c0 ld [ %l2 + 0x1c0 ], %g2 <== NOT EXECUTED 2010680: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2010684: 12 80 00 24 bne 2010714 <== NOT EXECUTED 2010688: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 201068c: 40 00 18 e9 call 2016a30 <_Thread_Dispatch> <== NOT EXECUTED 2010690: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 2010694: 81 c7 e0 08 ret <== NOT EXECUTED 2010698: 81 e8 00 00 restore <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 201069c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20106a0: 12 bf ff b0 bne 2010560 <== NOT EXECUTED 20106a4: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20106a8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20106ac: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20106b0: 02 80 00 26 be 2010748 <== NOT EXECUTED 20106b4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 20106b8: 30 bf ff aa b,a 2010560 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20106bc: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 <== NOT EXECUTED ) { register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 20106c0: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 20106c4: c8 01 22 a0 ld [ %g4 + 0x2a0 ], %g4 <== NOT EXECUTED 20106c8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20106cc: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 20106d0: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] <== NOT EXECUTED 20106d4: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 20106d8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20106dc: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 20106e0: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 20106e4: 7f ff e9 0b call 200ab10 <== NOT EXECUTED 20106e8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20106ec: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 <== NOT EXECUTED 20106f0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20106f4: 40 00 0f 6c call 20144a4 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 20106f8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 20106fc: 10 bf ff 9c b 201056c <== NOT EXECUTED 2010700: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _RTEMS_Unlock_allocator(); return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2010704: 81 c7 e0 08 ret <== NOT EXECUTED 2010708: 81 e8 00 00 restore <== NOT EXECUTED register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 201070c: 02 80 00 04 be 201071c 2010710: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2010714: 81 c7 e0 08 ret <== NOT EXECUTED 2010718: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 201071c: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 2010720: 82 00 60 01 inc %g1 2010724: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2010728: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 201072c: 94 10 20 00 clr %o2 2010730: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010734: 40 00 0f 80 call 2014534 <_CORE_mutex_Surrender> 2010738: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201073c: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 2010740: 10 bf ff a4 b 20105d0 2010744: b0 10 20 04 mov 4, %i0 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2010748: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 201074c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2010750: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010754: 02 80 00 28 be 20107f4 <== NOT EXECUTED 2010758: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 201075c: 1a 80 00 1c bcc 20107cc <== NOT EXECUTED 2010760: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010764: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 <== NOT EXECUTED 2010768: 82 00 60 01 inc %g1 <== NOT EXECUTED 201076c: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010770: 7f ff e8 e8 call 200ab10 <== NOT EXECUTED 2010774: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2010778: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 201077c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010780: 40 00 17 7c call 2016570 <_Thread_Change_priority> <== NOT EXECUTED 2010784: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010788: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 <== NOT EXECUTED 201078c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010790: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] <== NOT EXECUTED 2010794: c4 04 a1 c0 ld [ %l2 + 0x1c0 ], %g2 <== NOT EXECUTED 2010798: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 201079c: 32 bf ff 74 bne,a 201056c <== NOT EXECUTED 20107a0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _Thread_Dispatch(); 20107a4: 40 00 18 a3 call 2016a30 <_Thread_Dispatch> <== NOT EXECUTED 20107a8: 01 00 00 00 nop <== NOT EXECUTED 20107ac: 10 bf ff 70 b 201056c <== NOT EXECUTED 20107b0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 20107b4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20107b8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 20107bc: 7f ff e8 d5 call 200ab10 <== NOT EXECUTED 20107c0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20107c4: 10 bf ff 6a b 201056c <== NOT EXECUTED 20107c8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20107cc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20107d0: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20107d4: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 20107d8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20107dc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20107e0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20107e4: 7f ff e8 cb call 200ab10 <== NOT EXECUTED 20107e8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20107ec: 10 bf ff 60 b 201056c <== NOT EXECUTED 20107f0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 20107f4: 7f ff e8 c7 call 200ab10 <== NOT EXECUTED 20107f8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20107fc: 10 bf ff 5c b 201056c <== NOT EXECUTED 2010800: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2010804: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2010808: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 201080c: 05 00 00 3f sethi %hi(0xfc00), %g2 2010810: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2010814: 82 08 40 02 and %g1, %g2, %g1 2010818: 80 a0 40 03 cmp %g1, %g3 201081c: 18 80 00 05 bgu 2010830 2010820: 01 00 00 00 nop information->local_table[ index ] = the_object; 2010824: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2010828: 83 28 60 02 sll %g1, 2, %g1 201082c: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 2010830: 40 00 12 f5 call 2015404 <_Objects_Free> 2010834: c0 22 60 0c clr [ %o1 + 0xc ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010838: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 201083c: 82 00 60 01 inc %g1 2010840: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks == 0 ) { _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 2010844: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 2010848: 94 10 20 00 clr %o2 201084c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010850: 40 00 0f 39 call 2014534 <_CORE_mutex_Surrender> 2010854: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010858: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 201085c: 10 bf ff 5d b 20105d0 2010860: b0 10 20 00 clr %i0 02010864 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 2010864: 9d e3 bf 90 save %sp, -112, %sp 2010868: a8 10 00 18 mov %i0, %l4 Objects_Locations location; uint32_t amount_extended; Heap_Extend_status heap_status; rtems_status_code status; if ( !starting_address ) 201086c: 80 a6 60 00 cmp %i1, 0 2010870: 02 80 00 59 be 20109d4 2010874: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 2010878: 7f ff e8 a2 call 200ab00 201087c: 01 00 00 00 nop 2010880: a4 10 00 08 mov %o0, %l2 2010884: 23 00 80 c8 sethi %hi(0x2032000), %l1 2010888: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 201088c: 80 a0 60 00 cmp %g1, 0 2010890: 02 80 00 0b be 20108bc 2010894: 27 00 80 c8 sethi %hi(0x2032000), %l3 2010898: 03 00 80 c8 sethi %hi(0x2032000), %g1 <== NOT EXECUTED 201089c: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20323a0 <_System_state_Current> <== NOT EXECUTED 20108a0: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 20108a4: 08 80 00 06 bleu 20108bc <== NOT EXECUTED 20108a8: 90 10 20 00 clr %o0 <== NOT EXECUTED 20108ac: 92 10 20 00 clr %o1 <== NOT EXECUTED 20108b0: 40 00 11 9a call 2014f18 <_Internal_error_Occurred> <== NOT EXECUTED 20108b4: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 20108b8: 27 00 80 c8 sethi %hi(0x2032000), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 20108bc: 09 00 80 c8 sethi %hi(0x2032000), %g4 20108c0: e0 04 e2 98 ld [ %l3 + 0x298 ], %l0 20108c4: c4 01 22 a0 ld [ %g4 + 0x2a0 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20108c8: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 20108cc: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 20108d0: 80 a0 60 00 cmp %g1, 0 20108d4: 22 80 00 42 be,a 20109dc 20108d8: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20108dc: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20108e0: 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; 20108e4: 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; 20108e8: 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; 20108ec: 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; 20108f0: 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 ) || 20108f4: 80 a0 e0 02 cmp %g3, 2 20108f8: 02 80 00 61 be 2010a7c 20108fc: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 2010900: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2010904: 22 80 00 60 be,a 2010a84 <== NOT EXECUTED 2010908: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 201090c: 7f ff e8 81 call 200ab10 2010910: 90 10 00 12 mov %l2, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 2010914: 92 10 00 14 mov %l4, %o1 2010918: 11 00 80 c7 sethi %hi(0x2031c00), %o0 201091c: 94 07 bf f4 add %fp, -12, %o2 2010920: 40 00 12 fc call 2015510 <_Objects_Get_no_protection> 2010924: 90 12 23 d8 or %o0, 0x3d8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 2010928: c2 07 bf f4 ld [ %fp + -12 ], %g1 201092c: 80 a0 60 01 cmp %g1, 1 2010930: 02 80 00 40 be 2010a30 2010934: a0 10 00 08 mov %o0, %l0 2010938: 80 a0 60 01 cmp %g1, 1 201093c: 1a 80 00 70 bcc 2010afc 2010940: 80 a0 60 02 cmp %g1, 2 _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: heap_status = _Heap_Extend( 2010944: 92 10 00 19 mov %i1, %o1 2010948: 94 10 00 1a mov %i2, %o2 201094c: 90 02 20 68 add %o0, 0x68, %o0 2010950: 96 07 bf f0 add %fp, -16, %o3 2010954: 40 00 10 3e call 2014a4c <_Heap_Extend> 2010958: b0 10 20 09 mov 9, %i0 starting_address, length, &amount_extended ); switch ( heap_status ) { 201095c: 80 a2 20 01 cmp %o0, 1 2010960: 02 80 00 0c be 2010990 2010964: 01 00 00 00 nop 2010968: 1a 80 00 8e bcc 2010ba0 201096c: 82 1a 20 02 xor %o0, 2, %g1 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 2010970: c6 07 bf f0 ld [ %fp + -16 ], %g3 2010974: c4 04 20 54 ld [ %l0 + 0x54 ], %g2 the_region->maximum_segment_size += amount_extended; 2010978: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 201097c: 84 00 80 03 add %g2, %g3, %g2 the_region->maximum_segment_size += amount_extended; 2010980: 82 00 40 03 add %g1, %g3, %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 2010984: c4 24 20 54 st %g2, [ %l0 + 0x54 ] the_region->maximum_segment_size += amount_extended; 2010988: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 201098c: b0 10 20 00 clr %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010990: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2010994: 82 00 60 01 inc %g1 2010998: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] break; case HEAP_EXTEND_NOT_IMPLEMENTED: status = RTEMS_NOT_IMPLEMENTED; break; } _RTEMS_Unlock_allocator(); 201099c: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 20109a0: 94 10 20 00 clr %o2 20109a4: d2 02 20 08 ld [ %o0 + 8 ], %o1 20109a8: 40 00 0e e3 call 2014534 <_CORE_mutex_Surrender> 20109ac: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20109b0: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 20109b4: 82 00 7f ff add %g1, -1, %g1 20109b8: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 20109bc: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 20109c0: 80 a0 a0 00 cmp %g2, 0 20109c4: 12 80 00 2c bne 2010a74 20109c8: 01 00 00 00 nop _Thread_Dispatch(); 20109cc: 40 00 18 19 call 2016a30 <_Thread_Dispatch> 20109d0: 01 00 00 00 nop 20109d4: 81 c7 e0 08 ret 20109d8: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 20109dc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20109e0: 12 80 00 4d bne 2010b14 <== NOT EXECUTED 20109e4: c6 04 e2 98 ld [ %l3 + 0x298 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20109e8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 20109ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20109f0: 12 80 00 47 bne 2010b0c <== NOT EXECUTED 20109f4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 20109f8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 20109fc: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010a00: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010a04: 7f ff e8 43 call 200ab10 <== NOT EXECUTED 2010a08: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010a0c: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 2010a10: 11 00 80 c7 sethi %hi(0x2031c00), %o0 <== NOT EXECUTED 2010a14: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 2010a18: 40 00 12 be call 2015510 <_Objects_Get_no_protection> <== NOT EXECUTED 2010a1c: 90 12 23 d8 or %o0, 0x3d8, %o0 <== NOT EXECUTED status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 2010a20: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2010a24: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010a28: 12 bf ff c5 bne 201093c <== NOT EXECUTED 2010a2c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010a30: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 2010a34: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010a38: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 2010a3c: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 <== NOT EXECUTED 2010a40: 94 10 20 00 clr %o2 <== NOT EXECUTED 2010a44: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2010a48: 40 00 0e bb call 2014534 <_CORE_mutex_Surrender> <== NOT EXECUTED 2010a4c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010a50: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 2010a54: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010a58: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED 2010a5c: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 <== NOT EXECUTED 2010a60: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2010a64: 12 80 00 28 bne 2010b04 <== NOT EXECUTED 2010a68: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 2010a6c: 40 00 17 f1 call 2016a30 <_Thread_Dispatch> <== NOT EXECUTED 2010a70: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 2010a74: 81 c7 e0 08 ret <== NOT EXECUTED 2010a78: 81 e8 00 00 restore <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2010a7c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010a80: 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++; 2010a84: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010a88: 12 bf ff a1 bne 201090c 2010a8c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2010a90: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 2010a94: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2010a98: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010a9c: 02 80 00 50 be 2010bdc <== NOT EXECUTED 2010aa0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2010aa4: 1a 80 00 44 bcc 2010bb4 <== NOT EXECUTED 2010aa8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010aac: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 2010ab0: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010ab4: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010ab8: 7f ff e8 16 call 200ab10 <== NOT EXECUTED 2010abc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 2010ac0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010ac4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010ac8: 40 00 16 aa call 2016570 <_Thread_Change_priority> <== NOT EXECUTED 2010acc: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010ad0: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 2010ad4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010ad8: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED 2010adc: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 <== NOT EXECUTED 2010ae0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2010ae4: 32 bf ff 8d bne,a 2010918 <== NOT EXECUTED 2010ae8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED _Thread_Dispatch(); 2010aec: 40 00 17 d1 call 2016a30 <_Thread_Dispatch> <== NOT EXECUTED 2010af0: 01 00 00 00 nop <== NOT EXECUTED 2010af4: 10 bf ff 89 b 2010918 <== NOT EXECUTED 2010af8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 2010afc: 02 80 00 18 be 2010b5c 2010b00: 01 00 00 00 nop 2010b04: 81 c7 e0 08 ret <== NOT EXECUTED 2010b08: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010b0c: 02 80 00 1f be 2010b88 <== NOT EXECUTED 2010b10: c6 04 e2 98 ld [ %l3 + 0x298 ], %g3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010b14: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED if ( !starting_address ) return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 2010b18: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2010b1c: c8 01 22 a0 ld [ %g4 + 0x2a0 ], %g4 <== NOT EXECUTED 2010b20: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010b24: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2010b28: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED 2010b2c: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 2010b30: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2010b34: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2010b38: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2010b3c: 7f ff e7 f5 call 200ab10 <== NOT EXECUTED 2010b40: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010b44: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 <== NOT EXECUTED 2010b48: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010b4c: 40 00 0e 56 call 20144a4 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010b50: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010b54: 10 bf ff 71 b 2010918 <== NOT EXECUTED 2010b58: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 2010b5c: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2010b60: 82 00 60 01 inc %g1 2010b64: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2010b68: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 2010b6c: 94 10 20 00 clr %o2 2010b70: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010b74: 40 00 0e 70 call 2014534 <_CORE_mutex_Surrender> 2010b78: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010b7c: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2010b80: 10 bf ff 8d b 20109b4 2010b84: b0 10 20 04 mov 4, %i0 case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2010b88: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2010b8c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2010b90: 7f ff e7 e0 call 200ab10 <== NOT EXECUTED 2010b94: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010b98: 10 bf ff 60 b 2010918 <== NOT EXECUTED 2010b9c: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 2010ba0: 80 a0 00 01 cmp %g0, %g1 2010ba4: 84 60 20 00 subx %g0, 0, %g2 2010ba8: b0 08 bf e8 and %g2, -24, %i0 2010bac: 10 bf ff 79 b 2010990 2010bb0: b0 06 20 18 add %i0, 0x18, %i0 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2010bb4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2010bb8: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2010bbc: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2010bc0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2010bc4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010bc8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2010bcc: 7f ff e7 d1 call 200ab10 <== NOT EXECUTED 2010bd0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010bd4: 10 bf ff 51 b 2010918 <== NOT EXECUTED 2010bd8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2010bdc: 7f ff e7 cd call 200ab10 <== NOT EXECUTED 2010be0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010be4: 10 bf ff 4d b 2010918 <== NOT EXECUTED 2010be8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 02010bec : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 2010bec: 9d e3 bf 90 save %sp, -112, %sp 2010bf0: aa 10 00 18 mov %i0, %l5 register Region_Control *the_region; Objects_Locations location; Thread_Control *executing; void *the_segment; if ( !segment ) 2010bf4: 80 a7 20 00 cmp %i4, 0 2010bf8: 02 80 00 4e be 2010d30 2010bfc: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; *segment = NULL; if ( size == 0 ) 2010c00: 80 a6 60 00 cmp %i1, 0 2010c04: 02 80 00 c8 be 2010f24 2010c08: c0 27 00 00 clr [ %i4 ] return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 2010c0c: 7f ff e7 bd call 200ab00 2010c10: 01 00 00 00 nop 2010c14: a4 10 00 08 mov %o0, %l2 2010c18: 23 00 80 c8 sethi %hi(0x2032000), %l1 2010c1c: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 2010c20: 80 a0 60 00 cmp %g1, 0 2010c24: 02 80 00 0b be 2010c50 2010c28: 29 00 80 c8 sethi %hi(0x2032000), %l4 2010c2c: 03 00 80 c8 sethi %hi(0x2032000), %g1 <== NOT EXECUTED 2010c30: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20323a0 <_System_state_Current> <== NOT EXECUTED 2010c34: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2010c38: 08 80 00 06 bleu 2010c50 <== NOT EXECUTED 2010c3c: 90 10 20 00 clr %o0 <== NOT EXECUTED 2010c40: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010c44: 40 00 10 b5 call 2014f18 <_Internal_error_Occurred> <== NOT EXECUTED 2010c48: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2010c4c: 29 00 80 c8 sethi %hi(0x2032000), %l4 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2010c50: 27 00 80 c8 sethi %hi(0x2032000), %l3 2010c54: e0 05 22 98 ld [ %l4 + 0x298 ], %l0 2010c58: c4 04 e2 a0 ld [ %l3 + 0x2a0 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2010c5c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2010c60: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2010c64: 80 a0 60 00 cmp %g1, 0 2010c68: 22 80 00 34 be,a 2010d38 2010c6c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2010c70: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2010c74: 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; 2010c78: 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; 2010c7c: 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; 2010c80: 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; 2010c84: 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 ) || 2010c88: 80 a0 e0 02 cmp %g3, 2 2010c8c: 02 80 00 54 be 2010ddc 2010c90: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 2010c94: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2010c98: 22 80 00 53 be,a 2010de4 <== NOT EXECUTED 2010c9c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 2010ca0: 7f ff e7 9c call 200ab10 2010ca4: 90 10 00 12 mov %l2, %o0 executing = _Thread_Executing; 2010ca8: f0 04 e2 a0 ld [ %l3 + 0x2a0 ], %i0 2010cac: 11 00 80 c7 sethi %hi(0x2031c00), %o0 2010cb0: 92 10 00 15 mov %l5, %o1 2010cb4: 90 12 23 d8 or %o0, 0x3d8, %o0 2010cb8: 40 00 12 16 call 2015510 <_Objects_Get_no_protection> 2010cbc: 94 07 bf f4 add %fp, -12, %o2 the_region = _Region_Get( id, &location ); switch ( location ) { 2010cc0: c2 07 bf f4 ld [ %fp + -12 ], %g1 2010cc4: 80 a0 60 01 cmp %g1, 1 2010cc8: 02 80 00 32 be 2010d90 2010ccc: a0 10 00 08 mov %o0, %l0 2010cd0: 80 a0 60 01 cmp %g1, 1 2010cd4: 1a 80 00 62 bcc 2010e5c 2010cd8: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) { 2010cdc: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 2010ce0: 80 a6 40 01 cmp %i1, %g1 2010ce4: 28 80 00 a0 bleu,a 2010f64 2010ce8: 90 02 20 68 add %o0, 0x68, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010cec: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2010cf0: 82 00 60 01 inc %g1 2010cf4: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] _RTEMS_Unlock_allocator(); 2010cf8: d0 05 22 98 ld [ %l4 + 0x298 ], %o0 2010cfc: 94 10 20 00 clr %o2 2010d00: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010d04: 40 00 0e 0c call 2014534 <_CORE_mutex_Surrender> 2010d08: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010d0c: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2010d10: 82 00 7f ff add %g1, -1, %g1 2010d14: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 2010d18: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 2010d1c: 80 a0 a0 00 cmp %g2, 0 2010d20: 12 80 00 81 bne 2010f24 2010d24: 01 00 00 00 nop _Thread_Dispatch(); 2010d28: 40 00 17 42 call 2016a30 <_Thread_Dispatch> 2010d2c: b0 10 20 08 mov 8, %i0 ! 8 2010d30: 81 c7 e0 08 ret 2010d34: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2010d38: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2010d3c: 12 80 00 4e bne 2010e74 <== NOT EXECUTED 2010d40: c6 05 22 98 ld [ %l4 + 0x298 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010d44: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2010d48: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010d4c: 12 80 00 48 bne 2010e6c <== NOT EXECUTED 2010d50: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2010d54: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2010d58: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010d5c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010d60: 7f ff e7 6c call 200ab10 <== NOT EXECUTED 2010d64: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010d68: 11 00 80 c7 sethi %hi(0x2031c00), %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 2010d6c: f0 04 e2 a0 ld [ %l3 + 0x2a0 ], %i0 <== NOT EXECUTED 2010d70: 90 12 23 d8 or %o0, 0x3d8, %o0 <== NOT EXECUTED 2010d74: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED 2010d78: 40 00 11 e6 call 2015510 <_Objects_Get_no_protection> <== NOT EXECUTED 2010d7c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 2010d80: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2010d84: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010d88: 12 bf ff d3 bne 2010cd4 <== NOT EXECUTED 2010d8c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010d90: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 2010d94: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010d98: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 2010d9c: d0 05 22 98 ld [ %l4 + 0x298 ], %o0 <== NOT EXECUTED 2010da0: 94 10 20 00 clr %o2 <== NOT EXECUTED 2010da4: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2010da8: 40 00 0d e3 call 2014534 <_CORE_mutex_Surrender> <== NOT EXECUTED 2010dac: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010db0: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 2010db4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010db8: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED 2010dbc: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 <== NOT EXECUTED 2010dc0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2010dc4: 12 80 00 28 bne 2010e64 <== NOT EXECUTED 2010dc8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 2010dcc: 40 00 17 19 call 2016a30 <_Thread_Dispatch> <== NOT EXECUTED 2010dd0: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 2010dd4: 81 c7 e0 08 ret <== NOT EXECUTED 2010dd8: 81 e8 00 00 restore <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2010ddc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010de0: 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++; 2010de4: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010de8: 12 bf ff ae bne 2010ca0 2010dec: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2010df0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 2010df4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2010df8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010dfc: 02 80 00 56 be 2010f54 <== NOT EXECUTED 2010e00: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2010e04: 1a 80 00 4a bcc 2010f2c <== NOT EXECUTED 2010e08: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010e0c: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 2010e10: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010e14: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010e18: 7f ff e7 3e call 200ab10 <== NOT EXECUTED 2010e1c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 2010e20: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010e24: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010e28: 40 00 15 d2 call 2016570 <_Thread_Change_priority> <== NOT EXECUTED 2010e2c: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010e30: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 2010e34: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010e38: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED 2010e3c: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 <== NOT EXECUTED 2010e40: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2010e44: 32 bf ff 9a bne,a 2010cac <== NOT EXECUTED 2010e48: f0 04 e2 a0 ld [ %l3 + 0x2a0 ], %i0 <== NOT EXECUTED _Thread_Dispatch(); 2010e4c: 40 00 16 f9 call 2016a30 <_Thread_Dispatch> <== NOT EXECUTED 2010e50: 01 00 00 00 nop <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 2010e54: 10 bf ff 96 b 2010cac <== NOT EXECUTED 2010e58: f0 04 e2 a0 ld [ %l3 + 0x2a0 ], %i0 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 2010e5c: 02 80 00 18 be 2010ebc 2010e60: 01 00 00 00 nop _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 2010e64: 81 c7 e0 08 ret <== NOT EXECUTED 2010e68: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010e6c: 02 80 00 28 be 2010f0c <== NOT EXECUTED 2010e70: c6 05 22 98 ld [ %l4 + 0x298 ], %g3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010e74: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 2010e78: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2010e7c: c8 04 e2 a0 ld [ %l3 + 0x2a0 ], %g4 <== NOT EXECUTED 2010e80: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010e84: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2010e88: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED 2010e8c: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 2010e90: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2010e94: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2010e98: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2010e9c: 7f ff e7 1d call 200ab10 <== NOT EXECUTED 2010ea0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010ea4: d0 05 22 98 ld [ %l4 + 0x298 ], %o0 <== NOT EXECUTED 2010ea8: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010eac: 40 00 0d 7e call 20144a4 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010eb0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED executing = _Thread_Executing; 2010eb4: 10 bf ff 7e b 2010cac <== NOT EXECUTED 2010eb8: f0 04 e2 a0 ld [ %l3 + 0x2a0 ], %i0 <== NOT EXECUTED 2010ebc: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2010ec0: 82 00 60 01 inc %g1 2010ec4: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2010ec8: d0 05 22 98 ld [ %l4 + 0x298 ], %o0 2010ecc: 94 10 20 00 clr %o2 2010ed0: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010ed4: 40 00 0d 98 call 2014534 <_CORE_mutex_Surrender> 2010ed8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010edc: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2010ee0: b0 10 20 04 mov 4, %i0 _Thread_Dispatch(); 2010ee4: 82 00 7f ff add %g1, -1, %g1 2010ee8: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 2010eec: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 2010ef0: 80 a0 a0 00 cmp %g2, 0 2010ef4: 12 80 00 6d bne 20110a8 2010ef8: 01 00 00 00 nop 2010efc: 40 00 16 cd call 2016a30 <_Thread_Dispatch> 2010f00: 01 00 00 00 nop 2010f04: 81 c7 e0 08 ret 2010f08: 81 e8 00 00 restore case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2010f0c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2010f10: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2010f14: 7f ff e6 ff call 200ab10 <== NOT EXECUTED 2010f18: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 2010f1c: 10 bf ff 64 b 2010cac <== NOT EXECUTED 2010f20: f0 04 e2 a0 ld [ %l3 + 0x2a0 ], %i0 <== NOT EXECUTED _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 2010f24: 81 c7 e0 08 ret <== NOT EXECUTED 2010f28: 91 e8 20 08 restore %g0, 8, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2010f2c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2010f30: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2010f34: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2010f38: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2010f3c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010f40: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2010f44: 7f ff e6 f3 call 200ab10 <== NOT EXECUTED 2010f48: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 2010f4c: 10 bf ff 58 b 2010cac <== NOT EXECUTED 2010f50: f0 04 e2 a0 ld [ %l3 + 0x2a0 ], %i0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2010f54: 7f ff e6 ef call 200ab10 <== NOT EXECUTED 2010f58: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010f5c: 10 bf ff 54 b 2010cac <== NOT EXECUTED 2010f60: f0 04 e2 a0 ld [ %l3 + 0x2a0 ], %i0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 2010f64: 40 00 0e 88 call 2014984 <_Heap_Allocate> 2010f68: 92 10 00 19 mov %i1, %o1 the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 2010f6c: a4 92 20 00 orcc %o0, 0, %l2 2010f70: 02 80 00 17 be 2010fcc 2010f74: 80 8e a0 01 btst 1, %i2 the_region->number_of_used_blocks += 1; 2010f78: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010f7c: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 2010f80: 82 00 60 01 inc %g1 2010f84: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 2010f88: 84 00 a0 01 inc %g2 2010f8c: c4 24 61 c0 st %g2, [ %l1 + 0x1c0 ] _RTEMS_Unlock_allocator(); 2010f90: d0 05 22 98 ld [ %l4 + 0x298 ], %o0 2010f94: 94 10 20 00 clr %o2 2010f98: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010f9c: 40 00 0d 66 call 2014534 <_CORE_mutex_Surrender> 2010fa0: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010fa4: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2010fa8: 82 00 7f ff add %g1, -1, %g1 2010fac: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 2010fb0: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 2010fb4: 80 a0 a0 00 cmp %g2, 0 2010fb8: 02 80 00 12 be 2011000 2010fbc: 01 00 00 00 nop *segment = the_segment; 2010fc0: e4 27 00 00 st %l2, [ %i4 ] <== NOT EXECUTED 2010fc4: 81 c7 e0 08 ret 2010fc8: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; } if ( _Options_Is_no_wait( option_set ) ) { 2010fcc: 02 80 00 11 be 2011010 2010fd0: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010fd4: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2010fd8: 82 00 60 01 inc %g1 2010fdc: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] _RTEMS_Unlock_allocator(); 2010fe0: d0 05 22 98 ld [ %l4 + 0x298 ], %o0 2010fe4: 94 10 20 00 clr %o2 2010fe8: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010fec: 40 00 0d 52 call 2014534 <_CORE_mutex_Surrender> 2010ff0: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010ff4: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2010ff8: 10 bf ff bb b 2010ee4 2010ffc: b0 10 20 0d mov 0xd, %i0 _Thread_Dispatch(); 2011000: 40 00 16 8c call 2016a30 <_Thread_Dispatch> 2011004: 01 00 00 00 nop _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { the_region->number_of_used_blocks += 1; _RTEMS_Unlock_allocator(); *segment = the_segment; 2011008: 10 bf ff ef b 2010fc4 201100c: e4 27 00 00 st %l2, [ %i4 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2011010: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2011014: 25 00 80 c8 sethi %hi(0x2032000), %l2 2011018: 82 00 60 01 inc %g1 201101c: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 2011020: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2011024: 82 00 60 01 inc %g1 2011028: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] * 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(); 201102c: d0 05 22 98 ld [ %l4 + 0x298 ], %o0 2011030: 94 10 20 00 clr %o2 2011034: d2 02 20 08 ld [ %o0 + 8 ], %o1 2011038: 40 00 0d 3f call 2014534 <_CORE_mutex_Surrender> 201103c: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2011040: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2011044: 82 00 7f ff add %g1, -1, %g1 2011048: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 201104c: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 2011050: 80 a0 a0 00 cmp %g2, 0 2011054: 02 80 00 17 be 20110b0 2011058: 01 00 00 00 nop 201105c: 82 10 20 01 mov 1, %g1 ! 1 executing->Wait.queue = &the_region->Wait_queue; 2011060: 90 04 20 10 add %l0, 0x10, %o0 executing->Wait.id = id; 2011064: ea 26 20 20 st %l5, [ %i0 + 0x20 ] executing->Wait.count = size; 2011068: f2 26 20 24 st %i1, [ %i0 + 0x24 ] executing->Wait.return_argument = segment; 201106c: 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 ); 2011070: 92 10 00 1b mov %i3, %o1 * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; 2011074: d0 26 20 44 st %o0, [ %i0 + 0x44 ] 2011078: c2 24 20 40 st %g1, [ %l0 + 0x40 ] executing->Wait.count = size; executing->Wait.return_argument = segment; _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 201107c: 15 00 80 5d sethi %hi(0x2017400), %o2 2011080: 40 00 18 05 call 2017094 <_Thread_queue_Enqueue_with_handler> 2011084: 94 12 a1 d4 or %o2, 0x1d4, %o2 ! 20175d4 <_Thread_queue_Timeout> 2011088: c2 04 a1 c0 ld [ %l2 + 0x1c0 ], %g1 201108c: 82 00 7f ff add %g1, -1, %g1 2011090: c2 24 a1 c0 st %g1, [ %l2 + 0x1c0 ] 2011094: c4 04 a1 c0 ld [ %l2 + 0x1c0 ], %g2 2011098: 80 a0 a0 00 cmp %g2, 0 201109c: 02 80 00 09 be 20110c0 20110a0: 01 00 00 00 nop _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 20110a4: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 <== NOT EXECUTED 20110a8: 81 c7 e0 08 ret <== NOT EXECUTED 20110ac: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 20110b0: 40 00 16 60 call 2016a30 <_Thread_Dispatch> <== NOT EXECUTED 20110b4: 01 00 00 00 nop <== NOT EXECUTED 20110b8: 10 bf ff ea b 2011060 <== NOT EXECUTED 20110bc: 82 10 20 01 mov 1, %g1 ! 1 <== NOT EXECUTED 20110c0: 40 00 16 5c call 2016a30 <_Thread_Dispatch> 20110c4: 01 00 00 00 nop 20110c8: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 20110cc: 81 c7 e0 08 ret 20110d0: 81 e8 00 00 restore 0201110c : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 201110c: 9d e3 bf 90 save %sp, -112, %sp #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 2011110: 7f ff e6 7c call 200ab00 2011114: 01 00 00 00 nop 2011118: a4 10 00 08 mov %o0, %l2 201111c: 23 00 80 c8 sethi %hi(0x2032000), %l1 2011120: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 2011124: 80 a0 60 00 cmp %g1, 0 2011128: 02 80 00 0b be 2011154 201112c: 27 00 80 c8 sethi %hi(0x2032000), %l3 2011130: 03 00 80 c8 sethi %hi(0x2032000), %g1 <== NOT EXECUTED 2011134: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20323a0 <_System_state_Current> <== NOT EXECUTED 2011138: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 201113c: 08 80 00 06 bleu 2011154 <== NOT EXECUTED 2011140: 90 10 20 00 clr %o0 <== NOT EXECUTED 2011144: 92 10 20 00 clr %o1 <== NOT EXECUTED 2011148: 40 00 0f 74 call 2014f18 <_Internal_error_Occurred> <== NOT EXECUTED 201114c: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2011150: 27 00 80 c8 sethi %hi(0x2032000), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2011154: 09 00 80 c8 sethi %hi(0x2032000), %g4 2011158: e0 04 e2 98 ld [ %l3 + 0x298 ], %l0 201115c: c4 01 22 a0 ld [ %g4 + 0x2a0 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2011160: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2011164: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2011168: 80 a0 60 00 cmp %g1, 0 201116c: 22 80 00 38 be,a 201124c 2011170: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2011174: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2011178: 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; 201117c: 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; 2011180: 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; 2011184: 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; 2011188: 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 ) || 201118c: 80 a0 e0 02 cmp %g3, 2 2011190: 12 80 00 58 bne 20112f0 2011194: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2011198: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 201119c: 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++; 20111a0: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20111a4: 02 80 00 7c be 2011394 20111a8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 20111ac: 7f ff e6 59 call 200ab10 20111b0: 90 10 00 12 mov %l2, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 20111b4: 92 10 00 18 mov %i0, %o1 20111b8: 11 00 80 c7 sethi %hi(0x2031c00), %o0 20111bc: 94 07 bf f4 add %fp, -12, %o2 20111c0: 40 00 10 d4 call 2015510 <_Objects_Get_no_protection> 20111c4: 90 12 23 d8 or %o0, 0x3d8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 20111c8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20111cc: 80 a0 60 01 cmp %g1, 1 20111d0: 02 80 00 35 be 20112a4 20111d4: a0 10 00 08 mov %o0, %l0 20111d8: 80 a0 60 01 cmp %g1, 1 20111dc: 1a 80 00 5f bcc 2011358 20111e0: 80 a0 60 02 cmp %g1, 2 RTEMS_INLINE_ROUTINE boolean _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 20111e4: 92 10 00 19 mov %i1, %o1 20111e8: 40 00 0e 4c call 2014b18 <_Heap_Free> 20111ec: 90 02 20 68 add %o0, 0x68, %o0 status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) { 20111f0: 80 a2 20 00 cmp %o0, 0 20111f4: 32 80 00 97 bne,a 2011450 20111f8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20111fc: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2011200: 82 00 60 01 inc %g1 2011204: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] _RTEMS_Unlock_allocator(); 2011208: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 201120c: 94 10 20 00 clr %o2 2011210: d2 02 20 08 ld [ %o0 + 8 ], %o1 2011214: 40 00 0c c8 call 2014534 <_CORE_mutex_Surrender> 2011218: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201121c: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2011220: b0 10 20 09 mov 9, %i0 2011224: 82 00 7f ff add %g1, -1, %g1 2011228: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 201122c: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 2011230: 80 a0 a0 00 cmp %g2, 0 2011234: 12 80 00 8c bne 2011464 2011238: 01 00 00 00 nop _Thread_Dispatch(); 201123c: 40 00 15 fd call 2016a30 <_Thread_Dispatch> 2011240: 01 00 00 00 nop 2011244: 81 c7 e0 08 ret 2011248: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 201124c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2011250: 12 80 00 30 bne 2011310 <== NOT EXECUTED 2011254: c6 04 e2 98 ld [ %l3 + 0x298 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2011258: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 201125c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2011260: 22 80 00 68 be,a 2011400 <== NOT EXECUTED 2011264: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2011268: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 201126c: 12 80 00 29 bne 2011310 <== NOT EXECUTED 2011270: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2011274: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2011278: 7f ff e6 26 call 200ab10 <== NOT EXECUTED 201127c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 2011280: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2011284: 11 00 80 c7 sethi %hi(0x2031c00), %o0 <== NOT EXECUTED 2011288: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 201128c: 40 00 10 a1 call 2015510 <_Objects_Get_no_protection> <== NOT EXECUTED 2011290: 90 12 23 d8 or %o0, 0x3d8, %o0 <== NOT EXECUTED #endif int status; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 2011294: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2011298: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 201129c: 12 bf ff d0 bne 20111dc <== NOT EXECUTED 20112a0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20112a4: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 20112a8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20112ac: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 20112b0: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 <== NOT EXECUTED 20112b4: 94 10 20 00 clr %o2 <== NOT EXECUTED 20112b8: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 20112bc: 40 00 0c 9e call 2014534 <_CORE_mutex_Surrender> <== NOT EXECUTED 20112c0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20112c4: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 20112c8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20112cc: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED 20112d0: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 <== NOT EXECUTED 20112d4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20112d8: 12 80 00 22 bne 2011360 <== NOT EXECUTED 20112dc: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 20112e0: 40 00 15 d4 call 2016a30 <_Thread_Dispatch> <== NOT EXECUTED 20112e4: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 20112e8: 81 c7 e0 08 ret <== NOT EXECUTED 20112ec: 81 e8 00 00 restore <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20112f0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20112f4: 12 bf ff ae bne 20111ac <== NOT EXECUTED 20112f8: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20112fc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2011300: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2011304: 02 80 00 24 be 2011394 <== NOT EXECUTED 2011308: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 201130c: 30 bf ff a8 b,a 20111ac <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2011310: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 2011314: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2011318: c8 01 22 a0 ld [ %g4 + 0x2a0 ], %g4 <== NOT EXECUTED 201131c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2011320: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2011324: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED 2011328: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 201132c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2011330: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2011334: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2011338: 7f ff e5 f6 call 200ab10 <== NOT EXECUTED 201133c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2011340: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 <== NOT EXECUTED 2011344: 92 10 20 00 clr %o1 <== NOT EXECUTED 2011348: 40 00 0c 57 call 20144a4 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 201134c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2011350: 10 bf ff 9a b 20111b8 <== NOT EXECUTED 2011354: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 2011358: 02 80 00 04 be 2011368 201135c: 01 00 00 00 nop the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator internally */ return RTEMS_SUCCESSFUL; 2011360: 81 c7 e0 08 ret <== NOT EXECUTED 2011364: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 2011368: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 201136c: 82 00 60 01 inc %g1 2011370: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2011374: d0 04 e2 98 ld [ %l3 + 0x298 ], %o0 2011378: 94 10 20 00 clr %o2 201137c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2011380: 40 00 0c 6d call 2014534 <_CORE_mutex_Surrender> 2011384: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2011388: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 201138c: 10 bf ff a6 b 2011224 2011390: b0 10 20 04 mov 4, %i0 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2011394: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 2011398: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 201139c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 20113a0: 02 80 00 28 be 2011440 <== NOT EXECUTED 20113a4: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 20113a8: 1a 80 00 1c bcc 2011418 <== NOT EXECUTED 20113ac: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20113b0: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 20113b4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20113b8: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20113bc: 7f ff e5 d5 call 200ab10 <== NOT EXECUTED 20113c0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 20113c4: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 20113c8: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 20113cc: 40 00 14 69 call 2016570 <_Thread_Change_priority> <== NOT EXECUTED 20113d0: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20113d4: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 <== NOT EXECUTED 20113d8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20113dc: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] <== NOT EXECUTED 20113e0: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 <== NOT EXECUTED 20113e4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20113e8: 32 bf ff 74 bne,a 20111b8 <== NOT EXECUTED 20113ec: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _Thread_Dispatch(); 20113f0: 40 00 15 90 call 2016a30 <_Thread_Dispatch> <== NOT EXECUTED 20113f4: 01 00 00 00 nop <== NOT EXECUTED 20113f8: 10 bf ff 70 b 20111b8 <== NOT EXECUTED 20113fc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2011400: 82 00 60 01 inc %g1 <== NOT EXECUTED 2011404: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2011408: 7f ff e5 c2 call 200ab10 <== NOT EXECUTED 201140c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2011410: 10 bf ff 6a b 20111b8 <== NOT EXECUTED 2011414: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2011418: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 201141c: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2011420: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2011424: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2011428: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 201142c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2011430: 7f ff e5 b8 call 200ab10 <== NOT EXECUTED 2011434: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2011438: 10 bf ff 60 b 20111b8 <== NOT EXECUTED 201143c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2011440: 7f ff e5 b4 call 200ab10 <== NOT EXECUTED 2011444: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2011448: 10 bf ff 5c b 20111b8 <== NOT EXECUTED 201144c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator internally */ 2011450: 90 10 00 10 mov %l0, %o0 if ( !status ) { _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 2011454: 82 00 7f ff add %g1, -1, %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 2011458: b0 10 20 00 clr %i0 201145c: 40 00 24 fb call 201a848 <_Region_Process_queue> 2011460: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 2011464: 81 c7 e0 08 ret 2011468: 81 e8 00 00 restore 02005a88 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 2005a88: 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 ) ) 2005a8c: aa 96 20 00 orcc %i0, 0, %l5 2005a90: 02 80 00 12 be 2005ad8 2005a94: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2005a98: 80 a7 20 00 cmp %i4, 0 2005a9c: 02 80 00 0f be 2005ad8 2005aa0: b0 10 20 09 mov 9, %i0 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 2005aa4: a4 8e a0 40 andcc %i2, 0x40, %l2 2005aa8: 12 80 00 0e bne 2005ae0 2005aac: a0 0e a0 30 and %i2, 0x30, %l0 2005ab0: 80 8e a0 80 btst 0x80, %i2 2005ab4: 12 80 00 0c bne 2005ae4 2005ab8: 80 a4 20 10 cmp %l0, 0x10 RTEMS_INLINE_ROUTINE boolean _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 2005abc: 80 a0 00 10 cmp %g0, %l0 2005ac0: a2 60 3f ff subx %g0, -1, %l1 if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 2005ac4: 80 a4 60 00 cmp %l1, 0 2005ac8: 12 80 00 17 bne 2005b24 2005acc: 80 a6 60 01 cmp %i1, 1 2005ad0: 08 80 00 15 bleu 2005b24 2005ad4: b0 10 20 0a mov 0xa, %i0 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 2005ad8: 81 c7 e0 08 ret 2005adc: 81 e8 00 00 restore #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 2005ae0: 80 a4 20 10 cmp %l0, 0x10 2005ae4: 12 80 00 0b bne 2005b10 2005ae8: 80 a4 20 20 cmp %l0, 0x20 2005aec: 80 8e a0 04 btst 4, %i2 2005af0: 02 80 00 06 be 2005b08 2005af4: 80 a4 a0 00 cmp %l2, 0 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 2005af8: 02 bf ff f1 be 2005abc 2005afc: 80 8e a0 80 btst 0x80, %i2 2005b00: 02 bf ff f0 be 2005ac0 2005b04: 80 a0 00 10 cmp %g0, %l0 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 2005b08: 81 c7 e0 08 ret 2005b0c: 91 e8 20 0b restore %g0, 0xb, %o0 #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 2005b10: 12 bf ff fe bne 2005b08 2005b14: 80 8e a0 04 btst 4, %i2 2005b18: 12 bf ff f8 bne 2005af8 2005b1c: 80 a4 a0 00 cmp %l2, 0 2005b20: 30 bf ff fa b,a 2005b08 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005b24: 29 00 80 61 sethi %hi(0x2018400), %l4 2005b28: c2 05 23 e0 ld [ %l4 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> 2005b2c: 82 00 60 01 inc %g1 2005b30: c2 25 23 e0 st %g1, [ %l4 + 0x3e0 ] * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 2005b34: 31 00 80 61 sethi %hi(0x2018400), %i0 2005b38: 40 00 07 27 call 20077d4 <_Objects_Allocate> 2005b3c: 90 16 22 90 or %i0, 0x290, %o0 ! 2018690 <_Semaphore_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 2005b40: a6 92 20 00 orcc %o0, 0, %l3 2005b44: 12 80 00 0e bne 2005b7c 2005b48: 80 a4 60 00 cmp %l1, 0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005b4c: c2 05 23 e0 ld [ %l4 + 0x3e0 ], %g1 2005b50: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 2005b54: 82 00 7f ff add %g1, -1, %g1 2005b58: c2 25 23 e0 st %g1, [ %l4 + 0x3e0 ] 2005b5c: c4 05 23 e0 ld [ %l4 + 0x3e0 ], %g2 2005b60: 80 a0 a0 00 cmp %g2, 0 2005b64: 12 80 00 04 bne 2005b74 2005b68: 01 00 00 00 nop 2005b6c: 40 00 0d 9f call 20091e8 <_Thread_Dispatch> 2005b70: 01 00 00 00 nop 2005b74: 81 c7 e0 08 ret 2005b78: 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 ) ) { 2005b7c: 12 80 00 1e bne 2005bf4 2005b80: f4 24 e0 10 st %i2, [ %l3 + 0x10 ] CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 2005b84: 80 a4 a0 00 cmp %l2, 0 2005b88: 02 80 00 39 be 2005c6c 2005b8c: 80 8e a0 80 btst 0x80, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 2005b90: 82 10 20 02 mov 2, %g1 2005b94: c2 27 bf e8 st %g1, [ %fp + -24 ] the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 2005b98: 80 a4 20 10 cmp %l0, 0x10 2005b9c: 12 80 00 39 bne 2005c80 2005ba0: 82 10 20 02 mov 2, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 2005ba4: c2 07 bf e8 ld [ %fp + -24 ], %g1 2005ba8: 80 a0 60 01 cmp %g1, 1 2005bac: 18 80 00 3d bgu 2005ca0 2005bb0: c0 27 bf e0 clr [ %fp + -32 ] case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; 2005bb4: c0 27 bf e4 clr [ %fp + -28 ] the_mutex_attributes.only_owner_release = FALSE; } the_mutex_attributes.priority_ceiling = priority_ceiling; mutex_status = _CORE_mutex_Initialize( 2005bb8: 82 1e 60 01 xor %i1, 1, %g1 2005bbc: 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; 2005bc0: f6 27 bf ec st %i3, [ %fp + -20 ] mutex_status = _CORE_mutex_Initialize( 2005bc4: 94 60 3f ff subx %g0, -1, %o2 2005bc8: 90 04 e0 14 add %l3, 0x14, %o0 2005bcc: 40 00 04 75 call 2006da0 <_CORE_mutex_Initialize> 2005bd0: 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 ) { 2005bd4: 80 a2 20 06 cmp %o0, 6 2005bd8: 12 80 00 14 bne 2005c28 2005bdc: 90 16 22 90 or %i0, 0x290, %o0 RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 2005be0: 40 00 08 0b call 2007c0c <_Objects_Free> <== NOT EXECUTED 2005be4: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005be8: c2 05 23 e0 ld [ %l4 + 0x3e0 ], %g1 <== NOT EXECUTED 2005bec: 10 bf ff da b 2005b54 <== NOT EXECUTED 2005bf0: b0 10 20 13 mov 0x13, %i0 <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) 2005bf4: 80 8e a0 04 btst 4, %i2 2005bf8: 22 80 00 04 be,a 2005c08 2005bfc: c0 27 bf f4 clr [ %fp + -12 ] the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 2005c00: 82 10 20 01 mov 1, %g1 2005c04: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 2005c08: 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; 2005c0c: c0 27 bf e0 clr [ %fp + -32 ] the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 2005c10: c0 27 bf ec clr [ %fp + -20 ] _CORE_semaphore_Initialize( 2005c14: 94 10 00 19 mov %i1, %o2 /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 2005c18: 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( 2005c1c: 90 04 e0 14 add %l3, 0x14, %o0 2005c20: 40 00 05 1d call 2007094 <_CORE_semaphore_Initialize> 2005c24: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005c28: 90 16 22 90 or %i0, 0x290, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2005c2c: c6 04 e0 08 ld [ %l3 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005c30: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2005c34: 03 00 00 3f sethi %hi(0xfc00), %g1 2005c38: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005c3c: 82 08 c0 01 and %g3, %g1, %g1 2005c40: 80 a0 40 02 cmp %g1, %g2 2005c44: 38 80 00 06 bgu,a 2005c5c 2005c48: ea 24 e0 0c st %l5, [ %l3 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005c4c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005c50: 83 28 60 02 sll %g1, 2, %g1 2005c54: e6 20 80 01 st %l3, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 2005c58: ea 24 e0 0c st %l5, [ %l3 + 0xc ] &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 2005c5c: c6 27 00 00 st %g3, [ %i4 ] 2005c60: c2 05 23 e0 ld [ %l4 + 0x3e0 ], %g1 2005c64: 10 bf ff bc b 2005b54 2005c68: b0 10 20 00 clr %i0 if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 2005c6c: 02 80 00 08 be 2005c8c 2005c70: 80 8e a0 04 btst 4, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 2005c74: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 2005c78: 10 bf ff c8 b 2005b98 <== NOT EXECUTED 2005c7c: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED the_mutex_attributes.only_owner_release = TRUE; break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; the_mutex_attributes.only_owner_release = FALSE; 2005c80: 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; 2005c84: 10 bf ff cd b 2005bb8 2005c88: c2 27 bf e0 st %g1, [ %fp + -32 ] if ( _Attributes_Is_inherit_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; else if ( _Attributes_Is_priority( attribute_set ) ) 2005c8c: 22 bf ff c3 be,a 2005b98 2005c90: c0 27 bf e8 clr [ %fp + -24 ] the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 2005c94: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2005c98: 10 bf ff c0 b 2005b98 <== NOT EXECUTED 2005c9c: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 2005ca0: 80 a0 60 03 cmp %g1, 3 2005ca4: 18 bf ff c6 bgu 2005bbc 2005ca8: 82 1e 60 01 xor %i1, 1, %g1 case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 2005cac: 82 10 20 01 mov 1, %g1 2005cb0: 10 bf ff c2 b 2005bb8 2005cb4: c2 27 bf e4 st %g1, [ %fp + -28 ] 02005cb8 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 2005cb8: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2005cbc: 21 00 80 61 sethi %hi(0x2018400), %l0 2005cc0: 92 10 00 18 mov %i0, %o1 2005cc4: 94 07 bf f4 add %fp, -12, %o2 2005cc8: 40 00 08 14 call 2007d18 <_Objects_Get> 2005ccc: 90 14 22 90 or %l0, 0x290, %o0 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2005cd0: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005cd4: 80 a0 60 00 cmp %g1, 0 2005cd8: 12 80 00 19 bne 2005d3c 2005cdc: b0 10 00 08 mov %o0, %i0 2005ce0: 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) ) { 2005ce4: 84 88 60 30 andcc %g1, 0x30, %g2 2005ce8: 22 80 00 1a be,a 2005d50 2005cec: 90 02 20 14 add %o0, 0x14, %o0 if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 2005cf0: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 2005cf4: 80 a0 60 00 cmp %g1, 0 2005cf8: 12 80 00 35 bne 2005dcc 2005cfc: 80 a0 a0 20 cmp %g2, 0x20 2005d00: 02 80 00 34 be 2005dd0 2005d04: 90 06 20 14 add %i0, 0x14, %o0 2005d08: 03 00 80 61 sethi %hi(0x2018400), %g1 2005d0c: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 20187e0 <_Thread_Dispatch_disable_level> 2005d10: b0 10 20 0c mov 0xc, %i0 2005d14: 84 00 bf ff add %g2, -1, %g2 2005d18: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] 2005d1c: c6 00 63 e0 ld [ %g1 + 0x3e0 ], %g3 2005d20: 80 a0 e0 00 cmp %g3, 0 2005d24: 12 80 00 28 bne 2005dc4 2005d28: 01 00 00 00 nop _Thread_Dispatch(); 2005d2c: 40 00 0d 2f call 20091e8 <_Thread_Dispatch> 2005d30: 01 00 00 00 nop 2005d34: 81 c7 e0 08 ret 2005d38: 81 e8 00 00 restore { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2005d3c: 80 a0 60 02 cmp %g1, 2 2005d40: 08 bf ff fd bleu 2005d34 2005d44: b0 10 20 04 mov 4, %i0 2005d48: 81 c7 e0 08 ret <== NOT EXECUTED 2005d4c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 2005d50: 92 10 20 00 clr %o1 2005d54: 40 00 04 cc call 2007084 <_CORE_semaphore_Flush> 2005d58: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005d5c: 90 14 22 90 or %l0, 0x290, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2005d60: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005d64: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005d68: 05 00 00 3f sethi %hi(0xfc00), %g2 2005d6c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2005d70: 82 08 40 02 and %g1, %g2, %g1 2005d74: 80 a0 40 03 cmp %g1, %g3 2005d78: 38 80 00 06 bgu,a 2005d90 2005d7c: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005d80: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005d84: 83 28 60 02 sll %g1, 2, %g1 2005d88: 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; 2005d8c: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 2005d90: 40 00 07 9f call 2007c0c <_Objects_Free> 2005d94: 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 ) 2005d98: 03 00 80 61 sethi %hi(0x2018400), %g1 2005d9c: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 20187e0 <_Thread_Dispatch_disable_level> 2005da0: b0 10 20 00 clr %i0 2005da4: 84 00 bf ff add %g2, -1, %g2 2005da8: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] 2005dac: c6 00 63 e0 ld [ %g1 + 0x3e0 ], %g3 2005db0: 80 a0 e0 00 cmp %g3, 0 2005db4: 12 80 00 04 bne 2005dc4 2005db8: 01 00 00 00 nop _Thread_Dispatch(); 2005dbc: 40 00 0d 0b call 20091e8 <_Thread_Dispatch> 2005dc0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005dc4: 81 c7 e0 08 ret 2005dc8: 81 e8 00 00 restore !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 2005dcc: 90 06 20 14 add %i0, 0x14, %o0 2005dd0: 92 10 20 00 clr %o1 2005dd4: 40 00 03 ef call 2006d90 <_CORE_mutex_Flush> 2005dd8: 94 10 20 04 mov 4, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005ddc: 10 bf ff e1 b 2005d60 2005de0: 90 14 22 90 or %l0, 0x290, %o0 02006284 : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 2006284: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2006288: 11 00 80 68 sethi %hi(0x201a000), %o0 200628c: 92 10 00 18 mov %i0, %o1 2006290: 90 12 21 a8 or %o0, 0x1a8, %o0 2006294: 40 00 08 74 call 2008464 <_Objects_Get> 2006298: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 200629c: c2 07 bf f4 ld [ %fp + -12 ], %g1 20062a0: 80 a0 60 00 cmp %g1, 0 20062a4: 12 80 00 16 bne 20062fc 20062a8: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 20062ac: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 20062b0: 80 88 60 30 btst 0x30, %g1 20062b4: 12 80 00 16 bne 200630c 20062b8: 90 02 20 14 add %o0, 0x14, %o0 &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 20062bc: 92 10 20 00 clr %o1 <== NOT EXECUTED 20062c0: 40 00 05 44 call 20077d0 <_CORE_semaphore_Flush> <== NOT EXECUTED 20062c4: 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 ) 20062c8: 03 00 80 68 sethi %hi(0x201a000), %g1 20062cc: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 201a2f0 <_Thread_Dispatch_disable_level> 20062d0: b0 10 20 00 clr %i0 20062d4: 84 00 bf ff add %g2, -1, %g2 20062d8: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] 20062dc: c6 00 62 f0 ld [ %g1 + 0x2f0 ], %g3 20062e0: 80 a0 e0 00 cmp %g3, 0 20062e4: 12 80 00 04 bne 20062f4 20062e8: 01 00 00 00 nop _Thread_Dispatch(); 20062ec: 40 00 0d 56 call 2009844 <_Thread_Dispatch> 20062f0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20062f4: 81 c7 e0 08 ret 20062f8: 81 e8 00 00 restore { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 20062fc: 08 bf ff fe bleu 20062f4 <== NOT EXECUTED 2006300: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2006304: 81 c7 e0 08 ret <== NOT EXECUTED 2006308: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Flush( 200630c: 92 10 20 00 clr %o1 2006310: 40 00 04 73 call 20074dc <_CORE_mutex_Flush> 2006314: 94 10 20 01 mov 1, %o2 2006318: 30 bf ff ec b,a 20062c8 02005de4 : rtems_status_code rtems_semaphore_obtain( rtems_id id, uint32_t option_set, rtems_interval timeout ) { 2005de4: 9d e3 bf 90 save %sp, -112, %sp Objects_Id id, Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) 2005de8: 11 00 80 61 sethi %hi(0x2018400), %o0 2005dec: 92 10 00 18 mov %i0, %o1 2005df0: 90 12 22 90 or %o0, 0x290, %o0 2005df4: 94 07 bf f4 add %fp, -12, %o2 2005df8: 40 00 07 aa call 2007ca0 <_Objects_Get_isr_disable> 2005dfc: 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 ) { 2005e00: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005e04: 80 a0 60 00 cmp %g1, 0 2005e08: 12 80 00 19 bne 2005e6c 2005e0c: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 2005e10: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2005e14: 80 88 60 30 btst 0x30, %g1 2005e18: 12 80 00 1b bne 2005e84 2005e1c: 23 00 80 61 sethi %hi(0x2018400), %l1 Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2005e20: 27 00 80 62 sethi %hi(0x2018800), %l3 2005e24: e4 04 e0 c0 ld [ %l3 + 0xc0 ], %l2 ! 20188c0 <_Thread_Executing> Watchdog_Interval timeout, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 2005e28: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 2005e2c: c0 24 a0 34 clr [ %l2 + 0x34 ] if ( the_semaphore->count != 0 ) { 2005e30: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 2005e34: 80 a0 60 00 cmp %g1, 0 2005e38: 12 80 00 8f bne 2006074 2005e3c: 80 8e 60 01 btst 1, %i1 the_semaphore->count -= 1; _ISR_Enable( level ); return; } if ( !wait ) { 2005e40: 02 80 00 73 be 200600c 2005e44: 01 00 00 00 nop _ISR_Enable( level ); 2005e48: 7f ff ef ea call 2001df0 2005e4c: 01 00 00 00 nop executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 2005e50: 82 10 20 01 mov 1, %g1 ! 1 2005e54: c2 24 a0 34 st %g1, [ %l2 + 0x34 ] id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 2005e58: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 2005e5c: 40 00 00 f4 call 200622c <_Semaphore_Translate_core_semaphore_return_code> 2005e60: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005e64: 81 c7 e0 08 ret 2005e68: 91 e8 00 08 restore %g0, %o0, %o0 register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 2005e6c: 80 a0 60 02 cmp %g1, 2 2005e70: 08 bf ff fd bleu 2005e64 2005e74: 90 10 20 04 mov 4, %o0 2005e78: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Semaphore_Translate_core_semaphore_return_code( _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005e7c: 81 c7 e0 08 ret <== NOT EXECUTED 2005e80: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 2005e84: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 2005e88: 80 a0 60 00 cmp %g1, 0 2005e8c: 02 80 00 0e be 2005ec4 2005e90: 27 00 80 62 sethi %hi(0x2018800), %l3 2005e94: 80 8e 60 01 btst 1, %i1 2005e98: 12 80 00 0c bne 2005ec8 2005e9c: c6 04 e0 c0 ld [ %l3 + 0xc0 ], %g3 2005ea0: 03 00 80 62 sethi %hi(0x2018800), %g1 2005ea4: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20189c0 <_System_state_Current> 2005ea8: 80 a0 a0 01 cmp %g2, 1 2005eac: 08 80 00 07 bleu 2005ec8 2005eb0: 90 10 20 00 clr %o0 2005eb4: 92 10 20 00 clr %o1 <== NOT EXECUTED 2005eb8: 40 00 06 1a call 2007720 <_Internal_error_Occurred> <== NOT EXECUTED 2005ebc: 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; 2005ec0: 27 00 80 62 sethi %hi(0x2018800), %l3 <== NOT EXECUTED 2005ec4: c6 04 e0 c0 ld [ %l3 + 0xc0 ], %g3 ! 20188c0 <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 2005ec8: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2005ecc: c0 20 e0 34 clr [ %g3 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2005ed0: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 2005ed4: 80 a0 60 00 cmp %g1, 0 2005ed8: 22 80 00 37 be,a 2005fb4 2005edc: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 2005ee0: c0 24 20 64 clr [ %l0 + 0x64 ] the_mutex->holder = executing; 2005ee4: c6 24 20 70 st %g3, [ %l0 + 0x70 ] the_mutex->holder_id = executing->Object.id; 2005ee8: c2 00 e0 08 ld [ %g3 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 2005eec: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2005ef0: 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; 2005ef4: c2 24 20 74 st %g1, [ %l0 + 0x74 ] the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2005ef8: 80 a0 a0 02 cmp %g2, 2 2005efc: 12 80 00 24 bne 2005f8c 2005f00: c8 24 20 68 st %g4, [ %l0 + 0x68 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2005f04: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2005f08: 82 00 60 01 inc %g1 2005f0c: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2005f10: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 2005f14: 80 a0 a0 03 cmp %g2, 3 2005f18: 12 80 00 20 bne 2005f98 2005f1c: 01 00 00 00 nop */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2005f20: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 <== NOT EXECUTED current = executing->current_priority; 2005f24: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2005f28: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2005f2c: 02 80 00 79 be 2006110 <== NOT EXECUTED 2005f30: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2005f34: 1a 80 00 6d bcc 20060e8 <== NOT EXECUTED 2005f38: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005f3c: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2005f40: 82 00 60 01 inc %g1 <== NOT EXECUTED 2005f44: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2005f48: 7f ff ef aa call 2001df0 <== NOT EXECUTED 2005f4c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Change_priority( 2005f50: d2 04 20 60 ld [ %l0 + 0x60 ], %o1 <== NOT EXECUTED 2005f54: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 <== NOT EXECUTED 2005f58: 40 00 0b 74 call 2008d28 <_Thread_Change_priority> <== NOT EXECUTED 2005f5c: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005f60: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 <== NOT EXECUTED 2005f64: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2005f68: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] <== NOT EXECUTED 2005f6c: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 <== NOT EXECUTED 2005f70: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2005f74: 32 80 00 0c bne,a 2005fa4 <== NOT EXECUTED 2005f78: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 2005f7c: 40 00 0c 9b call 20091e8 <_Thread_Dispatch> <== NOT EXECUTED 2005f80: 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( 2005f84: 10 80 00 08 b 2005fa4 <== NOT EXECUTED 2005f88: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2005f8c: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 2005f90: 22 bf ff de be,a 2005f08 <== NOT EXECUTED 2005f94: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 2005f98: 7f ff ef 96 call 2001df0 2005f9c: 01 00 00 00 nop 2005fa0: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 2005fa4: 40 00 00 98 call 2006204 <_Semaphore_Translate_core_mutex_return_code> 2005fa8: 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 */ } 2005fac: 81 c7 e0 08 ret 2005fb0: 91 e8 00 08 restore %g0, %o0, %o0 /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2005fb4: 80 a0 40 03 cmp %g1, %g3 2005fb8: 12 80 00 0d bne 2005fec 2005fbc: 80 8e 60 01 btst 1, %i1 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2005fc0: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 2005fc4: 80 a0 60 00 cmp %g1, 0 2005fc8: 12 80 00 40 bne 20060c8 2005fcc: 80 a0 60 01 cmp %g1, 1 case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2005fd0: c2 04 20 68 ld [ %l0 + 0x68 ], %g1 2005fd4: 82 00 60 01 inc %g1 2005fd8: c2 24 20 68 st %g1, [ %l0 + 0x68 ] _ISR_Enable( level ); 2005fdc: 7f ff ef 85 call 2001df0 2005fe0: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 2005fe4: 10 bf ff f0 b 2005fa4 2005fe8: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 2005fec: 02 80 00 28 be 200608c 2005ff0: c6 04 e0 c0 ld [ %l3 + 0xc0 ], %g3 2005ff4: 7f ff ef 7f call 2001df0 2005ff8: d0 07 bf f0 ld [ %fp + -16 ], %o0 2005ffc: c4 04 e0 c0 ld [ %l3 + 0xc0 ], %g2 2006000: 82 10 20 01 mov 1, %g1 2006004: 10 bf ff e7 b 2005fa0 2006008: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200600c: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 2006010: 82 00 60 01 inc %g1 2006014: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2006018: 82 10 20 01 mov 1, %g1 200601c: 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; 2006020: f0 24 a0 20 st %i0, [ %l2 + 0x20 ] return; } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 2006024: a0 04 20 14 add %l0, 0x14, %l0 2006028: e0 24 a0 44 st %l0, [ %l2 + 0x44 ] executing->Wait.id = id; _ISR_Enable( level ); 200602c: 7f ff ef 71 call 2001df0 2006030: 01 00 00 00 nop _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 2006034: 90 10 00 10 mov %l0, %o0 2006038: 92 10 00 1a mov %i2, %o1 200603c: 15 00 80 27 sethi %hi(0x2009c00), %o2 2006040: 40 00 0e 03 call 200984c <_Thread_queue_Enqueue_with_handler> 2006044: 94 12 a1 8c or %o2, 0x18c, %o2 ! 2009d8c <_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 ) 2006048: c2 04 63 e0 ld [ %l1 + 0x3e0 ], %g1 200604c: 82 00 7f ff add %g1, -1, %g1 2006050: c2 24 63 e0 st %g1, [ %l1 + 0x3e0 ] 2006054: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 2006058: 80 a0 a0 00 cmp %g2, 0 200605c: 32 bf ff 80 bne,a 2005e5c 2006060: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 2006064: 40 00 0c 61 call 20091e8 <_Thread_Dispatch> 2006068: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 200606c: 10 bf ff 7c b 2005e5c 2006070: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; 2006074: 82 00 7f ff add %g1, -1, %g1 2006078: c2 24 20 5c st %g1, [ %l0 + 0x5c ] _ISR_Enable( level ); 200607c: 7f ff ef 5d call 2001df0 2006080: 01 00 00 00 nop 2006084: 10 bf ff 76 b 2005e5c 2006088: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200608c: c4 04 63 e0 ld [ %l1 + 0x3e0 ], %g2 2006090: 82 10 20 01 mov 1, %g1 2006094: c2 24 20 44 st %g1, [ %l0 + 0x44 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 2006098: f0 20 e0 20 st %i0, [ %g3 + 0x20 ] 200609c: 84 00 a0 01 inc %g2 20060a0: a0 04 20 14 add %l0, 0x14, %l0 20060a4: c4 24 63 e0 st %g2, [ %l1 + 0x3e0 ] 20060a8: e0 20 e0 44 st %l0, [ %g3 + 0x44 ] 20060ac: 7f ff ef 51 call 2001df0 20060b0: d0 07 bf f0 ld [ %fp + -16 ], %o0 20060b4: 90 10 00 10 mov %l0, %o0 20060b8: 40 00 03 73 call 2006e84 <_CORE_mutex_Seize_interrupt_blocking> 20060bc: 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( 20060c0: 10 bf ff b9 b 2005fa4 20060c4: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20060c8: 12 bf ff c9 bne 2005fec 20060cc: 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; 20060d0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20060d4: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20060d8: 7f ff ef 46 call 2001df0 <== NOT EXECUTED 20060dc: 01 00 00 00 nop <== NOT EXECUTED 20060e0: 10 bf ff b1 b 2005fa4 <== NOT EXECUTED 20060e4: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20060e8: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20060ec: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20060f0: c0 24 20 68 clr [ %l0 + 0x68 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 20060f4: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 20060f8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20060fc: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2006100: 7f ff ef 3c call 2001df0 <== NOT EXECUTED 2006104: 01 00 00 00 nop <== NOT EXECUTED 2006108: 10 bf ff a7 b 2005fa4 <== NOT EXECUTED 200610c: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2006110: 7f ff ef 38 call 2001df0 <== NOT EXECUTED 2006114: 01 00 00 00 nop <== NOT EXECUTED 2006118: 10 bf ff a3 b 2005fa4 <== NOT EXECUTED 200611c: c2 04 e0 c0 ld [ %l3 + 0xc0 ], %g1 <== NOT EXECUTED 02006120 : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 2006120: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2006124: 11 00 80 61 sethi %hi(0x2018400), %o0 2006128: 92 10 00 18 mov %i0, %o1 200612c: 90 12 22 90 or %o0, 0x290, %o0 2006130: 40 00 06 fa call 2007d18 <_Objects_Get> 2006134: 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 ) { 2006138: c2 07 bf f4 ld [ %fp + -12 ], %g1 200613c: 80 a0 60 00 cmp %g1, 0 2006140: 12 80 00 16 bne 2006198 2006144: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 2006148: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 200614c: 80 88 60 30 btst 0x30, %g1 2006150: 02 80 00 17 be 20061ac 2006154: 92 10 00 18 mov %i0, %o1 mutex_status = _CORE_mutex_Surrender( 2006158: 94 10 20 00 clr %o2 200615c: 40 00 03 6e call 2006f14 <_CORE_mutex_Surrender> 2006160: 90 02 20 14 add %o0, 0x14, %o0 2006164: 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 ) 2006168: 03 00 80 61 sethi %hi(0x2018400), %g1 200616c: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 20187e0 <_Thread_Dispatch_disable_level> 2006170: 84 00 bf ff add %g2, -1, %g2 2006174: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] 2006178: c6 00 63 e0 ld [ %g1 + 0x3e0 ], %g3 200617c: 80 a0 e0 00 cmp %g3, 0 2006180: 02 80 00 1e be 20061f8 2006184: 01 00 00 00 nop &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 2006188: 40 00 00 1f call 2006204 <_Semaphore_Translate_core_mutex_return_code> 200618c: 90 10 00 18 mov %i0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006190: 81 c7 e0 08 ret 2006194: 91 e8 00 08 restore %g0, %o0, %o0 Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2006198: 08 bf ff fe bleu 2006190 200619c: 90 10 20 04 mov 4, %o0 20061a0: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20061a4: 81 c7 e0 08 ret <== NOT EXECUTED 20061a8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 20061ac: 94 10 20 00 clr %o2 20061b0: 40 00 03 c8 call 20070d0 <_CORE_semaphore_Surrender> 20061b4: 90 02 20 14 add %o0, 0x14, %o0 20061b8: b0 10 00 08 mov %o0, %i0 20061bc: 03 00 80 61 sethi %hi(0x2018400), %g1 20061c0: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 20187e0 <_Thread_Dispatch_disable_level> 20061c4: 84 00 bf ff add %g2, -1, %g2 20061c8: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] 20061cc: c6 00 63 e0 ld [ %g1 + 0x3e0 ], %g3 20061d0: 80 a0 e0 00 cmp %g3, 0 20061d4: 02 80 00 06 be 20061ec 20061d8: 01 00 00 00 nop &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return 20061dc: 40 00 00 14 call 200622c <_Semaphore_Translate_core_semaphore_return_code> 20061e0: 90 10 00 18 mov %i0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20061e4: 81 c7 e0 08 ret 20061e8: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 20061ec: 40 00 0b ff call 20091e8 <_Thread_Dispatch> 20061f0: 01 00 00 00 nop 20061f4: 30 bf ff fa b,a 20061dc 20061f8: 40 00 0b fc call 20091e8 <_Thread_Dispatch> 20061fc: 01 00 00 00 nop 2006200: 30 bf ff e2 b,a 2006188 020163d0 : */ void rtems_shutdown_executive( uint32_t result ) { 20163d0: 9d e3 bf 98 save %sp, -104, %sp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 20163d4: 33 00 80 62 sethi %hi(0x2018800), %i1 20163d8: c2 06 61 c0 ld [ %i1 + 0x1c0 ], %g1 ! 20189c0 <_System_state_Current> 20163dc: 80 a0 60 04 cmp %g1, 4 20163e0: 02 80 00 0c be 2016410 20163e4: 11 00 80 5d sethi %hi(0x2017400), %o0 #if defined(__USE_INIT_FINI__) extern void _fini( void ); atexit( _fini ); 20163e8: 7f ff e0 01 call 200e3ec 20163ec: 90 12 22 d4 or %o0, 0x2d4, %o0 ! 20176d4 <_fini> * routine which initialized the system. */ RTEMS_INLINE_ROUTINE void _Thread_Stop_multitasking( void ) { _Context_Switch( &_Thread_Executing->Registers, &_Thread_BSP_context ); 20163f0: 03 00 80 62 sethi %hi(0x2018800), %g1 20163f4: f0 00 60 c0 ld [ %g1 + 0xc0 ], %i0 ! 20188c0 <_Thread_Executing> 20163f8: 84 10 20 04 mov 4, %g2 20163fc: b0 06 20 e0 add %i0, 0xe0, %i0 2016400: c4 26 61 c0 st %g2, [ %i1 + 0x1c0 ] 2016404: 33 00 80 61 sethi %hi(0x2018400), %i1 2016408: 7f ff d2 07 call 200ac24 <_CPU_Context_switch> 201640c: 93 ee 63 58 restore %i1, 0x358, %o1 2016410: 81 c7 e0 08 ret <== NOT EXECUTED 2016414: 81 e8 00 00 restore <== NOT EXECUTED 02011c6c : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 2011c6c: 9d e3 bf 90 save %sp, -112, %sp 2011c70: 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 ) 2011c74: 80 a6 60 00 cmp %i1, 0 2011c78: 02 80 00 1b be 2011ce4 2011c7c: 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 ) ) { 2011c80: 80 a2 60 00 cmp %o1, 0 2011c84: 12 80 00 1a bne 2011cec 2011c88: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2011c8c: 23 00 80 c8 sethi %hi(0x2032000), %l1 2011c90: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 2011c94: 82 00 60 01 inc %g1 2011c98: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 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; 2011c9c: 03 00 80 c8 sethi %hi(0x2032000), %g1 2011ca0: e0 00 62 a0 ld [ %g1 + 0x2a0 ], %l0 ! 20322a0 <_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; 2011ca4: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 2011ca8: f0 04 21 70 ld [ %l0 + 0x170 ], %i0 asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 2011cac: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 2011cb0: 80 a0 60 00 cmp %g1, 0 2011cb4: 32 80 00 2c bne,a 2011d64 2011cb8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2011cbc: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2011cc0: b0 10 20 0b mov 0xb, %i0 2011cc4: 82 00 7f ff add %g1, -1, %g1 2011cc8: c2 24 61 c0 st %g1, [ %l1 + 0x1c0 ] 2011ccc: c4 04 61 c0 ld [ %l1 + 0x1c0 ], %g2 2011cd0: 80 a0 a0 00 cmp %g2, 0 2011cd4: 12 80 00 0b bne 2011d00 2011cd8: 01 00 00 00 nop _Thread_Dispatch(); 2011cdc: 40 00 13 55 call 2016a30 <_Thread_Dispatch> 2011ce0: 01 00 00 00 nop 2011ce4: 81 c7 e0 08 ret 2011ce8: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2011cec: 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 ) { 2011cf0: 80 a0 a0 04 cmp %g2, 4 2011cf4: 08 80 00 05 bleu 2011d08 2011cf8: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2011cfc: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2011d00: 81 c7 e0 08 ret 2011d04: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2011d08: 80 a0 60 01 cmp %g1, 1 2011d0c: 12 bf ff f6 bne 2011ce4 2011d10: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2011d14: 83 28 a0 02 sll %g2, 2, %g1 2011d18: 05 00 80 c8 sethi %hi(0x2032000), %g2 2011d1c: 84 10 a1 20 or %g2, 0x120, %g2 ! 2032120 <_Objects_Information_table> 2011d20: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2011d24: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2011d28: 80 a2 20 00 cmp %o0, 0 2011d2c: 02 bf ff f5 be 2011d00 2011d30: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2011d34: 40 00 0e 0b call 2015560 <_Objects_Get> 2011d38: 94 07 bf f4 add %fp, -12, %o2 if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2011d3c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2011d40: a0 10 00 08 mov %o0, %l0 2011d44: 80 a0 60 00 cmp %g1, 0 2011d48: 02 bf ff d8 be 2011ca8 2011d4c: 23 00 80 c8 sethi %hi(0x2032000), %l1 2011d50: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2011d54: 18 bf ff e4 bgu 2011ce4 <== NOT EXECUTED 2011d58: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2011d5c: 81 c7 e0 08 ret <== NOT EXECUTED 2011d60: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { if ( asr->is_enabled ) { 2011d64: 80 a0 60 00 cmp %g1, 0 2011d68: 02 80 00 19 be 2011dcc 2011d6c: 01 00 00 00 nop rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 2011d70: 7f ff e3 64 call 200ab00 2011d74: 01 00 00 00 nop *signal_set |= signals; 2011d78: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 2011d7c: 82 10 40 19 or %g1, %i1, %g1 2011d80: c2 26 20 54 st %g1, [ %i0 + 0x54 ] _ISR_Enable( _level ); 2011d84: 7f ff e3 63 call 200ab10 2011d88: 01 00 00 00 nop _ASR_Post_signals( signal_set, &asr->signals_posted ); the_thread->do_post_task_switch_extension = TRUE; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 2011d8c: 03 00 80 c8 sethi %hi(0x2032000), %g1 2011d90: c4 00 62 88 ld [ %g1 + 0x288 ], %g2 ! 2032288 <_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; 2011d94: 86 10 20 01 mov 1, %g3 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 2011d98: 80 a0 a0 00 cmp %g2, 0 2011d9c: 02 80 00 09 be 2011dc0 2011da0: c6 24 20 78 st %g3, [ %l0 + 0x78 ] 2011da4: 03 00 80 c8 sethi %hi(0x2032000), %g1 <== NOT EXECUTED 2011da8: c4 00 62 a0 ld [ %g1 + 0x2a0 ], %g2 ! 20322a0 <_Thread_Executing> <== NOT EXECUTED 2011dac: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 2011db0: 12 80 00 04 bne 2011dc0 <== NOT EXECUTED 2011db4: 01 00 00 00 nop <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 2011db8: 03 00 80 c8 sethi %hi(0x2032000), %g1 <== NOT EXECUTED 2011dbc: c6 20 63 48 st %g3, [ %g1 + 0x348 ] ! 2032348 <_ISR_Signals_to_thread_executing> <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2011dc0: c2 04 61 c0 ld [ %l1 + 0x1c0 ], %g1 2011dc4: 10 bf ff c0 b 2011cc4 2011dc8: b0 10 20 00 clr %i0 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 2011dcc: 7f ff e3 4d call 200ab00 2011dd0: 01 00 00 00 nop *signal_set |= signals; 2011dd4: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 2011dd8: 82 10 40 19 or %g1, %i1, %g1 2011ddc: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _ISR_Enable( _level ); 2011de0: 7f ff e3 4c call 200ab10 2011de4: 01 00 00 00 nop 2011de8: 30 bf ff f6 b,a 2011dc0 020063bc : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 20063bc: 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 ) ) { 20063c0: 92 96 20 00 orcc %i0, 0, %o1 20063c4: 12 80 00 20 bne 2006444 20063c8: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20063cc: 21 00 80 61 sethi %hi(0x2018400), %l0 20063d0: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> 20063d4: 82 00 60 01 inc %g1 20063d8: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ] 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; 20063dc: 03 00 80 62 sethi %hi(0x2018800), %g1 20063e0: f0 00 60 c0 ld [ %g1 + 0xc0 ], %i0 ! 20188c0 <_Thread_Executing> 20063e4: 07 00 80 61 sethi %hi(0x2018400), %g3 Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; 20063e8: c0 27 bf f4 clr [ %fp + -12 ] 20063ec: a2 10 e3 40 or %g3, 0x340, %l1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_information = _Objects_Get_information( the_thread->Object.id ); 20063f0: c2 06 20 08 ld [ %i0 + 8 ], %g1 20063f4: 85 30 60 16 srl %g1, 0x16, %g2 20063f8: 84 08 a0 1c and %g2, 0x1c, %g2 20063fc: c6 04 40 02 ld [ %l1 + %g2 ], %g3 2006400: 83 30 60 1b srl %g1, 0x1b, %g1 2006404: 83 28 60 02 sll %g1, 2, %g1 2006408: d0 00 c0 01 ld [ %g3 + %g1 ], %o0 if ( !the_information ) { 200640c: 80 a2 20 00 cmp %o0, 0 2006410: 12 80 00 13 bne 200645c 2006414: 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 ) 2006418: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 <== NOT EXECUTED 200641c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2006420: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ] <== NOT EXECUTED 2006424: c4 04 23 e0 ld [ %l0 + 0x3e0 ], %g2 <== NOT EXECUTED 2006428: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200642c: 12 80 00 04 bne 200643c <== NOT EXECUTED 2006430: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2006434: 40 00 0b 6d call 20091e8 <_Thread_Dispatch> <== NOT EXECUTED 2006438: 01 00 00 00 nop <== NOT EXECUTED 200643c: 81 c7 e0 08 ret 2006440: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2006444: 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 ) { 2006448: 80 a0 a0 04 cmp %g2, 4 200644c: 08 80 00 1b bleu 20064b8 2006450: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006454: 81 c7 e0 08 ret <== NOT EXECUTED 2006458: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INVALID_ID; /* This should never happen if _Thread_Get() works right */ } _Thread_Close( the_information, the_thread ); 200645c: 40 00 0a d9 call 2008fc0 <_Thread_Close> 2006460: 92 10 00 18 mov %i0, %o1 2006464: c4 06 20 08 ld [ %i0 + 8 ], %g2 2006468: 92 10 00 18 mov %i0, %o1 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 200646c: 83 30 a0 16 srl %g2, 0x16, %g1 2006470: 82 08 60 1c and %g1, 0x1c, %g1 2006474: c6 04 40 01 ld [ %l1 + %g1 ], %g3 2006478: 85 30 a0 1b srl %g2, 0x1b, %g2 200647c: 85 28 a0 02 sll %g2, 2, %g2 2006480: 40 00 05 e3 call 2007c0c <_Objects_Free> 2006484: d0 00 c0 02 ld [ %g3 + %g2 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006488: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 200648c: b0 10 20 00 clr %i0 2006490: 82 00 7f ff add %g1, -1, %g1 2006494: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ] 2006498: c4 04 23 e0 ld [ %l0 + 0x3e0 ], %g2 200649c: 80 a0 a0 00 cmp %g2, 0 20064a0: 12 80 00 04 bne 20064b0 20064a4: 01 00 00 00 nop _Thread_Dispatch(); 20064a8: 40 00 0b 50 call 20091e8 <_Thread_Dispatch> 20064ac: 01 00 00 00 nop 20064b0: 81 c7 e0 08 ret 20064b4: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20064b8: 80 a0 60 01 cmp %g1, 1 20064bc: 12 bf ff e0 bne 200643c 20064c0: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20064c4: 85 28 a0 02 sll %g2, 2, %g2 20064c8: 07 00 80 61 sethi %hi(0x2018400), %g3 20064cc: a2 10 e3 40 or %g3, 0x340, %l1 ! 2018740 <_Objects_Information_table> 20064d0: c2 04 40 02 ld [ %l1 + %g2 ], %g1 20064d4: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20064d8: 80 a2 20 00 cmp %o0, 0 20064dc: 02 bf ff f5 be 20064b0 20064e0: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20064e4: 40 00 06 0d call 2007d18 <_Objects_Get> 20064e8: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20064ec: c2 07 bf f4 ld [ %fp + -12 ], %g1 20064f0: b0 10 00 08 mov %o0, %i0 20064f4: 80 a0 60 00 cmp %g1, 0 20064f8: 02 bf ff be be 20063f0 20064fc: 21 00 80 61 sethi %hi(0x2018400), %l0 2006500: 80 a0 60 02 cmp %g1, 2 2006504: 18 bf ff ce bgu 200643c 2006508: b0 10 20 19 mov 0x19, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 200650c: 81 c7 e0 08 ret 2006510: 91 e8 20 04 restore %g0, 4, %o0 02007cc8 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 2007cc8: 9d e3 bf 90 save %sp, -112, %sp 2007ccc: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !note ) 2007cd0: 80 a6 a0 00 cmp %i2, 0 2007cd4: 02 80 00 3b be 2007dc0 2007cd8: 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 ) 2007cdc: 80 a6 60 0f cmp %i1, 0xf 2007ce0: 18 80 00 38 bgu 2007dc0 2007ce4: 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 ) || 2007ce8: 80 a2 60 00 cmp %o1, 0 2007cec: 12 80 00 09 bne 2007d10 2007cf0: 07 00 80 76 sethi %hi(0x201d800), %g3 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 2007cf4: c2 00 e2 f0 ld [ %g3 + 0x2f0 ], %g1 ! 201daf0 <_Thread_Executing> 2007cf8: 87 2e 60 02 sll %i1, 2, %g3 2007cfc: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 2007d00: c2 00 80 03 ld [ %g2 + %g3 ], %g1 2007d04: c2 26 80 00 st %g1, [ %i2 ] 2007d08: 81 c7 e0 08 ret 2007d0c: 91 e8 20 00 restore %g0, 0, %o0 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 2007d10: c2 00 e2 f0 ld [ %g3 + 0x2f0 ], %g1 2007d14: c4 00 60 08 ld [ %g1 + 8 ], %g2 2007d18: 80 a2 40 02 cmp %o1, %g2 2007d1c: 22 bf ff f8 be,a 2007cfc 2007d20: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2007d24: 83 32 60 18 srl %o1, 0x18, %g1 2007d28: 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 ) { 2007d2c: 80 a0 a0 04 cmp %g2, 4 2007d30: 08 80 00 04 bleu 2007d40 2007d34: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007d38: 81 c7 e0 08 ret <== NOT EXECUTED 2007d3c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007d40: 80 a0 60 01 cmp %g1, 1 2007d44: 12 80 00 1f bne 2007dc0 2007d48: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007d4c: 83 28 a0 02 sll %g2, 2, %g1 2007d50: 05 00 80 76 sethi %hi(0x201d800), %g2 2007d54: 84 10 a1 70 or %g2, 0x170, %g2 ! 201d970 <_Objects_Information_table> 2007d58: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2007d5c: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2007d60: 80 a2 20 00 cmp %o0, 0 2007d64: 02 80 00 17 be 2007dc0 2007d68: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007d6c: 40 00 07 53 call 2009ab8 <_Objects_Get> 2007d70: 94 07 bf f4 add %fp, -12, %o2 *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007d74: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007d78: 80 a0 60 00 cmp %g1, 0 2007d7c: 12 80 00 13 bne 2007dc8 2007d80: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 2007d84: c6 02 21 70 ld [ %o0 + 0x170 ], %g3 2007d88: 83 2e 60 02 sll %i1, 2, %g1 2007d8c: c4 00 c0 01 ld [ %g3 + %g1 ], %g2 2007d90: c4 26 80 00 st %g2, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007d94: 07 00 80 76 sethi %hi(0x201d800), %g3 2007d98: c2 00 e2 10 ld [ %g3 + 0x210 ], %g1 ! 201da10 <_Thread_Dispatch_disable_level> 2007d9c: b0 10 20 00 clr %i0 2007da0: 82 00 7f ff add %g1, -1, %g1 2007da4: c2 20 e2 10 st %g1, [ %g3 + 0x210 ] 2007da8: c4 00 e2 10 ld [ %g3 + 0x210 ], %g2 2007dac: 80 a0 a0 00 cmp %g2, 0 2007db0: 12 80 00 04 bne 2007dc0 2007db4: 01 00 00 00 nop _Thread_Dispatch(); 2007db8: 40 00 0c 38 call 200ae98 <_Thread_Dispatch> 2007dbc: 01 00 00 00 nop 2007dc0: 81 c7 e0 08 ret 2007dc4: 81 e8 00 00 restore *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007dc8: 18 bf ff fe bgu 2007dc0 <== NOT EXECUTED 2007dcc: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 2007dd0: 81 c7 e0 08 ret <== NOT EXECUTED 2007dd4: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 02006ba4 : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 2006ba4: 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 ) ) { 2006ba8: 92 96 20 00 orcc %i0, 0, %o1 2006bac: 12 80 00 19 bne 2006c10 2006bb0: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006bb4: 05 00 80 6e sethi %hi(0x201b800), %g2 <== NOT EXECUTED 2006bb8: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 ! 201b890 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2006bbc: 82 00 60 01 inc %g1 <== NOT EXECUTED 2006bc0: c2 20 a0 90 st %g1, [ %g2 + 0x90 ] <== 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; 2006bc4: 03 00 80 6e sethi %hi(0x201b800), %g1 <== NOT EXECUTED 2006bc8: d0 00 61 70 ld [ %g1 + 0x170 ], %o0 ! 201b970 <_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; 2006bcc: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 2006bd0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2006bd4: 80 88 60 02 btst 2, %g1 2006bd8: 02 80 00 15 be 2006c2c 2006bdc: 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 ) 2006be0: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 2006be4: b0 10 20 0f mov 0xf, %i0 2006be8: 82 00 7f ff add %g1, -1, %g1 2006bec: c2 20 a0 90 st %g1, [ %g2 + 0x90 ] 2006bf0: c4 00 a0 90 ld [ %g2 + 0x90 ], %g2 2006bf4: 80 a0 a0 00 cmp %g2, 0 2006bf8: 12 80 00 0b bne 2006c24 2006bfc: 01 00 00 00 nop _Thread_Dispatch(); 2006c00: 40 00 0b 5a call 2009968 <_Thread_Dispatch> 2006c04: 01 00 00 00 nop 2006c08: 81 c7 e0 08 ret 2006c0c: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2006c10: 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 ) { 2006c14: 80 a0 a0 04 cmp %g2, 4 2006c18: 08 80 00 08 bleu 2006c38 2006c1c: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2006c20: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006c24: 81 c7 e0 08 ret <== NOT EXECUTED 2006c28: 81 e8 00 00 restore <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006c2c: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 2006c30: 10 bf ff ee b 2006be8 2006c34: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2006c38: 80 a0 60 01 cmp %g1, 1 2006c3c: 12 bf ff f3 bne 2006c08 2006c40: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2006c44: 83 28 a0 02 sll %g2, 2, %g1 2006c48: 05 00 80 6d sethi %hi(0x201b400), %g2 2006c4c: 84 10 a3 f0 or %g2, 0x3f0, %g2 ! 201b7f0 <_Objects_Information_table> 2006c50: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2006c54: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2006c58: 80 a2 20 00 cmp %o0, 0 2006c5c: 02 bf ff f2 be 2006c24 2006c60: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2006c64: 40 00 06 49 call 2008588 <_Objects_Get> 2006c68: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006c6c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006c70: 80 a0 60 00 cmp %g1, 0 2006c74: 02 bf ff d7 be 2006bd0 2006c78: 05 00 80 6e sethi %hi(0x201b800), %g2 2006c7c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2006c80: 18 bf ff e2 bgu 2006c08 <== NOT EXECUTED 2006c84: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2006c88: 81 c7 e0 08 ret <== NOT EXECUTED 2006c8c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 02007180 : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 2007180: 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 ) ) { 2007184: 92 96 20 00 orcc %i0, 0, %o1 2007188: 12 80 00 1b bne 20071f4 200718c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007190: 21 00 80 6f sethi %hi(0x201bc00), %l0 2007194: c2 04 21 60 ld [ %l0 + 0x160 ], %g1 ! 201bd60 <_Thread_Dispatch_disable_level> 2007198: 82 00 60 01 inc %g1 200719c: c2 24 21 60 st %g1, [ %l0 + 0x160 ] 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; 20071a0: 03 00 80 6f sethi %hi(0x201bc00), %g1 20071a4: d0 00 62 40 ld [ %g1 + 0x240 ], %o0 ! 201be40 <_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; 20071a8: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 20071ac: 94 10 00 19 mov %i1, %o2 20071b0: 40 00 0e 5a call 200ab18 <_Thread_Restart> 20071b4: 92 10 20 00 clr %o1 20071b8: 80 a2 20 00 cmp %o0, 0 20071bc: 12 80 00 15 bne 2007210 20071c0: 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 ) 20071c4: c2 04 21 60 ld [ %l0 + 0x160 ], %g1 20071c8: b0 10 20 0e mov 0xe, %i0 20071cc: 82 00 7f ff add %g1, -1, %g1 20071d0: c2 24 21 60 st %g1, [ %l0 + 0x160 ] 20071d4: c4 04 21 60 ld [ %l0 + 0x160 ], %g2 20071d8: 80 a0 a0 00 cmp %g2, 0 20071dc: 12 80 00 0b bne 2007208 20071e0: 01 00 00 00 nop _Thread_Dispatch(); 20071e4: 40 00 0b 2e call 2009e9c <_Thread_Dispatch> 20071e8: 01 00 00 00 nop 20071ec: 81 c7 e0 08 ret 20071f0: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 20071f4: 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 ) { 20071f8: 80 a0 a0 04 cmp %g2, 4 20071fc: 08 80 00 08 bleu 200721c 2007200: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2007204: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007208: 81 c7 e0 08 ret <== NOT EXECUTED 200720c: 81 e8 00 00 restore <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007210: c2 04 21 60 ld [ %l0 + 0x160 ], %g1 2007214: 10 bf ff ee b 20071cc 2007218: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 200721c: 80 a0 60 01 cmp %g1, 1 2007220: 12 bf ff f3 bne 20071ec 2007224: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007228: 83 28 a0 02 sll %g2, 2, %g1 200722c: 05 00 80 6f sethi %hi(0x201bc00), %g2 2007230: 84 10 a0 c0 or %g2, 0xc0, %g2 ! 201bcc0 <_Objects_Information_table> 2007234: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2007238: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 200723c: 80 a2 20 00 cmp %o0, 0 2007240: 02 bf ff f2 be 2007208 2007244: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007248: 40 00 06 1d call 2008abc <_Objects_Get> 200724c: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007250: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007254: 80 a0 60 00 cmp %g1, 0 2007258: 02 bf ff d5 be 20071ac 200725c: 21 00 80 6f sethi %hi(0x201bc00), %l0 2007260: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2007264: 18 bf ff e2 bgu 20071ec <== NOT EXECUTED 2007268: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 200726c: 81 c7 e0 08 ret <== NOT EXECUTED 2007270: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 02007c3c : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 2007c3c: 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 ) ) { 2007c40: 92 96 20 00 orcc %i0, 0, %o1 2007c44: 12 80 00 19 bne 2007ca8 2007c48: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007c4c: 21 00 80 93 sethi %hi(0x2024c00), %l0 2007c50: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 ! 2024dc0 <_Thread_Dispatch_disable_level> 2007c54: 82 00 60 01 inc %g1 2007c58: c2 24 21 c0 st %g1, [ %l0 + 0x1c0 ] 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; 2007c5c: 03 00 80 93 sethi %hi(0x2024c00), %g1 2007c60: d0 00 62 a0 ld [ %g1 + 0x2a0 ], %o0 ! 2024ea0 <_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; 2007c64: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 2007c68: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2007c6c: 80 88 60 02 btst 2, %g1 2007c70: 12 80 00 2b bne 2007d1c 2007c74: 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 ) 2007c78: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 2007c7c: b0 10 20 0e mov 0xe, %i0 2007c80: 82 00 7f ff add %g1, -1, %g1 2007c84: c2 24 21 c0 st %g1, [ %l0 + 0x1c0 ] 2007c88: c4 04 21 c0 ld [ %l0 + 0x1c0 ], %g2 2007c8c: 80 a0 a0 00 cmp %g2, 0 2007c90: 12 80 00 0b bne 2007cbc 2007c94: 01 00 00 00 nop _Thread_Dispatch(); 2007c98: 40 00 0c 13 call 200ace4 <_Thread_Dispatch> 2007c9c: 01 00 00 00 nop 2007ca0: 81 c7 e0 08 ret 2007ca4: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2007ca8: 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 ) { 2007cac: 80 a0 a0 04 cmp %g2, 4 2007cb0: 08 80 00 05 bleu 2007cc4 2007cb4: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2007cb8: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007cbc: 81 c7 e0 08 ret 2007cc0: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007cc4: 80 a0 60 01 cmp %g1, 1 2007cc8: 12 bf ff f6 bne 2007ca0 2007ccc: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007cd0: 83 28 a0 02 sll %g2, 2, %g1 2007cd4: 05 00 80 93 sethi %hi(0x2024c00), %g2 2007cd8: 84 10 a1 20 or %g2, 0x120, %g2 ! 2024d20 <_Objects_Information_table> 2007cdc: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2007ce0: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2007ce4: 80 a2 20 00 cmp %o0, 0 2007ce8: 02 bf ff f5 be 2007cbc 2007cec: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007cf0: 40 00 07 05 call 2009904 <_Objects_Get> 2007cf4: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007cf8: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007cfc: 80 a0 60 00 cmp %g1, 0 2007d00: 02 bf ff da be 2007c68 2007d04: 21 00 80 93 sethi %hi(0x2024c00), %l0 2007d08: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2007d0c: 18 bf ff e5 bgu 2007ca0 <== NOT EXECUTED 2007d10: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2007d14: 81 c7 e0 08 ret <== NOT EXECUTED 2007d18: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { _Thread_Resume( the_thread, TRUE ); 2007d1c: 40 00 0f 27 call 200b9b8 <_Thread_Resume> 2007d20: 92 10 20 01 mov 1, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007d24: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 2007d28: 10 bf ff d6 b 2007c80 2007d2c: b0 10 20 00 clr %i0 02007fa8 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 2007fa8: 9d e3 bf 90 save %sp, -112, %sp 2007fac: 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 ) 2007fb0: 80 a6 60 0f cmp %i1, 0xf 2007fb4: 18 80 00 36 bgu 200808c 2007fb8: 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 ) || 2007fbc: 80 a2 60 00 cmp %o1, 0 2007fc0: 12 80 00 08 bne 2007fe0 2007fc4: 07 00 80 76 sethi %hi(0x201d800), %g3 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 2007fc8: c2 00 e2 f0 ld [ %g3 + 0x2f0 ], %g1 ! 201daf0 <_Thread_Executing> <== NOT EXECUTED 2007fcc: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 <== NOT EXECUTED 2007fd0: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED 2007fd4: f4 20 80 03 st %i2, [ %g2 + %g3 ] <== NOT EXECUTED 2007fd8: 81 c7 e0 08 ret <== NOT EXECUTED 2007fdc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 2007fe0: c2 00 e2 f0 ld [ %g3 + 0x2f0 ], %g1 2007fe4: c4 00 60 08 ld [ %g1 + 8 ], %g2 2007fe8: 80 a2 40 02 cmp %o1, %g2 2007fec: 22 bf ff f9 be,a 2007fd0 2007ff0: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 <== NOT EXECUTED 2007ff4: 83 32 60 18 srl %o1, 0x18, %g1 2007ff8: 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 ) { 2007ffc: 80 a0 a0 04 cmp %g2, 4 2008000: 08 80 00 04 bleu 2008010 2008004: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2008008: 81 c7 e0 08 ret <== NOT EXECUTED 200800c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2008010: 80 a0 60 01 cmp %g1, 1 2008014: 12 80 00 1e bne 200808c 2008018: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 200801c: 83 28 a0 02 sll %g2, 2, %g1 2008020: 05 00 80 76 sethi %hi(0x201d800), %g2 2008024: 84 10 a1 70 or %g2, 0x170, %g2 ! 201d970 <_Objects_Information_table> 2008028: c6 00 80 01 ld [ %g2 + %g1 ], %g3 200802c: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2008030: 80 a2 20 00 cmp %o0, 0 2008034: 02 80 00 16 be 200808c 2008038: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200803c: 40 00 06 9f call 2009ab8 <_Objects_Get> 2008040: 94 07 bf f4 add %fp, -12, %o2 api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 2008044: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008048: 80 a0 60 00 cmp %g1, 0 200804c: 12 80 00 12 bne 2008094 2008050: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 2008054: c4 02 21 70 ld [ %o0 + 0x170 ], %g2 2008058: 83 2e 60 02 sll %i1, 2, %g1 200805c: 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 ) 2008060: 07 00 80 76 sethi %hi(0x201d800), %g3 2008064: c2 00 e2 10 ld [ %g3 + 0x210 ], %g1 ! 201da10 <_Thread_Dispatch_disable_level> 2008068: b0 10 20 00 clr %i0 200806c: 82 00 7f ff add %g1, -1, %g1 2008070: c2 20 e2 10 st %g1, [ %g3 + 0x210 ] 2008074: c4 00 e2 10 ld [ %g3 + 0x210 ], %g2 2008078: 80 a0 a0 00 cmp %g2, 0 200807c: 12 80 00 04 bne 200808c 2008080: 01 00 00 00 nop _Thread_Dispatch(); 2008084: 40 00 0b 85 call 200ae98 <_Thread_Dispatch> 2008088: 01 00 00 00 nop 200808c: 81 c7 e0 08 ret 2008090: 81 e8 00 00 restore api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 2008094: 18 bf ff fe bgu 200808c <== NOT EXECUTED 2008098: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 200809c: 81 c7 e0 08 ret <== NOT EXECUTED 20080a0: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 0200d594 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 200d594: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 200d598: 80 a6 60 00 cmp %i1, 0 200d59c: 02 80 00 06 be 200d5b4 200d5a0: 92 10 00 18 mov %i0, %o1 200d5a4: 82 06 7f ff add %i1, -1, %g1 200d5a8: 80 a0 60 fe cmp %g1, 0xfe 200d5ac: 18 80 00 26 bgu 200d644 200d5b0: b0 10 20 13 mov 0x13, %i0 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 200d5b4: 80 a6 a0 00 cmp %i2, 0 200d5b8: 02 80 00 23 be 200d644 200d5bc: 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 ) ) { 200d5c0: 80 a2 60 00 cmp %o1, 0 200d5c4: 12 80 00 22 bne 200d64c 200d5c8: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200d5cc: 21 00 80 a7 sethi %hi(0x2029c00), %l0 200d5d0: c2 04 23 40 ld [ %l0 + 0x340 ], %g1 ! 2029f40 <_Thread_Dispatch_disable_level> 200d5d4: 82 00 60 01 inc %g1 200d5d8: c2 24 23 40 st %g1, [ %l0 + 0x340 ] 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; 200d5dc: 03 00 80 a8 sethi %hi(0x202a000), %g1 200d5e0: d0 00 60 20 ld [ %g1 + 0x20 ], %o0 ! 202a020 <_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; 200d5e4: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: /* XXX convert from core priority */ *old_priority = the_thread->current_priority; 200d5e8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 200d5ec: 80 a6 60 00 cmp %i1, 0 200d5f0: 02 80 00 0d be 200d624 200d5f4: c2 26 80 00 st %g1, [ %i2 ] the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200d5f8: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 200d5fc: 80 a0 60 00 cmp %g1, 0 200d600: 02 80 00 06 be 200d618 200d604: f2 22 20 18 st %i1, [ %o0 + 0x18 ] 200d608: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200d60c: 80 a6 40 01 cmp %i1, %g1 200d610: 1a 80 00 05 bcc 200d624 200d614: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 200d618: 92 10 00 19 mov %i1, %o1 200d61c: 40 00 0a 59 call 200ff80 <_Thread_Change_priority> 200d620: 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 ) 200d624: c2 04 23 40 ld [ %l0 + 0x340 ], %g1 200d628: b0 10 20 00 clr %i0 200d62c: 82 00 7f ff add %g1, -1, %g1 200d630: c2 24 23 40 st %g1, [ %l0 + 0x340 ] 200d634: c4 04 23 40 ld [ %l0 + 0x340 ], %g2 200d638: 80 a0 a0 00 cmp %g2, 0 200d63c: 02 80 00 0a be 200d664 200d640: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200d644: 81 c7 e0 08 ret 200d648: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 200d64c: 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 ) { 200d650: 80 a0 a0 04 cmp %g2, 4 200d654: 08 80 00 08 bleu 200d674 200d658: 83 32 60 1b srl %o1, 0x1b, %g1 200d65c: 81 c7 e0 08 ret <== NOT EXECUTED 200d660: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 200d664: 40 00 0b 77 call 2010440 <_Thread_Dispatch> 200d668: 01 00 00 00 nop 200d66c: 81 c7 e0 08 ret 200d670: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 200d674: 80 a0 60 01 cmp %g1, 1 200d678: 12 bf ff f3 bne 200d644 200d67c: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 200d680: 83 28 a0 02 sll %g2, 2, %g1 200d684: 05 00 80 a7 sethi %hi(0x2029c00), %g2 200d688: 84 10 a2 a0 or %g2, 0x2a0, %g2 ! 2029ea0 <_Objects_Information_table> 200d68c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 200d690: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 200d694: 80 a2 20 00 cmp %o0, 0 200d698: 02 bf ff f5 be 200d66c 200d69c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200d6a0: 40 00 06 34 call 200ef70 <_Objects_Get> 200d6a4: 94 07 bf f4 add %fp, -12, %o2 if ( !old_priority ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 200d6a8: c2 07 bf f4 ld [ %fp + -12 ], %g1 200d6ac: 80 a0 60 00 cmp %g1, 0 200d6b0: 02 bf ff ce be 200d5e8 200d6b4: 21 00 80 a7 sethi %hi(0x2029c00), %l0 200d6b8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200d6bc: 18 bf ff e2 bgu 200d644 <== NOT EXECUTED 200d6c0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 200d6c4: 81 c7 e0 08 ret <== NOT EXECUTED 200d6c8: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 02006650 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 2006650: 9d e3 bf 90 save %sp, -112, %sp 2006654: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 2006658: 80 a6 60 00 cmp %i1, 0 200665c: 02 80 00 1e be 20066d4 2006660: 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 ) ) { 2006664: 80 a2 60 00 cmp %o1, 0 2006668: 12 80 00 1d bne 20066dc 200666c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006670: 21 00 80 61 sethi %hi(0x2018400), %l0 2006674: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 ! 20187e0 <_Thread_Dispatch_disable_level> 2006678: 82 00 60 01 inc %g1 200667c: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ] 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; 2006680: 03 00 80 62 sethi %hi(0x2018800), %g1 2006684: d0 00 60 c0 ld [ %g1 + 0xc0 ], %o0 ! 20188c0 <_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; 2006688: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Start( 200668c: 94 10 00 19 mov %i1, %o2 2006690: 98 10 00 1a mov %i2, %o4 2006694: 92 10 20 00 clr %o1 2006698: 40 00 0e dd call 200a20c <_Thread_Start> 200669c: 96 10 20 00 clr %o3 20066a0: 80 a2 20 00 cmp %o0, 0 20066a4: 12 80 00 2b bne 2006750 20066a8: 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 ) 20066ac: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 20066b0: b0 10 20 0e mov 0xe, %i0 20066b4: 82 00 7f ff add %g1, -1, %g1 20066b8: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ] 20066bc: c4 04 23 e0 ld [ %l0 + 0x3e0 ], %g2 20066c0: 80 a0 a0 00 cmp %g2, 0 20066c4: 12 80 00 0b bne 20066f0 20066c8: 01 00 00 00 nop _Thread_Dispatch(); 20066cc: 40 00 0a c7 call 20091e8 <_Thread_Dispatch> 20066d0: 01 00 00 00 nop 20066d4: 81 c7 e0 08 ret 20066d8: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 20066dc: 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 ) { 20066e0: 80 a0 a0 04 cmp %g2, 4 20066e4: 08 80 00 05 bleu 20066f8 20066e8: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 20066ec: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20066f0: 81 c7 e0 08 ret 20066f4: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20066f8: 80 a0 60 01 cmp %g1, 1 20066fc: 12 bf ff f6 bne 20066d4 2006700: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2006704: 83 28 a0 02 sll %g2, 2, %g1 2006708: 05 00 80 61 sethi %hi(0x2018400), %g2 200670c: 84 10 a3 40 or %g2, 0x340, %g2 ! 2018740 <_Objects_Information_table> 2006710: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2006714: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2006718: 80 a2 20 00 cmp %o0, 0 200671c: 02 bf ff f5 be 20066f0 2006720: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2006724: 40 00 05 7d call 2007d18 <_Objects_Get> 2006728: 94 07 bf f4 add %fp, -12, %o2 if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 200672c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006730: 80 a0 60 00 cmp %g1, 0 2006734: 02 bf ff d6 be 200668c 2006738: 21 00 80 61 sethi %hi(0x2018400), %l0 200673c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2006740: 18 bf ff e5 bgu 20066d4 <== NOT EXECUTED 2006744: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2006748: 81 c7 e0 08 ret <== NOT EXECUTED 200674c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006750: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 2006754: 10 bf ff d8 b 20066b4 2006758: b0 10 20 00 clr %i0 02007e3c : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 2007e3c: 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 ) ) { 2007e40: 92 96 20 00 orcc %i0, 0, %o1 2007e44: 12 80 00 19 bne 2007ea8 2007e48: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007e4c: 21 00 80 93 sethi %hi(0x2024c00), %l0 2007e50: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 ! 2024dc0 <_Thread_Dispatch_disable_level> 2007e54: 82 00 60 01 inc %g1 2007e58: c2 24 21 c0 st %g1, [ %l0 + 0x1c0 ] 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; 2007e5c: 03 00 80 93 sethi %hi(0x2024c00), %g1 2007e60: d0 00 62 a0 ld [ %g1 + 0x2a0 ], %o0 ! 2024ea0 <_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; 2007e64: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 2007e68: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2007e6c: 80 88 60 02 btst 2, %g1 2007e70: 02 80 00 2b be 2007f1c 2007e74: 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 ) 2007e78: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 2007e7c: b0 10 20 0f mov 0xf, %i0 2007e80: 82 00 7f ff add %g1, -1, %g1 2007e84: c2 24 21 c0 st %g1, [ %l0 + 0x1c0 ] 2007e88: c4 04 21 c0 ld [ %l0 + 0x1c0 ], %g2 2007e8c: 80 a0 a0 00 cmp %g2, 0 2007e90: 12 80 00 0b bne 2007ebc 2007e94: 01 00 00 00 nop _Thread_Dispatch(); 2007e98: 40 00 0b 93 call 200ace4 <_Thread_Dispatch> 2007e9c: 01 00 00 00 nop 2007ea0: 81 c7 e0 08 ret 2007ea4: 81 e8 00 00 restore 2007ea8: 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 ) { 2007eac: 80 a0 a0 04 cmp %g2, 4 2007eb0: 08 80 00 05 bleu 2007ec4 2007eb4: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2007eb8: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007ebc: 81 c7 e0 08 ret <== NOT EXECUTED 2007ec0: 81 e8 00 00 restore <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007ec4: 80 a0 60 01 cmp %g1, 1 2007ec8: 12 bf ff f6 bne 2007ea0 2007ecc: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007ed0: 83 28 a0 02 sll %g2, 2, %g1 2007ed4: 05 00 80 93 sethi %hi(0x2024c00), %g2 2007ed8: 84 10 a1 20 or %g2, 0x120, %g2 ! 2024d20 <_Objects_Information_table> 2007edc: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2007ee0: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2007ee4: 80 a2 20 00 cmp %o0, 0 2007ee8: 02 bf ff f5 be 2007ebc 2007eec: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007ef0: 40 00 06 85 call 2009904 <_Objects_Get> 2007ef4: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007ef8: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007efc: 80 a0 60 00 cmp %g1, 0 2007f00: 02 bf ff da be 2007e68 2007f04: 21 00 80 93 sethi %hi(0x2024c00), %l0 2007f08: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2007f0c: 18 bf ff e5 bgu 2007ea0 <== NOT EXECUTED 2007f10: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2007f14: 81 c7 e0 08 ret <== NOT EXECUTED 2007f18: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Suspend( the_thread ); 2007f1c: 40 00 0f eb call 200bec8 <_Thread_Suspend> 2007f20: 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 ) 2007f24: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 2007f28: 10 bf ff d6 b 2007e80 2007f2c: b0 10 20 00 clr %i0 020196e0 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 20196e0: 9d e3 bf 90 save %sp, -112, %sp 20196e4: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 20196e8: 80 a6 60 00 cmp %i1, 0 20196ec: 02 80 00 22 be 2019774 20196f0: 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 ) ) { 20196f4: 80 a2 60 00 cmp %o1, 0 20196f8: 12 80 00 21 bne 201977c 20196fc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2019700: 21 00 80 ef sethi %hi(0x203bc00), %l0 2019704: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 ! 203bcb0 <_Thread_Dispatch_disable_level> 2019708: 82 00 60 01 inc %g1 201970c: c2 24 20 b0 st %g1, [ %l0 + 0xb0 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 2019710: 03 00 80 ef sethi %hi(0x203bc00), %g1 2019714: f0 00 61 90 ld [ %g1 + 0x190 ], %i0 ! 203bd90 <_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; 2019718: c0 27 bf f4 clr [ %fp + -12 ] /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 201971c: c4 06 21 80 ld [ %i0 + 0x180 ], %g2 while (tvp) { 2019720: 80 a0 a0 00 cmp %g2, 0 2019724: 32 80 00 08 bne,a 2019744 2019728: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 201972c: 10 80 00 1a b 2019794 2019730: 11 00 80 ef sethi %hi(0x203bc00), %o0 2019734: 84 90 60 00 orcc %g1, 0, %g2 <== NOT EXECUTED 2019738: 02 80 00 17 be 2019794 <== NOT EXECUTED 201973c: 11 00 80 ef sethi %hi(0x203bc00), %o0 <== NOT EXECUTED if (tvp->ptr == ptr) { 2019740: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 2019744: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 2019748: 32 bf ff fb bne,a 2019734 <== NOT EXECUTED 201974c: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED tvp->dtor = dtor; 2019750: f4 20 a0 10 st %i2, [ %g2 + 0x10 ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2019754: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 _Thread_Dispatch(); 2019758: b0 10 20 00 clr %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201975c: 82 00 7f ff add %g1, -1, %g1 2019760: c2 24 20 b0 st %g1, [ %l0 + 0xb0 ] 2019764: c4 04 20 b0 ld [ %l0 + 0xb0 ], %g2 2019768: 80 a0 a0 00 cmp %g2, 0 201976c: 02 80 00 1c be 20197dc 2019770: 01 00 00 00 nop the_thread->task_variables = new; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2019774: 81 c7 e0 08 ret <== NOT EXECUTED 2019778: 81 e8 00 00 restore <== NOT EXECUTED 201977c: 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 ) { 2019780: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2019784: 08 80 00 21 bleu 2019808 <== NOT EXECUTED 2019788: 83 32 60 1b srl %o1, 0x1b, %g1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 201978c: 81 c7 e0 08 ret <== NOT EXECUTED 2019790: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 2019794: 92 10 20 14 mov 0x14, %o1 2019798: 7f ff c0 f4 call 2009b68 <_Heap_Allocate> 201979c: 90 12 20 fc or %o0, 0xfc, %o0 * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 20197a0: 80 a2 20 00 cmp %o0, 0 20197a4: 32 80 00 12 bne,a 20197ec 20197a8: c4 06 21 80 ld [ %i0 + 0x180 ], %g2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20197ac: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 <== NOT EXECUTED 20197b0: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED 20197b4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20197b8: c2 24 20 b0 st %g1, [ %l0 + 0xb0 ] <== NOT EXECUTED 20197bc: c4 04 20 b0 ld [ %l0 + 0xb0 ], %g2 <== NOT EXECUTED 20197c0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20197c4: 12 80 00 08 bne 20197e4 <== NOT EXECUTED 20197c8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 20197cc: 7f ff c9 27 call 200bc68 <_Thread_Dispatch> <== NOT EXECUTED 20197d0: 01 00 00 00 nop <== NOT EXECUTED 20197d4: 81 c7 e0 08 ret <== NOT EXECUTED 20197d8: 81 e8 00 00 restore <== NOT EXECUTED 20197dc: 7f ff c9 23 call 200bc68 <_Thread_Dispatch> 20197e0: b0 10 20 00 clr %i0 20197e4: 81 c7 e0 08 ret 20197e8: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 20197ec: 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; 20197f0: 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; 20197f4: c2 22 20 08 st %g1, [ %o0 + 8 ] new->ptr = ptr; 20197f8: f2 22 20 04 st %i1, [ %o0 + 4 ] new->dtor = dtor; 20197fc: f4 22 20 10 st %i2, [ %o0 + 0x10 ] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 2019800: 10 bf ff d5 b 2019754 2019804: c4 22 00 00 st %g2, [ %o0 ] *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2019808: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 201980c: 12 bf ff e0 bne 201978c <== NOT EXECUTED 2019810: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2019814: 05 00 80 ef sethi %hi(0x203bc00), %g2 <== NOT EXECUTED 2019818: 84 10 a0 10 or %g2, 0x10, %g2 ! 203bc10 <_Objects_Information_table> <== NOT EXECUTED 201981c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 2019820: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 2019824: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2019828: 02 bf ff d9 be 201978c <== NOT EXECUTED 201982c: 01 00 00 00 nop <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2019830: 7f ff c3 7e call 200a628 <_Objects_Get> <== NOT EXECUTED 2019834: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 2019838: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 201983c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 2019840: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2019844: 02 bf ff b6 be 201971c <== NOT EXECUTED 2019848: 21 00 80 ef sethi %hi(0x203bc00), %l0 <== NOT EXECUTED 201984c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2019850: 18 bf ff c9 bgu 2019774 <== NOT EXECUTED 2019854: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 2019858: 30 bf ff cd b,a 201978c <== NOT EXECUTED 0201985c : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 201985c: 9d e3 bf 90 save %sp, -112, %sp Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 2019860: 80 a6 60 00 cmp %i1, 0 2019864: 02 80 00 50 be 20199a4 2019868: 92 10 00 18 mov %i0, %o1 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 201986c: 80 a6 20 00 cmp %i0, 0 2019870: 12 80 00 26 bne 2019908 2019874: 83 36 20 18 srl %i0, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2019878: 21 00 80 ef sethi %hi(0x203bc00), %l0 201987c: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 ! 203bcb0 <_Thread_Dispatch_disable_level> 2019880: 82 00 60 01 inc %g1 2019884: c2 24 20 b0 st %g1, [ %l0 + 0xb0 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 2019888: 03 00 80 ef sethi %hi(0x203bc00), %g1 201988c: d0 00 61 90 ld [ %g1 + 0x190 ], %o0 ! 203bd90 <_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; 2019890: c0 27 bf f4 clr [ %fp + -12 ] default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; 2019894: c6 02 21 80 ld [ %o0 + 0x180 ], %g3 while (tvp) { 2019898: 80 a0 e0 00 cmp %g3, 0 201989c: 02 80 00 10 be 20198dc 20198a0: 01 00 00 00 nop if (tvp->ptr == ptr) { 20198a4: c2 00 e0 04 ld [ %g3 + 4 ], %g1 20198a8: 80 a0 40 19 cmp %g1, %i1 20198ac: 32 80 00 09 bne,a 20198d0 20198b0: c4 00 c0 00 ld [ %g3 ], %g2 <== NOT EXECUTED if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 20198b4: 10 80 00 5b b 2019a20 20198b8: c2 00 c0 00 ld [ %g3 ], %g1 return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 20198bc: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 20198c0: 02 80 00 18 be 2019920 <== NOT EXECUTED 20198c4: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 20198c8: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED _Workspace_Free(tvp); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 20198cc: c4 00 c0 00 ld [ %g3 ], %g2 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 20198d0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20198d4: 32 bf ff fa bne,a 20198bc <== NOT EXECUTED 20198d8: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20198dc: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 <== NOT EXECUTED 20198e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20198e4: c2 24 20 b0 st %g1, [ %l0 + 0xb0 ] <== NOT EXECUTED 20198e8: c4 04 20 b0 ld [ %l0 + 0xb0 ], %g2 <== NOT EXECUTED 20198ec: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20198f0: 12 80 00 2d bne 20199a4 <== NOT EXECUTED 20198f4: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 20198f8: 7f ff c8 dc call 200bc68 <_Thread_Dispatch> <== NOT EXECUTED 20198fc: b0 10 20 09 mov 9, %i0 ! 9 <== NOT EXECUTED 2019900: 81 c7 e0 08 ret <== NOT EXECUTED 2019904: 81 e8 00 00 restore <== NOT EXECUTED 2019908: 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 ) { 201990c: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2019910: 08 80 00 2e bleu 20199c8 <== NOT EXECUTED 2019914: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2019918: 81 c7 e0 08 ret <== NOT EXECUTED 201991c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 2019920: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED 2019924: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(the_thread)) { 2019928: 03 00 80 ef sethi %hi(0x203bc00), %g1 201992c: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 203bd90 <_Thread_Executing> 2019930: 80 a2 00 02 cmp %o0, %g2 2019934: 32 80 00 1e bne,a 20199ac 2019938: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED if (tvp->dtor) 201993c: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 2019940: 80 a0 a0 00 cmp %g2, 0 2019944: 22 80 00 06 be,a 201995c 2019948: c4 06 20 04 ld [ %i0 + 4 ], %g2 (*tvp->dtor)(*tvp->ptr); 201994c: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 2019950: 9f c0 80 00 call %g2 <== NOT EXECUTED 2019954: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 2019958: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED 201995c: c2 06 20 08 ld [ %i0 + 8 ], %g1 2019960: c2 20 80 00 st %g1, [ %g2 ] RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2019964: 92 10 00 18 mov %i0, %o1 2019968: 11 00 80 ef sethi %hi(0x203bc00), %o0 201996c: 7f ff c0 b1 call 2009c30 <_Heap_Free> 2019970: 90 12 20 fc or %o0, 0xfc, %o0 ! 203bcfc <_Workspace_Area> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2019974: c2 04 20 b0 ld [ %l0 + 0xb0 ], %g1 2019978: b0 10 20 00 clr %i0 201997c: 82 00 7f ff add %g1, -1, %g1 2019980: c2 24 20 b0 st %g1, [ %l0 + 0xb0 ] 2019984: c4 04 20 b0 ld [ %l0 + 0xb0 ], %g2 2019988: 80 a0 a0 00 cmp %g2, 0 201998c: 12 80 00 04 bne 201999c 2019990: 01 00 00 00 nop _Thread_Dispatch(); 2019994: 7f ff c8 b5 call 200bc68 <_Thread_Dispatch> 2019998: 01 00 00 00 nop 201999c: 81 c7 e0 08 ret 20199a0: 81 e8 00 00 restore 20199a4: 81 c7 e0 08 ret <== NOT EXECUTED 20199a8: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED } else { if (tvp->dtor) 20199ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20199b0: 22 bf ff ee be,a 2019968 <== NOT EXECUTED 20199b4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 20199b8: 9f c0 40 00 call %g1 <== NOT EXECUTED 20199bc: d0 06 20 0c ld [ %i0 + 0xc ], %o0 <== NOT EXECUTED 20199c0: 10 bf ff ea b 2019968 <== NOT EXECUTED 20199c4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20199c8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20199cc: 32 bf ff cd bne,a 2019900 <== NOT EXECUTED 20199d0: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20199d4: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 20199d8: 05 00 80 ef sethi %hi(0x203bc00), %g2 <== NOT EXECUTED 20199dc: 84 10 a0 10 or %g2, 0x10, %g2 ! 203bc10 <_Objects_Information_table> <== NOT EXECUTED 20199e0: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 20199e4: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 20199e8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20199ec: 22 bf ff c5 be,a 2019900 <== NOT EXECUTED 20199f0: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20199f4: 7f ff c3 0d call 200a628 <_Objects_Get> <== NOT EXECUTED 20199f8: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 20199fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2019a00: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2019a04: 02 bf ff a4 be 2019894 <== NOT EXECUTED 2019a08: 21 00 80 ef sethi %hi(0x203bc00), %l0 <== NOT EXECUTED 2019a0c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2019a10: 18 bf ff bc bgu 2019900 <== NOT EXECUTED 2019a14: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2019a18: 81 c7 e0 08 ret <== NOT EXECUTED 2019a1c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 2019a20: b0 10 00 03 mov %g3, %i0 2019a24: 10 bf ff c1 b 2019928 2019a28: c2 22 21 80 st %g1, [ %o0 + 0x180 ] 02019a2c : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 2019a2c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 2019a30: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2019a34: 02 80 00 3b be 2019b20 <== NOT EXECUTED 2019a38: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 2019a3c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 2019a40: 02 80 00 38 be 2019b20 <== NOT EXECUTED 2019a44: 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 ) ) { 2019a48: 12 80 00 21 bne 2019acc <== NOT EXECUTED 2019a4c: 83 36 20 18 srl %i0, 0x18, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2019a50: 05 00 80 ef sethi %hi(0x203bc00), %g2 <== NOT EXECUTED 2019a54: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 203bcb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2019a58: 82 00 60 01 inc %g1 <== NOT EXECUTED 2019a5c: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== 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; 2019a60: 03 00 80 ef sethi %hi(0x203bc00), %g1 <== NOT EXECUTED 2019a64: d0 00 61 90 ld [ %g1 + 0x190 ], %o0 ! 203bd90 <_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; 2019a68: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 2019a6c: d0 02 21 80 ld [ %o0 + 0x180 ], %o0 <== NOT EXECUTED while (tvp) { 2019a70: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2019a74: 32 80 00 07 bne,a 2019a90 <== NOT EXECUTED 2019a78: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 2019a7c: 30 80 00 1a b,a 2019ae4 <== NOT EXECUTED 2019a80: 90 90 60 00 orcc %g1, 0, %o0 <== NOT EXECUTED 2019a84: 02 80 00 18 be 2019ae4 <== NOT EXECUTED 2019a88: 01 00 00 00 nop <== NOT EXECUTED if (tvp->ptr == ptr) { 2019a8c: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 2019a90: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 2019a94: 32 bf ff fb bne,a 2019a80 <== NOT EXECUTED 2019a98: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 2019a9c: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED 2019aa0: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2019aa4: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 <== NOT EXECUTED 2019aa8: b0 10 20 00 clr %i0 <== NOT EXECUTED 2019aac: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2019ab0: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED 2019ab4: c4 00 a0 b0 ld [ %g2 + 0xb0 ], %g2 <== NOT EXECUTED 2019ab8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2019abc: 02 80 00 15 be 2019b10 <== NOT EXECUTED 2019ac0: 01 00 00 00 nop <== NOT EXECUTED } _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2019ac4: 81 c7 e0 08 ret <== NOT EXECUTED 2019ac8: 81 e8 00 00 restore <== NOT EXECUTED 2019acc: 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 ) { 2019ad0: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2019ad4: 08 80 00 15 bleu 2019b28 <== NOT EXECUTED 2019ad8: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED 2019adc: 81 c7 e0 08 ret <== NOT EXECUTED 2019ae0: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2019ae4: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 <== NOT EXECUTED 2019ae8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2019aec: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ] <== NOT EXECUTED 2019af0: c4 00 a0 b0 ld [ %g2 + 0xb0 ], %g2 <== NOT EXECUTED 2019af4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2019af8: 12 80 00 0a bne 2019b20 <== NOT EXECUTED 2019afc: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 2019b00: 7f ff c8 5a call 200bc68 <_Thread_Dispatch> <== NOT EXECUTED 2019b04: b0 10 20 09 mov 9, %i0 ! 9 <== NOT EXECUTED 2019b08: 81 c7 e0 08 ret <== NOT EXECUTED 2019b0c: 81 e8 00 00 restore <== NOT EXECUTED 2019b10: 7f ff c8 56 call 200bc68 <_Thread_Dispatch> <== NOT EXECUTED 2019b14: 01 00 00 00 nop <== NOT EXECUTED 2019b18: 81 c7 e0 08 ret <== NOT EXECUTED 2019b1c: 81 e8 00 00 restore <== NOT EXECUTED 2019b20: 81 c7 e0 08 ret <== NOT EXECUTED 2019b24: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2019b28: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2019b2c: 32 bf ff e6 bne,a 2019ac4 <== NOT EXECUTED 2019b30: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2019b34: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 2019b38: 05 00 80 ef sethi %hi(0x203bc00), %g2 <== NOT EXECUTED 2019b3c: 84 10 a0 10 or %g2, 0x10, %g2 ! 203bc10 <_Objects_Information_table> <== NOT EXECUTED 2019b40: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 2019b44: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 2019b48: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2019b4c: 22 bf ff de be,a 2019ac4 <== NOT EXECUTED 2019b50: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2019b54: 7f ff c2 b5 call 200a628 <_Objects_Get> <== NOT EXECUTED 2019b58: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 2019b5c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2019b60: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2019b64: 02 bf ff c2 be 2019a6c <== NOT EXECUTED 2019b68: 05 00 80 ef sethi %hi(0x203bc00), %g2 <== NOT EXECUTED 2019b6c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2019b70: 18 bf ff d5 bgu 2019ac4 <== NOT EXECUTED 2019b74: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2019b78: 81 c7 e0 08 ret <== NOT EXECUTED 2019b7c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 02012aa0 : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 2012aa0: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2012aa4: 11 00 80 c9 sethi %hi(0x2032400), %o0 2012aa8: 92 10 00 18 mov %i0, %o1 2012aac: 90 12 21 2c or %o0, 0x12c, %o0 2012ab0: 40 00 0a ac call 2015560 <_Objects_Get> 2012ab4: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012ab8: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012abc: 80 a0 60 00 cmp %g1, 0 2012ac0: 12 80 00 11 bne 2012b04 2012ac4: 82 18 60 02 xor %g1, 2, %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 2012ac8: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 2012acc: 80 a0 60 04 cmp %g1, 4 2012ad0: 12 80 00 16 bne 2012b28 2012ad4: 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 ) 2012ad8: 03 00 80 c8 sethi %hi(0x2032000), %g1 <== NOT EXECUTED 2012adc: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2012ae0: b0 10 20 00 clr %i0 <== NOT EXECUTED 2012ae4: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 2012ae8: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] <== NOT EXECUTED 2012aec: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 <== NOT EXECUTED 2012af0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 2012af4: 02 80 00 09 be 2012b18 <== NOT EXECUTED 2012af8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012afc: 81 c7 e0 08 ret <== NOT EXECUTED 2012b00: 81 e8 00 00 restore <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012b04: 80 a0 00 01 cmp %g0, %g1 2012b08: 84 60 20 00 subx %g0, 0, %g2 2012b0c: b0 08 a0 15 and %g2, 0x15, %i0 2012b10: 81 c7 e0 08 ret 2012b14: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 2012b18: 40 00 0f c6 call 2016a30 <_Thread_Dispatch> 2012b1c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012b20: 81 c7 e0 08 ret 2012b24: 81 e8 00 00 restore case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) (void) _Watchdog_Remove( &the_timer->Ticker ); 2012b28: 40 00 16 c0 call 2018628 <_Watchdog_Remove> 2012b2c: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2012b30: 03 00 80 c8 sethi %hi(0x2032000), %g1 2012b34: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 2012b38: b0 10 20 00 clr %i0 2012b3c: 84 00 bf ff add %g2, -1, %g2 2012b40: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 2012b44: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 2012b48: 80 a0 e0 00 cmp %g3, 0 2012b4c: 12 bf ff f5 bne 2012b20 2012b50: 01 00 00 00 nop 2012b54: 30 bf ff f1 b,a 2012b18 02012c44 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 2012c44: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2012c48: 21 00 80 c9 sethi %hi(0x2032400), %l0 2012c4c: 92 10 00 18 mov %i0, %o1 2012c50: 94 07 bf f4 add %fp, -12, %o2 2012c54: 40 00 0a 43 call 2015560 <_Objects_Get> 2012c58: 90 14 21 2c or %l0, 0x12c, %o0 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012c5c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012c60: 80 a0 60 00 cmp %g1, 0 2012c64: 12 80 00 1f bne 2012ce0 2012c68: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012c6c: a0 14 21 2c or %l0, 0x12c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2012c70: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012c74: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 2012c78: 05 00 00 3f sethi %hi(0xfc00), %g2 2012c7c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2012c80: 82 08 40 02 and %g1, %g2, %g1 2012c84: 80 a0 40 03 cmp %g1, %g3 2012c88: 38 80 00 06 bgu,a 2012ca0 2012c8c: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2012c90: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 2012c94: 83 28 60 02 sll %g1, 2, %g1 2012c98: 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; 2012c9c: 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 ); 2012ca0: 40 00 16 62 call 2018628 <_Watchdog_Remove> 2012ca4: 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 ); 2012ca8: 90 10 00 10 mov %l0, %o0 2012cac: 40 00 09 d6 call 2015404 <_Objects_Free> 2012cb0: 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 ) 2012cb4: 03 00 80 c8 sethi %hi(0x2032000), %g1 2012cb8: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 2012cbc: b0 10 20 00 clr %i0 2012cc0: 84 00 bf ff add %g2, -1, %g2 2012cc4: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 2012cc8: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 2012ccc: 80 a0 e0 00 cmp %g3, 0 2012cd0: 02 80 00 0a be 2012cf8 2012cd4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012cd8: 81 c7 e0 08 ret <== NOT EXECUTED 2012cdc: 81 e8 00 00 restore <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012ce0: 82 18 60 02 xor %g1, 2, %g1 2012ce4: 80 a0 00 01 cmp %g0, %g1 2012ce8: 84 60 20 00 subx %g0, 0, %g2 2012cec: b0 08 a0 15 and %g2, 0x15, %i0 2012cf0: 81 c7 e0 08 ret 2012cf4: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 2012cf8: 40 00 0f 4e call 2016a30 <_Thread_Dispatch> 2012cfc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012d00: 81 c7 e0 08 ret 2012d04: 81 e8 00 00 restore 02012d08 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 2012d08: 9d e3 bf 90 save %sp, -112, %sp 2012d0c: a4 10 00 18 mov %i0, %l2 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 2012d10: 80 a6 60 00 cmp %i1, 0 2012d14: 02 80 00 3e be 2012e0c 2012d18: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( !routine ) 2012d1c: 80 a6 a0 00 cmp %i2, 0 2012d20: 02 80 00 3b be 2012e0c 2012d24: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2012d28: 11 00 80 c9 sethi %hi(0x2032400), %o0 2012d2c: 92 10 00 12 mov %l2, %o1 2012d30: 90 12 21 2c or %o0, 0x12c, %o0 2012d34: 40 00 0a 0b call 2015560 <_Objects_Get> 2012d38: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012d3c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012d40: 80 a0 60 00 cmp %g1, 0 2012d44: 12 80 00 17 bne 2012da0 2012d48: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 2012d4c: a2 02 20 10 add %o0, 0x10, %l1 2012d50: 40 00 16 36 call 2018628 <_Watchdog_Remove> 2012d54: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 2012d58: 7f ff df 6a call 200ab00 2012d5c: 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 ) { 2012d60: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 2012d64: 80 a0 60 00 cmp %g1, 0 2012d68: 22 80 00 14 be,a 2012db8 2012d6c: f4 24 20 2c st %i2, [ %l0 + 0x2c ] _ISR_Enable( level ); 2012d70: 7f ff df 68 call 200ab10 <== NOT EXECUTED 2012d74: 01 00 00 00 nop <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2012d78: 03 00 80 c8 sethi %hi(0x2032000), %g1 <== NOT EXECUTED 2012d7c: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2012d80: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 2012d84: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] <== NOT EXECUTED 2012d88: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 <== NOT EXECUTED 2012d8c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 2012d90: 02 80 00 1d be 2012e04 <== NOT EXECUTED 2012d94: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012d98: 81 c7 e0 08 ret <== NOT EXECUTED 2012d9c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012da0: 82 18 60 02 xor %g1, 2, %g1 2012da4: 80 a0 00 01 cmp %g0, %g1 2012da8: 84 60 20 00 subx %g0, 0, %g2 2012dac: b0 08 a0 15 and %g2, 0x15, %i0 2012db0: 81 c7 e0 08 ret 2012db4: 91 ee 20 04 restore %i0, 4, %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 2012db8: e4 24 20 30 st %l2, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 2012dbc: 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; 2012dc0: c0 24 20 38 clr [ %l0 + 0x38 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012dc4: c0 24 20 18 clr [ %l0 + 0x18 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 2012dc8: 7f ff df 52 call 200ab10 2012dcc: 01 00 00 00 nop ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012dd0: 92 10 00 11 mov %l1, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012dd4: f2 24 20 1c st %i1, [ %l0 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012dd8: 11 00 80 c8 sethi %hi(0x2032000), %o0 2012ddc: 40 00 15 a9 call 2018480 <_Watchdog_Insert> 2012de0: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 20322c0 <_Watchdog_Ticks_chain> 2012de4: 05 00 80 c8 sethi %hi(0x2032000), %g2 2012de8: c2 00 a1 c0 ld [ %g2 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 2012dec: 82 00 7f ff add %g1, -1, %g1 2012df0: c2 20 a1 c0 st %g1, [ %g2 + 0x1c0 ] 2012df4: c6 00 a1 c0 ld [ %g2 + 0x1c0 ], %g3 2012df8: 80 a0 e0 00 cmp %g3, 0 2012dfc: 32 80 00 04 bne,a 2012e0c 2012e00: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Dispatch(); 2012e04: 40 00 0f 0b call 2016a30 <_Thread_Dispatch> 2012e08: b0 10 20 00 clr %i0 2012e0c: 81 c7 e0 08 ret 2012e10: 81 e8 00 00 restore 02008650 : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 2008650: 9d e3 bf 90 save %sp, -112, %sp 2008654: 92 10 00 18 mov %i0, %o1 Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 2008658: 80 a6 60 00 cmp %i1, 0 200865c: 02 80 00 1b be 20086c8 2008660: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2008664: 11 00 80 78 sethi %hi(0x201e000), %o0 2008668: 94 07 bf f4 add %fp, -12, %o2 200866c: 40 00 07 90 call 200a4ac <_Objects_Get> 2008670: 90 12 20 80 or %o0, 0x80, %o0 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2008674: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008678: 80 a0 60 00 cmp %g1, 0 200867c: 12 80 00 15 bne 20086d0 2008680: 82 18 60 02 xor %g1, 2, %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; the_info->initial = the_timer->Ticker.initial; 2008684: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 2008688: c6 02 20 38 ld [ %o0 + 0x38 ], %g3 the_info->initial = the_timer->Ticker.initial; 200868c: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->start_time = the_timer->Ticker.start_time; 2008690: c4 02 20 24 ld [ %o0 + 0x24 ], %g2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 2008694: c6 26 40 00 st %g3, [ %i1 ] the_info->initial = the_timer->Ticker.initial; the_info->start_time = the_timer->Ticker.start_time; 2008698: c4 26 60 08 st %g2, [ %i1 + 8 ] the_info->stop_time = the_timer->Ticker.stop_time; 200869c: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 20086a0: 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 ) 20086a4: 07 00 80 78 sethi %hi(0x201e000), %g3 20086a8: c2 00 e2 60 ld [ %g3 + 0x260 ], %g1 ! 201e260 <_Thread_Dispatch_disable_level> 20086ac: b0 10 20 00 clr %i0 20086b0: 82 00 7f ff add %g1, -1, %g1 20086b4: c2 20 e2 60 st %g1, [ %g3 + 0x260 ] 20086b8: c4 00 e2 60 ld [ %g3 + 0x260 ], %g2 20086bc: 80 a0 a0 00 cmp %g2, 0 20086c0: 02 80 00 09 be 20086e4 20086c4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20086c8: 81 c7 e0 08 ret <== NOT EXECUTED 20086cc: 81 e8 00 00 restore <== NOT EXECUTED if ( !the_info ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20086d0: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 20086d4: 84 60 20 00 subx %g0, 0, %g2 <== NOT EXECUTED 20086d8: b0 08 a0 15 and %g2, 0x15, %i0 <== NOT EXECUTED 20086dc: 81 c7 e0 08 ret <== NOT EXECUTED 20086e0: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED _Thread_Dispatch(); 20086e4: 40 00 0c a6 call 200b97c <_Thread_Dispatch> 20086e8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20086ec: 81 c7 e0 08 ret 20086f0: 81 e8 00 00 restore 0201356c : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 201356c: 9d e3 bf 90 save %sp, -112, %sp /* * Make sure the requested priority is valid. */ _priority = priority; if ( priority == RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 2013570: 92 10 20 00 clr %o1 2013574: 80 a6 3f ff cmp %i0, -1 2013578: 02 80 00 07 be 2013594 201357c: 94 10 00 19 mov %i1, %o2 _priority = 0; else if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) 2013580: 82 06 3f ff add %i0, -1, %g1 2013584: 80 a0 60 fe cmp %g1, 0xfe 2013588: 18 80 00 16 bgu 20135e0 201358c: a2 10 20 13 mov 0x13, %l1 2013590: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2013594: 21 00 80 c8 sethi %hi(0x2032000), %l0 2013598: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 ! 20321c0 <_Thread_Dispatch_disable_level> 201359c: 82 00 60 01 inc %g1 20135a0: c2 24 21 c0 st %g1, [ %l0 + 0x1c0 ] * Just to make sure the test versus create/start operation are atomic. */ _Thread_Disable_dispatch(); if ( _Timer_Server ) { 20135a4: 33 00 80 c9 sethi %hi(0x2032400), %i1 20135a8: c2 06 61 78 ld [ %i1 + 0x178 ], %g1 ! 2032578 <_Timer_Server> 20135ac: 80 a0 60 00 cmp %g1, 0 20135b0: 02 80 00 0e be 20135e8 20135b4: 19 00 00 20 sethi %hi(0x8000), %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20135b8: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 <== NOT EXECUTED 20135bc: a2 10 20 0e mov 0xe, %l1 <== NOT EXECUTED _Thread_Dispatch(); 20135c0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20135c4: c2 24 21 c0 st %g1, [ %l0 + 0x1c0 ] 20135c8: c4 04 21 c0 ld [ %l0 + 0x1c0 ], %g2 20135cc: 80 a0 a0 00 cmp %g2, 0 20135d0: 12 80 00 04 bne 20135e0 20135d4: 01 00 00 00 nop 20135d8: 40 00 0d 16 call 2016a30 <_Thread_Dispatch> 20135dc: 01 00 00 00 nop _Watchdog_Initialize( &_Timer_Server->Timer, _Thread_Delay_ended, id, NULL ); _Watchdog_Initialize( &_Timer_Seconds_timer, _Thread_Delay_ended, id, NULL ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 20135e0: 81 c7 e0 08 ret 20135e4: 91 e8 00 11 restore %g0, %l1, %o0 * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 20135e8: 11 15 12 53 sethi %hi(0x54494c00), %o0 20135ec: 98 16 80 0c or %i2, %o4, %o4 20135f0: 90 12 21 45 or %o0, 0x145, %o0 20135f4: 96 10 21 00 mov 0x100, %o3 20135f8: 7f ff f9 fd call 2011dec 20135fc: 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) { 2013600: a2 92 20 00 orcc %o0, 0, %l1 2013604: 02 80 00 05 be 2013618 2013608: d0 07 bf f4 ld [ %fp + -12 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201360c: c2 04 21 c0 ld [ %l0 + 0x1c0 ], %g1 2013610: 10 bf ff ed b 20135c4 2013614: 82 00 7f ff add %g1, -1, %g1 _Thread_Enable_dispatch(); return status; } status = rtems_task_start( 2013618: 13 00 80 4d sethi %hi(0x2013400), %o1 201361c: 94 10 20 00 clr %o2 2013620: 7f ff fc 3d call 2012714 2013624: 92 12 60 18 or %o1, 0x18, %o1 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 2013628: a2 92 20 00 orcc %o0, 0, %l1 201362c: 12 bf ff f8 bne 201360c 2013630: 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 ) 2013634: 03 00 80 c8 sethi %hi(0x2032000), %g1 2013638: 9a 10 60 70 or %g1, 0x70, %o5 ! 2032070 <_RTEMS_tasks_Information> 201363c: c4 13 60 10 lduh [ %o5 + 0x10 ], %g2 2013640: 03 00 00 3f sethi %hi(0xfc00), %g1 2013644: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2013648: 86 09 00 01 and %g4, %g1, %g3 201364c: 80 a0 c0 02 cmp %g3, %g2 2013650: 18 80 00 05 bgu 2013664 2013654: 82 10 20 00 clr %g1 2013658: c4 03 60 20 ld [ %o5 + 0x20 ], %g2 201365c: 83 28 e0 02 sll %g3, 2, %g1 2013660: c2 00 80 01 ld [ %g2 + %g1 ], %g1 ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2013664: c0 20 60 6c clr [ %g1 + 0x6c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2013668: c0 20 60 50 clr [ %g1 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; 201366c: c8 20 60 68 st %g4, [ %g1 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2013670: 07 00 80 5a sethi %hi(0x2016800), %g3 * * NOTE: Setting the pointer to the Timer Server TCB to a value other than * NULL indicates that task-based timer support is initialized. */ _Timer_Server = (Thread_Control *)_Objects_Get_local_object( 2013674: c2 26 61 78 st %g1, [ %i1 + 0x178 ] 2013678: 86 10 e1 8c or %g3, 0x18c, %g3 201367c: c6 20 60 64 st %g3, [ %g1 + 0x64 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2013680: 03 00 80 c8 sethi %hi(0x2032000), %g1 2013684: 82 10 60 c0 or %g1, 0xc0, %g1 ! 20320c0 <_Timer_Ticks_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2013688: c2 20 7f fc st %g1, [ %g1 + -4 ] 201368c: 82 00 7f fc add %g1, -4, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2013690: 05 00 80 c8 sethi %hi(0x2032000), %g2 Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2013694: c2 20 60 08 st %g1, [ %g1 + 8 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2013698: 84 10 a0 d4 or %g2, 0xd4, %g2 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 201369c: c0 20 60 04 clr [ %g1 + 4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 20136a0: c4 20 bf fc st %g2, [ %g2 + -4 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20136a4: 03 00 80 c8 sethi %hi(0x2032000), %g1 20136a8: 84 00 bf fc add %g2, -4, %g2 20136ac: 82 10 60 dc or %g1, 0xdc, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 20136b0: c4 20 a0 08 st %g2, [ %g2 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 20136b4: c0 20 a0 04 clr [ %g2 + 4 ] the_watchdog->routine = routine; 20136b8: c6 20 60 1c st %g3, [ %g1 + 0x1c ] the_watchdog->id = id; 20136bc: c8 20 60 20 st %g4, [ %g1 + 0x20 ] the_watchdog->user_data = user_data; 20136c0: c0 20 60 24 clr [ %g1 + 0x24 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20136c4: 10 bf ff d2 b 201360c 20136c8: c0 20 60 08 clr [ %g1 + 8 ] 02012f60 : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 2012f60: 9d e3 bf 90 save %sp, -112, %sp 2012f64: 11 00 80 c9 sethi %hi(0x2032400), %o0 2012f68: 92 10 00 18 mov %i0, %o1 2012f6c: 90 12 21 2c or %o0, 0x12c, %o0 2012f70: 40 00 09 7c call 2015560 <_Objects_Get> 2012f74: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012f78: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012f7c: 80 a0 60 00 cmp %g1, 0 2012f80: 12 80 00 18 bne 2012fe0 2012f84: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 2012f88: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 2012f8c: 80 a0 60 01 cmp %g1, 1 2012f90: 22 80 00 2f be,a 201304c 2012f94: 31 00 80 c9 sethi %hi(0x2032400), %i0 2012f98: 2a 80 00 18 bcs,a 2012ff8 2012f9c: a0 02 20 10 add %o0, 0x10, %l0 2012fa0: 80 a0 60 04 cmp %g1, 4 2012fa4: 18 80 00 1b bgu 2013010 2012fa8: 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 ) 2012fac: 03 00 80 c8 sethi %hi(0x2032000), %g1 2012fb0: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 2012fb4: b0 10 20 0b mov 0xb, %i0 2012fb8: 84 00 bf ff add %g2, -1, %g2 2012fbc: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 2012fc0: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 2012fc4: 80 a0 e0 00 cmp %g3, 0 2012fc8: 12 80 00 1f bne 2013044 2012fcc: 01 00 00 00 nop _Thread_Dispatch(); 2012fd0: 40 00 0e 98 call 2016a30 <_Thread_Dispatch> 2012fd4: 01 00 00 00 nop 2012fd8: 81 c7 e0 08 ret 2012fdc: 81 e8 00 00 restore { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012fe0: 82 18 60 02 xor %g1, 2, %g1 2012fe4: 80 a0 00 01 cmp %g0, %g1 2012fe8: 84 60 20 00 subx %g0, 0, %g2 2012fec: b0 08 a0 15 and %g2, 0x15, %i0 2012ff0: 81 c7 e0 08 ret 2012ff4: 91 ee 20 04 restore %i0, 4, %o0 return RTEMS_INVALID_ID; case OBJECTS_LOCAL: switch ( the_timer->the_class ) { case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); 2012ff8: 40 00 15 8c call 2018628 <_Watchdog_Remove> 2012ffc: 90 10 00 10 mov %l0, %o0 _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 2013000: 11 00 80 c8 sethi %hi(0x2032000), %o0 2013004: 92 10 00 10 mov %l0, %o1 2013008: 40 00 15 1e call 2018480 <_Watchdog_Insert> 201300c: 90 12 22 c0 or %o0, 0x2c0, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2013010: 03 00 80 c8 sethi %hi(0x2032000), %g1 2013014: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> 2013018: b0 10 20 00 clr %i0 201301c: 84 00 bf ff add %g2, -1, %g2 2013020: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 2013024: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 2013028: 80 a0 e0 00 cmp %g3, 0 201302c: 02 80 00 04 be 201303c 2013030: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2013034: 81 c7 e0 08 ret <== NOT EXECUTED 2013038: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 201303c: 40 00 0e 7d call 2016a30 <_Thread_Dispatch> 2013040: 01 00 00 00 nop 2013044: 81 c7 e0 08 ret 2013048: 81 e8 00 00 restore case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: _Timer_Server_stop_ticks_timer(); 201304c: d0 06 21 78 ld [ %i0 + 0x178 ], %o0 _Watchdog_Remove( &the_timer->Ticker ); 2013050: a2 04 20 10 add %l0, 0x10, %l1 case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: _Timer_Server_stop_ticks_timer(); 2013054: 40 00 15 75 call 2018628 <_Watchdog_Remove> 2013058: 90 02 20 48 add %o0, 0x48, %o0 _Watchdog_Remove( &the_timer->Ticker ); 201305c: 40 00 15 73 call 2018628 <_Watchdog_Remove> 2013060: 90 10 00 11 mov %l1, %o0 _Timer_Server_process_ticks_chain(); 2013064: 40 00 00 dc call 20133d4 <_Timer_Server_process_ticks_chain> 2013068: 21 00 80 c8 sethi %hi(0x2032000), %l0 _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 201306c: 92 10 00 11 mov %l1, %o1 2013070: 40 00 15 04 call 2018480 <_Watchdog_Insert> 2013074: 90 14 20 bc or %l0, 0xbc, %o0 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2013078: c4 04 20 bc ld [ %l0 + 0xbc ], %g2 201307c: a0 14 20 bc or %l0, 0xbc, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2013080: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 2013084: 80 a0 80 10 cmp %g2, %l0 2013088: 02 bf ff e2 be 2013010 201308c: c2 06 21 78 ld [ %i0 + 0x178 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2013090: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2013094: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2013098: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 201309c: 11 00 80 c8 sethi %hi(0x2032000), %o0 20130a0: 40 00 14 f8 call 2018480 <_Watchdog_Insert> 20130a4: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 20322c0 <_Watchdog_Ticks_chain> 20130a8: 30 bf ff da b,a 2013010 020130ac : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 20130ac: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 20130b0: 23 00 80 c9 sethi %hi(0x2032400), %l1 20130b4: c2 04 61 78 ld [ %l1 + 0x178 ], %g1 ! 2032578 <_Timer_Server> Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 20130b8: a6 10 00 18 mov %i0, %l3 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 20130bc: 80 a0 60 00 cmp %g1, 0 20130c0: 02 80 00 3b be 20131ac 20130c4: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; if ( !routine ) 20130c8: 80 a6 a0 00 cmp %i2, 0 20130cc: 02 80 00 38 be 20131ac 20130d0: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 20130d4: 80 a6 60 00 cmp %i1, 0 20130d8: 02 80 00 35 be 20131ac 20130dc: b0 10 20 0a mov 0xa, %i0 20130e0: 11 00 80 c9 sethi %hi(0x2032400), %o0 20130e4: 92 10 00 13 mov %l3, %o1 20130e8: 90 12 21 2c or %o0, 0x12c, %o0 20130ec: 40 00 09 1d call 2015560 <_Objects_Get> 20130f0: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20130f4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20130f8: 80 a0 60 00 cmp %g1, 0 20130fc: 12 80 00 30 bne 20131bc 2013100: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 2013104: a4 02 20 10 add %o0, 0x10, %l2 2013108: 40 00 15 48 call 2018628 <_Watchdog_Remove> 201310c: 90 10 00 12 mov %l2, %o0 _ISR_Disable( level ); 2013110: 7f ff de 7c call 200ab00 2013114: 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 ) { 2013118: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 201311c: 80 a0 60 00 cmp %g1, 0 2013120: 12 80 00 2d bne 20131d4 2013124: 82 10 20 01 mov 1, %g1 * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL_ON_TASK; _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 2013128: f2 24 20 1c st %i1, [ %l0 + 0x1c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 201312c: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 2013130: e6 24 20 30 st %l3, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 2013134: f6 24 20 34 st %i3, [ %l0 + 0x34 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2013138: 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; 201313c: 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 ); 2013140: 7f ff de 74 call 200ab10 2013144: 21 00 80 c8 sethi %hi(0x2032000), %l0 _Timer_Server_stop_ticks_timer(); 2013148: d0 04 61 78 ld [ %l1 + 0x178 ], %o0 201314c: 40 00 15 37 call 2018628 <_Watchdog_Remove> 2013150: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_process_ticks_chain(); 2013154: 40 00 00 a0 call 20133d4 <_Timer_Server_process_ticks_chain> 2013158: 01 00 00 00 nop _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 201315c: 90 14 20 bc or %l0, 0xbc, %o0 2013160: 40 00 14 c8 call 2018480 <_Watchdog_Insert> 2013164: 92 10 00 12 mov %l2, %o1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2013168: c4 04 20 bc ld [ %l0 + 0xbc ], %g2 201316c: a0 14 20 bc or %l0, 0xbc, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2013170: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 2013174: 80 a0 80 10 cmp %g2, %l0 2013178: 12 80 00 1a bne 20131e0 201317c: c2 04 61 78 ld [ %l1 + 0x178 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2013180: 03 00 80 c8 sethi %hi(0x2032000), %g1 2013184: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20321c0 <_Thread_Dispatch_disable_level> _Thread_Dispatch(); 2013188: b0 10 20 00 clr %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201318c: 84 00 bf ff add %g2, -1, %g2 2013190: c4 20 61 c0 st %g2, [ %g1 + 0x1c0 ] 2013194: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 2013198: 80 a0 e0 00 cmp %g3, 0 201319c: 12 80 00 06 bne 20131b4 20131a0: 01 00 00 00 nop _Thread_Dispatch(); 20131a4: 40 00 0e 23 call 2016a30 <_Thread_Dispatch> 20131a8: b0 10 20 00 clr %i0 ! 0 20131ac: 81 c7 e0 08 ret 20131b0: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20131b4: 81 c7 e0 08 ret <== NOT EXECUTED 20131b8: 81 e8 00 00 restore <== NOT EXECUTED if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20131bc: 82 18 60 02 xor %g1, 2, %g1 20131c0: 80 a0 00 01 cmp %g0, %g1 20131c4: 84 60 20 00 subx %g0, 0, %g2 20131c8: b0 08 a0 15 and %g2, 0x15, %i0 20131cc: 81 c7 e0 08 ret 20131d0: 91 ee 20 04 restore %i0, 4, %o0 * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 20131d4: 7f ff de 4f call 200ab10 <== NOT EXECUTED 20131d8: 01 00 00 00 nop <== NOT EXECUTED 20131dc: 30 bf ff e9 b,a 2013180 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20131e0: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20131e4: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20131e8: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20131ec: 11 00 80 c8 sethi %hi(0x2032000), %o0 20131f0: 40 00 14 a4 call 2018480 <_Watchdog_Insert> 20131f4: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 20322c0 <_Watchdog_Ticks_chain> 20131f8: 30 bf ff e2 b,a 2013180