020066c0 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 20066c0: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 20066c4: 03 00 80 5f sethi %hi(0x2017c00), %g1 20066c8: e0 00 62 40 ld [ %g1 + 0x240 ], %l0 ! 2017e40 <_API_extensions_List> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 20066cc: 03 00 80 5f sethi %hi(0x2017c00), %g1 20066d0: 10 80 00 08 b 20066f0 <_API_extensions_Run_postdriver+0x30> 20066d4: a2 10 62 44 or %g1, 0x244, %l1 ! 2017e44 <_API_extensions_List+0x4> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 20066d8: 80 a0 60 00 cmp %g1, 0 20066dc: 22 80 00 05 be,a 20066f0 <_API_extensions_Run_postdriver+0x30> 20066e0: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postdriver_hook)(); 20066e4: 9f c0 40 00 call %g1 20066e8: 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 ) { 20066ec: 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 ) ; 20066f0: 80 a4 00 11 cmp %l0, %l1 20066f4: 32 bf ff f9 bne,a 20066d8 <_API_extensions_Run_postdriver+0x18> 20066f8: c2 04 20 0c ld [ %l0 + 0xc ], %g1 the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 20066fc: 81 c7 e0 08 ret 2006700: 81 e8 00 00 restore 02006764 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 2006764: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 2006768: 03 00 80 5f sethi %hi(0x2017c00), %g1 200676c: e0 00 62 40 ld [ %g1 + 0x240 ], %l0 ! 2017e40 <_API_extensions_List> the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); 2006770: 23 00 80 5f sethi %hi(0x2017c00), %l1 2006774: 03 00 80 5f sethi %hi(0x2017c00), %g1 2006778: 10 80 00 08 b 2006798 <_API_extensions_Run_postswitch+0x34> 200677c: a4 10 62 44 or %g1, 0x244, %l2 ! 2017e44 <_API_extensions_List+0x4> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 2006780: 80 a0 60 00 cmp %g1, 0 2006784: 22 80 00 05 be,a 2006798 <_API_extensions_Run_postswitch+0x34> 2006788: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 200678c: 9f c0 40 00 call %g1 2006790: d0 04 60 90 ld [ %l1 + 0x90 ], %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 ) { 2006794: 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 ) ; 2006798: 80 a4 00 12 cmp %l0, %l2 200679c: 32 bf ff f9 bne,a 2006780 <_API_extensions_Run_postswitch+0x1c> 20067a0: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); } } 20067a4: 81 c7 e0 08 ret 20067a8: 81 e8 00 00 restore 02006720 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 2006720: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 2006724: 03 00 80 5f sethi %hi(0x2017c00), %g1 2006728: e0 00 62 40 ld [ %g1 + 0x240 ], %l0 ! 2017e40 <_API_extensions_List> 200672c: 03 00 80 5f sethi %hi(0x2017c00), %g1 2006730: 10 80 00 08 b 2006750 <_API_extensions_Run_predriver+0x30> 2006734: a2 10 62 44 or %g1, 0x244, %l1 ! 2017e44 <_API_extensions_List+0x4> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 2006738: 80 a0 60 00 cmp %g1, 0 200673c: 22 80 00 05 be,a 2006750 <_API_extensions_Run_predriver+0x30> 2006740: e0 04 00 00 ld [ %l0 ], %l0 (*the_extension->predriver_hook)(); 2006744: 9f c0 40 00 call %g1 <== NOT EXECUTED 2006748: 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 ) { 200674c: 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 ) ; 2006750: 80 a4 00 11 cmp %l0, %l1 2006754: 32 bf ff f9 bne,a 2006738 <_API_extensions_Run_predriver+0x18> 2006758: c2 04 20 08 ld [ %l0 + 8 ], %g1 the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 200675c: 81 c7 e0 08 ret 2006760: 81 e8 00 00 restore 0201346c <_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 ) { 201346c: 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 ) { 2013470: 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 ) { 2013474: 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 ) { 2013478: 80 a6 80 01 cmp %i2, %g1 201347c: 18 80 00 17 bgu 20134d8 <_CORE_message_queue_Broadcast+0x6c> 2013480: 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 ) { 2013484: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1 2013488: 80 a0 60 00 cmp %g1, 0 201348c: 02 80 00 0a be 20134b4 <_CORE_message_queue_Broadcast+0x48> 2013490: a2 10 20 00 clr %l1 *count = 0; 2013494: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED 2013498: 81 c7 e0 08 ret <== NOT EXECUTED 201349c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 20134a0: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 20134a4: 40 00 20 ad call 201b758 20134a8: a2 04 60 01 inc %l1 buffer, waitp->return_argument, size ); *(uint32_t *)the_thread->Wait.return_argument_1 = size; 20134ac: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 20134b0: 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))) { 20134b4: 40 00 0b 7f call 20162b0 <_Thread_queue_Dequeue> 20134b8: 90 10 00 12 mov %l2, %o0 20134bc: 92 10 00 19 mov %i1, %o1 20134c0: a0 10 00 08 mov %o0, %l0 20134c4: 80 a2 20 00 cmp %o0, 0 20134c8: 12 bf ff f6 bne 20134a0 <_CORE_message_queue_Broadcast+0x34> 20134cc: 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; 20134d0: e2 27 40 00 st %l1, [ %i5 ] 20134d4: b0 10 20 00 clr %i0 return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 20134d8: 81 c7 e0 08 ret 20134dc: 81 e8 00 00 restore 0201359c <_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 ) { 201359c: 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; 20135a0: 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; 20135a4: 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; 20135a8: 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; 20135ac: c0 26 20 60 clr [ %i0 + 0x60 ] the_message_queue->notify_argument = the_argument; 20135b0: 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)) { 20135b4: 80 8e e0 03 btst 3, %i3 20135b8: 02 80 00 07 be 20135d4 <_CORE_message_queue_Initialize+0x38> 20135bc: a0 10 00 1b mov %i3, %l0 allocated_message_size += sizeof(uint32_t); 20135c0: 82 06 e0 04 add %i3, 4, %g1 allocated_message_size &= ~(sizeof(uint32_t) - 1); 20135c4: a0 08 7f fc and %g1, -4, %l0 } if (allocated_message_size < maximum_message_size) 20135c8: 80 a4 00 1b cmp %l0, %i3 20135cc: 0a 80 00 24 bcs 201365c <_CORE_message_queue_Initialize+0xc0> 20135d0: 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 * 20135d4: b6 04 20 14 add %l0, 0x14, %i3 20135d8: 92 10 00 1a mov %i2, %o1 20135dc: 40 00 40 a8 call 202387c <.umul> 20135e0: 90 10 00 1b mov %i3, %o0 (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 20135e4: 80 a2 00 10 cmp %o0, %l0 20135e8: 0a 80 00 1d bcs 201365c <_CORE_message_queue_Initialize+0xc0> 20135ec: 92 10 00 08 mov %o0, %o1 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 20135f0: 11 00 80 c3 sethi %hi(0x2030c00), %o0 20135f4: 40 00 02 20 call 2013e74 <_Heap_Allocate> 20135f8: 90 12 23 fc or %o0, 0x3fc, %o0 ! 2030ffc <_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) 20135fc: 80 a2 20 00 cmp %o0, 0 2013600: 02 80 00 17 be 201365c <_CORE_message_queue_Initialize+0xc0> 2013604: d0 26 20 5c st %o0, [ %i0 + 0x5c ] /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 2013608: 92 10 00 08 mov %o0, %o1 201360c: 94 10 00 1a mov %i2, %o2 2013610: 90 06 20 68 add %i0, 0x68, %o0 2013614: 7f ff ff 88 call 2013434 <_Chain_Initialize> 2013618: 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( 201361c: c2 06 40 00 ld [ %i1 ], %g1 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2013620: c0 26 20 54 clr [ %i0 + 0x54 ] 2013624: 82 18 60 01 xor %g1, 1, %g1 2013628: 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); 201362c: 82 06 20 54 add %i0, 0x54, %g1 2013630: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2013634: 82 06 20 50 add %i0, 0x50, %g1 2013638: 90 10 00 18 mov %i0, %o0 201363c: c2 26 20 58 st %g1, [ %i0 + 0x58 ] 2013640: 92 60 3f ff subx %g0, -1, %o1 2013644: 94 10 20 80 mov 0x80, %o2 2013648: 96 10 20 06 mov 6, %o3 201364c: 40 00 0c 6e call 2016804 <_Thread_queue_Initialize> 2013650: b0 10 20 01 mov 1, %i0 2013654: 81 c7 e0 08 ret 2013658: 81 e8 00 00 restore STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return TRUE; } 201365c: 81 c7 e0 08 ret <== NOT EXECUTED 2013660: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 02015c1c <_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 ) { 2015c1c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; boolean notify = FALSE; the_message->priority = submit_type; switch ( submit_type ) { 2015c20: 03 20 00 00 sethi %hi(0x80000000), %g1 2015c24: 80 a6 80 01 cmp %i2, %g1 2015c28: 02 80 00 16 be 2015c80 <_CORE_message_queue_Insert_message+0x64> 2015c2c: f4 26 60 08 st %i2, [ %i1 + 8 ] 2015c30: 82 00 7c 00 add %g1, -1024, %g1 2015c34: 82 10 63 ff or %g1, 0x3ff, %g1 2015c38: 80 a6 80 01 cmp %i2, %g1 2015c3c: 32 80 00 20 bne,a 2015cbc <_CORE_message_queue_Insert_message+0xa0> 2015c40: e0 06 20 50 ld [ %i0 + 0x50 ], %l0 <== NOT EXECUTED case CORE_MESSAGE_QUEUE_SEND_REQUEST: _ISR_Disable( level ); 2015c44: 7f ff b2 29 call 20024e8 2015c48: 01 00 00 00 nop Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 2015c4c: 82 06 20 54 add %i0, 0x54, %g1 if ( the_message_queue->number_of_pending_messages++ == 0 ) 2015c50: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 2015c54: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 2015c58: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 the_chain->last = the_node; 2015c5c: f2 26 20 58 st %i1, [ %i0 + 0x58 ] 2015c60: 84 00 a0 01 inc %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 2015c64: c2 26 60 04 st %g1, [ %i1 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 2015c68: f2 20 40 00 st %i1, [ %g1 ] 2015c6c: c4 26 20 48 st %g2, [ %i0 + 0x48 ] 2015c70: 82 18 a0 01 xor %g2, 1, %g1 2015c74: 80 a0 00 01 cmp %g0, %g1 2015c78: a0 60 3f ff subx %g0, -1, %l0 notify = TRUE; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 2015c7c: 30 80 00 27 b,a 2015d18 <_CORE_message_queue_Insert_message+0xfc> break; case CORE_MESSAGE_QUEUE_URGENT_REQUEST: _ISR_Disable( level ); 2015c80: 7f ff b2 1a call 20024e8 2015c84: 01 00 00 00 nop ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 2015c88: c6 06 20 50 ld [ %i0 + 0x50 ], %g3 if ( the_message_queue->number_of_pending_messages++ == 0 ) 2015c8c: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 2015c90: 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; 2015c94: f2 26 20 50 st %i1, [ %i0 + 0x50 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 2015c98: c2 26 60 04 st %g1, [ %i1 + 4 ] 2015c9c: 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; 2015ca0: f2 20 e0 04 st %i1, [ %g3 + 4 ] 2015ca4: 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; 2015ca8: c6 26 40 00 st %g3, [ %i1 ] 2015cac: 80 a0 00 01 cmp %g0, %g1 2015cb0: c4 26 20 48 st %g2, [ %i0 + 0x48 ] 2015cb4: a0 60 3f ff subx %g0, -1, %l0 notify = TRUE; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 2015cb8: 30 80 00 18 b,a 2015d18 <_CORE_message_queue_Insert_message+0xfc> 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 ) ) { 2015cbc: 10 80 00 06 b 2015cd4 <_CORE_message_queue_Insert_message+0xb8> <== NOT EXECUTED 2015cc0: 84 06 20 54 add %i0, 0x54, %g2 <== NOT EXECUTED this_message = (CORE_message_queue_Buffer_control *) the_node; if ( this_message->priority <= the_message->priority ) { 2015cc4: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED 2015cc8: 14 80 00 06 bg 2015ce0 <_CORE_message_queue_Insert_message+0xc4> <== NOT EXECUTED 2015ccc: 01 00 00 00 nop <== NOT EXECUTED the_node = the_node->next; 2015cd0: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED 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 ) ) { 2015cd4: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 2015cd8: 32 bf ff fb bne,a 2015cc4 <_CORE_message_queue_Insert_message+0xa8> <== NOT EXECUTED 2015cdc: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 2015ce0: 7f ff b2 02 call 20024e8 <== NOT EXECUTED 2015ce4: 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 ); 2015ce8: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED } break; } _ISR_Disable( level ); if ( the_message_queue->number_of_pending_messages++ == 0 ) 2015cec: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 2015cf0: c6 00 40 00 ld [ %g1 ], %g3 <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 2015cf4: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; 2015cf8: f2 20 40 00 st %i1, [ %g1 ] <== NOT EXECUTED 2015cfc: 84 00 a0 01 inc %g2 <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 2015d00: f2 20 e0 04 st %i1, [ %g3 + 4 ] <== NOT EXECUTED 2015d04: 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; 2015d08: c6 26 40 00 st %g3, [ %i1 ] <== NOT EXECUTED 2015d0c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 2015d10: c4 26 20 48 st %g2, [ %i0 + 0x48 ] <== NOT EXECUTED 2015d14: a0 60 3f ff subx %g0, -1, %l0 <== NOT EXECUTED notify = TRUE; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); _ISR_Enable( level ); 2015d18: 7f ff b1 f8 call 20024f8 2015d1c: 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 ) 2015d20: 80 a4 20 00 cmp %l0, 0 2015d24: 02 80 00 08 be 2015d44 <_CORE_message_queue_Insert_message+0x128> 2015d28: 01 00 00 00 nop 2015d2c: c2 06 20 60 ld [ %i0 + 0x60 ], %g1 2015d30: 80 a0 60 00 cmp %g1, 0 2015d34: 02 80 00 04 be 2015d44 <_CORE_message_queue_Insert_message+0x128> 2015d38: 01 00 00 00 nop (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 2015d3c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2015d40: d0 06 20 64 ld [ %i0 + 0x64 ], %o0 <== NOT EXECUTED 2015d44: 81 c7 e0 08 ret 2015d48: 81 e8 00 00 restore 02012e88 <_CORE_message_queue_Seize>: void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 2012e88: 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; 2012e8c: 03 00 80 99 sethi %hi(0x2026400), %g1 2012e90: e2 00 61 60 ld [ %g1 + 0x160 ], %l1 ! 2026560 <_Thread_Executing> void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 2012e94: 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 ); 2012e98: 7f ff bd 94 call 20024e8 2012e9c: c0 24 60 34 clr [ %l1 + 0x34 ] 2012ea0: 86 10 00 08 mov %o0, %g3 if ( the_message_queue->number_of_pending_messages != 0 ) { 2012ea4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2012ea8: 80 a0 60 00 cmp %g1, 0 2012eac: 02 80 00 2a be 2012f54 <_CORE_message_queue_Seize+0xcc> 2012eb0: 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)); 2012eb4: f2 06 20 50 ld [ %i0 + 0x50 ], %i1 the_message_queue->number_of_pending_messages -= 1; 2012eb8: 82 00 7f ff add %g1, -1, %g1 2012ebc: 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)) 2012ec0: 82 06 20 54 add %i0, 0x54, %g1 2012ec4: 80 a6 40 01 cmp %i1, %g1 2012ec8: 32 80 00 04 bne,a 2012ed8 <_CORE_message_queue_Seize+0x50> 2012ecc: c2 06 40 00 ld [ %i1 ], %g1 2012ed0: 10 80 00 05 b 2012ee4 <_CORE_message_queue_Seize+0x5c> <== NOT EXECUTED 2012ed4: b2 10 20 00 clr %i1 <== NOT EXECUTED Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; new_first->previous = _Chain_Head(the_chain); 2012ed8: 84 06 20 50 add %i0, 0x50, %g2 Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; 2012edc: c2 26 20 50 st %g1, [ %i0 + 0x50 ] new_first->previous = _Chain_Head(the_chain); 2012ee0: c4 20 60 04 st %g2, [ %g1 + 4 ] the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); 2012ee4: 7f ff bd 85 call 20024f8 2012ee8: 90 10 00 03 mov %g3, %o0 *size = the_message->Contents.size; 2012eec: d4 06 60 0c ld [ %i1 + 0xc ], %o2 _Thread_Executing->Wait.count = the_message->priority; 2012ef0: 03 00 80 99 sethi %hi(0x2026400), %g1 the_message_queue->number_of_pending_messages -= 1; the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); *size = the_message->Contents.size; 2012ef4: d4 26 c0 00 st %o2, [ %i3 ] _Thread_Executing->Wait.count = the_message->priority; 2012ef8: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 2012efc: c2 06 60 08 ld [ %i1 + 8 ], %g1 _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size); 2012f00: 92 10 00 1a mov %i2, %o1 the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); *size = the_message->Contents.size; _Thread_Executing->Wait.count = the_message->priority; 2012f04: c2 20 a0 24 st %g1, [ %g2 + 0x24 ] _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size); 2012f08: a2 06 60 10 add %i1, 0x10, %l1 2012f0c: 7f ff ff d8 call 2012e6c <_CORE_message_queue_Copy_buffer> 2012f10: 90 10 00 11 mov %l1, %o0 * * NOTE: If we note that the queue was not full before this receive, * then we can avoid this dequeue. */ the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 2012f14: 7f ff ea 59 call 200d878 <_Thread_queue_Dequeue> 2012f18: 90 10 00 10 mov %l0, %o0 if ( !the_thread ) { 2012f1c: 82 92 20 00 orcc %o0, 0, %g1 2012f20: 32 80 00 04 bne,a 2012f30 <_CORE_message_queue_Seize+0xa8> 2012f24: d4 00 60 30 ld [ %g1 + 0x30 ], %o2 <== NOT EXECUTED 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 ); 2012f28: 7f ff e0 37 call 200b004 <_Chain_Append> 2012f2c: 91 ec 20 68 restore %l0, 0x68, %o0 * waiting task. */ the_message->priority = the_thread->Wait.count; the_message->Contents.size = (uint32_t)the_thread->Wait.option; _CORE_message_queue_Copy_buffer( 2012f30: d0 00 60 28 ld [ %g1 + 0x28 ], %o0 <== 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; 2012f34: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 <== NOT EXECUTED the_message->Contents.size = (uint32_t)the_thread->Wait.option; 2012f38: 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; 2012f3c: c2 26 60 08 st %g1, [ %i1 + 8 ] <== NOT EXECUTED the_message->Contents.size = (uint32_t)the_thread->Wait.option; _CORE_message_queue_Copy_buffer( 2012f40: 7f ff ff cb call 2012e6c <_CORE_message_queue_Copy_buffer> <== NOT EXECUTED 2012f44: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED the_thread->Wait.return_argument, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 2012f48: f4 06 60 08 ld [ %i1 + 8 ], %i2 <== NOT EXECUTED 2012f4c: 40 00 0b 34 call 2015c1c <_CORE_message_queue_Insert_message> <== NOT EXECUTED 2012f50: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 2012f54: 12 80 00 08 bne 2012f74 <_CORE_message_queue_Seize+0xec> 2012f58: 82 10 20 01 mov 1, %g1 _ISR_Enable( level ); 2012f5c: 7f ff bd 67 call 20024f8 2012f60: 01 00 00 00 nop executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 2012f64: 82 10 20 04 mov 4, %g1 ! 4 2012f68: 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 ); } 2012f6c: 81 c7 e0 08 ret 2012f70: 81 e8 00 00 restore _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; executing->Wait.id = id; executing->Wait.return_argument = buffer; executing->Wait.return_argument_1 = (void *)size; 2012f74: 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; 2012f78: f0 24 60 44 st %i0, [ %l1 + 0x44 ] executing->Wait.id = id; 2012f7c: f2 24 60 20 st %i1, [ %l1 + 0x20 ] executing->Wait.return_argument = buffer; 2012f80: 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; 2012f84: 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 ); 2012f88: 7f ff bd 5c call 20024f8 2012f8c: 35 00 80 37 sethi %hi(0x200dc00), %i2 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 2012f90: b2 10 00 1d mov %i5, %i1 2012f94: 7f ff ea a7 call 200da30 <_Thread_queue_Enqueue_with_handler> 2012f98: 95 ee a2 c8 restore %i2, 0x2c8, %o2 2012f9c: 01 00 00 00 nop 02012fbc <_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 ) { 2012fbc: 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 ) { 2012fc0: 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 ) { 2012fc4: 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 ) { 2012fc8: 80 a6 80 01 cmp %i2, %g1 2012fcc: 18 80 00 3f bgu 20130c8 <_CORE_message_queue_Submit+0x10c> 2012fd0: 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 ) { 2012fd4: c2 04 60 48 ld [ %l1 + 0x48 ], %g1 2012fd8: 80 a0 60 00 cmp %g1, 0 2012fdc: 32 80 00 0f bne,a 2013018 <_CORE_message_queue_Submit+0x5c> 2012fe0: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 2012fe4: 7f ff ea 25 call 200d878 <_Thread_queue_Dequeue> 2012fe8: 90 10 00 11 mov %l1, %o0 if ( the_thread ) { 2012fec: a0 92 20 00 orcc %o0, 0, %l0 2012ff0: 02 80 00 09 be 2013014 <_CORE_message_queue_Submit+0x58> 2012ff4: 90 10 00 19 mov %i1, %o0 _CORE_message_queue_Copy_buffer( 2012ff8: d2 04 20 28 ld [ %l0 + 0x28 ], %o1 2012ffc: 7f ff ff e9 call 2012fa0 <_CORE_message_queue_Copy_buffer> 2013000: 94 10 00 1a mov %i2, %o2 buffer, the_thread->Wait.return_argument, size ); *(size_t *)the_thread->Wait.return_argument_1 = size; 2013004: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 the_thread->Wait.count = submit_type; 2013008: 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; 201300c: 10 80 00 15 b 2013060 <_CORE_message_queue_Submit+0xa4> 2013010: f4 20 40 00 st %i2, [ %g1 ] /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 2013014: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 2013018: c2 04 60 44 ld [ %l1 + 0x44 ], %g1 201301c: 80 a0 80 01 cmp %g2, %g1 2013020: 1a 80 00 12 bcc 2013068 <_CORE_message_queue_Submit+0xac> 2013024: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 RTEMS_INLINE_ROUTINE CORE_message_queue_Buffer_control * _CORE_message_queue_Allocate_message_buffer ( CORE_message_queue_Control *the_message_queue ) { return (CORE_message_queue_Buffer_control *) 2013028: 7f ff e0 03 call 200b034 <_Chain_Get> 201302c: 90 04 60 68 add %l1, 0x68, %o0 /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 2013030: a0 92 20 00 orcc %o0, 0, %l0 2013034: 02 80 00 27 be 20130d0 <_CORE_message_queue_Submit+0x114> 2013038: 90 10 00 19 mov %i1, %o0 return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; } _CORE_message_queue_Copy_buffer( 201303c: 92 04 20 10 add %l0, 0x10, %o1 2013040: 7f ff ff d8 call 2012fa0 <_CORE_message_queue_Copy_buffer> 2013044: 94 10 00 1a mov %i2, %o2 size ); the_message->Contents.size = size; the_message->priority = submit_type; _CORE_message_queue_Insert_message( 2013048: 90 10 00 11 mov %l1, %o0 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 201304c: f4 24 20 0c st %i2, [ %l0 + 0xc ] the_message->priority = submit_type; 2013050: fa 24 20 08 st %i5, [ %l0 + 8 ] _CORE_message_queue_Insert_message( 2013054: 92 10 00 10 mov %l0, %o1 2013058: 40 00 0a f1 call 2015c1c <_CORE_message_queue_Insert_message> 201305c: 94 10 00 1d mov %i5, %o2 2013060: 81 c7 e0 08 ret 2013064: 91 e8 20 00 restore %g0, 0, %o0 * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { 2013068: 80 a0 60 00 cmp %g1, 0 201306c: 02 80 00 17 be 20130c8 <_CORE_message_queue_Submit+0x10c> 2013070: 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() ) { 2013074: 03 00 80 99 sethi %hi(0x2026400), %g1 <== NOT EXECUTED 2013078: c2 00 61 48 ld [ %g1 + 0x148 ], %g1 ! 2026548 <_ISR_Nest_level> <== NOT EXECUTED 201307c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2013080: 12 80 00 14 bne 20130d0 <_CORE_message_queue_Submit+0x114> <== NOT EXECUTED 2013084: 03 00 80 99 sethi %hi(0x2026400), %g1 <== NOT EXECUTED */ { Thread_Control *executing = _Thread_Executing; _ISR_Disable( level ); 2013088: 7f ff bd 18 call 20024e8 <== NOT EXECUTED 201308c: e0 00 61 60 ld [ %g1 + 0x160 ], %l0 ! 2026560 <_Thread_Executing> <== NOT EXECUTED 2013090: 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; 2013094: 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; 2013098: f6 24 20 20 st %i3, [ %l0 + 0x20 ] <== NOT EXECUTED executing->Wait.return_argument = buffer; 201309c: f2 24 20 28 st %i1, [ %l0 + 0x28 ] <== NOT EXECUTED executing->Wait.option = size; 20130a0: 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; 20130a4: e2 24 20 44 st %l1, [ %l0 + 0x44 ] <== NOT EXECUTED 20130a8: 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 ); 20130ac: 7f ff bd 13 call 20024f8 <== NOT EXECUTED 20130b0: b0 10 20 07 mov 7, %i0 <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 20130b4: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 <== NOT EXECUTED 20130b8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20130bc: 15 00 80 37 sethi %hi(0x200dc00), %o2 <== NOT EXECUTED 20130c0: 7f ff ea 5c call 200da30 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 20130c4: 94 12 a2 c8 or %o2, 0x2c8, %o2 ! 200dec8 <_Thread_queue_Timeout> <== NOT EXECUTED 20130c8: 81 c7 e0 08 ret 20130cc: 81 e8 00 00 restore } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 20130d0: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED } 20130d4: 81 c7 e0 08 ret <== NOT EXECUTED 20130d8: 81 e8 00 00 restore <== NOT EXECUTED 020068e4 <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 20068e4: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 20068e8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20068ec: 80 a0 60 02 cmp %g1, 2 Watchdog_Interval timeout ) { Thread_Control *executing; executing = _Thread_Executing; 20068f0: 03 00 80 5f sethi %hi(0x2017c00), %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 20068f4: 12 80 00 0a bne 200691c <_CORE_mutex_Seize_interrupt_blocking+0x38> 20068f8: d2 00 60 90 ld [ %g1 + 0x90 ], %o1 ! 2017c90 <_Thread_Executing> if ( the_mutex->holder->current_priority > executing->current_priority ) { 20068fc: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 2006900: d2 02 60 14 ld [ %o1 + 0x14 ], %o1 2006904: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2006908: 80 a0 40 09 cmp %g1, %o1 200690c: 28 80 00 05 bleu,a 2006920 <_CORE_mutex_Seize_interrupt_blocking+0x3c> 2006910: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_Change_priority( 2006914: 40 00 07 47 call 2008630 <_Thread_Change_priority> 2006918: 94 10 20 00 clr %o2 FALSE ); } } the_mutex->blocked_count++; 200691c: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 2006920: 90 10 00 18 mov %i0, %o0 FALSE ); } } the_mutex->blocked_count++; 2006924: 82 00 60 01 inc %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 2006928: 92 10 00 19 mov %i1, %o1 FALSE ); } } the_mutex->blocked_count++; 200692c: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 2006930: 15 00 80 25 sethi %hi(0x2009400), %o2 2006934: 40 00 0a 13 call 2009180 <_Thread_queue_Enqueue_with_handler> 2006938: 94 12 a2 18 or %o2, 0x218, %o2 ! 2009618 <_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 ) 200693c: 05 00 80 5e sethi %hi(0x2017800), %g2 2006940: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> 2006944: 82 00 7f ff add %g1, -1, %g1 2006948: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 200694c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 2006950: 80 a0 60 00 cmp %g1, 0 2006954: 12 80 00 04 bne 2006964 <_CORE_mutex_Seize_interrupt_blocking+0x80> 2006958: 01 00 00 00 nop _Thread_Dispatch(); 200695c: 40 00 08 72 call 2008b24 <_Thread_Dispatch> 2006960: 81 e8 00 00 restore 2006964: 81 c7 e0 08 ret <== NOT EXECUTED 2006968: 81 e8 00 00 restore <== NOT EXECUTED 0200696c <_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 ) { 200696c: 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 ) { 2006970: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 2006974: 80 a0 60 00 cmp %g1, 0 2006978: 02 80 00 07 be 2006994 <_CORE_mutex_Surrender+0x28> 200697c: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 if ( !_Thread_Is_executing( holder ) ) 2006980: 03 00 80 5f sethi %hi(0x2017c00), %g1 2006984: c2 00 60 90 ld [ %g1 + 0x90 ], %g1 ! 2017c90 <_Thread_Executing> 2006988: 80 a2 00 01 cmp %o0, %g1 200698c: 12 80 00 51 bne 2006ad0 <_CORE_mutex_Surrender+0x164> 2006990: 84 10 20 03 mov 3, %g2 return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 2006994: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 2006998: 80 a0 60 00 cmp %g1, 0 200699c: 02 80 00 4c be 2006acc <_CORE_mutex_Surrender+0x160> 20069a0: 82 00 7f ff add %g1, -1, %g1 return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; if ( the_mutex->nest_count != 0 ) { 20069a4: 80 a0 60 00 cmp %g1, 0 20069a8: 02 80 00 09 be 20069cc <_CORE_mutex_Surrender+0x60> 20069ac: c2 26 20 54 st %g1, [ %i0 + 0x54 ] switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20069b0: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 20069b4: 80 a0 60 00 cmp %g1, 0 20069b8: 02 80 00 46 be 2006ad0 <_CORE_mutex_Surrender+0x164> 20069bc: 84 10 20 00 clr %g2 20069c0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20069c4: 02 80 00 43 be 2006ad0 <_CORE_mutex_Surrender+0x164> <== NOT EXECUTED 20069c8: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 20069cc: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20069d0: 80 a0 60 02 cmp %g1, 2 20069d4: 22 80 00 06 be,a 20069ec <_CORE_mutex_Surrender+0x80> 20069d8: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 20069dc: 80 a0 60 03 cmp %g1, 3 20069e0: 32 80 00 07 bne,a 20069fc <_CORE_mutex_Surrender+0x90> 20069e4: c0 26 20 5c clr [ %i0 + 0x5c ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; 20069e8: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED 20069ec: 82 00 7f ff add %g1, -1, %g1 20069f0: c2 22 20 1c st %g1, [ %o0 + 0x1c ] 20069f4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 the_mutex->holder = NULL; 20069f8: c0 26 20 5c clr [ %i0 + 0x5c ] /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20069fc: 80 a0 60 02 cmp %g1, 2 2006a00: 02 80 00 05 be 2006a14 <_CORE_mutex_Surrender+0xa8> 2006a04: c0 26 20 60 clr [ %i0 + 0x60 ] 2006a08: 80 a0 60 03 cmp %g1, 3 2006a0c: 12 80 00 0d bne 2006a40 <_CORE_mutex_Surrender+0xd4> 2006a10: 01 00 00 00 nop _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( holder->resource_count == 0 && 2006a14: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006a18: 80 a0 60 00 cmp %g1, 0 2006a1c: 12 80 00 09 bne 2006a40 <_CORE_mutex_Surrender+0xd4> 2006a20: 01 00 00 00 nop 2006a24: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 2006a28: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2006a2c: 80 a2 40 01 cmp %o1, %g1 2006a30: 02 80 00 04 be 2006a40 <_CORE_mutex_Surrender+0xd4> 2006a34: 01 00 00 00 nop holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 2006a38: 40 00 06 fe call 2008630 <_Thread_Change_priority> 2006a3c: 94 10 20 01 mov 1, %o2 ! 1 /* * Now we check if another thread was waiting for this mutex. If so, * transfer the mutex to that thread. */ if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) { 2006a40: 40 00 09 62 call 2008fc8 <_Thread_queue_Dequeue> 2006a44: 90 10 00 18 mov %i0, %o0 2006a48: 86 92 20 00 orcc %o0, 0, %g3 2006a4c: 02 80 00 1f be 2006ac8 <_CORE_mutex_Surrender+0x15c> 2006a50: 82 10 20 01 mov 1, %g1 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 2006a54: c2 00 e0 08 ld [ %g3 + 8 ], %g1 the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 2006a58: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 2006a5c: c2 26 20 60 st %g1, [ %i0 + 0x60 ] } else #endif { the_mutex->holder = the_thread; 2006a60: c6 26 20 5c st %g3, [ %i0 + 0x5c ] the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; 2006a64: 82 10 20 01 mov 1, %g1 switch ( the_mutex->Attributes.discipline ) { 2006a68: 80 a0 a0 02 cmp %g2, 2 2006a6c: 02 80 00 07 be 2006a88 <_CORE_mutex_Surrender+0x11c> 2006a70: c2 26 20 54 st %g1, [ %i0 + 0x54 ] 2006a74: 80 a0 a0 03 cmp %g2, 3 2006a78: 12 80 00 16 bne 2006ad0 <_CORE_mutex_Surrender+0x164> 2006a7c: 84 10 20 00 clr %g2 break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; 2006a80: 10 80 00 07 b 2006a9c <_CORE_mutex_Surrender+0x130> <== NOT EXECUTED 2006a84: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 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++; 2006a88: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2006a8c: 84 10 20 00 clr %g2 2006a90: 82 00 60 01 inc %g1 2006a94: 10 80 00 0f b 2006ad0 <_CORE_mutex_Surrender+0x164> 2006a98: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; if (the_mutex->Attributes.priority_ceiling < 2006a9c: 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++; 2006aa0: 82 00 60 01 inc %g1 <== NOT EXECUTED 2006aa4: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 2006aa8: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 <== NOT EXECUTED 2006aac: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED 2006ab0: 3a 80 00 08 bcc,a 2006ad0 <_CORE_mutex_Surrender+0x164> <== NOT EXECUTED 2006ab4: 84 10 20 00 clr %g2 <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 2006ab8: 40 00 06 de call 2008630 <_Thread_Change_priority> <== NOT EXECUTED 2006abc: 94 10 20 00 clr %o2 <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 2006ac0: 10 80 00 04 b 2006ad0 <_CORE_mutex_Surrender+0x164> <== NOT EXECUTED 2006ac4: 84 10 20 00 clr %g2 <== NOT EXECUTED 2006ac8: c2 26 20 50 st %g1, [ %i0 + 0x50 ] 2006acc: 84 10 20 00 clr %g2 return CORE_MUTEX_STATUS_SUCCESSFUL; } 2006ad0: 81 c7 e0 08 ret 2006ad4: 91 e8 00 02 restore %g0, %g2, %o0 0200c368 <_Debug_Is_enabled>: */ boolean _Debug_Is_enabled( rtems_debug_control level ) { 200c368: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 200c36c: c2 00 60 94 ld [ %g1 + 0x94 ], %g1 ! 2017c94 <_Debug_Level> <== NOT EXECUTED 200c370: 90 0a 00 01 and %o0, %g1, %o0 <== NOT EXECUTED return (_Debug_Level & level) ? TRUE : FALSE; } 200c374: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 200c378: 81 c3 e0 08 retl <== NOT EXECUTED 200c37c: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED 020050b0 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 20050b0: 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; 20050b4: 03 00 80 5f sethi %hi(0x2017c00), %g1 20050b8: e0 00 60 90 ld [ %g1 + 0x90 ], %l0 ! 2017c90 <_Thread_Executing> executing->Wait.return_code = RTEMS_SUCCESSFUL; 20050bc: c0 24 20 34 clr [ %l0 + 0x34 ] api = executing->API_Extensions[ THREAD_API_RTEMS ]; _ISR_Disable( level ); 20050c0: 7f ff f3 20 call 2001d40 20050c4: e4 04 21 70 ld [ %l0 + 0x170 ], %l2 20050c8: 84 10 00 08 mov %o0, %g2 pending_events = api->pending_events; 20050cc: c2 04 a0 40 ld [ %l2 + 0x40 ], %g1 seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 20050d0: a2 8e 00 01 andcc %i0, %g1, %l1 20050d4: 02 80 00 0e be 200510c <_Event_Seize+0x5c> 20050d8: 80 8e 60 01 btst 1, %i1 20050dc: 80 a4 40 18 cmp %l1, %i0 20050e0: 02 80 00 04 be 20050f0 <_Event_Seize+0x40> 20050e4: 80 8e 60 02 btst 2, %i1 20050e8: 02 80 00 09 be 200510c <_Event_Seize+0x5c> 20050ec: 80 8e 60 01 btst 1, %i1 (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 20050f0: 82 28 40 11 andn %g1, %l1, %g1 20050f4: c2 24 a0 40 st %g1, [ %l2 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 20050f8: 7f ff f3 16 call 2001d50 20050fc: 01 00 00 00 nop 2005100: e2 26 c0 00 st %l1, [ %i3 ] 2005104: 81 c7 e0 08 ret 2005108: 81 e8 00 00 restore *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 200510c: 22 80 00 09 be,a 2005130 <_Event_Seize+0x80> 2005110: 23 00 80 5f sethi %hi(0x2017c00), %l1 _ISR_Enable( level ); 2005114: 7f ff f3 0f call 2001d50 2005118: 90 10 00 02 mov %g2, %o0 executing->Wait.return_code = RTEMS_UNSATISFIED; 200511c: 82 10 20 0d mov 0xd, %g1 2005120: c2 24 20 34 st %g1, [ %l0 + 0x34 ] *event_out = seized_events; 2005124: e2 26 c0 00 st %l1, [ %i3 ] 2005128: 81 c7 e0 08 ret 200512c: 81 e8 00 00 restore return; } _Event_Sync_state = EVENT_SYNC_NOTHING_HAPPENED; 2005130: 82 10 20 01 mov 1, %g1 executing->Wait.option = (uint32_t ) option_set; 2005134: f2 24 20 30 st %i1, [ %l0 + 0x30 ] executing->Wait.count = (uint32_t ) event_in; 2005138: f0 24 20 24 st %i0, [ %l0 + 0x24 ] executing->Wait.return_argument = event_out; 200513c: 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; 2005140: c2 24 62 c4 st %g1, [ %l1 + 0x2c4 ] executing->Wait.option = (uint32_t ) option_set; executing->Wait.count = (uint32_t ) event_in; executing->Wait.return_argument = event_out; _ISR_Enable( level ); 2005144: 7f ff f3 03 call 2001d50 2005148: 90 10 00 02 mov %g2, %o0 if ( ticks ) { 200514c: 80 a6 a0 00 cmp %i2, 0 2005150: 02 80 00 0f be 200518c <_Event_Seize+0xdc> 2005154: 90 10 00 10 mov %l0, %o0 _Watchdog_Initialize( 2005158: c2 04 20 08 ld [ %l0 + 8 ], %g1 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200515c: 11 00 80 5f sethi %hi(0x2017c00), %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 2005160: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2005164: 03 00 80 15 sethi %hi(0x2005400), %g1 2005168: 82 10 60 38 or %g1, 0x38, %g1 ! 2005438 <_Event_Timeout> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200516c: f4 24 20 54 st %i2, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2005170: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2005174: c0 24 20 6c clr [ %l0 + 0x6c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2005178: c2 24 20 64 st %g1, [ %l0 + 0x64 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200517c: 90 12 20 b0 or %o0, 0xb0, %o0 2005180: 40 00 13 7a call 2009f68 <_Watchdog_Insert> 2005184: 92 04 20 48 add %l0, 0x48, %o1 NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 2005188: 90 10 00 10 mov %l0, %o0 200518c: 40 00 11 7b call 2009778 <_Thread_Set_state> 2005190: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 2005194: 7f ff f2 eb call 2001d40 2005198: 01 00 00 00 nop 200519c: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 20051a0: c4 04 62 c4 ld [ %l1 + 0x2c4 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 20051a4: c0 24 62 c4 clr [ %l1 + 0x2c4 ] switch ( sync_state ) { 20051a8: 80 a0 a0 02 cmp %g2, 2 20051ac: 02 80 00 08 be 20051cc <_Event_Seize+0x11c> 20051b0: 80 a0 a0 03 cmp %g2, 3 20051b4: 02 80 00 09 be 20051d8 <_Event_Seize+0x128> 20051b8: 80 a0 a0 01 cmp %g2, 1 20051bc: 12 80 00 15 bne 2005210 <_Event_Seize+0x160> 20051c0: 01 00 00 00 nop * enter the synchronization states above. */ return; case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); 20051c4: 7f ff f2 e3 call 2001d50 20051c8: 81 e8 00 00 restore return; case EVENT_SYNC_TIMEOUT: executing->Wait.return_code = RTEMS_TIMEOUT; 20051cc: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 20051d0: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20051d4: 30 80 00 0b b,a 2005200 <_Event_Seize+0x150> <== NOT EXECUTED _Thread_Unblock( executing ); return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { 20051d8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 20051dc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20051e0: 12 80 00 08 bne 2005200 <_Event_Seize+0x150> <== NOT EXECUTED 20051e4: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 20051e8: c4 24 20 50 st %g2, [ %l0 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); 20051ec: 7f ff f2 d9 call 2001d50 <== NOT EXECUTED 20051f0: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED (void) _Watchdog_Remove( &executing->Timer ); 20051f4: 40 00 13 b5 call 200a0c8 <_Watchdog_Remove> <== NOT EXECUTED 20051f8: 90 04 20 48 add %l0, 0x48, %o0 <== NOT EXECUTED 20051fc: 30 80 00 03 b,a 2005208 <_Event_Seize+0x158> <== NOT EXECUTED } else _ISR_Enable( level ); 2005200: 7f ff f2 d4 call 2001d50 <== NOT EXECUTED 2005204: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED _Thread_Unblock( executing ); 2005208: 7f ff ff a4 call 2005098 <_Thread_Unblock> <== NOT EXECUTED 200520c: 81 e8 00 00 restore <== NOT EXECUTED 2005210: 81 c7 e0 08 ret <== NOT EXECUTED 2005214: 81 e8 00 00 restore <== NOT EXECUTED 02005330 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 2005330: 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 ]; 2005334: e2 06 21 70 ld [ %i0 + 0x170 ], %l1 option_set = (rtems_option) the_thread->Wait.option; 2005338: e6 06 20 30 ld [ %i0 + 0x30 ], %l3 _ISR_Disable( level ); 200533c: 7f ff f2 81 call 2001d40 2005340: a0 10 00 18 mov %i0, %l0 2005344: a4 10 00 08 mov %o0, %l2 pending_events = api->pending_events; 2005348: c8 04 60 40 ld [ %l1 + 0x40 ], %g4 event_condition = (rtems_event_set) the_thread->Wait.count; 200534c: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { 2005350: 86 88 80 04 andcc %g2, %g4, %g3 2005354: 02 80 00 36 be 200542c <_Event_Surrender+0xfc> 2005358: 01 00 00 00 nop if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 200535c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 2005360: 80 88 61 00 btst 0x100, %g1 2005364: 02 80 00 1e be 20053dc <_Event_Surrender+0xac> 2005368: 1b 00 80 5f sethi %hi(0x2017c00), %o5 if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 200536c: 80 a0 c0 02 cmp %g3, %g2 2005370: 02 80 00 04 be 2005380 <_Event_Surrender+0x50> 2005374: 80 8c e0 02 btst 2, %l3 2005378: 02 80 00 19 be 20053dc <_Event_Surrender+0xac> 200537c: 01 00 00 00 nop api->pending_events = 2005380: 82 29 00 03 andn %g4, %g3, %g1 2005384: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 2005388: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 if ( !_Event_sets_Is_empty( seized_events ) ) { if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 200538c: c0 24 20 24 clr [ %l0 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 2005390: c6 20 40 00 st %g3, [ %g1 ] _ISR_Flash( level ); 2005394: 7f ff f2 6f call 2001d50 2005398: 01 00 00 00 nop 200539c: 7f ff f2 69 call 2001d40 20053a0: 01 00 00 00 nop if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 20053a4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 20053a8: 80 a0 60 02 cmp %g1, 2 20053ac: 02 80 00 05 be 20053c0 <_Event_Surrender+0x90> 20053b0: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 20053b4: 7f ff f2 67 call 2001d50 20053b8: 90 10 00 12 mov %l2, %o0 20053bc: 30 80 00 06 b,a 20053d4 <_Event_Surrender+0xa4> 20053c0: c2 24 20 50 st %g1, [ %l0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 20053c4: 7f ff f2 63 call 2001d50 20053c8: 90 10 00 12 mov %l2, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 20053cc: 40 00 13 3f call 200a0c8 <_Watchdog_Remove> 20053d0: 90 04 20 48 add %l0, 0x48, %o0 _Thread_Unblock( the_thread ); 20053d4: 7f ff ff d1 call 2005318 <_Thread_Unblock> 20053d8: 81 e8 00 00 restore } return; } } switch ( _Event_Sync_state ) { 20053dc: c2 03 62 c4 ld [ %o5 + 0x2c4 ], %g1 <== NOT EXECUTED 20053e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20053e4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20053e8: 18 80 00 11 bgu 200542c <_Event_Surrender+0xfc> <== NOT EXECUTED 20053ec: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED case EVENT_SYNC_SATISFIED: break; case EVENT_SYNC_NOTHING_HAPPENED: case EVENT_SYNC_TIMEOUT: if ( !_Thread_Is_executing( the_thread ) ) 20053f0: c2 00 60 90 ld [ %g1 + 0x90 ], %g1 ! 2017c90 <_Thread_Executing> <== NOT EXECUTED 20053f4: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 20053f8: 12 80 00 0d bne 200542c <_Event_Surrender+0xfc> <== NOT EXECUTED 20053fc: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 2005400: 02 80 00 04 be 2005410 <_Event_Surrender+0xe0> <== NOT EXECUTED 2005404: 80 8c e0 02 btst 2, %l3 <== NOT EXECUTED 2005408: 02 80 00 09 be 200542c <_Event_Surrender+0xfc> <== NOT EXECUTED 200540c: 01 00 00 00 nop <== NOT EXECUTED api->pending_events = 2005410: 82 29 00 03 andn %g4, %g3, %g1 <== NOT EXECUTED 2005414: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 2005418: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 200541c: c0 24 20 24 clr [ %l0 + 0x24 ] <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 2005420: c6 20 40 00 st %g3, [ %g1 ] <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_SATISFIED; 2005424: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 2005428: c2 23 62 c4 st %g1, [ %o5 + 0x2c4 ] <== NOT EXECUTED } break; } } _ISR_Enable( level ); 200542c: 7f ff f2 49 call 2001d50 2005430: 91 e8 00 12 restore %g0, %l2, %o0 2005434: 01 00 00 00 nop 02005438 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 2005438: 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 ) ) { 200543c: 92 96 20 00 orcc %i0, 0, %o1 2005440: 12 80 00 0a bne 2005468 <_Event_Timeout+0x30> 2005444: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005448: 03 00 80 5e sethi %hi(0x2017800), %g1 <== NOT EXECUTED 200544c: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2005450: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2005454: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] <== 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; 2005458: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 200545c: f0 00 60 90 ld [ %g1 + 0x90 ], %i0 ! 2017c90 <_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; 2005460: 10 80 00 18 b 20054c0 <_Event_Timeout+0x88> <== NOT EXECUTED 2005464: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 2005468: 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 ) { 200546c: 80 a0 a0 04 cmp %g2, 4 2005470: 18 80 00 0e bgu 20054a8 <_Event_Timeout+0x70> 2005474: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2005478: 83 32 60 1b srl %o1, 0x1b, %g1 200547c: 80 a0 60 01 cmp %g1, 1 2005480: 12 80 00 0a bne 20054a8 <_Event_Timeout+0x70> 2005484: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2005488: 83 28 a0 02 sll %g2, 2, %g1 200548c: 05 00 80 5e sethi %hi(0x2017800), %g2 2005490: 84 10 a3 10 or %g2, 0x310, %g2 ! 2017b10 <_Objects_Information_table> 2005494: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2005498: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 200549c: 80 a2 20 00 cmp %o0, 0 20054a0: 12 80 00 05 bne 20054b4 <_Event_Timeout+0x7c> 20054a4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20054a8: b0 10 20 00 clr %i0 <== NOT EXECUTED 20054ac: 10 80 00 05 b 20054c0 <_Event_Timeout+0x88> <== NOT EXECUTED 20054b0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20054b4: 40 00 08 97 call 2007710 <_Objects_Get> 20054b8: 94 07 bf f4 add %fp, -12, %o2 20054bc: b0 10 00 08 mov %o0, %i0 Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20054c0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20054c4: 80 a0 60 00 cmp %g1, 0 20054c8: 12 80 00 27 bne 2005564 <_Event_Timeout+0x12c> 20054cc: 01 00 00 00 nop * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 20054d0: 7f ff f2 1c call 2001d40 20054d4: 01 00 00 00 nop 20054d8: 86 10 00 08 mov %o0, %g3 if ( the_thread->Wait.count ) { /* verify thread is waiting */ 20054dc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 20054e0: 80 a0 60 00 cmp %g1, 0 20054e4: 02 80 00 1a be 200554c <_Event_Timeout+0x114> 20054e8: 05 00 80 5f sethi %hi(0x2017c00), %g2 the_thread->Wait.count = 0; if ( _Event_Sync_state != EVENT_SYNC_SYNCHRONIZED && 20054ec: c2 00 a2 c4 ld [ %g2 + 0x2c4 ], %g1 ! 2017ec4 <_Event_Sync_state> 20054f0: 80 a0 60 00 cmp %g1, 0 20054f4: 02 80 00 0d be 2005528 <_Event_Timeout+0xf0> 20054f8: c0 26 20 24 clr [ %i0 + 0x24 ] 20054fc: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2005500: c2 00 60 90 ld [ %g1 + 0x90 ], %g1 ! 2017c90 <_Thread_Executing> <== NOT EXECUTED 2005504: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 2005508: 12 80 00 09 bne 200552c <_Event_Timeout+0xf4> <== NOT EXECUTED 200550c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { 2005510: c2 00 a2 c4 ld [ %g2 + 0x2c4 ], %g1 <== NOT EXECUTED 2005514: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2005518: 02 80 00 03 be 2005524 <_Event_Timeout+0xec> <== NOT EXECUTED 200551c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_TIMEOUT; 2005520: c2 20 a2 c4 st %g1, [ %g2 + 0x2c4 ] <== NOT EXECUTED } _ISR_Enable( level ); 2005524: 30 80 00 0a b,a 200554c <_Event_Timeout+0x114> <== NOT EXECUTED } else { the_thread->Wait.return_code = RTEMS_TIMEOUT; 2005528: 82 10 20 06 mov 6, %g1 200552c: c2 26 20 34 st %g1, [ %i0 + 0x34 ] _ISR_Enable( level ); 2005530: 7f ff f2 08 call 2001d50 2005534: 90 10 00 03 mov %g3, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2005538: 90 10 00 18 mov %i0, %o0 200553c: 13 04 00 ff sethi %hi(0x1003fc00), %o1 2005540: 40 00 0c ae call 20087f8 <_Thread_Clear_state> 2005544: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 2005548: 30 80 00 03 b,a 2005554 <_Event_Timeout+0x11c> _Thread_Unblock( the_thread ); } } else { _ISR_Enable( level ); 200554c: 7f ff f2 01 call 2001d50 <== NOT EXECUTED 2005550: 01 00 00 00 nop <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2005554: 05 00 80 5e sethi %hi(0x2017800), %g2 2005558: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> 200555c: 82 00 7f ff add %g1, -1, %g1 2005560: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 2005564: 81 c7 e0 08 ret 2005568: 81 e8 00 00 restore 02006f34 <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 2006f34: 9d e3 bf 90 save %sp, -112, %sp uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 2006f38: 82 06 20 04 add %i0, 4, %g1 _Heap_Align_up(&block_size, page_size); 2006f3c: 92 10 00 19 mov %i1, %o1 size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 2006f40: c2 27 bf f4 st %g1, [ %fp + -12 ] _Heap_Align_up(&block_size, page_size); 2006f44: 7f ff ff f0 call 2006f04 <_Heap_Align_up> 2006f48: 90 07 bf f4 add %fp, -12, %o0 if (block_size < min_size) block_size = min_size; 2006f4c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006f50: 80 a0 40 1a cmp %g1, %i2 2006f54: 1a 80 00 04 bcc 2006f64 <_Heap_Calc_block_size+0x30> 2006f58: a0 10 00 18 mov %i0, %l0 2006f5c: f4 27 bf f4 st %i2, [ %fp + -12 ] <== NOT EXECUTED /* 'block_size' becomes <= 'size' if and only if overflow occured. */ return (block_size > size) ? block_size : 0; 2006f60: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2006f64: 80 a0 40 10 cmp %g1, %l0 2006f68: 08 80 00 03 bleu 2006f74 <_Heap_Calc_block_size+0x40> 2006f6c: b0 10 20 00 clr %i0 2006f70: b0 10 00 01 mov %g1, %i0 } 2006f74: 81 c7 e0 08 ret 2006f78: 81 e8 00 00 restore 020179e0 <_Heap_Get_free_information>: */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 20179e0: 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; 20179e4: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED info->largest = 0; 20179e8: c0 22 60 04 clr [ %o1 + 4 ] <== NOT EXECUTED info->total = 0; 20179ec: 10 80 00 0e b 2017a24 <_Heap_Get_free_information+0x44> <== NOT EXECUTED 20179f0: c0 22 60 08 clr [ %o1 + 8 ] <== NOT EXECUTED uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 20179f4: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED info->total += the_size; 20179f8: c4 02 60 08 ld [ %o1 + 8 ], %g2 <== NOT EXECUTED if ( info->largest < the_size ) 20179fc: c8 02 60 04 ld [ %o1 + 4 ], %g4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 2017a00: 86 08 ff fe and %g3, -2, %g3 <== NOT EXECUTED uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 2017a04: 82 00 60 01 inc %g1 <== NOT EXECUTED info->total += the_size; 2017a08: 84 00 80 03 add %g2, %g3, %g2 <== NOT EXECUTED uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 2017a0c: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED info->total += the_size; if ( info->largest < the_size ) 2017a10: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED 2017a14: 1a 80 00 03 bcc 2017a20 <_Heap_Get_free_information+0x40> <== NOT EXECUTED 2017a18: c4 22 60 08 st %g2, [ %o1 + 8 ] <== NOT EXECUTED info->largest = the_size; 2017a1c: c6 22 60 04 st %g3, [ %o1 + 4 ] <== NOT EXECUTED info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 2017a20: 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; 2017a24: 80 a3 40 08 cmp %o5, %o0 <== NOT EXECUTED 2017a28: 32 bf ff f3 bne,a 20179f4 <_Heap_Get_free_information+0x14> <== NOT EXECUTED 2017a2c: c6 03 60 04 ld [ %o5 + 4 ], %g3 <== NOT EXECUTED info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 2017a30: 81 c3 e0 08 retl <== NOT EXECUTED 2017a34: 01 00 00 00 nop 02007024 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 2007024: 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) 2007028: 80 a6 e0 00 cmp %i3, 0 200702c: 12 80 00 05 bne 2007040 <_Heap_Initialize+0x1c> 2007030: f6 27 a0 50 st %i3, [ %fp + 0x50 ] page_size = CPU_ALIGNMENT; 2007034: 82 10 20 08 mov 8, %g1 <== NOT EXECUTED 2007038: 10 80 00 05 b 200704c <_Heap_Initialize+0x28> <== NOT EXECUTED 200703c: c2 27 a0 50 st %g1, [ %fp + 0x50 ] <== NOT EXECUTED else _Heap_Align_up( &page_size, CPU_ALIGNMENT ); 2007040: 90 07 a0 50 add %fp, 0x50, %o0 2007044: 7f ff ff b0 call 2006f04 <_Heap_Align_up> 2007048: 92 10 20 08 mov 8, %o1 /* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET (value of user pointer) is aligned on 'page_size' boundary. Make sure resulting 'aligned_start' is not below 'starting_address'. */ start = _H_p2u(starting_address); aligned_start = start + HEAP_BLOCK_USER_OFFSET; _Heap_Align_up_uptr ( &aligned_start, page_size ); 200704c: e0 07 a0 50 ld [ %fp + 0x50 ], %l0 /* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET (value of user pointer) is aligned on 'page_size' boundary. Make sure resulting 'aligned_start' is not below 'starting_address'. */ start = _H_p2u(starting_address); aligned_start = start + HEAP_BLOCK_USER_OFFSET; 2007050: a4 06 60 08 add %i1, 8, %l2 uint32_t alignment ) { _H_uptr_t v = *value; uint32_t a = alignment; _H_uptr_t r = v % a; 2007054: 92 10 00 10 mov %l0, %o1 2007058: 40 00 36 46 call 2014970 <.urem> 200705c: 90 10 00 12 mov %l2, %o0 *value = r ? v - r + a : v; 2007060: 80 a2 20 00 cmp %o0, 0 2007064: 02 80 00 05 be 2007078 <_Heap_Initialize+0x54> 2007068: 82 10 20 10 mov 0x10, %g1 200706c: 82 04 80 10 add %l2, %l0, %g1 2007070: a4 20 40 08 sub %g1, %o0, %l2 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; /* Calculate 'min_block_size'. It's HEAP_MIN_BLOCK_SIZE aligned up to the nearest multiple of 'page_size'. */ the_heap->min_block_size = HEAP_MIN_BLOCK_SIZE; 2007074: 82 10 20 10 mov 0x10, %g1 _Heap_Align_up ( &the_heap->min_block_size, page_size ); 2007078: 92 10 00 10 mov %l0, %o1 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; /* Calculate 'min_block_size'. It's HEAP_MIN_BLOCK_SIZE aligned up to the nearest multiple of 'page_size'. */ the_heap->min_block_size = HEAP_MIN_BLOCK_SIZE; 200707c: c2 26 20 14 st %g1, [ %i0 + 0x14 ] _Heap_Align_up ( &the_heap->min_block_size, page_size ); 2007080: 7f ff ff a1 call 2006f04 <_Heap_Align_up> 2007084: 90 06 20 14 add %i0, 0x14, %o0 (value of user pointer) is aligned on 'page_size' boundary. Make sure resulting 'aligned_start' is not below 'starting_address'. */ start = _H_p2u(starting_address); aligned_start = start + HEAP_BLOCK_USER_OFFSET; _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 2007088: b6 04 bf f8 add %l2, -8, %i3 /* Calculate 'the_size' -- size of the first block so that there is enough space at the end for the permanent last block. It is equal to 'size' minus total overhead aligned down to the nearest multiple of 'page_size'. */ overhead = HEAP_OVERHEAD + (aligned_start - start); 200708c: 82 26 c0 19 sub %i3, %i1, %g1 2007090: 82 00 60 08 add %g1, 8, %g1 if ( size < overhead ) 2007094: 80 a6 80 01 cmp %i2, %g1 2007098: 0a 80 00 2b bcs 2007144 <_Heap_Initialize+0x120> 200709c: e2 07 a0 50 ld [ %fp + 0x50 ], %l1 return 0; /* Too small area for the heap */ the_size = size - overhead; 20070a0: a0 26 80 01 sub %i2, %g1, %l0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 20070a4: 92 10 00 11 mov %l1, %o1 20070a8: 40 00 36 32 call 2014970 <.urem> 20070ac: 90 10 00 10 mov %l0, %o0 _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 20070b0: a0 a4 00 08 subcc %l0, %o0, %l0 20070b4: 02 80 00 24 be 2007144 <_Heap_Initialize+0x120> 20070b8: 07 00 80 5e sethi %hi(0x2017800), %g3 return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 20070bc: e2 26 20 10 st %l1, [ %i0 + 0x10 ] the_heap->begin = starting_address; the_heap->end = starting_address + size; the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 20070c0: e2 24 bf f8 st %l1, [ %l2 + -8 ] the_block->size = the_size | HEAP_PREV_USED; 20070c4: 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++; 20070c8: c4 00 e0 04 ld [ %g3 + 4 ], %g2 the_heap->end = starting_address + size; the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; 20070cc: c2 26 e0 04 st %g1, [ %i3 + 4 ] _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ 20070d0: e0 26 c0 10 st %l0, [ %i3 + %l0 ] RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 20070d4: 88 06 c0 10 add %i3, %l0, %g4 the_block->size = page_size; 20070d8: e2 21 20 04 st %l1, [ %g4 + 4 ] the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; the_block->next = _Heap_Tail( the_heap ); 20070dc: f0 26 e0 08 st %i0, [ %i3 + 8 ] the_block->prev = _Heap_Head( the_heap ); 20070e0: f0 26 e0 0c st %i0, [ %i3 + 0xc ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 20070e4: c4 26 20 28 st %g2, [ %i0 + 0x28 ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 20070e8: 82 10 20 01 mov 1, %g1 the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ the_block->size = page_size; stats->size = size; 20070ec: f4 26 20 2c st %i2, [ %i0 + 0x2c ] stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; stats->max_free_blocks = 1; 20070f0: c2 26 20 3c st %g1, [ %i0 + 0x3c ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 20070f4: c2 26 20 38 st %g1, [ %i0 + 0x38 ] the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ the_block->size = page_size; stats->size = size; stats->free_size = the_size; 20070f8: e0 26 20 30 st %l0, [ %i0 + 0x30 ] stats->min_free_size = the_size; 20070fc: e0 26 20 34 st %l0, [ %i0 + 0x34 ] stats->free_blocks = 1; stats->max_free_blocks = 1; stats->used_blocks = 0; 2007100: c0 26 20 40 clr [ %i0 + 0x40 ] stats->max_search = 0; 2007104: c0 26 20 44 clr [ %i0 + 0x44 ] stats->allocs = 0; 2007108: c0 26 20 48 clr [ %i0 + 0x48 ] stats->searches = 0; 200710c: c0 26 20 4c clr [ %i0 + 0x4c ] stats->frees = 0; 2007110: c0 26 20 50 clr [ %i0 + 0x50 ] stats->resizes = 0; 2007114: c0 26 20 54 clr [ %i0 + 0x54 ] if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 2007118: 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++; 200711c: 84 00 a0 01 inc %g2 if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 2007120: 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; 2007124: 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; 2007128: f6 26 20 08 st %i3, [ %i0 + 8 ] _Heap_Tail(the_heap)->prev = the_block; 200712c: f6 26 20 0c st %i3, [ %i0 + 0xc ] the_heap->start = the_block; 2007130: f6 26 20 20 st %i3, [ %i0 + 0x20 ] _HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT)); _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ 2007134: c8 26 20 24 st %g4, [ %i0 + 0x24 ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 2007138: c4 20 e0 04 st %g2, [ %g3 + 4 ] return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 200713c: 81 c7 e0 08 ret 2007140: 91 ec 3f fc restore %l0, -4, %o0 } 2007144: 81 c7 e0 08 ret 2007148: 91 e8 20 00 restore %g0, 0, %o0 0200c568 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 200c568: 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; 200c56c: 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; 200c570: ea 06 20 14 ld [ %i0 + 0x14 ], %l5 <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; *old_mem_size = 0; 200c574: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED *avail_mem_size = 0; 200c578: 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); 200c57c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200c580: 40 00 20 fc call 2014970 <.urem> <== NOT EXECUTED 200c584: 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 ); 200c588: 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); 200c58c: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 200c590: 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)) 200c594: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED 200c598: 0a 80 00 78 bcs 200c778 <_Heap_Resize_block+0x210> <== NOT EXECUTED 200c59c: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 <== NOT EXECUTED 200c5a0: 80 a4 80 02 cmp %l2, %g2 <== NOT EXECUTED 200c5a4: 38 80 00 78 bgu,a 200c784 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200c5a8: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 200c5ac: 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); 200c5b0: ae 08 ff fe and %g3, -2, %l7 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200c5b4: a2 04 80 17 add %l2, %l7, %l1 <== NOT EXECUTED old_block_size = _Heap_Block_size(the_block); next_block = _Heap_Block_at(the_block, old_block_size); _HAssert(_Heap_Is_block_in(the_heap, next_block)); _HAssert(_Heap_Is_prev_used(next_block)); if ( !_Heap_Is_block_in(the_heap, next_block) || 200c5b8: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 200c5bc: 2a 80 00 72 bcs,a 200c784 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200c5c0: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 200c5c4: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 200c5c8: 38 80 00 6f bgu,a 200c784 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200c5cc: 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); 200c5d0: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED 200c5d4: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200c5d8: 02 80 00 68 be 200c778 <_Heap_Resize_block+0x210> <== NOT EXECUTED 200c5dc: a8 08 7f fe and %g1, -2, %l4 <== NOT EXECUTED !_Heap_Is_prev_used(next_block)) return HEAP_RESIZE_FATAL_ERROR; next_block_size = _Heap_Block_size(next_block); next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || 200c5e0: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 200c5e4: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED 200c5e8: 02 80 00 04 be 200c5f8 <_Heap_Resize_block+0x90> <== NOT EXECUTED 200c5ec: ba 04 40 14 add %l1, %l4, %i5 <== NOT EXECUTED 200c5f0: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED 200c5f4: 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) 200c5f8: 82 24 40 19 sub %l1, %i1, %g1 <== NOT EXECUTED 200c5fc: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 200c600: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED if (size > old_user_size) { 200c604: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED 200c608: 08 80 00 1f bleu 200c684 <_Heap_Resize_block+0x11c> <== NOT EXECUTED 200c60c: 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 */ 200c610: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 200c614: 12 80 00 5b bne 200c780 <_Heap_Resize_block+0x218> <== NOT EXECUTED 200c618: 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; 200c61c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 200c620: 40 00 20 d4 call 2014970 <.urem> <== NOT EXECUTED 200c624: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED *value = r ? v - r + a : v; 200c628: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200c62c: 02 80 00 05 be 200c640 <_Heap_Resize_block+0xd8> <== NOT EXECUTED 200c630: 80 a4 00 15 cmp %l0, %l5 <== NOT EXECUTED 200c634: 82 04 00 13 add %l0, %l3, %g1 <== NOT EXECUTED 200c638: a0 20 40 08 sub %g1, %o0, %l0 <== NOT EXECUTED 200c63c: 80 a4 00 15 cmp %l0, %l5 <== NOT EXECUTED 200c640: 1a 80 00 03 bcc 200c64c <_Heap_Resize_block+0xe4> <== NOT EXECUTED 200c644: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 200c648: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED else { uint32_t add_block_size = size - old_user_size; _Heap_Align_up(&add_block_size, page_size); if (add_block_size < min_block_size) add_block_size = min_block_size; if (add_block_size > next_block_size) 200c64c: 80 a2 00 14 cmp %o0, %l4 <== NOT EXECUTED 200c650: 38 80 00 4d bgu,a 200c784 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200c654: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 200c658: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 200c65c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 200c660: 7f ff ea 47 call 2006f7c <_Heap_Block_allocate> <== NOT EXECUTED 200c664: 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; 200c668: 90 02 00 17 add %o0, %l7, %o0 <== NOT EXECUTED 200c66c: 90 12 00 1b or %o0, %i3, %o0 <== NOT EXECUTED 200c670: d0 24 a0 04 st %o0, [ %l2 + 4 ] <== NOT EXECUTED --stats->used_blocks; 200c674: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED 200c678: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200c67c: 10 80 00 3a b 200c764 <_Heap_Resize_block+0x1fc> <== NOT EXECUTED 200c680: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 200c684: a0 20 40 1a sub %g1, %i2, %l0 <== NOT EXECUTED uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 200c688: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 200c68c: 40 00 20 b9 call 2014970 <.urem> <== NOT EXECUTED 200c690: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 200c694: a0 a4 00 08 subcc %l0, %o0, %l0 <== NOT EXECUTED 200c698: 22 80 00 34 be,a 200c768 <_Heap_Resize_block+0x200> <== NOT EXECUTED 200c69c: 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; 200c6a0: 84 25 c0 10 sub %l7, %l0, %g2 <== NOT EXECUTED if (new_block_size < min_block_size) { 200c6a4: 80 a0 80 15 cmp %g2, %l5 <== NOT EXECUTED 200c6a8: 1a 80 00 08 bcc 200c6c8 <_Heap_Resize_block+0x160> <== NOT EXECUTED 200c6ac: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 200c6b0: 82 25 40 02 sub %l5, %g2, %g1 <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 200c6b4: a0 a4 00 01 subcc %l0, %g1, %l0 <== NOT EXECUTED 200c6b8: 22 80 00 2c be,a 200c768 <_Heap_Resize_block+0x200> <== NOT EXECUTED 200c6bc: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 200c6c0: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED _HAssert(new_block_size >= min_block_size); _HAssert(new_block_size + free_block_size == old_block_size); _HAssert(_Heap_Is_aligned(new_block_size, page_size)); _HAssert(_Heap_Is_aligned(free_block_size, page_size)); if (!next_is_used) { 200c6c4: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 200c6c8: 12 80 00 15 bne 200c71c <_Heap_Resize_block+0x1b4> <== NOT EXECUTED 200c6cc: 80 a4 00 15 cmp %l0, %l5 <== NOT EXECUTED Heap_Block *const new_next_block = _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 200c6d0: 82 10 80 1b or %g2, %i3, %g1 <== NOT EXECUTED if (!next_is_used) { /* Extend the next block to the low addresses by 'free_block_size' */ Heap_Block *const new_next_block = _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; 200c6d4: 86 04 00 14 add %l0, %l4, %g3 <== NOT EXECUTED _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 200c6d8: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED new_next_block->size = new_next_block_size | HEAP_PREV_USED; 200c6dc: 82 10 e0 01 or %g3, 1, %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200c6e0: 84 04 80 02 add %l2, %g2, %g2 <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; 200c6e4: c6 27 40 00 st %g3, [ %i5 ] <== NOT EXECUTED Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; 200c6e8: da 04 60 0c ld [ %l1 + 0xc ], %o5 <== NOT EXECUTED Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; 200c6ec: c8 04 60 08 ld [ %l1 + 8 ], %g4 <== NOT EXECUTED _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; new_next_block->size = new_next_block_size | HEAP_PREV_USED; 200c6f0: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; _Heap_Block_replace(next_block, new_next_block); the_heap->stats.free_size += free_block_size; 200c6f4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED Heap_Block *prev = block->prev; block = new_block; block->next = next; 200c6f8: c8 20 a0 08 st %g4, [ %g2 + 8 ] <== NOT EXECUTED 200c6fc: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED block->prev = prev; 200c700: da 20 a0 0c st %o5, [ %g2 + 0xc ] <== NOT EXECUTED 200c704: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 200c708: 86 00 ff fc add %g3, -4, %g3 <== NOT EXECUTED next->prev = prev->next = block; 200c70c: c4 21 20 0c st %g2, [ %g4 + 0xc ] <== NOT EXECUTED 200c710: c4 23 60 08 st %g2, [ %o5 + 8 ] <== NOT EXECUTED 200c714: 10 80 00 14 b 200c764 <_Heap_Resize_block+0x1fc> <== NOT EXECUTED 200c718: c6 27 00 00 st %g3, [ %i4 ] <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 200c71c: 2a 80 00 13 bcs,a 200c768 <_Heap_Resize_block+0x200> <== NOT EXECUTED 200c720: 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; 200c724: 82 10 80 1b or %g2, %i3, %g1 <== NOT EXECUTED 200c728: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 200c72c: 82 14 20 01 or %l0, 1, %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200c730: 92 04 80 02 add %l2, %g2, %o1 <== NOT EXECUTED 200c734: c2 22 60 04 st %g1, [ %o1 + 4 ] <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 200c738: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200c73c: 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 */ 200c740: 82 00 60 01 inc %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200c744: 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 */ 200c748: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200c74c: c4 26 20 50 st %g2, [ %i0 + 0x50 ] <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 200c750: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 200c754: 7f ff e9 7a call 2006d3c <_Heap_Free> <== NOT EXECUTED 200c758: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 200c75c: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED 200c760: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED } } } ++stats->resizes; 200c764: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 200c768: 84 10 20 00 clr %g2 <== NOT EXECUTED 200c76c: 82 00 60 01 inc %g1 <== NOT EXECUTED 200c770: 10 80 00 05 b 200c784 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200c774: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; 200c778: 10 80 00 03 b 200c784 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200c77c: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 200c780: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED } 200c784: 81 c7 e0 08 ret <== NOT EXECUTED 200c788: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED 0200c78c <_Heap_Size_of_user_area>: boolean _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 200c78c: 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( 200c790: e2 06 20 20 ld [ %i0 + 0x20 ], %l1 <== NOT EXECUTED 200c794: 80 a6 40 11 cmp %i1, %l1 <== NOT EXECUTED 200c798: 0a 80 00 1f bcs 200c814 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200c79c: e0 06 20 24 ld [ %i0 + 0x24 ], %l0 <== NOT EXECUTED 200c7a0: 80 a6 40 10 cmp %i1, %l0 <== NOT EXECUTED 200c7a4: 18 80 00 1c bgu 200c814 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200c7a8: 01 00 00 00 nop <== NOT EXECUTED /* The address passed could be greater than the block address plus * HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user * pointers. To get rid of this offset we need to align the address down * to the nearest 'page_size' boundary. */ _Heap_Align_down_uptr ( &addr, the_heap->page_size ); *the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET); 200c7ac: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 <== NOT EXECUTED 200c7b0: 40 00 20 70 call 2014970 <.urem> <== NOT EXECUTED 200c7b4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200c7b8: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 200c7bc: 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 ) ) 200c7c0: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 200c7c4: 0a 80 00 14 bcs 200c814 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200c7c8: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 200c7cc: 18 80 00 12 bgu 200c814 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200c7d0: 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 ); 200c7d4: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 200c7d8: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 200c7dc: 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 ( 200c7e0: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 200c7e4: 0a 80 00 0c bcs 200c814 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200c7e8: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 200c7ec: 18 80 00 0a bgu 200c814 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200c7f0: 01 00 00 00 nop <== NOT EXECUTED 200c7f4: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 200c7f8: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200c7fc: 02 80 00 06 be 200c814 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200c800: 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 ) 200c804: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED 200c808: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 200c80c: 81 c7 e0 08 ret <== NOT EXECUTED 200c810: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); } 200c814: 81 c7 e0 08 ret <== NOT EXECUTED 200c818: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 020065a4 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 20065a4: 9d e3 bf 98 save %sp, -104, %sp 20065a8: 23 00 80 5f sethi %hi(0x2017c00), %l1 /* * If the user claims there are less drivers than are actually in * the table, then let's just go with the table's count. */ if ( number_of_drivers <= drivers_in_table ) 20065ac: 80 a6 80 19 cmp %i2, %i1 20065b0: 18 80 00 06 bgu 20065c8 <_IO_Manager_initialization+0x24> 20065b4: 25 00 80 5f sethi %hi(0x2017c00), %l2 * If the maximum number of driver is the same as the number in the * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; 20065b8: f0 24 63 18 st %i0, [ %l1 + 0x318 ] _IO_Number_of_drivers = number_of_drivers; 20065bc: f2 24 a3 14 st %i1, [ %l2 + 0x314 ] 20065c0: 81 c7 e0 08 ret 20065c4: 81 e8 00 00 restore /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 20065c8: 83 2e a0 03 sll %i2, 3, %g1 <== NOT EXECUTED 20065cc: a1 2e a0 05 sll %i2, 5, %l0 <== NOT EXECUTED 20065d0: a0 24 00 01 sub %l0, %g1, %l0 <== NOT EXECUTED 20065d4: 40 00 0f 10 call 200a214 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 20065d8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 20065dc: 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; 20065e0: f4 24 a3 14 st %i2, [ %l2 + 0x314 ] <== 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 *) 20065e4: d0 24 63 18 st %o0, [ %l1 + 0x318 ] <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 20065e8: 40 00 1e 9b call 200e054 <== NOT EXECUTED 20065ec: 92 10 20 00 clr %o1 <== NOT EXECUTED _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; 20065f0: e2 04 63 18 ld [ %l1 + 0x318 ], %l1 <== NOT EXECUTED 20065f4: b4 10 20 00 clr %i2 <== NOT EXECUTED 20065f8: 10 80 00 07 b 2006614 <_IO_Manager_initialization+0x70> <== NOT EXECUTED 20065fc: a0 10 20 00 clr %l0 <== NOT EXECUTED 2006600: 92 04 00 18 add %l0, %i0, %o1 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006604: b4 06 a0 01 inc %i2 <== NOT EXECUTED 2006608: a0 04 20 18 add %l0, 0x18, %l0 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 200660c: 40 00 1e 65 call 200dfa0 <== NOT EXECUTED 2006610: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006614: 80 a6 80 19 cmp %i2, %i1 <== NOT EXECUTED 2006618: 12 bf ff fa bne 2006600 <_IO_Manager_initialization+0x5c> <== NOT EXECUTED 200661c: 90 04 00 11 add %l0, %l1, %o0 <== NOT EXECUTED 2006620: 81 c7 e0 08 ret <== NOT EXECUTED 2006624: 81 e8 00 00 restore <== NOT EXECUTED 0200718c <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 200718c: 9d e3 bf 98 save %sp, -104, %sp _ISR_Signals_to_thread_executing = FALSE; 2007190: 03 00 80 5f sethi %hi(0x2017c00), %g1 2007194: c0 20 61 38 clr [ %g1 + 0x138 ] ! 2017d38 <_ISR_Signals_to_thread_executing> _ISR_Nest_level = 0; 2007198: 03 00 80 5f sethi %hi(0x2017c00), %g1 _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 200719c: 90 10 24 00 mov 0x400, %o0 void _ISR_Handler_initialization( void ) { _ISR_Signals_to_thread_executing = FALSE; _ISR_Nest_level = 0; 20071a0: c0 20 60 78 clr [ %g1 + 0x78 ] _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 20071a4: 40 00 0c 1c call 200a214 <_Workspace_Allocate_or_fatal_error> 20071a8: 01 00 00 00 nop _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 20071ac: 03 00 80 5e sethi %hi(0x2017800), %g1 20071b0: a0 10 63 c4 or %g1, 0x3c4, %l0 ! 2017bc4 <_CPU_Table> 20071b4: 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( 20071b8: 03 00 80 5f sethi %hi(0x2017c00), %g1 _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 20071bc: 80 a0 af ff cmp %g2, 0xfff 20071c0: 18 80 00 06 bgu 20071d8 <_ISR_Handler_initialization+0x4c> 20071c4: d0 20 60 54 st %o0, [ %g1 + 0x54 ] _Internal_error_Occurred( 20071c8: 90 10 20 00 clr %o0 <== NOT EXECUTED 20071cc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 20071d0: 7f ff ff df call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 20071d4: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 20071d8: 40 00 0c 0f call 200a214 <_Workspace_Allocate_or_fatal_error> 20071dc: d0 04 20 18 ld [ %l0 + 0x18 ], %o0 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 20071e0: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 20071e4: 03 00 80 5e sethi %hi(0x2017800), %g1 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 20071e8: 84 02 00 02 add %o0, %g2, %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 20071ec: d0 20 63 c0 st %o0, [ %g1 + 0x3c0 ] _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 20071f0: 03 00 80 5e sethi %hi(0x2017800), %g1 20071f4: c4 20 63 0c st %g2, [ %g1 + 0x30c ] ! 2017b0c <_CPU_Interrupt_stack_high> #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 20071f8: 81 c7 e0 08 ret 20071fc: 81 e8 00 00 restore 0200c82c <_Objects_Compare_name_string>: boolean _Objects_Compare_name_string( void *name_1, void *name_2, uint16_t length ) { 200c82c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if ( !strncmp( name_1, name_2, length ) ) 200c830: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200c834: 95 2e a0 10 sll %i2, 0x10, %o2 <== NOT EXECUTED 200c838: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200c83c: 40 00 09 02 call 200ec44 <== NOT EXECUTED 200c840: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED return TRUE; return FALSE; } 200c844: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 200c848: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 200c84c: 81 c7 e0 08 ret <== NOT EXECUTED 200c850: 81 e8 00 00 restore <== NOT EXECUTED 02015d4c <_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; 2015d4c: 10 80 00 05 b 2015d60 <_Objects_Copy_name_raw+0x14> <== NOT EXECUTED 2015d50: 95 32 a0 02 srl %o2, 2, %o2 <== NOT EXECUTED while ( tmp_length-- ) *destination_p++ = *source_p++; 2015d54: 90 02 20 04 add %o0, 4, %o0 <== NOT EXECUTED 2015d58: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED 2015d5c: 92 02 60 04 add %o1, 4, %o1 <== NOT EXECUTED { uint32_t *source_p = (uint32_t *) source; uint32_t *destination_p = (uint32_t *) destination; size_t tmp_length = length / OBJECTS_NAME_ALIGNMENT; while ( tmp_length-- ) 2015d60: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED 2015d64: 80 a2 bf ff cmp %o2, -1 <== NOT EXECUTED 2015d68: 32 bf ff fb bne,a 2015d54 <_Objects_Copy_name_raw+0x8> <== NOT EXECUTED 2015d6c: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED *destination_p++ = *source_p++; } 2015d70: 81 c3 e0 08 retl <== NOT EXECUTED 2015d74: 01 00 00 00 nop 020072dc <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 20072dc: 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; 20072e0: 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 ) 20072e4: e0 16 20 10 lduh [ %i0 + 0x10 ], %l0 20072e8: 03 00 00 3f sethi %hi(0xfc00), %g1 20072ec: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20072f0: a2 08 80 01 and %g2, %g1, %l1 20072f4: 80 a4 00 11 cmp %l0, %l1 20072f8: 3a 80 00 06 bcc,a 2007310 <_Objects_Extend_information+0x34> 20072fc: e4 06 20 18 ld [ %i0 + 0x18 ], %l2 2007300: ac 10 00 11 mov %l1, %l6 2007304: 90 10 20 00 clr %o0 2007308: 10 80 00 12 b 2007350 <_Objects_Extend_information+0x74> 200730c: b8 10 20 00 clr %i4 block_count = 0; else { block_count = information->maximum / information->allocation_size; 2007310: 90 10 00 10 mov %l0, %o0 2007314: 92 10 00 12 mov %l2, %o1 2007318: 40 00 34 ea call 20146c0 <.udiv> 200731c: ac 10 00 11 mov %l1, %l6 2007320: 10 80 00 09 b 2007344 <_Objects_Extend_information+0x68> 2007324: b8 10 20 00 clr %i4 for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 2007328: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 200732c: c2 00 40 02 ld [ %g1 + %g2 ], %g1 2007330: 80 a0 60 00 cmp %g1, 0 2007334: 02 80 00 08 be 2007354 <_Objects_Extend_information+0x78> 2007338: 80 a5 80 10 cmp %l6, %l0 break; else index_base += information->allocation_size; 200733c: ac 05 80 12 add %l6, %l2, %l6 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 2007340: b8 07 20 01 inc %i4 2007344: 80 a7 00 08 cmp %i4, %o0 2007348: 12 bf ff f8 bne 2007328 <_Objects_Extend_information+0x4c> 200734c: 85 2f 20 02 sll %i4, 2, %g2 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 2007350: 80 a5 80 10 cmp %l6, %l0 2007354: 2a 80 00 63 bcs,a 20074e0 <_Objects_Extend_information+0x204> 2007358: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 200735c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2007360: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 2007364: ae 04 00 01 add %l0, %g1, %l7 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2007368: 80 a0 a0 00 cmp %g2, 0 /* * Up the block count and maximum */ block_count++; 200736c: a0 02 20 01 add %o0, 1, %l0 2007370: 82 05 c0 11 add %l7, %l1, %g1 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2007374: 02 80 00 0b be 20073a0 <_Objects_Extend_information+0xc4> 2007378: 91 2c 20 01 sll %l0, 1, %o0 object_blocks = (void**) 200737c: 90 02 00 10 add %o0, %l0, %o0 2007380: 90 00 40 08 add %g1, %o0, %o0 2007384: 7f ff ff cf call 20072c0 <_Workspace_Allocate> 2007388: 91 2a 20 02 sll %o0, 2, %o0 block_count * (sizeof(void *) + sizeof(uint32_t ) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 200738c: a4 92 20 00 orcc %o0, 0, %l2 2007390: 32 80 00 0a bne,a 20073b8 <_Objects_Extend_information+0xdc> 2007394: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 2007398: 81 c7 e0 08 ret <== NOT EXECUTED 200739c: 81 e8 00 00 restore <== NOT EXECUTED return; } else { object_blocks = (void**) 20073a0: 90 02 00 10 add %o0, %l0, %o0 20073a4: 90 00 40 08 add %g1, %o0, %o0 20073a8: 40 00 0b 9b call 200a214 <_Workspace_Allocate_or_fatal_error> 20073ac: 91 2a 20 02 sll %o0, 2, %o0 20073b0: a4 10 00 08 mov %o0, %l2 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 20073b4: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 /* * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; 20073b8: ba 04 3f ff add %l0, -1, %i5 if ( information->maximum > minimum_index ) { 20073bc: 80 a0 40 11 cmp %g1, %l1 20073c0: 84 10 20 00 clr %g2 20073c4: 83 2c 20 02 sll %l0, 2, %g1 /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 20073c8: a8 04 80 01 add %l2, %g1, %l4 object_blocks, block_count * sizeof(void*) ); name_table = (Objects_Name *) _Addresses_Add_offset( 20073cc: aa 05 00 01 add %l4, %g1, %l5 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 20073d0: 08 80 00 19 bleu 2007434 <_Objects_Extend_information+0x158> 20073d4: a6 05 40 01 add %l5, %g1, %l3 /* * Copy each section of the table over. This has to be performed as * separate parts as size of each block has changed. */ memcpy( object_blocks, 20073d8: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 20073dc: a1 2f 60 02 sll %i5, 2, %l0 20073e0: 90 10 00 12 mov %l2, %o0 20073e4: 40 00 1a ef call 200dfa0 20073e8: 94 10 00 10 mov %l0, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 20073ec: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 20073f0: 94 10 00 10 mov %l0, %o2 20073f4: 40 00 1a eb call 200dfa0 20073f8: 90 10 00 14 mov %l4, %o0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, 20073fc: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 2007400: 94 10 00 10 mov %l0, %o2 2007404: 40 00 1a e7 call 200dfa0 2007408: 90 10 00 15 mov %l5, %o0 information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 200740c: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 2007410: d2 06 20 20 ld [ %i0 + 0x20 ], %o1 2007414: 94 02 80 11 add %o2, %l1, %o2 2007418: 90 10 00 13 mov %l3, %o0 200741c: 40 00 1a e1 call 200dfa0 2007420: 95 2a a0 02 sll %o2, 2, %o2 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 2007424: 10 80 00 08 b 2007444 <_Objects_Extend_information+0x168> 2007428: 83 2f 60 02 sll %i5, 2, %g1 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 200742c: 84 00 a0 01 inc %g2 local_table[ index ] = NULL; 2007430: c0 20 40 13 clr [ %g1 + %l3 ] else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 2007434: 80 a0 80 11 cmp %g2, %l1 2007438: 32 bf ff fd bne,a 200742c <_Objects_Extend_information+0x150> 200743c: 83 28 a0 02 sll %g2, 2, %g1 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 2007440: 83 2f 60 02 sll %i5, 2, %g1 inactive_per_block[block_count] = 0; 2007444: c0 25 00 01 clr [ %l4 + %g1 ] /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 2007448: c0 24 80 01 clr [ %l2 + %g1 ] inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); 200744c: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; name_table[block_count] = NULL; 2007450: c0 25 40 01 clr [ %l5 + %g1 ] for ( index=index_base ; index < ( information->allocation_size + index_base ); 2007454: 83 2d a0 02 sll %l6, 2, %g1 2007458: 86 05 80 02 add %l6, %g2, %g3 200745c: 84 04 c0 01 add %l3, %g1, %g2 2007460: 10 80 00 04 b 2007470 <_Objects_Extend_information+0x194> 2007464: 82 10 00 16 mov %l6, %g1 index++ ) { local_table[ index ] = NULL; 2007468: c0 20 bf fc clr [ %g2 + -4 ] inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 200746c: 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 ); 2007470: 80 a0 40 03 cmp %g1, %g3 2007474: 0a bf ff fd bcs 2007468 <_Objects_Extend_information+0x18c> 2007478: 84 00 a0 04 add %g2, 4, %g2 index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 200747c: 7f ff ea 31 call 2001d40 2007480: 01 00 00 00 nop 2007484: a0 10 00 08 mov %o0, %l0 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2007488: d0 06 00 00 ld [ %i0 ], %o0 200748c: d2 16 20 04 lduh [ %i0 + 4 ], %o1 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; 2007490: e8 26 20 38 st %l4, [ %i0 + 0x38 ] information->name_table = name_table; 2007494: ea 26 20 24 st %l5, [ %i0 + 0x24 ] information->local_table = local_table; 2007498: e6 26 20 20 st %l3, [ %i0 + 0x20 ] information->maximum = maximum; 200749c: ee 36 20 10 sth %l7, [ %i0 + 0x10 ] information->maximum_id = _Objects_Build_id( 20074a0: 97 2d e0 10 sll %l7, 0x10, %o3 local_table[ index ] = NULL; } _ISR_Disable( level ); old_tables = information->object_blocks; 20074a4: e2 06 20 3c ld [ %i0 + 0x3c ], %l1 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 20074a8: 97 32 e0 10 srl %o3, 0x10, %o3 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; 20074ac: e4 26 20 3c st %l2, [ %i0 + 0x3c ] information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 20074b0: 7f ff ff 7d call 20072a4 <_Objects_Build_id> 20074b4: 94 10 20 01 mov 1, %o2 20074b8: d0 26 20 0c st %o0, [ %i0 + 0xc ] information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 20074bc: 7f ff ea 25 call 2001d50 20074c0: 90 10 00 10 mov %l0, %o0 if ( old_tables ) 20074c4: 80 a4 60 00 cmp %l1, 0 20074c8: 02 80 00 05 be 20074dc <_Objects_Extend_information+0x200> 20074cc: 11 00 80 5e sethi %hi(0x2017800), %o0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 20074d0: 92 10 00 11 mov %l1, %o1 20074d4: 7f ff fe 1a call 2006d3c <_Heap_Free> 20074d8: 90 12 23 fc or %o0, 0x3fc, %o0 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 20074dc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 20074e0: e2 06 20 3c ld [ %i0 + 0x3c ], %l1 20074e4: 80 a0 60 00 cmp %g1, 0 20074e8: a1 2f 20 02 sll %i4, 2, %l0 20074ec: d0 16 20 44 lduh [ %i0 + 0x44 ], %o0 20074f0: 02 80 00 11 be 2007534 <_Objects_Extend_information+0x258> 20074f4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 information->object_blocks[ block ] = 20074f8: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 20074fc: 91 2a 20 10 sll %o0, 0x10, %o0 2007500: 91 32 20 10 srl %o0, 0x10, %o0 2007504: 40 00 34 35 call 20145d8 <.umul> 2007508: 90 02 00 01 add %o0, %g1, %o0 200750c: 7f ff ff 6d call 20072c0 <_Workspace_Allocate> 2007510: 01 00 00 00 nop _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 2007514: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { information->object_blocks[ block ] = 2007518: d0 24 00 11 st %o0, [ %l0 + %l1 ] _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 200751c: c2 00 40 10 ld [ %g1 + %l0 ], %g1 2007520: 80 a0 60 00 cmp %g1, 0 2007524: 32 80 00 0d bne,a 2007558 <_Objects_Extend_information+0x27c> 2007528: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 200752c: 81 c7 e0 08 ret <== NOT EXECUTED 2007530: 81 e8 00 00 restore <== NOT EXECUTED return; } else { information->object_blocks[ block ] = 2007534: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 2007538: 91 2a 20 10 sll %o0, 0x10, %o0 200753c: 91 32 20 10 srl %o0, 0x10, %o0 2007540: 40 00 34 26 call 20145d8 <.umul> 2007544: 90 02 00 01 add %o0, %g1, %o0 2007548: 40 00 0b 33 call 200a214 <_Workspace_Allocate_or_fatal_error> 200754c: 01 00 00 00 nop 2007550: d0 24 00 11 st %o0, [ %l0 + %l1 ] 2007554: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 2007558: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 200755c: 40 00 34 1f call 20145d8 <.umul> 2007560: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); } name_area = (Objects_Name *) _Addresses_Add_offset( 2007564: a7 2f 20 02 sll %i4, 2, %l3 information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 2007568: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 200756c: c2 04 00 13 ld [ %l0 + %l3 ], %g1 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007570: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 2007574: a2 02 00 01 add %o0, %g1, %l1 2007578: d6 06 20 1c ld [ %i0 + 0x1c ], %o3 name_area = (Objects_Name *) _Addresses_Add_offset( information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 200757c: e2 20 80 13 st %l1, [ %g2 + %l3 ] /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007580: d2 04 00 13 ld [ %l0 + %l3 ], %o1 2007584: 90 07 bf ec add %fp, -20, %o0 2007588: a4 10 00 16 mov %l6, %l2 * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 200758c: aa 10 00 08 mov %o0, %l5 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007590: 40 00 13 9e call 200c408 <_Chain_Initialize> 2007594: a8 06 20 28 add %i0, 0x28, %l4 2007598: 30 80 00 0c b,a 20075c8 <_Objects_Extend_information+0x2ec> index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 200759c: d2 16 20 04 lduh [ %i0 + 4 ], %o1 20075a0: d0 06 00 00 ld [ %i0 ], %o0 20075a4: 7f ff ff 40 call 20072a4 <_Objects_Build_id> 20075a8: a4 04 a0 01 inc %l2 20075ac: c2 16 20 44 lduh [ %i0 + 0x44 ], %g1 20075b0: d0 24 20 08 st %o0, [ %l0 + 8 ] information->the_class, _Objects_Local_node, index ); the_object->name = (void *) name_area; 20075b4: e2 24 20 0c st %l1, [ %l0 + 0xc ] name_area = _Addresses_Add_offset( name_area, information->name_length ); _Chain_Append( &information->Inactive, &the_object->Node ); 20075b8: 92 10 00 10 mov %l0, %o1 20075bc: a2 04 40 01 add %l1, %g1, %l1 20075c0: 7f ff fc 7b call 20067ac <_Chain_Append> 20075c4: 90 10 00 14 mov %l4, %o0 * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 20075c8: 7f ff fc 85 call 20067dc <_Chain_Get> 20075cc: 90 10 00 15 mov %l5, %o0 the_object->id = _Objects_Build_id( 20075d0: 96 10 00 12 mov %l2, %o3 * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 20075d4: a0 10 00 08 mov %o0, %l0 20075d8: 80 a2 20 00 cmp %o0, 0 20075dc: 12 bf ff f0 bne 200759c <_Objects_Extend_information+0x2c0> 20075e0: 94 10 20 01 mov 1, %o2 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 20075e4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 20075e8: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 information->inactive += information->allocation_size; 20075ec: c6 16 20 34 lduh [ %i0 + 0x34 ], %g3 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 20075f0: c2 20 80 13 st %g1, [ %g2 + %l3 ] information->inactive += information->allocation_size; 20075f4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 20075f8: 82 00 40 03 add %g1, %g3, %g1 20075fc: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 2007600: 81 c7 e0 08 ret 2007604: 81 e8 00 00 restore 02007698 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 2007698: 9d e3 bf 98 save %sp, -104, %sp Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 200769c: c2 06 20 08 ld [ %i0 + 8 ], %g1 _ISR_Disable( level ); 20076a0: 7f ff e9 a8 call 2001d40 20076a4: b2 26 40 01 sub %i1, %g1, %i1 { Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 20076a8: b2 06 60 01 inc %i1 _ISR_Disable( level ); if ( information->maximum >= index ) { 20076ac: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 20076b0: 80 a0 40 19 cmp %g1, %i1 20076b4: 0a 80 00 11 bcs 20076f8 <_Objects_Get_isr_disable+0x60> 20076b8: 83 2e 60 02 sll %i1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 20076bc: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 20076c0: f0 00 80 01 ld [ %g2 + %g1 ], %i0 20076c4: 80 a6 20 00 cmp %i0, 0 20076c8: 02 80 00 06 be 20076e0 <_Objects_Get_isr_disable+0x48> 20076cc: 01 00 00 00 nop *location = OBJECTS_LOCAL; *level_p = level; 20076d0: 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; 20076d4: c0 26 80 00 clr [ %i2 ] 20076d8: 81 c7 e0 08 ret 20076dc: 81 e8 00 00 restore *level_p = level; return the_object; } _ISR_Enable( level ); 20076e0: 7f ff e9 9c call 2001d50 <== NOT EXECUTED 20076e4: 01 00 00 00 nop <== NOT EXECUTED *location = OBJECTS_ERROR; 20076e8: 82 10 20 02 mov 2, %g1 ! 2 <== NOT EXECUTED 20076ec: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 20076f0: 81 c7 e0 08 ret <== NOT EXECUTED 20076f4: 81 e8 00 00 restore <== NOT EXECUTED return NULL; } _ISR_Enable( level ); 20076f8: 7f ff e9 96 call 2001d50 20076fc: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; 2007700: 82 10 20 02 mov 2, %g1 2007704: c2 26 80 00 st %g1, [ %i2 ] _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 2007708: 81 c7 e0 08 ret 200770c: 81 e8 00 00 restore 02009164 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 2009164: 9d e3 bf 88 save %sp, -120, %sp 2009168: 92 10 00 18 mov %i0, %o1 uint32_t i; char lname[5]; Objects_Control *the_object; Objects_Locations location; if ( length == 0 ) 200916c: 80 a6 60 00 cmp %i1, 0 2009170: 02 80 00 43 be 200927c <_Objects_Get_name_as_string+0x118> 2009174: b0 10 00 1a mov %i2, %i0 return NULL; if ( name == NULL ) 2009178: 80 a6 a0 00 cmp %i2, 0 200917c: 02 80 00 3e be 2009274 <_Objects_Get_name_as_string+0x110> 2009180: 85 32 60 16 srl %o1, 0x16, %g2 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 2009184: 03 00 80 90 sethi %hi(0x2024000), %g1 2009188: 84 08 a0 1c and %g2, 0x1c, %g2 200918c: 82 10 60 40 or %g1, 0x40, %g1 2009190: c4 00 40 02 ld [ %g1 + %g2 ], %g2 2009194: 83 32 60 1b srl %o1, 0x1b, %g1 2009198: 83 28 60 02 sll %g1, 2, %g1 200919c: e0 00 80 01 ld [ %g2 + %g1 ], %l0 return NULL; information = _Objects_Get_information( id ); if ( !information ) 20091a0: 80 a4 20 00 cmp %l0, 0 20091a4: 22 80 00 34 be,a 2009274 <_Objects_Get_name_as_string+0x110> 20091a8: b0 10 20 00 clr %i0 <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, id, &location ); 20091ac: 90 10 00 10 mov %l0, %o0 20091b0: 40 00 00 36 call 2009288 <_Objects_Get> 20091b4: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 20091b8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20091bc: 80 a0 60 00 cmp %g1, 0 20091c0: 32 80 00 2d bne,a 2009274 <_Objects_Get_name_as_string+0x110> 20091c4: b0 10 20 00 clr %i0 <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 20091c8: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 20091cc: 80 a0 60 00 cmp %g1, 0 20091d0: 12 80 00 0b bne 20091fc <_Objects_Get_name_as_string+0x98> 20091d4: d0 02 20 0c ld [ %o0 + 0xc ], %o0 s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; 20091d8: 83 32 20 18 srl %o0, 0x18, %g1 20091dc: c2 2f bf ef stb %g1, [ %fp + -17 ] lname[ 1 ] = (u32_name >> 16) & 0xff; 20091e0: 83 32 20 10 srl %o0, 0x10, %g1 lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; 20091e4: d0 2f bf f2 stb %o0, [ %fp + -14 ] s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; 20091e8: c2 2f bf f0 stb %g1, [ %fp + -16 ] lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20091ec: c0 2f bf f3 clrb [ %fp + -13 ] } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 20091f0: 83 32 20 08 srl %o0, 8, %g1 lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20091f4: 90 07 bf ef add %fp, -17, %o0 } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 20091f8: c2 2f bf f1 stb %g1, [ %fp + -15 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20091fc: 84 10 00 18 mov %i0, %g2 2009200: 88 10 20 01 mov 1, %g4 s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { *d = (!isprint(*s)) ? '*' : *s; 2009204: 10 80 00 09 b 2009228 <_Objects_Get_name_as_string+0xc4> 2009208: 19 00 80 6e sethi %hi(0x201b800), %o4 200920c: c2 03 22 10 ld [ %o4 + 0x210 ], %g1 ! 201ba10 <__ctype_ptr> 2009210: c2 48 40 03 ldsb [ %g1 + %g3 ], %g1 2009214: 80 88 60 97 btst 0x97, %g1 2009218: 22 80 00 02 be,a 2009220 <_Objects_Get_name_as_string+0xbc> 200921c: 9a 10 20 2a mov 0x2a, %o5 <== NOT EXECUTED 2009220: da 28 80 00 stb %o5, [ %g2 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { 2009224: 84 00 a0 01 inc %g2 2009228: 80 a1 00 19 cmp %g4, %i1 200922c: 02 80 00 07 be 2009248 <_Objects_Get_name_as_string+0xe4> 2009230: 82 02 00 04 add %o0, %g4, %g1 2009234: c6 48 7f ff ldsb [ %g1 + -1 ], %g3 2009238: 88 01 20 01 inc %g4 200923c: 80 a0 e0 00 cmp %g3, 0 2009240: 12 bf ff f3 bne 200920c <_Objects_Get_name_as_string+0xa8> 2009244: da 08 7f ff ldub [ %g1 + -1 ], %o5 *d = (!isprint(*s)) ? '*' : *s; } *d = '\0'; 2009248: c0 28 80 00 clrb [ %g2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200924c: 03 00 80 90 sethi %hi(0x2024000), %g1 2009250: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 20240e0 <_Thread_Dispatch_disable_level> 2009254: 84 00 bf ff add %g2, -1, %g2 2009258: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 200925c: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 2009260: 80 a0 60 00 cmp %g1, 0 2009264: 12 80 00 07 bne 2009280 <_Objects_Get_name_as_string+0x11c> 2009268: 01 00 00 00 nop _Thread_Dispatch(); 200926c: 40 00 04 cd call 200a5a0 <_Thread_Dispatch> 2009270: 01 00 00 00 nop 2009274: 81 c7 e0 08 ret 2009278: 81 e8 00 00 restore 200927c: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 2009280: 81 c7 e0 08 ret <== NOT EXECUTED 2009284: 81 e8 00 00 restore <== NOT EXECUTED 02015d78 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 2015d78: 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) 2015d7c: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 2015d80: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <== NOT EXECUTED 2015d84: 80 8e 40 01 btst %i1, %g1 <== NOT EXECUTED 2015d88: 22 80 00 02 be,a 2015d90 <_Objects_Get_next+0x18> <== NOT EXECUTED 2015d8c: 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) 2015d90: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 2015d94: a0 10 63 ff or %g1, 0x3ff, %l0 ! ffff <== NOT EXECUTED 2015d98: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED 2015d9c: 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); 2015da0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2015da4: 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) 2015da8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2015dac: 18 80 00 0a bgu 2015dd4 <_Objects_Get_next+0x5c> <== NOT EXECUTED 2015db0: 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); 2015db4: 7f ff d8 6d call 200bf68 <_Objects_Get> <== NOT EXECUTED 2015db8: b2 06 60 01 inc %i1 <== NOT EXECUTED next_id++; } while (*location_p != OBJECTS_LOCAL); 2015dbc: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 2015dc0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2015dc4: 32 bf ff f6 bne,a 2015d9c <_Objects_Get_next+0x24> <== NOT EXECUTED 2015dc8: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED *next_id_p = next_id; 2015dcc: 10 80 00 07 b 2015de8 <_Objects_Get_next+0x70> <== NOT EXECUTED 2015dd0: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 2015dd4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 2015dd8: 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; 2015ddc: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 2015de0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED 2015de4: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED return 0; } 2015de8: 81 c7 e0 08 ret <== NOT EXECUTED 2015dec: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 020149a8 <_Objects_Get_no_protection>: ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 20149a8: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->maximum >= index ) { 20149ac: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 20149b0: 92 22 40 01 sub %o1, %g1, %o1 20149b4: 82 02 60 01 add %o1, 1, %g1 if ( information->maximum >= index ) { 20149b8: 80 a0 80 01 cmp %g2, %g1 20149bc: 0a 80 00 0b bcs 20149e8 <_Objects_Get_no_protection+0x40> 20149c0: 83 28 60 02 sll %g1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 20149c4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 20149c8: d0 00 80 01 ld [ %g2 + %g1 ], %o0 20149cc: 80 a2 20 00 cmp %o0, 0 20149d0: 02 80 00 04 be 20149e0 <_Objects_Get_no_protection+0x38> 20149d4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_LOCAL; 20149d8: 81 c3 e0 08 retl 20149dc: c0 22 80 00 clr [ %o2 ] return the_object; } *location = OBJECTS_ERROR; 20149e0: 81 c3 e0 08 retl <== NOT EXECUTED 20149e4: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED return NULL; } *location = OBJECTS_ERROR; 20149e8: 82 10 20 02 mov 2, %g1 20149ec: 90 10 20 00 clr %o0 /* * Not supported for multiprocessing */ return NULL; } 20149f0: 81 c3 e0 08 retl 20149f4: c2 22 80 00 st %g1, [ %o2 ] 02007974 <_Objects_Handler_initialization>: uint32_t node, uint32_t maximum_nodes, uint32_t maximum_global_objects ) { if ( node < 1 || node > maximum_nodes ) 2007974: 80 a2 20 00 cmp %o0, 0 2007978: 22 80 00 05 be,a 200798c <_Objects_Handler_initialization+0x18> 200797c: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007980: 80 a2 00 09 cmp %o0, %o1 2007984: 08 80 00 07 bleu 20079a0 <_Objects_Handler_initialization+0x2c> 2007988: 90 10 20 00 clr %o0 _Internal_error_Occurred( 200798c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2007990: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED 2007994: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2007998: 7f ff fd ed call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 200799c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20079a0: 81 c3 e0 08 retl 20079a4: 01 00 00 00 nop 02008db8 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 2008db8: 9d e3 bf 90 save %sp, -112, %sp 2008dbc: 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 ) 2008dc0: 80 a6 60 00 cmp %i1, 0 2008dc4: 02 80 00 26 be 2008e5c <_Objects_Id_to_name+0xa4> 2008dc8: 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); 2008dcc: 83 32 60 18 srl %o1, 0x18, %g1 2008dd0: 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 ) 2008dd4: 80 a0 60 04 cmp %g1, 4 2008dd8: 18 80 00 23 bgu 2008e64 <_Objects_Id_to_name+0xac> 2008ddc: 85 28 60 02 sll %g1, 2, %g2 return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( id ); information = _Objects_Information_table[ the_api ][ the_class ]; 2008de0: 03 00 80 6f sethi %hi(0x201bc00), %g1 2008de4: 82 10 63 40 or %g1, 0x340, %g1 ! 201bf40 <_Objects_Information_table> 2008de8: c4 00 40 02 ld [ %g1 + %g2 ], %g2 2008dec: 83 32 60 1b srl %o1, 0x1b, %g1 2008df0: 83 28 60 02 sll %g1, 2, %g1 2008df4: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( !information ) 2008df8: 80 a2 20 00 cmp %o0, 0 2008dfc: 02 80 00 18 be 2008e5c <_Objects_Id_to_name+0xa4> 2008e00: b0 10 20 03 mov 3, %i0 return OBJECTS_INVALID_ID; if ( information->is_string ) 2008e04: c2 02 20 40 ld [ %o0 + 0x40 ], %g1 2008e08: 80 a0 60 00 cmp %g1, 0 2008e0c: 12 80 00 17 bne 2008e68 <_Objects_Id_to_name+0xb0> 2008e10: 01 00 00 00 nop return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, id, &ignored_location ); 2008e14: 7f ff ff c4 call 2008d24 <_Objects_Get> 2008e18: 94 07 bf f4 add %fp, -12, %o2 if ( !the_object ) 2008e1c: 80 a2 20 00 cmp %o0, 0 2008e20: 02 80 00 0f be 2008e5c <_Objects_Id_to_name+0xa4> 2008e24: b0 10 20 03 mov 3, %i0 return OBJECTS_INVALID_ID; *name = the_object->name; 2008e28: c2 02 20 0c ld [ %o0 + 0xc ], %g1 2008e2c: 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 ) 2008e30: 05 00 80 6f sethi %hi(0x201bc00), %g2 2008e34: c2 00 a3 e0 ld [ %g2 + 0x3e0 ], %g1 ! 201bfe0 <_Thread_Dispatch_disable_level> 2008e38: b0 10 20 00 clr %i0 2008e3c: 82 00 7f ff add %g1, -1, %g1 2008e40: c2 20 a3 e0 st %g1, [ %g2 + 0x3e0 ] 2008e44: c2 00 a3 e0 ld [ %g2 + 0x3e0 ], %g1 2008e48: 80 a0 60 00 cmp %g1, 0 2008e4c: 12 80 00 07 bne 2008e68 <_Objects_Id_to_name+0xb0> 2008e50: 01 00 00 00 nop _Thread_Dispatch(); 2008e54: 40 00 04 e7 call 200a1f0 <_Thread_Dispatch> 2008e58: 01 00 00 00 nop 2008e5c: 81 c7 e0 08 ret 2008e60: 81 e8 00 00 restore 2008e64: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 2008e68: 81 c7 e0 08 ret <== NOT EXECUTED 2008e6c: 81 e8 00 00 restore <== NOT EXECUTED 020077a4 <_Objects_Initialize_information>: , boolean supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 20077a4: 9d e3 bf 98 save %sp, -104, %sp /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 20077a8: 03 00 80 5e sethi %hi(0x2017800), %g1 20077ac: 85 2e 60 02 sll %i1, 2, %g2 20077b0: 82 10 63 10 or %g1, 0x310, %g1 20077b4: c2 00 40 02 ld [ %g1 + %g2 ], %g1 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 20077b8: 89 2e a0 1b sll %i2, 0x1b, %g4 #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; information->the_class = the_class; 20077bc: f4 36 20 04 sth %i2, [ %i0 + 4 ] /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 20077c0: b5 2e a0 02 sll %i2, 2, %i2 20077c4: f0 20 40 1a st %i0, [ %g1 + %i2 ] /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; 20077c8: 83 36 e0 1f srl %i3, 0x1f, %g1 20077cc: c2 26 20 14 st %g1, [ %i0 + 0x14 ] maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 20077d0: 03 20 00 00 sethi %hi(0x80000000), %g1 , boolean supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 20077d4: de 07 a0 5c ld [ %fp + 0x5c ], %o7 uint32_t index; #endif information->the_api = the_api; information->the_class = the_class; information->is_string = is_string; 20077d8: fa 26 20 40 st %i5, [ %i0 + 0x40 ] /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 20077dc: ba 2e c0 01 andn %i3, %g1, %i5 /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 20077e0: 03 00 80 5e sethi %hi(0x2017800), %g1 20077e4: 82 10 60 08 or %g1, 8, %g1 ! 2017808 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 20077e8: 80 a0 00 1d cmp %g0, %i5 /* * Set the size of the object */ information->size = size; 20077ec: b9 2f 20 10 sll %i4, 0x10, %i4 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 20077f0: 86 40 20 00 addx %g0, 0, %g3 20077f4: 85 2e 60 18 sll %i1, 0x18, %g2 /* * Set the size of the object */ information->size = size; 20077f8: b9 37 20 10 srl %i4, 0x10, %i4 /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 20077fc: c2 26 20 20 st %g1, [ %i0 + 0x20 ] /* * Set the size of the object */ information->size = size; 2007800: f8 26 20 1c st %i4, [ %i0 + 0x1c ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 2007804: 03 00 00 40 sethi %hi(0x10000), %g1 uint32_t name_length; #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; 2007808: f2 26 00 00 st %i1, [ %i0 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 200780c: 84 10 80 01 or %g2, %g1, %g2 information->the_api = the_api; information->the_class = the_class; information->is_string = is_string; information->local_table = 0; information->name_table = 0; 2007810: c0 26 20 24 clr [ %i0 + 0x24 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 2007814: 84 10 80 04 or %g2, %g4, %g2 information->the_class = the_class; information->is_string = is_string; information->local_table = 0; information->name_table = 0; information->inactive_per_block = 0; 2007818: c0 26 20 38 clr [ %i0 + 0x38 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 200781c: 84 10 80 03 or %g2, %g3, %g2 information->is_string = is_string; information->local_table = 0; information->name_table = 0; information->inactive_per_block = 0; information->object_blocks = 0; 2007820: c0 26 20 3c clr [ %i0 + 0x3c ] information->inactive = 0; 2007824: c0 36 20 34 clrh [ %i0 + 0x34 ] /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 2007828: fa 26 20 18 st %i5, [ %i0 + 0x18 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 200782c: c4 26 20 08 st %g2, [ %i0 + 8 ] * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) 2007830: 80 8b e0 03 btst 3, %o7 2007834: 02 80 00 04 be 2007844 <_Objects_Initialize_information+0xa0> 2007838: 82 10 00 0f mov %o7, %g1 name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 200783c: 82 03 e0 04 add %o7, 4, %g1 <== NOT EXECUTED 2007840: 82 08 7f fc and %g1, -4, %g1 <== NOT EXECUTED ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 2007844: c2 36 20 44 sth %g1, [ %i0 + 0x44 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2007848: 82 06 20 2c add %i0, 0x2c, %g1 the_chain->permanent_null = NULL; 200784c: 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); 2007850: c2 26 20 28 st %g1, [ %i0 + 0x28 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2007854: 82 06 20 28 add %i0, 0x28, %g1 /* * Initialize objects .. if there are any */ if ( maximum ) { 2007858: 80 a7 60 00 cmp %i5, 0 200785c: 02 80 00 05 be 2007870 <_Objects_Initialize_information+0xcc> 2007860: c2 26 20 30 st %g1, [ %i0 + 0x30 ] /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 2007864: 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 ); 2007868: 7f ff fe 9d call 20072dc <_Objects_Extend_information> 200786c: 81 e8 00 00 restore 2007870: 81 c7 e0 08 ret 2007874: 81 e8 00 00 restore 02007878 <_Objects_Name_to_id>: Objects_Information *information, Objects_Name name, uint32_t node, Objects_Id *id ) { 2007878: 9d e3 bf 98 save %sp, -104, %sp 200787c: 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 ) 2007880: 80 a6 e0 00 cmp %i3, 0 2007884: 02 80 00 3a be 200796c <_Objects_Name_to_id+0xf4> 2007888: b0 10 20 02 mov 2, %i0 return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 200788c: 80 a6 60 00 cmp %i1, 0 2007890: 02 80 00 2d be 2007944 <_Objects_Name_to_id+0xcc> 2007894: 01 00 00 00 nop return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007898: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 200789c: 80 a0 60 00 cmp %g1, 0 20078a0: 02 80 00 29 be 2007944 <_Objects_Name_to_id+0xcc> 20078a4: 80 a6 a0 00 cmp %i2, 0 20078a8: 22 80 00 2a be,a 2007950 <_Objects_Name_to_id+0xd8> 20078ac: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 20078b0: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 20078b4: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff 20078b8: 80 a6 80 01 cmp %i2, %g1 20078bc: 02 80 00 24 be 200794c <_Objects_Name_to_id+0xd4> 20078c0: 80 a6 a0 01 cmp %i2, 1 20078c4: 22 80 00 23 be,a 2007950 <_Objects_Name_to_id+0xd8> 20078c8: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; else compare_them = _Objects_Compare_name_raw; for ( index = 1; index <= information->maximum; index++ ) { 20078cc: 81 c7 e0 08 ret 20078d0: 91 e8 20 01 restore %g0, 1, %o0 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 20078d4: a4 10 60 2c or %g1, 0x2c, %l2 <== 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 ) ) { 20078d8: 83 28 a0 10 sll %g2, 0x10, %g1 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 20078dc: 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 ) ) { 20078e0: 10 80 00 15 b 2007934 <_Objects_Name_to_id+0xbc> 20078e4: 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 ]; 20078e8: c2 04 60 20 ld [ %l1 + 0x20 ], %g1 name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; else compare_them = _Objects_Compare_name_raw; for ( index = 1; index <= information->maximum; index++ ) { 20078ec: a0 04 20 01 inc %l0 the_object = information->local_table[ index ]; 20078f0: f4 00 40 02 ld [ %g1 + %g2 ], %i2 if ( !the_object || !the_object->name ) 20078f4: 80 a6 a0 00 cmp %i2, 0 20078f8: 02 80 00 0f be 2007934 <_Objects_Name_to_id+0xbc> 20078fc: 90 10 00 19 mov %i1, %o0 2007900: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 2007904: 80 a2 60 00 cmp %o1, 0 2007908: 02 80 00 0b be 2007934 <_Objects_Name_to_id+0xbc> 200790c: 94 10 00 18 mov %i0, %o2 continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 2007910: 9f c4 80 00 call %l2 2007914: 01 00 00 00 nop 2007918: 80 a2 20 00 cmp %o0, 0 200791c: 22 80 00 07 be,a 2007938 <_Objects_Name_to_id+0xc0> 2007920: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 *id = the_object->id; 2007924: c2 06 a0 08 ld [ %i2 + 8 ], %g1 2007928: c2 26 c0 00 st %g1, [ %i3 ] 200792c: 81 c7 e0 08 ret 2007930: 91 e8 20 00 restore %g0, 0, %o0 name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; else compare_them = _Objects_Compare_name_raw; for ( index = 1; index <= information->maximum; index++ ) { 2007934: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 2007938: 80 a4 00 01 cmp %l0, %g1 200793c: 08 bf ff eb bleu 20078e8 <_Objects_Name_to_id+0x70> 2007940: 85 2c 20 02 sll %l0, 2, %g2 2007944: 81 c7 e0 08 ret 2007948: 91 e8 20 01 restore %g0, 1, %o0 search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; 200794c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 _Objects_Is_local_node( node ) )) search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; 2007950: c4 14 60 44 lduh [ %l1 + 0x44 ], %g2 if ( information->is_string ) compare_them = _Objects_Compare_name_string; 2007954: 80 a0 60 00 cmp %g1, 0 2007958: 03 00 80 32 sethi %hi(0x200c800), %g1 200795c: 02 bf ff df be 20078d8 <_Objects_Name_to_id+0x60> 2007960: a4 10 60 1c or %g1, 0x1c, %l2 ! 200c81c <_Objects_Compare_name_raw> if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007964: 10 bf ff dc b 20078d4 <_Objects_Name_to_id+0x5c> <== NOT EXECUTED 2007968: 03 00 80 32 sethi %hi(0x200c800), %g1 <== NOT EXECUTED return ( _Objects_MP_Global_name_search( information, name, node, id ) ); #else return OBJECTS_INVALID_NAME; #endif } 200796c: 81 c7 e0 08 ret <== NOT EXECUTED 2007970: 81 e8 00 00 restore <== NOT EXECUTED 020079a8 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 20079a8: 9d e3 bf 98 save %sp, -104, %sp 20079ac: 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; 20079b0: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 20079b4: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0 20079b8: 03 00 00 3f sethi %hi(0xfc00), %g1 20079bc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20079c0: 92 10 00 10 mov %l0, %o1 20079c4: a2 08 80 01 and %g2, %g1, %l1 20079c8: 40 00 33 3e call 20146c0 <.udiv> 20079cc: 90 22 00 11 sub %o0, %l1, %o0 20079d0: 86 10 20 00 clr %g3 20079d4: 10 80 00 33 b 2007aa0 <_Objects_Shrink_information+0xf8> 20079d8: a4 10 20 00 clr %l2 for ( block = 0; block < block_count; block++ ) { 20079dc: 86 00 e0 01 inc %g3 if ( information->inactive_per_block[ block ] == information->allocation_size ) { 20079e0: c2 00 40 12 ld [ %g1 + %l2 ], %g1 20079e4: 80 a0 40 10 cmp %g1, %l0 20079e8: 12 80 00 2c bne 2007a98 <_Objects_Shrink_information+0xf0> 20079ec: 84 04 a0 04 add %l2, 4, %g2 /* * XXX - Not to sure how to use a chain where you need to iterate and * and remove elements. */ the_object = (Objects_Control *) information->Inactive.first; 20079f0: e0 06 20 28 ld [ %i0 + 0x28 ], %l0 20079f4: 03 00 00 3f sethi %hi(0xfc00), %g1 20079f8: a6 10 63 ff or %g1, 0x3ff, %l3 ! ffff 20079fc: c2 04 20 08 ld [ %l0 + 8 ], %g1 2007a00: 84 08 40 13 and %g1, %l3, %g2 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 2007a04: 80 a0 80 11 cmp %g2, %l1 2007a08: 2a 80 00 0c bcs,a 2007a38 <_Objects_Shrink_information+0x90> 2007a0c: e0 04 00 00 ld [ %l0 ], %l0 2007a10: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2007a14: 82 04 40 01 add %l1, %g1, %g1 2007a18: 80 a0 80 01 cmp %g2, %g1 2007a1c: 1a 80 00 06 bcc 2007a34 <_Objects_Shrink_information+0x8c> 2007a20: 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 ); 2007a24: 40 00 12 6f call 200c3e0 <_Chain_Extract> 2007a28: e0 04 00 00 ld [ %l0 ], %l0 } else { the_object = (Objects_Control *) the_object->Node.next; } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 2007a2c: 10 80 00 04 b 2007a3c <_Objects_Shrink_information+0x94> 2007a30: 80 a4 20 00 cmp %l0, 0 the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 2007a34: e0 04 00 00 ld [ %l0 ], %l0 } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 2007a38: 80 a4 20 00 cmp %l0, 0 2007a3c: 22 80 00 07 be,a 2007a58 <_Objects_Shrink_information+0xb0> 2007a40: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED 2007a44: c2 04 00 00 ld [ %l0 ], %g1 2007a48: 80 a0 60 00 cmp %g1, 0 2007a4c: 32 bf ff ed bne,a 2007a00 <_Objects_Shrink_information+0x58> 2007a50: c2 04 20 08 ld [ %l0 + 8 ], %g1 2007a54: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 2007a58: 11 00 80 5e sethi %hi(0x2017800), %o0 2007a5c: d2 00 40 12 ld [ %g1 + %l2 ], %o1 2007a60: 7f ff fc b7 call 2006d3c <_Heap_Free> 2007a64: 90 12 23 fc or %o0, 0x3fc, %o0 */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 2007a68: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 2007a6c: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 2007a70: c0 20 40 12 clr [ %g1 + %l2 ] * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; 2007a74: c8 06 20 3c ld [ %i0 + 0x3c ], %g4 information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2007a78: c2 16 20 34 lduh [ %i0 + 0x34 ], %g1 2007a7c: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 2007a80: c0 20 c0 12 clr [ %g3 + %l2 ] information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2007a84: 82 20 40 02 sub %g1, %g2, %g1 * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; 2007a88: c0 21 00 12 clr [ %g4 + %l2 ] information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2007a8c: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 2007a90: 81 c7 e0 08 ret 2007a94: 81 e8 00 00 restore return; } index_base += information->allocation_size; 2007a98: 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++ ) { 2007a9c: a4 10 00 02 mov %g2, %l2 2007aa0: 80 a0 c0 08 cmp %g3, %o0 2007aa4: 32 bf ff ce bne,a 20079dc <_Objects_Shrink_information+0x34> 2007aa8: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 2007aac: 81 c7 e0 08 ret 2007ab0: 81 e8 00 00 restore 02007ae8 <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 2007ae8: 9d e3 bf 98 save %sp, -104, %sp void *p; _RTEMS_Lock_allocator(); 2007aec: 7f ff e8 95 call 2001d40 2007af0: 01 00 00 00 nop 2007af4: a2 10 00 08 mov %o0, %l1 2007af8: 03 00 80 5e sethi %hi(0x2017800), %g1 2007afc: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> 2007b00: 80 a0 60 00 cmp %g1, 0 2007b04: 02 80 00 0b be 2007b30 <_Protected_heap_Allocate+0x48> 2007b08: 03 00 80 5f sethi %hi(0x2017c00), %g1 2007b0c: 03 00 80 5f sethi %hi(0x2017c00), %g1 2007b10: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 2017d90 <_System_state_Current> 2007b14: 80 a0 60 01 cmp %g1, 1 2007b18: 08 80 00 05 bleu 2007b2c <_Protected_heap_Allocate+0x44> 2007b1c: 90 10 20 00 clr %o0 2007b20: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007b24: 7f ff fd 8a call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 2007b28: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2007b2c: 03 00 80 5f sethi %hi(0x2017c00), %g1 2007b30: e0 00 60 88 ld [ %g1 + 0x88 ], %l0 ! 2017c88 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2007b34: 03 00 80 5f sethi %hi(0x2017c00), %g1 2007b38: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2017c90 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2007b3c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2007b40: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2007b44: 80 a0 60 00 cmp %g1, 0 2007b48: 22 80 00 33 be,a 2007c14 <_Protected_heap_Allocate+0x12c> 2007b4c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2007b50: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007b54: 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; 2007b58: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007b5c: 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; 2007b60: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2007b64: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2007b68: 80 a0 e0 02 cmp %g3, 2 2007b6c: 02 80 00 05 be 2007b80 <_Protected_heap_Allocate+0x98> 2007b70: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 2007b74: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2007b78: 32 80 00 06 bne,a 2007b90 <_Protected_heap_Allocate+0xa8> <== NOT EXECUTED 2007b7c: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2007b80: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 2007b84: 82 00 60 01 inc %g1 2007b88: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2007b8c: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 2007b90: 80 a0 60 03 cmp %g1, 3 2007b94: 22 80 00 03 be,a 2007ba0 <_Protected_heap_Allocate+0xb8> 2007b98: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2007b9c: 30 80 00 2c b,a 2007c4c <_Protected_heap_Allocate+0x164> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2007ba0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2007ba4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2007ba8: 12 80 00 03 bne 2007bb4 <_Protected_heap_Allocate+0xcc> <== NOT EXECUTED 2007bac: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2007bb0: 30 80 00 27 b,a 2007c4c <_Protected_heap_Allocate+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2007bb4: 08 80 00 10 bleu 2007bf4 <_Protected_heap_Allocate+0x10c> <== NOT EXECUTED 2007bb8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007bbc: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 2007bc0: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007bc4: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007bc8: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2007bcc: 7f ff e8 61 call 2001d50 <== NOT EXECUTED 2007bd0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2007bd4: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2007bd8: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2007bdc: 40 00 02 95 call 2008630 <_Thread_Change_priority> <== NOT EXECUTED 2007be0: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2007be4: 7f ff ff b4 call 2007ab4 <_Thread_Enable_dispatch> <== NOT EXECUTED 2007be8: 01 00 00 00 nop <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 2007bec: 10 80 00 32 b 2007cb4 <_Protected_heap_Allocate+0x1cc> <== NOT EXECUTED 2007bf0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2007bf4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2007bf8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2007bfc: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 2007c00: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2007c04: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2007c08: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2007c0c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2007c10: 30 80 00 0f b,a 2007c4c <_Protected_heap_Allocate+0x164> <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2007c14: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2007c18: 32 80 00 13 bne,a 2007c64 <_Protected_heap_Allocate+0x17c> <== NOT EXECUTED 2007c1c: 21 00 80 5f sethi %hi(0x2017c00), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2007c20: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2017c50 <_Workspace_Area+0x54> <== NOT EXECUTED 2007c24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007c28: 22 80 00 07 be,a 2007c44 <_Protected_heap_Allocate+0x15c> <== NOT EXECUTED 2007c2c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2007c30: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2007c34: 32 80 00 0c bne,a 2007c64 <_Protected_heap_Allocate+0x17c> <== NOT EXECUTED 2007c38: 21 00 80 5f sethi %hi(0x2017c00), %l0 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2007c3c: 10 80 00 08 b 2007c5c <_Protected_heap_Allocate+0x174> <== NOT EXECUTED 2007c40: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2007c44: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007c48: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2007c4c: 7f ff e8 41 call 2001d50 2007c50: 90 10 00 11 mov %l1, %o0 2007c54: 10 80 00 18 b 2007cb4 <_Protected_heap_Allocate+0x1cc> 2007c58: 90 10 00 18 mov %i0, %o0 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2007c5c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2007c60: 30 bf ff fb b,a 2007c4c <_Protected_heap_Allocate+0x164> <== NOT EXECUTED size_t size ) { void *p; _RTEMS_Lock_allocator(); 2007c64: c6 04 20 88 ld [ %l0 + 0x88 ], %g3 <== NOT EXECUTED 2007c68: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2007c6c: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2007c70: c8 00 60 90 ld [ %g1 + 0x90 ], %g4 <== NOT EXECUTED 2007c74: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 2007c78: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007c7c: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 2007c80: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007c84: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 2007c88: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2007c8c: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2007c90: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2007c94: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2007c98: 7f ff e8 2e call 2001d50 <== NOT EXECUTED 2007c9c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2007ca0: d0 04 20 88 ld [ %l0 + 0x88 ], %o0 <== NOT EXECUTED 2007ca4: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007ca8: 7f ff fb 0f call 20068e4 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2007cac: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 2007cb0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2007cb4: 7f ff fb fb call 2006ca0 <_Heap_Allocate> 2007cb8: 92 10 00 19 mov %i1, %o1 2007cbc: 05 00 80 5e sethi %hi(0x2017800), %g2 2007cc0: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> 2007cc4: b0 10 00 08 mov %o0, %i0 2007cc8: 82 00 60 01 inc %g1 2007ccc: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] _RTEMS_Unlock_allocator(); 2007cd0: 03 00 80 5f sethi %hi(0x2017c00), %g1 2007cd4: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2017c88 <_RTEMS_Allocator_Mutex> 2007cd8: 94 10 20 00 clr %o2 2007cdc: d2 02 20 08 ld [ %o0 + 8 ], %o1 2007ce0: 7f ff fb 23 call 200696c <_CORE_mutex_Surrender> 2007ce4: 90 02 20 10 add %o0, 0x10, %o0 2007ce8: 7f ff ff 73 call 2007ab4 <_Thread_Enable_dispatch> 2007cec: 01 00 00 00 nop return p; } 2007cf0: 81 c7 e0 08 ret 2007cf4: 81 e8 00 00 restore 02007d2c <_Protected_heap_Extend>: boolean _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 2007d2c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 2007d30: 7f ff e8 04 call 2001d40 <== NOT EXECUTED 2007d34: 01 00 00 00 nop <== NOT EXECUTED 2007d38: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 2007d3c: 03 00 80 5e sethi %hi(0x2017800), %g1 <== NOT EXECUTED 2007d40: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007d44: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007d48: 02 80 00 0b be 2007d74 <_Protected_heap_Extend+0x48> <== NOT EXECUTED 2007d4c: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2007d50: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2007d54: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 2017d90 <_System_state_Current> <== NOT EXECUTED 2007d58: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2007d5c: 08 80 00 05 bleu 2007d70 <_Protected_heap_Extend+0x44> <== NOT EXECUTED 2007d60: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007d64: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007d68: 7f ff fc f9 call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 2007d6c: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2007d70: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2007d74: e0 00 60 88 ld [ %g1 + 0x88 ], %l0 ! 2017c88 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2007d78: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2007d7c: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2017c90 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2007d80: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2007d84: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2007d88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007d8c: 22 80 00 33 be,a 2007e58 <_Protected_heap_Extend+0x12c> <== NOT EXECUTED 2007d90: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2007d94: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007d98: 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; 2007d9c: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007da0: 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; 2007da4: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2007da8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2007dac: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2007db0: 02 80 00 05 be 2007dc4 <_Protected_heap_Extend+0x98> <== NOT EXECUTED 2007db4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 2007db8: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2007dbc: 32 80 00 06 bne,a 2007dd4 <_Protected_heap_Extend+0xa8> <== NOT EXECUTED 2007dc0: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2007dc4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2007dc8: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007dcc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2007dd0: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 2007dd4: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2007dd8: 22 80 00 03 be,a 2007de4 <_Protected_heap_Extend+0xb8> <== NOT EXECUTED 2007ddc: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2007de0: 30 80 00 2c b,a 2007e90 <_Protected_heap_Extend+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2007de4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2007de8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2007dec: 12 80 00 03 bne 2007df8 <_Protected_heap_Extend+0xcc> <== NOT EXECUTED 2007df0: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2007df4: 30 80 00 27 b,a 2007e90 <_Protected_heap_Extend+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2007df8: 08 80 00 10 bleu 2007e38 <_Protected_heap_Extend+0x10c> <== NOT EXECUTED 2007dfc: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007e00: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 2007e04: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007e08: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007e0c: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2007e10: 7f ff e7 d0 call 2001d50 <== NOT EXECUTED 2007e14: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2007e18: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2007e1c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2007e20: 40 00 02 04 call 2008630 <_Thread_Change_priority> <== NOT EXECUTED 2007e24: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2007e28: 7f ff ff b4 call 2007cf8 <_Thread_Enable_dispatch> <== NOT EXECUTED 2007e2c: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 2007e30: 10 80 00 32 b 2007ef8 <_Protected_heap_Extend+0x1cc> <== NOT EXECUTED 2007e34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2007e38: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2007e3c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2007e40: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 2007e44: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2007e48: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2007e4c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2007e50: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2007e54: 30 80 00 0f b,a 2007e90 <_Protected_heap_Extend+0x164> <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2007e58: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2007e5c: 32 80 00 13 bne,a 2007ea8 <_Protected_heap_Extend+0x17c> <== NOT EXECUTED 2007e60: 21 00 80 5f sethi %hi(0x2017c00), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2007e64: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2017c50 <_Workspace_Area+0x54> <== NOT EXECUTED 2007e68: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007e6c: 22 80 00 07 be,a 2007e88 <_Protected_heap_Extend+0x15c> <== NOT EXECUTED 2007e70: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2007e74: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2007e78: 12 80 00 0c bne 2007ea8 <_Protected_heap_Extend+0x17c> <== NOT EXECUTED 2007e7c: 21 00 80 5f sethi %hi(0x2017c00), %l0 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2007e80: 10 80 00 08 b 2007ea0 <_Protected_heap_Extend+0x174> <== NOT EXECUTED 2007e84: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2007e88: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007e8c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2007e90: 7f ff e7 b0 call 2001d50 <== NOT EXECUTED 2007e94: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2007e98: 10 80 00 18 b 2007ef8 <_Protected_heap_Extend+0x1cc> <== NOT EXECUTED 2007e9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2007ea0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2007ea4: 30 bf ff fb b,a 2007e90 <_Protected_heap_Extend+0x164> <== NOT EXECUTED ) { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 2007ea8: c6 04 20 88 ld [ %l0 + 0x88 ], %g3 <== NOT EXECUTED 2007eac: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2007eb0: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2007eb4: c8 00 60 90 ld [ %g1 + 0x90 ], %g4 <== NOT EXECUTED 2007eb8: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 2007ebc: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007ec0: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 2007ec4: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007ec8: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 2007ecc: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2007ed0: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 2007ed4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2007ed8: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2007edc: 7f ff e7 9d call 2001d50 <== NOT EXECUTED 2007ee0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2007ee4: d0 04 20 88 ld [ %l0 + 0x88 ], %o0 <== NOT EXECUTED 2007ee8: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007eec: 7f ff fa 7e call 20068e4 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2007ef0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 2007ef4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2007ef8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2007efc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2007f00: 40 00 11 69 call 200c4a4 <_Heap_Extend> <== NOT EXECUTED 2007f04: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 2007f08: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 2007f0c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007f10: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 2007f14: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007f18: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 2007f1c: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2007f20: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2017c88 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 2007f24: 94 10 20 00 clr %o2 <== NOT EXECUTED 2007f28: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2007f2c: 7f ff fa 90 call 200696c <_CORE_mutex_Surrender> <== NOT EXECUTED 2007f30: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2007f34: 7f ff ff 71 call 2007cf8 <_Thread_Enable_dispatch> <== NOT EXECUTED 2007f38: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 2007f3c: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 2007f40: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 2007f44: 81 c7 e0 08 ret <== NOT EXECUTED 2007f48: 81 e8 00 00 restore <== NOT EXECUTED 02007f80 <_Protected_heap_Free>: boolean _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 2007f80: 9d e3 bf 98 save %sp, -104, %sp boolean status; _RTEMS_Lock_allocator(); 2007f84: 7f ff e7 6f call 2001d40 2007f88: 01 00 00 00 nop 2007f8c: a2 10 00 08 mov %o0, %l1 2007f90: 03 00 80 5e sethi %hi(0x2017800), %g1 2007f94: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> 2007f98: 80 a0 60 00 cmp %g1, 0 2007f9c: 02 80 00 0b be 2007fc8 <_Protected_heap_Free+0x48> 2007fa0: 03 00 80 5f sethi %hi(0x2017c00), %g1 2007fa4: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2007fa8: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 2017d90 <_System_state_Current> <== NOT EXECUTED 2007fac: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2007fb0: 08 80 00 05 bleu 2007fc4 <_Protected_heap_Free+0x44> <== NOT EXECUTED 2007fb4: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007fb8: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007fbc: 7f ff fc 64 call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 2007fc0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2007fc4: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2007fc8: e0 00 60 88 ld [ %g1 + 0x88 ], %l0 ! 2017c88 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2007fcc: 03 00 80 5f sethi %hi(0x2017c00), %g1 2007fd0: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2017c90 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2007fd4: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2007fd8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2007fdc: 80 a0 60 00 cmp %g1, 0 2007fe0: 22 80 00 33 be,a 20080ac <_Protected_heap_Free+0x12c> 2007fe4: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2007fe8: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007fec: 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; 2007ff0: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007ff4: 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; 2007ff8: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2007ffc: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008000: 80 a0 e0 02 cmp %g3, 2 2008004: 02 80 00 05 be 2008018 <_Protected_heap_Free+0x98> 2008008: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 200800c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008010: 32 80 00 06 bne,a 2008028 <_Protected_heap_Free+0xa8> <== NOT EXECUTED 2008014: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008018: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 200801c: 82 00 60 01 inc %g1 2008020: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008024: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 2008028: 80 a0 60 03 cmp %g1, 3 200802c: 22 80 00 03 be,a 2008038 <_Protected_heap_Free+0xb8> 2008030: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2008034: 30 80 00 2c b,a 20080e4 <_Protected_heap_Free+0x164> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2008038: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200803c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008040: 12 80 00 03 bne 200804c <_Protected_heap_Free+0xcc> <== NOT EXECUTED 2008044: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2008048: 30 80 00 27 b,a 20080e4 <_Protected_heap_Free+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 200804c: 08 80 00 10 bleu 200808c <_Protected_heap_Free+0x10c> <== NOT EXECUTED 2008050: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008054: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 2008058: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200805c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008060: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2008064: 7f ff e7 3b call 2001d50 <== NOT EXECUTED 2008068: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 200806c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2008070: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008074: 40 00 01 6f call 2008630 <_Thread_Change_priority> <== NOT EXECUTED 2008078: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 200807c: 7f ff ff b4 call 2007f4c <_Thread_Enable_dispatch> <== NOT EXECUTED 2008080: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 2008084: 10 80 00 32 b 200814c <_Protected_heap_Free+0x1cc> <== NOT EXECUTED 2008088: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200808c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2008090: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2008094: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 2008098: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 200809c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20080a0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20080a4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20080a8: 30 80 00 0f b,a 20080e4 <_Protected_heap_Free+0x164> <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 20080ac: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20080b0: 32 80 00 13 bne,a 20080fc <_Protected_heap_Free+0x17c> <== NOT EXECUTED 20080b4: 21 00 80 5f sethi %hi(0x2017c00), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20080b8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2017c50 <_Workspace_Area+0x54> <== NOT EXECUTED 20080bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20080c0: 22 80 00 07 be,a 20080dc <_Protected_heap_Free+0x15c> <== NOT EXECUTED 20080c4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 20080c8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20080cc: 32 80 00 0c bne,a 20080fc <_Protected_heap_Free+0x17c> <== NOT EXECUTED 20080d0: 21 00 80 5f sethi %hi(0x2017c00), %l0 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 20080d4: 10 80 00 08 b 20080f4 <_Protected_heap_Free+0x174> <== NOT EXECUTED 20080d8: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 20080dc: 82 00 60 01 inc %g1 <== NOT EXECUTED 20080e0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 20080e4: 7f ff e7 1b call 2001d50 20080e8: 90 10 00 11 mov %l1, %o0 20080ec: 10 80 00 18 b 200814c <_Protected_heap_Free+0x1cc> 20080f0: 90 10 00 18 mov %i0, %o0 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 20080f4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20080f8: 30 bf ff fb b,a 20080e4 <_Protected_heap_Free+0x164> <== NOT EXECUTED void *start_address ) { boolean status; _RTEMS_Lock_allocator(); 20080fc: c6 04 20 88 ld [ %l0 + 0x88 ], %g3 <== NOT EXECUTED 2008100: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2008104: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2008108: c8 00 60 90 ld [ %g1 + 0x90 ], %g4 <== NOT EXECUTED 200810c: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 2008110: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008114: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 2008118: 82 00 60 01 inc %g1 <== NOT EXECUTED 200811c: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 2008120: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2008124: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 2008128: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200812c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2008130: 7f ff e7 08 call 2001d50 <== NOT EXECUTED 2008134: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2008138: d0 04 20 88 ld [ %l0 + 0x88 ], %o0 <== NOT EXECUTED 200813c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008140: 7f ff f9 e9 call 20068e4 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2008144: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 2008148: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200814c: 7f ff fa fc call 2006d3c <_Heap_Free> 2008150: 92 10 00 19 mov %i1, %o1 2008154: 05 00 80 5e sethi %hi(0x2017800), %g2 2008158: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> 200815c: b0 10 00 08 mov %o0, %i0 2008160: 82 00 60 01 inc %g1 2008164: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] _RTEMS_Unlock_allocator(); 2008168: 03 00 80 5f sethi %hi(0x2017c00), %g1 200816c: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2017c88 <_RTEMS_Allocator_Mutex> 2008170: 94 10 20 00 clr %o2 2008174: d2 02 20 08 ld [ %o0 + 8 ], %o1 2008178: 7f ff f9 fd call 200696c <_CORE_mutex_Surrender> 200817c: 90 02 20 10 add %o0, 0x10, %o0 2008180: 7f ff ff 73 call 2007f4c <_Thread_Enable_dispatch> 2008184: 01 00 00 00 nop return status; } 2008188: 81 c7 e0 08 ret 200818c: 81 e8 00 00 restore 020081c4 <_Protected_heap_Get_block_size>: boolean _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 20081c4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED boolean status; _RTEMS_Lock_allocator(); 20081c8: 7f ff e6 de call 2001d40 <== NOT EXECUTED 20081cc: 01 00 00 00 nop <== NOT EXECUTED 20081d0: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 20081d4: 03 00 80 5e sethi %hi(0x2017800), %g1 <== NOT EXECUTED 20081d8: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20081dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20081e0: 02 80 00 0b be 200820c <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 20081e4: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 20081e8: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 20081ec: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 2017d90 <_System_state_Current> <== NOT EXECUTED 20081f0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20081f4: 08 80 00 05 bleu 2008208 <_Protected_heap_Get_block_size+0x44> <== NOT EXECUTED 20081f8: 90 10 20 00 clr %o0 <== NOT EXECUTED 20081fc: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008200: 7f ff fb d3 call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 2008204: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2008208: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 200820c: e0 00 60 88 ld [ %g1 + 0x88 ], %l0 ! 2017c88 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2008210: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2008214: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2017c90 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2008218: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200821c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2008220: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008224: 22 80 00 33 be,a 20082f0 <_Protected_heap_Get_block_size+0x12c> <== NOT EXECUTED 2008228: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200822c: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008230: 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; 2008234: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008238: 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; 200823c: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2008240: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008244: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2008248: 02 80 00 05 be 200825c <_Protected_heap_Get_block_size+0x98> <== NOT EXECUTED 200824c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 2008250: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008254: 32 80 00 06 bne,a 200826c <_Protected_heap_Get_block_size+0xa8> <== NOT EXECUTED 2008258: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200825c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008260: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008264: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008268: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 200826c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2008270: 22 80 00 03 be,a 200827c <_Protected_heap_Get_block_size+0xb8> <== NOT EXECUTED 2008274: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2008278: 30 80 00 2c b,a 2008328 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 200827c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2008280: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008284: 12 80 00 03 bne 2008290 <_Protected_heap_Get_block_size+0xcc> <== NOT EXECUTED 2008288: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200828c: 30 80 00 27 b,a 2008328 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2008290: 08 80 00 10 bleu 20082d0 <_Protected_heap_Get_block_size+0x10c> <== NOT EXECUTED 2008294: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008298: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 200829c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20082a0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20082a4: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20082a8: 7f ff e6 aa call 2001d50 <== NOT EXECUTED 20082ac: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 20082b0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 20082b4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 20082b8: 40 00 00 de call 2008630 <_Thread_Change_priority> <== NOT EXECUTED 20082bc: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 20082c0: 7f ff ff b4 call 2008190 <_Thread_Enable_dispatch> <== NOT EXECUTED 20082c4: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 20082c8: 10 80 00 32 b 2008390 <_Protected_heap_Get_block_size+0x1cc> <== NOT EXECUTED 20082cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20082d0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20082d4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20082d8: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 20082dc: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 20082e0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20082e4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20082e8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20082ec: 30 80 00 0f b,a 2008328 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 20082f0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20082f4: 32 80 00 13 bne,a 2008340 <_Protected_heap_Get_block_size+0x17c> <== NOT EXECUTED 20082f8: 21 00 80 5f sethi %hi(0x2017c00), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20082fc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2017c50 <_Workspace_Area+0x54> <== NOT EXECUTED 2008300: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008304: 22 80 00 07 be,a 2008320 <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 2008308: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200830c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008310: 32 80 00 0c bne,a 2008340 <_Protected_heap_Get_block_size+0x17c> <== NOT EXECUTED 2008314: 21 00 80 5f sethi %hi(0x2017c00), %l0 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2008318: 10 80 00 08 b 2008338 <_Protected_heap_Get_block_size+0x174> <== NOT EXECUTED 200831c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2008320: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008324: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2008328: 7f ff e6 8a call 2001d50 <== NOT EXECUTED 200832c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2008330: 10 80 00 18 b 2008390 <_Protected_heap_Get_block_size+0x1cc> <== NOT EXECUTED 2008334: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2008338: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200833c: 30 bf ff fb b,a 2008328 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED size_t *size ) { boolean status; _RTEMS_Lock_allocator(); 2008340: c6 04 20 88 ld [ %l0 + 0x88 ], %g3 <== NOT EXECUTED 2008344: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2008348: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 200834c: c8 00 60 90 ld [ %g1 + 0x90 ], %g4 <== NOT EXECUTED 2008350: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 2008354: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008358: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 200835c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008360: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 2008364: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2008368: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200836c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2008370: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2008374: 7f ff e6 77 call 2001d50 <== NOT EXECUTED 2008378: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200837c: d0 04 20 88 ld [ %l0 + 0x88 ], %o0 <== NOT EXECUTED 2008380: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008384: 7f ff f9 58 call 20068e4 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2008388: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 200838c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2008390: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2008394: 40 00 10 fe call 200c78c <_Heap_Size_of_user_area> <== NOT EXECUTED 2008398: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 200839c: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 20083a0: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20083a4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 20083a8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20083ac: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 20083b0: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 20083b4: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2017c88 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 20083b8: 94 10 20 00 clr %o2 <== NOT EXECUTED 20083bc: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 20083c0: 7f ff f9 6b call 200696c <_CORE_mutex_Surrender> <== NOT EXECUTED 20083c4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 20083c8: 7f ff ff 72 call 2008190 <_Thread_Enable_dispatch> <== NOT EXECUTED 20083cc: 01 00 00 00 nop <== NOT EXECUTED return status; } 20083d0: 81 c7 e0 08 ret <== NOT EXECUTED 20083d4: 81 e8 00 00 restore <== NOT EXECUTED 0200a954 <_Protected_heap_Get_free_information>: void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 200a954: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 200a958: 7f ff e0 84 call 2002b68 <== NOT EXECUTED 200a95c: 01 00 00 00 nop <== NOT EXECUTED 200a960: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 200a964: 03 00 80 e0 sethi %hi(0x2038000), %g1 <== NOT EXECUTED 200a968: c2 00 63 30 ld [ %g1 + 0x330 ], %g1 ! 2038330 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200a96c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200a970: 02 80 00 0b be 200a99c <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 200a974: 03 00 80 e1 sethi %hi(0x2038400), %g1 <== NOT EXECUTED 200a978: 03 00 80 e1 sethi %hi(0x2038400), %g1 <== NOT EXECUTED 200a97c: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 ! 2038510 <_System_state_Current> <== NOT EXECUTED 200a980: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200a984: 08 80 00 05 bleu 200a998 <_Protected_heap_Get_free_information+0x44> <== NOT EXECUTED 200a988: 90 10 20 00 clr %o0 <== NOT EXECUTED 200a98c: 92 10 20 00 clr %o1 <== NOT EXECUTED 200a990: 7f ff fb 80 call 2009790 <_Internal_error_Occurred> <== NOT EXECUTED 200a994: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200a998: 03 00 80 e1 sethi %hi(0x2038400), %g1 <== NOT EXECUTED 200a99c: e0 00 60 08 ld [ %g1 + 8 ], %l0 ! 2038408 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200a9a0: 03 00 80 e1 sethi %hi(0x2038400), %g1 <== NOT EXECUTED 200a9a4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 2038410 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200a9a8: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200a9ac: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 200a9b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200a9b4: 22 80 00 33 be,a 200aa80 <_Protected_heap_Get_free_information+0x12c> <== NOT EXECUTED 200a9b8: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200a9bc: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200a9c0: 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; 200a9c4: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200a9c8: 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; 200a9cc: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 200a9d0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200a9d4: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 200a9d8: 02 80 00 05 be 200a9ec <_Protected_heap_Get_free_information+0x98> <== NOT EXECUTED 200a9dc: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 200a9e0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200a9e4: 32 80 00 06 bne,a 200a9fc <_Protected_heap_Get_free_information+0xa8> <== NOT EXECUTED 200a9e8: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200a9ec: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200a9f0: 82 00 60 01 inc %g1 <== NOT EXECUTED 200a9f4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200a9f8: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 200a9fc: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 200aa00: 22 80 00 03 be,a 200aa0c <_Protected_heap_Get_free_information+0xb8> <== NOT EXECUTED 200aa04: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 200aa08: 30 80 00 2c b,a 200aab8 <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 200aa0c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200aa10: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200aa14: 12 80 00 03 bne 200aa20 <_Protected_heap_Get_free_information+0xcc> <== NOT EXECUTED 200aa18: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200aa1c: 30 80 00 27 b,a 200aab8 <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 200aa20: 08 80 00 10 bleu 200aa60 <_Protected_heap_Get_free_information+0x10c> <== NOT EXECUTED 200aa24: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200aa28: 05 00 80 e0 sethi %hi(0x2038000), %g2 <== NOT EXECUTED 200aa2c: c2 00 a3 30 ld [ %g2 + 0x330 ], %g1 ! 2038330 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200aa30: 82 00 60 01 inc %g1 <== NOT EXECUTED 200aa34: c2 20 a3 30 st %g1, [ %g2 + 0x330 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200aa38: 7f ff e0 50 call 2002b78 <== NOT EXECUTED 200aa3c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 200aa40: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200aa44: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200aa48: 40 00 00 db call 200adb4 <_Thread_Change_priority> <== NOT EXECUTED 200aa4c: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 200aa50: 7f ff ff b4 call 200a920 <_Thread_Enable_dispatch> <== NOT EXECUTED 200aa54: 01 00 00 00 nop <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 200aa58: 10 80 00 32 b 200ab20 <_Protected_heap_Get_free_information+0x1cc> <== NOT EXECUTED 200aa5c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200aa60: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200aa64: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200aa68: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 200aa6c: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 200aa70: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200aa74: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200aa78: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200aa7c: 30 80 00 0f b,a 200aab8 <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 200aa80: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200aa84: 32 80 00 13 bne,a 200aad0 <_Protected_heap_Get_free_information+0x17c> <== NOT EXECUTED 200aa88: 21 00 80 e1 sethi %hi(0x2038400), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200aa8c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2038450 <_API_Mutex_Information+0x10> <== NOT EXECUTED 200aa90: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200aa94: 22 80 00 07 be,a 200aab0 <_Protected_heap_Get_free_information+0x15c> <== NOT EXECUTED 200aa98: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200aa9c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200aaa0: 32 80 00 0c bne,a 200aad0 <_Protected_heap_Get_free_information+0x17c> <== NOT EXECUTED 200aaa4: 21 00 80 e1 sethi %hi(0x2038400), %l0 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200aaa8: 10 80 00 08 b 200aac8 <_Protected_heap_Get_free_information+0x174> <== NOT EXECUTED 200aaac: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 200aab0: 82 00 60 01 inc %g1 <== NOT EXECUTED 200aab4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200aab8: 7f ff e0 30 call 2002b78 <== NOT EXECUTED 200aabc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200aac0: 10 80 00 18 b 200ab20 <_Protected_heap_Get_free_information+0x1cc> <== NOT EXECUTED 200aac4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200aac8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200aacc: 30 bf ff fb b,a 200aab8 <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); 200aad0: c6 04 20 08 ld [ %l0 + 8 ], %g3 <== NOT EXECUTED 200aad4: 03 00 80 e1 sethi %hi(0x2038400), %g1 <== NOT EXECUTED 200aad8: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 200aadc: c8 00 60 10 ld [ %g1 + 0x10 ], %g4 <== NOT EXECUTED 200aae0: 05 00 80 e0 sethi %hi(0x2038000), %g2 <== NOT EXECUTED 200aae4: c2 00 a3 30 ld [ %g2 + 0x330 ], %g1 ! 2038330 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200aae8: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 200aaec: 82 00 60 01 inc %g1 <== NOT EXECUTED 200aaf0: c2 20 a3 30 st %g1, [ %g2 + 0x330 ] <== NOT EXECUTED 200aaf4: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 200aaf8: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200aafc: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200ab00: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 200ab04: 7f ff e0 1d call 2002b78 <== NOT EXECUTED 200ab08: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200ab0c: d0 04 20 08 ld [ %l0 + 8 ], %o0 <== NOT EXECUTED 200ab10: 92 10 20 00 clr %o1 <== NOT EXECUTED 200ab14: 7f ff f9 05 call 2008f28 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200ab18: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 200ab1c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200ab20: 40 00 33 b0 call 20179e0 <_Heap_Get_free_information> <== NOT EXECUTED 200ab24: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200ab28: 05 00 80 e0 sethi %hi(0x2038000), %g2 <== NOT EXECUTED 200ab2c: c2 00 a3 30 ld [ %g2 + 0x330 ], %g1 ! 2038330 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200ab30: 82 00 60 01 inc %g1 <== NOT EXECUTED 200ab34: c2 20 a3 30 st %g1, [ %g2 + 0x330 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 200ab38: 03 00 80 e1 sethi %hi(0x2038400), %g1 <== NOT EXECUTED 200ab3c: d0 00 60 08 ld [ %g1 + 8 ], %o0 ! 2038408 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 200ab40: 94 10 20 00 clr %o2 <== NOT EXECUTED 200ab44: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 200ab48: 7f ff f9 1a call 2008fb0 <_CORE_mutex_Surrender> <== NOT EXECUTED 200ab4c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200ab50: 7f ff ff 74 call 200a920 <_Thread_Enable_dispatch> <== NOT EXECUTED 200ab54: 81 e8 00 00 restore <== NOT EXECUTED 200ab58: 01 00 00 00 nop 0200840c <_Protected_heap_Resize_block>: boolean _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 200840c: 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(); 2008410: 7f ff e6 4c call 2001d40 <== NOT EXECUTED 2008414: 01 00 00 00 nop <== NOT EXECUTED 2008418: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 200841c: 03 00 80 5e sethi %hi(0x2017800), %g1 <== NOT EXECUTED 2008420: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008424: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008428: 02 80 00 0b be 2008454 <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 200842c: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2008430: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2008434: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 2017d90 <_System_state_Current> <== NOT EXECUTED 2008438: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200843c: 08 80 00 05 bleu 2008450 <_Protected_heap_Resize_block+0x44> <== NOT EXECUTED 2008440: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008444: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008448: 7f ff fb 41 call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 200844c: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2008450: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2008454: e0 00 60 88 ld [ %g1 + 0x88 ], %l0 ! 2017c88 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2008458: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 200845c: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2017c90 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2008460: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2008464: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2008468: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200846c: 22 80 00 33 be,a 2008538 <_Protected_heap_Resize_block+0x12c> <== NOT EXECUTED 2008470: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2008474: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008478: 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; 200847c: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008480: 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; 2008484: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2008488: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200848c: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2008490: 02 80 00 05 be 20084a4 <_Protected_heap_Resize_block+0x98> <== NOT EXECUTED 2008494: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 2008498: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200849c: 32 80 00 06 bne,a 20084b4 <_Protected_heap_Resize_block+0xa8> <== NOT EXECUTED 20084a0: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20084a4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20084a8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20084ac: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20084b0: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 20084b4: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 20084b8: 22 80 00 03 be,a 20084c4 <_Protected_heap_Resize_block+0xb8> <== NOT EXECUTED 20084bc: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 20084c0: 30 80 00 2c b,a 2008570 <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 20084c4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 20084c8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 20084cc: 12 80 00 03 bne 20084d8 <_Protected_heap_Resize_block+0xcc> <== NOT EXECUTED 20084d0: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 20084d4: 30 80 00 27 b,a 2008570 <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 20084d8: 08 80 00 10 bleu 2008518 <_Protected_heap_Resize_block+0x10c> <== NOT EXECUTED 20084dc: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20084e0: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 20084e4: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20084e8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20084ec: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20084f0: 7f ff e6 18 call 2001d50 <== NOT EXECUTED 20084f4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 20084f8: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 20084fc: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008500: 40 00 00 4c call 2008630 <_Thread_Change_priority> <== NOT EXECUTED 2008504: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2008508: 7f ff ff b4 call 20083d8 <_Thread_Enable_dispatch> <== NOT EXECUTED 200850c: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Resize_block( 2008510: 10 80 00 32 b 20085d8 <_Protected_heap_Resize_block+0x1cc> <== NOT EXECUTED 2008514: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008518: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200851c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2008520: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 2008524: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2008528: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200852c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008530: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008534: 30 80 00 0f b,a 2008570 <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2008538: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200853c: 32 80 00 13 bne,a 2008588 <_Protected_heap_Resize_block+0x17c> <== NOT EXECUTED 2008540: 21 00 80 5f sethi %hi(0x2017c00), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2008544: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2017c50 <_Workspace_Area+0x54> <== NOT EXECUTED 2008548: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200854c: 22 80 00 07 be,a 2008568 <_Protected_heap_Resize_block+0x15c> <== NOT EXECUTED 2008550: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2008554: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008558: 12 80 00 0c bne 2008588 <_Protected_heap_Resize_block+0x17c> <== NOT EXECUTED 200855c: 21 00 80 5f sethi %hi(0x2017c00), %l0 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2008560: 10 80 00 08 b 2008580 <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 2008564: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2008568: 82 00 60 01 inc %g1 <== NOT EXECUTED 200856c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2008570: 7f ff e5 f8 call 2001d50 <== NOT EXECUTED 2008574: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2008578: 10 80 00 18 b 20085d8 <_Protected_heap_Resize_block+0x1cc> <== NOT EXECUTED 200857c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2008580: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2008584: 30 bf ff fb b,a 2008570 <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED { Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 2008588: c6 04 20 88 ld [ %l0 + 0x88 ], %g3 <== NOT EXECUTED 200858c: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2008590: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2008594: c8 00 60 90 ld [ %g1 + 0x90 ], %g4 <== NOT EXECUTED 2008598: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 200859c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20085a0: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 20085a4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20085a8: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 20085ac: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 20085b0: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 20085b4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20085b8: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 20085bc: 7f ff e5 e5 call 2001d50 <== NOT EXECUTED 20085c0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20085c4: d0 04 20 88 ld [ %l0 + 0x88 ], %o0 <== NOT EXECUTED 20085c8: 92 10 20 00 clr %o1 <== NOT EXECUTED 20085cc: 7f ff f8 c6 call 20068e4 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 20085d0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 20085d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20085d8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 20085dc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 20085e0: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 20085e4: 40 00 0f e1 call 200c568 <_Heap_Resize_block> <== NOT EXECUTED 20085e8: 98 07 bf f0 add %fp, -16, %o4 <== NOT EXECUTED 20085ec: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 20085f0: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20085f4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 20085f8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20085fc: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 2008600: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2008604: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2017c88 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 2008608: 94 10 20 00 clr %o2 <== NOT EXECUTED 200860c: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2008610: 7f ff f8 d7 call 200696c <_CORE_mutex_Surrender> <== NOT EXECUTED 2008614: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2008618: 7f ff ff 70 call 20083d8 <_Thread_Enable_dispatch> <== NOT EXECUTED 200861c: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 2008620: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 2008624: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 2008628: 81 c7 e0 08 ret <== NOT EXECUTED 200862c: 81 e8 00 00 restore <== NOT EXECUTED 0200c248 <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 200c248: 9d e3 bf 98 save %sp, -104, %sp /* * Free per task variable memory */ tvp = deleted->task_variables; 200c24c: e0 06 61 80 ld [ %i1 + 0x180 ], %l0 deleted->task_variables = NULL; while (tvp) { next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 200c250: 25 00 80 5f sethi %hi(0x2017c00), %l2 /* * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; 200c254: 10 80 00 18 b 200c2b4 <_RTEMS_tasks_Delete_extension+0x6c> 200c258: c0 26 61 80 clr [ %i1 + 0x180 ] 200c25c: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED while (tvp) { next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 200c260: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 200c264: 12 80 00 0c bne 200c294 <_RTEMS_tasks_Delete_extension+0x4c> <== NOT EXECUTED 200c268: e2 04 00 00 ld [ %l0 ], %l1 <== NOT EXECUTED if (tvp->dtor) 200c26c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200c270: 22 80 00 06 be,a 200c288 <_RTEMS_tasks_Delete_extension+0x40> <== NOT EXECUTED 200c274: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED (*tvp->dtor)(*tvp->ptr); 200c278: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 200c27c: 9f c0 80 00 call %g2 <== NOT EXECUTED 200c280: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 200c284: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED 200c288: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 200c28c: 10 80 00 07 b 200c2a8 <_RTEMS_tasks_Delete_extension+0x60> <== NOT EXECUTED 200c290: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED } else { if (tvp->dtor) 200c294: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200c298: 02 80 00 05 be 200c2ac <_RTEMS_tasks_Delete_extension+0x64> <== NOT EXECUTED 200c29c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 200c2a0: 9f c0 80 00 call %g2 <== NOT EXECUTED 200c2a4: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED } _Workspace_Free( tvp ); 200c2a8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 200c2ac: 7f ff ff e0 call 200c22c <_Workspace_Free> <== NOT EXECUTED 200c2b0: a0 10 00 11 mov %l1, %l0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 200c2b4: 80 a4 20 00 cmp %l0, 0 200c2b8: 12 bf ff e9 bne 200c25c <_RTEMS_tasks_Delete_extension+0x14> 200c2bc: c2 04 a0 90 ld [ %l2 + 0x90 ], %g1 /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 200c2c0: 7f ff ff db call 200c22c <_Workspace_Free> 200c2c4: d0 06 61 70 ld [ %i1 + 0x170 ], %o0 deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 200c2c8: c0 26 61 70 clr [ %i1 + 0x170 ] } 200c2cc: 81 c7 e0 08 ret 200c2d0: 81 e8 00 00 restore 02006068 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 2006068: 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; 200606c: 03 00 80 5f sethi %hi(0x2017c00), %g1 2006070: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 2017c74 <_Configuration_Table> 2006074: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 2006078: d0 00 60 28 ld [ %g1 + 0x28 ], %o0 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) 200607c: 80 a2 20 00 cmp %o0, 0 2006080: 02 80 00 25 be 2006114 <_RTEMS_tasks_Initialize_user_tasks_body+0xac> 2006084: e4 00 60 24 ld [ %g1 + 0x24 ], %l2 2006088: 80 a4 a0 00 cmp %l2, 0 200608c: 02 80 00 22 be 2006114 <_RTEMS_tasks_Initialize_user_tasks_body+0xac> 2006090: a0 10 00 08 mov %o0, %l0 return; 2006094: a2 10 20 00 clr %l1 for ( index=0 ; index < maximum ; index++ ) { return_value = rtems_task_create( 2006098: 10 80 00 1c b 2006108 <_RTEMS_tasks_Initialize_user_tasks_body+0xa0> 200609c: a6 07 bf f4 add %fp, -12, %l3 20060a0: d6 04 20 14 ld [ %l0 + 0x14 ], %o3 20060a4: d8 04 20 0c ld [ %l0 + 0xc ], %o4 20060a8: d2 04 20 08 ld [ %l0 + 8 ], %o1 20060ac: d4 04 20 04 ld [ %l0 + 4 ], %o2 20060b0: d0 04 00 00 ld [ %l0 ], %o0 20060b4: 7f ff ff 35 call 2005d88 20060b8: a2 04 60 01 inc %l1 user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 20060bc: 80 a2 20 00 cmp %o0, 0 20060c0: 22 80 00 07 be,a 20060dc <_RTEMS_tasks_Initialize_user_tasks_body+0x74> 20060c4: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 20060c8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 20060cc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 20060d0: 40 00 04 1f call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 20060d4: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED return_value = rtems_task_start( 20060d8: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED 20060dc: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 20060e0: d0 07 bf f4 ld [ %fp + -12 ], %o0 20060e4: 40 00 00 1b call 2006150 20060e8: a0 04 20 1c add %l0, 0x1c, %l0 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 20060ec: 80 a2 20 00 cmp %o0, 0 20060f0: 02 80 00 07 be 200610c <_RTEMS_tasks_Initialize_user_tasks_body+0xa4> 20060f4: 80 a4 40 12 cmp %l1, %l2 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 20060f8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 20060fc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2006100: 40 00 04 13 call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 2006104: 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++ ) { 2006108: 80 a4 40 12 cmp %l1, %l2 200610c: 12 bf ff e5 bne 20060a0 <_RTEMS_tasks_Initialize_user_tasks_body+0x38> 2006110: 9a 10 00 13 mov %l3, %o5 2006114: 81 c7 e0 08 ret 2006118: 81 e8 00 00 restore 02006c7c <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 2006c7c: 9d e3 bf 90 save %sp, -112, %sp 2006c80: 11 00 80 70 sethi %hi(0x201c000), %o0 2006c84: 92 10 00 18 mov %i0, %o1 2006c88: 90 12 21 04 or %o0, 0x104, %o0 2006c8c: 40 00 09 37 call 2009168 <_Objects_Get> 2006c90: 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 ) { 2006c94: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006c98: 80 a0 60 00 cmp %g1, 0 2006c9c: 12 80 00 20 bne 2006d1c <_Rate_monotonic_Timeout+0xa0> 2006ca0: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: /* impossible */ case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; 2006ca4: d0 02 20 50 ld [ %o0 + 0x50 ], %o0 if ( _States_Is_waiting_for_period( the_thread->current_state ) && 2006ca8: 03 00 00 10 sethi %hi(0x4000), %g1 2006cac: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 2006cb0: 80 88 80 01 btst %g2, %g1 2006cb4: 22 80 00 0c be,a 2006ce4 <_Rate_monotonic_Timeout+0x68> 2006cb8: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 2006cbc: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006cc0: c2 06 20 08 ld [ %i0 + 8 ], %g1 2006cc4: 80 a0 80 01 cmp %g2, %g1 2006cc8: 32 80 00 07 bne,a 2006ce4 <_Rate_monotonic_Timeout+0x68> 2006ccc: 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 ); 2006cd0: 13 04 00 ff sethi %hi(0x1003fc00), %o1 2006cd4: 40 00 0d 5f call 200a250 <_Thread_Clear_state> 2006cd8: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 2006cdc: 10 80 00 08 b 2006cfc <_Rate_monotonic_Timeout+0x80> 2006ce0: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 2006ce4: 80 a0 60 01 cmp %g1, 1 2006ce8: 12 80 00 08 bne 2006d08 <_Rate_monotonic_Timeout+0x8c> 2006cec: 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 ); 2006cf0: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 <== NOT EXECUTED the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 2006cf4: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 2006cf8: c2 26 20 38 st %g1, [ %i0 + 0x38 ] <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 2006cfc: 7f ff ff d8 call 2006c5c <_Watchdog_Insert_ticks> 2006d00: 90 06 20 10 add %i0, 0x10, %o0 2006d04: 30 80 00 02 b,a 2006d0c <_Rate_monotonic_Timeout+0x90> } else the_period->state = RATE_MONOTONIC_EXPIRED; 2006d08: 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; 2006d0c: 05 00 80 70 sethi %hi(0x201c000), %g2 2006d10: c2 00 a2 a0 ld [ %g2 + 0x2a0 ], %g1 ! 201c2a0 <_Thread_Dispatch_disable_level> 2006d14: 82 00 7f ff add %g1, -1, %g1 2006d18: c2 20 a2 a0 st %g1, [ %g2 + 0x2a0 ] 2006d1c: 81 c7 e0 08 ret 2006d20: 81 e8 00 00 restore 02008550 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 2008550: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008554: 03 00 80 90 sethi %hi(0x2024000), %g1 2008558: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 20240e0 <_Thread_Dispatch_disable_level> 200855c: 84 00 a0 01 inc %g2 2008560: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 2008564: 03 00 80 90 sethi %hi(0x2024000), %g1 2008568: d2 06 00 00 ld [ %i0 ], %o1 200856c: c2 00 61 9c ld [ %g1 + 0x19c ], %g1 2008570: 80 a2 40 01 cmp %o1, %g1 2008574: 36 80 00 05 bge,a 2008588 <_TOD_Set+0x38> 2008578: 92 22 40 01 sub %o1, %g1, %o1 _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, 200857c: 92 20 40 09 sub %g1, %o1, %o1 2008580: 10 80 00 03 b 200858c <_TOD_Set+0x3c> 2008584: 90 10 20 01 mov 1, %o0 _TOD_Seconds_since_epoch - time->tv_sec ); else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, 2008588: 90 10 20 00 clr %o0 200858c: 7f ff ff e9 call 2008530 <_Watchdog_Adjust_seconds> 2008590: 01 00 00 00 nop time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 2008594: c4 06 00 00 ld [ %i0 ], %g2 2008598: 03 00 80 90 sethi %hi(0x2024000), %g1 200859c: c4 20 61 9c st %g2, [ %g1 + 0x19c ] ! 202419c <_TOD_Now> 20085a0: c4 06 20 04 ld [ %i0 + 4 ], %g2 20085a4: 82 10 61 9c or %g1, 0x19c, %g1 20085a8: c4 20 60 04 st %g2, [ %g1 + 4 ] _TOD_Is_set = TRUE; 20085ac: 84 10 20 01 mov 1, %g2 20085b0: 03 00 80 90 sethi %hi(0x2024000), %g1 20085b4: c4 20 61 1c st %g2, [ %g1 + 0x11c ] ! 202411c <_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 ) 20085b8: 05 00 80 90 sethi %hi(0x2024000), %g2 20085bc: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1 ! 20240e0 <_Thread_Dispatch_disable_level> 20085c0: 82 00 7f ff add %g1, -1, %g1 20085c4: c2 20 a0 e0 st %g1, [ %g2 + 0xe0 ] 20085c8: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1 20085cc: 80 a0 60 00 cmp %g1, 0 20085d0: 12 80 00 04 bne 20085e0 <_TOD_Set+0x90> 20085d4: 01 00 00 00 nop _Thread_Dispatch(); 20085d8: 40 00 07 f2 call 200a5a0 <_Thread_Dispatch> <== NOT EXECUTED 20085dc: 81 e8 00 00 restore <== NOT EXECUTED 20085e0: 81 c7 e0 08 ret 20085e4: 81 e8 00 00 restore 020089b4 <_Thread_Create_idle>: */ const char *_Thread_Idle_name = "IDLE"; void _Thread_Create_idle( void ) { 20089b4: 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 ); 20089b8: 11 00 80 5f sethi %hi(0x2017c00), %o0 20089bc: 7f ff fa 11 call 2007200 <_Objects_Allocate> 20089c0: 90 12 21 40 or %o0, 0x140, %o0 ! 2017d40 <_Thread_Internal_information> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 20089c4: 03 00 80 5e sethi %hi(0x2017800), %g1 20089c8: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2017bd0 <_CPU_Table+0xc> * The entire workspace is zeroed during its initialization. Thus, all * fields not explicitly assigned were explicitly zeroed by * _Workspace_Initialization. */ _Thread_Idle = _Thread_Internal_allocate(); 20089cc: 03 00 80 5f sethi %hi(0x2017c00), %g1 20089d0: d0 20 61 98 st %o0, [ %g1 + 0x198 ] ! 2017d98 <_Thread_Idle> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 20089d4: 80 a0 a0 00 cmp %g2, 0 20089d8: 03 00 80 23 sethi %hi(0x2008c00), %g1 20089dc: 02 80 00 03 be 20089e8 <_Thread_Create_idle+0x34> 20089e0: b4 10 60 9c or %g1, 0x9c, %i2 ! 2008c9c <_Thread_Idle_body> idle = _CPU_Table.idle_task; 20089e4: b4 10 00 02 mov %g2, %i2 <== NOT EXECUTED idle_task_stack_size = _CPU_Table.idle_task_stack_size; 20089e8: 03 00 80 5e sethi %hi(0x2017800), %g1 20089ec: d6 00 63 d8 ld [ %g1 + 0x3d8 ], %o3 ! 2017bd8 <_CPU_Table+0x14> if ( idle_task_stack_size < STACK_MINIMUM_SIZE ) 20089f0: 80 a2 ef ff cmp %o3, 0xfff 20089f4: 28 80 00 02 bleu,a 20089fc <_Thread_Create_idle+0x48> 20089f8: 17 00 00 04 sethi %hi(0x1000), %o3 idle_task_stack_size = STACK_MINIMUM_SIZE; _Thread_Initialize( 20089fc: 03 00 80 5c sethi %hi(0x2017000), %g1 2008a00: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 2017020 <_Thread_Idle_name> 2008a04: 92 10 00 08 mov %o0, %o1 2008a08: c2 23 a0 6c st %g1, [ %sp + 0x6c ] 2008a0c: 82 10 20 01 mov 1, %g1 2008a10: c0 23 a0 60 clr [ %sp + 0x60 ] 2008a14: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2008a18: c0 23 a0 64 clr [ %sp + 0x64 ] 2008a1c: c0 23 a0 68 clr [ %sp + 0x68 ] 2008a20: 11 00 80 5f sethi %hi(0x2017c00), %o0 2008a24: 94 10 20 00 clr %o2 2008a28: 90 12 21 40 or %o0, 0x140, %o0 2008a2c: 98 10 20 00 clr %o4 2008a30: 40 00 00 aa call 2008cd8 <_Thread_Initialize> 2008a34: 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 = 2008a38: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008a3c: c4 00 61 98 ld [ %g1 + 0x198 ], %g2 ! 2017d98 <_Thread_Idle> 2008a40: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008a44: c4 20 60 90 st %g2, [ %g1 + 0x90 ] ! 2017c90 <_Thread_Executing> 2008a48: 03 00 80 5f sethi %hi(0x2017c00), %g1 _Thread_Executing = _Thread_Idle; _Thread_Start( 2008a4c: b0 10 00 02 mov %g2, %i0 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 2008a50: c4 20 60 68 st %g2, [ %g1 + 0x68 ] _Thread_Executing = _Thread_Idle; _Thread_Start( 2008a54: b2 10 20 00 clr %i1 2008a58: b6 10 20 00 clr %i3 2008a5c: 40 00 04 0c call 2009a8c <_Thread_Start> 2008a60: 99 e8 20 00 restore %g0, 0, %o4 2008a64: 01 00 00 00 nop 02008a68 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 2008a68: 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 ) ) { 2008a6c: 92 96 20 00 orcc %i0, 0, %o1 2008a70: 12 80 00 0a bne 2008a98 <_Thread_Delay_ended+0x30> 2008a74: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008a78: 03 00 80 5e sethi %hi(0x2017800), %g1 <== NOT EXECUTED 2008a7c: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008a80: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2008a84: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] <== 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; 2008a88: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2008a8c: d0 00 60 90 ld [ %g1 + 0x90 ], %o0 ! 2017c90 <_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; 2008a90: 10 80 00 19 b 2008af4 <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 2008a94: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2008a98: 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 ) { 2008a9c: 80 a0 a0 04 cmp %g2, 4 2008aa0: 18 80 00 06 bgu 2008ab8 <_Thread_Delay_ended+0x50> 2008aa4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2008aa8: 83 32 60 1b srl %o1, 0x1b, %g1 2008aac: 80 a0 60 01 cmp %g1, 1 2008ab0: 02 80 00 05 be 2008ac4 <_Thread_Delay_ended+0x5c> 2008ab4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2008ab8: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008abc: 10 80 00 0e b 2008af4 <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 2008ac0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2008ac4: 83 28 a0 02 sll %g2, 2, %g1 2008ac8: 05 00 80 5e sethi %hi(0x2017800), %g2 2008acc: 84 10 a3 10 or %g2, 0x310, %g2 ! 2017b10 <_Objects_Information_table> 2008ad0: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2008ad4: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2008ad8: 80 a2 20 00 cmp %o0, 0 2008adc: 12 80 00 04 bne 2008aec <_Thread_Delay_ended+0x84> 2008ae0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2008ae4: 10 80 00 04 b 2008af4 <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 2008ae8: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2008aec: 7f ff fb 09 call 2007710 <_Objects_Get> 2008af0: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2008af4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008af8: 80 a0 60 00 cmp %g1, 0 2008afc: 12 80 00 08 bne 2008b1c <_Thread_Delay_ended+0xb4> 2008b00: 13 04 00 ff sethi %hi(0x1003fc00), %o1 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2008b04: 7f ff ff 3d call 20087f8 <_Thread_Clear_state> 2008b08: 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; 2008b0c: 05 00 80 5e sethi %hi(0x2017800), %g2 2008b10: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> 2008b14: 82 00 7f ff add %g1, -1, %g1 2008b18: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 2008b1c: 81 c7 e0 08 ret 2008b20: 81 e8 00 00 restore 0200d5b8 <_Thread_Evaluate_mode>: boolean _Thread_Evaluate_mode( void ) { Thread_Control *executing; executing = _Thread_Executing; 200d5b8: 03 00 80 5f sethi %hi(0x2017c00), %g1 200d5bc: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2017c90 <_Thread_Executing> if ( !_States_Is_ready( executing->current_state ) || 200d5c0: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 200d5c4: 80 a0 60 00 cmp %g1, 0 200d5c8: 32 80 00 0b bne,a 200d5f4 <_Thread_Evaluate_mode+0x3c> 200d5cc: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 200d5d0: 03 00 80 5f sethi %hi(0x2017c00), %g1 200d5d4: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 ! 2017c68 <_Thread_Heir> 200d5d8: 80 a0 80 01 cmp %g2, %g1 200d5dc: 02 80 00 0b be 200d608 <_Thread_Evaluate_mode+0x50> 200d5e0: 01 00 00 00 nop 200d5e4: c2 00 a0 7c ld [ %g2 + 0x7c ], %g1 200d5e8: 80 a0 60 00 cmp %g1, 0 200d5ec: 02 80 00 07 be 200d608 <_Thread_Evaluate_mode+0x50> 200d5f0: 84 10 20 01 mov 1, %g2 ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 200d5f4: 03 00 80 5f sethi %hi(0x2017c00), %g1 200d5f8: 90 10 20 01 mov 1, %o0 200d5fc: c4 20 60 a0 st %g2, [ %g1 + 0xa0 ] 200d600: 81 c3 e0 08 retl 200d604: 01 00 00 00 nop return TRUE; } return FALSE; } 200d608: 81 c3 e0 08 retl 200d60c: 90 10 20 00 clr %o0 ! 0 0200d610 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 200d610: 9d e3 bf 98 save %sp, -104, %sp #endif #if defined(__USE__MAIN__) extern void _main(void); #endif executing = _Thread_Executing; 200d614: 03 00 80 5f sethi %hi(0x2017c00), %g1 200d618: f4 00 60 90 ld [ %g1 + 0x90 ], %i2 ! 2017c90 <_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(); 200d61c: 3f 00 80 35 sethi %hi(0x200d400), %i7 200d620: be 17 e2 10 or %i7, 0x210, %i7 ! 200d610 <_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); 200d624: d0 06 a0 c4 ld [ %i2 + 0xc4 ], %o0 200d628: 7f ff d1 ca call 2001d50 200d62c: 91 2a 20 08 sll %o0, 8, %o0 #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; doneConstructors = 1; 200d630: 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; 200d634: 05 00 80 5e sethi %hi(0x2017800), %g2 200d638: f0 08 a0 48 ldub [ %g2 + 0x48 ], %i0 ! 2017848 doneConstructors = 1; 200d63c: c2 28 a0 48 stb %g1, [ %g2 + 0x48 ] #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 ) ) { 200d640: c2 06 a1 68 ld [ %i2 + 0x168 ], %g1 200d644: 80 a0 60 00 cmp %g1, 0 200d648: 02 80 00 0b be 200d674 <_Thread_Handler+0x64> 200d64c: 33 00 80 5f sethi %hi(0x2017c00), %i1 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE boolean _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 200d650: d0 06 60 60 ld [ %i1 + 0x60 ], %o0 ! 2017c60 <_Thread_Allocated_fp> 200d654: 80 a6 80 08 cmp %i2, %o0 200d658: 02 80 00 07 be 200d674 <_Thread_Handler+0x64> 200d65c: 80 a2 20 00 cmp %o0, 0 if ( _Thread_Allocated_fp != NULL ) 200d660: 22 80 00 05 be,a 200d674 <_Thread_Handler+0x64> 200d664: f4 26 60 60 st %i2, [ %i1 + 0x60 ] _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 200d668: 7f ff f3 1c call 200a2d8 <_CPU_Context_save_fp> 200d66c: 90 02 21 68 add %o0, 0x168, %o0 _Thread_Allocated_fp = executing; 200d670: f4 26 60 60 st %i2, [ %i1 + 0x60 ] * 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 ); 200d674: 7f ff f1 be call 2009d6c <_User_extensions_Thread_begin> 200d678: 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 ) 200d67c: 03 00 80 5e sethi %hi(0x2017800), %g1 200d680: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2017bb0 <_Thread_Dispatch_disable_level> 200d684: 84 00 bf ff add %g2, -1, %g2 200d688: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 200d68c: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 200d690: 80 a0 60 00 cmp %g1, 0 200d694: 12 80 00 05 bne 200d6a8 <_Thread_Handler+0x98> 200d698: 83 2e 20 18 sll %i0, 0x18, %g1 _Thread_Dispatch(); 200d69c: 7f ff ed 22 call 2008b24 <_Thread_Dispatch> 200d6a0: 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) */ 200d6a4: 83 2e 20 18 sll %i0, 0x18, %g1 200d6a8: 80 a0 60 00 cmp %g1, 0 200d6ac: 32 80 00 05 bne,a 200d6c0 <_Thread_Handler+0xb0> 200d6b0: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 _init (); 200d6b4: 40 00 24 f5 call 2016a88 <_init> 200d6b8: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200d6bc: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 200d6c0: 80 a0 60 01 cmp %g1, 1 200d6c4: 22 80 00 0d be,a 200d6f8 <_Thread_Handler+0xe8> 200d6c8: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 200d6cc: 2a 80 00 09 bcs,a 200d6f0 <_Thread_Handler+0xe0> 200d6d0: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 200d6d4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200d6d8: 02 80 00 0d be 200d70c <_Thread_Handler+0xfc> <== NOT EXECUTED 200d6dc: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 200d6e0: 12 80 00 14 bne 200d730 <_Thread_Handler+0x120> <== NOT EXECUTED 200d6e4: 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 = 200d6e8: 10 80 00 0c b 200d718 <_Thread_Handler+0x108> <== NOT EXECUTED 200d6ec: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED __main (); #endif switch ( executing->Start.prototype ) { case THREAD_START_NUMERIC: executing->Wait.return_argument = 200d6f0: 10 80 00 03 b 200d6fc <_Thread_Handler+0xec> 200d6f4: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 200d6f8: d0 06 a0 b0 ld [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED 200d6fc: 9f c0 40 00 call %g1 200d700: 01 00 00 00 nop executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 200d704: 10 80 00 0a b 200d72c <_Thread_Handler+0x11c> 200d708: d0 26 a0 28 st %o0, [ %i2 + 0x28 ] (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 200d70c: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 200d710: 10 80 00 04 b 200d720 <_Thread_Handler+0x110> <== NOT EXECUTED 200d714: d0 1e a0 b0 ldd [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 200d718: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 <== NOT EXECUTED 200d71c: d2 06 a0 b0 ld [ %i2 + 0xb0 ], %o1 <== NOT EXECUTED 200d720: 9f c0 40 00 call %g1 <== NOT EXECUTED 200d724: 01 00 00 00 nop <== NOT EXECUTED 200d728: 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 ); 200d72c: 90 10 00 1a mov %i2, %o0 200d730: 7f ff f1 b2 call 2009df8 <_User_extensions_Thread_exitted> 200d734: b0 10 20 00 clr %i0 _Internal_error_Occurred( 200d738: b2 10 20 01 mov 1, %i1 200d73c: 7f ff e6 84 call 200714c <_Internal_error_Occurred> 200d740: 95 e8 20 06 restore %g0, 6, %o2 200d744: 01 00 00 00 nop 02008ed8 <_Thread_Handler_initialization>: void _Thread_Handler_initialization( uint32_t ticks_per_timeslice, uint32_t maximum_extensions, uint32_t maximum_proxies ) { 2008ed8: 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 ) 2008edc: 03 00 80 5e sethi %hi(0x2017800), %g1 2008ee0: 82 10 63 c4 or %g1, 0x3c4, %g1 ! 2017bc4 <_CPU_Table> 2008ee4: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 2008ee8: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 2008eec: 80 a0 00 02 cmp %g0, %g2 2008ef0: 84 60 3f ff subx %g0, -1, %g2 2008ef4: 80 a0 00 01 cmp %g0, %g1 2008ef8: 82 60 3f ff subx %g0, -1, %g1 2008efc: 80 a0 80 01 cmp %g2, %g1 2008f00: 02 80 00 07 be 2008f1c <_Thread_Handler_initialization+0x44> 2008f04: 03 00 80 5f sethi %hi(0x2017c00), %g1 == ( _CPU_Table.stack_free_hook == 0 ) ) ) _Internal_error_Occurred( 2008f08: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008f0c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2008f10: 7f ff f8 8f call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 2008f14: 94 10 20 0f mov 0xf, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 2008f18: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2008f1c: c0 20 60 a0 clr [ %g1 + 0xa0 ] ! 2017ca0 <_Context_Switch_necessary> _Thread_Executing = NULL; 2008f20: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008f24: c0 20 60 90 clr [ %g1 + 0x90 ] ! 2017c90 <_Thread_Executing> _Thread_Heir = NULL; 2008f28: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008f2c: c0 20 60 68 clr [ %g1 + 0x68 ] ! 2017c68 <_Thread_Heir> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 2008f30: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008f34: c0 20 60 60 clr [ %g1 + 0x60 ] ! 2017c60 <_Thread_Allocated_fp> #endif _Thread_Do_post_task_switch_extension = 0; 2008f38: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008f3c: c0 20 60 80 clr [ %g1 + 0x80 ] ! 2017c80 <_Thread_Do_post_task_switch_extension> _Thread_Maximum_extensions = maximum_extensions; 2008f40: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008f44: f2 20 60 7c st %i1, [ %g1 + 0x7c ] ! 2017c7c <_Thread_Maximum_extensions> _Thread_Ticks_per_timeslice = ticks_per_timeslice; 2008f48: 03 00 80 5e sethi %hi(0x2017800), %g1 _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 2008f4c: 90 10 2c 00 mov 0xc00, %o0 2008f50: 40 00 04 b1 call 200a214 <_Workspace_Allocate_or_fatal_error> 2008f54: f0 20 63 08 st %i0, [ %g1 + 0x308 ] 2008f58: 03 00 80 5e sethi %hi(0x2017800), %g1 2008f5c: 84 10 00 08 mov %o0, %g2 2008f60: d0 20 63 04 st %o0, [ %g1 + 0x304 ] (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 2008f64: 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); 2008f68: 82 00 a0 04 add %g2, 4, %g1 the_chain->permanent_null = NULL; 2008f6c: c0 20 a0 04 clr [ %g2 + 4 ] the_chain->last = _Chain_Head(the_chain); 2008f70: 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); 2008f74: c2 20 80 00 st %g1, [ %g2 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2008f78: 84 00 a0 0c add %g2, 0xc, %g2 2008f7c: 80 a0 80 03 cmp %g2, %g3 2008f80: 12 bf ff fb bne 2008f6c <_Thread_Handler_initialization+0x94> 2008f84: 82 00 a0 04 add %g2, 4, %g1 /* * Initialize this class of objects. */ _Objects_Initialize_information( 2008f88: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008f8c: c2 00 60 bc ld [ %g1 + 0xbc ], %g1 ! 2017cbc <_System_state_Is_multiprocessing> 2008f90: 96 10 20 02 mov 2, %o3 2008f94: 80 a0 00 01 cmp %g0, %g1 2008f98: 82 10 20 08 mov 8, %g1 2008f9c: 96 42 ff ff addx %o3, -1, %o3 2008fa0: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2008fa4: 11 00 80 5f sethi %hi(0x2017c00), %o0 2008fa8: 92 10 20 01 mov 1, %o1 2008fac: 90 12 21 40 or %o0, 0x140, %o0 2008fb0: 94 10 20 01 mov 1, %o2 2008fb4: 98 10 21 88 mov 0x188, %o4 2008fb8: 7f ff f9 fb call 20077a4 <_Objects_Initialize_information> 2008fbc: 9a 10 20 01 mov 1, %o5 FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 2008fc0: 81 c7 e0 08 ret 2008fc4: 81 e8 00 00 restore 02008cd8 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 2008cd8: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the Ada self pointer */ the_thread->rtems_ada_self = NULL; 2008cdc: c0 26 60 80 clr [ %i1 + 0x80 ] /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 2008ce0: 80 a6 a0 00 cmp %i2, 0 2008ce4: 12 80 00 10 bne 2008d24 <_Thread_Initialize+0x4c> 2008ce8: e0 07 a0 60 ld [ %fp + 0x60 ], %l0 if ( !_Stack_Is_enough( stack_size ) ) 2008cec: 80 a6 ef ff cmp %i3, 0xfff 2008cf0: 08 80 00 03 bleu 2008cfc <_Thread_Initialize+0x24> 2008cf4: 13 00 00 04 sethi %hi(0x1000), %o1 2008cf8: 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 ); 2008cfc: 40 00 03 26 call 2009994 <_Thread_Stack_Allocate> 2008d00: 90 10 00 19 mov %i1, %o0 if ( !actual_stack_size || actual_stack_size < stack_size ) 2008d04: 80 a2 20 00 cmp %o0, 0 2008d08: 02 80 00 2c be 2008db8 <_Thread_Initialize+0xe0> 2008d0c: 80 a2 00 1b cmp %o0, %i3 2008d10: 0a 80 00 2a bcs 2008db8 <_Thread_Initialize+0xe0> 2008d14: 82 10 20 01 mov 1, %g1 return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 2008d18: f4 06 60 dc ld [ %i1 + 0xdc ], %i2 the_thread->Start.core_allocated_stack = TRUE; 2008d1c: 10 80 00 04 b 2008d2c <_Thread_Initialize+0x54> 2008d20: c2 26 60 cc st %g1, [ %i1 + 0xcc ] } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 2008d24: c0 26 60 cc clr [ %i1 + 0xcc ] <== NOT EXECUTED 2008d28: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 2008d2c: f4 26 60 d4 st %i2, [ %i1 + 0xd4 ] the_stack->size = size; 2008d30: 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 ) { 2008d34: 80 a7 20 00 cmp %i4, 0 2008d38: 02 80 00 07 be 2008d54 <_Thread_Initialize+0x7c> 2008d3c: b8 10 20 00 clr %i4 fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 2008d40: 7f ff ff d8 call 2008ca0 <_Workspace_Allocate> 2008d44: 90 10 20 88 mov 0x88, %o0 if ( !fp_area ) { 2008d48: b8 92 20 00 orcc %o0, 0, %i4 2008d4c: 02 80 00 19 be 2008db0 <_Thread_Initialize+0xd8> 2008d50: 01 00 00 00 nop /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 2008d54: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008d58: d0 00 60 7c ld [ %g1 + 0x7c ], %o0 ! 2017c7c <_Thread_Maximum_extensions> fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 2008d5c: f8 26 61 68 st %i4, [ %i1 + 0x168 ] the_thread->Start.fp_context = fp_area; 2008d60: f8 26 60 d8 st %i4, [ %i1 + 0xd8 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2008d64: c0 26 60 50 clr [ %i1 + 0x50 ] the_watchdog->routine = routine; 2008d68: c0 26 60 64 clr [ %i1 + 0x64 ] the_watchdog->id = id; 2008d6c: c0 26 60 68 clr [ %i1 + 0x68 ] the_watchdog->user_data = user_data; 2008d70: c0 26 60 6c clr [ %i1 + 0x6c ] /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 2008d74: c0 26 61 6c clr [ %i1 + 0x16c ] /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 2008d78: 80 a2 20 00 cmp %o0, 0 2008d7c: 02 80 00 11 be 2008dc0 <_Thread_Initialize+0xe8> 2008d80: b6 10 20 00 clr %i3 extensions_area = _Workspace_Allocate( 2008d84: 90 02 20 01 inc %o0 2008d88: 7f ff ff c6 call 2008ca0 <_Workspace_Allocate> 2008d8c: 91 2a 20 02 sll %o0, 2, %o0 (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 2008d90: b6 92 20 00 orcc %o0, 0, %i3 2008d94: 12 80 00 0c bne 2008dc4 <_Thread_Initialize+0xec> 2008d98: 80 a6 e0 00 cmp %i3, 0 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2008d9c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 2008da0: 02 80 00 04 be 2008db0 <_Thread_Initialize+0xd8> <== NOT EXECUTED 2008da4: 01 00 00 00 nop <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 2008da8: 7f ff ff c5 call 2008cbc <_Workspace_Free> <== NOT EXECUTED 2008dac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 2008db0: 40 00 03 10 call 20099f0 <_Thread_Stack_Free> <== NOT EXECUTED 2008db4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2008db8: 81 c7 e0 08 ret 2008dbc: 91 e8 20 00 restore %g0, 0, %o0 * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { 2008dc0: 80 a6 e0 00 cmp %i3, 0 2008dc4: 02 80 00 0d be 2008df8 <_Thread_Initialize+0x120> 2008dc8: f6 26 61 7c st %i3, [ %i1 + 0x17c ] int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2008dcc: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008dd0: c2 00 60 7c ld [ %g1 + 0x7c ], %g1 ! 2017c7c <_Thread_Maximum_extensions> 2008dd4: 86 10 20 00 clr %g3 2008dd8: 10 80 00 05 b 2008dec <_Thread_Initialize+0x114> 2008ddc: 88 00 60 01 add %g1, 1, %g4 the_thread->extensions[i] = NULL; 2008de0: 83 28 e0 02 sll %g3, 2, %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2008de4: 86 00 e0 01 inc %g3 the_thread->extensions[i] = NULL; 2008de8: c0 20 80 01 clr [ %g2 + %g1 ] * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2008dec: 80 a0 c0 04 cmp %g3, %g4 2008df0: 32 bf ff fc bne,a 2008de0 <_Thread_Initialize+0x108> 2008df4: c4 06 61 7c ld [ %i1 + 0x17c ], %g2 /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 2008df8: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 the_thread->Start.budget_algorithm = budget_algorithm; 2008dfc: e0 26 60 bc st %l0, [ %i1 + 0xbc ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 2008e00: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 2008e04: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 switch ( budget_algorithm ) { 2008e08: 80 a4 20 02 cmp %l0, 2 2008e0c: 12 80 00 05 bne 2008e20 <_Thread_Initialize+0x148> 2008e10: 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; 2008e14: 03 00 80 5e sethi %hi(0x2017800), %g1 <== NOT EXECUTED 2008e18: c2 00 63 08 ld [ %g1 + 0x308 ], %g1 ! 2017b08 <_Thread_Ticks_per_timeslice> <== NOT EXECUTED 2008e1c: c2 26 60 84 st %g1, [ %i1 + 0x84 ] <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 2008e20: c2 07 a0 68 ld [ %fp + 0x68 ], %g1 the_thread->current_state = STATES_DORMANT; the_thread->Wait.queue = NULL; 2008e24: c0 26 60 44 clr [ %i1 + 0x44 ] break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 2008e28: c2 26 60 c4 st %g1, [ %i1 + 0xc4 ] the_thread->current_state = STATES_DORMANT; 2008e2c: 82 10 20 01 mov 1, %g1 the_thread->Wait.queue = NULL; the_thread->resource_count = 0; 2008e30: c0 26 60 1c clr [ %i1 + 0x1c ] break; } the_thread->Start.isr_level = isr_level; the_thread->current_state = STATES_DORMANT; 2008e34: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_thread->Wait.queue = NULL; the_thread->resource_count = 0; the_thread->suspend_count = 0; 2008e38: c0 26 60 70 clr [ %i1 + 0x70 ] the_thread->real_priority = priority; 2008e3c: fa 26 60 18 st %i5, [ %i1 + 0x18 ] the_thread->Start.initial_priority = priority; 2008e40: fa 26 60 c8 st %i5, [ %i1 + 0xc8 ] _Thread_Set_priority( the_thread, priority ); 2008e44: 92 10 00 1d mov %i5, %o1 2008e48: 40 00 02 32 call 2009710 <_Thread_Set_priority> 2008e4c: 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 ); 2008e50: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2008e54: 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; 2008e58: c0 26 60 90 clr [ %i1 + 0x90 ] 2008e5c: 03 00 00 3f sethi %hi(0xfc00), %g1 2008e60: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2008e64: 82 08 80 01 and %g2, %g1, %g1 2008e68: 80 a0 40 03 cmp %g1, %g3 2008e6c: 18 80 00 05 bgu 2008e80 <_Thread_Initialize+0x1a8> 2008e70: c0 26 60 94 clr [ %i1 + 0x94 ] information->local_table[ index ] = the_object; 2008e74: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 2008e78: 83 28 60 02 sll %g1, 2, %g1 2008e7c: f2 20 80 01 st %i1, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 2008e80: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 /* * Invoke create extensions */ if ( !_User_extensions_Thread_create( the_thread ) ) { 2008e84: 90 10 00 19 mov %i1, %o0 2008e88: c2 26 60 0c st %g1, [ %i1 + 0xc ] 2008e8c: 40 00 03 ec call 2009e3c <_User_extensions_Thread_create> 2008e90: b0 10 20 01 mov 1, %i0 2008e94: 80 a2 20 00 cmp %o0, 0 2008e98: 12 80 00 0e bne 2008ed0 <_Thread_Initialize+0x1f8> 2008e9c: 80 a6 e0 00 cmp %i3, 0 if ( extensions_area ) 2008ea0: 02 80 00 05 be 2008eb4 <_Thread_Initialize+0x1dc> 2008ea4: 80 a7 20 00 cmp %i4, 0 (void) _Workspace_Free( extensions_area ); 2008ea8: 7f ff ff 85 call 2008cbc <_Workspace_Free> <== NOT EXECUTED 2008eac: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2008eb0: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 2008eb4: 02 80 00 05 be 2008ec8 <_Thread_Initialize+0x1f0> 2008eb8: 90 10 00 19 mov %i1, %o0 (void) _Workspace_Free( fp_area ); 2008ebc: 7f ff ff 80 call 2008cbc <_Workspace_Free> <== NOT EXECUTED 2008ec0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 2008ec4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2008ec8: 40 00 02 ca call 20099f0 <_Thread_Stack_Free> 2008ecc: b0 10 20 00 clr %i0 return FALSE; } return TRUE; } 2008ed0: 81 c7 e0 08 ret 2008ed4: 81 e8 00 00 restore 0200db18 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { 200db18: 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; 200db1c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 200db20: c4 06 20 bc ld [ %i0 + 0xbc ], %g2 the_thread->budget_callout = the_thread->Start.budget_callout; 200db24: 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; 200db28: 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; 200db2c: c4 3e 20 88 std %g2, [ %i0 + 0x88 ] the_thread->Start.pointer_argument = pointer_argument; 200db30: f2 26 20 b0 st %i1, [ %i0 + 0xb0 ] the_thread->Start.numeric_argument = numeric_argument; 200db34: f4 26 20 b4 st %i2, [ %i0 + 0xb4 ] Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { the_thread->resource_count = 0; 200db38: c0 26 20 1c clr [ %i0 + 0x1c ] the_thread->suspend_count = 0; 200db3c: 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 ) ) { 200db40: 7f ff f1 9b call 200a1ac <_Thread_queue_Extract_with_proxy> 200db44: 90 10 00 18 mov %i0, %o0 200db48: 80 a2 20 00 cmp %o0, 0 200db4c: 32 80 00 09 bne,a 200db70 <_Thread_Reset+0x58> 200db50: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 if ( _Watchdog_Is_active( &the_thread->Timer ) ) 200db54: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 200db58: 80 a0 60 02 cmp %g1, 2 200db5c: 32 80 00 05 bne,a 200db70 <_Thread_Reset+0x58> 200db60: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 (void) _Watchdog_Remove( &the_thread->Timer ); 200db64: 7f ff f4 e0 call 200aee4 <_Watchdog_Remove> <== NOT EXECUTED 200db68: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 200db6c: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 <== NOT EXECUTED 200db70: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 200db74: 80 a0 40 19 cmp %g1, %i1 200db78: 02 80 00 05 be 200db8c <_Thread_Reset+0x74> 200db7c: 01 00 00 00 nop the_thread->real_priority = the_thread->Start.initial_priority; 200db80: f2 26 20 18 st %i1, [ %i0 + 0x18 ] _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 200db84: 7f ff f2 58 call 200a4e4 <_Thread_Set_priority> 200db88: 81 e8 00 00 restore 200db8c: 81 c7 e0 08 ret 200db90: 81 e8 00 00 restore 0200cca8 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 200cca8: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 200ccac: 03 00 80 5f sethi %hi(0x2017c00), %g1 200ccb0: e0 00 60 90 ld [ %g1 + 0x90 ], %l0 ! 2017c90 <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 200ccb4: 7f ff d4 23 call 2001d40 200ccb8: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 200ccbc: b0 10 00 08 mov %o0, %i0 if ( _Chain_Has_only_one_node( ready ) ) { 200ccc0: c4 04 40 00 ld [ %l1 ], %g2 200ccc4: c2 04 60 08 ld [ %l1 + 8 ], %g1 200ccc8: 80 a0 80 01 cmp %g2, %g1 200cccc: 32 80 00 03 bne,a 200ccd8 <_Thread_Reset_timeslice+0x30> 200ccd0: c6 04 00 00 ld [ %l0 ], %g3 _ISR_Enable( level ); 200ccd4: 30 80 00 18 b,a 200cd34 <_Thread_Reset_timeslice+0x8c> { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 200ccd8: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200ccdc: 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; 200cce0: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200cce4: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200cce8: 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; 200ccec: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 200ccf0: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200ccf4: 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; 200ccf8: e0 20 40 00 st %l0, [ %g1 ] return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 200ccfc: 7f ff d4 15 call 2001d50 200cd00: 01 00 00 00 nop 200cd04: 7f ff d4 0f call 2001d40 200cd08: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 200cd0c: 05 00 80 5f sethi %hi(0x2017c00), %g2 200cd10: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1 ! 2017c68 <_Thread_Heir> 200cd14: 80 a4 00 01 cmp %l0, %g1 200cd18: 32 80 00 05 bne,a 200cd2c <_Thread_Reset_timeslice+0x84> 200cd1c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 200cd20: c2 04 40 00 ld [ %l1 ], %g1 200cd24: c2 20 a0 68 st %g1, [ %g2 + 0x68 ] _Context_Switch_necessary = TRUE; 200cd28: 84 10 20 01 mov 1, %g2 200cd2c: 03 00 80 5f sethi %hi(0x2017c00), %g1 200cd30: c4 20 60 a0 st %g2, [ %g1 + 0xa0 ] ! 2017ca0 <_Context_Switch_necessary> _ISR_Enable( level ); 200cd34: 7f ff d4 07 call 2001d50 200cd38: 81 e8 00 00 restore 200cd3c: 01 00 00 00 nop 0200b1e4 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, boolean force ) { 200b1e4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; States_Control current_state; _ISR_Disable( level ); 200b1e8: 7f ff de 1f call 2002a64 200b1ec: 01 00 00 00 nop 200b1f0: a0 10 00 08 mov %o0, %l0 if ( force == TRUE ) 200b1f4: 80 a6 60 01 cmp %i1, 1 200b1f8: 32 80 00 04 bne,a 200b208 <_Thread_Resume+0x24> 200b1fc: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED the_thread->suspend_count = 0; 200b200: 10 80 00 04 b 200b210 <_Thread_Resume+0x2c> 200b204: c0 26 20 70 clr [ %i0 + 0x70 ] else the_thread->suspend_count--; 200b208: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200b20c: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 200b210: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 200b214: 80 a0 60 00 cmp %g1, 0 200b218: 22 80 00 03 be,a 200b224 <_Thread_Resume+0x40> 200b21c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 _ISR_Enable( level ); 200b220: 30 80 00 2e b,a 200b2d8 <_Thread_Resume+0xf4> <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { 200b224: 80 88 60 02 btst 2, %g1 200b228: 02 80 00 2c be 200b2d8 <_Thread_Resume+0xf4> 200b22c: 82 08 7f fd and %g1, -3, %g1 current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 200b230: 80 a0 60 00 cmp %g1, 0 200b234: 12 80 00 29 bne 200b2d8 <_Thread_Resume+0xf4> 200b238: c2 26 20 10 st %g1, [ %i0 + 0x10 ] RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 200b23c: c8 06 20 9c ld [ %i0 + 0x9c ], %g4 200b240: c4 16 20 a2 lduh [ %i0 + 0xa2 ], %g2 200b244: c2 11 00 00 lduh [ %g4 ], %g1 _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 200b248: c6 06 20 98 ld [ %i0 + 0x98 ], %g3 200b24c: 82 10 40 02 or %g1, %g2, %g1 200b250: c2 31 00 00 sth %g1, [ %g4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200b254: 82 00 e0 04 add %g3, 4, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 200b258: 09 00 80 90 sethi %hi(0x2024000), %g4 200b25c: c2 26 00 00 st %g1, [ %i0 ] 200b260: da 16 20 a0 lduh [ %i0 + 0xa0 ], %o5 old_last_node = the_chain->last; 200b264: c2 00 e0 08 ld [ %g3 + 8 ], %g1 200b268: c4 11 21 b4 lduh [ %g4 + 0x1b4 ], %g2 the_chain->last = the_node; 200b26c: f0 20 e0 08 st %i0, [ %g3 + 8 ] 200b270: 84 10 80 0d or %g2, %o5, %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 200b274: c2 26 20 04 st %g1, [ %i0 + 4 ] 200b278: c4 31 21 b4 sth %g2, [ %g4 + 0x1b4 ] 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; 200b27c: f0 20 40 00 st %i0, [ %g1 ] _ISR_Flash( level ); 200b280: 7f ff dd fd call 2002a74 200b284: 90 10 00 10 mov %l0, %o0 200b288: 7f ff dd f7 call 2002a64 200b28c: 01 00 00 00 nop if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 200b290: 07 00 80 90 sethi %hi(0x2024000), %g3 200b294: c2 00 e1 98 ld [ %g3 + 0x198 ], %g1 ! 2024198 <_Thread_Heir> 200b298: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 200b29c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 200b2a0: 80 a0 80 01 cmp %g2, %g1 200b2a4: 1a 80 00 0d bcc 200b2d8 <_Thread_Resume+0xf4> 200b2a8: 03 00 80 90 sethi %hi(0x2024000), %g1 _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200b2ac: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 ! 20241c0 <_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; 200b2b0: f0 20 e1 98 st %i0, [ %g3 + 0x198 ] if ( _Thread_Executing->is_preemptible || 200b2b4: c2 00 60 7c ld [ %g1 + 0x7c ], %g1 200b2b8: 80 a0 60 00 cmp %g1, 0 200b2bc: 32 80 00 05 bne,a 200b2d0 <_Thread_Resume+0xec> 200b2c0: 84 10 20 01 mov 1, %g2 200b2c4: 80 a0 a0 00 cmp %g2, 0 200b2c8: 12 80 00 04 bne 200b2d8 <_Thread_Resume+0xf4> 200b2cc: 84 10 20 01 mov 1, %g2 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 200b2d0: 03 00 80 90 sethi %hi(0x2024000), %g1 200b2d4: c4 20 61 d0 st %g2, [ %g1 + 0x1d0 ] ! 20241d0 <_Context_Switch_necessary> } } } _ISR_Enable( level ); 200b2d8: 7f ff dd e7 call 2002a74 200b2dc: 91 e8 00 10 restore %g0, %l0, %o0 200b2e0: 01 00 00 00 nop 02009994 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 2009994: 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 ) ) 2009998: 80 a6 6f ff cmp %i1, 0xfff 200999c: 28 80 00 02 bleu,a 20099a4 <_Thread_Stack_Allocate+0x10> 20099a0: 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 ) { 20099a4: 03 00 80 5e sethi %hi(0x2017800), %g1 20099a8: c2 00 63 e4 ld [ %g1 + 0x3e4 ], %g1 ! 2017be4 <_CPU_Table+0x20> 20099ac: 80 a0 60 00 cmp %g1, 0 20099b0: 02 80 00 06 be 20099c8 <_Thread_Stack_Allocate+0x34> 20099b4: 92 06 60 10 add %i1, 0x10, %o1 stack_addr = (*_CPU_Table.stack_allocate_hook)( the_stack_size ); 20099b8: 9f c0 40 00 call %g1 <== NOT EXECUTED 20099bc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 20099c0: 10 80 00 07 b 20099dc <_Thread_Stack_Allocate+0x48> <== NOT EXECUTED 20099c4: d0 26 20 dc st %o0, [ %i0 + 0xdc ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 20099c8: 11 00 80 5e sethi %hi(0x2017800), %o0 20099cc: b2 10 00 09 mov %o1, %i1 20099d0: 7f ff f4 b4 call 2006ca0 <_Heap_Allocate> 20099d4: 90 12 23 fc or %o0, 0x3fc, %o0 20099d8: 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 ) 20099dc: 80 a0 00 08 cmp %g0, %o0 20099e0: b0 60 20 00 subx %g0, 0, %i0 the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 20099e4: b0 0e 40 18 and %i1, %i0, %i0 20099e8: 81 c7 e0 08 ret 20099ec: 81 e8 00 00 restore 020099f0 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 20099f0: 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 ) 20099f4: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 20099f8: 80 a0 60 00 cmp %g1, 0 20099fc: 02 80 00 08 be 2009a1c <_Thread_Stack_Free+0x2c> 2009a00: 03 00 80 5e sethi %hi(0x2017800), %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 ) 2009a04: c2 00 63 e8 ld [ %g1 + 0x3e8 ], %g1 ! 2017be8 <_CPU_Table+0x24> 2009a08: 80 a0 60 00 cmp %g1, 0 2009a0c: 02 80 00 06 be 2009a24 <_Thread_Stack_Free+0x34> 2009a10: d0 06 20 d4 ld [ %i0 + 0xd4 ], %o0 (*_CPU_Table.stack_free_hook)( the_thread->Start.Initial_stack.area ); 2009a14: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009a18: 01 00 00 00 nop <== NOT EXECUTED 2009a1c: 81 c7 e0 08 ret <== NOT EXECUTED 2009a20: 81 e8 00 00 restore <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2009a24: 31 00 80 5e sethi %hi(0x2017800), %i0 2009a28: b2 10 00 08 mov %o0, %i1 2009a2c: 7f ff f4 c4 call 2006d3c <_Heap_Free> 2009a30: 91 ee 23 fc restore %i0, 0x3fc, %o0 2009a34: 01 00 00 00 nop 02009ad4 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 2009ad4: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; 2009ad8: 03 00 80 5f sethi %hi(0x2017c00), %g1 2009adc: e0 00 60 90 ld [ %g1 + 0x90 ], %l0 ! 2017c90 <_Thread_Executing> /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 2009ae0: c2 04 20 7c ld [ %l0 + 0x7c ], %g1 2009ae4: 80 a0 60 00 cmp %g1, 0 2009ae8: 02 80 00 23 be 2009b74 <_Thread_Tickle_timeslice+0xa0> 2009aec: 01 00 00 00 nop return; if ( !_States_Is_ready( executing->current_state ) ) 2009af0: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2009af4: 80 a0 60 00 cmp %g1, 0 2009af8: 12 80 00 1f bne 2009b74 <_Thread_Tickle_timeslice+0xa0> 2009afc: 01 00 00 00 nop /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 2009b00: c2 04 20 88 ld [ %l0 + 0x88 ], %g1 2009b04: 80 a0 60 01 cmp %g1, 1 2009b08: 0a 80 00 12 bcs 2009b50 <_Thread_Tickle_timeslice+0x7c> 2009b0c: 80 a0 60 02 cmp %g1, 2 2009b10: 28 80 00 07 bleu,a 2009b2c <_Thread_Tickle_timeslice+0x58> 2009b14: c2 04 20 84 ld [ %l0 + 0x84 ], %g1 2009b18: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2009b1c: 12 80 00 16 bne 2009b74 <_Thread_Tickle_timeslice+0xa0> <== NOT EXECUTED 2009b20: 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 ) 2009b24: 10 80 00 0d b 2009b58 <_Thread_Tickle_timeslice+0x84> <== NOT EXECUTED 2009b28: c2 04 20 84 ld [ %l0 + 0x84 ], %g1 <== NOT EXECUTED 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 ) { 2009b2c: 82 00 7f ff add %g1, -1, %g1 2009b30: 80 a0 60 00 cmp %g1, 0 2009b34: 14 80 00 07 bg 2009b50 <_Thread_Tickle_timeslice+0x7c> 2009b38: c2 24 20 84 st %g1, [ %l0 + 0x84 ] _Thread_Reset_timeslice(); 2009b3c: 40 00 0c 5b call 200cca8 <_Thread_Reset_timeslice> 2009b40: 01 00 00 00 nop executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 2009b44: 03 00 80 5e sethi %hi(0x2017800), %g1 2009b48: c2 00 63 08 ld [ %g1 + 0x308 ], %g1 ! 2017b08 <_Thread_Ticks_per_timeslice> 2009b4c: c2 24 20 84 st %g1, [ %l0 + 0x84 ] 2009b50: 81 c7 e0 08 ret 2009b54: 81 e8 00 00 restore } break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 2009b58: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2009b5c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2009b60: 12 bf ff fc bne 2009b50 <_Thread_Tickle_timeslice+0x7c> <== NOT EXECUTED 2009b64: c2 24 20 84 st %g1, [ %l0 + 0x84 ] <== NOT EXECUTED (*executing->budget_callout)( executing ); 2009b68: c2 04 20 8c ld [ %l0 + 0x8c ], %g1 <== NOT EXECUTED 2009b6c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009b70: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2009b74: 81 c7 e0 08 ret 2009b78: 81 e8 00 00 restore 02008fc8 <_Thread_queue_Dequeue>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 2008fc8: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 2008fcc: 80 a0 60 00 cmp %g1, 0 2008fd0: 02 80 00 05 be 2008fe4 <_Thread_queue_Dequeue+0x1c> 2008fd4: 80 a0 60 01 cmp %g1, 1 2008fd8: 12 80 00 09 bne 2008ffc <_Thread_queue_Dequeue+0x34> 2008fdc: 01 00 00 00 nop 2008fe0: 30 80 00 04 b,a 2008ff0 <_Thread_queue_Dequeue+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); 2008fe4: 82 13 c0 00 mov %o7, %g1 2008fe8: 40 00 0e 3a call 200c8d0 <_Thread_queue_Dequeue_fifo> 2008fec: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_Dequeue_priority( the_thread_queue ); 2008ff0: 82 13 c0 00 mov %o7, %g1 2008ff4: 40 00 00 0a call 200901c <_Thread_queue_Dequeue_priority> 2008ff8: 9e 10 40 00 mov %g1, %o7 the_thread = NULL; break; } return( the_thread ); } 2008ffc: 81 c3 e0 08 retl <== NOT EXECUTED 2009000: 90 10 20 00 clr %o0 <== NOT EXECUTED 0200c8d0 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 200c8d0: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 200c8d4: 7f ff d5 1b call 2001d40 200c8d8: a0 10 00 18 mov %i0, %l0 200c8dc: 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)); 200c8e0: f0 06 00 00 ld [ %i0 ], %i0 if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 200c8e4: 82 04 20 04 add %l0, 4, %g1 200c8e8: 80 a6 00 01 cmp %i0, %g1 200c8ec: 22 80 00 16 be,a 200c944 <_Thread_queue_Dequeue_fifo+0x74> 200c8f0: 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; 200c8f4: c2 06 00 00 ld [ %i0 ], %g1 the_chain->first = new_first; 200c8f8: 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 ) ) { 200c8fc: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 new_first->previous = _Chain_Head(the_chain); 200c900: e0 20 60 04 st %l0, [ %g1 + 4 ] 200c904: 80 a0 a0 02 cmp %g2, 2 200c908: 02 80 00 05 be 200c91c <_Thread_queue_Dequeue_fifo+0x4c> 200c90c: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 200c910: 7f ff d5 10 call 2001d50 200c914: 01 00 00 00 nop 200c918: 30 80 00 07 b,a 200c934 <_Thread_queue_Dequeue_fifo+0x64> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 200c91c: 82 10 20 03 mov 3, %g1 ! 3 200c920: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200c924: 7f ff d5 0b call 2001d50 200c928: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 200c92c: 7f ff f5 e7 call 200a0c8 <_Watchdog_Remove> 200c930: 90 06 20 48 add %i0, 0x48, %o0 _Thread_Unblock( the_thread ); 200c934: 7f ff ff e1 call 200c8b8 <_Thread_Unblock> 200c938: 90 10 00 18 mov %i0, %o0 200c93c: 81 c7 e0 08 ret 200c940: 81 e8 00 00 restore #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 200c944: 80 a0 60 02 cmp %g1, 2 200c948: 18 80 00 06 bgu 200c960 <_Thread_queue_Dequeue_fifo+0x90> 200c94c: 80 a0 60 03 cmp %g1, 3 200c950: 80 a0 60 01 cmp %g1, 1 200c954: 1a 80 00 0a bcc 200c97c <_Thread_queue_Dequeue_fifo+0xac> 200c958: 82 10 20 03 mov 3, %g1 200c95c: 30 80 00 03 b,a 200c968 <_Thread_queue_Dequeue_fifo+0x98> 200c960: 12 bf ff f7 bne 200c93c <_Thread_queue_Dequeue_fifo+0x6c> <== NOT EXECUTED 200c964: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 200c968: b0 10 20 00 clr %i0 200c96c: 7f ff d4 f9 call 2001d50 200c970: 90 10 00 02 mov %g2, %o0 200c974: 81 c7 e0 08 ret 200c978: 81 e8 00 00 restore return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 200c97c: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 200c980: 7f ff d4 f4 call 2001d50 <== NOT EXECUTED 200c984: 01 00 00 00 nop <== NOT EXECUTED return _Thread_Executing; 200c988: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 200c98c: f0 00 60 90 ld [ %g1 + 0x90 ], %i0 ! 2017c90 <_Thread_Executing> <== NOT EXECUTED } return NULL; /* this is only to prevent warnings */ } 200c990: 81 c7 e0 08 ret <== NOT EXECUTED 200c994: 81 e8 00 00 restore <== NOT EXECUTED 0200901c <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 200901c: 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 ); 2009020: 7f ff e3 48 call 2001d40 2009024: 01 00 00 00 nop 2009028: 98 10 00 08 mov %o0, %o4 200902c: 86 10 20 00 clr %g3 2009030: 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)); 2009034: 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 ] ) ) { 2009038: 85 28 e0 02 sll %g3, 2, %g2 200903c: 83 28 e0 04 sll %g3, 4, %g1 2009040: 82 20 40 02 sub %g1, %g2, %g1 2009044: 82 06 00 01 add %i0, %g1, %g1 2009048: 82 00 60 04 add %g1, 4, %g1 200904c: 80 a2 00 01 cmp %o0, %g1 2009050: 02 80 00 04 be 2009060 <_Thread_queue_Dequeue_priority+0x44> 2009054: 88 01 20 0c add %g4, 0xc, %g4 the_thread = (Thread_Control *) 2009058: 10 80 00 1c b 20090c8 <_Thread_queue_Dequeue_priority+0xac> 200905c: b0 10 00 08 mov %o0, %i0 Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 2009060: 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 ; 2009064: 80 a0 e0 04 cmp %g3, 4 2009068: 32 bf ff f4 bne,a 2009038 <_Thread_queue_Dequeue_priority+0x1c> 200906c: d0 01 00 18 ld [ %g4 + %i0 ], %o0 the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 2009070: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2009074: 80 a0 60 02 cmp %g1, 2 2009078: 18 80 00 06 bgu 2009090 <_Thread_queue_Dequeue_priority+0x74> 200907c: 80 a0 60 03 cmp %g1, 3 2009080: 80 a0 60 01 cmp %g1, 1 2009084: 1a 80 00 0a bcc 20090ac <_Thread_queue_Dequeue_priority+0x90> 2009088: 82 10 20 03 mov 3, %g1 200908c: 30 80 00 03 b,a 2009098 <_Thread_queue_Dequeue_priority+0x7c> 2009090: 12 80 00 0e bne 20090c8 <_Thread_queue_Dequeue_priority+0xac> <== NOT EXECUTED 2009094: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 2009098: b0 10 20 00 clr %i0 200909c: 7f ff e3 2d call 2001d50 20090a0: 90 10 00 0c mov %o4, %o0 20090a4: 81 c7 e0 08 ret 20090a8: 81 e8 00 00 restore return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 20090ac: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 20090b0: 7f ff e3 28 call 2001d50 <== NOT EXECUTED 20090b4: 90 10 00 0c mov %o4, %o0 <== NOT EXECUTED return _Thread_Executing; 20090b8: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 20090bc: f0 00 60 90 ld [ %g1 + 0x90 ], %i0 ! 2017c90 <_Thread_Executing> <== NOT EXECUTED 20090c0: 81 c7 e0 08 ret <== NOT EXECUTED 20090c4: 81 e8 00 00 restore <== NOT EXECUTED } dequeue: the_thread->Wait.queue = NULL; new_first_node = the_thread->Wait.Block2n.first; 20090c8: 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 ) ) { 20090cc: 82 06 20 3c add %i0, 0x3c, %g1 _ISR_Enable( level ); return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; 20090d0: 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 ) ) { 20090d4: 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; 20090d8: c4 06 00 00 ld [ %i0 ], %g2 previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 20090dc: 02 80 00 14 be 200912c <_Thread_queue_Dequeue_priority+0x110> 20090e0: c2 06 20 04 ld [ %i0 + 4 ], %g1 last_node = the_thread->Wait.Block2n.last; 20090e4: da 06 20 40 ld [ %i0 + 0x40 ], %o5 new_second_node = new_first_node->next; 20090e8: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 20090ec: 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; 20090f0: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 20090f4: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 20090f8: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 20090fc: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 2009100: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 2009104: 80 a0 80 01 cmp %g2, %g1 2009108: 22 80 00 0c be,a 2009138 <_Thread_queue_Dequeue_priority+0x11c> 200910c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 /* > two threads on 2-n */ new_second_node->previous = 2009110: 82 00 e0 38 add %g3, 0x38, %g1 2009114: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 2009118: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] new_first_thread->Wait.Block2n.last = last_node; 200911c: da 20 e0 40 st %o5, [ %g3 + 0x40 ] last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 2009120: 82 00 e0 3c add %g3, 0x3c, %g1 2009124: 10 80 00 04 b 2009134 <_Thread_queue_Dequeue_priority+0x118> 2009128: c2 23 40 00 st %g1, [ %o5 ] } } else { previous_node->next = next_node; next_node->previous = previous_node; 200912c: 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; 2009130: c4 20 40 00 st %g2, [ %g1 ] next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 2009134: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 2009138: 80 a0 60 02 cmp %g1, 2 200913c: 02 80 00 08 be 200915c <_Thread_queue_Dequeue_priority+0x140> 2009140: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 2009144: 7f ff e3 03 call 2001d50 2009148: 90 10 00 0c mov %o4, %o0 _Thread_Unblock( the_thread ); 200914c: 7f ff ff ae call 2009004 <_Thread_Unblock> 2009150: 90 10 00 18 mov %i0, %o0 2009154: 81 c7 e0 08 ret 2009158: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 200915c: c2 26 20 50 st %g1, [ %i0 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 2009160: 7f ff e2 fc call 2001d50 2009164: 90 10 00 0c mov %o4, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 2009168: 40 00 03 d8 call 200a0c8 <_Watchdog_Remove> 200916c: 90 06 20 48 add %i0, 0x48, %o0 _Thread_Unblock( the_thread ); 2009170: 7f ff ff a5 call 2009004 <_Thread_Unblock> 2009174: 90 10 00 18 mov %i0, %o0 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 2009178: 81 c7 e0 08 ret 200917c: 81 e8 00 00 restore 0200c998 <_Thread_queue_Enqueue_fifo>: void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200c998: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); 200c99c: 7f ff d4 e9 call 2001d40 200c9a0: a0 10 00 18 mov %i0, %l0 void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200c9a4: b0 10 00 19 mov %i1, %i0 ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); sync_state = the_thread_queue->sync_state; 200c9a8: c4 04 20 30 ld [ %l0 + 0x30 ], %g2 the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 200c9ac: 80 a0 a0 02 cmp %g2, 2 200c9b0: 02 80 00 10 be 200c9f0 <_Thread_queue_Enqueue_fifo+0x58> 200c9b4: c0 24 20 30 clr [ %l0 + 0x30 ] 200c9b8: 80 a0 a0 03 cmp %g2, 3 200c9bc: 02 80 00 12 be 200ca04 <_Thread_queue_Enqueue_fifo+0x6c> 200c9c0: 80 a0 a0 01 cmp %g2, 1 200c9c4: 32 80 00 1e bne,a 200ca3c <_Thread_queue_Enqueue_fifo+0xa4> 200c9c8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200c9cc: 82 04 20 04 add %l0, 4, %g1 200c9d0: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 200c9d4: c2 04 20 08 ld [ %l0 + 8 ], %g1 the_chain->last = the_node; 200c9d8: f2 24 20 08 st %i1, [ %l0 + 8 ] case THREAD_QUEUE_NOTHING_HAPPENED: _Chain_Append_unprotected( &the_thread_queue->Queues.Fifo, &the_thread->Object.Node ); the_thread->Wait.queue = the_thread_queue; 200c9dc: e0 26 60 44 st %l0, [ %i1 + 0x44 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200c9e0: c2 26 60 04 st %g1, [ %i1 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 200c9e4: f2 20 40 00 st %i1, [ %g1 ] _ISR_Enable( level ); 200c9e8: 7f ff d4 da call 2001d50 200c9ec: 91 e8 00 08 restore %g0, %o0, %o0 return; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 200c9f0: c2 06 60 44 ld [ %i1 + 0x44 ], %g1 <== NOT EXECUTED the_thread->Wait.queue = NULL; 200c9f4: 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; 200c9f8: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED 200c9fc: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 200ca00: 30 80 00 0d b,a 200ca34 <_Thread_queue_Enqueue_fifo+0x9c> <== NOT EXECUTED break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 200ca04: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 200ca08: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200ca0c: 12 80 00 0a bne 200ca34 <_Thread_queue_Enqueue_fifo+0x9c> <== NOT EXECUTED 200ca10: 01 00 00 00 nop <== NOT EXECUTED 200ca14: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 200ca18: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 200ca1c: 7f ff d4 cd call 2001d50 <== NOT EXECUTED 200ca20: 01 00 00 00 nop <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 200ca24: 7f ff f5 a9 call 200a0c8 <_Watchdog_Remove> <== NOT EXECUTED 200ca28: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 200ca2c: 10 80 00 04 b 200ca3c <_Thread_queue_Enqueue_fifo+0xa4> <== NOT EXECUTED 200ca30: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED } else _ISR_Enable( level ); 200ca34: 7f ff d4 c7 call 2001d50 <== NOT EXECUTED 200ca38: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200ca3c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 200ca40: 7f ff ef 6e call 20087f8 <_Thread_Clear_state> <== NOT EXECUTED 200ca44: 81 e8 00 00 restore <== NOT EXECUTED 200ca48: 01 00 00 00 nop 02009204 <_Thread_queue_Enqueue_priority>: void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 2009204: 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; 2009208: 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); 200920c: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; 2009210: c0 26 60 3c clr [ %i1 + 0x3c ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009214: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009218: 82 06 60 38 add %i1, 0x38, %g1 200921c: c2 26 60 40 st %g1, [ %i1 + 0x40 ] header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 2009220: 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); 2009224: 85 34 a0 06 srl %l2, 6, %g2 2009228: 12 80 00 34 bne 20092f8 <_Thread_queue_Enqueue_priority+0xf4> 200922c: ec 06 20 38 ld [ %i0 + 0x38 ], %l6 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 2009230: 83 28 a0 04 sll %g2, 4, %g1 2009234: 85 28 a0 02 sll %g2, 2, %g2 2009238: aa 20 40 02 sub %g1, %g2, %l5 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200923c: 82 06 00 15 add %i0, %l5, %g1 2009240: a8 00 60 04 add %g1, 4, %l4 if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 2009244: 7f ff e2 bf call 2001d40 2009248: 01 00 00 00 nop 200924c: a2 10 00 08 mov %o0, %l1 search_thread = (Thread_Control *) header->first; 2009250: e0 06 00 15 ld [ %i0 + %l5 ], %l0 2009254: 10 80 00 18 b 20092b4 <_Thread_queue_Enqueue_priority+0xb0> 2009258: a6 10 3f ff mov -1, %l3 while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; if ( priority <= search_priority ) 200925c: 80 a4 80 13 cmp %l2, %l3 2009260: 28 80 00 19 bleu,a 20092c4 <_Thread_queue_Enqueue_priority+0xc0> 2009264: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 2009268: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 200926c: 80 a4 00 14 cmp %l0, %l4 2009270: 22 80 00 15 be,a 20092c4 <_Thread_queue_Enqueue_priority+0xc0> 2009274: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 2009278: e6 04 20 14 ld [ %l0 + 0x14 ], %l3 if ( priority <= search_priority ) 200927c: 80 a4 80 13 cmp %l2, %l3 2009280: 28 80 00 11 bleu,a 20092c4 <_Thread_queue_Enqueue_priority+0xc0> 2009284: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #endif _ISR_Flash( level ); 2009288: 7f ff e2 b2 call 2001d50 200928c: 90 10 00 11 mov %l1, %o0 2009290: 7f ff e2 ac call 2001d40 2009294: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2009298: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 200929c: 80 8d 80 01 btst %l6, %g1 20092a0: 32 80 00 05 bne,a 20092b4 <_Thread_queue_Enqueue_priority+0xb0> 20092a4: e0 04 00 00 ld [ %l0 ], %l0 _ISR_Enable( level ); 20092a8: 7f ff e2 aa call 2001d50 <== NOT EXECUTED 20092ac: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20092b0: 30 bf ff e5 b,a 2009244 <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 20092b4: 80 a4 00 14 cmp %l0, %l4 20092b8: 32 bf ff e9 bne,a 200925c <_Thread_queue_Enqueue_priority+0x58> 20092bc: e6 04 20 14 ld [ %l0 + 0x14 ], %l3 } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 20092c0: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 20092c4: 80 a0 60 01 cmp %g1, 1 20092c8: 32 80 00 47 bne,a 20093e4 <_Thread_queue_Enqueue_priority+0x1e0> 20092cc: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 <== NOT EXECUTED goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 20092d0: 80 a4 80 13 cmp %l2, %l3 20092d4: 02 80 00 3c be 20093c4 <_Thread_queue_Enqueue_priority+0x1c0> 20092d8: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 20092dc: c2 04 20 04 ld [ %l0 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 20092e0: e0 26 40 00 st %l0, [ %i1 ] the_node->previous = previous_node; 20092e4: 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; 20092e8: f0 26 60 44 st %i0, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 20092ec: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 20092f0: f2 24 20 04 st %i1, [ %l0 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 20092f4: 30 80 00 32 b,a 20093bc <_Thread_queue_Enqueue_priority+0x1b8> restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 20092f8: 83 28 a0 04 sll %g2, 4, %g1 20092fc: 85 28 a0 02 sll %g2, 2, %g2 2009300: 82 20 40 02 sub %g1, %g2, %g1 2009304: a6 00 40 18 add %g1, %i0, %l3 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 2009308: aa 10 00 13 mov %l3, %l5 return; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); 200930c: 7f ff e2 8d call 2001d40 2009310: 01 00 00 00 nop 2009314: a2 10 00 08 mov %o0, %l1 search_thread = (Thread_Control *) header->last; 2009318: e0 05 60 08 ld [ %l5 + 8 ], %l0 200931c: 10 80 00 18 b 200937c <_Thread_queue_Enqueue_priority+0x178> 2009320: a8 10 21 00 mov 0x100, %l4 while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; if ( priority >= search_priority ) 2009324: 80 a4 80 14 cmp %l2, %l4 2009328: 3a 80 00 19 bcc,a 200938c <_Thread_queue_Enqueue_priority+0x188> 200932c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 2009330: e0 04 20 04 ld [ %l0 + 4 ], %l0 if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 2009334: 80 a4 00 13 cmp %l0, %l3 2009338: 22 80 00 15 be,a 200938c <_Thread_queue_Enqueue_priority+0x188> 200933c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 2009340: e8 04 20 14 ld [ %l0 + 0x14 ], %l4 if ( priority >= search_priority ) 2009344: 80 a4 80 14 cmp %l2, %l4 2009348: 3a 80 00 11 bcc,a 200938c <_Thread_queue_Enqueue_priority+0x188> 200934c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED break; #endif _ISR_Flash( level ); 2009350: 7f ff e2 80 call 2001d50 2009354: 90 10 00 11 mov %l1, %o0 2009358: 7f ff e2 7a call 2001d40 200935c: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2009360: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2009364: 80 8d 80 01 btst %l6, %g1 2009368: 32 80 00 05 bne,a 200937c <_Thread_queue_Enqueue_priority+0x178> 200936c: e0 04 20 04 ld [ %l0 + 4 ], %l0 _ISR_Enable( level ); 2009370: 7f ff e2 78 call 2001d50 <== NOT EXECUTED 2009374: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2009378: 30 bf ff e5 b,a 200930c <_Thread_queue_Enqueue_priority+0x108> <== NOT EXECUTED restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 200937c: 80 a4 00 13 cmp %l0, %l3 2009380: 32 bf ff e9 bne,a 2009324 <_Thread_queue_Enqueue_priority+0x120> 2009384: e8 04 20 14 ld [ %l0 + 0x14 ], %l4 } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 2009388: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 200938c: 80 a0 60 01 cmp %g1, 1 2009390: 32 80 00 15 bne,a 20093e4 <_Thread_queue_Enqueue_priority+0x1e0> 2009394: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 <== NOT EXECUTED goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 2009398: 80 a4 80 14 cmp %l2, %l4 200939c: 02 80 00 0a be 20093c4 <_Thread_queue_Enqueue_priority+0x1c0> 20093a0: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 20093a4: c2 04 00 00 ld [ %l0 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 20093a8: 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; 20093ac: 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; 20093b0: f0 26 60 44 st %i0, [ %i1 + 0x44 ] next_node = search_node->next; the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; search_node->next = the_node; 20093b4: f2 24 00 00 st %i1, [ %l0 ] next_node->previous = the_node; 20093b8: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 20093bc: 7f ff e2 65 call 2001d50 20093c0: 91 e8 00 11 restore %g0, %l1, %o0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 20093c4: 82 04 20 3c add %l0, 0x3c, %g1 return; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 20093c8: c4 00 60 04 ld [ %g1 + 4 ], %g2 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 20093cc: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = previous_node; 20093d0: 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; 20093d4: f0 26 60 44 st %i0, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 20093d8: f2 20 80 00 st %i1, [ %g2 ] search_node->previous = the_node; 20093dc: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 20093e0: 30 bf ff f7 b,a 20093bc <_Thread_queue_Enqueue_priority+0x1b8> synchronize: sync_state = the_thread_queue->sync_state; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 20093e4: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 20093e8: 02 80 00 07 be 2009404 <_Thread_queue_Enqueue_priority+0x200> <== NOT EXECUTED 20093ec: c0 26 20 30 clr [ %i0 + 0x30 ] <== NOT EXECUTED 20093f0: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 20093f4: 12 80 00 17 bne 2009450 <_Thread_queue_Enqueue_priority+0x24c> <== NOT EXECUTED 20093f8: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 20093fc: 10 80 00 07 b 2009418 <_Thread_queue_Enqueue_priority+0x214> <== NOT EXECUTED 2009400: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED * This should never happen. All of this was dealt with above. */ break; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 2009404: c2 06 60 44 ld [ %i1 + 0x44 ], %g1 <== NOT EXECUTED the_thread->Wait.queue = NULL; 2009408: 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; 200940c: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED 2009410: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 2009414: 30 80 00 0c b,a 2009444 <_Thread_queue_Enqueue_priority+0x240> <== NOT EXECUTED break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 2009418: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200941c: 12 80 00 0a bne 2009444 <_Thread_queue_Enqueue_priority+0x240> <== NOT EXECUTED 2009420: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 2009424: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 2009428: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 200942c: 7f ff e2 49 call 2001d50 <== NOT EXECUTED 2009430: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 2009434: 40 00 03 25 call 200a0c8 <_Watchdog_Remove> <== NOT EXECUTED 2009438: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 200943c: 10 80 00 05 b 2009450 <_Thread_queue_Enqueue_priority+0x24c> <== NOT EXECUTED 2009440: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED } else _ISR_Enable( level ); 2009444: 7f ff e2 43 call 2001d50 <== NOT EXECUTED 2009448: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200944c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 2009450: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 2009454: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2009458: 7f ff fc e8 call 20087f8 <_Thread_Clear_state> <== NOT EXECUTED 200945c: 81 e8 00 00 restore <== NOT EXECUTED 2009460: 01 00 00 00 nop 02009180 <_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 ) { 2009180: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; the_thread = _Thread_Executing; 2009184: 03 00 80 5f sethi %hi(0x2017c00), %g1 else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 2009188: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 Thread_queue_Timeout_callout handler ) { Thread_Control *the_thread; the_thread = _Thread_Executing; 200918c: e0 00 60 90 ld [ %g1 + 0x90 ], %l0 void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 2009190: 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 ); 2009194: 40 00 01 79 call 2009778 <_Thread_Set_state> 2009198: 90 10 00 10 mov %l0, %o0 /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 200919c: 80 a6 60 00 cmp %i1, 0 20091a0: 22 80 00 0d be,a 20091d4 <_Thread_queue_Enqueue_with_handler+0x54> 20091a4: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 _Watchdog_Initialize( 20091a8: c2 04 20 08 ld [ %l0 + 8 ], %g1 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20091ac: 11 00 80 5f sethi %hi(0x2017c00), %o0 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 20091b0: f4 24 20 64 st %i2, [ %l0 + 0x64 ] the_watchdog->id = id; 20091b4: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20091b8: f2 24 20 54 st %i1, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20091bc: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 20091c0: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20091c4: 90 12 20 b0 or %o0, 0xb0, %o0 20091c8: 40 00 03 68 call 2009f68 <_Watchdog_Insert> 20091cc: 92 04 20 48 add %l0, 0x48, %o1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 20091d0: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 20091d4: 80 a0 60 00 cmp %g1, 0 20091d8: 02 80 00 05 be 20091ec <_Thread_queue_Enqueue_with_handler+0x6c> 20091dc: 80 a0 60 01 cmp %g1, 1 20091e0: 12 80 00 07 bne 20091fc <_Thread_queue_Enqueue_with_handler+0x7c> 20091e4: 01 00 00 00 nop 20091e8: 30 80 00 03 b,a 20091f4 <_Thread_queue_Enqueue_with_handler+0x74> case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); 20091ec: 40 00 0d eb call 200c998 <_Thread_queue_Enqueue_fifo> 20091f0: 93 e8 00 10 restore %g0, %l0, %o1 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Enqueue_priority( the_thread_queue, the_thread ); 20091f4: 40 00 00 04 call 2009204 <_Thread_queue_Enqueue_priority> 20091f8: 93 e8 00 10 restore %g0, %l0, %o1 20091fc: 81 c7 e0 08 ret <== NOT EXECUTED 2009200: 81 e8 00 00 restore <== NOT EXECUTED 0200ca4c <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 200ca4c: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 200ca50: 80 a0 60 00 cmp %g1, 0 200ca54: 02 80 00 05 be 200ca68 <_Thread_queue_Extract+0x1c> 200ca58: 80 a0 60 01 cmp %g1, 1 200ca5c: 12 80 00 09 bne 200ca80 <_Thread_queue_Extract+0x34> 200ca60: 94 10 20 00 clr %o2 200ca64: 30 80 00 04 b,a 200ca74 <_Thread_queue_Extract+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 200ca68: 82 13 c0 00 mov %o7, %g1 200ca6c: 40 00 03 37 call 200d748 <_Thread_queue_Extract_fifo> 200ca70: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 200ca74: 82 13 c0 00 mov %o7, %g1 200ca78: 40 00 00 04 call 200ca88 <_Thread_queue_Extract_priority_helper> 200ca7c: 9e 10 40 00 mov %g1, %o7 200ca80: 81 c3 e0 08 retl <== NOT EXECUTED 200ca84: 01 00 00 00 nop 0200d748 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200d748: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 200d74c: 7f ff d1 7d call 2001d40 200d750: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200d754: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200d758: 03 00 00 ef sethi %hi(0x3bc00), %g1 200d75c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200d760: 80 88 80 01 btst %g2, %g1 200d764: 32 80 00 04 bne,a 200d774 <_Thread_queue_Extract_fifo+0x2c> 200d768: c2 06 40 00 ld [ %i1 ], %g1 _ISR_Enable( level ); 200d76c: 7f ff d1 79 call 2001d50 <== NOT EXECUTED 200d770: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 200d774: 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 ) ) { 200d778: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 next->previous = previous; previous->next = next; 200d77c: c2 20 80 00 st %g1, [ %g2 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200d780: c4 20 60 04 st %g2, [ %g1 + 4 ] 200d784: 80 a0 e0 02 cmp %g3, 2 200d788: 02 80 00 06 be 200d7a0 <_Thread_queue_Extract_fifo+0x58> 200d78c: c0 26 60 44 clr [ %i1 + 0x44 ] _ISR_Enable( level ); 200d790: 7f ff d1 70 call 2001d50 200d794: 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 ); 200d798: 10 80 00 0a b 200d7c0 <_Thread_queue_Extract_fifo+0x78> 200d79c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200d7a0: 82 10 20 03 mov 3, %g1 200d7a4: c2 26 60 50 st %g1, [ %i1 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200d7a8: 7f ff d1 6a call 2001d50 200d7ac: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 200d7b0: 7f ff f2 46 call 200a0c8 <_Watchdog_Remove> 200d7b4: 90 06 60 48 add %i1, 0x48, %o0 200d7b8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200d7bc: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200d7c0: 7f ff ec 0e call 20087f8 <_Thread_Clear_state> 200d7c4: 81 e8 00 00 restore 200d7c8: 01 00 00 00 nop 0200ca88 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, boolean requeuing ) { 200ca88: 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 ); 200ca8c: 7f ff d4 ad call 2001d40 200ca90: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200ca94: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200ca98: 03 00 00 ef sethi %hi(0x3bc00), %g1 200ca9c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200caa0: 80 88 80 01 btst %g2, %g1 200caa4: 32 80 00 03 bne,a 200cab0 <_Thread_queue_Extract_priority_helper+0x28> 200caa8: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 _ISR_Enable( level ); 200caac: 30 80 00 1d b,a 200cb20 <_Thread_queue_Extract_priority_helper+0x98> <== NOT EXECUTED */ next_node = the_node->next; previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 200cab0: 82 06 60 3c add %i1, 0x3c, %g1 /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 200cab4: c4 06 40 00 ld [ %i1 ], %g2 previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 200cab8: 80 a0 c0 01 cmp %g3, %g1 200cabc: 02 80 00 14 be 200cb0c <_Thread_queue_Extract_priority_helper+0x84> 200cac0: c2 06 60 04 ld [ %i1 + 4 ], %g1 new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 200cac4: da 06 60 40 ld [ %i1 + 0x40 ], %o5 new_second_node = new_first_node->next; 200cac8: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 200cacc: 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; 200cad0: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 200cad4: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 200cad8: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 200cadc: c4 06 60 38 ld [ %i1 + 0x38 ], %g2 200cae0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 200cae4: 80 a0 80 01 cmp %g2, %g1 200cae8: 02 80 00 0c be 200cb18 <_Thread_queue_Extract_priority_helper+0x90> 200caec: 80 a6 a0 00 cmp %i2, 0 /* > two threads on 2-n */ new_second_node->previous = 200caf0: 82 00 e0 38 add %g3, 0x38, %g1 <== NOT EXECUTED 200caf4: 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; 200caf8: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 200cafc: da 20 e0 40 st %o5, [ %g3 + 0x40 ] <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 200cb00: 82 00 e0 3c add %g3, 0x3c, %g1 <== NOT EXECUTED 200cb04: 10 80 00 05 b 200cb18 <_Thread_queue_Extract_priority_helper+0x90> <== NOT EXECUTED 200cb08: c2 23 40 00 st %g1, [ %o5 ] <== NOT EXECUTED } } else { previous_node->next = next_node; next_node->previous = previous_node; 200cb0c: 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; 200cb10: c4 20 40 00 st %g2, [ %g1 ] /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 200cb14: 80 a6 a0 00 cmp %i2, 0 200cb18: 22 80 00 04 be,a 200cb28 <_Thread_queue_Extract_priority_helper+0xa0> 200cb1c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 _ISR_Enable( level ); 200cb20: 7f ff d4 8c call 2001d50 200cb24: 91 e8 00 08 restore %g0, %o0, %o0 return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 200cb28: 80 a0 60 02 cmp %g1, 2 200cb2c: 02 80 00 06 be 200cb44 <_Thread_queue_Extract_priority_helper+0xbc> 200cb30: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 200cb34: 7f ff d4 87 call 2001d50 200cb38: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200cb3c: 10 80 00 08 b 200cb5c <_Thread_queue_Extract_priority_helper+0xd4> 200cb40: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200cb44: c2 26 20 50 st %g1, [ %i0 + 0x50 ] <== NOT EXECUTED } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200cb48: 7f ff d4 82 call 2001d50 <== NOT EXECUTED 200cb4c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 200cb50: 7f ff f5 5e call 200a0c8 <_Watchdog_Remove> <== NOT EXECUTED 200cb54: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED 200cb58: b2 16 63 f8 or %i1, 0x3f8, %i1 <== NOT EXECUTED 200cb5c: 7f ff ef 27 call 20087f8 <_Thread_Clear_state> 200cb60: 81 e8 00 00 restore 200cb64: 01 00 00 00 nop 02009464 <_Thread_queue_Extract_with_proxy>: */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 2009464: 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; 2009468: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 200946c: 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 ) ) { 2009470: 03 00 00 ef sethi %hi(0x3bc00), %g1 2009474: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2009478: 80 88 80 01 btst %g2, %g1 200947c: 02 80 00 1e be 20094f4 <_Thread_queue_Extract_with_proxy+0x90> 2009480: b0 10 20 00 clr %i0 if ( _States_Is_waiting_for_rpc_reply( state ) && 2009484: 03 00 00 08 sethi %hi(0x2000), %g1 2009488: 80 88 80 01 btst %g2, %g1 200948c: 22 80 00 17 be,a 20094e8 <_Thread_queue_Extract_with_proxy+0x84> 2009490: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 2009494: 03 00 00 e7 sethi %hi(0x39c00), %g1 <== NOT EXECUTED 2009498: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 39ee0 <== NOT EXECUTED 200949c: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 20094a0: 22 80 00 12 be,a 20094e8 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 20094a4: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED _States_Is_locally_blocked( state ) ) { the_information = _Objects_Get_information( the_thread->Wait.id ); 20094a8: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED proxy_extract_callout = 20094ac: 03 00 80 5e sethi %hi(0x2017800), %g1 <== NOT EXECUTED 20094b0: 85 30 e0 16 srl %g3, 0x16, %g2 <== NOT EXECUTED 20094b4: 82 10 63 10 or %g1, 0x310, %g1 <== NOT EXECUTED 20094b8: 84 08 a0 1c and %g2, 0x1c, %g2 <== NOT EXECUTED 20094bc: c2 00 40 02 ld [ %g1 + %g2 ], %g1 <== NOT EXECUTED 20094c0: 87 30 e0 1b srl %g3, 0x1b, %g3 <== NOT EXECUTED 20094c4: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED 20094c8: c2 00 40 03 ld [ %g1 + %g3 ], %g1 <== NOT EXECUTED 20094cc: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 <== NOT EXECUTED (Objects_Thread_queue_Extract_callout) the_information->extract; if ( proxy_extract_callout ) 20094d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20094d4: 22 80 00 05 be,a 20094e8 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 20094d8: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED (*proxy_extract_callout)( the_thread ); 20094dc: 9f c0 40 00 call %g1 <== NOT EXECUTED 20094e0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 20094e4: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED 20094e8: 92 10 00 10 mov %l0, %o1 20094ec: 40 00 0d 58 call 200ca4c <_Thread_queue_Extract> 20094f0: b0 10 20 01 mov 1, %i0 return TRUE; } return FALSE; } 20094f4: 81 c7 e0 08 ret 20094f8: 81 e8 00 00 restore 0201a390 <_Thread_queue_First>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 201a390: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 201a394: 80 a0 60 00 cmp %g1, 0 201a398: 02 80 00 05 be 201a3ac <_Thread_queue_First+0x1c> 201a39c: 80 a0 60 01 cmp %g1, 1 201a3a0: 12 80 00 09 bne 201a3c4 <_Thread_queue_First+0x34> 201a3a4: 01 00 00 00 nop 201a3a8: 30 80 00 04 b,a 201a3b8 <_Thread_queue_First+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); 201a3ac: 82 13 c0 00 mov %o7, %g1 201a3b0: 40 00 02 e7 call 201af4c <_Thread_queue_First_fifo> 201a3b4: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_First_priority( the_thread_queue ); 201a3b8: 82 13 c0 00 mov %o7, %g1 201a3bc: 40 00 00 04 call 201a3cc <_Thread_queue_First_priority> 201a3c0: 9e 10 40 00 mov %g1, %o7 the_thread = NULL; break; } return the_thread; } 201a3c4: 81 c3 e0 08 retl <== NOT EXECUTED 201a3c8: 90 10 20 00 clr %o0 <== NOT EXECUTED 020095a8 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 20095a8: 9d e3 bf 98 save %sp, -104, %sp /* just in case the thread really wasn't blocked here */ if ( !the_thread_queue ) { 20095ac: 80 a6 20 00 cmp %i0, 0 20095b0: 02 80 00 18 be 2009610 <_Thread_queue_Requeue+0x68> 20095b4: 01 00 00 00 nop return; } switch ( the_thread_queue->discipline ) { 20095b8: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 20095bc: 80 a4 20 01 cmp %l0, 1 20095c0: 12 80 00 14 bne 2009610 <_Thread_queue_Requeue+0x68> 20095c4: 01 00 00 00 nop break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; _ISR_Disable( level ); 20095c8: 7f ff e1 de call 2001d40 20095cc: 01 00 00 00 nop 20095d0: a2 10 00 08 mov %o0, %l1 if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 20095d4: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 20095d8: 03 00 00 ef sethi %hi(0x3bc00), %g1 20095dc: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 20095e0: 80 88 80 01 btst %g2, %g1 20095e4: 02 80 00 09 be 2009608 <_Thread_queue_Requeue+0x60> 20095e8: 90 10 00 18 mov %i0, %o0 _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 20095ec: 92 10 00 19 mov %i1, %o1 20095f0: 94 10 20 01 mov 1, %o2 20095f4: 40 00 0d 25 call 200ca88 <_Thread_queue_Extract_priority_helper> 20095f8: e0 26 20 30 st %l0, [ %i0 + 0x30 ] _Thread_queue_Enqueue_priority( tq, the_thread ); 20095fc: 90 10 00 18 mov %i0, %o0 2009600: 7f ff ff 01 call 2009204 <_Thread_queue_Enqueue_priority> 2009604: 92 10 00 19 mov %i1, %o1 } _ISR_Enable( level ); 2009608: 7f ff e1 d2 call 2001d50 200960c: 91 e8 00 11 restore %g0, %l1, %o0 2009610: 81 c7 e0 08 ret <== NOT EXECUTED 2009614: 81 e8 00 00 restore <== NOT EXECUTED 02009618 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 2009618: 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 ) ) { 200961c: 92 96 20 00 orcc %i0, 0, %o1 2009620: 12 80 00 0a bne 2009648 <_Thread_queue_Timeout+0x30> 2009624: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2009628: 03 00 80 5e sethi %hi(0x2017800), %g1 <== NOT EXECUTED 200962c: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2009630: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2009634: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] <== 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; 2009638: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 200963c: d2 00 60 90 ld [ %g1 + 0x90 ], %o1 ! 2017c90 <_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; 2009640: 10 80 00 18 b 20096a0 <_Thread_queue_Timeout+0x88> <== NOT EXECUTED 2009644: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2009648: 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 ) { 200964c: 80 a0 a0 04 cmp %g2, 4 2009650: 18 80 00 0e bgu 2009688 <_Thread_queue_Timeout+0x70> 2009654: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2009658: 83 32 60 1b srl %o1, 0x1b, %g1 200965c: 80 a0 60 01 cmp %g1, 1 2009660: 12 80 00 0a bne 2009688 <_Thread_queue_Timeout+0x70> 2009664: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2009668: 83 28 a0 02 sll %g2, 2, %g1 200966c: 05 00 80 5e sethi %hi(0x2017800), %g2 2009670: 84 10 a3 10 or %g2, 0x310, %g2 ! 2017b10 <_Objects_Information_table> 2009674: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2009678: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 200967c: 80 a2 20 00 cmp %o0, 0 2009680: 12 80 00 05 bne 2009694 <_Thread_queue_Timeout+0x7c> 2009684: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2009688: 92 10 20 00 clr %o1 <== NOT EXECUTED 200968c: 10 80 00 05 b 20096a0 <_Thread_queue_Timeout+0x88> <== NOT EXECUTED 2009690: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2009694: 7f ff f8 1f call 2007710 <_Objects_Get> 2009698: 94 07 bf f4 add %fp, -12, %o2 200969c: 92 10 00 08 mov %o0, %o1 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20096a0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20096a4: 80 a0 60 00 cmp %g1, 0 20096a8: 12 80 00 18 bne 2009708 <_Thread_queue_Timeout+0xf0> 20096ac: 01 00 00 00 nop */ static inline void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 20096b0: c4 02 60 44 ld [ %o1 + 0x44 ], %g2 * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && 20096b4: c6 00 a0 30 ld [ %g2 + 0x30 ], %g3 20096b8: 80 a0 e0 00 cmp %g3, 0 20096bc: 02 80 00 0b be 20096e8 <_Thread_queue_Timeout+0xd0> 20096c0: 03 00 80 5f sethi %hi(0x2017c00), %g1 20096c4: c2 00 60 90 ld [ %g1 + 0x90 ], %g1 ! 2017c90 <_Thread_Executing> <== NOT EXECUTED 20096c8: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED 20096cc: 32 80 00 08 bne,a 20096ec <_Thread_queue_Timeout+0xd4> <== NOT EXECUTED 20096d0: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 20096d4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20096d8: 02 80 00 08 be 20096f8 <_Thread_queue_Timeout+0xe0> <== NOT EXECUTED 20096dc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 20096e0: 10 80 00 06 b 20096f8 <_Thread_queue_Timeout+0xe0> <== NOT EXECUTED 20096e4: c2 20 a0 30 st %g1, [ %g2 + 0x30 ] <== NOT EXECUTED } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 20096e8: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 20096ec: d0 02 60 44 ld [ %o1 + 0x44 ], %o0 20096f0: 40 00 0c d7 call 200ca4c <_Thread_queue_Extract> 20096f4: 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; 20096f8: 05 00 80 5e sethi %hi(0x2017800), %g2 20096fc: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> 2009700: 82 00 7f ff add %g1, -1, %g1 2009704: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 2009708: 81 c7 e0 08 ret 200970c: 81 e8 00 00 restore 02012a18 <_Timer_Server_body>: */ Thread _Timer_Server_body( uint32_t ignored ) { 2012a18: 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; 2012a1c: 03 00 80 c4 sethi %hi(0x2031000), %g1 2012a20: c8 00 61 34 ld [ %g1 + 0x134 ], %g4 ! 2031134 <_Watchdog_Ticks_since_boot> _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2012a24: 03 00 80 c4 sethi %hi(0x2031000), %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2012a28: 07 00 80 c3 sethi %hi(0x2030c00), %g3 2012a2c: da 00 60 6c ld [ %g1 + 0x6c ], %o5 2012a30: c2 00 e3 b0 ld [ %g3 + 0x3b0 ], %g1 /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 2012a34: 05 00 80 c3 sethi %hi(0x2030c00), %g2 2012a38: 82 00 60 01 inc %g1 2012a3c: c8 20 a2 bc st %g4, [ %g2 + 0x2bc ] 2012a40: c2 20 e3 b0 st %g1, [ %g3 + 0x3b0 ] _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2012a44: 03 00 80 c3 sethi %hi(0x2030c00), %g1 2012a48: da 20 62 b8 st %o5, [ %g1 + 0x2b8 ] ! 2030eb8 <_Timer_Server_seconds_last_time> ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012a4c: 03 00 80 c4 sethi %hi(0x2031000), %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2012a50: 27 00 80 c3 sethi %hi(0x2030c00), %l3 2012a54: ba 10 60 b0 or %g1, 0xb0, %i5 2012a58: 82 14 e2 ac or %l3, 0x2ac, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2012a5c: ae 00 60 04 add %g1, 4, %l7 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012a60: 03 00 80 c3 sethi %hi(0x2030c00), %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2012a64: 25 00 80 c3 sethi %hi(0x2030c00), %l2 2012a68: a2 10 62 cc or %g1, 0x2cc, %l1 2012a6c: 82 14 a2 c0 or %l2, 0x2c0, %g1 2012a70: a8 10 00 03 mov %g3, %l4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2012a74: ac 00 60 04 add %g1, 4, %l6 /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 2012a78: 21 00 80 c4 sethi %hi(0x2031000), %l0 _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2012a7c: 03 00 80 c4 sethi %hi(0x2031000), %g1 2012a80: aa 10 60 a4 or %g1, 0xa4, %l5 ! 20310a4 <_Watchdog_Seconds_chain> 2012a84: d0 04 23 68 ld [ %l0 + 0x368 ], %o0 2012a88: 40 00 10 59 call 2016bec <_Thread_Set_state> 2012a8c: 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)); 2012a90: c2 04 e2 ac ld [ %l3 + 0x2ac ], %g1 _Timer_Server_reset_ticks_timer(); 2012a94: 80 a0 40 17 cmp %g1, %l7 2012a98: 22 80 00 09 be,a 2012abc <_Timer_Server_body+0xa4> 2012a9c: c2 04 a2 c0 ld [ %l2 + 0x2c0 ], %g1 2012aa0: d2 04 23 68 ld [ %l0 + 0x368 ], %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012aa4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012aa8: 90 10 00 1d mov %i5, %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012aac: c2 22 60 54 st %g1, [ %o1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012ab0: 40 00 13 0d call 20176e4 <_Watchdog_Insert> 2012ab4: 92 02 60 48 add %o1, 0x48, %o1 2012ab8: c2 04 a2 c0 ld [ %l2 + 0x2c0 ], %g1 _Timer_Server_reset_seconds_timer(); 2012abc: 80 a0 40 16 cmp %g1, %l6 2012ac0: 02 80 00 06 be 2012ad8 <_Timer_Server_body+0xc0> 2012ac4: 92 10 00 11 mov %l1, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012ac8: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED 2012acc: c2 24 60 0c st %g1, [ %l1 + 0xc ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2012ad0: 40 00 13 05 call 20176e4 <_Watchdog_Insert> <== NOT EXECUTED 2012ad4: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); 2012ad8: 7f ff ff c3 call 20129e4 <_Thread_Enable_dispatch> 2012adc: 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(); 2012ae0: d0 04 23 68 ld [ %l0 + 0x368 ], %o0 2012ae4: 40 00 13 58 call 2017844 <_Watchdog_Remove> 2012ae8: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_stop_seconds_timer(); 2012aec: 40 00 13 56 call 2017844 <_Watchdog_Remove> 2012af0: 90 10 00 11 mov %l1, %o0 2012af4: c2 05 23 b0 ld [ %l4 + 0x3b0 ], %g1 2012af8: 82 00 60 01 inc %g1 2012afc: c2 25 23 b0 st %g1, [ %l4 + 0x3b0 ] * 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(); 2012b00: 7f ff ff a7 call 201299c <_Timer_Server_process_ticks_chain> 2012b04: 01 00 00 00 nop _Timer_Server_process_seconds_chain(); 2012b08: 7f ff ff 8d call 201293c <_Timer_Server_process_seconds_chain> 2012b0c: 01 00 00 00 nop /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 2012b10: 10 bf ff de b 2012a88 <_Timer_Server_body+0x70> 2012b14: d0 04 23 68 ld [ %l0 + 0x368 ], %o0 0201299c <_Timer_Server_process_ticks_chain>: void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 201299c: 03 00 80 c4 sethi %hi(0x2031000), %g1 20129a0: c4 00 61 34 ld [ %g1 + 0x134 ], %g2 ! 2031134 <_Watchdog_Ticks_since_boot> if ( snapshot >= _Timer_Server_ticks_last_time ) 20129a4: 03 00 80 c3 sethi %hi(0x2030c00), %g1 20129a8: c2 00 62 bc ld [ %g1 + 0x2bc ], %g1 ! 2030ebc <_Timer_Server_ticks_last_time> 20129ac: 80 a0 80 01 cmp %g2, %g1 20129b0: 1a 80 00 04 bcc 20129c0 <_Timer_Server_process_ticks_chain+0x24> 20129b4: 94 20 80 01 sub %g2, %g1, %o2 ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 20129b8: 82 38 00 01 xnor %g0, %g1, %g1 <== NOT EXECUTED 20129bc: 94 00 40 02 add %g1, %g2, %o2 <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; 20129c0: 03 00 80 c3 sethi %hi(0x2030c00), %g1 _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 20129c4: 11 00 80 c3 sethi %hi(0x2030c00), %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; 20129c8: c4 20 62 bc st %g2, [ %g1 + 0x2bc ] _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 20129cc: 90 12 22 ac or %o0, 0x2ac, %o0 20129d0: 92 10 20 00 clr %o1 20129d4: 82 13 c0 00 mov %o7, %g1 20129d8: 40 00 13 1b call 2017644 <_Watchdog_Adjust> 20129dc: 9e 10 40 00 mov %g1, %o7 20129e0: 01 00 00 00 nop 0200b9ec <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 200b9ec: 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; 200b9f0: 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; 200b9f4: de 06 20 04 ld [ %i0 + 4 ], %o7 right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 200b9f8: 96 10 00 01 mov %g1, %o3 200b9fc: 95 38 60 1f sra %g1, 0x1f, %o2 200ba00: 83 30 60 1d srl %g1, 0x1d, %g1 200ba04: 9b 2a e0 03 sll %o3, 3, %o5 200ba08: 99 2a a0 03 sll %o2, 3, %o4 200ba0c: 98 10 40 0c or %g1, %o4, %o4 200ba10: 83 33 60 1b srl %o5, 0x1b, %g1 200ba14: 85 2b 20 05 sll %o4, 5, %g2 200ba18: 87 2b 60 05 sll %o5, 5, %g3 200ba1c: 84 10 40 02 or %g1, %g2, %g2 200ba20: 86 a0 c0 0d subcc %g3, %o5, %g3 200ba24: 83 30 e0 1a srl %g3, 0x1a, %g1 200ba28: 84 60 80 0c subx %g2, %o4, %g2 200ba2c: 9b 28 e0 06 sll %g3, 6, %o5 200ba30: 99 28 a0 06 sll %g2, 6, %o4 200ba34: 9a a3 40 03 subcc %o5, %g3, %o5 200ba38: 98 10 40 0c or %g1, %o4, %o4 200ba3c: 98 63 00 02 subx %o4, %g2, %o4 200ba40: 9a 83 40 0b addcc %o5, %o3, %o5 200ba44: 83 33 60 1e srl %o5, 0x1e, %g1 200ba48: 98 43 00 0a addx %o4, %o2, %o4 200ba4c: 87 2b 60 02 sll %o5, 2, %g3 200ba50: 85 2b 20 02 sll %o4, 2, %g2 200ba54: 9a 83 40 03 addcc %o5, %g3, %o5 200ba58: 84 10 40 02 or %g1, %g2, %g2 200ba5c: 83 33 60 1e srl %o5, 0x1e, %g1 200ba60: 98 43 00 02 addx %o4, %g2, %o4 200ba64: 87 2b 60 02 sll %o5, 2, %g3 200ba68: 85 2b 20 02 sll %o4, 2, %g2 200ba6c: 9a 83 40 03 addcc %o5, %g3, %o5 200ba70: 84 10 40 02 or %g1, %g2, %g2 200ba74: 83 33 60 1e srl %o5, 0x1e, %g1 200ba78: 98 43 00 02 addx %o4, %g2, %o4 200ba7c: 85 2b 20 02 sll %o4, 2, %g2 200ba80: 84 10 40 02 or %g1, %g2, %g2 right += rhs->tv_nsec; 200ba84: 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; 200ba88: 87 2b 60 02 sll %o5, 2, %g3 200ba8c: 9a 83 40 03 addcc %o5, %g3, %o5 right += rhs->tv_nsec; 200ba90: 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; 200ba94: 98 43 00 02 addx %o4, %g2, %o4 200ba98: 89 33 60 17 srl %o5, 0x17, %g4 200ba9c: 85 2b 20 09 sll %o4, 9, %g2 200baa0: 87 2b 60 09 sll %o5, 9, %g3 200baa4: 84 11 00 02 or %g4, %g2, %g2 right += rhs->tv_nsec; 200baa8: 96 80 c0 01 addcc %g3, %g1, %o3 200baac: 94 40 80 0a addx %g2, %o2, %o2 if ( right == 0 ) { 200bab0: 80 92 80 0b orcc %o2, %o3, %g0 200bab4: 12 80 00 06 bne 200bacc <_Timespec_Divide+0xe0> 200bab8: f0 06 00 00 ld [ %i0 ], %i0 *ival_percentage = 0; 200babc: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED *fval_percentage = 0; 200bac0: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 200bac4: 81 c7 e0 08 ret <== NOT EXECUTED 200bac8: 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; 200bacc: 83 36 20 1d srl %i0, 0x1d, %g1 200bad0: 9b 2e 20 03 sll %i0, 3, %o5 200bad4: 91 3e 20 1f sra %i0, 0x1f, %o0 200bad8: 99 2a 20 03 sll %o0, 3, %o4 200badc: 98 10 40 0c or %g1, %o4, %o4 200bae0: 83 33 60 1b srl %o5, 0x1b, %g1 200bae4: 85 2b 20 05 sll %o4, 5, %g2 200bae8: 87 2b 60 05 sll %o5, 5, %g3 200baec: 84 10 40 02 or %g1, %g2, %g2 200baf0: 86 a0 c0 0d subcc %g3, %o5, %g3 200baf4: 83 30 e0 1a srl %g3, 0x1a, %g1 200baf8: 84 60 80 0c subx %g2, %o4, %g2 200bafc: 9b 28 e0 06 sll %g3, 6, %o5 200bb00: 99 28 a0 06 sll %g2, 6, %o4 200bb04: 9a a3 40 03 subcc %o5, %g3, %o5 200bb08: 98 10 40 0c or %g1, %o4, %o4 200bb0c: 98 63 00 02 subx %o4, %g2, %o4 200bb10: 9a 83 40 18 addcc %o5, %i0, %o5 200bb14: 83 33 60 1e srl %o5, 0x1e, %g1 200bb18: 98 43 00 08 addx %o4, %o0, %o4 200bb1c: 87 2b 60 02 sll %o5, 2, %g3 200bb20: 85 2b 20 02 sll %o4, 2, %g2 200bb24: 9a 83 40 03 addcc %o5, %g3, %o5 200bb28: 84 10 40 02 or %g1, %g2, %g2 200bb2c: 83 33 60 1e srl %o5, 0x1e, %g1 200bb30: 98 43 00 02 addx %o4, %g2, %o4 200bb34: 87 2b 60 02 sll %o5, 2, %g3 200bb38: 85 2b 20 02 sll %o4, 2, %g2 200bb3c: 9a 83 40 03 addcc %o5, %g3, %o5 200bb40: 84 10 40 02 or %g1, %g2, %g2 200bb44: 83 33 60 1e srl %o5, 0x1e, %g1 200bb48: 98 43 00 02 addx %o4, %g2, %o4 200bb4c: 87 2b 60 02 sll %o5, 2, %g3 200bb50: 85 2b 20 02 sll %o4, 2, %g2 200bb54: 9a 83 40 03 addcc %o5, %g3, %o5 200bb58: 84 10 40 02 or %g1, %g2, %g2 200bb5c: 83 33 60 17 srl %o5, 0x17, %g1 200bb60: 98 43 00 02 addx %o4, %g2, %o4 200bb64: 93 2b 60 09 sll %o5, 9, %o1 200bb68: 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; 200bb6c: 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; 200bb70: 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; 200bb74: 83 32 60 1e srl %o1, 0x1e, %g1 200bb78: a1 3b e0 1f sra %o7, 0x1f, %l0 200bb7c: 87 2a 60 02 sll %o1, 2, %g3 200bb80: 90 42 00 10 addx %o0, %l0, %o0 200bb84: 85 2a 20 02 sll %o0, 2, %g2 200bb88: 84 10 40 02 or %g1, %g2, %g2 200bb8c: 83 30 e0 1b srl %g3, 0x1b, %g1 200bb90: 99 28 a0 05 sll %g2, 5, %o4 200bb94: 9b 28 e0 05 sll %g3, 5, %o5 200bb98: 98 10 40 0c or %g1, %o4, %o4 200bb9c: 9a a3 40 03 subcc %o5, %g3, %o5 200bba0: 98 63 00 02 subx %o4, %g2, %o4 200bba4: 9a 83 40 09 addcc %o5, %o1, %o5 200bba8: 83 33 60 1e srl %o5, 0x1e, %g1 200bbac: 98 43 00 08 addx %o4, %o0, %o4 200bbb0: 87 2b 60 02 sll %o5, 2, %g3 200bbb4: 85 2b 20 02 sll %o4, 2, %g2 200bbb8: 9a 83 40 03 addcc %o5, %g3, %o5 200bbbc: 84 10 40 02 or %g1, %g2, %g2 200bbc0: 83 33 60 1e srl %o5, 0x1e, %g1 200bbc4: 87 2b 60 02 sll %o5, 2, %g3 200bbc8: 98 43 00 02 addx %o4, %g2, %o4 200bbcc: 9a 83 40 03 addcc %o5, %g3, %o5 200bbd0: 85 2b 20 02 sll %o4, 2, %g2 200bbd4: 84 10 40 02 or %g1, %g2, %g2 200bbd8: 83 33 60 1b srl %o5, 0x1b, %g1 200bbdc: 98 43 00 02 addx %o4, %g2, %o4 200bbe0: 93 2b 60 05 sll %o5, 5, %o1 200bbe4: 91 2b 20 05 sll %o4, 5, %o0 200bbe8: 40 00 32 26 call 2018480 <__udivdi3> 200bbec: 90 10 40 08 or %g1, %o0, %o0 *ival_percentage = answer / 1000; 200bbf0: 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; 200bbf4: a0 10 00 08 mov %o0, %l0 200bbf8: a2 10 00 09 mov %o1, %l1 *ival_percentage = answer / 1000; 200bbfc: 96 10 23 e8 mov 0x3e8, %o3 200bc00: 40 00 32 20 call 2018480 <__udivdi3> 200bc04: 90 10 00 10 mov %l0, %o0 *fval_percentage = answer % 1000; 200bc08: 90 10 00 10 mov %l0, %o0 * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 200bc0c: d2 26 80 00 st %o1, [ %i2 ] *fval_percentage = answer % 1000; 200bc10: 94 10 20 00 clr %o2 200bc14: 92 10 00 11 mov %l1, %o1 200bc18: 40 00 32 f9 call 20187fc <__umoddi3> 200bc1c: 96 10 23 e8 mov 0x3e8, %o3 200bc20: d2 26 c0 00 st %o1, [ %i3 ] 200bc24: 81 c7 e0 08 ret 200bc28: 81 e8 00 00 restore 020139dc <_Timespec_From_ticks>: void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 20139dc: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 20139e0: 03 00 80 99 sethi %hi(0x2026400), %g1 <== NOT EXECUTED 20139e4: d2 00 62 5c ld [ %g1 + 0x25c ], %o1 ! 202665c <_TOD_Microseconds_per_tick> <== NOT EXECUTED 20139e8: 40 00 2e 69 call 201f38c <.umul> <== NOT EXECUTED 20139ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 20139f0: 21 00 03 d0 sethi %hi(0xf4000), %l0 <== NOT EXECUTED struct timespec *time ) { uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 20139f4: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 20139f8: 7f ff b7 60 call 2001778 <.udiv> <== NOT EXECUTED 20139fc: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 2013a00: 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; 2013a04: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 2013a08: 40 00 2e 9b call 201f474 <.urem> <== NOT EXECUTED 2013a0c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2013a10: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED 2013a14: 83 2a 20 07 sll %o0, 7, %g1 <== NOT EXECUTED 2013a18: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 2013a1c: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 2013a20: 83 28 60 03 sll %g1, 3, %g1 <== NOT EXECUTED 2013a24: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 2013a28: 81 c7 e0 08 ret <== NOT EXECUTED 2013a2c: 81 e8 00 00 restore <== NOT EXECUTED 02013a30 <_Timespec_Is_valid>: boolean _Timespec_Is_valid( const struct timespec *time ) { if ( !time ) 2013a30: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2013a34: 02 80 00 0e be 2013a6c <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 2013a38: 01 00 00 00 nop <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) 2013a3c: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 2013a40: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2013a44: 06 80 00 0a bl 2013a6c <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 2013a48: 01 00 00 00 nop <== NOT EXECUTED return FALSE; if ( time->tv_nsec < 0 ) 2013a4c: d0 02 20 04 ld [ %o0 + 4 ], %o0 <== NOT EXECUTED 2013a50: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2013a54: 06 80 00 06 bl 2013a6c <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 2013a58: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 <== NOT EXECUTED 2013a5c: 82 10 61 ff or %g1, 0x1ff, %g1 ! 3b9ac9ff <== NOT EXECUTED 2013a60: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED 2013a64: 81 c3 e0 08 retl <== NOT EXECUTED 2013a68: 90 60 3f ff subx %g0, -1, %o0 <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 2013a6c: 81 c3 e0 08 retl <== NOT EXECUTED 2013a70: 90 10 20 00 clr %o0 <== NOT EXECUTED 02013a74 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 2013a74: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 2013a78: e0 06 00 00 ld [ %i0 ], %l0 <== NOT EXECUTED 2013a7c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2013a80: 12 80 00 06 bne 2013a98 <_Timespec_To_ticks+0x24> <== NOT EXECUTED 2013a84: a4 10 00 18 mov %i0, %l2 <== NOT EXECUTED 2013a88: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 2013a8c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2013a90: 02 80 00 13 be 2013adc <_Timespec_To_ticks+0x68> <== NOT EXECUTED 2013a94: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 2013a98: 03 00 80 99 sethi %hi(0x2026400), %g1 <== NOT EXECUTED 2013a9c: e2 00 62 5c ld [ %g1 + 0x25c ], %l1 ! 202665c <_TOD_Microseconds_per_tick> <== NOT EXECUTED 2013aa0: 11 00 03 d0 sethi %hi(0xf4000), %o0 <== NOT EXECUTED 2013aa4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2013aa8: 7f ff b7 34 call 2001778 <.udiv> <== NOT EXECUTED 2013aac: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED 2013ab0: 40 00 2e 37 call 201f38c <.umul> <== NOT EXECUTED 2013ab4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2013ab8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 2013abc: d0 04 a0 04 ld [ %l2 + 4 ], %o0 <== NOT EXECUTED 2013ac0: 7f ff b7 2e call 2001778 <.udiv> <== NOT EXECUTED 2013ac4: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED 2013ac8: 7f ff b7 2c call 2001778 <.udiv> <== NOT EXECUTED 2013acc: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED _TOD_Microseconds_per_tick; if (ticks) 2013ad0: b0 82 00 10 addcc %o0, %l0, %i0 <== NOT EXECUTED 2013ad4: 22 80 00 02 be,a 2013adc <_Timespec_To_ticks+0x68> <== NOT EXECUTED 2013ad8: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED return ticks; return 1; } 2013adc: 81 c7 e0 08 ret <== NOT EXECUTED 2013ae0: 81 e8 00 00 restore <== NOT EXECUTED 0200cd40 <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 200cd40: 9d e3 bf 98 save %sp, -104, %sp _Chain_Append( &_User_extensions_List, &the_extension->Node ); 200cd44: 11 00 80 5f sethi %hi(0x2017c00), %o0 200cd48: 92 10 00 18 mov %i0, %o1 200cd4c: 7f ff e6 98 call 20067ac <_Chain_Append> 200cd50: 90 12 22 34 or %o0, 0x234, %o0 /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 200cd54: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 200cd58: 80 a0 60 00 cmp %g1, 0 200cd5c: 02 80 00 06 be 200cd74 <_User_extensions_Add_API_set+0x34> 200cd60: b2 06 20 08 add %i0, 8, %i1 the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 200cd64: c2 26 20 10 st %g1, [ %i0 + 0x10 ] _Chain_Append( 200cd68: 31 00 80 5e sethi %hi(0x2017800), %i0 200cd6c: 7f ff e6 90 call 20067ac <_Chain_Append> 200cd70: 91 ee 23 b4 restore %i0, 0x3b4, %o0 200cd74: 81 c7 e0 08 ret <== NOT EXECUTED 200cd78: 81 e8 00 00 restore <== NOT EXECUTED 02009db0 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, boolean is_internal, uint32_t the_error ) { 2009db0: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 2009db4: 03 00 80 5f sethi %hi(0x2017c00), %g1 2009db8: 82 10 62 34 or %g1, 0x234, %g1 ! 2017e34 <_User_extensions_List> 2009dbc: e0 00 60 08 ld [ %g1 + 8 ], %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 2009dc0: 10 80 00 09 b 2009de4 <_User_extensions_Fatal+0x34> 2009dc4: a2 10 00 01 mov %g1, %l1 !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 2009dc8: 80 a0 60 00 cmp %g1, 0 2009dcc: 02 80 00 05 be 2009de0 <_User_extensions_Fatal+0x30> 2009dd0: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 2009dd4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2009dd8: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009ddc: 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 ) { 2009de0: 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 ) ; 2009de4: 80 a4 00 11 cmp %l0, %l1 2009de8: 32 bf ff f8 bne,a 2009dc8 <_User_extensions_Fatal+0x18> 2009dec: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 2009df0: 81 c7 e0 08 ret 2009df4: 81 e8 00 00 restore 0200e668 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 200e668: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 200e66c: 40 00 11 c2 call 2012d74 <_Chain_Extract> <== NOT EXECUTED 200e670: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 200e674: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED 200e678: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200e67c: 02 80 00 04 be 200e68c <_User_extensions_Remove_set+0x24> <== NOT EXECUTED 200e680: 01 00 00 00 nop <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 200e684: 40 00 11 bc call 2012d74 <_Chain_Extract> <== NOT EXECUTED 200e688: 91 ee 20 08 restore %i0, 8, %o0 <== NOT EXECUTED 200e68c: 81 c7 e0 08 ret <== NOT EXECUTED 200e690: 81 e8 00 00 restore <== NOT EXECUTED 02009f68 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 2009f68: 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; 2009f6c: 03 00 80 5f sethi %hi(0x2017c00), %g1 void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 2009f70: aa 10 00 18 mov %i0, %l5 Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 2009f74: e6 00 60 78 ld [ %g1 + 0x78 ], %l3 _ISR_Disable( level ); 2009f78: 7f ff df 72 call 2001d40 2009f7c: 01 00 00 00 nop 2009f80: 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 ) { 2009f84: c2 06 60 08 ld [ %i1 + 8 ], %g1 2009f88: 80 a0 60 00 cmp %g1, 0 2009f8c: 02 80 00 03 be 2009f98 <_Watchdog_Insert+0x30> 2009f90: 03 00 80 5f sethi %hi(0x2017c00), %g1 _ISR_Enable( level ); 2009f94: 30 80 00 37 b,a 200a070 <_Watchdog_Insert+0x108> <== NOT EXECUTED return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 2009f98: c4 00 61 30 ld [ %g1 + 0x130 ], %g2 ! 2017d30 <_Watchdog_Sync_count> if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 2009f9c: 86 10 20 01 mov 1, %g3 _Watchdog_Sync_count++; 2009fa0: 84 00 a0 01 inc %g2 if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 2009fa4: c6 26 60 08 st %g3, [ %i1 + 8 ] _Watchdog_Sync_count++; 2009fa8: c4 20 61 30 st %g2, [ %g1 + 0x130 ] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 2009fac: 29 00 80 5f sethi %hi(0x2017c00), %l4 the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 2009fb0: 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 ; 2009fb4: e2 05 40 00 ld [ %l5 ], %l1 ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 2009fb8: 80 a4 a0 00 cmp %l2, 0 2009fbc: 22 80 00 1c be,a 200a02c <_Watchdog_Insert+0xc4> 2009fc0: c4 04 60 04 ld [ %l1 + 4 ], %g2 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 2009fc4: c2 04 40 00 ld [ %l1 ], %g1 2009fc8: 80 a0 60 00 cmp %g1, 0 2009fcc: 22 80 00 18 be,a 200a02c <_Watchdog_Insert+0xc4> 2009fd0: c4 04 60 04 ld [ %l1 + 4 ], %g2 break; if ( delta_interval < after->delta_interval ) { 2009fd4: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 2009fd8: 80 a4 80 10 cmp %l2, %l0 2009fdc: 1a 80 00 04 bcc 2009fec <_Watchdog_Insert+0x84> 2009fe0: 82 24 00 12 sub %l0, %l2, %g1 after->delta_interval -= delta_interval; 2009fe4: 10 80 00 11 b 200a028 <_Watchdog_Insert+0xc0> 2009fe8: c2 24 60 10 st %g1, [ %l1 + 0x10 ] * used around this flash point allowed interrupts to execute * which violated the design assumptions. The critical section * mechanism used here WAS redesigned to address this. */ _ISR_Flash( level ); 2009fec: 7f ff df 59 call 2001d50 2009ff0: 90 10 00 18 mov %i0, %o0 2009ff4: 7f ff df 53 call 2001d40 2009ff8: 01 00 00 00 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 2009ffc: c2 06 60 08 ld [ %i1 + 8 ], %g1 200a000: 80 a0 60 01 cmp %g1, 1 200a004: 12 80 00 15 bne 200a058 <_Watchdog_Insert+0xf0> 200a008: a4 24 80 10 sub %l2, %l0, %l2 goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 200a00c: c2 05 20 8c ld [ %l4 + 0x8c ], %g1 200a010: 80 a0 40 13 cmp %g1, %l3 200a014: 28 bf ff e9 bleu,a 2009fb8 <_Watchdog_Insert+0x50> 200a018: e2 04 40 00 ld [ %l1 ], %l1 _Watchdog_Sync_level = insert_isr_nest_level; 200a01c: e6 25 20 8c st %l3, [ %l4 + 0x8c ] the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 200a020: 10 bf ff e5 b 2009fb4 <_Watchdog_Insert+0x4c> 200a024: e4 06 60 0c ld [ %i1 + 0xc ], %l2 _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 200a028: c4 04 60 04 ld [ %l1 + 4 ], %g2 the_watchdog->start_time = _Watchdog_Ticks_since_boot; 200a02c: 03 00 80 5f sethi %hi(0x2017c00), %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 200a030: c6 00 80 00 ld [ %g2 ], %g3 200a034: c2 00 61 34 ld [ %g1 + 0x134 ], %g1 after_node->next = the_node; 200a038: f2 20 80 00 st %i1, [ %g2 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 200a03c: c4 26 60 04 st %g2, [ %i1 + 4 ] 200a040: c2 26 60 14 st %g1, [ %i1 + 0x14 ] } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 200a044: e4 26 60 10 st %l2, [ %i1 + 0x10 ] RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 200a048: 82 10 20 02 mov 2, %g1 before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; before_node->previous = the_node; 200a04c: f2 20 e0 04 st %i1, [ %g3 + 4 ] Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 200a050: c6 26 40 00 st %g3, [ %i1 ] 200a054: c2 26 60 08 st %g1, [ %i1 + 8 ] _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 200a058: 03 00 80 5f sethi %hi(0x2017c00), %g1 _Watchdog_Sync_count--; 200a05c: 05 00 80 5f sethi %hi(0x2017c00), %g2 _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 200a060: e6 20 60 8c st %l3, [ %g1 + 0x8c ] _Watchdog_Sync_count--; 200a064: c2 00 a1 30 ld [ %g2 + 0x130 ], %g1 200a068: 82 00 7f ff add %g1, -1, %g1 200a06c: c2 20 a1 30 st %g1, [ %g2 + 0x130 ] _ISR_Enable( level ); 200a070: 7f ff df 38 call 2001d50 200a074: 81 e8 00 00 restore 200a078: 01 00 00 00 nop 0200a0c8 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 200a0c8: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 200a0cc: 7f ff df 1d call 2001d40 200a0d0: 01 00 00 00 nop previous_state = the_watchdog->state; 200a0d4: e0 06 20 08 ld [ %i0 + 8 ], %l0 switch ( previous_state ) { 200a0d8: 80 a4 20 01 cmp %l0, 1 200a0dc: 22 80 00 1e be,a 200a154 <_Watchdog_Remove+0x8c> 200a0e0: c0 26 20 08 clr [ %i0 + 8 ] <== NOT EXECUTED 200a0e4: 0a 80 00 1d bcs 200a158 <_Watchdog_Remove+0x90> 200a0e8: 03 00 80 5f sethi %hi(0x2017c00), %g1 200a0ec: 80 a4 20 03 cmp %l0, 3 200a0f0: 18 80 00 1a bgu 200a158 <_Watchdog_Remove+0x90> 200a0f4: 01 00 00 00 nop 200a0f8: c6 06 00 00 ld [ %i0 ], %g3 break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 200a0fc: c0 26 20 08 clr [ %i0 + 8 ] next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 200a100: c2 00 c0 00 ld [ %g3 ], %g1 200a104: 80 a0 60 00 cmp %g1, 0 200a108: 02 80 00 07 be 200a124 <_Watchdog_Remove+0x5c> 200a10c: 03 00 80 5f sethi %hi(0x2017c00), %g1 next_watchdog->delta_interval += the_watchdog->delta_interval; 200a110: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1 200a114: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 200a118: 82 00 40 02 add %g1, %g2, %g1 200a11c: c2 20 e0 10 st %g1, [ %g3 + 0x10 ] if ( _Watchdog_Sync_count ) 200a120: 03 00 80 5f sethi %hi(0x2017c00), %g1 200a124: c2 00 61 30 ld [ %g1 + 0x130 ], %g1 ! 2017d30 <_Watchdog_Sync_count> 200a128: 80 a0 60 00 cmp %g1, 0 200a12c: 22 80 00 07 be,a 200a148 <_Watchdog_Remove+0x80> 200a130: c4 06 00 00 ld [ %i0 ], %g2 _Watchdog_Sync_level = _ISR_Nest_level; 200a134: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 200a138: c4 00 60 78 ld [ %g1 + 0x78 ], %g2 ! 2017c78 <_ISR_Nest_level> <== NOT EXECUTED 200a13c: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 200a140: c4 20 60 8c st %g2, [ %g1 + 0x8c ] ! 2017c8c <_Watchdog_Sync_level> <== NOT EXECUTED ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 200a144: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED previous = the_node->previous; 200a148: c2 06 20 04 ld [ %i0 + 4 ], %g1 next->previous = previous; previous->next = next; 200a14c: c4 20 40 00 st %g2, [ %g1 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200a150: c2 20 a0 04 st %g1, [ %g2 + 4 ] _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200a154: 03 00 80 5f sethi %hi(0x2017c00), %g1 200a158: c2 00 61 34 ld [ %g1 + 0x134 ], %g1 ! 2017d34 <_Watchdog_Ticks_since_boot> 200a15c: c2 26 20 18 st %g1, [ %i0 + 0x18 ] _ISR_Enable( level ); 200a160: 7f ff de fc call 2001d50 200a164: b0 10 00 10 mov %l0, %i0 return( previous_state ); } 200a168: 81 c7 e0 08 ret 200a16c: 81 e8 00 00 restore 0200a214 <_Workspace_Allocate_or_fatal_error>: */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 200a214: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 200a218: 11 00 80 5e sethi %hi(0x2017800), %o0 200a21c: 92 10 00 18 mov %i0, %o1 200a220: 7f ff f2 a0 call 2006ca0 <_Heap_Allocate> 200a224: 90 12 23 fc or %o0, 0x3fc, %o0 void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 200a228: b0 92 20 00 orcc %o0, 0, %i0 200a22c: 12 80 00 04 bne 200a23c <_Workspace_Allocate_or_fatal_error+0x28> 200a230: 92 10 20 01 mov 1, %o1 _Internal_error_Occurred( 200a234: 7f ff f3 c6 call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 200a238: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 200a23c: 81 c7 e0 08 ret 200a240: 81 e8 00 00 restore 0200a244 <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 200a244: 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 ) ) 200a248: 80 a6 20 00 cmp %i0, 0 200a24c: 02 80 00 04 be 200a25c <_Workspace_Handler_initialization+0x18> 200a250: 80 8e 20 07 btst 7, %i0 200a254: 02 80 00 07 be 200a270 <_Workspace_Handler_initialization+0x2c> 200a258: 03 00 80 5e sethi %hi(0x2017800), %g1 _Internal_error_Occurred( 200a25c: 90 10 20 00 clr %o0 <== NOT EXECUTED 200a260: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 200a264: 7f ff f3 ba call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 200a268: 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 ) { 200a26c: 03 00 80 5e sethi %hi(0x2017800), %g1 <== NOT EXECUTED 200a270: c2 00 63 d4 ld [ %g1 + 0x3d4 ], %g1 ! 2017bd4 <_CPU_Table+0x10> 200a274: 84 10 20 00 clr %g2 200a278: 80 a0 60 00 cmp %g1, 0 200a27c: 12 80 00 06 bne 200a294 <_Workspace_Handler_initialization+0x50> 200a280: 87 36 60 02 srl %i1, 2, %g3 index < size / sizeof( uint32_t ) ; index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 200a284: 10 80 00 08 b 200a2a4 <_Workspace_Handler_initialization+0x60> 200a288: 92 10 00 18 mov %i0, %o1 ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; index++ ) 200a28c: 84 00 a0 01 inc %g2 <== NOT EXECUTED zero_out_array[ index ] = 0; 200a290: c0 20 40 18 clr [ %g1 + %i0 ] <== NOT EXECUTED INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; 200a294: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED 200a298: 0a bf ff fd bcs 200a28c <_Workspace_Handler_initialization+0x48> <== NOT EXECUTED 200a29c: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 200a2a0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200a2a4: 94 10 00 19 mov %i1, %o2 200a2a8: 11 00 80 5e sethi %hi(0x2017800), %o0 200a2ac: 96 10 20 08 mov 8, %o3 200a2b0: 7f ff f3 5d call 2007024 <_Heap_Initialize> 200a2b4: 90 12 23 fc or %o0, 0x3fc, %o0 starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 200a2b8: 80 a2 20 00 cmp %o0, 0 200a2bc: 12 80 00 05 bne 200a2d0 <_Workspace_Handler_initialization+0x8c> 200a2c0: b0 10 20 00 clr %i0 _Internal_error_Occurred( 200a2c4: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED 200a2c8: 7f ff f3 a1 call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 200a2cc: 95 e8 20 03 restore %g0, 3, %o2 <== NOT EXECUTED 200a2d0: 81 c7 e0 08 ret 200a2d4: 81 e8 00 00 restore 02005d3c : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 2005d3c: 9d e3 bf 90 save %sp, -112, %sp Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 2005d40: a2 96 20 00 orcc %i0, 0, %l1 2005d44: 02 80 00 1b be 2005db0 2005d48: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2005d4c: 80 a6 e0 00 cmp %i3, 0 2005d50: 02 80 00 18 be 2005db0 2005d54: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 2005d58: 80 8e 60 10 btst 0x10, %i1 2005d5c: 02 80 00 06 be 2005d74 2005d60: 80 a6 a0 00 cmp %i2, 0 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 2005d64: 02 80 00 13 be 2005db0 2005d68: 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; 2005d6c: 10 80 00 04 b 2005d7c 2005d70: c0 27 bf f0 clr [ %fp + -16 ] if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 2005d74: 82 10 20 01 mov 1, %g1 2005d78: c2 27 bf f0 st %g1, [ %fp + -16 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005d7c: 05 00 80 6e sethi %hi(0x201b800), %g2 2005d80: c2 00 a2 e0 ld [ %g2 + 0x2e0 ], %g1 ! 201bae0 <_Thread_Dispatch_disable_level> the_attributes.maximum_count = maximum_waiters; 2005d84: f4 27 bf f4 st %i2, [ %fp + -12 ] 2005d88: 82 00 60 01 inc %g1 2005d8c: c2 20 a2 e0 st %g1, [ %g2 + 0x2e0 ] * 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 ); 2005d90: 21 00 80 6e sethi %hi(0x201b800), %l0 2005d94: 40 00 09 d4 call 20084e4 <_Objects_Allocate> 2005d98: 90 14 21 40 or %l0, 0x140, %o0 ! 201b940 <_Barrier_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 2005d9c: b4 92 20 00 orcc %o0, 0, %i2 2005da0: 12 80 00 06 bne 2005db8 2005da4: 90 06 a0 14 add %i2, 0x14, %o0 _Thread_Enable_dispatch(); 2005da8: 7f ff ff d8 call 2005d08 <_Thread_Enable_dispatch> 2005dac: b0 10 20 05 mov 5, %i0 2005db0: 81 c7 e0 08 ret 2005db4: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 2005db8: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 2005dbc: 40 00 07 16 call 2007a14 <_CORE_barrier_Initialize> 2005dc0: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005dc4: 90 14 21 40 or %l0, 0x140, %o0 Objects_Name name ) { uint32_t index; index = _Objects_Get_index( the_object->id ); 2005dc8: c6 06 a0 08 ld [ %i2 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005dcc: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2005dd0: 03 00 00 3f sethi %hi(0xfc00), %g1 2005dd4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005dd8: 82 08 c0 01 and %g3, %g1, %g1 2005ddc: 80 a0 40 02 cmp %g1, %g2 2005de0: 38 80 00 06 bgu,a 2005df8 2005de4: e2 26 a0 0c st %l1, [ %i2 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005de8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005dec: 83 28 60 02 sll %g1, 2, %g1 2005df0: 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; 2005df4: e2 26 a0 0c st %l1, [ %i2 + 0xc ] &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 2005df8: c6 26 c0 00 st %g3, [ %i3 ] _Thread_Enable_dispatch(); 2005dfc: 7f ff ff c3 call 2005d08 <_Thread_Enable_dispatch> 2005e00: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 2005e04: 81 c7 e0 08 ret 2005e08: 81 e8 00 00 restore 02005e0c : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 2005e0c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 2005e10: 21 00 80 6e sethi %hi(0x201b800), %l0 2005e14: 92 10 00 18 mov %i0, %o1 2005e18: 94 07 bf f4 add %fp, -12, %o2 2005e1c: 40 00 0a f6 call 20089f4 <_Objects_Get> 2005e20: 90 14 21 40 or %l0, 0x140, %o0 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2005e24: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005e28: 80 a0 60 00 cmp %g1, 0 2005e2c: 02 80 00 07 be 2005e48 2005e30: b0 10 00 08 mov %o0, %i0 2005e34: 80 a0 60 02 cmp %g1, 2 2005e38: 08 80 00 22 bleu 2005ec0 2005e3c: b0 10 20 04 mov 4, %i0 2005e40: 81 c7 e0 08 ret <== NOT EXECUTED 2005e44: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Flush( 2005e48: 90 02 20 14 add %o0, 0x14, %o0 2005e4c: 92 10 20 00 clr %o1 2005e50: 40 00 12 64 call 200a7e0 <_Thread_queue_Flush> 2005e54: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005e58: 90 14 21 40 or %l0, 0x140, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2005e5c: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005e60: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005e64: 05 00 00 3f sethi %hi(0xfc00), %g2 2005e68: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2005e6c: 82 08 40 02 and %g1, %g2, %g1 2005e70: 80 a0 40 03 cmp %g1, %g3 2005e74: 38 80 00 06 bgu,a 2005e8c 2005e78: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005e7c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005e80: 83 28 60 02 sll %g1, 2, %g1 2005e84: 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; 2005e88: c0 26 20 0c clr [ %i0 + 0xc ] */ RTEMS_INLINE_ROUTINE void _Barrier_Free ( Barrier_Control *the_barrier ) { _Objects_Free( &_Barrier_Information, &the_barrier->Object ); 2005e8c: 40 00 0a 98 call 20088ec <_Objects_Free> 2005e90: 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 ) 2005e94: 03 00 80 6e sethi %hi(0x201b800), %g1 2005e98: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 201bae0 <_Thread_Dispatch_disable_level> 2005e9c: b0 10 20 00 clr %i0 2005ea0: 84 00 bf ff add %g2, -1, %g2 2005ea4: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ] 2005ea8: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 2005eac: 80 a0 60 00 cmp %g1, 0 2005eb0: 12 80 00 04 bne 2005ec0 2005eb4: 01 00 00 00 nop _Thread_Dispatch(); 2005eb8: 40 00 0f d4 call 2009e08 <_Thread_Dispatch> 2005ebc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005ec0: 81 c7 e0 08 ret 2005ec4: 81 e8 00 00 restore 02005f00 : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 2005f00: 9d e3 bf 90 save %sp, -112, %sp 2005f04: a0 10 00 18 mov %i0, %l0 Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 2005f08: 80 a6 60 00 cmp %i1, 0 2005f0c: 02 80 00 1f be 2005f88 2005f10: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 2005f14: 11 00 80 6e sethi %hi(0x201b800), %o0 2005f18: 92 10 00 10 mov %l0, %o1 2005f1c: 90 12 21 40 or %o0, 0x140, %o0 2005f20: 40 00 0a b5 call 20089f4 <_Objects_Get> 2005f24: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2005f28: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005f2c: 80 a0 60 00 cmp %g1, 0 2005f30: 02 80 00 07 be 2005f4c 2005f34: 92 10 00 10 mov %l0, %o1 2005f38: 80 a0 60 02 cmp %g1, 2 2005f3c: 08 80 00 13 bleu 2005f88 2005f40: b0 10 20 04 mov 4, %i0 2005f44: 81 c7 e0 08 ret <== NOT EXECUTED 2005f48: 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 ); 2005f4c: 94 10 20 00 clr %o2 2005f50: 40 00 06 bd call 2007a44 <_CORE_barrier_Release> 2005f54: 90 02 20 14 add %o0, 0x14, %o0 2005f58: 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 ) 2005f5c: 03 00 80 6e sethi %hi(0x201b800), %g1 2005f60: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 201bae0 <_Thread_Dispatch_disable_level> 2005f64: b0 10 20 00 clr %i0 2005f68: 84 00 bf ff add %g2, -1, %g2 2005f6c: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ] 2005f70: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 2005f74: 80 a0 60 00 cmp %g1, 0 2005f78: 12 80 00 04 bne 2005f88 2005f7c: 01 00 00 00 nop _Thread_Dispatch(); 2005f80: 40 00 0f a2 call 2009e08 <_Thread_Dispatch> 2005f84: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005f88: 81 c7 e0 08 ret 2005f8c: 81 e8 00 00 restore 02005f90 : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 2005f90: 9d e3 bf 90 save %sp, -112, %sp 2005f94: 11 00 80 6e sethi %hi(0x201b800), %o0 2005f98: 92 10 00 18 mov %i0, %o1 2005f9c: 90 12 21 40 or %o0, 0x140, %o0 2005fa0: 40 00 0a 95 call 20089f4 <_Objects_Get> 2005fa4: 94 07 bf f4 add %fp, -12, %o2 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2005fa8: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005fac: 80 a0 60 00 cmp %g1, 0 2005fb0: 02 80 00 07 be 2005fcc 2005fb4: 96 10 00 19 mov %i1, %o3 2005fb8: 80 a0 60 02 cmp %g1, 2 2005fbc: 08 80 00 17 bleu 2006018 2005fc0: 90 10 20 04 mov 4, %o0 2005fc4: 10 80 00 15 b 2006018 <== NOT EXECUTED 2005fc8: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Wait( 2005fcc: 90 02 20 14 add %o0, 0x14, %o0 2005fd0: 92 10 00 18 mov %i0, %o1 2005fd4: 94 10 20 01 mov 1, %o2 2005fd8: 40 00 06 a6 call 2007a70 <_CORE_barrier_Wait> 2005fdc: 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 ) 2005fe0: 03 00 80 6e sethi %hi(0x201b800), %g1 2005fe4: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 201bae0 <_Thread_Dispatch_disable_level> 2005fe8: 84 00 bf ff add %g2, -1, %g2 2005fec: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ] 2005ff0: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 2005ff4: 80 a0 60 00 cmp %g1, 0 2005ff8: 12 80 00 05 bne 200600c 2005ffc: 03 00 80 6e sethi %hi(0x201b800), %g1 _Thread_Dispatch(); 2006000: 40 00 0f 82 call 2009e08 <_Thread_Dispatch> 2006004: 01 00 00 00 nop TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 2006008: 03 00 80 6e sethi %hi(0x201b800), %g1 200600c: c2 00 63 c0 ld [ %g1 + 0x3c0 ], %g1 ! 201bbc0 <_Thread_Executing> 2006010: 40 00 1c ab call 200d2bc <_Barrier_Translate_core_barrier_return_code> 2006014: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006018: 81 c7 e0 08 ret 200601c: 91 e8 00 08 restore %g0, %o0, %o0 02004e64 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 2004e64: 9d e3 bf 68 save %sp, -152, %sp 2004e68: 82 10 00 18 mov %i0, %g1 if ( !time_buffer ) 2004e6c: 80 a6 60 00 cmp %i1, 0 2004e70: 02 80 00 47 be 2004f8c 2004e74: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; switch ( option ) { 2004e78: 80 a0 60 04 cmp %g1, 4 2004e7c: 18 80 00 44 bgu 2004f8c 2004e80: b0 10 20 19 mov 0x19, %i0 2004e84: 83 28 60 02 sll %g1, 2, %g1 2004e88: 05 00 80 13 sethi %hi(0x2004c00), %g2 2004e8c: 84 10 a2 10 or %g2, 0x210, %g2 ! 2004e10 2004e90: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2004e94: 81 c0 40 00 jmp %g1 2004e98: 01 00 00 00 nop case RTEMS_CLOCK_GET_TOD: { struct tm time; struct timeval now; rtems_time_of_day *tmbuf = (rtems_time_of_day *)time_buffer; if ( !_TOD_Is_set ) 2004e9c: 03 00 80 5e sethi %hi(0x2017800), %g1 2004ea0: c2 00 63 ec ld [ %g1 + 0x3ec ], %g1 ! 2017bec <_TOD_Is_set> 2004ea4: 80 a0 60 00 cmp %g1, 0 2004ea8: 22 80 00 39 be,a 2004f8c 2004eac: b0 10 20 0b mov 0xb, %i0 return RTEMS_NOT_DEFINED; /* Obtain the current time */ _TOD_Get_timeval( &now ); 2004eb0: a0 07 bf f0 add %fp, -16, %l0 2004eb4: 7f ff ff dc call 2004e24 <_TOD_Get_timeval> 2004eb8: 90 10 00 10 mov %l0, %o0 /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 2004ebc: 92 07 bf cc add %fp, -52, %o1 2004ec0: 40 00 24 33 call 200df8c 2004ec4: 90 10 00 10 mov %l0, %o0 tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 2004ec8: 03 00 80 5f sethi %hi(0x2017c00), %g1 2004ecc: d2 00 61 8c ld [ %g1 + 0x18c ], %o1 ! 2017d8c <_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; 2004ed0: c2 07 bf d8 ld [ %fp + -40 ], %g1 tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 2004ed4: d0 07 bf f4 ld [ %fp + -12 ], %o0 gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; 2004ed8: c2 26 60 08 st %g1, [ %i1 + 8 ] tmbuf->hour = time.tm_hour; 2004edc: c2 07 bf d4 ld [ %fp + -44 ], %g1 2004ee0: c2 26 60 0c st %g1, [ %i1 + 0xc ] tmbuf->minute = time.tm_min; 2004ee4: c2 07 bf d0 ld [ %fp + -48 ], %g1 2004ee8: c2 26 60 10 st %g1, [ %i1 + 0x10 ] tmbuf->second = time.tm_sec; 2004eec: c2 07 bf cc ld [ %fp + -52 ], %g1 2004ef0: c2 26 60 14 st %g1, [ %i1 + 0x14 ] /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 2004ef4: c2 07 bf e0 ld [ %fp + -32 ], %g1 2004ef8: 82 00 67 6c add %g1, 0x76c, %g1 2004efc: c2 26 40 00 st %g1, [ %i1 ] tmbuf->month = time.tm_mon + 1; 2004f00: c2 07 bf dc ld [ %fp + -36 ], %g1 2004f04: 82 00 60 01 inc %g1 tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 2004f08: 40 00 3d ee call 20146c0 <.udiv> 2004f0c: c2 26 60 04 st %g1, [ %i1 + 4 ] 2004f10: 10 80 00 1c b 2004f80 2004f14: d0 26 60 18 st %o0, [ %i1 + 0x18 ] return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: { rtems_interval *interval = (rtems_interval *)time_buffer; if ( !_TOD_Is_set ) 2004f18: 03 00 80 5e sethi %hi(0x2017800), %g1 2004f1c: c2 00 63 ec ld [ %g1 + 0x3ec ], %g1 ! 2017bec <_TOD_Is_set> 2004f20: 80 a0 60 00 cmp %g1, 0 2004f24: 02 80 00 19 be 2004f88 2004f28: 03 00 80 5f sethi %hi(0x2017c00), %g1 return RTEMS_NOT_DEFINED; *interval = _TOD_Seconds_since_epoch; 2004f2c: 10 80 00 04 b 2004f3c 2004f30: c2 00 60 6c ld [ %g1 + 0x6c ], %g1 ! 2017c6c <_TOD_Now> } case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = _Watchdog_Ticks_since_boot; 2004f34: 03 00 80 5f sethi %hi(0x2017c00), %g1 2004f38: c2 00 61 34 ld [ %g1 + 0x134 ], %g1 ! 2017d34 <_Watchdog_Ticks_since_boot> 2004f3c: c2 26 40 00 st %g1, [ %i1 ] 2004f40: 81 c7 e0 08 ret 2004f44: 91 e8 20 00 restore %g0, 0, %o0 } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick; 2004f48: 03 00 80 5f sethi %hi(0x2017c00), %g1 2004f4c: d2 00 61 8c ld [ %g1 + 0x18c ], %o1 ! 2017d8c <_TOD_Microseconds_per_tick> 2004f50: 11 00 03 d0 sethi %hi(0xf4000), %o0 2004f54: 40 00 3d db call 20146c0 <.udiv> 2004f58: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 2004f5c: 10 80 00 09 b 2004f80 2004f60: d0 26 40 00 st %o0, [ %i1 ] } case RTEMS_CLOCK_GET_TIME_VALUE: { struct timeval *time = (struct timeval *)time_buffer; if ( !_TOD_Is_set ) 2004f64: 03 00 80 5e sethi %hi(0x2017800), %g1 <== NOT EXECUTED 2004f68: c2 00 63 ec ld [ %g1 + 0x3ec ], %g1 ! 2017bec <_TOD_Is_set> <== NOT EXECUTED 2004f6c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004f70: 22 80 00 07 be,a 2004f8c <== NOT EXECUTED 2004f74: b0 10 20 0b mov 0xb, %i0 <== NOT EXECUTED return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); 2004f78: 7f ff ff ab call 2004e24 <_TOD_Get_timeval> <== NOT EXECUTED 2004f7c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2004f80: 81 c7 e0 08 ret 2004f84: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; 2004f88: b0 10 20 0b mov 0xb, %i0 <== NOT EXECUTED } } return RTEMS_INTERNAL_ERROR; /* should never get here */ } 2004f8c: 81 c7 e0 08 ret 2004f90: 81 e8 00 00 restore 02004fb4 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 2004fb4: 9d e3 bf 98 save %sp, -104, %sp _TOD_Tickle_ticks(); 2004fb8: 40 00 07 18 call 2006c18 <_TOD_Tickle_ticks> 2004fbc: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 2004fc0: 11 00 80 5f sethi %hi(0x2017c00), %o0 2004fc4: 40 00 14 6b call 200a170 <_Watchdog_Tickle> 2004fc8: 90 12 20 b0 or %o0, 0xb0, %o0 ! 2017cb0 <_Watchdog_Ticks_chain> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 2004fcc: 40 00 12 c2 call 2009ad4 <_Thread_Tickle_timeslice> 2004fd0: 01 00 00 00 nop * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_context_switch_necessary( void ) { return ( _Context_Switch_necessary ); 2004fd4: 03 00 80 5f sethi %hi(0x2017c00), %g1 2004fd8: c2 00 60 a0 ld [ %g1 + 0xa0 ], %g1 ! 2017ca0 <_Context_Switch_necessary> if ( _Thread_Is_context_switch_necessary() && 2004fdc: 80 a0 60 00 cmp %g1, 0 2004fe0: 02 80 00 08 be 2005000 2004fe4: 03 00 80 5e sethi %hi(0x2017800), %g1 * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 2004fe8: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> 2004fec: 80 a0 60 00 cmp %g1, 0 2004ff0: 12 80 00 04 bne 2005000 2004ff4: 01 00 00 00 nop _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 2004ff8: 40 00 0e cb call 2008b24 <_Thread_Dispatch> <== NOT EXECUTED 2004ffc: 01 00 00 00 nop <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 2005000: 81 c7 e0 08 ret 2005004: 91 e8 20 00 restore %g0, 0, %o0 02005218 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 2005218: 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 ) ) { 200521c: 92 96 20 00 orcc %i0, 0, %o1 2005220: 12 80 00 0a bne 2005248 2005224: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005228: 03 00 80 5e sethi %hi(0x2017800), %g1 200522c: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2017bb0 <_Thread_Dispatch_disable_level> 2005230: 84 00 a0 01 inc %g2 2005234: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 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; 2005238: 03 00 80 5f sethi %hi(0x2017c00), %g1 200523c: f0 00 60 90 ld [ %g1 + 0x90 ], %i0 ! 2017c90 <_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; 2005240: 10 80 00 18 b 20052a0 2005244: c0 27 bf f4 clr [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2005248: 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 ) { 200524c: 80 a0 a0 04 cmp %g2, 4 2005250: 18 80 00 0e bgu 2005288 2005254: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2005258: 83 32 60 1b srl %o1, 0x1b, %g1 200525c: 80 a0 60 01 cmp %g1, 1 2005260: 12 80 00 0a bne 2005288 2005264: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2005268: 83 28 a0 02 sll %g2, 2, %g1 200526c: 05 00 80 5e sethi %hi(0x2017800), %g2 2005270: 84 10 a3 10 or %g2, 0x310, %g2 ! 2017b10 <_Objects_Information_table> 2005274: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2005278: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 200527c: 80 a2 20 00 cmp %o0, 0 2005280: 12 80 00 05 bne 2005294 2005284: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2005288: b0 10 20 00 clr %i0 200528c: 10 80 00 05 b 20052a0 2005290: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2005294: 40 00 09 1f call 2007710 <_Objects_Get> 2005298: 94 07 bf f4 add %fp, -12, %o2 200529c: b0 10 00 08 mov %o0, %i0 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20052a0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20052a4: 80 a0 60 00 cmp %g1, 0 20052a8: 02 80 00 06 be 20052c0 20052ac: 80 a0 60 02 cmp %g1, 2 20052b0: 08 80 00 18 bleu 2005310 20052b4: b0 10 20 04 mov 4, %i0 20052b8: 81 c7 e0 08 ret <== NOT EXECUTED 20052bc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 20052c0: 7f ff f2 a0 call 2001d40 20052c4: e0 06 21 70 ld [ %i0 + 0x170 ], %l0 *the_event_set |= the_new_events; 20052c8: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 20052cc: 82 10 40 19 or %g1, %i1, %g1 20052d0: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _ISR_Enable( level ); 20052d4: 7f ff f2 9f call 2001d50 20052d8: 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 ); 20052dc: 40 00 00 15 call 2005330 <_Event_Surrender> 20052e0: 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 ) 20052e4: 05 00 80 5e sethi %hi(0x2017800), %g2 20052e8: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> 20052ec: b0 10 20 00 clr %i0 20052f0: 82 00 7f ff add %g1, -1, %g1 20052f4: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 20052f8: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 20052fc: 80 a0 60 00 cmp %g1, 0 2005300: 12 80 00 04 bne 2005310 2005304: 01 00 00 00 nop _Thread_Dispatch(); 2005308: 40 00 0e 07 call 2008b24 <_Thread_Dispatch> 200530c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005310: 81 c7 e0 08 ret 2005314: 81 e8 00 00 restore 0200ac18 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 200ac18: 9d e3 bf 98 save %sp, -104, %sp Extension_Control *the_extension; if ( !rtems_is_name_valid( name ) ) 200ac1c: a4 96 20 00 orcc %i0, 0, %l2 200ac20: 02 80 00 0e be 200ac58 200ac24: b0 10 20 03 mov 3, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200ac28: 05 00 80 99 sethi %hi(0x2026400), %g2 200ac2c: c2 00 a0 80 ld [ %g2 + 0x80 ], %g1 ! 2026480 <_Thread_Dispatch_disable_level> 200ac30: 82 00 60 01 inc %g1 200ac34: c2 20 a0 80 st %g1, [ %g2 + 0x80 ] * the inactive chain of free extension control blocks. */ RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void ) { return (Extension_Control *) _Objects_Allocate( &_Extension_Information ); 200ac38: 23 00 80 99 sethi %hi(0x2026400), %l1 200ac3c: 40 00 03 87 call 200ba58 <_Objects_Allocate> 200ac40: 90 14 63 1c or %l1, 0x31c, %o0 ! 202671c <_Extension_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 200ac44: a0 92 20 00 orcc %o0, 0, %l0 200ac48: 12 80 00 06 bne 200ac60 200ac4c: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); 200ac50: 7f ff ff e5 call 200abe4 <_Thread_Enable_dispatch> <== NOT EXECUTED 200ac54: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 200ac58: 81 c7 e0 08 ret <== NOT EXECUTED 200ac5c: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 200ac60: 40 00 0e 48 call 200e580 <_User_extensions_Add_set> 200ac64: 92 10 00 19 mov %i1, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ac68: 90 14 63 1c or %l1, 0x31c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200ac6c: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ac70: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200ac74: 05 00 00 3f sethi %hi(0xfc00), %g2 200ac78: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200ac7c: 82 08 40 02 and %g1, %g2, %g1 200ac80: 80 a0 40 03 cmp %g1, %g3 200ac84: 38 80 00 06 bgu,a 200ac9c 200ac88: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200ac8c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200ac90: 83 28 60 02 sll %g1, 2, %g1 200ac94: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 200ac98: c2 04 20 08 ld [ %l0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200ac9c: e4 24 20 0c st %l2, [ %l0 + 0xc ] 200aca0: c2 26 80 00 st %g1, [ %i2 ] _Thread_Enable_dispatch(); 200aca4: 7f ff ff d0 call 200abe4 <_Thread_Enable_dispatch> 200aca8: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 200acac: 81 c7 e0 08 ret 200acb0: 81 e8 00 00 restore 0200acb4 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 200acb4: 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 *) 200acb8: 21 00 80 99 sethi %hi(0x2026400), %l0 <== NOT EXECUTED 200acbc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200acc0: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 200acc4: 40 00 04 a9 call 200bf68 <_Objects_Get> <== NOT EXECUTED 200acc8: 90 14 23 1c or %l0, 0x31c, %o0 <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 200accc: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200acd0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200acd4: 02 80 00 07 be 200acf0 <== NOT EXECUTED 200acd8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 200acdc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200ace0: 08 80 00 20 bleu 200ad60 <== NOT EXECUTED 200ace4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 200ace8: 81 c7 e0 08 ret <== NOT EXECUTED 200acec: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never return this */ return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 200acf0: 40 00 0e 5e call 200e668 <_User_extensions_Remove_set> <== NOT EXECUTED 200acf4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200acf8: 90 14 23 1c or %l0, 0x31c, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200acfc: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ad00: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 <== NOT EXECUTED 200ad04: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED 200ad08: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <== NOT EXECUTED 200ad0c: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 200ad10: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200ad14: 38 80 00 06 bgu,a 200ad2c <== NOT EXECUTED 200ad18: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200ad1c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 <== NOT EXECUTED 200ad20: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 200ad24: 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; 200ad28: 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 ); 200ad2c: 40 00 04 4d call 200be60 <_Objects_Free> <== NOT EXECUTED 200ad30: 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 ) 200ad34: 03 00 80 99 sethi %hi(0x2026400), %g1 <== NOT EXECUTED 200ad38: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 2026480 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200ad3c: b0 10 20 00 clr %i0 <== NOT EXECUTED 200ad40: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 200ad44: c4 20 60 80 st %g2, [ %g1 + 0x80 ] <== NOT EXECUTED 200ad48: c2 00 60 80 ld [ %g1 + 0x80 ], %g1 <== NOT EXECUTED 200ad4c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200ad50: 12 80 00 04 bne 200ad60 <== NOT EXECUTED 200ad54: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 200ad58: 40 00 09 89 call 200d37c <_Thread_Dispatch> <== NOT EXECUTED 200ad5c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200ad60: 81 c7 e0 08 ret <== NOT EXECUTED 200ad64: 81 e8 00 00 restore <== NOT EXECUTED 02006544 : */ void rtems_fatal_error_occurred( uint32_t the_error ) { 2006544: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error ); 2006548: 92 10 20 00 clr %o1 <== NOT EXECUTED 200654c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 2006550: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2006554: 40 00 02 fe call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 2006558: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 200655c: 01 00 00 00 nop 02006560 : #include const char *rtems_get_version_string(void) { return _RTEMS_version; } 2006560: 11 00 80 5a sethi %hi(0x2016800), %o0 <== NOT EXECUTED 2006564: 81 c3 e0 08 retl <== NOT EXECUTED 2006568: 90 12 22 68 or %o0, 0x268, %o0 ! 2016a68 <_RTEMS_version> <== NOT EXECUTED 02006308 : rtems_interrupt_level rtems_initialize_executive_early( rtems_configuration_table *configuration_table, rtems_cpu_table *cpu_table ) { 2006308: 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 ); 200630c: 7f ff ee 8d call 2001d40 2006310: 01 00 00 00 nop 2006314: a4 10 00 08 mov %o0, %l2 if ( configuration_table == NULL ) 2006318: 80 a6 20 00 cmp %i0, 0 200631c: 12 80 00 07 bne 2006338 2006320: 03 00 80 5f sethi %hi(0x2017c00), %g1 _Internal_error_Occurred( 2006324: 90 10 20 00 clr %o0 <== NOT EXECUTED 2006328: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 200632c: 40 00 03 88 call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 2006330: 94 10 20 00 clr %o2 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; 2006334: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2006338: c0 20 61 90 clr [ %g1 + 0x190 ] ! 2017d90 <_System_state_Current> _System_state_Is_multiprocessing = is_multiprocessing; 200633c: 03 00 80 5f sethi %hi(0x2017c00), %g1 /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 2006340: 94 10 20 28 mov 0x28, %o2 2006344: 92 10 00 19 mov %i1, %o1 2006348: c0 20 60 bc clr [ %g1 + 0xbc ] 200634c: 11 00 80 5e sethi %hi(0x2017800), %o0 2006350: 40 00 1f 14 call 200dfa0 2006354: 90 12 23 c4 or %o0, 0x3c4, %o0 ! 2017bc4 <_CPU_Table> /* * Provided just for user convenience. */ _Configuration_Table = configuration_table; 2006358: 03 00 80 5f sethi %hi(0x2017c00), %g1 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_NO_CPU_TABLE ); _CPU_Initialize( cpu_table, _Thread_Dispatch ); 200635c: 90 10 00 19 mov %i1, %o0 2006360: 13 00 80 22 sethi %hi(0x2008800), %o1 2006364: 92 12 63 24 or %o1, 0x324, %o1 ! 2008b24 <_Thread_Dispatch> 2006368: 40 00 11 6c call 200a918 <_CPU_Initialize> 200636c: f0 20 60 74 st %i0, [ %g1 + 0x74 ] /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 2006370: 40 00 18 04 call 200c380 <_Debug_Manager_initialization> 2006374: 01 00 00 00 nop _API_extensions_Initialization(); 2006378: 40 00 00 cb call 20066a4 <_API_extensions_Initialization> 200637c: 01 00 00 00 nop _Thread_Dispatch_initialization(); _Workspace_Handler_initialization( 2006380: d2 06 20 04 ld [ %i0 + 4 ], %o1 2006384: 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; 2006388: 84 10 20 01 mov 1, %g2 200638c: 03 00 80 5e sethi %hi(0x2017800), %g1 2006390: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] ! 2017bb0 <_Thread_Dispatch_disable_level> 2006394: 40 00 0f ac call 200a244 <_Workspace_Handler_initialization> 2006398: 23 00 80 5f sethi %hi(0x2017c00), %l1 (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 200639c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 20063a0: 40 00 0e 4c call 2009cd0 <_User_extensions_Handler_initialization> 20063a4: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 20063a8: 40 00 03 79 call 200718c <_ISR_Handler_initialization> 20063ac: a0 07 bf e8 add %fp, -24, %l0 _Objects_Handler_initialization( 20063b0: 90 10 20 01 mov 1, %o0 20063b4: 92 10 20 01 mov 1, %o1 20063b8: 40 00 05 6f call 2007974 <_Objects_Handler_initialization> 20063bc: 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; 20063c0: 05 00 80 5e sethi %hi(0x2017800), %g2 /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20063c4: 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; 20063c8: 03 00 80 5e sethi %hi(0x2017800), %g1 20063cc: 82 10 63 f0 or %g1, 0x3f0, %g1 ! 2017bf0 <_Internal_Objects> /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20063d0: 96 10 20 01 mov 1, %o3 multiprocessing_table->node, multiprocessing_table->maximum_nodes, multiprocessing_table->maximum_global_objects ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 20063d4: c2 20 a3 14 st %g1, [ %g2 + 0x314 ] /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20063d8: 98 10 20 74 mov 0x74, %o4 20063dc: 9a 10 20 00 clr %o5 20063e0: 90 14 60 c0 or %l1, 0xc0, %o0 20063e4: 92 10 20 01 mov 1, %o1 20063e8: 40 00 04 ef call 20077a4 <_Objects_Initialize_information> 20063ec: 94 10 20 02 mov 2, %o2 _API_Mutex_Allocate( _RTEMS_Allocator_Mutex ); 20063f0: 94 10 20 10 mov 0x10, %o2 20063f4: 13 00 80 58 sethi %hi(0x2016000), %o1 20063f8: 90 10 00 10 mov %l0, %o0 20063fc: 40 00 1e e9 call 200dfa0 2006400: 92 12 62 10 or %o1, 0x210, %o1 2006404: 40 00 03 7f call 2007200 <_Objects_Allocate> 2006408: 90 14 60 c0 or %l1, 0xc0, %o0 200640c: 03 00 80 5f sethi %hi(0x2017c00), %g1 2006410: 84 10 00 08 mov %o0, %g2 2006414: 92 10 00 10 mov %l0, %o1 2006418: c4 20 60 88 st %g2, [ %g1 + 0x88 ] 200641c: 90 02 20 10 add %o0, 0x10, %o0 2006420: 40 00 01 03 call 200682c <_CORE_mutex_Initialize> 2006424: 94 10 20 01 mov 1, %o2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 2006428: 03 00 80 5f sethi %hi(0x2017c00), %g1 200642c: 84 10 20 00 clr %g2 2006430: c0 30 60 84 clrh [ %g1 + 0x84 ] for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 2006434: 03 00 80 5f sethi %hi(0x2017c00), %g1 2006438: 82 10 61 10 or %g1, 0x110, %g1 ! 2017d10 <_Priority_Bit_map> 200643c: c0 30 80 01 clrh [ %g2 + %g1 ] 2006440: 84 00 a0 02 add %g2, 2, %g2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; for ( index=0 ; index <16 ; index++ ) 2006444: 80 a0 a0 20 cmp %g2, 0x20 2006448: 32 bf ff fe bne,a 2006440 200644c: c0 30 80 01 clrh [ %g2 + %g1 ] _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 2006450: 40 00 0f 0b call 200a07c <_Watchdog_Handler_initialization> 2006454: 01 00 00 00 nop _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 2006458: 40 00 01 e1 call 2006bdc <_TOD_Handler_initialization> 200645c: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _Thread_Handler_initialization( 2006460: d2 06 20 08 ld [ %i0 + 8 ], %o1 2006464: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 2006468: 40 00 0a 9c call 2008ed8 <_Thread_Handler_initialization> 200646c: 94 10 20 00 clr %o2 ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 2006470: 40 00 00 6e call 2006628 <_RTEMS_API_Initialize> 2006474: 90 10 00 18 mov %i0, %o0 _Extension_Manager_initialization( configuration_table->maximum_extensions ); 2006478: 40 00 00 26 call 2006510 <_Extension_Manager_initialization> 200647c: d0 06 20 08 ld [ %i0 + 8 ], %o0 _IO_Manager_initialization( 2006480: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 2006484: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 2006488: 40 00 00 47 call 20065a4 <_IO_Manager_initialization> 200648c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 2006490: 84 10 20 01 mov 1, %g2 2006494: 03 00 80 5f sethi %hi(0x2017c00), %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(); 2006498: 40 00 09 47 call 20089b4 <_Thread_Create_idle> 200649c: c4 20 61 90 st %g2, [ %g1 + 0x190 ] ! 2017d90 <_System_state_Current> /* * Scheduling can properly occur now as long as we avoid dispatching. */ if ( cpu_table->pretasking_hook ) 20064a0: d0 06 40 00 ld [ %i1 ], %o0 20064a4: 80 a2 20 00 cmp %o0, 0 20064a8: 02 80 00 04 be 20064b8 20064ac: 01 00 00 00 nop (*cpu_table->pretasking_hook)(); 20064b0: 9f c2 00 00 call %o0 20064b4: 01 00 00 00 nop /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 20064b8: 40 00 00 9a call 2006720 <_API_extensions_Run_predriver> 20064bc: 01 00 00 00 nop if ( _CPU_Table.predriver_hook ) 20064c0: 03 00 80 5e sethi %hi(0x2017800), %g1 20064c4: a0 10 63 c4 or %g1, 0x3c4, %l0 ! 2017bc4 <_CPU_Table> 20064c8: c2 04 20 04 ld [ %l0 + 4 ], %g1 20064cc: 80 a0 60 00 cmp %g1, 0 20064d0: 02 80 00 04 be 20064e0 20064d4: 01 00 00 00 nop (*_CPU_Table.predriver_hook)(); 20064d8: 9f c0 40 00 call %g1 <== NOT EXECUTED 20064dc: 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(); 20064e0: 40 00 00 23 call 200656c <_IO_Initialize_all_drivers> 20064e4: 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(); 20064e8: 40 00 00 76 call 20066c0 <_API_extensions_Run_postdriver> 20064ec: 01 00 00 00 nop if ( _CPU_Table.postdriver_hook ) 20064f0: c2 04 20 08 ld [ %l0 + 8 ], %g1 20064f4: 80 a0 60 00 cmp %g1, 0 20064f8: 02 80 00 04 be 2006508 20064fc: 01 00 00 00 nop (*_CPU_Table.postdriver_hook)(); 2006500: 9f c0 40 00 call %g1 2006504: 01 00 00 00 nop return bsp_level; } 2006508: 81 c7 e0 08 ret 200650c: 91 e8 00 12 restore %g0, %l2, %o0 02007600 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 2007600: 9d e3 bf 98 save %sp, -104, %sp /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 2007604: 92 96 60 00 orcc %i1, 0, %o1 2007608: 02 80 00 40 be 2007708 200760c: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 2007610: 02 80 00 41 be 2007714 2007614: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 2007618: c2 02 40 00 ld [ %o1 ], %g1 200761c: 80 a0 60 00 cmp %g1, 0 2007620: 12 80 00 07 bne 200763c 2007624: 03 00 80 6e sethi %hi(0x201b800), %g1 2007628: c2 02 60 04 ld [ %o1 + 4 ], %g1 200762c: 80 a0 60 00 cmp %g1, 0 2007630: 22 80 00 39 be,a 2007714 2007634: 82 10 20 09 mov 9, %g1 *registered_major = 0; /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 2007638: 03 00 80 6e sethi %hi(0x201b800), %g1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) return RTEMS_INVALID_ADDRESS; *registered_major = 0; 200763c: c0 26 80 00 clr [ %i2 ] /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 2007640: c8 00 61 dc ld [ %g1 + 0x1dc ], %g4 2007644: 80 a6 00 04 cmp %i0, %g4 2007648: 1a 80 00 33 bcc 2007714 200764c: 82 10 20 0a mov 0xa, %g1 /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 2007650: 80 a6 20 00 cmp %i0, 0 2007654: 12 80 00 18 bne 20076b4 2007658: 03 00 80 6e sethi %hi(0x201b800), %g1 boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 200765c: c6 00 61 e0 ld [ %g1 + 0x1e0 ], %g3 ! 201b9e0 <_IO_Driver_address_table> 2007660: 85 29 20 03 sll %g4, 3, %g2 2007664: 83 29 20 05 sll %g4, 5, %g1 2007668: b0 01 3f ff add %g4, -1, %i0 200766c: 82 20 40 02 sub %g1, %g2, %g1 2007670: 82 00 7f e8 add %g1, -24, %g1 2007674: 10 80 00 0b b 20076a0 2007678: 84 00 40 03 add %g1, %g3, %g2 if ( !_IO_Driver_address_table[major].initialization_entry && 200767c: 80 a0 60 00 cmp %g1, 0 2007680: 32 80 00 07 bne,a 200769c 2007684: b0 06 3f ff add %i0, -1, %i0 2007688: c2 00 a0 04 ld [ %g2 + 4 ], %g1 200768c: 80 a0 60 00 cmp %g1, 0 2007690: 02 80 00 09 be 20076b4 2007694: 03 00 80 6e sethi %hi(0x201b800), %g1 * in use. */ if ( major == 0 ) { boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 2007698: b0 06 3f ff add %i0, -1, %i0 <== NOT EXECUTED 200769c: 84 00 bf e8 add %g2, -24, %g2 20076a0: 80 a6 20 00 cmp %i0, 0 20076a4: 32 bf ff f6 bne,a 200767c 20076a8: c2 00 80 00 ld [ %g2 ], %g1 20076ac: 10 80 00 1a b 2007714 20076b0: 82 10 20 05 mov 5, %g1 if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 20076b4: c6 00 61 e0 ld [ %g1 + 0x1e0 ], %g3 20076b8: 85 2e 20 03 sll %i0, 3, %g2 20076bc: 83 2e 20 05 sll %i0, 5, %g1 20076c0: 82 20 40 02 sub %g1, %g2, %g1 20076c4: c4 00 40 03 ld [ %g1 + %g3 ], %g2 20076c8: 80 a0 a0 00 cmp %g2, 0 20076cc: 12 80 00 11 bne 2007710 20076d0: 90 00 40 03 add %g1, %g3, %o0 20076d4: c2 02 20 04 ld [ %o0 + 4 ], %g1 20076d8: 80 a0 60 00 cmp %g1, 0 20076dc: 32 80 00 0e bne,a 2007714 20076e0: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 20076e4: 40 00 1d f0 call 200eea4 20076e8: 94 10 20 18 mov 0x18, %o2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 20076ec: 90 10 00 18 mov %i0, %o0 _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; *registered_major = major; 20076f0: f0 26 80 00 st %i0, [ %i2 ] rtems_io_initialize( major, 0, NULL ); 20076f4: 92 10 20 00 clr %o1 20076f8: 7f ff ff 52 call 2007440 20076fc: 94 10 20 00 clr %o2 2007700: 10 80 00 05 b 2007714 2007704: 82 10 20 00 clr %g1 return RTEMS_SUCCESSFUL; 2007708: 10 80 00 03 b 2007714 200770c: 82 10 20 09 mov 9, %g1 2007710: 82 10 20 0c mov 0xc, %g1 } 2007714: 81 c7 e0 08 ret 2007718: 91 e8 00 01 restore %g0, %g1, %o0 02008bd0 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 2008bd0: 9d e3 bf 98 save %sp, -104, %sp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 2008bd4: 80 a6 20 00 cmp %i0, 0 2008bd8: 02 80 00 1d be 2008c4c 2008bdc: 03 00 80 90 sethi %hi(0x2024000), %g1 return; 2008be0: a4 10 60 44 or %g1, 0x44, %l2 ! 2024044 <_Objects_Information_table+0x4> for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 2008be4: a6 04 a0 10 add %l2, 0x10, %l3 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 2008be8: c2 04 80 00 ld [ %l2 ], %g1 2008bec: 80 a0 60 00 cmp %g1, 0 2008bf0: 22 80 00 14 be,a 2008c40 2008bf4: a4 04 a0 04 add %l2, 4, %l2 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 2008bf8: e0 00 60 04 ld [ %g1 + 4 ], %l0 if ( information ) { 2008bfc: 80 a4 20 00 cmp %l0, 0 2008c00: 12 80 00 0b bne 2008c2c 2008c04: a2 10 20 01 mov 1, %l1 for ( i=1 ; i <= information->maximum ; i++ ) { 2008c08: 10 80 00 0e b 2008c40 <== NOT EXECUTED 2008c0c: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED the_thread = (Thread_Control *)information->local_table[ i ]; 2008c10: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 2008c14: d0 00 40 08 ld [ %g1 + %o0 ], %o0 if ( !the_thread ) 2008c18: 80 a2 20 00 cmp %o0, 0 2008c1c: 02 80 00 04 be 2008c2c 2008c20: a2 04 60 01 inc %l1 continue; (*routine)(the_thread); 2008c24: 9f c6 00 00 call %i0 2008c28: 01 00 00 00 nop api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 2008c2c: c2 14 20 10 lduh [ %l0 + 0x10 ], %g1 2008c30: 80 a4 40 01 cmp %l1, %g1 2008c34: 08 bf ff f7 bleu 2008c10 2008c38: 91 2c 60 02 sll %l1, 2, %o0 2008c3c: a4 04 a0 04 add %l2, 4, %l2 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 2008c40: 80 a4 80 13 cmp %l2, %l3 2008c44: 32 bf ff ea bne,a 2008bec 2008c48: c2 04 80 00 ld [ %l2 ], %g1 2008c4c: 81 c7 e0 08 ret 2008c50: 81 e8 00 00 restore 0200e7b8 : Objects_Id id, void *buffer, size_t size, uint32_t *count ) { 200e7b8: 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 ) 200e7bc: 80 a6 60 00 cmp %i1, 0 200e7c0: 02 80 00 26 be 200e858 200e7c4: 80 a6 e0 00 cmp %i3, 0 return RTEMS_INVALID_ADDRESS; if ( !count ) 200e7c8: 02 80 00 24 be 200e858 200e7cc: 11 00 80 c4 sethi %hi(0x2031000), %o0 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 200e7d0: 92 10 00 18 mov %i0, %o1 200e7d4: 90 12 22 d0 or %o0, 0x2d0, %o0 200e7d8: 40 00 18 88 call 20149f8 <_Objects_Get> 200e7dc: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200e7e0: c2 07 bf f4 ld [ %fp + -12 ], %g1 200e7e4: 80 a0 60 00 cmp %g1, 0 200e7e8: 02 80 00 07 be 200e804 200e7ec: 9a 10 00 1b mov %i3, %o5 200e7f0: 80 a0 60 02 cmp %g1, 2 200e7f4: 08 80 00 1a bleu 200e85c 200e7f8: 90 10 20 04 mov 4, %o0 200e7fc: 10 80 00 18 b 200e85c <== NOT EXECUTED 200e800: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 200e804: 92 10 00 19 mov %i1, %o1 200e808: 94 10 00 1a mov %i2, %o2 200e80c: 96 10 00 18 mov %i0, %o3 200e810: 98 10 20 00 clr %o4 200e814: 40 00 13 16 call 201346c <_CORE_message_queue_Broadcast> 200e818: 90 02 20 14 add %o0, 0x14, %o0 200e81c: 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 ) 200e820: 03 00 80 c3 sethi %hi(0x2030c00), %g1 200e824: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2030fb0 <_Thread_Dispatch_disable_level> 200e828: 84 00 bf ff add %g2, -1, %g2 200e82c: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 200e830: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 200e834: 80 a0 60 00 cmp %g1, 0 200e838: 12 80 00 04 bne 200e848 200e83c: 01 00 00 00 nop _Thread_Dispatch(); 200e840: 40 00 1d 73 call 2015e0c <_Thread_Dispatch> 200e844: 01 00 00 00 nop #endif count ); _Thread_Enable_dispatch(); return 200e848: 40 00 01 2e call 200ed00 <_Message_queue_Translate_core_message_queue_return_code> 200e84c: 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 */ } 200e850: 81 c7 e0 08 ret 200e854: 91 e8 00 08 restore %g0, %o0, %o0 #endif count ); _Thread_Enable_dispatch(); return 200e858: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED _Message_queue_Translate_core_message_queue_return_code( core_status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e85c: b0 10 00 08 mov %o0, %i0 200e860: 81 c7 e0 08 ret 200e864: 81 e8 00 00 restore 0200e89c : uint32_t count, uint32_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 200e89c: 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 ) ) 200e8a0: a2 96 20 00 orcc %i0, 0, %l1 200e8a4: 02 80 00 17 be 200e900 200e8a8: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 200e8ac: 80 a7 20 00 cmp %i4, 0 200e8b0: 02 80 00 14 be 200e900 200e8b4: 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 ) 200e8b8: 80 a6 60 00 cmp %i1, 0 200e8bc: 02 80 00 11 be 200e900 200e8c0: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 200e8c4: 80 a6 a0 00 cmp %i2, 0 200e8c8: 02 80 00 0e be 200e900 200e8cc: b0 10 20 08 mov 8, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200e8d0: 05 00 80 c3 sethi %hi(0x2030c00), %g2 200e8d4: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 200e8d8: 82 00 60 01 inc %g1 200e8dc: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate( count, max_message_size ); 200e8e0: 90 10 00 19 mov %i1, %o0 200e8e4: 40 00 2b bc call 20197d4 <_Message_queue_Allocate> 200e8e8: 92 10 00 1a mov %i2, %o1 if ( !the_message_queue ) { 200e8ec: a0 92 20 00 orcc %o0, 0, %l0 200e8f0: 12 80 00 06 bne 200e908 200e8f4: 80 8e e0 04 btst 4, %i3 _Thread_Enable_dispatch(); 200e8f8: 7f ff ff dc call 200e868 <_Thread_Enable_dispatch> 200e8fc: b0 10 20 05 mov 5, %i0 200e900: 81 c7 e0 08 ret 200e904: 81 e8 00 00 restore } #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) 200e908: 02 80 00 05 be 200e91c 200e90c: f6 24 20 10 st %i3, [ %l0 + 0x10 ] the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 200e910: 82 10 20 01 mov 1, %g1 200e914: 10 80 00 03 b 200e920 200e918: c2 27 bf f4 st %g1, [ %fp + -12 ] else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 200e91c: c0 27 bf f4 clr [ %fp + -12 ] if ( ! _CORE_message_queue_Initialize( 200e920: 94 10 00 19 mov %i1, %o2 200e924: 96 10 00 1a mov %i2, %o3 200e928: 90 04 20 14 add %l0, 0x14, %o0 200e92c: 40 00 13 1c call 201359c <_CORE_message_queue_Initialize> 200e930: 92 07 bf f4 add %fp, -12, %o1 200e934: 80 a2 20 00 cmp %o0, 0 200e938: 12 80 00 0a bne 200e960 200e93c: 11 00 80 c4 sethi %hi(0x2031000), %o0 RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 200e940: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 20312d0 <_Message_queue_Information> <== NOT EXECUTED 200e944: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 200e948: 40 00 17 d6 call 20148a0 <_Objects_Free> <== NOT EXECUTED 200e94c: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 200e950: 7f ff ff c6 call 200e868 <_Thread_Enable_dispatch> <== NOT EXECUTED 200e954: 01 00 00 00 nop <== NOT EXECUTED 200e958: 81 c7 e0 08 ret <== NOT EXECUTED 200e95c: 81 e8 00 00 restore <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e960: 90 12 22 d0 or %o0, 0x2d0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200e964: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e968: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200e96c: 05 00 00 3f sethi %hi(0xfc00), %g2 200e970: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200e974: 82 08 40 02 and %g1, %g2, %g1 200e978: 80 a0 40 03 cmp %g1, %g3 200e97c: 38 80 00 06 bgu,a 200e994 200e980: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200e984: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200e988: 83 28 60 02 sll %g1, 2, %g1 200e98c: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 200e990: c2 04 20 08 ld [ %l0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200e994: e2 24 20 0c st %l1, [ %l0 + 0xc ] 200e998: c2 27 00 00 st %g1, [ %i4 ] name, 0 ); #endif _Thread_Enable_dispatch(); 200e99c: 7f ff ff b3 call 200e868 <_Thread_Enable_dispatch> 200e9a0: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 200e9a4: 81 c7 e0 08 ret 200e9a8: 81 e8 00 00 restore 020126e8 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 20126e8: 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 *) 20126ec: 21 00 80 9a sethi %hi(0x2026800), %l0 20126f0: 92 10 00 18 mov %i0, %o1 20126f4: 94 07 bf f4 add %fp, -12, %o2 20126f8: 7f ff e6 1c call 200bf68 <_Objects_Get> 20126fc: 90 14 20 1c or %l0, 0x1c, %o0 register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 2012700: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012704: 80 a0 60 00 cmp %g1, 0 2012708: 02 80 00 07 be 2012724 201270c: b0 10 00 08 mov %o0, %i0 2012710: 80 a0 60 02 cmp %g1, 2 2012714: 08 80 00 22 bleu 201279c 2012718: b0 10 20 04 mov 4, %i0 201271c: 81 c7 e0 08 ret <== NOT EXECUTED 2012720: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012724: a0 14 20 1c or %l0, 0x1c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2012728: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 201272c: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 2012730: 05 00 00 3f sethi %hi(0xfc00), %g2 2012734: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2012738: 82 08 40 02 and %g1, %g2, %g1 201273c: 80 a0 40 03 cmp %g1, %g3 2012740: 18 80 00 05 bgu 2012754 2012744: 94 10 20 05 mov 5, %o2 information->local_table[ index ] = the_object; 2012748: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 201274c: 83 28 60 02 sll %g1, 2, %g1 2012750: c0 20 80 01 clr [ %g2 + %g1 ] case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, &the_message_queue->Object ); _CORE_message_queue_Close( 2012754: 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; 2012758: c0 26 20 0c clr [ %i0 + 0xc ] 201275c: 40 00 01 9e call 2012dd4 <_CORE_message_queue_Close> 2012760: 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 ); 2012764: 90 10 00 10 mov %l0, %o0 2012768: 7f ff e5 be call 200be60 <_Objects_Free> 201276c: 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 ) 2012770: 03 00 80 99 sethi %hi(0x2026400), %g1 2012774: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 2026480 <_Thread_Dispatch_disable_level> 2012778: b0 10 20 00 clr %i0 201277c: 84 00 bf ff add %g2, -1, %g2 2012780: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 2012784: c2 00 60 80 ld [ %g1 + 0x80 ], %g1 2012788: 80 a0 60 00 cmp %g1, 0 201278c: 12 80 00 04 bne 201279c 2012790: 01 00 00 00 nop _Thread_Dispatch(); 2012794: 7f ff ea fa call 200d37c <_Thread_Dispatch> 2012798: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 201279c: 81 c7 e0 08 ret 20127a0: 81 e8 00 00 restore 0200ea68 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 200ea68: 9d e3 bf 90 save %sp, -112, %sp 200ea6c: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200ea70: 80 a6 60 00 cmp %i1, 0 200ea74: 02 80 00 1c be 200eae4 200ea78: 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 *) 200ea7c: 11 00 80 c4 sethi %hi(0x2031000), %o0 200ea80: 94 07 bf f4 add %fp, -12, %o2 200ea84: 40 00 17 dd call 20149f8 <_Objects_Get> 200ea88: 90 12 22 d0 or %o0, 0x2d0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200ea8c: c2 07 bf f4 ld [ %fp + -12 ], %g1 200ea90: 80 a0 60 00 cmp %g1, 0 200ea94: 02 80 00 06 be 200eaac 200ea98: 80 a0 60 02 cmp %g1, 2 200ea9c: 08 80 00 12 bleu 200eae4 200eaa0: b0 10 20 04 mov 4, %i0 200eaa4: 81 c7 e0 08 ret <== NOT EXECUTED 200eaa8: 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 ); 200eaac: 40 00 12 9d call 2013520 <_CORE_message_queue_Flush> 200eab0: 90 02 20 14 add %o0, 0x14, %o0 200eab4: 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 ) 200eab8: 03 00 80 c3 sethi %hi(0x2030c00), %g1 200eabc: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2030fb0 <_Thread_Dispatch_disable_level> 200eac0: b0 10 20 00 clr %i0 200eac4: 84 00 bf ff add %g2, -1, %g2 200eac8: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 200eacc: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 200ead0: 80 a0 60 00 cmp %g1, 0 200ead4: 12 80 00 04 bne 200eae4 200ead8: 01 00 00 00 nop _Thread_Dispatch(); 200eadc: 40 00 1c cc call 2015e0c <_Thread_Dispatch> 200eae0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200eae4: 81 c7 e0 08 ret 200eae8: 81 e8 00 00 restore 0200eaec : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 200eaec: 9d e3 bf 90 save %sp, -112, %sp 200eaf0: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200eaf4: 80 a6 60 00 cmp %i1, 0 200eaf8: 02 80 00 1b be 200eb64 200eafc: b0 10 20 09 mov 9, %i0 200eb00: 11 00 80 c4 sethi %hi(0x2031000), %o0 200eb04: 94 07 bf f4 add %fp, -12, %o2 200eb08: 40 00 17 bc call 20149f8 <_Objects_Get> 200eb0c: 90 12 22 d0 or %o0, 0x2d0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200eb10: c2 07 bf f4 ld [ %fp + -12 ], %g1 200eb14: 80 a0 60 00 cmp %g1, 0 200eb18: 22 80 00 07 be,a 200eb34 200eb1c: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 200eb20: 80 a0 60 02 cmp %g1, 2 200eb24: 08 80 00 10 bleu 200eb64 200eb28: b0 10 20 04 mov 4, %i0 200eb2c: 81 c7 e0 08 ret <== NOT EXECUTED 200eb30: 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; 200eb34: 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 ) 200eb38: 05 00 80 c3 sethi %hi(0x2030c00), %g2 200eb3c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 200eb40: b0 10 20 00 clr %i0 200eb44: 82 00 7f ff add %g1, -1, %g1 200eb48: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 200eb4c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 200eb50: 80 a0 60 00 cmp %g1, 0 200eb54: 12 80 00 04 bne 200eb64 200eb58: 01 00 00 00 nop _Thread_Dispatch(); 200eb5c: 40 00 1c ac call 2015e0c <_Thread_Dispatch> 200eb60: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200eb64: 81 c7 e0 08 ret 200eb68: 81 e8 00 00 restore 020127d8 : void *buffer, size_t *size, uint32_t option_set, rtems_interval timeout ) { 20127d8: 9d e3 bf 90 save %sp, -112, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; boolean wait; if ( !buffer ) 20127dc: 80 a6 60 00 cmp %i1, 0 20127e0: 02 80 00 28 be 2012880 20127e4: 92 10 00 18 mov %i0, %o1 return RTEMS_INVALID_ADDRESS; if ( !size ) 20127e8: 80 a6 a0 00 cmp %i2, 0 20127ec: 02 80 00 25 be 2012880 20127f0: 11 00 80 9a sethi %hi(0x2026800), %o0 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 20127f4: 94 07 bf f4 add %fp, -12, %o2 20127f8: 7f ff e5 dc call 200bf68 <_Objects_Get> 20127fc: 90 12 20 1c or %o0, 0x1c, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 2012800: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012804: 80 a0 60 00 cmp %g1, 0 2012808: 22 80 00 07 be,a 2012824 201280c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2012810: 80 a0 60 02 cmp %g1, 2 2012814: 08 80 00 1c bleu 2012884 2012818: 90 10 20 04 mov 4, %o0 201281c: 10 80 00 1a b 2012884 <== NOT EXECUTED 2012820: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED 2012824: 98 0e e0 01 and %i3, 1, %o4 if ( _Options_Is_no_wait( option_set ) ) wait = FALSE; else wait = TRUE; _CORE_message_queue_Seize( 2012828: 94 10 00 19 mov %i1, %o2 201282c: 96 10 00 1a mov %i2, %o3 2012830: 98 1b 20 01 xor %o4, 1, %o4 2012834: 9a 10 00 1c mov %i4, %o5 2012838: 40 00 01 94 call 2012e88 <_CORE_message_queue_Seize> 201283c: 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 ) 2012840: 05 00 80 99 sethi %hi(0x2026400), %g2 2012844: c2 00 a0 80 ld [ %g2 + 0x80 ], %g1 ! 2026480 <_Thread_Dispatch_disable_level> 2012848: 82 00 7f ff add %g1, -1, %g1 201284c: c2 20 a0 80 st %g1, [ %g2 + 0x80 ] 2012850: c2 00 a0 80 ld [ %g2 + 0x80 ], %g1 2012854: 80 a0 60 00 cmp %g1, 0 2012858: 12 80 00 05 bne 201286c 201285c: 03 00 80 99 sethi %hi(0x2026400), %g1 _Thread_Dispatch(); 2012860: 7f ff ea c7 call 200d37c <_Thread_Dispatch> 2012864: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 2012868: 03 00 80 99 sethi %hi(0x2026400), %g1 201286c: c2 00 61 60 ld [ %g1 + 0x160 ], %g1 ! 2026560 <_Thread_Executing> 2012870: 40 00 00 32 call 2012938 <_Message_queue_Translate_core_message_queue_return_code> 2012874: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012878: 81 c7 e0 08 ret 201287c: 91 e8 00 08 restore %g0, %o0, %o0 size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 2012880: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012884: b0 10 00 08 mov %o0, %i0 2012888: 81 c7 e0 08 ret 201288c: 81 e8 00 00 restore 02012890 : rtems_status_code rtems_message_queue_send( Objects_Id id, void *buffer, size_t size ) { 2012890: 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 ) 2012894: 80 a6 60 00 cmp %i1, 0 2012898: 02 80 00 26 be 2012930 201289c: 90 10 20 09 mov 9, %o0 20128a0: 11 00 80 9a sethi %hi(0x2026800), %o0 20128a4: 92 10 00 18 mov %i0, %o1 20128a8: 90 12 20 1c or %o0, 0x1c, %o0 20128ac: 7f ff e5 af call 200bf68 <_Objects_Get> 20128b0: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 20128b4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20128b8: 80 a0 60 00 cmp %g1, 0 20128bc: 22 80 00 07 be,a 20128d8 20128c0: 94 10 00 1a mov %i2, %o2 20128c4: 80 a0 60 02 cmp %g1, 2 20128c8: 08 80 00 1a bleu 2012930 20128cc: 90 10 20 04 mov 4, %o0 20128d0: 10 80 00 18 b 2012930 <== NOT EXECUTED 20128d4: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 20128d8: c0 23 a0 5c clr [ %sp + 0x5c ] 20128dc: c0 23 a0 60 clr [ %sp + 0x60 ] 20128e0: 92 10 00 19 mov %i1, %o1 20128e4: 96 10 00 18 mov %i0, %o3 20128e8: 98 10 20 00 clr %o4 20128ec: 90 02 20 14 add %o0, 0x14, %o0 20128f0: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5 20128f4: 40 00 01 b2 call 2012fbc <_CORE_message_queue_Submit> 20128f8: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff 20128fc: 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 ) 2012900: 05 00 80 99 sethi %hi(0x2026400), %g2 2012904: c2 00 a0 80 ld [ %g2 + 0x80 ], %g1 ! 2026480 <_Thread_Dispatch_disable_level> 2012908: 82 00 7f ff add %g1, -1, %g1 201290c: c2 20 a0 80 st %g1, [ %g2 + 0x80 ] 2012910: c2 00 a0 80 ld [ %g2 + 0x80 ], %g1 2012914: 80 a0 60 00 cmp %g1, 0 2012918: 12 80 00 04 bne 2012928 201291c: 01 00 00 00 nop _Thread_Dispatch(); 2012920: 7f ff ea 97 call 200d37c <_Thread_Dispatch> 2012924: 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); 2012928: 40 00 00 04 call 2012938 <_Message_queue_Translate_core_message_queue_return_code> 201292c: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012930: 81 c7 e0 08 ret 2012934: 91 e8 00 08 restore %g0, %o0, %o0 02008300 : rtems_status_code rtems_message_queue_urgent( Objects_Id id, void *buffer, size_t size ) { 2008300: 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 ) 2008304: 80 a6 60 00 cmp %i1, 0 2008308: 02 80 00 25 be 200839c 200830c: 90 10 20 09 mov 9, %o0 2008310: 11 00 80 7d sethi %hi(0x201f400), %o0 2008314: 92 10 00 18 mov %i0, %o1 2008318: 90 12 22 b8 or %o0, 0x2b8, %o0 200831c: 40 00 09 dd call 200aa90 <_Objects_Get> 2008320: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 2008324: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008328: 80 a0 60 00 cmp %g1, 0 200832c: 22 80 00 07 be,a 2008348 2008330: 94 10 00 1a mov %i2, %o2 2008334: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2008338: 08 80 00 19 bleu 200839c <== NOT EXECUTED 200833c: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED 2008340: 10 80 00 17 b 200839c <== NOT EXECUTED 2008344: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 2008348: c0 23 a0 5c clr [ %sp + 0x5c ] 200834c: c0 23 a0 60 clr [ %sp + 0x60 ] 2008350: 92 10 00 19 mov %i1, %o1 2008354: 96 10 00 18 mov %i0, %o3 2008358: 98 10 20 00 clr %o4 200835c: 1b 20 00 00 sethi %hi(0x80000000), %o5 2008360: 40 00 05 c7 call 2009a7c <_CORE_message_queue_Submit> 2008364: 90 02 20 14 add %o0, 0x14, %o0 2008368: 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 ) 200836c: 03 00 80 7c sethi %hi(0x201f000), %g1 2008370: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 201f3a0 <_Thread_Dispatch_disable_level> 2008374: 84 00 bf ff add %g2, -1, %g2 2008378: c4 20 63 a0 st %g2, [ %g1 + 0x3a0 ] 200837c: c2 00 63 a0 ld [ %g1 + 0x3a0 ], %g1 2008380: 80 a0 60 00 cmp %g1, 0 2008384: 12 80 00 04 bne 2008394 2008388: 01 00 00 00 nop _Thread_Dispatch(); 200838c: 40 00 0e c6 call 200bea4 <_Thread_Dispatch> 2008390: 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); 2008394: 7f ff ff d1 call 20082d8 <_Message_queue_Translate_core_message_queue_return_code> 2008398: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200839c: 81 c7 e0 08 ret 20083a0: 91 e8 00 08 restore %g0, %o0, %o0 0200ed5c : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 200ed5c: 9d e3 bf 98 save %sp, -104, %sp register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 200ed60: a6 96 20 00 orcc %i0, 0, %l3 200ed64: 02 80 00 1e be 200eddc 200ed68: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 200ed6c: 80 a6 60 00 cmp %i1, 0 200ed70: 02 80 00 3d be 200ee64 200ed74: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 200ed78: 02 80 00 3b be 200ee64 200ed7c: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 200ed80: 22 80 00 17 be,a 200eddc 200ed84: b0 10 20 08 mov 8, %i0 200ed88: 80 a6 e0 00 cmp %i3, 0 200ed8c: 22 80 00 14 be,a 200eddc 200ed90: b0 10 20 08 mov 8, %i0 200ed94: 80 a6 80 1b cmp %i2, %i3 200ed98: 0a 80 00 35 bcs 200ee6c 200ed9c: 80 8e e0 07 btst 7, %i3 200eda0: 12 80 00 33 bne 200ee6c 200eda4: 80 8e 60 07 btst 7, %i1 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 200eda8: 12 80 00 2f bne 200ee64 200edac: 05 00 80 c3 sethi %hi(0x2030c00), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200edb0: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 200edb4: 82 00 60 01 inc %g1 200edb8: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 200edbc: 25 00 80 c3 sethi %hi(0x2030c00), %l2 200edc0: 40 00 15 b6 call 2014498 <_Objects_Allocate> 200edc4: 90 14 a1 30 or %l2, 0x130, %o0 ! 2030d30 <_Partition_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 200edc8: a2 92 20 00 orcc %o0, 0, %l1 200edcc: 12 80 00 06 bne 200ede4 200edd0: 92 10 00 1b mov %i3, %o1 _Thread_Enable_dispatch(); 200edd4: 7f ff ff d5 call 200ed28 <_Thread_Enable_dispatch> 200edd8: b0 10 20 05 mov 5, %i0 200eddc: 81 c7 e0 08 ret 200ede0: 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; 200ede4: f8 24 60 1c st %i4, [ %l1 + 0x1c ] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 200ede8: f2 24 60 10 st %i1, [ %l1 + 0x10 ] the_partition->length = length; 200edec: f4 24 60 14 st %i2, [ %l1 + 0x14 ] the_partition->buffer_size = buffer_size; 200edf0: f6 24 60 18 st %i3, [ %l1 + 0x18 ] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 200edf4: c0 24 60 20 clr [ %l1 + 0x20 ] _Chain_Initialize( &the_partition->Memory, starting_address, 200edf8: 40 00 52 db call 2023964 <.udiv> 200edfc: 90 10 00 1a mov %i2, %o0 200ee00: a0 04 60 24 add %l1, 0x24, %l0 200ee04: 94 10 00 08 mov %o0, %o2 200ee08: 92 10 00 19 mov %i1, %o1 200ee0c: 90 10 00 10 mov %l0, %o0 200ee10: 40 00 11 89 call 2013434 <_Chain_Initialize> 200ee14: 96 10 00 1b mov %i3, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ee18: 90 14 a1 30 or %l2, 0x130, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200ee1c: c4 04 60 08 ld [ %l1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ee20: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200ee24: 03 00 00 3f sethi %hi(0xfc00), %g1 200ee28: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200ee2c: 82 08 80 01 and %g2, %g1, %g1 200ee30: 80 a0 40 03 cmp %g1, %g3 200ee34: 38 80 00 06 bgu,a 200ee4c 200ee38: c2 04 60 08 ld [ %l1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200ee3c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200ee40: 83 28 60 02 sll %g1, 2, %g1 200ee44: e2 20 80 01 st %l1, [ %g2 + %g1 ] &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 200ee48: c2 04 60 08 ld [ %l1 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200ee4c: e6 24 60 0c st %l3, [ %l1 + 0xc ] 200ee50: c2 27 40 00 st %g1, [ %i5 ] name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 200ee54: 7f ff ff b5 call 200ed28 <_Thread_Enable_dispatch> 200ee58: b0 10 20 00 clr %i0 200ee5c: 81 c7 e0 08 ret 200ee60: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 200ee64: 81 c7 e0 08 ret 200ee68: 91 e8 20 09 restore %g0, 9, %o0 200ee6c: b0 10 20 08 mov 8, %i0 } 200ee70: 81 c7 e0 08 ret 200ee74: 81 e8 00 00 restore 0200eeac : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 200eeac: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200eeb0: 92 10 00 18 mov %i0, %o1 200eeb4: 94 07 bf f4 add %fp, -12, %o2 200eeb8: 31 00 80 c3 sethi %hi(0x2030c00), %i0 200eebc: 40 00 16 cf call 20149f8 <_Objects_Get> 200eec0: 90 16 21 30 or %i0, 0x130, %o0 ! 2030d30 <_Partition_Information> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200eec4: c2 07 bf f4 ld [ %fp + -12 ], %g1 200eec8: 80 a0 60 00 cmp %g1, 0 200eecc: 02 80 00 07 be 200eee8 200eed0: 88 10 00 08 mov %o0, %g4 200eed4: 80 a0 60 02 cmp %g1, 2 200eed8: 08 80 00 18 bleu 200ef38 200eedc: b0 10 20 04 mov 4, %i0 200eee0: 81 c7 e0 08 ret <== NOT EXECUTED 200eee4: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 200eee8: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 200eeec: 80 a0 60 00 cmp %g1, 0 200eef0: 12 80 00 14 bne 200ef40 200eef4: 90 16 21 30 or %i0, 0x130, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200eef8: c2 01 20 08 ld [ %g4 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200eefc: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200ef00: 05 00 00 3f sethi %hi(0xfc00), %g2 200ef04: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200ef08: 82 08 40 02 and %g1, %g2, %g1 200ef0c: 80 a0 40 03 cmp %g1, %g3 200ef10: 18 80 00 05 bgu 200ef24 200ef14: 92 10 00 04 mov %g4, %o1 information->local_table[ index ] = the_object; 200ef18: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200ef1c: 83 28 60 02 sll %g1, 2, %g1 200ef20: 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; 200ef24: c0 21 20 0c clr [ %g4 + 0xc ] RTEMS_INLINE_ROUTINE void _Partition_Free ( Partition_Control *the_partition ) { _Objects_Free( &_Partition_Information, &the_partition->Object ); 200ef28: 40 00 16 5e call 20148a0 <_Objects_Free> 200ef2c: b0 10 20 00 clr %i0 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 200ef30: 7f ff ff d2 call 200ee78 <_Thread_Enable_dispatch> 200ef34: 01 00 00 00 nop 200ef38: 81 c7 e0 08 ret 200ef3c: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 200ef40: 7f ff ff ce call 200ee78 <_Thread_Enable_dispatch> 200ef44: b0 10 20 0c mov 0xc, %i0 return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200ef48: 81 c7 e0 08 ret 200ef4c: 81 e8 00 00 restore 0200ef84 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 200ef84: 9d e3 bf 90 save %sp, -112, %sp 200ef88: 92 10 00 18 mov %i0, %o1 register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 200ef8c: 80 a6 60 00 cmp %i1, 0 200ef90: 02 80 00 1a be 200eff8 200ef94: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200ef98: 11 00 80 c3 sethi %hi(0x2030c00), %o0 200ef9c: 94 07 bf f4 add %fp, -12, %o2 200efa0: 40 00 16 96 call 20149f8 <_Objects_Get> 200efa4: 90 12 21 30 or %o0, 0x130, %o0 return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200efa8: c2 07 bf f4 ld [ %fp + -12 ], %g1 200efac: 80 a0 60 00 cmp %g1, 0 200efb0: 02 80 00 07 be 200efcc 200efb4: b0 10 00 08 mov %o0, %i0 200efb8: 80 a0 60 02 cmp %g1, 2 200efbc: 08 80 00 0f bleu 200eff8 200efc0: b0 10 20 04 mov 4, %i0 200efc4: 81 c7 e0 08 ret <== NOT EXECUTED 200efc8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 200efcc: 40 00 11 0a call 20133f4 <_Chain_Get> 200efd0: 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 ) { 200efd4: a0 92 20 00 orcc %o0, 0, %l0 200efd8: 02 80 00 0a be 200f000 200efdc: 01 00 00 00 nop the_partition->number_of_used_blocks += 1; 200efe0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 200efe4: 82 00 60 01 inc %g1 200efe8: c2 26 20 20 st %g1, [ %i0 + 0x20 ] _Thread_Enable_dispatch(); 200efec: 7f ff ff d9 call 200ef50 <_Thread_Enable_dispatch> 200eff0: b0 10 20 00 clr %i0 *buffer = the_buffer; 200eff4: e0 26 40 00 st %l0, [ %i1 ] 200eff8: 81 c7 e0 08 ret 200effc: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 200f000: 7f ff ff d4 call 200ef50 <_Thread_Enable_dispatch> 200f004: b0 10 20 0d mov 0xd, %i0 return RTEMS_UNSATISFIED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f008: 81 c7 e0 08 ret 200f00c: 81 e8 00 00 restore 0200f078 : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 200f078: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200f07c: 11 00 80 c3 sethi %hi(0x2030c00), %o0 200f080: 92 10 00 18 mov %i0, %o1 200f084: 90 12 21 30 or %o0, 0x130, %o0 200f088: 40 00 16 5c call 20149f8 <_Objects_Get> 200f08c: 94 07 bf f4 add %fp, -12, %o2 register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f090: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f094: 80 a0 60 00 cmp %g1, 0 200f098: 02 80 00 07 be 200f0b4 200f09c: b0 10 00 08 mov %o0, %i0 200f0a0: 80 a0 60 02 cmp %g1, 2 200f0a4: 08 80 00 1a bleu 200f10c 200f0a8: b0 10 20 04 mov 4, %i0 200f0ac: 81 c7 e0 08 ret <== NOT EXECUTED 200f0b0: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED ) { void *starting; void *ending; starting = the_partition->starting_address; 200f0b4: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( 200f0b8: 80 a6 40 02 cmp %i1, %g2 200f0bc: 0a 80 00 16 bcs 200f114 200f0c0: 01 00 00 00 nop 200f0c4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200f0c8: 82 00 80 01 add %g2, %g1, %g1 200f0cc: 80 a6 40 01 cmp %i1, %g1 200f0d0: 18 80 00 11 bgu 200f114 200f0d4: 01 00 00 00 nop 200f0d8: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 200f0dc: 40 00 52 ce call 2023c14 <.urem> 200f0e0: 90 26 40 02 sub %i1, %g2, %o0 200f0e4: 80 a2 20 00 cmp %o0, 0 200f0e8: 12 80 00 0b bne 200f114 200f0ec: 90 06 20 24 add %i0, 0x24, %o0 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 200f0f0: 40 00 10 b5 call 20133c4 <_Chain_Append> 200f0f4: 92 10 00 19 mov %i1, %o1 return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 200f0f8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 200f0fc: 82 00 7f ff add %g1, -1, %g1 200f100: c2 26 20 20 st %g1, [ %i0 + 0x20 ] _Thread_Enable_dispatch(); 200f104: 7f ff ff d0 call 200f044 <_Thread_Enable_dispatch> 200f108: b0 10 20 00 clr %i0 200f10c: 81 c7 e0 08 ret 200f110: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 200f114: 7f ff ff cc call 200f044 <_Thread_Enable_dispatch> 200f118: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f11c: 81 c7 e0 08 ret 200f120: 81 e8 00 00 restore 0200df20 : void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) { 200df20: 9d e3 bf 98 save %sp, -104, %sp register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 200df24: a2 96 20 00 orcc %i0, 0, %l1 200df28: 02 80 00 15 be 200df7c 200df2c: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 200df30: 80 a7 20 00 cmp %i4, 0 200df34: 02 80 00 29 be 200dfd8 200df38: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 200df3c: 12 80 00 27 bne 200dfd8 200df40: 80 8e a0 07 btst 7, %i2 200df44: 32 80 00 0e bne,a 200df7c 200df48: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200df4c: 05 00 80 c3 sethi %hi(0x2030c00), %g2 200df50: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 200df54: 82 00 60 01 inc %g1 200df58: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] */ RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Allocate ( void ) { return (Dual_ported_memory_Control *) 200df5c: 21 00 80 c3 sethi %hi(0x2030c00), %l0 200df60: 40 00 19 4e call 2014498 <_Objects_Allocate> 200df64: 90 14 20 e4 or %l0, 0xe4, %o0 ! 2030ce4 <_Dual_ported_memory_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 200df68: 80 a2 20 00 cmp %o0, 0 200df6c: 12 80 00 06 bne 200df84 200df70: 88 14 20 e4 or %l0, 0xe4, %g4 _Thread_Enable_dispatch(); 200df74: 7f ff ff de call 200deec <_Thread_Enable_dispatch> 200df78: b0 10 20 05 mov 5, %i0 200df7c: 81 c7 e0 08 ret 200df80: 81 e8 00 00 restore ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200df84: c4 02 20 08 ld [ %o0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200df88: c6 11 20 10 lduh [ %g4 + 0x10 ], %g3 return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; the_port->external_base = external_start; the_port->length = length - 1; 200df8c: 82 06 ff ff add %i3, -1, %g1 if ( !the_port ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 200df90: f2 22 20 10 st %i1, [ %o0 + 0x10 ] the_port->external_base = external_start; the_port->length = length - 1; 200df94: c2 22 20 18 st %g1, [ %o0 + 0x18 ] 200df98: 03 00 00 3f sethi %hi(0xfc00), %g1 200df9c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200dfa0: 82 08 80 01 and %g2, %g1, %g1 200dfa4: 80 a0 40 03 cmp %g1, %g3 200dfa8: 18 80 00 05 bgu 200dfbc 200dfac: f4 22 20 14 st %i2, [ %o0 + 0x14 ] information->local_table[ index ] = the_object; 200dfb0: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 200dfb4: 83 28 60 02 sll %g1, 2, %g1 200dfb8: d0 20 80 01 st %o0, [ %g2 + %g1 ] &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 200dfbc: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200dfc0: e2 22 20 0c st %l1, [ %o0 + 0xc ] 200dfc4: c2 27 00 00 st %g1, [ %i4 ] _Thread_Enable_dispatch(); 200dfc8: 7f ff ff c9 call 200deec <_Thread_Enable_dispatch> 200dfcc: b0 10 20 00 clr %i0 200dfd0: 81 c7 e0 08 ret 200dfd4: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 200dfd8: b0 10 20 09 mov 9, %i0 } 200dfdc: 81 c7 e0 08 ret 200dfe0: 81 e8 00 00 restore 02006428 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) { 2006428: 9d e3 bf 98 save %sp, -104, %sp Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 200642c: a4 96 20 00 orcc %i0, 0, %l2 2006430: 02 80 00 11 be 2006474 2006434: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2006438: 80 a6 60 00 cmp %i1, 0 200643c: 02 80 00 0e be 2006474 2006440: b0 10 20 09 mov 9, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006444: 05 00 80 70 sethi %hi(0x201c000), %g2 2006448: c2 00 a2 a0 ld [ %g2 + 0x2a0 ], %g1 ! 201c2a0 <_Thread_Dispatch_disable_level> 200644c: 82 00 60 01 inc %g1 2006450: c2 20 a2 a0 st %g1, [ %g2 + 0x2a0 ] * the inactive chain of free period control blocks. */ RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void ) { return (Rate_monotonic_Control *) 2006454: 23 00 80 70 sethi %hi(0x201c000), %l1 2006458: 40 00 09 b7 call 2008b34 <_Objects_Allocate> 200645c: 90 14 61 04 or %l1, 0x104, %o0 ! 201c104 <_Rate_monotonic_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 2006460: a0 92 20 00 orcc %o0, 0, %l0 2006464: 12 80 00 06 bne 200647c 2006468: 03 00 80 70 sethi %hi(0x201c000), %g1 _Thread_Enable_dispatch(); 200646c: 7f ff ff e2 call 20063f4 <_Thread_Enable_dispatch> 2006470: b0 10 20 05 mov 5, %i0 2006474: 81 c7 e0 08 ret 2006478: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 200647c: c2 00 63 80 ld [ %g1 + 0x380 ], %g1 the_period->state = RATE_MONOTONIC_INACTIVE; 2006480: c0 24 20 38 clr [ %l0 + 0x38 ] if ( !the_period ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 2006484: c2 24 20 50 st %g1, [ %l0 + 0x50 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2006488: c0 24 20 18 clr [ %l0 + 0x18 ] the_watchdog->routine = routine; 200648c: c0 24 20 2c clr [ %l0 + 0x2c ] the_watchdog->id = id; 2006490: c0 24 20 30 clr [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 2006494: c0 24 20 34 clr [ %l0 + 0x34 ] the_period->state = RATE_MONOTONIC_INACTIVE; _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 2006498: 90 04 20 54 add %l0, 0x54, %o0 200649c: 92 10 20 00 clr %o1 20064a0: 40 00 25 ef call 200fc5c 20064a4: 94 10 20 38 mov 0x38, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20064a8: 90 14 61 04 or %l1, 0x104, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 20064ac: c4 04 20 08 ld [ %l0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20064b0: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 20064b4: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 20064b8: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff 20064bc: c2 24 20 78 st %g1, [ %l0 + 0x78 ] 20064c0: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 20064c4: c2 24 20 60 st %g1, [ %l0 + 0x60 ] 20064c8: c2 24 20 74 st %g1, [ %l0 + 0x74 ] 20064cc: 03 00 00 3f sethi %hi(0xfc00), %g1 20064d0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20064d4: 82 08 80 01 and %g2, %g1, %g1 20064d8: 80 a0 40 03 cmp %g1, %g3 20064dc: 38 80 00 06 bgu,a 20064f4 20064e0: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 20064e4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 20064e8: 83 28 60 02 sll %g1, 2, %g1 20064ec: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 20064f0: c2 04 20 08 ld [ %l0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 20064f4: e4 24 20 0c st %l2, [ %l0 + 0xc ] 20064f8: c2 26 40 00 st %g1, [ %i1 ] _Thread_Enable_dispatch(); 20064fc: 7f ff ff be call 20063f4 <_Thread_Enable_dispatch> 2006500: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 2006504: 81 c7 e0 08 ret 2006508: 81 e8 00 00 restore 0200f2f4 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 200f2f4: 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 *) 200f2f8: 21 00 80 c3 sethi %hi(0x2030c00), %l0 200f2fc: 92 10 00 18 mov %i0, %o1 200f300: 94 07 bf f4 add %fp, -12, %o2 200f304: 40 00 15 bd call 20149f8 <_Objects_Get> 200f308: 90 14 21 7c or %l0, 0x17c, %o0 Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200f30c: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f310: 80 a0 60 00 cmp %g1, 0 200f314: 02 80 00 08 be 200f334 200f318: b0 10 00 08 mov %o0, %i0 200f31c: 82 18 60 02 xor %g1, 2, %g1 200f320: 80 a0 00 01 cmp %g0, %g1 200f324: 82 60 20 00 subx %g0, 0, %g1 200f328: b0 08 60 15 and %g1, 0x15, %i0 200f32c: 81 c7 e0 08 ret 200f330: 91 ee 20 04 restore %i0, 4, %o0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f334: a0 14 21 7c or %l0, 0x17c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200f338: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f33c: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 200f340: 05 00 00 3f sethi %hi(0xfc00), %g2 200f344: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200f348: 82 08 40 02 and %g1, %g2, %g1 200f34c: 80 a0 40 03 cmp %g1, %g3 200f350: 38 80 00 06 bgu,a 200f368 200f354: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200f358: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 200f35c: 83 28 60 02 sll %g1, 2, %g1 200f360: 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; 200f364: 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 ); 200f368: 40 00 21 37 call 2017844 <_Watchdog_Remove> 200f36c: 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 ); 200f370: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_INACTIVE; 200f374: c0 26 20 38 clr [ %i0 + 0x38 ] 200f378: 40 00 15 4a call 20148a0 <_Objects_Free> 200f37c: 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 ) 200f380: 03 00 80 c3 sethi %hi(0x2030c00), %g1 200f384: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2030fb0 <_Thread_Dispatch_disable_level> 200f388: b0 10 20 00 clr %i0 200f38c: 84 00 bf ff add %g2, -1, %g2 200f390: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 200f394: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 200f398: 80 a0 60 00 cmp %g1, 0 200f39c: 12 80 00 04 bne 200f3ac 200f3a0: 01 00 00 00 nop _Thread_Dispatch(); 200f3a4: 40 00 1a 9a call 2015e0c <_Thread_Dispatch> 200f3a8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f3ac: 81 c7 e0 08 ret 200f3b0: 81 e8 00 00 restore 0200dd20 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 200dd20: 9d e3 bf 88 save %sp, -120, %sp 200dd24: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 200dd28: 80 a6 60 00 cmp %i1, 0 200dd2c: 02 80 00 36 be 200de04 200dd30: b0 10 20 09 mov 9, %i0 200dd34: 11 00 80 70 sethi %hi(0x201c000), %o0 200dd38: 94 07 bf f4 add %fp, -12, %o2 200dd3c: 7f ff ed 0b call 2009168 <_Objects_Get> 200dd40: 90 12 21 04 or %o0, 0x104, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200dd44: c2 07 bf f4 ld [ %fp + -12 ], %g1 200dd48: 80 a0 60 00 cmp %g1, 0 200dd4c: 02 80 00 08 be 200dd6c 200dd50: b0 10 00 08 mov %o0, %i0 200dd54: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 200dd58: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 200dd5c: 82 60 20 00 subx %g0, 0, %g1 <== NOT EXECUTED 200dd60: b0 08 60 15 and %g1, 0x15, %i0 <== NOT EXECUTED 200dd64: 81 c7 e0 08 ret <== NOT EXECUTED 200dd68: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 200dd6c: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 200dd70: 80 a0 60 00 cmp %g1, 0 200dd74: 02 80 00 03 be 200dd80 200dd78: 84 10 20 00 clr %g2 200dd7c: c4 00 60 08 ld [ %g1 + 8 ], %g2 status->state = the_period->state; 200dd80: 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); 200dd84: c4 26 40 00 st %g2, [ %i1 ] status->state = the_period->state; if ( status->state == RATE_MONOTONIC_INACTIVE ) { 200dd88: 80 a0 60 00 cmp %g1, 0 200dd8c: 12 80 00 07 bne 200dda8 200dd90: 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; 200dd94: 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; 200dd98: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 200dd9c: 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; 200dda0: 10 80 00 0e b 200ddd8 <== NOT EXECUTED 200dda4: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED * This lets them share one single invocation of _TOD_Get_uptime(). */ #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 200dda8: a0 07 bf ec add %fp, -20, %l0 200ddac: 7f ff e9 c0 call 20084ac <_TOD_Get_uptime> 200ddb0: 90 10 00 10 mov %l0, %o0 #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 200ddb4: 90 06 20 44 add %i0, 0x44, %o0 200ddb8: 92 10 00 10 mov %l0, %o1 200ddbc: 7f ff f6 a6 call 200b854 <_Timespec_Subtract> 200ddc0: 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( 200ddc4: 11 00 80 70 sethi %hi(0x201c000), %o0 200ddc8: 92 10 00 10 mov %l0, %o1 200ddcc: 94 06 60 10 add %i1, 0x10, %o2 200ddd0: 7f ff f6 a1 call 200b854 <_Timespec_Subtract> 200ddd4: 90 12 23 88 or %o0, 0x388, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200ddd8: 03 00 80 70 sethi %hi(0x201c000), %g1 200dddc: c4 00 62 a0 ld [ %g1 + 0x2a0 ], %g2 ! 201c2a0 <_Thread_Dispatch_disable_level> 200dde0: b0 10 20 00 clr %i0 200dde4: 84 00 bf ff add %g2, -1, %g2 200dde8: c4 20 62 a0 st %g2, [ %g1 + 0x2a0 ] 200ddec: c2 00 62 a0 ld [ %g1 + 0x2a0 ], %g1 200ddf0: 80 a0 60 00 cmp %g1, 0 200ddf4: 12 80 00 04 bne 200de04 200ddf8: 01 00 00 00 nop _Thread_Dispatch(); 200ddfc: 7f ff f1 e0 call 200a57c <_Thread_Dispatch> 200de00: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200de04: 81 c7 e0 08 ret 200de08: 81 e8 00 00 restore 02006714 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 2006714: 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 *) 2006718: 11 00 80 70 sethi %hi(0x201c000), %o0 200671c: 92 10 00 18 mov %i0, %o1 2006720: 90 12 21 04 or %o0, 0x104, %o0 2006724: 40 00 0a 91 call 2009168 <_Objects_Get> 2006728: 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 ) { 200672c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006730: 80 a0 60 00 cmp %g1, 0 2006734: 02 80 00 07 be 2006750 2006738: a2 10 00 08 mov %o0, %l1 200673c: 80 a0 60 02 cmp %g1, 2 2006740: 02 80 00 0c be 2006770 2006744: b0 10 20 04 mov 4, %i0 the_period->state = RATE_MONOTONIC_ACTIVE; the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_TIMEOUT; 2006748: 81 c7 e0 08 ret <== NOT EXECUTED 200674c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 2006750: 27 00 80 70 sethi %hi(0x201c000), %l3 2006754: c4 02 20 50 ld [ %o0 + 0x50 ], %g2 2006758: c2 04 e3 80 ld [ %l3 + 0x380 ], %g1 200675c: 80 a0 80 01 cmp %g2, %g1 2006760: 02 80 00 06 be 2006778 2006764: 80 a6 60 00 cmp %i1, 0 _Thread_Enable_dispatch(); 2006768: 7f ff ff 7f call 2006564 <_Thread_Enable_dispatch> 200676c: b0 10 20 17 mov 0x17, %i0 2006770: 81 c7 e0 08 ret 2006774: 81 e8 00 00 restore return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 2006778: 12 80 00 11 bne 20067bc 200677c: 01 00 00 00 nop switch ( the_period->state ) { 2006780: d0 02 20 38 ld [ %o0 + 0x38 ], %o0 2006784: 80 a2 20 02 cmp %o0, 2 2006788: 02 80 00 09 be 20067ac 200678c: b0 10 20 00 clr %i0 2006790: 80 a2 20 04 cmp %o0, 4 2006794: 02 80 00 06 be 20067ac 2006798: b0 10 20 06 mov 6, %i0 200679c: 80 a2 20 00 cmp %o0, 0 20067a0: 02 80 00 03 be 20067ac 20067a4: b0 10 20 0b mov 0xb, %i0 20067a8: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED break; default: /* unreached -- only to remove warnings */ return_value = RTEMS_INTERNAL_ERROR; break; } _Thread_Enable_dispatch(); 20067ac: 7f ff ff 6e call 2006564 <_Thread_Enable_dispatch> 20067b0: 01 00 00 00 nop 20067b4: 81 c7 e0 08 ret 20067b8: 81 e8 00 00 restore return( return_value ); } _ISR_Disable( level ); 20067bc: 7f ff f0 43 call 20028c8 20067c0: 01 00 00 00 nop 20067c4: a0 10 00 08 mov %o0, %l0 switch ( the_period->state ) { 20067c8: e4 04 60 38 ld [ %l1 + 0x38 ], %l2 20067cc: 80 a4 a0 02 cmp %l2, 2 20067d0: 02 80 00 29 be 2006874 20067d4: 80 a4 a0 04 cmp %l2, 4 20067d8: 02 80 00 43 be 20068e4 20067dc: 80 a4 a0 00 cmp %l2, 0 20067e0: 32 bf ff e4 bne,a 2006770 20067e4: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED /* * No need to update statistics -- there are not a period active */ _ISR_Enable( level ); 20067e8: 7f ff f0 3c call 20028d8 20067ec: 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 ); 20067f0: 40 00 07 2f call 20084ac <_TOD_Get_uptime> 20067f4: 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; 20067f8: c2 07 bf ec ld [ %fp + -20 ], %g1 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 20067fc: c4 04 e3 80 ld [ %l3 + 0x380 ], %g2 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS /* * Since the statistics didn't update the starting time, * we do it here. */ the_period->time_at_period = uptime; 2006800: c2 24 60 44 st %g1, [ %l1 + 0x44 ] 2006804: 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( 2006808: 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; 200680c: c2 24 60 48 st %g1, [ %l1 + 0x48 ] #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006810: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006814: a0 07 bf e4 add %fp, -28, %l0 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006818: c2 24 60 3c st %g1, [ %l1 + 0x3c ] 200681c: c2 00 a0 94 ld [ %g2 + 0x94 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006820: 94 10 00 10 mov %l0, %o2 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006824: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006828: 11 00 80 70 sethi %hi(0x201c000), %o0 200682c: 40 00 14 0a call 200b854 <_Timespec_Subtract> 2006830: 90 12 23 88 or %o0, 0x388, %o0 ! 201c388 <_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 ); 2006834: 92 10 00 10 mov %l0, %o1 2006838: 40 00 13 a6 call 200b6d0 <_Timespec_Add_to> 200683c: 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; 2006840: 82 10 20 02 mov 2, %g1 2006844: c2 24 60 38 st %g1, [ %l1 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2006848: 03 00 80 1b sethi %hi(0x2006c00), %g1 200684c: 82 10 60 7c or %g1, 0x7c, %g1 ! 2006c7c <_Rate_monotonic_Timeout> NULL ); the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); 2006850: 90 04 60 10 add %l1, 0x10, %o0 2006854: 92 10 00 19 mov %i1, %o1 the_watchdog->id = id; 2006858: f0 24 60 30 st %i0, [ %l1 + 0x30 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200685c: c0 24 60 18 clr [ %l1 + 0x18 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2006860: c0 24 60 34 clr [ %l1 + 0x34 ] _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 2006864: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert_ticks( &the_period->Timer, length ); 2006868: 7f ff ff 37 call 2006544 <_Watchdog_Insert_ticks> 200686c: c2 24 60 2c st %g1, [ %l1 + 0x2c ] 2006870: 30 80 00 19 b,a 20068d4 case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 2006874: 7f ff ff 49 call 2006598 <_Rate_monotonic_Update_statistics> 2006878: 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; 200687c: 82 10 20 01 mov 1, %g1 the_period->next_length = length; 2006880: 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; 2006884: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; _ISR_Enable( level ); 2006888: 7f ff f0 14 call 20028d8 200688c: 90 10 00 10 mov %l0, %o0 _Thread_Executing->Wait.id = the_period->Object.id; 2006890: c2 04 e3 80 ld [ %l3 + 0x380 ], %g1 2006894: c4 04 60 08 ld [ %l1 + 8 ], %g2 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 2006898: 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; 200689c: c4 20 60 20 st %g2, [ %g1 + 0x20 ] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 20068a0: 40 00 12 62 call 200b228 <_Thread_Set_state> 20068a4: 13 00 00 10 sethi %hi(0x4000), %o1 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 20068a8: 7f ff f0 08 call 20028c8 20068ac: 01 00 00 00 nop local_state = the_period->state; 20068b0: e0 04 60 38 ld [ %l1 + 0x38 ], %l0 the_period->state = RATE_MONOTONIC_ACTIVE; 20068b4: e4 24 60 38 st %l2, [ %l1 + 0x38 ] _ISR_Enable( level ); 20068b8: 7f ff f0 08 call 20028d8 20068bc: 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 ) 20068c0: 80 a4 20 03 cmp %l0, 3 20068c4: 12 80 00 04 bne 20068d4 20068c8: d0 04 e3 80 ld [ %l3 + 0x380 ], %o0 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 20068cc: 40 00 0e 61 call 200a250 <_Thread_Clear_state> <== NOT EXECUTED 20068d0: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED _Thread_Enable_dispatch(); 20068d4: 7f ff ff 24 call 2006564 <_Thread_Enable_dispatch> 20068d8: b0 10 20 00 clr %i0 20068dc: 81 c7 e0 08 ret 20068e0: 81 e8 00 00 restore case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 20068e4: 7f ff ff 2d call 2006598 <_Rate_monotonic_Update_statistics> 20068e8: 90 10 00 11 mov %l1, %o0 _ISR_Enable( level ); 20068ec: 7f ff ef fb call 20028d8 20068f0: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 20068f4: 82 10 20 02 mov 2, %g1 the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); 20068f8: 90 04 60 10 add %l1, 0x10, %o0 20068fc: 92 10 00 19 mov %i1, %o1 */ _Rate_monotonic_Update_statistics( the_period ); _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 2006900: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; 2006904: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert_ticks( &the_period->Timer, length ); 2006908: 7f ff ff 0f call 2006544 <_Watchdog_Insert_ticks> 200690c: b0 10 20 06 mov 6, %i0 _Thread_Enable_dispatch(); 2006910: 7f ff ff 15 call 2006564 <_Thread_Enable_dispatch> 2006914: 01 00 00 00 nop 2006918: 81 c7 e0 08 ret 200691c: 81 e8 00 00 restore break; } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006920: 81 c7 e0 08 ret <== NOT EXECUTED 2006924: 81 e8 00 00 restore <== NOT EXECUTED 02006928 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 2006928: 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 ) 200692c: 80 a6 60 00 cmp %i1, 0 2006930: 02 80 00 7f be 2006b2c 2006934: 90 10 00 18 mov %i0, %o0 return; (*print)( context, "Period information by period\n" ); 2006938: 13 00 80 66 sethi %hi(0x2019800), %o1 200693c: 9f c6 40 00 call %i1 2006940: 92 12 63 60 or %o1, 0x360, %o1 ! 2019b60 #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 2006944: 90 10 00 18 mov %i0, %o0 2006948: 13 00 80 66 sethi %hi(0x2019800), %o1 200694c: 9f c6 40 00 call %i1 2006950: 92 12 63 80 or %o1, 0x380, %o1 ! 2019b80 #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 2006954: 90 10 00 18 mov %i0, %o0 2006958: 13 00 80 66 sethi %hi(0x2019800), %o1 200695c: 9f c6 40 00 call %i1 2006960: 92 12 63 a8 or %o1, 0x3a8, %o1 ! 2019ba8 Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 2006964: 90 10 00 18 mov %i0, %o0 2006968: 13 00 80 66 sethi %hi(0x2019800), %o1 200696c: 9f c6 40 00 call %i1 2006970: 92 12 63 d0 or %o1, 0x3d0, %o1 ! 2019bd0 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 2006974: 90 10 00 18 mov %i0, %o0 2006978: 13 00 80 67 sethi %hi(0x2019c00), %o1 200697c: 9f c6 40 00 call %i1 2006980: 92 12 60 20 or %o1, 0x20, %o1 ! 2019c20 /* * 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 ; 2006984: 03 00 80 70 sethi %hi(0x201c000), %g1 2006988: 82 10 61 04 or %g1, 0x104, %g1 ! 201c104 <_Rate_monotonic_Information> 200698c: e4 00 60 08 ld [ %g1 + 8 ], %l2 _Timespec_Divide_by_integer( &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 2006990: 03 00 80 67 sethi %hi(0x2019c00), %g1 2006994: b4 10 60 88 or %g1, 0x88, %i2 ! 2019c88 _Timespec_Divide_by_integer( &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 2006998: 03 00 80 67 sethi %hi(0x2019c00), %g1 * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 200699c: ba 07 bf 98 add %fp, -104, %i5 _Timespec_Divide_by_integer( &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 20069a0: b6 10 60 a8 or %g1, 0xa8, %i3 status = rtems_rate_monotonic_get_statistics( id, &the_stats ); if ( status != RTEMS_SUCCESSFUL ) continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 20069a4: ae 07 bf d0 add %fp, -48, %l7 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 20069a8: 03 00 80 66 sethi %hi(0x2019800), %g1 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 20069ac: a8 07 bf f3 add %fp, -13, %l4 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 20069b0: b8 10 63 a0 or %g1, 0x3a0, %i4 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 20069b4: ac 07 bf b0 add %fp, -80, %l6 20069b8: a6 07 bf e8 add %fp, -24, %l3 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 20069bc: 10 80 00 56 b 2006b14 20069c0: aa 07 bf c8 add %fp, -56, %l5 * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 20069c4: 40 00 1c b3 call 200dc90 20069c8: 92 10 00 1d mov %i5, %o1 if ( status != RTEMS_SUCCESSFUL ) 20069cc: 80 a2 20 00 cmp %o0, 0 20069d0: 32 80 00 51 bne,a 2006b14 20069d4: a4 04 a0 01 inc %l2 continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 20069d8: 92 10 00 17 mov %l7, %o1 20069dc: 40 00 1c d1 call 200dd20 20069e0: 90 10 00 12 mov %l2, %o0 if ( status != RTEMS_SUCCESSFUL ) 20069e4: 80 a2 20 00 cmp %o0, 0 20069e8: 32 80 00 4b bne,a 2006b14 20069ec: a4 04 a0 01 inc %l2 <== NOT EXECUTED continue; name[ 0 ] = '\0'; if ( the_status.owner ) { 20069f0: d0 07 bf d0 ld [ %fp + -48 ], %o0 20069f4: 80 a2 20 00 cmp %o0, 0 20069f8: 02 80 00 05 be 2006a0c 20069fc: c0 2f bf f3 clrb [ %fp + -13 ] rtems_object_get_name( the_status.owner, sizeof(name), name ); 2006a00: 94 10 00 14 mov %l4, %o2 2006a04: 40 00 00 c8 call 2006d24 2006a08: 92 10 20 05 mov 5, %o1 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 2006a0c: d8 1f bf 98 ldd [ %fp + -104 ], %o4 2006a10: 94 10 00 12 mov %l2, %o2 2006a14: 96 10 00 14 mov %l4, %o3 2006a18: 13 00 80 67 sethi %hi(0x2019c00), %o1 2006a1c: 90 10 00 18 mov %i0, %o0 2006a20: 9f c6 40 00 call %i1 2006a24: 92 12 60 70 or %o1, 0x70, %o1 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006a28: c2 07 bf 98 ld [ %fp + -104 ], %g1 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006a2c: 94 10 00 13 mov %l3, %o2 2006a30: 90 10 00 16 mov %l6, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006a34: 80 a0 60 00 cmp %g1, 0 2006a38: 12 80 00 06 bne 2006a50 2006a3c: 92 10 00 1c mov %i4, %o1 (*print)( context, "\n" ); 2006a40: 9f c6 40 00 call %i1 2006a44: 90 10 00 18 mov %i0, %o0 * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 2006a48: 10 80 00 33 b 2006b14 2006a4c: a4 04 a0 01 inc %l2 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006a50: 40 00 13 38 call 200b730 <_Timespec_Divide_by_integer> 2006a54: 92 10 00 01 mov %g1, %o1 &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 2006a58: d0 07 bf a4 ld [ %fp + -92 ], %o0 2006a5c: 40 00 44 d8 call 2017dbc <.div> 2006a60: 92 10 23 e8 mov 0x3e8, %o1 2006a64: a2 10 00 08 mov %o0, %l1 2006a68: d0 07 bf ac ld [ %fp + -84 ], %o0 2006a6c: 40 00 44 d4 call 2017dbc <.div> 2006a70: 92 10 23 e8 mov 0x3e8, %o1 2006a74: c2 07 bf e8 ld [ %fp + -24 ], %g1 2006a78: a0 10 00 08 mov %o0, %l0 2006a7c: d0 07 bf ec ld [ %fp + -20 ], %o0 2006a80: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2006a84: 40 00 44 ce call 2017dbc <.div> 2006a88: 92 10 23 e8 mov 0x3e8, %o1 2006a8c: d8 07 bf a8 ld [ %fp + -88 ], %o4 2006a90: d4 07 bf a0 ld [ %fp + -96 ], %o2 2006a94: 96 10 00 11 mov %l1, %o3 2006a98: 9a 10 00 10 mov %l0, %o5 2006a9c: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 2006aa0: 92 10 00 1a mov %i2, %o1 2006aa4: 9f c6 40 00 call %i1 2006aa8: 90 10 00 18 mov %i0, %o0 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 2006aac: d2 07 bf 98 ld [ %fp + -104 ], %o1 2006ab0: 94 10 00 13 mov %l3, %o2 2006ab4: 40 00 13 1f call 200b730 <_Timespec_Divide_by_integer> 2006ab8: 90 10 00 15 mov %l5, %o0 &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 2006abc: d0 07 bf bc ld [ %fp + -68 ], %o0 2006ac0: 40 00 44 bf call 2017dbc <.div> 2006ac4: 92 10 23 e8 mov 0x3e8, %o1 2006ac8: a2 10 00 08 mov %o0, %l1 2006acc: d0 07 bf c4 ld [ %fp + -60 ], %o0 2006ad0: 40 00 44 bb call 2017dbc <.div> 2006ad4: 92 10 23 e8 mov 0x3e8, %o1 2006ad8: c2 07 bf e8 ld [ %fp + -24 ], %g1 2006adc: a0 10 00 08 mov %o0, %l0 2006ae0: d0 07 bf ec ld [ %fp + -20 ], %o0 2006ae4: 92 10 23 e8 mov 0x3e8, %o1 2006ae8: 40 00 44 b5 call 2017dbc <.div> 2006aec: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2006af0: d4 07 bf b8 ld [ %fp + -72 ], %o2 2006af4: d8 07 bf c0 ld [ %fp + -64 ], %o4 2006af8: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 2006afc: 96 10 00 11 mov %l1, %o3 2006b00: 9a 10 00 10 mov %l0, %o5 2006b04: 90 10 00 18 mov %i0, %o0 2006b08: 9f c6 40 00 call %i1 2006b0c: 92 10 00 1b mov %i3, %o1 * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 2006b10: 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 ; 2006b14: 05 00 80 70 sethi %hi(0x201c000), %g2 2006b18: 84 10 a1 04 or %g2, 0x104, %g2 ! 201c104 <_Rate_monotonic_Information> 2006b1c: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 2006b20: 80 a4 80 01 cmp %l2, %g1 2006b24: 08 bf ff a8 bleu 20069c4 2006b28: 90 10 00 12 mov %l2, %o0 2006b2c: 81 c7 e0 08 ret 2006b30: 81 e8 00 00 restore 02006b50 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 2006b50: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006b54: 03 00 80 70 sethi %hi(0x201c000), %g1 2006b58: c4 00 62 a0 ld [ %g1 + 0x2a0 ], %g2 ! 201c2a0 <_Thread_Dispatch_disable_level> 2006b5c: 84 00 a0 01 inc %g2 2006b60: c4 20 62 a0 st %g2, [ %g1 + 0x2a0 ] /* * 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 ; 2006b64: 03 00 80 70 sethi %hi(0x201c000), %g1 2006b68: 82 10 61 04 or %g1, 0x104, %g1 ! 201c104 <_Rate_monotonic_Information> 2006b6c: e0 00 60 08 ld [ %g1 + 8 ], %l0 id <= _Rate_monotonic_Information.maximum_id ; 2006b70: 10 80 00 04 b 2006b80 2006b74: a2 10 00 01 mov %g1, %l1 id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 2006b78: 40 00 00 12 call 2006bc0 2006b7c: 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 ; 2006b80: c2 04 60 0c ld [ %l1 + 0xc ], %g1 2006b84: 80 a4 00 01 cmp %l0, %g1 2006b88: 08 bf ff fc bleu 2006b78 2006b8c: 90 10 00 10 mov %l0, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006b90: 03 00 80 70 sethi %hi(0x201c000), %g1 2006b94: c4 00 62 a0 ld [ %g1 + 0x2a0 ], %g2 ! 201c2a0 <_Thread_Dispatch_disable_level> 2006b98: 84 00 bf ff add %g2, -1, %g2 2006b9c: c4 20 62 a0 st %g2, [ %g1 + 0x2a0 ] 2006ba0: c2 00 62 a0 ld [ %g1 + 0x2a0 ], %g1 2006ba4: 80 a0 60 00 cmp %g1, 0 2006ba8: 12 80 00 04 bne 2006bb8 2006bac: 01 00 00 00 nop _Thread_Dispatch(); 2006bb0: 40 00 0e 73 call 200a57c <_Thread_Dispatch> 2006bb4: 81 e8 00 00 restore 2006bb8: 81 c7 e0 08 ret <== NOT EXECUTED 2006bbc: 81 e8 00 00 restore <== NOT EXECUTED 0200f8cc : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 200f8cc: 9d e3 bf 98 save %sp, -104, %sp Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 200f8d0: a4 96 20 00 orcc %i0, 0, %l2 200f8d4: 02 80 00 87 be 200faf0 200f8d8: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 200f8dc: 80 a6 60 00 cmp %i1, 0 200f8e0: 02 80 00 c7 be 200fbfc 200f8e4: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 200f8e8: 02 80 00 c5 be 200fbfc 200f8ec: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 200f8f0: 32 80 00 80 bne,a 200faf0 200f8f4: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 200f8f8: 7f ff eb 8b call 200a724 200f8fc: 01 00 00 00 nop 200f900: a2 10 00 08 mov %o0, %l1 200f904: 03 00 80 c3 sethi %hi(0x2030c00), %g1 200f908: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 200f90c: 80 a0 60 00 cmp %g1, 0 200f910: 02 80 00 0b be 200f93c 200f914: 03 00 80 c4 sethi %hi(0x2031000), %g1 200f918: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 200f91c: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 2031190 <_System_state_Current> <== NOT EXECUTED 200f920: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200f924: 08 80 00 05 bleu 200f938 <== NOT EXECUTED 200f928: 90 10 20 00 clr %o0 <== NOT EXECUTED 200f92c: 92 10 20 00 clr %o1 <== NOT EXECUTED 200f930: 40 00 12 ad call 20143e4 <_Internal_error_Occurred> <== NOT EXECUTED 200f934: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200f938: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 200f93c: e0 00 60 88 ld [ %g1 + 0x88 ], %l0 ! 2031088 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200f940: 03 00 80 c4 sethi %hi(0x2031000), %g1 200f944: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2031090 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200f948: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200f94c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 200f950: 80 a0 60 00 cmp %g1, 0 200f954: 22 80 00 30 be,a 200fa14 200f958: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200f95c: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200f960: 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; 200f964: 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; 200f968: 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; 200f96c: 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; 200f970: 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 ) || 200f974: 80 a0 e0 02 cmp %g3, 2 200f978: 02 80 00 05 be 200f98c 200f97c: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 200f980: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200f984: 12 80 00 07 bne 200f9a0 <== NOT EXECUTED 200f988: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200f98c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200f990: 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++; 200f994: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200f998: 02 80 00 03 be 200f9a4 200f99c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 200f9a0: 30 80 00 2b b,a 200fa4c */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 200f9a4: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 200f9a8: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200f9ac: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200f9b0: 12 80 00 03 bne 200f9bc <== NOT EXECUTED 200f9b4: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200f9b8: 30 80 00 25 b,a 200fa4c <== NOT EXECUTED return 0; } if ( current > ceiling ) { 200f9bc: 08 80 00 0f bleu 200f9f8 <== NOT EXECUTED 200f9c0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200f9c4: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 200f9c8: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200f9cc: 82 00 60 01 inc %g1 <== NOT EXECUTED 200f9d0: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200f9d4: 7f ff eb 58 call 200a734 <== NOT EXECUTED 200f9d8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 200f9dc: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200f9e0: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200f9e4: 40 00 17 cd call 2015918 <_Thread_Change_priority> <== NOT EXECUTED 200f9e8: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 200f9ec: 7f ff ff ab call 200f898 <_Thread_Enable_dispatch> <== NOT EXECUTED 200f9f0: 23 00 80 c3 sethi %hi(0x2030c00), %l1 <== NOT EXECUTED 200f9f4: 30 80 00 2f b,a 200fab0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200f9f8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200f9fc: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200fa00: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 200fa04: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200fa08: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200fa0c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200fa10: 30 80 00 0f b,a 200fa4c <== 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 ) ) { 200fa14: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200fa18: 12 80 00 13 bne 200fa64 <== NOT EXECUTED 200fa1c: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200fa20: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 200fa24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200fa28: 22 80 00 07 be,a 200fa44 <== NOT EXECUTED 200fa2c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200fa30: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200fa34: 32 80 00 0c bne,a 200fa64 <== NOT EXECUTED 200fa38: 03 00 80 c4 sethi %hi(0x2031000), %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; 200fa3c: 10 80 00 08 b 200fa5c <== NOT EXECUTED 200fa40: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 200fa44: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fa48: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200fa4c: 7f ff eb 3a call 200a734 200fa50: 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 ); 200fa54: 10 80 00 17 b 200fab0 200fa58: 23 00 80 c3 sethi %hi(0x2030c00), %l1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200fa5c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200fa60: 30 bf ff fb b,a 200fa4c <== NOT EXECUTED 200fa64: c6 04 20 08 ld [ %l0 + 8 ], %g3 <== NOT EXECUTED 200fa68: c8 00 60 90 ld [ %g1 + 0x90 ], %g4 <== NOT EXECUTED 200fa6c: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 200fa70: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fa74: c6 21 20 20 st %g3, [ %g4 + 0x20 ] <== NOT EXECUTED 200fa78: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fa7c: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== 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; 200fa80: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200fa84: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== NOT EXECUTED 200fa88: 82 04 20 10 add %l0, 0x10, %g1 <== NOT EXECUTED 200fa8c: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200fa90: 7f ff eb 29 call 200a734 <== NOT EXECUTED 200fa94: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200fa98: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 200fa9c: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 200faa0: 92 10 20 00 clr %o1 <== NOT EXECUTED 200faa4: 40 00 0f be call 201399c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200faa8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200faac: 23 00 80 c3 sethi %hi(0x2030c00), %l1 <== NOT EXECUTED 200fab0: 40 00 12 7a call 2014498 <_Objects_Allocate> 200fab4: 90 14 61 c8 or %l1, 0x1c8, %o0 ! 2030dc8 <_Region_Information> the_region = _Region_Allocate(); if ( !the_region ) { 200fab8: a0 92 20 00 orcc %o0, 0, %l0 200fabc: 12 80 00 0f bne 200faf8 200fac0: 05 00 80 c3 sethi %hi(0x2030c00), %g2 200fac4: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 200fac8: 82 00 60 01 inc %g1 200facc: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] _RTEMS_Unlock_allocator(); 200fad0: 03 00 80 c4 sethi %hi(0x2031000), %g1 200fad4: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 200fad8: 94 10 20 00 clr %o2 200fadc: d2 02 20 08 ld [ %o0 + 8 ], %o1 200fae0: 40 00 0f d1 call 2013a24 <_CORE_mutex_Surrender> 200fae4: 90 02 20 10 add %o0, 0x10, %o0 200fae8: 7f ff ff 6c call 200f898 <_Thread_Enable_dispatch> 200faec: b0 10 20 05 mov 5, %i0 200faf0: 81 c7 e0 08 ret 200faf4: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_region->maximum_segment_size = 200faf8: 90 04 20 68 add %l0, 0x68, %o0 200fafc: 92 10 00 19 mov %i1, %o1 200fb00: 94 10 00 1a mov %i2, %o2 200fb04: 40 00 11 ee call 20142bc <_Heap_Initialize> 200fb08: 96 10 00 1b mov %i3, %o3 _Heap_Initialize(&the_region->Memory, starting_address, length, page_size); if ( !the_region->maximum_segment_size ) { 200fb0c: 80 a2 20 00 cmp %o0, 0 200fb10: 12 80 00 13 bne 200fb5c 200fb14: 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 ); 200fb18: 90 14 61 c8 or %l1, 0x1c8, %o0 200fb1c: 40 00 13 61 call 20148a0 <_Objects_Free> 200fb20: 92 10 00 10 mov %l0, %o1 200fb24: 05 00 80 c3 sethi %hi(0x2030c00), %g2 200fb28: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 200fb2c: 82 00 60 01 inc %g1 200fb30: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 200fb34: 03 00 80 c4 sethi %hi(0x2031000), %g1 200fb38: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 200fb3c: 94 10 20 00 clr %o2 200fb40: d2 02 20 08 ld [ %o0 + 8 ], %o1 200fb44: 40 00 0f b8 call 2013a24 <_CORE_mutex_Surrender> 200fb48: 90 02 20 10 add %o0, 0x10, %o0 200fb4c: 7f ff ff 53 call 200f898 <_Thread_Enable_dispatch> 200fb50: b0 10 20 08 mov 8, %i0 200fb54: 81 c7 e0 08 ret 200fb58: 81 e8 00 00 restore the_region->length = length; the_region->page_size = page_size; the_region->attribute_set = attribute_set; the_region->number_of_used_blocks = 0; _Thread_queue_Initialize( 200fb5c: 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; 200fb60: f2 24 20 50 st %i1, [ %l0 + 0x50 ] the_region->length = length; 200fb64: f4 24 20 54 st %i2, [ %l0 + 0x54 ] the_region->page_size = page_size; 200fb68: f6 24 20 58 st %i3, [ %l0 + 0x58 ] the_region->attribute_set = attribute_set; 200fb6c: f8 24 20 60 st %i4, [ %l0 + 0x60 ] the_region->number_of_used_blocks = 0; 200fb70: c0 24 20 64 clr [ %l0 + 0x64 ] _Thread_queue_Initialize( 200fb74: 93 37 20 02 srl %i4, 2, %o1 200fb78: 94 10 20 40 mov 0x40, %o2 200fb7c: 92 0a 60 01 and %o1, 1, %o1 200fb80: 40 00 1b 21 call 2016804 <_Thread_queue_Initialize> 200fb84: 96 10 20 06 mov 6, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fb88: 90 14 61 c8 or %l1, 0x1c8, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200fb8c: c4 04 20 08 ld [ %l0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fb90: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200fb94: 03 00 00 3f sethi %hi(0xfc00), %g1 200fb98: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200fb9c: 82 08 80 01 and %g2, %g1, %g1 200fba0: 80 a0 40 03 cmp %g1, %g3 200fba4: 38 80 00 06 bgu,a 200fbbc 200fba8: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200fbac: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200fbb0: 83 28 60 02 sll %g1, 2, %g1 200fbb4: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 200fbb8: c2 04 20 08 ld [ %l0 + 8 ], %g1 200fbbc: 05 00 80 c3 sethi %hi(0x2030c00), %g2 200fbc0: c2 27 40 00 st %g1, [ %i5 ] 200fbc4: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %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; 200fbc8: e4 24 20 0c st %l2, [ %l0 + 0xc ] 200fbcc: 82 00 60 01 inc %g1 200fbd0: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] _RTEMS_Unlock_allocator(); 200fbd4: 03 00 80 c4 sethi %hi(0x2031000), %g1 200fbd8: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 200fbdc: 94 10 20 00 clr %o2 200fbe0: d2 02 20 08 ld [ %o0 + 8 ], %o1 200fbe4: 40 00 0f 90 call 2013a24 <_CORE_mutex_Surrender> 200fbe8: 90 02 20 10 add %o0, 0x10, %o0 200fbec: 7f ff ff 2b call 200f898 <_Thread_Enable_dispatch> 200fbf0: b0 10 20 00 clr %i0 200fbf4: 81 c7 e0 08 ret 200fbf8: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 200fbfc: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED } 200fc00: 81 c7 e0 08 ret <== NOT EXECUTED 200fc04: 81 e8 00 00 restore <== NOT EXECUTED 0200fc3c : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 200fc3c: 9d e3 bf 90 save %sp, -112, %sp register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 200fc40: 7f ff ea b9 call 200a724 200fc44: 01 00 00 00 nop 200fc48: a2 10 00 08 mov %o0, %l1 200fc4c: 03 00 80 c3 sethi %hi(0x2030c00), %g1 200fc50: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 200fc54: 80 a0 60 00 cmp %g1, 0 200fc58: 02 80 00 0b be 200fc84 200fc5c: 03 00 80 c4 sethi %hi(0x2031000), %g1 200fc60: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 200fc64: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 2031190 <_System_state_Current> <== NOT EXECUTED 200fc68: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200fc6c: 08 80 00 05 bleu 200fc80 <== NOT EXECUTED 200fc70: 90 10 20 00 clr %o0 <== NOT EXECUTED 200fc74: 92 10 20 00 clr %o1 <== NOT EXECUTED 200fc78: 40 00 11 db call 20143e4 <_Internal_error_Occurred> <== NOT EXECUTED 200fc7c: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200fc80: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 200fc84: e0 00 60 88 ld [ %g1 + 0x88 ], %l0 ! 2031088 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200fc88: 03 00 80 c4 sethi %hi(0x2031000), %g1 200fc8c: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2031090 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200fc90: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200fc94: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 200fc98: 80 a0 60 00 cmp %g1, 0 200fc9c: 22 80 00 33 be,a 200fd68 200fca0: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200fca4: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200fca8: 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; 200fcac: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200fcb0: 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; 200fcb4: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 200fcb8: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200fcbc: 80 a0 e0 02 cmp %g3, 2 200fcc0: 02 80 00 05 be 200fcd4 200fcc4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 200fcc8: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200fccc: 32 80 00 06 bne,a 200fce4 <== NOT EXECUTED 200fcd0: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200fcd4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 200fcd8: 82 00 60 01 inc %g1 200fcdc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200fce0: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 200fce4: 80 a0 60 03 cmp %g1, 3 200fce8: 22 80 00 03 be,a 200fcf4 200fcec: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 200fcf0: 30 80 00 2c b,a 200fda0 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 200fcf4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200fcf8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200fcfc: 12 80 00 03 bne 200fd08 <== NOT EXECUTED 200fd00: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200fd04: 30 80 00 27 b,a 200fda0 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 200fd08: 08 80 00 10 bleu 200fd48 <== NOT EXECUTED 200fd0c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200fd10: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 200fd14: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fd18: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fd1c: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200fd20: 7f ff ea 85 call 200a734 <== NOT EXECUTED 200fd24: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 200fd28: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200fd2c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200fd30: 40 00 16 fa call 2015918 <_Thread_Change_priority> <== NOT EXECUTED 200fd34: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 200fd38: 7f ff ff b4 call 200fc08 <_Thread_Enable_dispatch> <== NOT EXECUTED 200fd3c: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 200fd40: 10 80 00 32 b 200fe08 <== NOT EXECUTED 200fd44: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200fd48: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200fd4c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200fd50: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 200fd54: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 200fd58: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200fd5c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200fd60: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200fd64: 30 80 00 0f b,a 200fda0 <== 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 ) ) { 200fd68: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200fd6c: 32 80 00 13 bne,a 200fdb8 <== NOT EXECUTED 200fd70: 21 00 80 c4 sethi %hi(0x2031000), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200fd74: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2031050 <_Workspace_Area+0x54> <== NOT EXECUTED 200fd78: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200fd7c: 22 80 00 07 be,a 200fd98 <== NOT EXECUTED 200fd80: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200fd84: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200fd88: 12 80 00 0c bne 200fdb8 <== NOT EXECUTED 200fd8c: 21 00 80 c4 sethi %hi(0x2031000), %l0 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200fd90: 10 80 00 08 b 200fdb0 <== NOT EXECUTED 200fd94: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 200fd98: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fd9c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200fda0: 7f ff ea 65 call 200a734 200fda4: 90 10 00 11 mov %l1, %o0 200fda8: 10 80 00 18 b 200fe08 200fdac: 92 10 00 18 mov %i0, %o1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200fdb0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200fdb4: 30 bf ff fb b,a 200fda0 <== NOT EXECUTED 200fdb8: c6 04 20 88 ld [ %l0 + 0x88 ], %g3 <== NOT EXECUTED 200fdbc: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 200fdc0: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 200fdc4: c8 00 60 90 ld [ %g1 + 0x90 ], %g4 <== NOT EXECUTED 200fdc8: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 200fdcc: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fdd0: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 200fdd4: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fdd8: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 200fddc: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 200fde0: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200fde4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200fde8: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 200fdec: 7f ff ea 52 call 200a734 <== NOT EXECUTED 200fdf0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200fdf4: d0 04 20 88 ld [ %l0 + 0x88 ], %o0 <== NOT EXECUTED 200fdf8: 92 10 20 00 clr %o1 <== NOT EXECUTED 200fdfc: 40 00 0e e8 call 201399c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200fe00: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200fe04: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200fe08: 21 00 80 c3 sethi %hi(0x2030c00), %l0 200fe0c: 94 07 bf f4 add %fp, -12, %o2 200fe10: 40 00 12 e6 call 20149a8 <_Objects_Get_no_protection> 200fe14: 90 14 21 c8 or %l0, 0x1c8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 200fe18: c2 07 bf f4 ld [ %fp + -12 ], %g1 200fe1c: 80 a0 60 01 cmp %g1, 1 200fe20: 02 80 00 0a be 200fe48 200fe24: 92 10 00 08 mov %o0, %o1 200fe28: 80 a0 60 01 cmp %g1, 1 200fe2c: 2a 80 00 22 bcs,a 200feb4 200fe30: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 200fe34: 80 a0 60 02 cmp %g1, 2 200fe38: 12 80 00 10 bne 200fe78 200fe3c: b0 10 20 19 mov 0x19, %i0 200fe40: 10 80 00 10 b 200fe80 200fe44: 05 00 80 c3 sethi %hi(0x2030c00), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 200fe48: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 200fe4c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fe50: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fe54: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 200fe58: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 200fe5c: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 200fe60: 94 10 20 00 clr %o2 <== NOT EXECUTED 200fe64: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 200fe68: 40 00 0e ef call 2013a24 <_CORE_mutex_Surrender> <== NOT EXECUTED 200fe6c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200fe70: 7f ff ff 66 call 200fc08 <_Thread_Enable_dispatch> <== NOT EXECUTED 200fe74: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 200fe78: 81 c7 e0 08 ret <== NOT EXECUTED 200fe7c: 81 e8 00 00 restore <== NOT EXECUTED 200fe80: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 200fe84: 82 00 60 01 inc %g1 200fe88: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 200fe8c: 03 00 80 c4 sethi %hi(0x2031000), %g1 200fe90: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 200fe94: 94 10 20 00 clr %o2 200fe98: d2 02 20 08 ld [ %o0 + 8 ], %o1 200fe9c: 40 00 0e e2 call 2013a24 <_CORE_mutex_Surrender> 200fea0: 90 02 20 10 add %o0, 0x10, %o0 200fea4: 7f ff ff 59 call 200fc08 <_Thread_Enable_dispatch> 200fea8: b0 10 20 04 mov 4, %i0 200feac: 81 c7 e0 08 ret 200feb0: 81 e8 00 00 restore return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks == 0 ) { 200feb4: 80 a0 60 00 cmp %g1, 0 200feb8: 12 80 00 1d bne 200ff2c 200febc: 05 00 80 c3 sethi %hi(0x2030c00), %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fec0: 90 14 21 c8 or %l0, 0x1c8, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200fec4: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fec8: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200fecc: 05 00 00 3f sethi %hi(0xfc00), %g2 200fed0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200fed4: 82 08 40 02 and %g1, %g2, %g1 200fed8: 80 a0 40 03 cmp %g1, %g3 200fedc: 18 80 00 04 bgu 200feec 200fee0: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 200fee4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200fee8: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 200feec: 40 00 12 6d call 20148a0 <_Objects_Free> 200fef0: c0 22 60 0c clr [ %o1 + 0xc ] 200fef4: 05 00 80 c3 sethi %hi(0x2030c00), %g2 200fef8: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 200fefc: 82 00 60 01 inc %g1 200ff00: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 200ff04: 03 00 80 c4 sethi %hi(0x2031000), %g1 200ff08: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 200ff0c: 94 10 20 00 clr %o2 200ff10: d2 02 20 08 ld [ %o0 + 8 ], %o1 200ff14: 40 00 0e c4 call 2013a24 <_CORE_mutex_Surrender> 200ff18: 90 02 20 10 add %o0, 0x10, %o0 200ff1c: 7f ff ff 3b call 200fc08 <_Thread_Enable_dispatch> 200ff20: b0 10 20 00 clr %i0 200ff24: 81 c7 e0 08 ret 200ff28: 81 e8 00 00 restore 200ff2c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 200ff30: 82 00 60 01 inc %g1 200ff34: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] return RTEMS_SUCCESSFUL; } _RTEMS_Unlock_allocator(); 200ff38: 03 00 80 c4 sethi %hi(0x2031000), %g1 200ff3c: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 200ff40: 94 10 20 00 clr %o2 200ff44: d2 02 20 08 ld [ %o0 + 8 ], %o1 200ff48: 40 00 0e b7 call 2013a24 <_CORE_mutex_Surrender> 200ff4c: 90 02 20 10 add %o0, 0x10, %o0 200ff50: 7f ff ff 2e call 200fc08 <_Thread_Enable_dispatch> 200ff54: b0 10 20 0c mov 0xc, %i0 return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200ff58: 81 c7 e0 08 ret 200ff5c: 81 e8 00 00 restore 0200ff94 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 200ff94: 9d e3 bf 90 save %sp, -112, %sp 200ff98: a4 10 00 18 mov %i0, %l2 Objects_Locations location; uint32_t amount_extended; Heap_Extend_status heap_status; rtems_status_code status; if ( !starting_address ) 200ff9c: 80 a6 60 00 cmp %i1, 0 200ffa0: 02 80 00 90 be 20101e0 200ffa4: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 200ffa8: 7f ff e9 df call 200a724 200ffac: 01 00 00 00 nop 200ffb0: a2 10 00 08 mov %o0, %l1 200ffb4: 03 00 80 c3 sethi %hi(0x2030c00), %g1 200ffb8: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 200ffbc: 80 a0 60 00 cmp %g1, 0 200ffc0: 02 80 00 0b be 200ffec 200ffc4: 03 00 80 c4 sethi %hi(0x2031000), %g1 200ffc8: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 200ffcc: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 2031190 <_System_state_Current> <== NOT EXECUTED 200ffd0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200ffd4: 08 80 00 05 bleu 200ffe8 <== NOT EXECUTED 200ffd8: 90 10 20 00 clr %o0 <== NOT EXECUTED 200ffdc: 92 10 20 00 clr %o1 <== NOT EXECUTED 200ffe0: 40 00 11 01 call 20143e4 <_Internal_error_Occurred> <== NOT EXECUTED 200ffe4: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200ffe8: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 200ffec: e0 00 60 88 ld [ %g1 + 0x88 ], %l0 ! 2031088 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200fff0: 03 00 80 c4 sethi %hi(0x2031000), %g1 200fff4: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2031090 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200fff8: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200fffc: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2010000: 80 a0 60 00 cmp %g1, 0 2010004: 22 80 00 33 be,a 20100d0 2010008: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 201000c: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2010010: 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; 2010014: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2010018: 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; 201001c: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2010020: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2010024: 80 a0 e0 02 cmp %g3, 2 2010028: 02 80 00 05 be 201003c 201002c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 2010030: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2010034: 32 80 00 06 bne,a 201004c <== NOT EXECUTED 2010038: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 201003c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 2010040: 82 00 60 01 inc %g1 2010044: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010048: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 201004c: 80 a0 60 03 cmp %g1, 3 2010050: 22 80 00 03 be,a 201005c 2010054: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2010058: 30 80 00 2c b,a 2010108 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 201005c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2010060: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010064: 12 80 00 03 bne 2010070 <== NOT EXECUTED 2010068: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 201006c: 30 80 00 27 b,a 2010108 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2010070: 08 80 00 10 bleu 20100b0 <== NOT EXECUTED 2010074: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010078: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 201007c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2010080: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010084: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010088: 7f ff e9 ab call 200a734 <== NOT EXECUTED 201008c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2010090: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010094: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010098: 40 00 16 20 call 2015918 <_Thread_Change_priority> <== NOT EXECUTED 201009c: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 20100a0: 7f ff ff b0 call 200ff60 <_Thread_Enable_dispatch> <== NOT EXECUTED 20100a4: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 20100a8: 10 80 00 32 b 2010170 <== NOT EXECUTED 20100ac: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20100b0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20100b4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20100b8: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 20100bc: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 20100c0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20100c4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20100c8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20100cc: 30 80 00 0f b,a 2010108 <== 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 ) ) { 20100d0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20100d4: 32 80 00 13 bne,a 2010120 <== NOT EXECUTED 20100d8: 21 00 80 c4 sethi %hi(0x2031000), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20100dc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2031050 <_Workspace_Area+0x54> <== NOT EXECUTED 20100e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20100e4: 22 80 00 07 be,a 2010100 <== NOT EXECUTED 20100e8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 20100ec: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20100f0: 12 80 00 0c bne 2010120 <== NOT EXECUTED 20100f4: 21 00 80 c4 sethi %hi(0x2031000), %l0 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 20100f8: 10 80 00 08 b 2010118 <== NOT EXECUTED 20100fc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2010100: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010104: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010108: 7f ff e9 8b call 200a734 201010c: 90 10 00 11 mov %l1, %o0 2010110: 10 80 00 18 b 2010170 2010114: 92 10 00 12 mov %l2, %o1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2010118: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 201011c: 30 bf ff fb b,a 2010108 <== NOT EXECUTED 2010120: c6 04 20 88 ld [ %l0 + 0x88 ], %g3 <== NOT EXECUTED 2010124: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 2010128: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 201012c: c8 00 60 90 ld [ %g1 + 0x90 ], %g4 <== NOT EXECUTED 2010130: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 2010134: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2010138: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 201013c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010140: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 2010144: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2010148: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 201014c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2010150: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2010154: 7f ff e9 78 call 200a734 <== NOT EXECUTED 2010158: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 201015c: d0 04 20 88 ld [ %l0 + 0x88 ], %o0 <== NOT EXECUTED 2010160: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010164: 40 00 0e 0e call 201399c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010168: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 201016c: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 2010170: 11 00 80 c3 sethi %hi(0x2030c00), %o0 2010174: 94 07 bf f4 add %fp, -12, %o2 2010178: 40 00 12 0c call 20149a8 <_Objects_Get_no_protection> 201017c: 90 12 21 c8 or %o0, 0x1c8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 2010180: c2 07 bf f4 ld [ %fp + -12 ], %g1 2010184: 80 a0 60 01 cmp %g1, 1 2010188: 02 80 00 0a be 20101b0 201018c: a0 10 00 08 mov %o0, %l0 2010190: 80 a0 60 01 cmp %g1, 1 2010194: 0a 80 00 22 bcs 201021c 2010198: 92 10 00 19 mov %i1, %o1 201019c: 80 a0 60 02 cmp %g1, 2 20101a0: 12 80 00 10 bne 20101e0 20101a4: b0 10 20 19 mov 0x19, %i0 20101a8: 10 80 00 10 b 20101e8 20101ac: 05 00 80 c3 sethi %hi(0x2030c00), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 20101b0: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 20101b4: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20101b8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20101bc: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 20101c0: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 20101c4: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 20101c8: 94 10 20 00 clr %o2 <== NOT EXECUTED 20101cc: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 20101d0: 40 00 0e 15 call 2013a24 <_CORE_mutex_Surrender> <== NOT EXECUTED 20101d4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 20101d8: 7f ff ff 62 call 200ff60 <_Thread_Enable_dispatch> <== NOT EXECUTED 20101dc: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 20101e0: 81 c7 e0 08 ret <== NOT EXECUTED 20101e4: 81 e8 00 00 restore <== NOT EXECUTED 20101e8: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 20101ec: 82 00 60 01 inc %g1 20101f0: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 20101f4: 03 00 80 c4 sethi %hi(0x2031000), %g1 20101f8: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 20101fc: 94 10 20 00 clr %o2 2010200: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010204: 40 00 0e 08 call 2013a24 <_CORE_mutex_Surrender> 2010208: 90 02 20 10 add %o0, 0x10, %o0 201020c: 7f ff ff 55 call 200ff60 <_Thread_Enable_dispatch> 2010210: b0 10 20 04 mov 4, %i0 2010214: 81 c7 e0 08 ret 2010218: 81 e8 00 00 restore return RTEMS_INVALID_ID; case OBJECTS_LOCAL: heap_status = _Heap_Extend( 201021c: 94 10 00 1a mov %i2, %o2 2010220: 90 02 20 68 add %o0, 0x68, %o0 2010224: 96 07 bf f0 add %fp, -16, %o3 2010228: 40 00 0f 3a call 2013f10 <_Heap_Extend> 201022c: b0 10 20 09 mov 9, %i0 starting_address, length, &amount_extended ); switch ( heap_status ) { 2010230: 80 a2 20 01 cmp %o0, 1 2010234: 02 80 00 12 be 201027c 2010238: 05 00 80 c3 sethi %hi(0x2030c00), %g2 201023c: 0a 80 00 08 bcs 201025c 2010240: c6 07 bf f0 ld [ %fp + -16 ], %g3 2010244: 82 1a 20 02 xor %o0, 2, %g1 2010248: 80 a0 00 01 cmp %g0, %g1 201024c: 82 60 20 00 subx %g0, 0, %g1 2010250: b0 08 7f e8 and %g1, -24, %i0 2010254: 10 80 00 0a b 201027c 2010258: b0 06 20 18 add %i0, 0x18, %i0 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 201025c: c4 04 20 54 ld [ %l0 + 0x54 ], %g2 the_region->maximum_segment_size += amount_extended; 2010260: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 2010264: 84 00 80 03 add %g2, %g3, %g2 the_region->maximum_segment_size += amount_extended; 2010268: 82 00 40 03 add %g1, %g3, %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 201026c: c4 24 20 54 st %g2, [ %l0 + 0x54 ] the_region->maximum_segment_size += amount_extended; 2010270: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 2010274: b0 10 20 00 clr %i0 2010278: 05 00 80 c3 sethi %hi(0x2030c00), %g2 201027c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 2010280: 82 00 60 01 inc %g1 2010284: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] break; case HEAP_EXTEND_NOT_IMPLEMENTED: status = RTEMS_NOT_IMPLEMENTED; break; } _RTEMS_Unlock_allocator(); 2010288: 03 00 80 c4 sethi %hi(0x2031000), %g1 201028c: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 2010290: 94 10 20 00 clr %o2 2010294: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010298: 40 00 0d e3 call 2013a24 <_CORE_mutex_Surrender> 201029c: 90 02 20 10 add %o0, 0x10, %o0 20102a0: 7f ff ff 30 call 200ff60 <_Thread_Enable_dispatch> 20102a4: 01 00 00 00 nop return( status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20102a8: 81 c7 e0 08 ret 20102ac: 81 e8 00 00 restore 020102e4 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 20102e4: 9d e3 bf 90 save %sp, -112, %sp 20102e8: a4 10 00 18 mov %i0, %l2 register Region_Control *the_region; Objects_Locations location; Thread_Control *executing; void *the_segment; if ( !segment ) 20102ec: 80 a7 20 00 cmp %i4, 0 20102f0: 02 80 00 96 be 2010548 20102f4: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; *segment = NULL; 20102f8: c0 27 00 00 clr [ %i4 ] if ( size == 0 ) 20102fc: 80 a6 60 00 cmp %i1, 0 2010300: 02 80 00 92 be 2010548 2010304: b0 10 20 08 mov 8, %i0 return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 2010308: 7f ff e9 07 call 200a724 201030c: 01 00 00 00 nop 2010310: a2 10 00 08 mov %o0, %l1 2010314: 03 00 80 c3 sethi %hi(0x2030c00), %g1 2010318: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 201031c: 80 a0 60 00 cmp %g1, 0 2010320: 02 80 00 0b be 201034c 2010324: 03 00 80 c4 sethi %hi(0x2031000), %g1 2010328: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 201032c: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 2031190 <_System_state_Current> <== NOT EXECUTED 2010330: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010334: 08 80 00 05 bleu 2010348 <== NOT EXECUTED 2010338: 90 10 20 00 clr %o0 <== NOT EXECUTED 201033c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010340: 40 00 10 29 call 20143e4 <_Internal_error_Occurred> <== NOT EXECUTED 2010344: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2010348: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 201034c: e0 00 60 88 ld [ %g1 + 0x88 ], %l0 ! 2031088 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2010350: 03 00 80 c4 sethi %hi(0x2031000), %g1 2010354: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2031090 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2010358: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 201035c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2010360: 80 a0 60 00 cmp %g1, 0 2010364: 22 80 00 33 be,a 2010430 2010368: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 201036c: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2010370: 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; 2010374: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2010378: 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; 201037c: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2010380: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2010384: 80 a0 e0 02 cmp %g3, 2 2010388: 02 80 00 05 be 201039c 201038c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 2010390: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2010394: 32 80 00 06 bne,a 20103ac <== NOT EXECUTED 2010398: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 201039c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 20103a0: 82 00 60 01 inc %g1 20103a4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20103a8: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 20103ac: 80 a0 60 03 cmp %g1, 3 20103b0: 22 80 00 03 be,a 20103bc 20103b4: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 20103b8: 30 80 00 2c b,a 2010468 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 20103bc: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 20103c0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 20103c4: 12 80 00 03 bne 20103d0 <== NOT EXECUTED 20103c8: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 20103cc: 30 80 00 27 b,a 2010468 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 20103d0: 28 80 00 10 bleu,a 2010410 <== NOT EXECUTED 20103d4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20103d8: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 20103dc: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20103e0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20103e4: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20103e8: 7f ff e8 d3 call 200a734 <== NOT EXECUTED 20103ec: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 20103f0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 20103f4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 20103f8: 40 00 15 48 call 2015918 <_Thread_Change_priority> <== NOT EXECUTED 20103fc: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2010400: 7f ff ff ac call 20102b0 <_Thread_Enable_dispatch> <== NOT EXECUTED 2010404: 01 00 00 00 nop <== NOT EXECUTED executing = _Thread_Executing; 2010408: 10 80 00 32 b 20104d0 <== NOT EXECUTED 201040c: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2010410: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2010414: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2010418: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 201041c: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2010420: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2010424: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010428: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 201042c: 30 80 00 0f b,a 2010468 <== 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 ) ) { 2010430: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2010434: 32 80 00 13 bne,a 2010480 <== NOT EXECUTED 2010438: 21 00 80 c4 sethi %hi(0x2031000), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 201043c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2031050 <_Workspace_Area+0x54> <== NOT EXECUTED 2010440: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010444: 22 80 00 07 be,a 2010460 <== NOT EXECUTED 2010448: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 201044c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010450: 12 80 00 0c bne 2010480 <== NOT EXECUTED 2010454: 21 00 80 c4 sethi %hi(0x2031000), %l0 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2010458: 10 80 00 08 b 2010478 <== NOT EXECUTED 201045c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2010460: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010464: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010468: 7f ff e8 b3 call 200a734 201046c: 90 10 00 11 mov %l1, %o0 2010470: 10 80 00 18 b 20104d0 2010474: 03 00 80 c4 sethi %hi(0x2031000), %g1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2010478: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 201047c: 30 bf ff fb b,a 2010468 <== NOT EXECUTED *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 2010480: c6 04 20 88 ld [ %l0 + 0x88 ], %g3 <== NOT EXECUTED 2010484: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 2010488: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 201048c: c8 00 60 90 ld [ %g1 + 0x90 ], %g4 <== NOT EXECUTED 2010490: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 2010494: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2010498: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 201049c: 82 00 60 01 inc %g1 <== NOT EXECUTED 20104a0: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 20104a4: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 20104a8: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 20104ac: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20104b0: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 20104b4: 7f ff e8 a0 call 200a734 <== NOT EXECUTED 20104b8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20104bc: d0 04 20 88 ld [ %l0 + 0x88 ], %o0 <== NOT EXECUTED 20104c0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20104c4: 40 00 0d 36 call 201399c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 20104c8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED executing = _Thread_Executing; 20104cc: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 20104d0: 11 00 80 c3 sethi %hi(0x2030c00), %o0 20104d4: f0 00 60 90 ld [ %g1 + 0x90 ], %i0 20104d8: 90 12 21 c8 or %o0, 0x1c8, %o0 20104dc: 92 10 00 12 mov %l2, %o1 20104e0: 40 00 11 32 call 20149a8 <_Objects_Get_no_protection> 20104e4: 94 07 bf f4 add %fp, -12, %o2 the_region = _Region_Get( id, &location ); switch ( location ) { 20104e8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20104ec: 80 a0 60 01 cmp %g1, 1 20104f0: 02 80 00 0a be 2010518 20104f4: a0 10 00 08 mov %o0, %l0 20104f8: 80 a0 60 01 cmp %g1, 1 20104fc: 2a 80 00 22 bcs,a 2010584 2010500: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 2010504: 80 a0 60 02 cmp %g1, 2 2010508: 12 80 00 10 bne 2010548 201050c: b0 10 20 19 mov 0x19, %i0 2010510: 10 80 00 10 b 2010550 2010514: 05 00 80 c3 sethi %hi(0x2030c00), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 2010518: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 201051c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2010520: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010524: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 2010528: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 201052c: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 2010530: 94 10 20 00 clr %o2 <== NOT EXECUTED 2010534: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2010538: 40 00 0d 3b call 2013a24 <_CORE_mutex_Surrender> <== NOT EXECUTED 201053c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010540: 7f ff ff 5c call 20102b0 <_Thread_Enable_dispatch> <== NOT EXECUTED 2010544: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 2010548: 81 c7 e0 08 ret <== NOT EXECUTED 201054c: 81 e8 00 00 restore <== NOT EXECUTED 2010550: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 2010554: 82 00 60 01 inc %g1 2010558: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 201055c: 03 00 80 c4 sethi %hi(0x2031000), %g1 2010560: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 2010564: 94 10 20 00 clr %o2 2010568: d2 02 20 08 ld [ %o0 + 8 ], %o1 201056c: 40 00 0d 2e call 2013a24 <_CORE_mutex_Surrender> 2010570: 90 02 20 10 add %o0, 0x10, %o0 2010574: 7f ff ff 4f call 20102b0 <_Thread_Enable_dispatch> 2010578: b0 10 20 04 mov 4, %i0 201057c: 81 c7 e0 08 ret 2010580: 81 e8 00 00 restore return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) { 2010584: 80 a6 40 01 cmp %i1, %g1 2010588: 08 80 00 0f bleu 20105c4 201058c: 05 00 80 c3 sethi %hi(0x2030c00), %g2 2010590: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 2010594: 82 00 60 01 inc %g1 2010598: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] _RTEMS_Unlock_allocator(); 201059c: 03 00 80 c4 sethi %hi(0x2031000), %g1 20105a0: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 20105a4: 94 10 20 00 clr %o2 20105a8: d2 02 20 08 ld [ %o0 + 8 ], %o1 20105ac: 40 00 0d 1e call 2013a24 <_CORE_mutex_Surrender> 20105b0: 90 02 20 10 add %o0, 0x10, %o0 20105b4: 7f ff ff 3f call 20102b0 <_Thread_Enable_dispatch> 20105b8: b0 10 20 08 mov 8, %i0 20105bc: 81 c7 e0 08 ret 20105c0: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 20105c4: 90 02 20 68 add %o0, 0x68, %o0 20105c8: 40 00 0e 2b call 2013e74 <_Heap_Allocate> 20105cc: 92 10 00 19 mov %i1, %o1 the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 20105d0: a2 92 20 00 orcc %o0, 0, %l1 20105d4: 02 80 00 13 be 2010620 20105d8: 07 00 80 c3 sethi %hi(0x2030c00), %g3 the_region->number_of_used_blocks += 1; 20105dc: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 20105e0: c4 00 e3 b0 ld [ %g3 + 0x3b0 ], %g2 20105e4: 82 00 60 01 inc %g1 20105e8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 20105ec: 84 00 a0 01 inc %g2 20105f0: c4 20 e3 b0 st %g2, [ %g3 + 0x3b0 ] _RTEMS_Unlock_allocator(); 20105f4: 03 00 80 c4 sethi %hi(0x2031000), %g1 20105f8: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 20105fc: 94 10 20 00 clr %o2 2010600: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010604: 40 00 0d 08 call 2013a24 <_CORE_mutex_Surrender> 2010608: 90 02 20 10 add %o0, 0x10, %o0 201060c: 7f ff ff 29 call 20102b0 <_Thread_Enable_dispatch> 2010610: b0 10 20 00 clr %i0 *segment = the_segment; 2010614: e2 27 00 00 st %l1, [ %i4 ] 2010618: 81 c7 e0 08 ret 201061c: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } if ( _Options_Is_no_wait( option_set ) ) { 2010620: 80 8e a0 01 btst 1, %i2 2010624: 05 00 80 c3 sethi %hi(0x2030c00), %g2 2010628: 02 80 00 0e be 2010660 201062c: 07 00 80 c4 sethi %hi(0x2031000), %g3 2010630: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 2010634: 82 00 60 01 inc %g1 2010638: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] _RTEMS_Unlock_allocator(); 201063c: d0 00 e0 88 ld [ %g3 + 0x88 ], %o0 2010640: 94 10 20 00 clr %o2 2010644: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010648: 40 00 0c f7 call 2013a24 <_CORE_mutex_Surrender> 201064c: 90 02 20 10 add %o0, 0x10, %o0 2010650: 7f ff ff 18 call 20102b0 <_Thread_Enable_dispatch> 2010654: b0 10 20 0d mov 0xd, %i0 2010658: 81 c7 e0 08 ret 201065c: 81 e8 00 00 restore 2010660: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 2010664: 82 00 60 01 inc %g1 2010668: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 201066c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 2010670: 82 00 60 01 inc %g1 2010674: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] * 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(); 2010678: d0 00 e0 88 ld [ %g3 + 0x88 ], %o0 201067c: 94 10 20 00 clr %o2 2010680: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010684: 40 00 0c e8 call 2013a24 <_CORE_mutex_Surrender> 2010688: 90 02 20 10 add %o0, 0x10, %o0 201068c: 7f ff ff 09 call 20102b0 <_Thread_Enable_dispatch> 2010690: 01 00 00 00 nop executing->Wait.queue = &the_region->Wait_queue; 2010694: 82 04 20 10 add %l0, 0x10, %g1 executing->Wait.count = size; executing->Wait.return_argument = segment; _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 2010698: 92 10 00 1b mov %i3, %o1 201069c: 90 10 00 01 mov %g1, %o0 * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; 20106a0: c2 26 20 44 st %g1, [ %i0 + 0x44 ] executing->Wait.count = size; executing->Wait.return_argument = segment; _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 20106a4: 15 00 80 5a sethi %hi(0x2016800), %o2 20106a8: 82 10 20 01 mov 1, %g1 20106ac: 94 12 a1 00 or %o2, 0x100, %o2 */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; executing->Wait.id = id; 20106b0: e4 26 20 20 st %l2, [ %i0 + 0x20 ] executing->Wait.count = size; 20106b4: f2 26 20 24 st %i1, [ %i0 + 0x24 ] executing->Wait.return_argument = segment; 20106b8: 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 ); 20106bc: 40 00 17 6b call 2016468 <_Thread_queue_Enqueue_with_handler> 20106c0: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _Thread_Enable_dispatch(); 20106c4: 7f ff fe fb call 20102b0 <_Thread_Enable_dispatch> 20106c8: 01 00 00 00 nop return (rtems_status_code) executing->Wait.return_code; 20106cc: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20106d0: 81 c7 e0 08 ret 20106d4: 81 e8 00 00 restore 02010744 : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 2010744: 9d e3 bf 90 save %sp, -112, %sp #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 2010748: 7f ff e7 f7 call 200a724 201074c: 01 00 00 00 nop 2010750: a2 10 00 08 mov %o0, %l1 2010754: 03 00 80 c3 sethi %hi(0x2030c00), %g1 2010758: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 201075c: 80 a0 60 00 cmp %g1, 0 2010760: 02 80 00 0b be 201078c 2010764: 03 00 80 c4 sethi %hi(0x2031000), %g1 2010768: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 201076c: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 2031190 <_System_state_Current> <== NOT EXECUTED 2010770: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010774: 08 80 00 05 bleu 2010788 <== NOT EXECUTED 2010778: 90 10 20 00 clr %o0 <== NOT EXECUTED 201077c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010780: 40 00 0f 19 call 20143e4 <_Internal_error_Occurred> <== NOT EXECUTED 2010784: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2010788: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 201078c: e0 00 60 88 ld [ %g1 + 0x88 ], %l0 ! 2031088 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2010790: 03 00 80 c4 sethi %hi(0x2031000), %g1 2010794: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2031090 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2010798: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 201079c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 20107a0: 80 a0 60 00 cmp %g1, 0 20107a4: 22 80 00 33 be,a 2010870 20107a8: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20107ac: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20107b0: 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; 20107b4: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20107b8: 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; 20107bc: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 20107c0: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20107c4: 80 a0 e0 02 cmp %g3, 2 20107c8: 02 80 00 05 be 20107dc 20107cc: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 20107d0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20107d4: 32 80 00 06 bne,a 20107ec <== NOT EXECUTED 20107d8: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20107dc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 20107e0: 82 00 60 01 inc %g1 20107e4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20107e8: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 20107ec: 80 a0 60 03 cmp %g1, 3 20107f0: 22 80 00 03 be,a 20107fc 20107f4: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 20107f8: 30 80 00 2c b,a 20108a8 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 20107fc: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2010800: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010804: 12 80 00 03 bne 2010810 <== NOT EXECUTED 2010808: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 201080c: 30 80 00 27 b,a 20108a8 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2010810: 08 80 00 10 bleu 2010850 <== NOT EXECUTED 2010814: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010818: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 201081c: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2010820: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010824: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010828: 7f ff e7 c3 call 200a734 <== NOT EXECUTED 201082c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2010830: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010834: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010838: 40 00 14 38 call 2015918 <_Thread_Change_priority> <== NOT EXECUTED 201083c: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2010840: 7f ff ff b4 call 2010710 <_Thread_Enable_dispatch> <== NOT EXECUTED 2010844: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 2010848: 10 80 00 32 b 2010910 <== NOT EXECUTED 201084c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2010850: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2010854: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2010858: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 201085c: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2010860: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2010864: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010868: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 201086c: 30 80 00 0f b,a 20108a8 <== 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 ) ) { 2010870: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2010874: 32 80 00 13 bne,a 20108c0 <== NOT EXECUTED 2010878: 21 00 80 c4 sethi %hi(0x2031000), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 201087c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2031050 <_Workspace_Area+0x54> <== NOT EXECUTED 2010880: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010884: 22 80 00 07 be,a 20108a0 <== NOT EXECUTED 2010888: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 201088c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010890: 12 80 00 0c bne 20108c0 <== NOT EXECUTED 2010894: 21 00 80 c4 sethi %hi(0x2031000), %l0 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2010898: 10 80 00 08 b 20108b8 <== NOT EXECUTED 201089c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 20108a0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20108a4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 20108a8: 7f ff e7 a3 call 200a734 20108ac: 90 10 00 11 mov %l1, %o0 20108b0: 10 80 00 18 b 2010910 20108b4: 92 10 00 18 mov %i0, %o1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 20108b8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20108bc: 30 bf ff fb b,a 20108a8 <== NOT EXECUTED 20108c0: c6 04 20 88 ld [ %l0 + 0x88 ], %g3 <== NOT EXECUTED 20108c4: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 20108c8: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 20108cc: c8 00 60 90 ld [ %g1 + 0x90 ], %g4 <== NOT EXECUTED 20108d0: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 20108d4: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20108d8: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 20108dc: 82 00 60 01 inc %g1 <== NOT EXECUTED 20108e0: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 20108e4: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 20108e8: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 20108ec: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20108f0: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 20108f4: 7f ff e7 90 call 200a734 <== NOT EXECUTED 20108f8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20108fc: d0 04 20 88 ld [ %l0 + 0x88 ], %o0 <== NOT EXECUTED 2010900: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010904: 40 00 0c 26 call 201399c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010908: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 201090c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2010910: 11 00 80 c3 sethi %hi(0x2030c00), %o0 2010914: 94 07 bf f4 add %fp, -12, %o2 2010918: 40 00 10 24 call 20149a8 <_Objects_Get_no_protection> 201091c: 90 12 21 c8 or %o0, 0x1c8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 2010920: c2 07 bf f4 ld [ %fp + -12 ], %g1 2010924: 80 a0 60 01 cmp %g1, 1 2010928: 02 80 00 0a be 2010950 201092c: a0 10 00 08 mov %o0, %l0 2010930: 80 a0 60 01 cmp %g1, 1 2010934: 0a 80 00 22 bcs 20109bc 2010938: 92 10 00 19 mov %i1, %o1 201093c: 80 a0 60 02 cmp %g1, 2 2010940: 12 80 00 10 bne 2010980 2010944: b0 10 20 19 mov 0x19, %i0 2010948: 10 80 00 10 b 2010988 201094c: 05 00 80 c3 sethi %hi(0x2030c00), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 2010950: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED 2010954: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2010958: 82 00 60 01 inc %g1 <== NOT EXECUTED 201095c: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED 2010960: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 2010964: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 2010968: 94 10 20 00 clr %o2 <== NOT EXECUTED 201096c: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2010970: 40 00 0c 2d call 2013a24 <_CORE_mutex_Surrender> <== NOT EXECUTED 2010974: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010978: 7f ff ff 66 call 2010710 <_Thread_Enable_dispatch> <== NOT EXECUTED 201097c: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 2010980: 81 c7 e0 08 ret <== NOT EXECUTED 2010984: 81 e8 00 00 restore <== NOT EXECUTED 2010988: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 201098c: 82 00 60 01 inc %g1 2010990: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2010994: 03 00 80 c4 sethi %hi(0x2031000), %g1 2010998: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 201099c: 94 10 20 00 clr %o2 20109a0: d2 02 20 08 ld [ %o0 + 8 ], %o1 20109a4: 40 00 0c 20 call 2013a24 <_CORE_mutex_Surrender> 20109a8: 90 02 20 10 add %o0, 0x10, %o0 20109ac: 7f ff ff 59 call 2010710 <_Thread_Enable_dispatch> 20109b0: b0 10 20 04 mov 4, %i0 20109b4: 81 c7 e0 08 ret 20109b8: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE boolean _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 20109bc: 40 00 0d 86 call 2013fd4 <_Heap_Free> 20109c0: 90 02 20 68 add %o0, 0x68, %o0 status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) { 20109c4: 80 a2 20 00 cmp %o0, 0 20109c8: 12 80 00 0f bne 2010a04 20109cc: 05 00 80 c3 sethi %hi(0x2030c00), %g2 20109d0: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 20109d4: 82 00 60 01 inc %g1 20109d8: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] _RTEMS_Unlock_allocator(); 20109dc: 03 00 80 c4 sethi %hi(0x2031000), %g1 20109e0: d0 00 60 88 ld [ %g1 + 0x88 ], %o0 ! 2031088 <_RTEMS_Allocator_Mutex> 20109e4: 94 10 20 00 clr %o2 20109e8: d2 02 20 08 ld [ %o0 + 8 ], %o1 20109ec: 40 00 0c 0e call 2013a24 <_CORE_mutex_Surrender> 20109f0: 90 02 20 10 add %o0, 0x10, %o0 20109f4: 7f ff ff 47 call 2010710 <_Thread_Enable_dispatch> 20109f8: b0 10 20 09 mov 9, %i0 20109fc: 81 c7 e0 08 ret 2010a00: 81 e8 00 00 restore return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 2010a04: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 2010a08: 90 10 00 10 mov %l0, %o0 if ( !status ) { _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 2010a0c: 82 00 7f ff add %g1, -1, %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 2010a10: b0 10 20 00 clr %i0 2010a14: 40 00 23 aa call 20198bc <_Region_Process_queue> 2010a18: c2 24 20 64 st %g1, [ %l0 + 0x64 ] return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2010a1c: 81 c7 e0 08 ret 2010a20: 81 e8 00 00 restore 020055ec : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 20055ec: 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 ) ) 20055f0: a8 96 20 00 orcc %i0, 0, %l4 20055f4: 02 80 00 2c be 20056a4 20055f8: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 20055fc: 80 a7 20 00 cmp %i4, 0 2005600: 02 80 00 29 be 20056a4 2005604: b0 10 20 09 mov 9, %i0 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 2005608: a4 8e a0 40 andcc %i2, 0x40, %l2 200560c: 12 80 00 06 bne 2005624 2005610: 82 0e a0 30 and %i2, 0x30, %g1 2005614: 80 8e a0 80 btst 0x80, %i2 2005618: 02 80 00 10 be 2005658 200561c: a6 0e a0 30 and %i2, 0x30, %l3 RTEMS_INLINE_ROUTINE boolean _Attributes_Is_binary_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE); 2005620: 82 0e a0 30 and %i2, 0x30, %g1 _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 2005624: 80 a0 60 10 cmp %g1, 0x10 2005628: 02 80 00 05 be 200563c 200562c: 80 8e a0 04 btst 4, %i2 2005630: 80 a0 60 20 cmp %g1, 0x20 2005634: 12 80 00 71 bne 20057f8 2005638: 80 8e a0 04 btst 4, %i2 200563c: 02 80 00 6f be 20057f8 2005640: 80 a4 a0 00 cmp %l2, 0 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 2005644: 02 80 00 04 be 2005654 2005648: 80 8e a0 80 btst 0x80, %i2 200564c: 32 80 00 16 bne,a 20056a4 2005650: b0 10 20 0b mov 0xb, %i0 RTEMS_INLINE_ROUTINE boolean _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 2005654: a6 0e a0 30 and %i2, 0x30, %l3 2005658: 80 a0 00 13 cmp %g0, %l3 200565c: a2 60 3f ff subx %g0, -1, %l1 _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 2005660: 80 a4 60 00 cmp %l1, 0 2005664: 12 80 00 04 bne 2005674 2005668: 80 a6 60 01 cmp %i1, 1 200566c: 18 80 00 0e bgu 20056a4 2005670: b0 10 20 0a mov 0xa, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005674: 03 00 80 5e sethi %hi(0x2017800), %g1 2005678: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2017bb0 <_Thread_Dispatch_disable_level> 200567c: 84 00 a0 01 inc %g2 2005680: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 2005684: 11 00 80 5e sethi %hi(0x2017800), %o0 2005688: 40 00 06 de call 2007200 <_Objects_Allocate> 200568c: 90 12 22 60 or %o0, 0x260, %o0 ! 2017a60 <_Semaphore_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 2005690: a0 92 20 00 orcc %o0, 0, %l0 2005694: 12 80 00 06 bne 20056ac 2005698: 80 a4 60 00 cmp %l1, 0 _Thread_Enable_dispatch(); 200569c: 7f ff ff c7 call 20055b8 <_Thread_Enable_dispatch> 20056a0: b0 10 20 05 mov 5, %i0 20056a4: 81 c7 e0 08 ret 20056a8: 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 ) ) { 20056ac: 12 80 00 32 bne 2005774 20056b0: f4 24 20 10 st %i2, [ %l0 + 0x10 ] CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 20056b4: 80 a4 a0 00 cmp %l2, 0 20056b8: 12 80 00 06 bne 20056d0 20056bc: 82 10 20 02 mov 2, %g1 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 20056c0: 80 8e a0 80 btst 0x80, %i2 20056c4: 02 80 00 05 be 20056d8 20056c8: 80 8e a0 04 btst 4, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 20056cc: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 20056d0: 10 80 00 05 b 20056e4 20056d4: c2 27 bf e8 st %g1, [ %fp + -24 ] else if ( _Attributes_Is_priority( attribute_set ) ) 20056d8: 12 bf ff fe bne 20056d0 20056dc: 82 10 20 01 mov 1, %g1 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; 20056e0: c0 27 bf e8 clr [ %fp + -24 ] if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 20056e4: 80 a4 e0 10 cmp %l3, 0x10 20056e8: 12 80 00 0f bne 2005724 20056ec: 82 10 20 02 mov 2, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 20056f0: c2 07 bf e8 ld [ %fp + -24 ], %g1 20056f4: 80 a0 60 01 cmp %g1, 1 20056f8: 08 80 00 07 bleu 2005714 20056fc: c0 27 bf e0 clr [ %fp + -32 ] 2005700: 80 a0 60 03 cmp %g1, 3 2005704: 38 80 00 0b bgu,a 2005730 2005708: 82 1e 60 01 xor %i1, 1, %g1 <== NOT EXECUTED case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 200570c: 10 80 00 04 b 200571c 2005710: 82 10 20 01 mov 1, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; 2005714: 10 80 00 06 b 200572c 2005718: c0 27 bf e4 clr [ %fp + -28 ] break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 200571c: 10 80 00 04 b 200572c 2005720: c2 27 bf e4 st %g1, [ %fp + -28 ] break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; the_mutex_attributes.only_owner_release = FALSE; 2005724: 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; 2005728: c2 27 bf e0 st %g1, [ %fp + -32 ] the_mutex_attributes.only_owner_release = FALSE; } the_mutex_attributes.priority_ceiling = priority_ceiling; mutex_status = _CORE_mutex_Initialize( 200572c: 82 1e 60 01 xor %i1, 1, %g1 2005730: 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; 2005734: f6 27 bf ec st %i3, [ %fp + -20 ] mutex_status = _CORE_mutex_Initialize( 2005738: 94 60 3f ff subx %g0, -1, %o2 200573c: 90 04 20 14 add %l0, 0x14, %o0 2005740: 40 00 04 3b call 200682c <_CORE_mutex_Initialize> 2005744: 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 ) { 2005748: 80 a2 20 06 cmp %o0, 6 200574c: 12 80 00 17 bne 20057a8 2005750: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 2005754: 11 00 80 5e sethi %hi(0x2017800), %o0 <== NOT EXECUTED 2005758: 90 12 22 60 or %o0, 0x260, %o0 ! 2017a60 <_Semaphore_Information> <== NOT EXECUTED 200575c: 40 00 07 ab call 2007608 <_Objects_Free> <== NOT EXECUTED 2005760: b0 10 20 13 mov 0x13, %i0 <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 2005764: 7f ff ff 95 call 20055b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 2005768: 01 00 00 00 nop <== NOT EXECUTED 200576c: 81 c7 e0 08 ret <== NOT EXECUTED 2005770: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) 2005774: 80 8e a0 04 btst 4, %i2 2005778: 22 80 00 04 be,a 2005788 200577c: c0 27 bf f4 clr [ %fp + -12 ] the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 2005780: 82 10 20 01 mov 1, %g1 2005784: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 2005788: 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; 200578c: c0 27 bf e0 clr [ %fp + -32 ] the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 2005790: c0 27 bf ec clr [ %fp + -20 ] _CORE_semaphore_Initialize( 2005794: 94 10 00 19 mov %i1, %o2 /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 2005798: 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( 200579c: 90 04 20 14 add %l0, 0x14, %o0 20057a0: 40 00 04 d2 call 2006ae8 <_CORE_semaphore_Initialize> 20057a4: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20057a8: 03 00 80 5e sethi %hi(0x2017800), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 20057ac: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20057b0: 88 10 62 60 or %g1, 0x260, %g4 20057b4: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 20057b8: 03 00 00 3f sethi %hi(0xfc00), %g1 20057bc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20057c0: 82 08 c0 01 and %g3, %g1, %g1 20057c4: 80 a0 40 02 cmp %g1, %g2 20057c8: 38 80 00 06 bgu,a 20057e0 20057cc: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 20057d0: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 20057d4: 83 28 60 02 sll %g1, 2, %g1 20057d8: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 20057dc: c2 04 20 08 ld [ %l0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 20057e0: e8 24 20 0c st %l4, [ %l0 + 0xc ] 20057e4: c2 27 00 00 st %g1, [ %i4 ] the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 20057e8: 7f ff ff 74 call 20055b8 <_Thread_Enable_dispatch> 20057ec: b0 10 20 00 clr %i0 20057f0: 81 c7 e0 08 ret 20057f4: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 20057f8: b0 10 20 0b mov 0xb, %i0 } 20057fc: 81 c7 e0 08 ret 2005800: 81 e8 00 00 restore 02005838 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 2005838: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 200583c: 11 00 80 5e sethi %hi(0x2017800), %o0 2005840: 92 10 00 18 mov %i0, %o1 2005844: 90 12 22 60 or %o0, 0x260, %o0 2005848: 40 00 07 b2 call 2007710 <_Objects_Get> 200584c: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2005850: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005854: 80 a0 60 00 cmp %g1, 0 2005858: 02 80 00 07 be 2005874 200585c: b0 10 00 08 mov %o0, %i0 2005860: 80 a0 60 02 cmp %g1, 2 2005864: 08 80 00 10 bleu 20058a4 2005868: b0 10 20 04 mov 4, %i0 200586c: 81 c7 e0 08 ret <== NOT EXECUTED 2005870: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 2005874: 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) ) { 2005878: 84 88 60 30 andcc %g1, 0x30, %g2 200587c: 22 80 00 12 be,a 20058c4 2005880: 90 02 20 14 add %o0, 0x14, %o0 if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 2005884: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 2005888: 80 a0 60 00 cmp %g1, 0 200588c: 12 80 00 08 bne 20058ac 2005890: 80 a0 a0 20 cmp %g2, 0x20 2005894: 02 80 00 07 be 20058b0 2005898: 90 06 20 14 add %i0, 0x14, %o0 !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 200589c: 7f ff ff da call 2005804 <_Thread_Enable_dispatch> 20058a0: b0 10 20 0c mov 0xc, %i0 20058a4: 81 c7 e0 08 ret 20058a8: 81 e8 00 00 restore return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 20058ac: 90 06 20 14 add %i0, 0x14, %o0 20058b0: 92 10 20 00 clr %o1 20058b4: 40 00 03 da call 200681c <_CORE_mutex_Flush> 20058b8: 94 10 20 04 mov 4, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20058bc: 10 80 00 06 b 20058d4 20058c0: 03 00 80 5e sethi %hi(0x2017800), %g1 &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 20058c4: 92 10 20 00 clr %o1 20058c8: 40 00 04 84 call 2006ad8 <_CORE_semaphore_Flush> 20058cc: 94 10 20 02 mov 2, %o2 20058d0: 03 00 80 5e sethi %hi(0x2017800), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 20058d4: c6 06 20 08 ld [ %i0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20058d8: 90 10 62 60 or %g1, 0x260, %o0 20058dc: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 20058e0: 03 00 00 3f sethi %hi(0xfc00), %g1 20058e4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20058e8: 82 08 c0 01 and %g3, %g1, %g1 20058ec: 80 a0 40 02 cmp %g1, %g2 20058f0: 18 80 00 05 bgu 2005904 20058f4: 92 10 00 18 mov %i0, %o1 information->local_table[ index ] = the_object; 20058f8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 20058fc: 83 28 60 02 sll %g1, 2, %g1 2005900: 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; 2005904: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 2005908: 40 00 07 40 call 2007608 <_Objects_Free> 200590c: b0 10 20 00 clr %i0 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 2005910: 7f ff ff bd call 2005804 <_Thread_Enable_dispatch> 2005914: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005918: 81 c7 e0 08 ret 200591c: 81 e8 00 00 restore 02005d7c : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 2005d7c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2005d80: 11 00 80 65 sethi %hi(0x2019400), %o0 2005d84: 92 10 00 18 mov %i0, %o1 2005d88: 90 12 21 28 or %o0, 0x128, %o0 2005d8c: 40 00 08 2f call 2007e48 <_Objects_Get> 2005d90: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2005d94: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005d98: 80 a0 60 00 cmp %g1, 0 2005d9c: 22 80 00 07 be,a 2005db8 2005da0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2005da4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2005da8: 08 80 00 19 bleu 2005e0c <== NOT EXECUTED 2005dac: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2005db0: 81 c7 e0 08 ret <== NOT EXECUTED 2005db4: 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) ) { 2005db8: 80 88 60 30 btst 0x30, %g1 2005dbc: 02 80 00 06 be 2005dd4 2005dc0: 90 02 20 14 add %o0, 0x14, %o0 _CORE_mutex_Flush( 2005dc4: 92 10 20 00 clr %o1 2005dc8: 40 00 04 63 call 2006f54 <_CORE_mutex_Flush> 2005dcc: 94 10 20 01 mov 1, %o2 2005dd0: 30 80 00 04 b,a 2005de0 &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 2005dd4: 92 10 20 00 clr %o1 <== NOT EXECUTED 2005dd8: 40 00 05 0e call 2007210 <_CORE_semaphore_Flush> <== NOT EXECUTED 2005ddc: 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 ) 2005de0: 03 00 80 65 sethi %hi(0x2019400), %g1 2005de4: c4 00 62 70 ld [ %g1 + 0x270 ], %g2 ! 2019670 <_Thread_Dispatch_disable_level> 2005de8: b0 10 20 00 clr %i0 2005dec: 84 00 bf ff add %g2, -1, %g2 2005df0: c4 20 62 70 st %g2, [ %g1 + 0x270 ] 2005df4: c2 00 62 70 ld [ %g1 + 0x270 ], %g1 2005df8: 80 a0 60 00 cmp %g1, 0 2005dfc: 12 80 00 04 bne 2005e0c 2005e00: 01 00 00 00 nop _Thread_Dispatch(); 2005e04: 40 00 0c d7 call 2009160 <_Thread_Dispatch> 2005e08: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005e0c: 81 c7 e0 08 ret 2005e10: 81 e8 00 00 restore 02005954 : rtems_status_code rtems_semaphore_obtain( rtems_id id, uint32_t option_set, rtems_interval timeout ) { 2005954: 9d e3 bf 90 save %sp, -112, %sp Objects_Id id, Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) 2005958: 11 00 80 5e sethi %hi(0x2017800), %o0 200595c: 92 10 00 18 mov %i0, %o1 2005960: 90 12 22 60 or %o0, 0x260, %o0 2005964: 94 07 bf f4 add %fp, -12, %o2 2005968: 40 00 07 4c call 2007698 <_Objects_Get_isr_disable> 200596c: 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 ) { 2005970: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005974: 80 a0 60 00 cmp %g1, 0 2005978: 02 80 00 07 be 2005994 200597c: a0 10 00 08 mov %o0, %l0 2005980: 80 a0 60 02 cmp %g1, 2 2005984: 08 80 00 ab bleu 2005c30 2005988: 90 10 20 04 mov 4, %o0 200598c: 10 80 00 a9 b 2005c30 <== NOT EXECUTED 2005990: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 2005994: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2005998: 80 88 60 30 btst 0x30, %g1 200599c: 02 80 00 7c be 2005b8c 20059a0: 03 00 80 5f sethi %hi(0x2017c00), %g1 _CORE_mutex_Seize( 20059a4: 03 00 80 5e sethi %hi(0x2017800), %g1 20059a8: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> 20059ac: 80 a0 60 00 cmp %g1, 0 20059b0: 02 80 00 0e be 20059e8 20059b4: 03 00 80 5f sethi %hi(0x2017c00), %g1 20059b8: 80 8e 60 01 btst 1, %i1 20059bc: 12 80 00 0c bne 20059ec 20059c0: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 20059c4: 03 00 80 5f sethi %hi(0x2017c00), %g1 20059c8: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 2017d90 <_System_state_Current> 20059cc: 80 a0 60 01 cmp %g1, 1 20059d0: 08 80 00 05 bleu 20059e4 20059d4: 90 10 20 00 clr %o0 20059d8: 92 10 20 00 clr %o1 <== NOT EXECUTED 20059dc: 40 00 05 dc call 200714c <_Internal_error_Occurred> <== NOT EXECUTED 20059e0: 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; 20059e4: 03 00 80 5f sethi %hi(0x2017c00), %g1 20059e8: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 2017c90 <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 20059ec: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20059f0: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 20059f4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 20059f8: 80 a0 60 00 cmp %g1, 0 20059fc: 22 80 00 33 be,a 2005ac8 2005a00: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 2005a04: c0 24 20 64 clr [ %l0 + 0x64 ] the_mutex->holder = executing; 2005a08: c4 24 20 70 st %g2, [ %l0 + 0x70 ] the_mutex->holder_id = executing->Object.id; 2005a0c: 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; 2005a10: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2005a14: c2 24 20 74 st %g1, [ %l0 + 0x74 ] the_mutex->nest_count = 1; 2005a18: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2005a1c: 80 a0 e0 02 cmp %g3, 2 2005a20: 02 80 00 05 be 2005a34 2005a24: c2 24 20 68 st %g1, [ %l0 + 0x68 ] 2005a28: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2005a2c: 32 80 00 06 bne,a 2005a44 <== NOT EXECUTED 2005a30: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2005a34: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 2005a38: 82 00 60 01 inc %g1 2005a3c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2005a40: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 2005a44: 80 a0 60 03 cmp %g1, 3 2005a48: 22 80 00 03 be,a 2005a54 2005a4c: c6 04 20 60 ld [ %l0 + 0x60 ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2005a50: 30 80 00 2e b,a 2005b08 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2005a54: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2005a58: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2005a5c: 12 80 00 03 bne 2005a68 <== NOT EXECUTED 2005a60: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2005a64: 30 80 00 29 b,a 2005b08 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2005a68: 28 80 00 10 bleu,a 2005aa8 <== NOT EXECUTED 2005a6c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005a70: 05 00 80 5e sethi %hi(0x2017800), %g2 <== NOT EXECUTED 2005a74: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2017bb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2005a78: 82 00 60 01 inc %g1 <== NOT EXECUTED 2005a7c: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2005a80: 7f ff f0 b4 call 2001d50 <== NOT EXECUTED 2005a84: 01 00 00 00 nop <== NOT EXECUTED _Thread_Change_priority( 2005a88: d2 04 20 60 ld [ %l0 + 0x60 ], %o1 <== NOT EXECUTED 2005a8c: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 <== NOT EXECUTED 2005a90: 40 00 0a e8 call 2008630 <_Thread_Change_priority> <== NOT EXECUTED 2005a94: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2005a98: 7f ff ff a2 call 2005920 <_Thread_Enable_dispatch> <== NOT EXECUTED 2005a9c: 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( 2005aa0: 10 80 00 36 b 2005b78 <== NOT EXECUTED 2005aa4: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2005aa8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2005aac: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2005ab0: c0 24 20 68 clr [ %l0 + 0x68 ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 2005ab4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2005ab8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2005abc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2005ac0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2005ac4: 30 80 00 11 b,a 2005b08 <== 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 ) ) { 2005ac8: 80 a0 40 02 cmp %g1, %g2 2005acc: 12 80 00 13 bne 2005b18 2005ad0: 80 8e 60 01 btst 1, %i1 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2005ad4: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 2005ad8: 80 a0 60 00 cmp %g1, 0 2005adc: 22 80 00 07 be,a 2005af8 2005ae0: c2 04 20 68 ld [ %l0 + 0x68 ], %g1 2005ae4: 80 a0 60 01 cmp %g1, 1 2005ae8: 12 80 00 0c bne 2005b18 2005aec: 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; 2005af0: 10 80 00 05 b 2005b04 <== NOT EXECUTED 2005af4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2005af8: 82 00 60 01 inc %g1 2005afc: c2 24 20 68 st %g1, [ %l0 + 0x68 ] _ISR_Enable( level ); 2005b00: 30 80 00 02 b,a 2005b08 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2005b04: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2005b08: 7f ff f0 92 call 2001d50 2005b0c: 01 00 00 00 nop 2005b10: 10 80 00 1a b 2005b78 2005b14: 03 00 80 5f sethi %hi(0x2017c00), %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 2005b18: 02 80 00 08 be 2005b38 2005b1c: 23 00 80 5f sethi %hi(0x2017c00), %l1 2005b20: 7f ff f0 8c call 2001d50 2005b24: d0 07 bf f0 ld [ %fp + -16 ], %o0 2005b28: c4 04 60 90 ld [ %l1 + 0x90 ], %g2 2005b2c: 82 10 20 01 mov 1, %g1 2005b30: 10 80 00 11 b 2005b74 2005b34: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] 2005b38: c6 04 60 90 ld [ %l1 + 0x90 ], %g3 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2005b3c: 82 10 20 01 mov 1, %g1 2005b40: 05 00 80 5e sethi %hi(0x2017800), %g2 2005b44: c2 24 20 44 st %g1, [ %l0 + 0x44 ] 2005b48: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 2005b4c: f0 20 e0 20 st %i0, [ %g3 + 0x20 ] 2005b50: 82 00 60 01 inc %g1 2005b54: a0 04 20 14 add %l0, 0x14, %l0 2005b58: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 2005b5c: e0 20 e0 44 st %l0, [ %g3 + 0x44 ] 2005b60: 7f ff f0 7c call 2001d50 2005b64: d0 07 bf f0 ld [ %fp + -16 ], %o0 2005b68: 90 10 00 10 mov %l0, %o0 2005b6c: 40 00 03 5e call 20068e4 <_CORE_mutex_Seize_interrupt_blocking> 2005b70: 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( 2005b74: 03 00 80 5f sethi %hi(0x2017c00), %g1 2005b78: c2 00 60 90 ld [ %g1 + 0x90 ], %g1 ! 2017c90 <_Thread_Executing> 2005b7c: 40 00 00 62 call 2005d04 <_Semaphore_Translate_core_mutex_return_code> 2005b80: 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 */ } 2005b84: 81 c7 e0 08 ret 2005b88: 91 e8 00 08 restore %g0, %o0, %o0 Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2005b8c: e2 00 60 90 ld [ %g1 + 0x90 ], %l1 Watchdog_Interval timeout, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 2005b90: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 2005b94: c0 24 60 34 clr [ %l1 + 0x34 ] if ( the_semaphore->count != 0 ) { 2005b98: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 2005b9c: 80 a0 60 00 cmp %g1, 0 2005ba0: 02 80 00 08 be 2005bc0 2005ba4: 80 8e 60 01 btst 1, %i1 the_semaphore->count -= 1; 2005ba8: 82 00 7f ff add %g1, -1, %g1 2005bac: c2 24 20 5c st %g1, [ %l0 + 0x5c ] _ISR_Enable( level ); 2005bb0: 7f ff f0 68 call 2001d50 2005bb4: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 2005bb8: 10 80 00 1b b 2005c24 2005bbc: 03 00 80 5f sethi %hi(0x2017c00), %g1 return; } if ( !wait ) { 2005bc0: 02 80 00 07 be 2005bdc 2005bc4: 05 00 80 5e sethi %hi(0x2017800), %g2 _ISR_Enable( level ); 2005bc8: 7f ff f0 62 call 2001d50 2005bcc: 01 00 00 00 nop executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 2005bd0: 82 10 20 01 mov 1, %g1 ! 1 2005bd4: 10 80 00 13 b 2005c20 2005bd8: c2 24 60 34 st %g1, [ %l1 + 0x34 ] 2005bdc: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 2005be0: 82 00 60 01 inc %g1 2005be4: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 2005be8: 82 10 20 01 mov 1, %g1 2005bec: 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; 2005bf0: f0 24 60 20 st %i0, [ %l1 + 0x20 ] return; } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 2005bf4: a0 04 20 14 add %l0, 0x14, %l0 2005bf8: e0 24 60 44 st %l0, [ %l1 + 0x44 ] executing->Wait.id = id; _ISR_Enable( level ); 2005bfc: 7f ff f0 55 call 2001d50 2005c00: 01 00 00 00 nop _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 2005c04: 90 10 00 10 mov %l0, %o0 2005c08: 92 10 00 1a mov %i2, %o1 2005c0c: 15 00 80 25 sethi %hi(0x2009400), %o2 2005c10: 40 00 0d 5c call 2009180 <_Thread_queue_Enqueue_with_handler> 2005c14: 94 12 a2 18 or %o2, 0x218, %o2 ! 2009618 <_Thread_queue_Timeout> _Thread_Enable_dispatch(); 2005c18: 7f ff ff 42 call 2005920 <_Thread_Enable_dispatch> 2005c1c: 01 00 00 00 nop 2005c20: 03 00 80 5f sethi %hi(0x2017c00), %g1 2005c24: c2 00 60 90 ld [ %g1 + 0x90 ], %g1 ! 2017c90 <_Thread_Executing> 2005c28: 40 00 00 41 call 2005d2c <_Semaphore_Translate_core_semaphore_return_code> 2005c2c: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005c30: b0 10 00 08 mov %o0, %i0 2005c34: 81 c7 e0 08 ret 2005c38: 81 e8 00 00 restore 02005c70 : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 2005c70: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2005c74: 11 00 80 5e sethi %hi(0x2017800), %o0 2005c78: 92 10 00 18 mov %i0, %o1 2005c7c: 90 12 22 60 or %o0, 0x260, %o0 2005c80: 40 00 06 a4 call 2007710 <_Objects_Get> 2005c84: 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 ) { 2005c88: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005c8c: 80 a0 60 00 cmp %g1, 0 2005c90: 22 80 00 07 be,a 2005cac 2005c94: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2005c98: 80 a0 60 02 cmp %g1, 2 2005c9c: 08 80 00 17 bleu 2005cf8 2005ca0: 90 10 20 04 mov 4, %o0 2005ca4: 10 80 00 15 b 2005cf8 <== NOT EXECUTED 2005ca8: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 2005cac: 80 88 60 30 btst 0x30, %g1 2005cb0: 02 80 00 0b be 2005cdc 2005cb4: 90 02 20 14 add %o0, 0x14, %o0 mutex_status = _CORE_mutex_Surrender( 2005cb8: 92 10 00 18 mov %i0, %o1 2005cbc: 40 00 03 2c call 200696c <_CORE_mutex_Surrender> 2005cc0: 94 10 20 00 clr %o2 &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 2005cc4: 7f ff ff de call 2005c3c <_Thread_Enable_dispatch> 2005cc8: a0 10 00 08 mov %o0, %l0 return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 2005ccc: 40 00 00 0e call 2005d04 <_Semaphore_Translate_core_mutex_return_code> 2005cd0: 90 10 00 10 mov %l0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005cd4: 81 c7 e0 08 ret 2005cd8: 91 e8 00 08 restore %g0, %o0, %o0 MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 2005cdc: 92 10 00 18 mov %i0, %o1 2005ce0: 40 00 03 91 call 2006b24 <_CORE_semaphore_Surrender> 2005ce4: 94 10 20 00 clr %o2 &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 2005ce8: 7f ff ff d5 call 2005c3c <_Thread_Enable_dispatch> 2005cec: a0 10 00 08 mov %o0, %l0 return 2005cf0: 40 00 00 0f call 2005d2c <_Semaphore_Translate_core_semaphore_return_code> 2005cf4: 90 10 00 10 mov %l0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005cf8: b0 10 00 08 mov %o0, %i0 2005cfc: 81 c7 e0 08 ret 2005d00: 81 e8 00 00 restore 020157a0 : */ void rtems_shutdown_executive( uint32_t result ) { 20157a0: 9d e3 bf 98 save %sp, -104, %sp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 20157a4: 33 00 80 5f sethi %hi(0x2017c00), %i1 20157a8: c2 06 61 90 ld [ %i1 + 0x190 ], %g1 ! 2017d90 <_System_state_Current> 20157ac: 80 a0 60 04 cmp %g1, 4 20157b0: 02 80 00 0c be 20157e0 20157b4: 11 00 80 5a sethi %hi(0x2016800), %o0 #if defined(__USE_INIT_FINI__) extern void _fini( void ); atexit( _fini ); 20157b8: 7f ff e0 1d call 200d82c 20157bc: 90 12 22 a4 or %o0, 0x2a4, %o0 ! 2016aa4 <_fini> * routine which initialized the system. */ RTEMS_INLINE_ROUTINE void _Thread_Stop_multitasking( void ) { _Context_Switch( &_Thread_Executing->Registers, &_Thread_BSP_context ); 20157c0: 03 00 80 5f sethi %hi(0x2017c00), %g1 20157c4: f0 00 60 90 ld [ %g1 + 0x90 ], %i0 ! 2017c90 <_Thread_Executing> 20157c8: 82 10 20 04 mov 4, %g1 20157cc: b0 06 20 e0 add %i0, 0xe0, %i0 20157d0: c2 26 61 90 st %g1, [ %i1 + 0x190 ] 20157d4: 33 00 80 5e sethi %hi(0x2017800), %i1 20157d8: 7f ff d2 fa call 200a3c0 <_CPU_Context_switch> 20157dc: 93 ee 63 28 restore %i1, 0x328, %o1 20157e0: 81 c7 e0 08 ret <== NOT EXECUTED 20157e4: 81 e8 00 00 restore <== NOT EXECUTED 0201124c : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 201124c: 9d e3 bf 90 save %sp, -112, %sp 2011250: 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 ) 2011254: 80 a6 60 00 cmp %i1, 0 2011258: 02 80 00 47 be 2011374 201125c: 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 ) ) { 2011260: 80 a2 60 00 cmp %o1, 0 2011264: 12 80 00 0a bne 201128c 2011268: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 201126c: 03 00 80 c3 sethi %hi(0x2030c00), %g1 2011270: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2030fb0 <_Thread_Dispatch_disable_level> 2011274: 84 00 a0 01 inc %g2 2011278: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 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; 201127c: 03 00 80 c4 sethi %hi(0x2031000), %g1 2011280: f0 00 60 90 ld [ %g1 + 0x90 ], %i0 ! 2031090 <_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; 2011284: 10 80 00 18 b 20112e4 2011288: c0 27 bf f4 clr [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 201128c: 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 ) { 2011290: 80 a0 a0 04 cmp %g2, 4 2011294: 18 80 00 0e bgu 20112cc 2011298: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 201129c: 83 32 60 1b srl %o1, 0x1b, %g1 20112a0: 80 a0 60 01 cmp %g1, 1 20112a4: 12 80 00 0a bne 20112cc 20112a8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20112ac: 83 28 a0 02 sll %g2, 2, %g1 20112b0: 05 00 80 c3 sethi %hi(0x2030c00), %g2 20112b4: 84 10 a3 10 or %g2, 0x310, %g2 ! 2030f10 <_Objects_Information_table> 20112b8: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20112bc: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20112c0: 80 a2 20 00 cmp %o0, 0 20112c4: 12 80 00 05 bne 20112d8 20112c8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20112cc: b0 10 20 00 clr %i0 20112d0: 10 80 00 05 b 20112e4 20112d4: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20112d8: 40 00 0d c8 call 20149f8 <_Objects_Get> 20112dc: 94 07 bf f4 add %fp, -12, %o2 20112e0: b0 10 00 08 mov %o0, %i0 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20112e4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20112e8: 80 a0 60 00 cmp %g1, 0 20112ec: 22 80 00 07 be,a 2011308 20112f0: d2 06 21 70 ld [ %i0 + 0x170 ], %o1 20112f4: 80 a0 60 02 cmp %g1, 2 20112f8: 08 80 00 1f bleu 2011374 20112fc: b0 10 20 04 mov 4, %i0 2011300: 81 c7 e0 08 ret <== NOT EXECUTED 2011304: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 2011308: c2 02 60 4c ld [ %o1 + 0x4c ], %g1 201130c: 80 a0 60 00 cmp %g1, 0 2011310: 02 80 00 1b be 201137c 2011314: 01 00 00 00 nop if ( asr->is_enabled ) { 2011318: c2 02 60 48 ld [ %o1 + 0x48 ], %g1 201131c: 80 a0 60 00 cmp %g1, 0 2011320: 02 80 00 11 be 2011364 2011324: 90 10 00 19 mov %i1, %o0 _ASR_Post_signals( signal_set, &asr->signals_posted ); 2011328: 7f ff ff b3 call 20111f4 <_ASR_Post_signals> 201132c: 92 02 60 54 add %o1, 0x54, %o1 the_thread->do_post_task_switch_extension = TRUE; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 2011330: 03 00 80 c4 sethi %hi(0x2031000), %g1 2011334: c2 00 60 78 ld [ %g1 + 0x78 ], %g1 ! 2031078 <_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; 2011338: 84 10 20 01 mov 1, %g2 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 201133c: 80 a0 60 00 cmp %g1, 0 2011340: 02 80 00 0b be 201136c 2011344: c4 26 20 78 st %g2, [ %i0 + 0x78 ] 2011348: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED 201134c: c2 00 60 90 ld [ %g1 + 0x90 ], %g1 ! 2031090 <_Thread_Executing> <== NOT EXECUTED 2011350: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 2011354: 12 80 00 06 bne 201136c <== NOT EXECUTED 2011358: 03 00 80 c4 sethi %hi(0x2031000), %g1 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 201135c: 10 80 00 04 b 201136c <== NOT EXECUTED 2011360: c4 20 61 38 st %g2, [ %g1 + 0x138 ] ! 2031138 <_ISR_Signals_to_thread_executing> <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); 2011364: 7f ff ff a4 call 20111f4 <_ASR_Post_signals> 2011368: 92 02 60 58 add %o1, 0x58, %o1 } _Thread_Enable_dispatch(); 201136c: 7f ff ff ab call 2011218 <_Thread_Enable_dispatch> 2011370: b0 10 20 00 clr %i0 2011374: 81 c7 e0 08 ret 2011378: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 201137c: 7f ff ff a7 call 2011218 <_Thread_Enable_dispatch> 2011380: b0 10 20 0b mov 0xb, %i0 return RTEMS_NOT_DEFINED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2011384: 81 c7 e0 08 ret 2011388: 81 e8 00 00 restore 02005f10 : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 2005f10: 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 ) ) { 2005f14: 92 96 20 00 orcc %i0, 0, %o1 2005f18: 12 80 00 0a bne 2005f40 2005f1c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005f20: 03 00 80 5e sethi %hi(0x2017800), %g1 2005f24: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2017bb0 <_Thread_Dispatch_disable_level> 2005f28: 84 00 a0 01 inc %g2 2005f2c: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 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; 2005f30: 03 00 80 5f sethi %hi(0x2017c00), %g1 2005f34: f0 00 60 90 ld [ %g1 + 0x90 ], %i0 ! 2017c90 <_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; 2005f38: 10 80 00 18 b 2005f98 2005f3c: c0 27 bf f4 clr [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2005f40: 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 ) { 2005f44: 80 a0 a0 04 cmp %g2, 4 2005f48: 18 80 00 0e bgu 2005f80 2005f4c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2005f50: 83 32 60 1b srl %o1, 0x1b, %g1 2005f54: 80 a0 60 01 cmp %g1, 1 2005f58: 12 80 00 0a bne 2005f80 2005f5c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2005f60: 83 28 a0 02 sll %g2, 2, %g1 2005f64: 05 00 80 5e sethi %hi(0x2017800), %g2 2005f68: 84 10 a3 10 or %g2, 0x310, %g2 ! 2017b10 <_Objects_Information_table> 2005f6c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2005f70: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2005f74: 80 a2 20 00 cmp %o0, 0 2005f78: 12 80 00 05 bne 2005f8c 2005f7c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2005f80: b0 10 20 00 clr %i0 2005f84: 10 80 00 05 b 2005f98 2005f88: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2005f8c: 40 00 05 e1 call 2007710 <_Objects_Get> 2005f90: 94 07 bf f4 add %fp, -12, %o2 2005f94: b0 10 00 08 mov %o0, %i0 register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2005f98: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005f9c: 80 a0 60 00 cmp %g1, 0 2005fa0: 02 80 00 06 be 2005fb8 2005fa4: 80 a0 60 02 cmp %g1, 2 2005fa8: 08 80 00 0b bleu 2005fd4 2005fac: b0 10 20 04 mov 4, %i0 2005fb0: 81 c7 e0 08 ret <== NOT EXECUTED 2005fb4: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_information = _Objects_Get_information( the_thread->Object.id ); 2005fb8: 7f ff ff c0 call 2005eb8 <_Objects_Get_information> 2005fbc: d0 06 20 08 ld [ %i0 + 8 ], %o0 if ( !the_information ) { 2005fc0: 80 a2 20 00 cmp %o0, 0 2005fc4: 12 80 00 06 bne 2005fdc 2005fc8: 01 00 00 00 nop _Thread_Enable_dispatch(); 2005fcc: 7f ff ff c4 call 2005edc <_Thread_Enable_dispatch> <== NOT EXECUTED 2005fd0: b0 10 20 04 mov 4, %i0 ! 4 <== NOT EXECUTED 2005fd4: 81 c7 e0 08 ret 2005fd8: 81 e8 00 00 restore return RTEMS_INVALID_ID; /* This should never happen if _Thread_Get() works right */ } _Thread_Close( the_information, the_thread ); 2005fdc: 40 00 0a 43 call 20088e8 <_Thread_Close> 2005fe0: 92 10 00 18 mov %i0, %o1 2005fe4: 7f ff ff b5 call 2005eb8 <_Objects_Get_information> 2005fe8: d0 06 20 08 ld [ %i0 + 8 ], %o0 2005fec: 92 10 00 18 mov %i0, %o1 2005ff0: 40 00 05 86 call 2007608 <_Objects_Free> 2005ff4: b0 10 20 00 clr %i0 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 2005ff8: 7f ff ff b9 call 2005edc <_Thread_Enable_dispatch> 2005ffc: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006000: 81 c7 e0 08 ret 2006004: 81 e8 00 00 restore 0200781c : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 200781c: 9d e3 bf 90 save %sp, -112, %sp 2007820: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !note ) 2007824: 80 a6 a0 00 cmp %i2, 0 2007828: 02 80 00 43 be 2007934 200782c: 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 ) 2007830: 80 a6 60 0f cmp %i1, 0xf 2007834: 18 80 00 40 bgu 2007934 2007838: 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 ) || 200783c: 80 a2 60 00 cmp %o1, 0 2007840: 02 80 00 08 be 2007860 2007844: 03 00 80 73 sethi %hi(0x201cc00), %g1 2007848: c2 00 63 40 ld [ %g1 + 0x340 ], %g1 ! 201cf40 <_Thread_Executing> 200784c: c2 00 60 08 ld [ %g1 + 8 ], %g1 2007850: 80 a2 40 01 cmp %o1, %g1 2007854: 12 80 00 0a bne 200787c 2007858: 83 32 60 18 srl %o1, 0x18, %g1 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 200785c: 03 00 80 73 sethi %hi(0x201cc00), %g1 <== NOT EXECUTED 2007860: c2 00 63 40 ld [ %g1 + 0x340 ], %g1 ! 201cf40 <_Thread_Executing> 2007864: 85 2e 60 02 sll %i1, 2, %g2 2007868: c2 00 61 70 ld [ %g1 + 0x170 ], %g1 200786c: c2 00 40 02 ld [ %g1 + %g2 ], %g1 2007870: c2 26 80 00 st %g1, [ %i2 ] 2007874: 81 c7 e0 08 ret 2007878: 91 e8 20 00 restore %g0, 0, %o0 200787c: 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 ) { 2007880: 80 a0 a0 04 cmp %g2, 4 2007884: 18 80 00 06 bgu 200789c 2007888: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 200788c: 83 32 60 1b srl %o1, 0x1b, %g1 2007890: 80 a0 60 01 cmp %g1, 1 2007894: 02 80 00 05 be 20078a8 2007898: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 200789c: 90 10 20 00 clr %o0 20078a0: 10 80 00 0e b 20078d8 20078a4: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20078a8: 83 28 a0 02 sll %g2, 2, %g1 20078ac: 05 00 80 73 sethi %hi(0x201cc00), %g2 20078b0: 84 10 a1 c0 or %g2, 0x1c0, %g2 ! 201cdc0 <_Objects_Information_table> 20078b4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20078b8: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20078bc: 80 a2 20 00 cmp %o0, 0 20078c0: 12 80 00 04 bne 20078d0 20078c4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20078c8: 10 80 00 04 b 20078d8 <== NOT EXECUTED 20078cc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20078d0: 40 00 07 2b call 200957c <_Objects_Get> 20078d4: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 20078d8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20078dc: 80 a0 60 00 cmp %g1, 0 20078e0: 22 80 00 07 be,a 20078fc 20078e4: c4 02 21 70 ld [ %o0 + 0x170 ], %g2 20078e8: 80 a0 60 02 cmp %g1, 2 20078ec: 08 80 00 12 bleu 2007934 20078f0: b0 10 20 04 mov 4, %i0 20078f4: 81 c7 e0 08 ret <== NOT EXECUTED 20078f8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 20078fc: 83 2e 60 02 sll %i1, 2, %g1 2007900: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2007904: c2 26 80 00 st %g1, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007908: 05 00 80 73 sethi %hi(0x201cc00), %g2 200790c: c2 00 a2 60 ld [ %g2 + 0x260 ], %g1 ! 201ce60 <_Thread_Dispatch_disable_level> 2007910: b0 10 20 00 clr %i0 2007914: 82 00 7f ff add %g1, -1, %g1 2007918: c2 20 a2 60 st %g1, [ %g2 + 0x260 ] 200791c: c2 00 a2 60 ld [ %g2 + 0x260 ], %g1 2007920: 80 a0 60 00 cmp %g1, 0 2007924: 12 80 00 04 bne 2007934 2007928: 01 00 00 00 nop _Thread_Dispatch(); 200792c: 40 00 0b da call 200a894 <_Thread_Dispatch> 2007930: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007934: 81 c7 e0 08 ret 2007938: 81 e8 00 00 restore 0200669c : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 200669c: 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 ) ) { 20066a0: 92 96 20 00 orcc %i0, 0, %o1 20066a4: 12 80 00 0a bne 20066cc 20066a8: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20066ac: 03 00 80 6b sethi %hi(0x201ac00), %g1 <== NOT EXECUTED 20066b0: c4 00 60 60 ld [ %g1 + 0x60 ], %g2 ! 201ac60 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20066b4: 84 00 a0 01 inc %g2 <== NOT EXECUTED 20066b8: c4 20 60 60 st %g2, [ %g1 + 0x60 ] <== 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; 20066bc: 03 00 80 6b sethi %hi(0x201ac00), %g1 <== NOT EXECUTED 20066c0: d0 00 61 40 ld [ %g1 + 0x140 ], %o0 ! 201ad40 <_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; 20066c4: 10 80 00 19 b 2006728 <== NOT EXECUTED 20066c8: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 20066cc: 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 ) { 20066d0: 80 a0 a0 04 cmp %g2, 4 20066d4: 18 80 00 06 bgu 20066ec 20066d8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20066dc: 83 32 60 1b srl %o1, 0x1b, %g1 20066e0: 80 a0 60 01 cmp %g1, 1 20066e4: 02 80 00 05 be 20066f8 20066e8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20066ec: 90 10 20 00 clr %o0 <== NOT EXECUTED 20066f0: 10 80 00 0e b 2006728 <== NOT EXECUTED 20066f4: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20066f8: 83 28 a0 02 sll %g2, 2, %g1 20066fc: 05 00 80 6a sethi %hi(0x201a800), %g2 2006700: 84 10 a3 c0 or %g2, 0x3c0, %g2 ! 201abc0 <_Objects_Information_table> 2006704: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2006708: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 200670c: 80 a2 20 00 cmp %o0, 0 2006710: 12 80 00 04 bne 2006720 2006714: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2006718: 10 80 00 04 b 2006728 <== NOT EXECUTED 200671c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2006720: 40 00 06 31 call 2007fe4 <_Objects_Get> 2006724: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006728: c2 07 bf f4 ld [ %fp + -12 ], %g1 200672c: 80 a0 60 00 cmp %g1, 0 2006730: 22 80 00 07 be,a 200674c 2006734: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2006738: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200673c: 08 80 00 09 bleu 2006760 <== NOT EXECUTED 2006740: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2006744: 81 c7 e0 08 ret <== NOT EXECUTED 2006748: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 200674c: 80 88 60 02 btst 2, %g1 2006750: 12 80 00 06 bne 2006768 2006754: 01 00 00 00 nop _Thread_Enable_dispatch(); 2006758: 7f ff ff c4 call 2006668 <_Thread_Enable_dispatch> 200675c: b0 10 20 00 clr %i0 ! 0 2006760: 81 c7 e0 08 ret 2006764: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2006768: 7f ff ff c0 call 2006668 <_Thread_Enable_dispatch> 200676c: b0 10 20 0f mov 0xf, %i0 return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006770: 81 c7 e0 08 ret 2006774: 81 e8 00 00 restore 02006cf0 : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 2006cf0: 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 ) ) { 2006cf4: 92 96 20 00 orcc %i0, 0, %o1 2006cf8: 12 80 00 0a bne 2006d20 2006cfc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006d00: 03 00 80 6c sethi %hi(0x201b000), %g1 2006d04: c4 00 61 a0 ld [ %g1 + 0x1a0 ], %g2 ! 201b1a0 <_Thread_Dispatch_disable_level> 2006d08: 84 00 a0 01 inc %g2 2006d0c: c4 20 61 a0 st %g2, [ %g1 + 0x1a0 ] 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; 2006d10: 03 00 80 6c sethi %hi(0x201b000), %g1 2006d14: d0 00 62 80 ld [ %g1 + 0x280 ], %o0 ! 201b280 <_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; 2006d18: 10 80 00 19 b 2006d7c 2006d1c: c0 27 bf f4 clr [ %fp + -12 ] 2006d20: 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 ) { 2006d24: 80 a0 a0 04 cmp %g2, 4 2006d28: 18 80 00 06 bgu 2006d40 2006d2c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2006d30: 83 32 60 1b srl %o1, 0x1b, %g1 2006d34: 80 a0 60 01 cmp %g1, 1 2006d38: 02 80 00 05 be 2006d4c 2006d3c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2006d40: 90 10 20 00 clr %o0 2006d44: 10 80 00 0e b 2006d7c 2006d48: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2006d4c: 83 28 a0 02 sll %g2, 2, %g1 2006d50: 05 00 80 6c sethi %hi(0x201b000), %g2 2006d54: 84 10 a1 00 or %g2, 0x100, %g2 ! 201b100 <_Objects_Information_table> 2006d58: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2006d5c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2006d60: 80 a2 20 00 cmp %o0, 0 2006d64: 12 80 00 04 bne 2006d74 2006d68: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2006d6c: 10 80 00 04 b 2006d7c <== NOT EXECUTED 2006d70: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2006d74: 40 00 05 f8 call 2008554 <_Objects_Get> 2006d78: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006d7c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006d80: 80 a0 60 00 cmp %g1, 0 2006d84: 22 80 00 07 be,a 2006da0 2006d88: 94 10 00 19 mov %i1, %o2 2006d8c: 80 a0 60 02 cmp %g1, 2 2006d90: 08 80 00 0b bleu 2006dbc 2006d94: b0 10 20 04 mov 4, %i0 2006d98: 81 c7 e0 08 ret <== NOT EXECUTED 2006d9c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 2006da0: 40 00 0d ae call 200a458 <_Thread_Restart> 2006da4: 92 10 20 00 clr %o1 2006da8: 80 a2 20 00 cmp %o0, 0 2006dac: 02 80 00 06 be 2006dc4 2006db0: 01 00 00 00 nop _Thread_Enable_dispatch(); 2006db4: 7f ff ff c2 call 2006cbc <_Thread_Enable_dispatch> 2006db8: b0 10 20 00 clr %i0 ! 0 2006dbc: 81 c7 e0 08 ret 2006dc0: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2006dc4: 7f ff ff be call 2006cbc <_Thread_Enable_dispatch> 2006dc8: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006dcc: 81 c7 e0 08 ret 2006dd0: 81 e8 00 00 restore 020076bc : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 20076bc: 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 ) ) { 20076c0: 92 96 20 00 orcc %i0, 0, %o1 20076c4: 12 80 00 0a bne 20076ec 20076c8: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20076cc: 03 00 80 90 sethi %hi(0x2024000), %g1 20076d0: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 20240e0 <_Thread_Dispatch_disable_level> 20076d4: 84 00 a0 01 inc %g2 20076d8: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 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; 20076dc: 03 00 80 90 sethi %hi(0x2024000), %g1 20076e0: d0 00 61 c0 ld [ %g1 + 0x1c0 ], %o0 ! 20241c0 <_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; 20076e4: 10 80 00 19 b 2007748 20076e8: c0 27 bf f4 clr [ %fp + -12 ] 20076ec: 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 ) { 20076f0: 80 a0 a0 04 cmp %g2, 4 20076f4: 18 80 00 06 bgu 200770c 20076f8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20076fc: 83 32 60 1b srl %o1, 0x1b, %g1 2007700: 80 a0 60 01 cmp %g1, 1 2007704: 02 80 00 05 be 2007718 2007708: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 200770c: 90 10 20 00 clr %o0 2007710: 10 80 00 0e b 2007748 2007714: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007718: 83 28 a0 02 sll %g2, 2, %g1 200771c: 05 00 80 90 sethi %hi(0x2024000), %g2 2007720: 84 10 a0 40 or %g2, 0x40, %g2 ! 2024040 <_Objects_Information_table> 2007724: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2007728: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 200772c: 80 a2 20 00 cmp %o0, 0 2007730: 12 80 00 04 bne 2007740 2007734: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007738: 10 80 00 04 b 2007748 <== NOT EXECUTED 200773c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007740: 40 00 06 d2 call 2009288 <_Objects_Get> 2007744: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007748: c2 07 bf f4 ld [ %fp + -12 ], %g1 200774c: 80 a0 60 00 cmp %g1, 0 2007750: 22 80 00 07 be,a 200776c 2007754: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2007758: 80 a0 60 02 cmp %g1, 2 200775c: 08 80 00 0b bleu 2007788 2007760: b0 10 20 04 mov 4, %i0 2007764: 81 c7 e0 08 ret <== NOT EXECUTED 2007768: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 200776c: 80 88 60 02 btst 2, %g1 2007770: 02 80 00 08 be 2007790 2007774: 92 10 20 01 mov 1, %o1 _Thread_Resume( the_thread, TRUE ); 2007778: 40 00 0e 9b call 200b1e4 <_Thread_Resume> 200777c: b0 10 20 00 clr %i0 _Thread_Enable_dispatch(); 2007780: 7f ff ff c2 call 2007688 <_Thread_Enable_dispatch> 2007784: 01 00 00 00 nop 2007788: 81 c7 e0 08 ret 200778c: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2007790: 7f ff ff be call 2007688 <_Thread_Enable_dispatch> 2007794: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007798: 81 c7 e0 08 ret 200779c: 81 e8 00 00 restore 02007b08 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 2007b08: 9d e3 bf 90 save %sp, -112, %sp 2007b0c: 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 ) 2007b10: 80 a6 60 0f cmp %i1, 0xf 2007b14: 18 80 00 3e bgu 2007c0c 2007b18: 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 ) || 2007b1c: 80 a2 60 00 cmp %o1, 0 2007b20: 02 80 00 08 be 2007b40 2007b24: 03 00 80 73 sethi %hi(0x201cc00), %g1 2007b28: c2 00 63 40 ld [ %g1 + 0x340 ], %g1 ! 201cf40 <_Thread_Executing> 2007b2c: c2 00 60 08 ld [ %g1 + 8 ], %g1 2007b30: 80 a2 40 01 cmp %o1, %g1 2007b34: 12 80 00 09 bne 2007b58 2007b38: 83 32 60 18 srl %o1, 0x18, %g1 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 2007b3c: 03 00 80 73 sethi %hi(0x201cc00), %g1 <== NOT EXECUTED 2007b40: c2 00 63 40 ld [ %g1 + 0x340 ], %g1 ! 201cf40 <_Thread_Executing> <== NOT EXECUTED 2007b44: 85 2e 60 02 sll %i1, 2, %g2 <== NOT EXECUTED 2007b48: c2 00 61 70 ld [ %g1 + 0x170 ], %g1 <== NOT EXECUTED 2007b4c: f4 20 40 02 st %i2, [ %g1 + %g2 ] <== NOT EXECUTED 2007b50: 81 c7 e0 08 ret <== NOT EXECUTED 2007b54: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 2007b58: 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 ) { 2007b5c: 80 a0 a0 04 cmp %g2, 4 2007b60: 18 80 00 06 bgu 2007b78 2007b64: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007b68: 83 32 60 1b srl %o1, 0x1b, %g1 2007b6c: 80 a0 60 01 cmp %g1, 1 2007b70: 02 80 00 05 be 2007b84 2007b74: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007b78: 90 10 20 00 clr %o0 2007b7c: 10 80 00 0e b 2007bb4 2007b80: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007b84: 83 28 a0 02 sll %g2, 2, %g1 2007b88: 05 00 80 73 sethi %hi(0x201cc00), %g2 2007b8c: 84 10 a1 c0 or %g2, 0x1c0, %g2 ! 201cdc0 <_Objects_Information_table> 2007b90: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2007b94: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2007b98: 80 a2 20 00 cmp %o0, 0 2007b9c: 12 80 00 04 bne 2007bac 2007ba0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007ba4: 10 80 00 04 b 2007bb4 <== NOT EXECUTED 2007ba8: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007bac: 40 00 06 74 call 200957c <_Objects_Get> 2007bb0: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007bb4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007bb8: 80 a0 60 00 cmp %g1, 0 2007bbc: 22 80 00 07 be,a 2007bd8 2007bc0: c4 02 21 70 ld [ %o0 + 0x170 ], %g2 2007bc4: 80 a0 60 02 cmp %g1, 2 2007bc8: 08 80 00 11 bleu 2007c0c 2007bcc: b0 10 20 04 mov 4, %i0 2007bd0: 81 c7 e0 08 ret <== NOT EXECUTED 2007bd4: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 2007bd8: 83 2e 60 02 sll %i1, 2, %g1 2007bdc: 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 ) 2007be0: 05 00 80 73 sethi %hi(0x201cc00), %g2 2007be4: c2 00 a2 60 ld [ %g2 + 0x260 ], %g1 ! 201ce60 <_Thread_Dispatch_disable_level> 2007be8: b0 10 20 00 clr %i0 2007bec: 82 00 7f ff add %g1, -1, %g1 2007bf0: c2 20 a2 60 st %g1, [ %g2 + 0x260 ] 2007bf4: c2 00 a2 60 ld [ %g2 + 0x260 ], %g1 2007bf8: 80 a0 60 00 cmp %g1, 0 2007bfc: 12 80 00 04 bne 2007c0c 2007c00: 01 00 00 00 nop _Thread_Dispatch(); 2007c04: 40 00 0b 24 call 200a894 <_Thread_Dispatch> 2007c08: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007c0c: 81 c7 e0 08 ret 2007c10: 81 e8 00 00 restore 0200a664 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 200a664: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 200a668: 80 a6 60 00 cmp %i1, 0 200a66c: 02 80 00 06 be 200a684 200a670: 92 10 00 18 mov %i0, %o1 200a674: 82 06 7f ff add %i1, -1, %g1 200a678: 80 a0 60 fe cmp %g1, 0xfe 200a67c: 18 80 00 49 bgu 200a7a0 200a680: b0 10 20 13 mov 0x13, %i0 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 200a684: 80 a6 a0 00 cmp %i2, 0 200a688: 02 80 00 46 be 200a7a0 200a68c: 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 ) ) { 200a690: 80 a2 60 00 cmp %o1, 0 200a694: 12 80 00 0a bne 200a6bc 200a698: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200a69c: 03 00 80 99 sethi %hi(0x2026400), %g1 200a6a0: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 2026480 <_Thread_Dispatch_disable_level> 200a6a4: 84 00 a0 01 inc %g2 200a6a8: c4 20 60 80 st %g2, [ %g1 + 0x80 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 200a6ac: 03 00 80 99 sethi %hi(0x2026400), %g1 200a6b0: d0 00 61 60 ld [ %g1 + 0x160 ], %o0 ! 2026560 <_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; 200a6b4: 10 80 00 19 b 200a718 200a6b8: c0 27 bf f4 clr [ %fp + -12 ] 200a6bc: 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 ) { 200a6c0: 80 a0 a0 04 cmp %g2, 4 200a6c4: 18 80 00 06 bgu 200a6dc 200a6c8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 200a6cc: 83 32 60 1b srl %o1, 0x1b, %g1 200a6d0: 80 a0 60 01 cmp %g1, 1 200a6d4: 02 80 00 05 be 200a6e8 200a6d8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 200a6dc: 90 10 20 00 clr %o0 200a6e0: 10 80 00 0e b 200a718 200a6e4: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 200a6e8: 83 28 a0 02 sll %g2, 2, %g1 200a6ec: 05 00 80 98 sethi %hi(0x2026000), %g2 200a6f0: 84 10 a3 e0 or %g2, 0x3e0, %g2 ! 20263e0 <_Objects_Information_table> 200a6f4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 200a6f8: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 200a6fc: 80 a2 20 00 cmp %o0, 0 200a700: 12 80 00 04 bne 200a710 200a704: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 200a708: 10 80 00 04 b 200a718 <== NOT EXECUTED 200a70c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200a710: 40 00 06 16 call 200bf68 <_Objects_Get> 200a714: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 200a718: c2 07 bf f4 ld [ %fp + -12 ], %g1 200a71c: 80 a0 60 00 cmp %g1, 0 200a720: 22 80 00 07 be,a 200a73c 200a724: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200a728: 80 a0 60 02 cmp %g1, 2 200a72c: 08 80 00 1d bleu 200a7a0 200a730: b0 10 20 04 mov 4, %i0 200a734: 81 c7 e0 08 ret <== NOT EXECUTED 200a738: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED return RTEMS_INVALID_ID; case OBJECTS_LOCAL: /* XXX convert from core priority */ *old_priority = the_thread->current_priority; if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 200a73c: 80 a6 60 00 cmp %i1, 0 200a740: 02 80 00 0d be 200a774 200a744: c2 26 80 00 st %g1, [ %i2 ] the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200a748: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 200a74c: 80 a0 60 00 cmp %g1, 0 200a750: 02 80 00 06 be 200a768 200a754: f2 22 20 18 st %i1, [ %o0 + 0x18 ] 200a758: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200a75c: 80 a0 40 19 cmp %g1, %i1 200a760: 08 80 00 05 bleu 200a774 200a764: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 200a768: 92 10 00 19 mov %i1, %o1 200a76c: 40 00 09 c7 call 200ce88 <_Thread_Change_priority> 200a770: 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 ) 200a774: 03 00 80 99 sethi %hi(0x2026400), %g1 200a778: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 2026480 <_Thread_Dispatch_disable_level> 200a77c: b0 10 20 00 clr %i0 200a780: 84 00 bf ff add %g2, -1, %g2 200a784: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 200a788: c2 00 60 80 ld [ %g1 + 0x80 ], %g1 200a78c: 80 a0 60 00 cmp %g1, 0 200a790: 12 80 00 04 bne 200a7a0 200a794: 01 00 00 00 nop _Thread_Dispatch(); 200a798: 40 00 0a f9 call 200d37c <_Thread_Dispatch> 200a79c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200a7a0: 81 c7 e0 08 ret 200a7a4: 81 e8 00 00 restore 02006150 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 2006150: 9d e3 bf 90 save %sp, -112, %sp 2006154: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 2006158: 80 a6 60 00 cmp %i1, 0 200615c: 02 80 00 36 be 2006234 2006160: 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 ) ) { 2006164: 80 a2 60 00 cmp %o1, 0 2006168: 12 80 00 0a bne 2006190 200616c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006170: 03 00 80 5e sethi %hi(0x2017800), %g1 2006174: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2017bb0 <_Thread_Dispatch_disable_level> 2006178: 84 00 a0 01 inc %g2 200617c: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 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; 2006180: 03 00 80 5f sethi %hi(0x2017c00), %g1 2006184: d0 00 60 90 ld [ %g1 + 0x90 ], %o0 ! 2017c90 <_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; 2006188: 10 80 00 19 b 20061ec 200618c: c0 27 bf f4 clr [ %fp + -12 ] 2006190: 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 ) { 2006194: 80 a0 a0 04 cmp %g2, 4 2006198: 18 80 00 06 bgu 20061b0 200619c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20061a0: 83 32 60 1b srl %o1, 0x1b, %g1 20061a4: 80 a0 60 01 cmp %g1, 1 20061a8: 02 80 00 05 be 20061bc 20061ac: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20061b0: 90 10 20 00 clr %o0 20061b4: 10 80 00 0e b 20061ec 20061b8: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20061bc: 83 28 a0 02 sll %g2, 2, %g1 20061c0: 05 00 80 5e sethi %hi(0x2017800), %g2 20061c4: 84 10 a3 10 or %g2, 0x310, %g2 ! 2017b10 <_Objects_Information_table> 20061c8: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20061cc: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20061d0: 80 a2 20 00 cmp %o0, 0 20061d4: 12 80 00 04 bne 20061e4 20061d8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20061dc: 10 80 00 04 b 20061ec <== NOT EXECUTED 20061e0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20061e4: 40 00 05 4b call 2007710 <_Objects_Get> 20061e8: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20061ec: c2 07 bf f4 ld [ %fp + -12 ], %g1 20061f0: 80 a0 60 00 cmp %g1, 0 20061f4: 22 80 00 07 be,a 2006210 20061f8: 94 10 00 19 mov %i1, %o2 20061fc: 80 a0 60 02 cmp %g1, 2 2006200: 08 80 00 0d bleu 2006234 2006204: b0 10 20 04 mov 4, %i0 2006208: 81 c7 e0 08 ret <== NOT EXECUTED 200620c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Start( 2006210: 98 10 00 1a mov %i2, %o4 2006214: 92 10 20 00 clr %o1 2006218: 40 00 0e 1d call 2009a8c <_Thread_Start> 200621c: 96 10 20 00 clr %o3 2006220: 80 a2 20 00 cmp %o0, 0 2006224: 02 80 00 06 be 200623c 2006228: 01 00 00 00 nop the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 200622c: 7f ff ff bc call 200611c <_Thread_Enable_dispatch> 2006230: b0 10 20 00 clr %i0 ! 0 2006234: 81 c7 e0 08 ret 2006238: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 200623c: 7f ff ff b8 call 200611c <_Thread_Enable_dispatch> 2006240: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006244: 81 c7 e0 08 ret 2006248: 81 e8 00 00 restore 02007904 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 2007904: 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 ) ) { 2007908: 92 96 20 00 orcc %i0, 0, %o1 200790c: 12 80 00 0a bne 2007934 2007910: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007914: 03 00 80 90 sethi %hi(0x2024000), %g1 2007918: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 20240e0 <_Thread_Dispatch_disable_level> 200791c: 84 00 a0 01 inc %g2 2007920: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 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; 2007924: 03 00 80 90 sethi %hi(0x2024000), %g1 2007928: d0 00 61 c0 ld [ %g1 + 0x1c0 ], %o0 ! 20241c0 <_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; 200792c: 10 80 00 19 b 2007990 2007930: c0 27 bf f4 clr [ %fp + -12 ] 2007934: 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 ) { 2007938: 80 a0 a0 04 cmp %g2, 4 200793c: 18 80 00 06 bgu 2007954 2007940: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007944: 83 32 60 1b srl %o1, 0x1b, %g1 2007948: 80 a0 60 01 cmp %g1, 1 200794c: 02 80 00 05 be 2007960 2007950: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007954: 90 10 20 00 clr %o0 2007958: 10 80 00 0e b 2007990 200795c: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007960: 83 28 a0 02 sll %g2, 2, %g1 2007964: 05 00 80 90 sethi %hi(0x2024000), %g2 2007968: 84 10 a0 40 or %g2, 0x40, %g2 ! 2024040 <_Objects_Information_table> 200796c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2007970: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2007974: 80 a2 20 00 cmp %o0, 0 2007978: 12 80 00 04 bne 2007988 200797c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007980: 10 80 00 04 b 2007990 <== NOT EXECUTED 2007984: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007988: 40 00 06 40 call 2009288 <_Objects_Get> 200798c: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007990: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007994: 80 a0 60 00 cmp %g1, 0 2007998: 22 80 00 07 be,a 20079b4 200799c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 20079a0: 80 a0 60 02 cmp %g1, 2 20079a4: 08 80 00 0b bleu 20079d0 20079a8: b0 10 20 04 mov 4, %i0 20079ac: 81 c7 e0 08 ret <== NOT EXECUTED 20079b0: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 20079b4: 80 88 60 02 btst 2, %g1 20079b8: 12 80 00 08 bne 20079d8 20079bc: 01 00 00 00 nop _Thread_Suspend( the_thread ); 20079c0: 40 00 0f 3a call 200b6a8 <_Thread_Suspend> 20079c4: b0 10 20 00 clr %i0 ! 0 _Thread_Enable_dispatch(); 20079c8: 7f ff ff c2 call 20078d0 <_Thread_Enable_dispatch> 20079cc: 01 00 00 00 nop 20079d0: 81 c7 e0 08 ret 20079d4: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 20079d8: 7f ff ff be call 20078d0 <_Thread_Enable_dispatch> 20079dc: b0 10 20 0f mov 0xf, %i0 return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20079e0: 81 c7 e0 08 ret 20079e4: 81 e8 00 00 restore 02017340 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 2017340: 9d e3 bf 90 save %sp, -112, %sp 2017344: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 2017348: 80 a6 60 00 cmp %i1, 0 201734c: 02 80 00 32 be 2017414 2017350: 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 ) ) { 2017354: 80 a2 60 00 cmp %o1, 0 2017358: 12 80 00 0a bne 2017380 201735c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2017360: 03 00 80 e0 sethi %hi(0x2038000), %g1 2017364: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 ! 2038330 <_Thread_Dispatch_disable_level> 2017368: 84 00 a0 01 inc %g2 201736c: c4 20 63 30 st %g2, [ %g1 + 0x330 ] 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; 2017370: 03 00 80 e1 sethi %hi(0x2038400), %g1 2017374: f0 00 60 10 ld [ %g1 + 0x10 ], %i0 ! 2038410 <_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; 2017378: 10 80 00 18 b 20173d8 201737c: c0 27 bf f4 clr [ %fp + -12 ] 2017380: 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 ) { 2017384: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2017388: 18 80 00 0e bgu 20173c0 <== NOT EXECUTED 201738c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2017390: 83 32 60 1b srl %o1, 0x1b, %g1 <== NOT EXECUTED 2017394: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2017398: 12 80 00 0a bne 20173c0 <== NOT EXECUTED 201739c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20173a0: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 20173a4: 05 00 80 e0 sethi %hi(0x2038000), %g2 <== NOT EXECUTED 20173a8: 84 10 a2 90 or %g2, 0x290, %g2 ! 2038290 <_Objects_Information_table> <== NOT EXECUTED 20173ac: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 20173b0: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 20173b4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20173b8: 12 80 00 05 bne 20173cc <== NOT EXECUTED 20173bc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 20173c0: b0 10 20 00 clr %i0 <== NOT EXECUTED 20173c4: 10 80 00 05 b 20173d8 <== NOT EXECUTED 20173c8: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20173cc: 7f ff ca 62 call 2009d54 <_Objects_Get> <== NOT EXECUTED 20173d0: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 20173d4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 20173d8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20173dc: 80 a0 60 00 cmp %g1, 0 20173e0: 22 80 00 0f be,a 201741c 20173e4: c4 06 21 80 ld [ %i0 + 0x180 ], %g2 20173e8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20173ec: 08 80 00 0a bleu 2017414 <== NOT EXECUTED 20173f0: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 20173f4: 81 c7 e0 08 ret <== NOT EXECUTED 20173f8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 20173fc: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 2017400: 32 80 00 07 bne,a 201741c <== NOT EXECUTED 2017404: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED tvp->dtor = dtor; 2017408: f4 20 a0 10 st %i2, [ %g2 + 0x10 ] <== NOT EXECUTED _Thread_Enable_dispatch(); 201740c: 7f ff ff c0 call 201730c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017410: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017414: 81 c7 e0 08 ret <== NOT EXECUTED 2017418: 81 e8 00 00 restore <== NOT EXECUTED /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 201741c: 80 a0 a0 00 cmp %g2, 0 2017420: 32 bf ff f7 bne,a 20173fc 2017424: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 2017428: 11 00 80 e0 sethi %hi(0x2038000), %o0 201742c: 92 10 20 14 mov 0x14, %o1 2017430: 7f ff c7 ad call 20092e4 <_Heap_Allocate> 2017434: 90 12 23 7c or %o0, 0x37c, %o0 * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 2017438: 80 a2 20 00 cmp %o0, 0 201743c: 32 80 00 06 bne,a 2017454 2017440: c4 06 21 80 ld [ %i0 + 0x180 ], %g2 _Thread_Enable_dispatch(); 2017444: 7f ff ff b2 call 201730c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017448: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED 201744c: 81 c7 e0 08 ret <== NOT EXECUTED 2017450: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_NO_MEMORY; } new->gval = *ptr; 2017454: 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; 2017458: 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; 201745c: c2 22 20 08 st %g1, [ %o0 + 8 ] new->ptr = ptr; 2017460: f2 22 20 04 st %i1, [ %o0 + 4 ] new->dtor = dtor; 2017464: f4 22 20 10 st %i2, [ %o0 + 0x10 ] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 2017468: c4 22 00 00 st %g2, [ %o0 ] the_thread->task_variables = new; _Thread_Enable_dispatch(); 201746c: 7f ff ff a8 call 201730c <_Thread_Enable_dispatch> 2017470: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2017474: 81 c7 e0 08 ret 2017478: 81 e8 00 00 restore 020174b0 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 20174b0: 9d e3 bf 90 save %sp, -112, %sp 20174b4: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 20174b8: 80 a6 60 00 cmp %i1, 0 20174bc: 02 80 00 52 be 2017604 20174c0: 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 ) ) { 20174c4: 80 a2 60 00 cmp %o1, 0 20174c8: 12 80 00 0a bne 20174f0 20174cc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20174d0: 03 00 80 e0 sethi %hi(0x2038000), %g1 20174d4: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 ! 2038330 <_Thread_Dispatch_disable_level> 20174d8: 84 00 a0 01 inc %g2 20174dc: c4 20 63 30 st %g2, [ %g1 + 0x330 ] 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; 20174e0: 03 00 80 e1 sethi %hi(0x2038400), %g1 20174e4: d0 00 60 10 ld [ %g1 + 0x10 ], %o0 ! 2038410 <_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; 20174e8: 10 80 00 19 b 201754c 20174ec: c0 27 bf f4 clr [ %fp + -12 ] 20174f0: 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 ) { 20174f4: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 20174f8: 18 80 00 06 bgu 2017510 <== NOT EXECUTED 20174fc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2017500: 83 32 60 1b srl %o1, 0x1b, %g1 <== NOT EXECUTED 2017504: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2017508: 02 80 00 05 be 201751c <== NOT EXECUTED 201750c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 2017510: 90 10 20 00 clr %o0 <== NOT EXECUTED 2017514: 10 80 00 0e b 201754c <== NOT EXECUTED 2017518: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 201751c: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 2017520: 05 00 80 e0 sethi %hi(0x2038000), %g2 <== NOT EXECUTED 2017524: 84 10 a2 90 or %g2, 0x290, %g2 ! 2038290 <_Objects_Information_table> <== NOT EXECUTED 2017528: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 201752c: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 2017530: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017534: 12 80 00 04 bne 2017544 <== NOT EXECUTED 2017538: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 201753c: 10 80 00 04 b 201754c <== NOT EXECUTED 2017540: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2017544: 7f ff ca 04 call 2009d54 <_Objects_Get> <== NOT EXECUTED 2017548: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 201754c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2017550: 80 a0 60 00 cmp %g1, 0 2017554: 22 80 00 07 be,a 2017570 2017558: f0 02 21 80 ld [ %o0 + 0x180 ], %i0 201755c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2017560: 08 80 00 29 bleu 2017604 <== NOT EXECUTED 2017564: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2017568: 81 c7 e0 08 ret <== NOT EXECUTED 201756c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; 2017570: 10 80 00 28 b 2017610 2017574: 84 10 20 00 clr %g2 while (tvp) { if (tvp->ptr == ptr) { 2017578: 80 a0 40 19 cmp %g1, %i1 201757c: 32 80 00 24 bne,a 201760c 2017580: 84 10 00 18 mov %i0, %g2 <== NOT EXECUTED if (prev) 2017584: 80 a0 a0 00 cmp %g2, 0 2017588: 02 80 00 04 be 2017598 201758c: c2 06 00 00 ld [ %i0 ], %g1 prev->next = tvp->next; 2017590: 10 80 00 03 b 201759c <== NOT EXECUTED 2017594: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 2017598: c2 22 21 80 st %g1, [ %o0 + 0x180 ] if (_Thread_Is_executing(the_thread)) { 201759c: 03 00 80 e1 sethi %hi(0x2038400), %g1 20175a0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 ! 2038410 <_Thread_Executing> 20175a4: 80 a2 00 01 cmp %o0, %g1 20175a8: 12 80 00 0c bne 20175d8 20175ac: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 if (tvp->dtor) 20175b0: 80 a0 a0 00 cmp %g2, 0 20175b4: 22 80 00 06 be,a 20175cc 20175b8: c4 06 20 04 ld [ %i0 + 4 ], %g2 (*tvp->dtor)(*tvp->ptr); 20175bc: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 20175c0: 9f c0 80 00 call %g2 <== NOT EXECUTED 20175c4: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 20175c8: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED 20175cc: c2 06 20 08 ld [ %i0 + 8 ], %g1 20175d0: 10 80 00 07 b 20175ec 20175d4: c2 20 80 00 st %g1, [ %g2 ] } else { if (tvp->dtor) 20175d8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20175dc: 02 80 00 05 be 20175f0 <== NOT EXECUTED 20175e0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 20175e4: 9f c0 80 00 call %g2 <== NOT EXECUTED 20175e8: d0 06 20 0c ld [ %i0 + 0xc ], %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 20175ec: 92 10 00 18 mov %i0, %o1 20175f0: 11 00 80 e0 sethi %hi(0x2038000), %o0 20175f4: 7f ff c7 63 call 2009380 <_Heap_Free> 20175f8: 90 12 23 7c or %o0, 0x37c, %o0 ! 203837c <_Workspace_Area> } _Workspace_Free(tvp); _Thread_Enable_dispatch(); 20175fc: 7f ff ff a0 call 201747c <_Thread_Enable_dispatch> 2017600: b0 10 20 00 clr %i0 2017604: 81 c7 e0 08 ret 2017608: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 201760c: f0 06 00 00 ld [ %i0 ], %i0 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 2017610: 80 a6 20 00 cmp %i0, 0 2017614: 32 bf ff d9 bne,a 2017578 2017618: c2 06 20 04 ld [ %i0 + 4 ], %g1 return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 201761c: 7f ff ff 98 call 201747c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017620: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2017624: 81 c7 e0 08 ret <== NOT EXECUTED 2017628: 81 e8 00 00 restore <== NOT EXECUTED 02017660 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 2017660: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 2017664: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2017668: 02 80 00 3f be 2017764 <== NOT EXECUTED 201766c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 2017670: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 2017674: 02 80 00 3c be 2017764 <== NOT EXECUTED 2017678: 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 ) ) { 201767c: 12 80 00 0a bne 20176a4 <== NOT EXECUTED 2017680: 83 36 20 18 srl %i0, 0x18, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2017684: 03 00 80 e0 sethi %hi(0x2038000), %g1 <== NOT EXECUTED 2017688: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 ! 2038330 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 201768c: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2017690: c4 20 63 30 st %g2, [ %g1 + 0x330 ] <== 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; 2017694: 03 00 80 e1 sethi %hi(0x2038400), %g1 <== NOT EXECUTED 2017698: d0 00 60 10 ld [ %g1 + 0x10 ], %o0 ! 2038410 <_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; 201769c: 10 80 00 19 b 2017700 <== NOT EXECUTED 20176a0: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 20176a4: 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 ) { 20176a8: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 20176ac: 18 80 00 06 bgu 20176c4 <== NOT EXECUTED 20176b0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20176b4: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED 20176b8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20176bc: 02 80 00 05 be 20176d0 <== NOT EXECUTED 20176c0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 20176c4: 90 10 20 00 clr %o0 <== NOT EXECUTED 20176c8: 10 80 00 0e b 2017700 <== NOT EXECUTED 20176cc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20176d0: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 20176d4: 05 00 80 e0 sethi %hi(0x2038000), %g2 <== NOT EXECUTED 20176d8: 84 10 a2 90 or %g2, 0x290, %g2 ! 2038290 <_Objects_Information_table> <== NOT EXECUTED 20176dc: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 20176e0: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 20176e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20176e8: 12 80 00 04 bne 20176f8 <== NOT EXECUTED 20176ec: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 20176f0: 10 80 00 04 b 2017700 <== NOT EXECUTED 20176f4: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20176f8: 7f ff c9 97 call 2009d54 <_Objects_Get> <== NOT EXECUTED 20176fc: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 2017700: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2017704: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2017708: 22 80 00 10 be,a 2017748 <== NOT EXECUTED 201770c: d0 02 21 80 ld [ %o0 + 0x180 ], %o0 <== NOT EXECUTED 2017710: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2017714: 08 80 00 0b bleu 2017740 <== NOT EXECUTED 2017718: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 201771c: 81 c7 e0 08 ret <== NOT EXECUTED 2017720: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 2017724: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 2017728: 32 80 00 08 bne,a 2017748 <== NOT EXECUTED 201772c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 2017730: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); 2017734: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017738: 7f ff ff bd call 201762c <_Thread_Enable_dispatch> <== NOT EXECUTED 201773c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 2017740: 81 c7 e0 08 ret <== NOT EXECUTED 2017744: 81 e8 00 00 restore <== NOT EXECUTED /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 2017748: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201774c: 32 bf ff f6 bne,a 2017724 <== NOT EXECUTED 2017750: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 2017754: 7f ff ff b6 call 201762c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017758: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED 201775c: 81 c7 e0 08 ret <== NOT EXECUTED 2017760: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 2017764: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2017768: 81 c7 e0 08 ret <== NOT EXECUTED 201776c: 81 e8 00 00 restore <== NOT EXECUTED 02012238 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 2012238: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 201223c: 21 00 80 c4 sethi %hi(0x2031000), %l0 2012240: 92 10 00 18 mov %i0, %o1 2012244: 94 07 bf f4 add %fp, -12, %o2 2012248: 40 00 09 ec call 20149f8 <_Objects_Get> 201224c: 90 14 23 1c or %l0, 0x31c, %o0 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012250: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012254: 80 a0 60 00 cmp %g1, 0 2012258: 02 80 00 08 be 2012278 201225c: b0 10 00 08 mov %o0, %i0 2012260: 82 18 60 02 xor %g1, 2, %g1 2012264: 80 a0 00 01 cmp %g0, %g1 2012268: 82 60 20 00 subx %g0, 0, %g1 201226c: b0 08 60 15 and %g1, 0x15, %i0 2012270: 81 c7 e0 08 ret 2012274: 91 ee 20 04 restore %i0, 4, %o0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012278: a0 14 23 1c or %l0, 0x31c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 201227c: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012280: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 2012284: 05 00 00 3f sethi %hi(0xfc00), %g2 2012288: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 201228c: 82 08 40 02 and %g1, %g2, %g1 2012290: 80 a0 40 03 cmp %g1, %g3 2012294: 38 80 00 06 bgu,a 20122ac 2012298: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 201229c: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 20122a0: 83 28 60 02 sll %g1, 2, %g1 20122a4: 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; 20122a8: 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 ); 20122ac: 40 00 15 66 call 2017844 <_Watchdog_Remove> 20122b0: 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 ); 20122b4: 90 10 00 10 mov %l0, %o0 20122b8: 40 00 09 7a call 20148a0 <_Objects_Free> 20122bc: 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 ) 20122c0: 03 00 80 c3 sethi %hi(0x2030c00), %g1 20122c4: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 2030fb0 <_Thread_Dispatch_disable_level> 20122c8: b0 10 20 00 clr %i0 20122cc: 84 00 bf ff add %g2, -1, %g2 20122d0: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 20122d4: c2 00 63 b0 ld [ %g1 + 0x3b0 ], %g1 20122d8: 80 a0 60 00 cmp %g1, 0 20122dc: 12 80 00 04 bne 20122ec 20122e0: 01 00 00 00 nop _Thread_Dispatch(); 20122e4: 40 00 0e ca call 2015e0c <_Thread_Dispatch> 20122e8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20122ec: 81 c7 e0 08 ret 20122f0: 81 e8 00 00 restore 02012328 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 2012328: 9d e3 bf 90 save %sp, -112, %sp 201232c: a4 10 00 18 mov %i0, %l2 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 2012330: 80 a6 60 00 cmp %i1, 0 2012334: 02 80 00 21 be 20123b8 2012338: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( !routine ) 201233c: 80 a6 a0 00 cmp %i2, 0 2012340: 02 80 00 1e be 20123b8 2012344: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2012348: 11 00 80 c4 sethi %hi(0x2031000), %o0 201234c: 92 10 00 12 mov %l2, %o1 2012350: 90 12 23 1c or %o0, 0x31c, %o0 2012354: 40 00 09 a9 call 20149f8 <_Objects_Get> 2012358: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 201235c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012360: 80 a0 60 00 cmp %g1, 0 2012364: 02 80 00 08 be 2012384 2012368: a0 10 00 08 mov %o0, %l0 201236c: 82 18 60 02 xor %g1, 2, %g1 2012370: 80 a0 00 01 cmp %g0, %g1 2012374: 82 60 20 00 subx %g0, 0, %g1 2012378: b0 08 60 15 and %g1, 0x15, %i0 201237c: 81 c7 e0 08 ret 2012380: 91 ee 20 04 restore %i0, 4, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 2012384: a2 02 20 10 add %o0, 0x10, %l1 2012388: 40 00 15 2f call 2017844 <_Watchdog_Remove> 201238c: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 2012390: 7f ff e0 e5 call 200a724 2012394: 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 ) { 2012398: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 201239c: 80 a0 60 00 cmp %g1, 0 20123a0: 22 80 00 08 be,a 20123c0 20123a4: f4 24 20 2c st %i2, [ %l0 + 0x2c ] _ISR_Enable( level ); 20123a8: 7f ff e0 e3 call 200a734 <== NOT EXECUTED 20123ac: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 20123b0: 7f ff ff d1 call 20122f4 <_Thread_Enable_dispatch> <== NOT EXECUTED 20123b4: 01 00 00 00 nop <== NOT EXECUTED 20123b8: 81 c7 e0 08 ret 20123bc: 81 e8 00 00 restore 20123c0: e4 24 20 30 st %l2, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 20123c4: 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; 20123c8: c0 24 20 38 clr [ %l0 + 0x38 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20123cc: c0 24 20 18 clr [ %l0 + 0x18 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 20123d0: 7f ff e0 d9 call 200a734 20123d4: b0 10 20 00 clr %i0 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20123d8: 92 10 00 11 mov %l1, %o1 20123dc: 11 00 80 c4 sethi %hi(0x2031000), %o0 20123e0: 90 12 20 b0 or %o0, 0xb0, %o0 ! 20310b0 <_Watchdog_Ticks_chain> 20123e4: 40 00 14 c0 call 20176e4 <_Watchdog_Insert> 20123e8: f2 24 20 1c st %i1, [ %l0 + 0x1c ] _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 20123ec: 7f ff ff c2 call 20122f4 <_Thread_Enable_dispatch> 20123f0: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20123f4: 81 c7 e0 08 ret 20123f8: 81 e8 00 00 restore 02008090 : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 2008090: 9d e3 bf 90 save %sp, -112, %sp 2008094: 92 10 00 18 mov %i0, %o1 Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 2008098: 80 a6 60 00 cmp %i1, 0 200809c: 02 80 00 22 be 2008124 20080a0: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 20080a4: 11 00 80 74 sethi %hi(0x201d000), %o0 20080a8: 94 07 bf f4 add %fp, -12, %o2 20080ac: 40 00 07 3f call 2009da8 <_Objects_Get> 20080b0: 90 12 22 e0 or %o0, 0x2e0, %o0 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20080b4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20080b8: 80 a0 60 00 cmp %g1, 0 20080bc: 22 80 00 08 be,a 20080dc 20080c0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 20080c4: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 20080c8: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 20080cc: 82 60 20 00 subx %g0, 0, %g1 <== NOT EXECUTED 20080d0: b0 08 60 15 and %g1, 0x15, %i0 <== NOT EXECUTED 20080d4: 81 c7 e0 08 ret <== NOT EXECUTED 20080d8: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 20080dc: c4 02 20 38 ld [ %o0 + 0x38 ], %g2 the_info->initial = the_timer->Ticker.initial; 20080e0: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->start_time = the_timer->Ticker.start_time; 20080e4: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 20080e8: c4 26 40 00 st %g2, [ %i1 ] the_info->initial = the_timer->Ticker.initial; the_info->start_time = the_timer->Ticker.start_time; 20080ec: c2 26 60 08 st %g1, [ %i1 + 8 ] the_info->stop_time = the_timer->Ticker.stop_time; 20080f0: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 20080f4: 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 ) 20080f8: 05 00 80 75 sethi %hi(0x201d400), %g2 20080fc: c2 00 a0 c0 ld [ %g2 + 0xc0 ], %g1 ! 201d4c0 <_Thread_Dispatch_disable_level> 2008100: b0 10 20 00 clr %i0 2008104: 82 00 7f ff add %g1, -1, %g1 2008108: c2 20 a0 c0 st %g1, [ %g2 + 0xc0 ] 200810c: c2 00 a0 c0 ld [ %g2 + 0xc0 ], %g1 2008110: 80 a0 60 00 cmp %g1, 0 2008114: 12 80 00 04 bne 2008124 2008118: 01 00 00 00 nop _Thread_Dispatch(); 200811c: 40 00 0c 28 call 200b1bc <_Thread_Dispatch> 2008120: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2008124: 81 c7 e0 08 ret 2008128: 81 e8 00 00 restore 02012b18 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 2012b18: 9d e3 bf 90 save %sp, -112, %sp /* * Make sure the requested priority is valid. */ _priority = priority; if ( priority == RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 2012b1c: 92 10 20 00 clr %o1 2012b20: 80 a6 3f ff cmp %i0, -1 2012b24: 02 80 00 07 be 2012b40 2012b28: 94 10 00 19 mov %i1, %o2 _priority = 0; else if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) 2012b2c: 82 06 3f ff add %i0, -1, %g1 2012b30: 80 a0 60 fe cmp %g1, 0xfe 2012b34: 18 80 00 48 bgu 2012c54 2012b38: a0 10 20 13 mov 0x13, %l0 2012b3c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2012b40: 05 00 80 c3 sethi %hi(0x2030c00), %g2 2012b44: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 2030fb0 <_Thread_Dispatch_disable_level> 2012b48: 82 00 60 01 inc %g1 2012b4c: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] * Just to make sure the test versus create/start operation are atomic. */ _Thread_Disable_dispatch(); if ( _Timer_Server ) { 2012b50: 03 00 80 c4 sethi %hi(0x2031000), %g1 2012b54: c2 00 63 68 ld [ %g1 + 0x368 ], %g1 ! 2031368 <_Timer_Server> 2012b58: 80 a0 60 00 cmp %g1, 0 2012b5c: 02 80 00 06 be 2012b74 2012b60: 19 00 00 20 sethi %hi(0x8000), %o4 _Thread_Enable_dispatch(); 2012b64: 7f ff ff a0 call 20129e4 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012b68: a0 10 20 0e mov 0xe, %l0 <== NOT EXECUTED _Watchdog_Initialize( &_Timer_Server->Timer, _Thread_Delay_ended, id, NULL ); _Watchdog_Initialize( &_Timer_Seconds_timer, _Thread_Delay_ended, id, NULL ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 2012b6c: 81 c7 e0 08 ret <== NOT EXECUTED 2012b70: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 2012b74: 11 15 12 53 sethi %hi(0x54494c00), %o0 2012b78: 98 16 80 0c or %i2, %o4, %o4 2012b7c: 90 12 21 45 or %o0, 0x145, %o0 2012b80: 96 10 21 00 mov 0x100, %o3 2012b84: 7f ff fa 0f call 20113c0 2012b88: 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) { 2012b8c: a0 92 20 00 orcc %o0, 0, %l0 2012b90: 12 80 00 2f bne 2012c4c 2012b94: d0 07 bf f4 ld [ %fp + -12 ], %o0 _Thread_Enable_dispatch(); return status; } status = rtems_task_start( 2012b98: 13 00 80 4a sethi %hi(0x2012800), %o1 2012b9c: 94 10 20 00 clr %o2 2012ba0: 7f ff fc 62 call 2011d28 2012ba4: 92 12 62 18 or %o1, 0x218, %o1 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 2012ba8: a0 92 20 00 orcc %o0, 0, %l0 2012bac: 12 80 00 28 bne 2012c4c 2012bb0: 03 00 80 c3 sethi %hi(0x2030c00), %g1 * * NOTE: Setting the pointer to the Timer Server TCB to a value other than * NULL indicates that task-based timer support is initialized. */ _Timer_Server = (Thread_Control *)_Objects_Get_local_object( 2012bb4: 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 ) 2012bb8: 9a 10 62 60 or %g1, 0x260, %o5 2012bbc: c4 13 60 10 lduh [ %o5 + 0x10 ], %g2 2012bc0: 03 00 00 3f sethi %hi(0xfc00), %g1 2012bc4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2012bc8: 82 09 00 01 and %g4, %g1, %g1 2012bcc: 80 a0 40 02 cmp %g1, %g2 2012bd0: 18 80 00 05 bgu 2012be4 2012bd4: 86 10 20 00 clr %g3 return NULL; return information->local_table[ index ]; 2012bd8: c4 03 60 20 ld [ %o5 + 0x20 ], %g2 2012bdc: 83 28 60 02 sll %g1, 2, %g1 2012be0: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2012be4: 03 00 80 c4 sethi %hi(0x2031000), %g1 2012be8: c6 20 63 68 st %g3, [ %g1 + 0x368 ] ! 2031368 <_Timer_Server> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2012bec: 03 00 80 c3 sethi %hi(0x2030c00), %g1 2012bf0: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 2030eb0 <_Timer_Ticks_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2012bf4: c2 20 7f fc st %g1, [ %g1 + -4 ] 2012bf8: 82 00 7f fc add %g1, -4, %g1 ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2012bfc: c0 20 e0 6c clr [ %g3 + 0x6c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012c00: c0 20 e0 50 clr [ %g3 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; 2012c04: c8 20 e0 68 st %g4, [ %g3 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2012c08: 05 00 80 57 sethi %hi(0x2015c00), %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2012c0c: c2 20 60 08 st %g1, [ %g1 + 8 ] 2012c10: 84 10 a1 50 or %g2, 0x150, %g2 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2012c14: c0 20 60 04 clr [ %g1 + 4 ] 2012c18: c4 20 e0 64 st %g2, [ %g3 + 0x64 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2012c1c: 03 00 80 c3 sethi %hi(0x2030c00), %g1 2012c20: 82 10 62 c4 or %g1, 0x2c4, %g1 ! 2030ec4 <_Timer_Seconds_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2012c24: c2 20 7f fc st %g1, [ %g1 + -4 ] 2012c28: 82 00 7f fc add %g1, -4, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2012c2c: c2 20 60 08 st %g1, [ %g1 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2012c30: c0 20 60 04 clr [ %g1 + 4 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012c34: 03 00 80 c3 sethi %hi(0x2030c00), %g1 2012c38: 82 10 62 cc or %g1, 0x2cc, %g1 ! 2030ecc <_Timer_Seconds_timer> the_watchdog->routine = routine; 2012c3c: c4 20 60 1c st %g2, [ %g1 + 0x1c ] the_watchdog->id = id; 2012c40: c8 20 60 20 st %g4, [ %g1 + 0x20 ] the_watchdog->user_data = user_data; 2012c44: c0 20 60 24 clr [ %g1 + 0x24 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012c48: c0 20 60 08 clr [ %g1 + 8 ] */ _Watchdog_Initialize( &_Timer_Server->Timer, _Thread_Delay_ended, id, NULL ); _Watchdog_Initialize( &_Timer_Seconds_timer, _Thread_Delay_ended, id, NULL ); _Thread_Enable_dispatch(); 2012c4c: 7f ff ff 66 call 20129e4 <_Thread_Enable_dispatch> 2012c50: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } 2012c54: b0 10 00 10 mov %l0, %i0 2012c58: 81 c7 e0 08 ret 2012c5c: 81 e8 00 00 restore 020126a8 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 20126a8: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 20126ac: 25 00 80 c4 sethi %hi(0x2031000), %l2 20126b0: c2 04 a3 68 ld [ %l2 + 0x368 ], %g1 ! 2031368 <_Timer_Server> Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 20126b4: a6 10 00 18 mov %i0, %l3 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 20126b8: 80 a0 60 00 cmp %g1, 0 20126bc: 02 80 00 24 be 201274c 20126c0: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; if ( !routine ) 20126c4: 80 a6 a0 00 cmp %i2, 0 20126c8: 02 80 00 21 be 201274c 20126cc: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 20126d0: 80 a6 60 00 cmp %i1, 0 20126d4: 02 80 00 1e be 201274c 20126d8: b0 10 20 0a mov 0xa, %i0 20126dc: 11 00 80 c4 sethi %hi(0x2031000), %o0 20126e0: 92 10 00 13 mov %l3, %o1 20126e4: 90 12 23 1c or %o0, 0x31c, %o0 20126e8: 40 00 08 c4 call 20149f8 <_Objects_Get> 20126ec: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20126f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20126f4: 80 a0 60 00 cmp %g1, 0 20126f8: 02 80 00 08 be 2012718 20126fc: a0 10 00 08 mov %o0, %l0 2012700: 82 18 60 02 xor %g1, 2, %g1 2012704: 80 a0 00 01 cmp %g0, %g1 2012708: 82 60 20 00 subx %g0, 0, %g1 201270c: b0 08 60 15 and %g1, 0x15, %i0 2012710: 81 c7 e0 08 ret 2012714: 91 ee 20 04 restore %i0, 4, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 2012718: a2 02 20 10 add %o0, 0x10, %l1 201271c: 40 00 14 4a call 2017844 <_Watchdog_Remove> 2012720: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 2012724: 7f ff e0 00 call 200a724 2012728: 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 ) { 201272c: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 2012730: 80 a0 60 00 cmp %g1, 0 2012734: 02 80 00 08 be 2012754 2012738: 82 10 20 01 mov 1, %g1 _ISR_Enable( level ); 201273c: 7f ff df fe call 200a734 <== NOT EXECUTED 2012740: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 2012744: 7f ff ff cc call 2012674 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012748: 01 00 00 00 nop <== NOT EXECUTED 201274c: 81 c7 e0 08 ret 2012750: 81 e8 00 00 restore * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL_ON_TASK; _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 2012754: f2 24 20 1c st %i1, [ %l0 + 0x1c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2012758: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 201275c: e6 24 20 30 st %l3, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 2012760: f6 24 20 34 st %i3, [ %l0 + 0x34 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012764: 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; 2012768: 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 ); 201276c: 7f ff df f2 call 200a734 2012770: 21 00 80 c3 sethi %hi(0x2030c00), %l0 _Timer_Server_stop_ticks_timer(); 2012774: d0 04 a3 68 ld [ %l2 + 0x368 ], %o0 2012778: 40 00 14 33 call 2017844 <_Watchdog_Remove> 201277c: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_process_ticks_chain(); 2012780: 40 00 00 87 call 201299c <_Timer_Server_process_ticks_chain> 2012784: 01 00 00 00 nop _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 2012788: 90 14 22 ac or %l0, 0x2ac, %o0 201278c: 40 00 13 d6 call 20176e4 <_Watchdog_Insert> 2012790: 92 10 00 11 mov %l1, %o1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2012794: c4 04 22 ac ld [ %l0 + 0x2ac ], %g2 2012798: a0 14 22 ac or %l0, 0x2ac, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 201279c: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 20127a0: 80 a0 80 10 cmp %g2, %l0 20127a4: 02 80 00 08 be 20127c4 20127a8: c2 04 a3 68 ld [ %l2 + 0x368 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20127ac: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20127b0: 11 00 80 c4 sethi %hi(0x2031000), %o0 20127b4: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20127b8: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20127bc: 40 00 13 ca call 20176e4 <_Watchdog_Insert> 20127c0: 90 12 20 b0 or %o0, 0xb0, %o0 _Thread_Enable_dispatch(); 20127c4: 7f ff ff ac call 2012674 <_Thread_Enable_dispatch> 20127c8: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20127cc: 81 c7 e0 08 ret 20127d0: 81 e8 00 00 restore