40007d34 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 40007d34: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 40007d38: 03 10 00 6c sethi %hi(0x4001b000), %g1 40007d3c: e0 00 60 20 ld [ %g1 + 0x20 ], %l0 ! 4001b020 <_API_extensions_List> 40007d40: 82 10 60 20 or %g1, 0x20, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40007d44: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 40007d48: 80 a4 00 11 cmp %l0, %l1 40007d4c: 02 80 00 0c be 40007d7c <_API_extensions_Run_postdriver+0x48> 40007d50: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 40007d54: c2 04 20 0c ld [ %l0 + 0xc ], %g1 40007d58: 80 a0 60 00 cmp %g1, 0 40007d5c: 22 80 00 05 be,a 40007d70 <_API_extensions_Run_postdriver+0x3c> 40007d60: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postdriver_hook)(); 40007d64: 9f c0 40 00 call %g1 40007d68: 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 ) { 40007d6c: 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 ) ; 40007d70: 80 a4 00 11 cmp %l0, %l1 40007d74: 32 bf ff f9 bne,a 40007d58 <_API_extensions_Run_postdriver+0x24> 40007d78: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED 40007d7c: 81 c7 e0 08 ret 40007d80: 81 e8 00 00 restore 40007df0 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 40007df0: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 40007df4: 03 10 00 6c sethi %hi(0x4001b000), %g1 40007df8: e0 00 60 20 ld [ %g1 + 0x20 ], %l0 ! 4001b020 <_API_extensions_List> 40007dfc: 82 10 60 20 or %g1, 0x20, %g1 40007e00: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 40007e04: 80 a4 00 11 cmp %l0, %l1 40007e08: 02 80 00 0c be 40007e38 <_API_extensions_Run_postswitch+0x48> 40007e0c: 25 10 00 6b sethi %hi(0x4001ac00), %l2 the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 40007e10: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 40007e14: 80 a0 60 00 cmp %g1, 0 40007e18: 22 80 00 05 be,a 40007e2c <_API_extensions_Run_postswitch+0x3c> 40007e1c: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 40007e20: 9f c0 40 00 call %g1 40007e24: d0 04 a2 6c ld [ %l2 + 0x26c ], %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 ) { 40007e28: 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 ) ; 40007e2c: 80 a4 00 11 cmp %l0, %l1 40007e30: 32 bf ff f9 bne,a 40007e14 <_API_extensions_Run_postswitch+0x24> 40007e34: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 40007e38: 81 c7 e0 08 ret 40007e3c: 81 e8 00 00 restore 40007da0 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 40007da0: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 40007da4: 03 10 00 6c sethi %hi(0x4001b000), %g1 40007da8: e0 00 60 20 ld [ %g1 + 0x20 ], %l0 ! 4001b020 <_API_extensions_List> 40007dac: 82 10 60 20 or %g1, 0x20, %g1 40007db0: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 40007db4: 80 a4 00 11 cmp %l0, %l1 40007db8: 02 80 00 0c be 40007de8 <_API_extensions_Run_predriver+0x48> 40007dbc: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 40007dc0: c2 04 20 08 ld [ %l0 + 8 ], %g1 40007dc4: 80 a0 60 00 cmp %g1, 0 40007dc8: 22 80 00 05 be,a 40007ddc <_API_extensions_Run_predriver+0x3c> 40007dcc: e0 04 00 00 ld [ %l0 ], %l0 (*the_extension->predriver_hook)(); 40007dd0: 9f c0 40 00 call %g1 <== NOT EXECUTED 40007dd4: 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 ) { 40007dd8: 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 ) ; 40007ddc: 80 a4 00 11 cmp %l0, %l1 40007de0: 32 bf ff f9 bne,a 40007dc4 <_API_extensions_Run_predriver+0x24> 40007de4: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 40007de8: 81 c7 e0 08 ret 40007dec: 81 e8 00 00 restore 4001509c <_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 ) { 4001509c: 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 ) { 400150a0: 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 ) { 400150a4: 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 ) { 400150a8: 80 a0 40 1a cmp %g1, %i2 400150ac: 0a 80 00 17 bcs 40015108 <_CORE_message_queue_Broadcast+0x6c> 400150b0: 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 ) { 400150b4: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1 400150b8: 80 a0 60 00 cmp %g1, 0 400150bc: 02 80 00 0a be 400150e4 <_CORE_message_queue_Broadcast+0x48> 400150c0: a2 10 20 00 clr %l1 *count = 0; 400150c4: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED 400150c8: 81 c7 e0 08 ret <== NOT EXECUTED 400150cc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 400150d0: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 400150d4: 40 00 21 ab call 4001d780 400150d8: a2 04 60 01 inc %l1 buffer, waitp->return_argument, size ); *(uint32_t *)the_thread->Wait.return_argument_1 = size; 400150dc: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 400150e0: 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))) { 400150e4: 40 00 0b 94 call 40017f34 <_Thread_queue_Dequeue> 400150e8: 90 10 00 12 mov %l2, %o0 400150ec: 92 10 00 19 mov %i1, %o1 400150f0: a0 10 00 08 mov %o0, %l0 400150f4: 80 a2 20 00 cmp %o0, 0 400150f8: 12 bf ff f6 bne 400150d0 <_CORE_message_queue_Broadcast+0x34> 400150fc: 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; 40015100: e2 27 40 00 st %l1, [ %i5 ] 40015104: b0 10 20 00 clr %i0 return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 40015108: 81 c7 e0 08 ret 4001510c: 81 e8 00 00 restore 400151d0 <_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 ) { 400151d0: 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; 400151d4: 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; 400151d8: 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; 400151dc: 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; 400151e0: c0 26 20 60 clr [ %i0 + 0x60 ] the_message_queue->notify_argument = the_argument; 400151e4: 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)) { 400151e8: 80 8e e0 03 btst 3, %i3 400151ec: 02 80 00 07 be 40015208 <_CORE_message_queue_Initialize+0x38> 400151f0: a0 10 00 1b mov %i3, %l0 allocated_message_size += sizeof(uint32_t); 400151f4: 82 06 e0 04 add %i3, 4, %g1 allocated_message_size &= ~(sizeof(uint32_t) - 1); 400151f8: a0 08 7f fc and %g1, -4, %l0 } if (allocated_message_size < maximum_message_size) 400151fc: 80 a6 c0 10 cmp %i3, %l0 40015200: 18 80 00 09 bgu 40015224 <_CORE_message_queue_Initialize+0x54> 40015204: 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 * 40015208: b6 04 20 14 add %l0, 0x14, %i3 4001520c: 92 10 00 1a mov %i2, %o1 40015210: 40 00 42 31 call 40025ad4 <.umul> 40015214: 90 10 00 1b mov %i3, %o0 (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 40015218: 80 a2 00 10 cmp %o0, %l0 4001521c: 1a 80 00 04 bcc 4001522c <_CORE_message_queue_Initialize+0x5c> 40015220: 92 10 00 08 mov %o0, %o1 STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return TRUE; } 40015224: 81 c7 e0 08 ret <== NOT EXECUTED 40015228: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 4001522c: 11 10 00 d1 sethi %hi(0x40034400), %o0 40015230: 40 00 02 20 call 40015ab0 <_Heap_Allocate> 40015234: 90 12 23 ac or %o0, 0x3ac, %o0 ! 400347ac <_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) 40015238: 80 a2 20 00 cmp %o0, 0 4001523c: 02 bf ff fa be 40015224 <_CORE_message_queue_Initialize+0x54> 40015240: d0 26 20 5c st %o0, [ %i0 + 0x5c ] /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 40015244: 92 10 00 08 mov %o0, %o1 40015248: 94 10 00 1a mov %i2, %o2 4001524c: 90 06 20 68 add %i0, 0x68, %o0 40015250: 7f ff ff 7b call 4001503c <_Chain_Initialize> 40015254: 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( 40015258: c2 06 40 00 ld [ %i1 ], %g1 4001525c: 84 06 20 50 add %i0, 0x50, %g2 40015260: 82 18 60 01 xor %g1, 1, %g1 40015264: 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); 40015268: 82 06 20 54 add %i0, 0x54, %g1 the_chain->permanent_null = NULL; 4001526c: c0 26 20 54 clr [ %i0 + 0x54 ] 40015270: 90 10 00 18 mov %i0, %o0 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40015274: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40015278: c4 26 20 58 st %g2, [ %i0 + 0x58 ] 4001527c: 92 60 3f ff subx %g0, -1, %o1 40015280: 94 10 20 80 mov 0x80, %o2 40015284: 96 10 20 06 mov 6, %o3 40015288: 40 00 0c a7 call 40018524 <_Thread_queue_Initialize> 4001528c: b0 10 20 01 mov 1, %i0 40015290: 81 c7 e0 08 ret 40015294: 81 e8 00 00 restore 4001a3e8 <_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 ) { 4001a3e8: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; boolean notify = FALSE; the_message->priority = submit_type; switch ( submit_type ) { 4001a3ec: 03 20 00 00 sethi %hi(0x80000000), %g1 4001a3f0: 80 a6 80 01 cmp %i2, %g1 4001a3f4: 02 80 00 40 be 4001a4f4 <_CORE_message_queue_Insert_message+0x10c> 4001a3f8: f4 26 60 08 st %i2, [ %i1 + 8 ] 4001a3fc: 82 00 7c 00 add %g1, -1024, %g1 4001a400: 82 10 63 ff or %g1, 0x3ff, %g1 4001a404: 80 a6 80 01 cmp %i2, %g1 4001a408: 02 80 00 29 be 4001a4ac <_CORE_message_queue_Insert_message+0xc4> 4001a40c: 84 06 20 54 add %i0, 0x54, %g2 CORE_message_queue_Buffer_control *this_message; Chain_Node *the_node; Chain_Control *the_header; the_header = &the_message_queue->Pending_messages; the_node = the_header->first; 4001a410: e0 06 20 50 ld [ %i0 + 0x50 ], %l0 <== NOT EXECUTED while ( !_Chain_Is_tail( the_header, the_node ) ) { 4001a414: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 4001a418: 32 80 00 21 bne,a 4001a49c <_CORE_message_queue_Insert_message+0xb4> <== NOT EXECUTED 4001a41c: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 4001a420: 7f ff a0 f4 call 400027f0 <== NOT EXECUTED 4001a424: 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 ); 4001a428: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED } break; } _ISR_Disable( level ); if ( the_message_queue->number_of_pending_messages++ == 0 ) 4001a42c: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 4001a430: c6 00 40 00 ld [ %g1 ], %g3 <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 4001a434: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; 4001a438: f2 20 40 00 st %i1, [ %g1 ] <== NOT EXECUTED 4001a43c: 84 00 a0 01 inc %g2 <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 4001a440: f2 20 e0 04 st %i1, [ %g3 + 4 ] <== NOT EXECUTED 4001a444: 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; 4001a448: c6 26 40 00 st %g3, [ %i1 ] <== NOT EXECUTED 4001a44c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 4001a450: c4 26 20 48 st %g2, [ %i0 + 0x48 ] <== NOT EXECUTED 4001a454: a0 60 3f ff subx %g0, -1, %l0 <== NOT EXECUTED notify = TRUE; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); _ISR_Enable( level ); 4001a458: 7f ff a0 ea call 40002800 <== NOT EXECUTED 4001a45c: 01 00 00 00 nop <== NOT EXECUTED * According to POSIX, does this happen before or after the message * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) 4001a460: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 4001a464: 02 80 00 08 be 4001a484 <_CORE_message_queue_Insert_message+0x9c> 4001a468: 01 00 00 00 nop 4001a46c: c2 06 20 60 ld [ %i0 + 0x60 ], %g1 4001a470: 80 a0 60 00 cmp %g1, 0 4001a474: 02 80 00 04 be 4001a484 <_CORE_message_queue_Insert_message+0x9c> 4001a478: 01 00 00 00 nop (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 4001a47c: 9f c0 40 00 call %g1 <== NOT EXECUTED 4001a480: d0 06 20 64 ld [ %i0 + 0x64 ], %o0 <== NOT EXECUTED 4001a484: 81 c7 e0 08 ret 4001a488: 81 e8 00 00 restore Chain_Node *the_node; Chain_Control *the_header; the_header = &the_message_queue->Pending_messages; the_node = the_header->first; while ( !_Chain_Is_tail( the_header, the_node ) ) { 4001a48c: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 4001a490: 02 bf ff e4 be 4001a420 <_CORE_message_queue_Insert_message+0x38> <== NOT EXECUTED 4001a494: 01 00 00 00 nop <== NOT EXECUTED this_message = (CORE_message_queue_Buffer_control *) the_node; if ( this_message->priority <= the_message->priority ) { 4001a498: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 4001a49c: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED 4001a4a0: 36 bf ff fb bge,a 4001a48c <_CORE_message_queue_Insert_message+0xa4> <== NOT EXECUTED 4001a4a4: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED 4001a4a8: 30 bf ff de b,a 4001a420 <_CORE_message_queue_Insert_message+0x38> <== NOT EXECUTED the_message->priority = submit_type; switch ( submit_type ) { case CORE_MESSAGE_QUEUE_SEND_REQUEST: _ISR_Disable( level ); 4001a4ac: 7f ff a0 d1 call 400027f0 4001a4b0: 01 00 00 00 nop if ( the_message_queue->number_of_pending_messages++ == 0 ) 4001a4b4: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4001a4b8: 82 06 20 54 add %i0, 0x54, %g1 4001a4bc: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 4001a4c0: c6 06 20 58 ld [ %i0 + 0x58 ], %g3 the_chain->last = the_node; 4001a4c4: f2 26 20 58 st %i1, [ %i0 + 0x58 ] 4001a4c8: 84 00 a0 01 inc %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 4001a4cc: c6 26 60 04 st %g3, [ %i1 + 4 ] 4001a4d0: 82 18 a0 01 xor %g2, 1, %g1 Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 4001a4d4: f2 20 c0 00 st %i1, [ %g3 ] 4001a4d8: 80 a0 00 01 cmp %g0, %g1 4001a4dc: c4 26 20 48 st %g2, [ %i0 + 0x48 ] 4001a4e0: a0 60 3f ff subx %g0, -1, %l0 notify = TRUE; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 4001a4e4: 7f ff a0 c7 call 40002800 4001a4e8: 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 ) 4001a4ec: 10 bf ff de b 4001a464 <_CORE_message_queue_Insert_message+0x7c> 4001a4f0: 80 a4 20 00 cmp %l0, 0 notify = TRUE; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); break; case CORE_MESSAGE_QUEUE_URGENT_REQUEST: _ISR_Disable( level ); 4001a4f4: 7f ff a0 bf call 400027f0 4001a4f8: 01 00 00 00 nop ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 4001a4fc: c6 06 20 50 ld [ %i0 + 0x50 ], %g3 if ( the_message_queue->number_of_pending_messages++ == 0 ) 4001a500: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 4001a504: 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; 4001a508: f2 26 20 50 st %i1, [ %i0 + 0x50 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 4001a50c: c2 26 60 04 st %g1, [ %i1 + 4 ] 4001a510: 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; 4001a514: f2 20 e0 04 st %i1, [ %g3 + 4 ] 4001a518: 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; 4001a51c: c6 26 40 00 st %g3, [ %i1 ] 4001a520: 80 a0 00 01 cmp %g0, %g1 4001a524: c4 26 20 48 st %g2, [ %i0 + 0x48 ] 4001a528: a0 60 3f ff subx %g0, -1, %l0 notify = TRUE; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 4001a52c: 7f ff a0 b5 call 40002800 4001a530: 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 ) 4001a534: 10 bf ff cc b 4001a464 <_CORE_message_queue_Insert_message+0x7c> 4001a538: 80 a4 20 00 cmp %l0, 0 4001742c <_CORE_message_queue_Seize>: void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 4001742c: 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; 40017430: 25 10 00 b1 sethi %hi(0x4002c400), %l2 40017434: e2 04 a0 ec ld [ %l2 + 0xec ], %l1 ! 4002c4ec <_Thread_Executing> void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 40017438: 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 ); 4001743c: 7f ff ac ed call 400027f0 40017440: c0 24 60 34 clr [ %l1 + 0x34 ] 40017444: 88 10 00 08 mov %o0, %g4 if ( the_message_queue->number_of_pending_messages != 0 ) { 40017448: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 4001744c: 80 a0 60 00 cmp %g1, 0 40017450: 02 80 00 23 be 400174dc <_CORE_message_queue_Seize+0xb0> 40017454: 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)); 40017458: c6 06 20 50 ld [ %i0 + 0x50 ], %g3 the_message_queue->number_of_pending_messages -= 1; 4001745c: 82 00 7f ff add %g1, -1, %g1 40017460: 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)) 40017464: 84 06 20 54 add %i0, 0x54, %g2 40017468: 80 a0 c0 02 cmp %g3, %g2 4001746c: 12 80 00 24 bne 400174fc <_CORE_message_queue_Seize+0xd0> 40017470: b2 10 20 00 clr %i1 the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); 40017474: 7f ff ac e3 call 40002800 40017478: 90 10 00 04 mov %g4, %o0 *size = the_message->Contents.size; 4001747c: d4 06 60 0c ld [ %i1 + 0xc ], %o2 _Thread_Executing->Wait.count = the_message->priority; 40017480: c4 04 a0 ec ld [ %l2 + 0xec ], %g2 the_message_queue->number_of_pending_messages -= 1; the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); *size = the_message->Contents.size; 40017484: d4 26 c0 00 st %o2, [ %i3 ] _Thread_Executing->Wait.count = the_message->priority; 40017488: c2 06 60 08 ld [ %i1 + 8 ], %g1 4001748c: a2 06 60 10 add %i1, 0x10, %l1 40017490: c2 20 a0 24 st %g1, [ %g2 + 0x24 ] const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 40017494: 92 10 00 11 mov %l1, %o1 40017498: 40 00 13 00 call 4001c098 4001749c: 90 10 00 1a mov %i2, %o0 * * NOTE: If we note that the queue was not full before this receive, * then we can avoid this dequeue. */ the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 400174a0: 7f ff e9 3e call 40011998 <_Thread_queue_Dequeue> 400174a4: 90 10 00 10 mov %l0, %o0 if ( !the_thread ) { 400174a8: 80 a2 20 00 cmp %o0, 0 400174ac: 02 80 00 24 be 4001753c <_CORE_message_queue_Seize+0x110> 400174b0: 01 00 00 00 nop * puts the messages in the message queue on behalf of the * waiting task. */ the_message->priority = the_thread->Wait.count; the_message->Contents.size = (uint32_t)the_thread->Wait.option; 400174b4: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== NOT EXECUTED * There was a thread waiting to send a message. This code * puts the messages in the message queue on behalf of the * waiting task. */ the_message->priority = the_thread->Wait.count; 400174b8: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED 400174bc: d2 02 20 28 ld [ %o0 + 0x28 ], %o1 <== NOT EXECUTED the_message->Contents.size = (uint32_t)the_thread->Wait.option; 400174c0: 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; 400174c4: c2 26 60 08 st %g1, [ %i1 + 8 ] <== NOT EXECUTED 400174c8: 40 00 12 f4 call 4001c098 <== NOT EXECUTED 400174cc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED the_thread->Wait.return_argument, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 400174d0: f4 06 60 08 ld [ %i1 + 8 ], %i2 <== NOT EXECUTED 400174d4: 40 00 0b c5 call 4001a3e8 <_CORE_message_queue_Insert_message> <== NOT EXECUTED 400174d8: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 400174dc: 12 80 00 0e bne 40017514 <_CORE_message_queue_Seize+0xe8> 400174e0: 82 10 20 01 mov 1, %g1 _ISR_Enable( level ); 400174e4: 7f ff ac c7 call 40002800 400174e8: 01 00 00 00 nop executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 400174ec: 82 10 20 04 mov 4, %g1 ! 4 400174f0: 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 ); } 400174f4: 81 c7 e0 08 ret 400174f8: 81 e8 00 00 restore { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 400174fc: c4 00 c0 00 ld [ %g3 ], %g2 the_chain->first = new_first; new_first->previous = _Chain_Head(the_chain); 40017500: 82 06 20 50 add %i0, 0x50, %g1 Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; 40017504: c4 26 20 50 st %g2, [ %i0 + 0x50 ] new_first->previous = _Chain_Head(the_chain); 40017508: b2 10 00 03 mov %g3, %i1 4001750c: 10 bf ff da b 40017474 <_CORE_message_queue_Seize+0x48> 40017510: c2 20 a0 04 st %g1, [ %g2 + 4 ] _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; executing->Wait.id = id; executing->Wait.return_argument = buffer; executing->Wait.return_argument_1 = (void *)size; 40017514: 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; 40017518: f0 24 60 44 st %i0, [ %l1 + 0x44 ] executing->Wait.id = id; 4001751c: f2 24 60 20 st %i1, [ %l1 + 0x20 ] executing->Wait.return_argument = buffer; 40017520: 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; 40017524: 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 ); 40017528: 7f ff ac b6 call 40002800 4001752c: 35 10 00 48 sethi %hi(0x40012000), %i2 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 40017530: b2 10 00 1d mov %i5, %i1 40017534: 7f ff e9 87 call 40011b50 <_Thread_queue_Enqueue_with_handler> 40017538: 95 ee a0 90 restore %i2, 0x90, %o2 RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer ( CORE_message_queue_Control *the_message_queue, CORE_message_queue_Buffer_control *the_message ) { _Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node ); 4001753c: 7f ff de d6 call 4000f094 <_Chain_Append> 40017540: 91 ec 20 68 restore %l0, 0x68, %o0 40017544: 01 00 00 00 nop 40017548 <_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 ) { 40017548: 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 ) { 4001754c: 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 ) { 40017550: 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 ) { 40017554: 80 a0 40 1a cmp %g1, %i2 40017558: 0a 80 00 22 bcs 400175e0 <_CORE_message_queue_Submit+0x98> 4001755c: 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 ) { 40017560: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 40017564: 80 a0 a0 00 cmp %g2, 0 40017568: 02 80 00 22 be 400175f0 <_CORE_message_queue_Submit+0xa8> 4001756c: 01 00 00 00 nop /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 40017570: c2 04 60 44 ld [ %l1 + 0x44 ], %g1 40017574: 80 a0 40 02 cmp %g1, %g2 40017578: 18 80 00 2b bgu 40017624 <_CORE_message_queue_Submit+0xdc> 4001757c: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { 40017580: 80 a0 60 00 cmp %g1, 0 40017584: 02 80 00 17 be 400175e0 <_CORE_message_queue_Submit+0x98> 40017588: 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() ) { 4001758c: 03 10 00 b1 sethi %hi(0x4002c400), %g1 <== NOT EXECUTED 40017590: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2 ! 4002c4d4 <_ISR_Nest_level> <== NOT EXECUTED 40017594: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40017598: 12 80 00 14 bne 400175e8 <_CORE_message_queue_Submit+0xa0> <== NOT EXECUTED 4001759c: 03 10 00 b1 sethi %hi(0x4002c400), %g1 <== NOT EXECUTED */ { Thread_Control *executing = _Thread_Executing; _ISR_Disable( level ); 400175a0: 7f ff ac 94 call 400027f0 <== NOT EXECUTED 400175a4: e0 00 60 ec ld [ %g1 + 0xec ], %l0 ! 4002c4ec <_Thread_Executing> <== NOT EXECUTED 400175a8: 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; 400175ac: 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; 400175b0: f6 24 20 20 st %i3, [ %l0 + 0x20 ] <== NOT EXECUTED executing->Wait.return_argument = buffer; 400175b4: f2 24 20 28 st %i1, [ %l0 + 0x28 ] <== NOT EXECUTED executing->Wait.option = size; 400175b8: 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; 400175bc: e2 24 20 44 st %l1, [ %l0 + 0x44 ] <== NOT EXECUTED 400175c0: 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 ); 400175c4: 7f ff ac 8f call 40002800 <== NOT EXECUTED 400175c8: b0 10 20 07 mov 7, %i0 <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 400175cc: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 <== NOT EXECUTED 400175d0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400175d4: 15 10 00 48 sethi %hi(0x40012000), %o2 <== NOT EXECUTED 400175d8: 7f ff e9 5e call 40011b50 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 400175dc: 94 12 a0 90 or %o2, 0x90, %o2 ! 40012090 <_Thread_queue_Timeout> <== NOT EXECUTED 400175e0: 81 c7 e0 08 ret 400175e4: 81 e8 00 00 restore } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 400175e8: 81 c7 e0 08 ret <== NOT EXECUTED 400175ec: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 400175f0: 7f ff e8 ea call 40011998 <_Thread_queue_Dequeue> 400175f4: 90 10 00 11 mov %l1, %o0 if ( the_thread ) { 400175f8: a0 92 20 00 orcc %o0, 0, %l0 400175fc: 02 80 00 1b be 40017668 <_CORE_message_queue_Submit+0x120> 40017600: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 40017604: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 40017608: 40 00 12 a4 call 4001c098 4001760c: 94 10 00 1a mov %i2, %o2 _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument, size ); *(size_t *)the_thread->Wait.return_argument_1 = size; 40017610: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 the_thread->Wait.count = submit_type; 40017614: 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; 40017618: f4 20 40 00 st %i2, [ %g1 ] the_thread->Wait.count = submit_type; 4001761c: 81 c7 e0 08 ret 40017620: 91 e8 20 00 restore %g0, 0, %o0 RTEMS_INLINE_ROUTINE CORE_message_queue_Buffer_control * _CORE_message_queue_Allocate_message_buffer ( CORE_message_queue_Control *the_message_queue ) { return (CORE_message_queue_Buffer_control *) 40017624: 7f ff de a8 call 4000f0c4 <_Chain_Get> 40017628: 90 04 60 68 add %l1, 0x68, %o0 /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 4001762c: a0 92 20 00 orcc %o0, 0, %l0 40017630: 02 bf ff ee be 400175e8 <_CORE_message_queue_Submit+0xa0> 40017634: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 40017638: 94 10 00 1a mov %i2, %o2 4001763c: 40 00 12 97 call 4001c098 40017640: 90 04 20 10 add %l0, 0x10, %o0 size ); the_message->Contents.size = size; the_message->priority = submit_type; _CORE_message_queue_Insert_message( 40017644: 90 10 00 11 mov %l1, %o0 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 40017648: f4 24 20 0c st %i2, [ %l0 + 0xc ] the_message->priority = submit_type; 4001764c: fa 24 20 08 st %i5, [ %l0 + 8 ] _CORE_message_queue_Insert_message( 40017650: 92 10 00 10 mov %l0, %o1 40017654: 94 10 00 1d mov %i5, %o2 40017658: 40 00 0b 64 call 4001a3e8 <_CORE_message_queue_Insert_message> 4001765c: b0 10 20 00 clr %i0 40017660: 81 c7 e0 08 ret 40017664: 81 e8 00 00 restore * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); if ( the_thread ) { 40017668: 10 bf ff c2 b 40017570 <_CORE_message_queue_Submit+0x28> 4001766c: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 40007ecc <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 40007ecc: 9d e3 bf 98 save %sp, -104, %sp /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 40007ed0: c2 06 40 00 ld [ %i1 ], %g1 CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 40007ed4: 90 10 00 18 mov %i0, %o0 /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 40007ed8: c2 26 20 40 st %g1, [ %i0 + 0x40 ] 40007edc: c4 06 60 04 ld [ %i1 + 4 ], %g2 the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 40007ee0: 80 a6 a0 00 cmp %i2, 0 /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 40007ee4: c4 26 20 44 st %g2, [ %i0 + 0x44 ] 40007ee8: c8 06 60 08 ld [ %i1 + 8 ], %g4 40007eec: c8 26 20 48 st %g4, [ %i0 + 0x48 ] 40007ef0: da 06 60 0c ld [ %i1 + 0xc ], %o5 the_mutex->lock = initial_lock; 40007ef4: f4 26 20 50 st %i2, [ %i0 + 0x50 ] /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 40007ef8: da 26 20 4c st %o5, [ %i0 + 0x4c ] the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 40007efc: 12 80 00 1c bne 40007f6c <_CORE_mutex_Initialize+0xa0> 40007f00: c0 26 20 58 clr [ %i0 + 0x58 ] the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; 40007f04: 19 10 00 6b sethi %hi(0x4001ac00), %o4 40007f08: c6 03 22 6c ld [ %o4 + 0x26c ], %g3 ! 4001ae6c <_Thread_Executing> the_mutex->Attributes = *the_mutex_attributes; the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; 40007f0c: 82 10 20 01 mov 1, %g1 40007f10: c2 26 20 54 st %g1, [ %i0 + 0x54 ] the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; 40007f14: c4 00 e0 08 ld [ %g3 + 8 ], %g2 the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; 40007f18: c6 26 20 5c st %g3, [ %i0 + 0x5c ] the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40007f1c: 80 a1 20 02 cmp %g4, 2 40007f20: 12 80 00 1f bne 40007f9c <_CORE_mutex_Initialize+0xd0> 40007f24: c4 26 20 60 st %g2, [ %i0 + 0x60 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < 40007f28: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 40007f2c: 80 a0 40 0d cmp %g1, %o5 40007f30: 0a 80 00 0d bcs 40007f64 <_CORE_mutex_Initialize+0x98> 40007f34: b0 10 20 06 mov 6, %i0 the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 40007f38: c4 03 22 6c ld [ %o4 + 0x26c ], %g2 the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40007f3c: 94 10 24 00 mov 0x400, %o2 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 40007f40: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40007f44: 96 10 20 05 mov 5, %o3 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 40007f48: 82 00 60 01 inc %g1 40007f4c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40007f50: c2 06 60 08 ld [ %i1 + 8 ], %g1 40007f54: b0 10 20 00 clr %i0 40007f58: 80 a0 00 01 cmp %g0, %g1 40007f5c: 40 00 0b 60 call 4000acdc <_Thread_queue_Initialize> 40007f60: 92 40 20 00 addx %g0, 0, %o1 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 40007f64: 81 c7 e0 08 ret 40007f68: 81 e8 00 00 restore the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40007f6c: c2 06 60 08 ld [ %i1 + 8 ], %g1 if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; } else { the_mutex->nest_count = 0; 40007f70: c0 26 20 54 clr [ %i0 + 0x54 ] the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40007f74: 80 a0 00 01 cmp %g0, %g1 the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; } else { the_mutex->nest_count = 0; the_mutex->holder = NULL; 40007f78: c0 26 20 5c clr [ %i0 + 0x5c ] the_mutex->holder_id = 0; 40007f7c: c0 26 20 60 clr [ %i0 + 0x60 ] } _Thread_queue_Initialize( 40007f80: 92 40 20 00 addx %g0, 0, %o1 40007f84: 94 10 24 00 mov 0x400, %o2 40007f88: 96 10 20 05 mov 5, %o3 40007f8c: 40 00 0b 54 call 4000acdc <_Thread_queue_Initialize> 40007f90: b0 10 20 00 clr %i0 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 40007f94: 81 c7 e0 08 ret 40007f98: 81 e8 00 00 restore if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40007f9c: 80 a1 20 03 cmp %g4, 3 40007fa0: 32 bf ff e7 bne,a 40007f3c <_CORE_mutex_Initialize+0x70> 40007fa4: c4 03 22 6c ld [ %o4 + 0x26c ], %g2 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < 40007fa8: 10 bf ff e1 b 40007f2c <_CORE_mutex_Initialize+0x60> <== NOT EXECUTED 40007fac: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED 40007fb0 <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 40007fb0: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 40007fb4: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 Watchdog_Interval timeout ) { Thread_Control *executing; executing = _Thread_Executing; 40007fb8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 40007fbc: 80 a0 a0 02 cmp %g2, 2 40007fc0: 12 80 00 08 bne 40007fe0 <_CORE_mutex_Seize_interrupt_blocking+0x30> 40007fc4: d2 00 62 6c ld [ %g1 + 0x26c ], %o1 if ( the_mutex->holder->current_priority > executing->current_priority ) { 40007fc8: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 40007fcc: d2 02 60 14 ld [ %o1 + 0x14 ], %o1 40007fd0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40007fd4: 80 a0 40 09 cmp %g1, %o1 40007fd8: 18 80 00 16 bgu 40008030 <_CORE_mutex_Seize_interrupt_blocking+0x80> 40007fdc: 01 00 00 00 nop FALSE ); } } the_mutex->blocked_count++; 40007fe0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 40007fe4: 90 10 00 18 mov %i0, %o0 FALSE ); } } the_mutex->blocked_count++; 40007fe8: 82 00 60 01 inc %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 40007fec: 92 10 00 19 mov %i1, %o1 FALSE ); } } the_mutex->blocked_count++; 40007ff0: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 40007ff4: 15 10 00 2b sethi %hi(0x4000ac00), %o2 40007ff8: 40 00 0a 2b call 4000a8a4 <_Thread_queue_Enqueue_with_handler> 40007ffc: 94 12 a1 e4 or %o2, 0x1e4, %o2 ! 4000ade4 <_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 ) 40008000: 05 10 00 6b sethi %hi(0x4001ac00), %g2 40008004: c2 00 a1 90 ld [ %g2 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> 40008008: 82 00 7f ff add %g1, -1, %g1 4000800c: c2 20 a1 90 st %g1, [ %g2 + 0x190 ] 40008010: c6 00 a1 90 ld [ %g2 + 0x190 ], %g3 40008014: 80 a0 e0 00 cmp %g3, 0 40008018: 02 80 00 04 be 40008028 <_CORE_mutex_Seize_interrupt_blocking+0x78> 4000801c: 01 00 00 00 nop 40008020: 81 c7 e0 08 ret <== NOT EXECUTED 40008024: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40008028: 40 00 08 af call 4000a2e4 <_Thread_Dispatch> 4000802c: 81 e8 00 00 restore Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { if ( the_mutex->holder->current_priority > executing->current_priority ) { _Thread_Change_priority( 40008030: 40 00 07 89 call 40009e54 <_Thread_Change_priority> 40008034: 94 10 20 00 clr %o2 FALSE ); } } the_mutex->blocked_count++; 40008038: 10 bf ff eb b 40007fe4 <_CORE_mutex_Seize_interrupt_blocking+0x34> 4000803c: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 40008040 <_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 ) { 40008040: 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 ) { 40008044: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 CORE_mutex_Status _CORE_mutex_Surrender( CORE_mutex_Control *the_mutex, Objects_Id id, CORE_mutex_API_mp_support_callout api_mutex_mp_support ) { 40008048: a0 10 00 18 mov %i0, %l0 * allowed when the mutex in quetion is FIFO or simple Priority * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) { 4000804c: 80 a0 60 00 cmp %g1, 0 40008050: 02 80 00 07 be 4000806c <_CORE_mutex_Surrender+0x2c> 40008054: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 if ( !_Thread_Is_executing( holder ) ) 40008058: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000805c: c4 00 62 6c ld [ %g1 + 0x26c ], %g2 ! 4001ae6c <_Thread_Executing> 40008060: 80 a2 00 02 cmp %o0, %g2 40008064: 12 80 00 49 bne 40008188 <_CORE_mutex_Surrender+0x148> 40008068: b0 10 20 03 mov 3, %i0 return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 4000806c: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 40008070: 80 a0 60 00 cmp %g1, 0 40008074: 22 80 00 45 be,a 40008188 <_CORE_mutex_Surrender+0x148> 40008078: b0 10 20 00 clr %i0 return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 4000807c: 82 00 7f ff add %g1, -1, %g1 if ( the_mutex->nest_count != 0 ) { 40008080: 80 a0 60 00 cmp %g1, 0 40008084: 02 80 00 09 be 400080a8 <_CORE_mutex_Surrender+0x68> 40008088: c2 24 20 54 st %g1, [ %l0 + 0x54 ] switch ( the_mutex->Attributes.lock_nesting_behavior ) { 4000808c: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 40008090: 80 a0 60 00 cmp %g1, 0 40008094: 02 80 00 3d be 40008188 <_CORE_mutex_Surrender+0x148> 40008098: b0 10 20 00 clr %i0 4000809c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400080a0: 02 80 00 3a be 40008188 <_CORE_mutex_Surrender+0x148> <== NOT EXECUTED 400080a4: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 400080a8: c4 04 20 48 ld [ %l0 + 0x48 ], %g2 /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400080ac: 80 a0 a0 02 cmp %g2, 2 400080b0: 22 80 00 2a be,a 40008158 <_CORE_mutex_Surrender+0x118> 400080b4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 400080b8: 80 a0 a0 03 cmp %g2, 3 400080bc: 22 80 00 27 be,a 40008158 <_CORE_mutex_Surrender+0x118> 400080c0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; the_mutex->holder = NULL; 400080c4: c0 24 20 5c clr [ %l0 + 0x5c ] /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400080c8: 80 a0 a0 02 cmp %g2, 2 400080cc: 02 80 00 17 be 40008128 <_CORE_mutex_Surrender+0xe8> 400080d0: c0 24 20 60 clr [ %l0 + 0x60 ] 400080d4: 80 a0 a0 03 cmp %g2, 3 400080d8: 22 80 00 15 be,a 4000812c <_CORE_mutex_Surrender+0xec> 400080dc: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED /* * Now we check if another thread was waiting for this mutex. If so, * transfer the mutex to that thread. */ if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) { 400080e0: 40 00 09 83 call 4000a6ec <_Thread_queue_Dequeue> 400080e4: 90 10 00 10 mov %l0, %o0 400080e8: 86 92 20 00 orcc %o0, 0, %g3 400080ec: 02 80 00 2e be 400081a4 <_CORE_mutex_Surrender+0x164> 400080f0: 82 10 20 01 mov 1, %g1 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 400080f4: c2 00 e0 08 ld [ %g3 + 8 ], %g1 the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 400080f8: c4 04 20 48 ld [ %l0 + 0x48 ], %g2 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 400080fc: c2 24 20 60 st %g1, [ %l0 + 0x60 ] } else #endif { the_mutex->holder = the_thread; 40008100: c6 24 20 5c st %g3, [ %l0 + 0x5c ] the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; 40008104: 82 10 20 01 mov 1, %g1 switch ( the_mutex->Attributes.discipline ) { 40008108: 80 a0 a0 02 cmp %g2, 2 4000810c: 02 80 00 21 be 40008190 <_CORE_mutex_Surrender+0x150> 40008110: c2 24 20 54 st %g1, [ %l0 + 0x54 ] 40008114: 80 a0 a0 03 cmp %g2, 3 40008118: 22 80 00 13 be,a 40008164 <_CORE_mutex_Surrender+0x124> 4000811c: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 40008120: 81 c7 e0 08 ret 40008124: 91 e8 20 00 restore %g0, 0, %o0 * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( holder->resource_count == 0 && 40008128: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 4000812c: 80 a0 60 00 cmp %g1, 0 40008130: 12 bf ff ec bne 400080e0 <_CORE_mutex_Surrender+0xa0> 40008134: 01 00 00 00 nop 40008138: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 4000813c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40008140: 80 a2 40 01 cmp %o1, %g1 40008144: 02 bf ff e7 be 400080e0 <_CORE_mutex_Surrender+0xa0> 40008148: 01 00 00 00 nop holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 4000814c: 40 00 07 42 call 40009e54 <_Thread_Change_priority> 40008150: 94 10 20 01 mov 1, %o2 ! 1 40008154: 30 bf ff e3 b,a 400080e0 <_CORE_mutex_Surrender+0xa0> * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; 40008158: 82 00 7f ff add %g1, -1, %g1 4000815c: 10 bf ff da b 400080c4 <_CORE_mutex_Surrender+0x84> 40008160: c2 22 20 1c st %g1, [ %o0 + 0x1c ] case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; if (the_mutex->Attributes.priority_ceiling < 40008164: 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++; 40008168: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000816c: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 40008170: d2 04 20 4c ld [ %l0 + 0x4c ], %o1 <== NOT EXECUTED 40008174: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED 40008178: 1a 80 00 04 bcc 40008188 <_CORE_mutex_Surrender+0x148> <== NOT EXECUTED 4000817c: b0 10 20 00 clr %i0 <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 40008180: 40 00 07 35 call 40009e54 <_Thread_Change_priority> <== NOT EXECUTED 40008184: 94 10 20 00 clr %o2 <== NOT EXECUTED 40008188: 81 c7 e0 08 ret 4000818c: 81 e8 00 00 restore switch ( the_mutex->Attributes.discipline ) { case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; 40008190: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 40008194: 82 00 60 01 inc %g1 40008198: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] 4000819c: 81 c7 e0 08 ret 400081a0: 91 e8 20 00 restore %g0, 0, %o0 } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 400081a4: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 400081a8: 81 c7 e0 08 ret 400081ac: 91 e8 20 00 restore %g0, 0, %o0 4000dca4 <_Debug_Is_enabled>: */ boolean _Debug_Is_enabled( rtems_debug_control level ) { 4000dca4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000dca8: c4 00 62 70 ld [ %g1 + 0x270 ], %g2 ! 4001ae70 <_Debug_Level> <== NOT EXECUTED 4000dcac: 90 0a 00 02 and %o0, %g2, %o0 <== NOT EXECUTED return (_Debug_Level & level) ? TRUE : FALSE; } 4000dcb0: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 4000dcb4: 81 c3 e0 08 retl <== NOT EXECUTED 4000dcb8: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED 40006670 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 40006670: 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; 40006674: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006678: e0 00 62 6c ld [ %g1 + 0x26c ], %l0 ! 4001ae6c <_Thread_Executing> executing->Wait.return_code = RTEMS_SUCCESSFUL; 4000667c: c0 24 20 34 clr [ %l0 + 0x34 ] api = executing->API_Extensions[ THREAD_API_RTEMS ]; _ISR_Disable( level ); 40006680: 7f ff ee 53 call 40001fcc 40006684: e4 04 21 6c ld [ %l0 + 0x16c ], %l2 40006688: 84 10 00 08 mov %o0, %g2 pending_events = api->pending_events; 4000668c: c2 04 a0 40 ld [ %l2 + 0x40 ], %g1 seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 40006690: a2 8e 00 01 andcc %i0, %g1, %l1 40006694: 02 80 00 0e be 400066cc <_Event_Seize+0x5c> 40006698: 80 8e 60 01 btst 1, %i1 4000669c: 80 a6 00 11 cmp %i0, %l1 400066a0: 02 80 00 04 be 400066b0 <_Event_Seize+0x40> 400066a4: 80 8e 60 02 btst 2, %i1 400066a8: 02 80 00 09 be 400066cc <_Event_Seize+0x5c> 400066ac: 80 8e 60 01 btst 1, %i1 (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 400066b0: 82 28 40 11 andn %g1, %l1, %g1 400066b4: c2 24 a0 40 st %g1, [ %l2 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 400066b8: 7f ff ee 49 call 40001fdc 400066bc: 01 00 00 00 nop *event_out = seized_events; 400066c0: e2 26 c0 00 st %l1, [ %i3 ] 400066c4: 81 c7 e0 08 ret 400066c8: 81 e8 00 00 restore return; } if ( _Options_Is_no_wait( option_set ) ) { 400066cc: 12 80 00 1e bne 40006744 <_Event_Seize+0xd4> 400066d0: 82 10 20 01 mov 1, %g1 executing->Wait.return_code = RTEMS_UNSATISFIED; *event_out = seized_events; return; } _Event_Sync_state = EVENT_SYNC_NOTHING_HAPPENED; 400066d4: 23 10 00 6c sethi %hi(0x4001b000), %l1 executing->Wait.option = (uint32_t ) option_set; 400066d8: f2 24 20 30 st %i1, [ %l0 + 0x30 ] executing->Wait.count = (uint32_t ) event_in; 400066dc: f0 24 20 24 st %i0, [ %l0 + 0x24 ] executing->Wait.return_argument = event_out; 400066e0: 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; 400066e4: c2 24 60 a4 st %g1, [ %l1 + 0xa4 ] executing->Wait.option = (uint32_t ) option_set; executing->Wait.count = (uint32_t ) event_in; executing->Wait.return_argument = event_out; _ISR_Enable( level ); 400066e8: 7f ff ee 3d call 40001fdc 400066ec: 90 10 00 02 mov %g2, %o0 if ( ticks ) { 400066f0: 80 a6 a0 00 cmp %i2, 0 400066f4: 32 80 00 24 bne,a 40006784 <_Event_Seize+0x114> 400066f8: c2 04 20 08 ld [ %l0 + 8 ], %g1 NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 400066fc: 90 10 00 10 mov %l0, %o0 40006700: 40 00 12 09 call 4000af24 <_Thread_Set_state> 40006704: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 40006708: 7f ff ee 31 call 40001fcc 4000670c: 01 00 00 00 nop 40006710: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 40006714: c4 04 60 a4 ld [ %l1 + 0xa4 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 40006718: c0 24 60 a4 clr [ %l1 + 0xa4 ] switch ( sync_state ) { 4000671c: 80 a0 a0 02 cmp %g2, 2 40006720: 02 80 00 30 be 400067e0 <_Event_Seize+0x170> 40006724: 82 10 20 06 mov 6, %g1 40006728: 80 a0 a0 03 cmp %g2, 3 4000672c: 02 80 00 0d be 40006760 <_Event_Seize+0xf0> 40006730: 80 a0 a0 01 cmp %g2, 1 40006734: 02 80 00 31 be 400067f8 <_Event_Seize+0x188> 40006738: 01 00 00 00 nop 4000673c: 81 c7 e0 08 ret <== NOT EXECUTED 40006740: 81 e8 00 00 restore <== NOT EXECUTED *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 40006744: 7f ff ee 26 call 40001fdc 40006748: 90 10 00 02 mov %g2, %o0 executing->Wait.return_code = RTEMS_UNSATISFIED; 4000674c: 82 10 20 0d mov 0xd, %g1 40006750: c2 24 20 34 st %g1, [ %l0 + 0x34 ] *event_out = seized_events; 40006754: e2 26 c0 00 st %l1, [ %i3 ] 40006758: 81 c7 e0 08 ret 4000675c: 81 e8 00 00 restore _ISR_Enable( level ); _Thread_Unblock( executing ); return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { 40006760: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40006764: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40006768: 22 80 00 26 be,a 40006800 <_Event_Seize+0x190> <== NOT EXECUTED 4000676c: c4 24 20 50 st %g2, [ %l0 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &executing->Timer ); } else _ISR_Enable( level ); 40006770: 7f ff ee 1b call 40001fdc <== NOT EXECUTED 40006774: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 40006778: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000677c: 40 00 0e 25 call 4000a010 <_Thread_Clear_state> <== NOT EXECUTED 40006780: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40006784: 92 04 20 48 add %l0, 0x48, %o1 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 40006788: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 4000678c: 03 10 00 1a sethi %hi(0x40006800), %g1 40006790: 82 10 62 34 or %g1, 0x234, %g1 ! 40006a34 <_Event_Timeout> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40006794: f4 24 20 54 st %i2, [ %l0 + 0x54 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40006798: c2 24 20 64 st %g1, [ %l0 + 0x64 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4000679c: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 400067a0: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400067a4: 11 10 00 6b sethi %hi(0x4001ac00), %o0 400067a8: 40 00 13 f6 call 4000b780 <_Watchdog_Insert> 400067ac: 90 12 22 8c or %o0, 0x28c, %o0 ! 4001ae8c <_Watchdog_Ticks_chain> NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 400067b0: 90 10 00 10 mov %l0, %o0 400067b4: 40 00 11 dc call 4000af24 <_Thread_Set_state> 400067b8: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 400067bc: 7f ff ee 04 call 40001fcc 400067c0: 01 00 00 00 nop 400067c4: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 400067c8: c4 04 60 a4 ld [ %l1 + 0xa4 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 400067cc: c0 24 60 a4 clr [ %l1 + 0xa4 ] switch ( sync_state ) { 400067d0: 80 a0 a0 02 cmp %g2, 2 400067d4: 12 bf ff d6 bne 4000672c <_Event_Seize+0xbc> 400067d8: 80 a0 a0 03 cmp %g2, 3 case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); return; case EVENT_SYNC_TIMEOUT: executing->Wait.return_code = RTEMS_TIMEOUT; 400067dc: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 400067e0: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400067e4: 7f ff ed fe call 40001fdc <== NOT EXECUTED 400067e8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 400067ec: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 400067f0: 40 00 0e 08 call 4000a010 <_Thread_Clear_state> <== NOT EXECUTED 400067f4: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED * enter the synchronization states above. */ return; case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); 400067f8: 7f ff ed f9 call 40001fdc 400067fc: 81 e8 00 00 restore return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); 40006800: 7f ff ed f7 call 40001fdc <== NOT EXECUTED 40006804: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED (void) _Watchdog_Remove( &executing->Timer ); 40006808: 40 00 14 48 call 4000b928 <_Watchdog_Remove> <== NOT EXECUTED 4000680c: 90 04 20 48 add %l0, 0x48, %o0 <== NOT EXECUTED 40006810: 10 bf ff db b 4000677c <_Event_Seize+0x10c> <== NOT EXECUTED 40006814: b2 16 63 f8 or %i1, 0x3f8, %i1 <== NOT EXECUTED 40006914 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 40006914: 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 ]; 40006918: e0 06 21 6c ld [ %i0 + 0x16c ], %l0 option_set = (rtems_option) the_thread->Wait.option; 4000691c: e4 06 20 30 ld [ %i0 + 0x30 ], %l2 _ISR_Disable( level ); 40006920: 7f ff ed ab call 40001fcc 40006924: b2 10 00 18 mov %i0, %i1 40006928: a2 10 00 08 mov %o0, %l1 pending_events = api->pending_events; 4000692c: c8 04 20 40 ld [ %l0 + 0x40 ], %g4 event_condition = (rtems_event_set) the_thread->Wait.count; 40006930: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { 40006934: 9a 88 c0 04 andcc %g3, %g4, %o5 40006938: 02 80 00 20 be 400069b8 <_Event_Surrender+0xa4> 4000693c: 01 00 00 00 nop if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 40006940: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 40006944: 80 88 61 00 btst 0x100, %g1 40006948: 02 80 00 08 be 40006968 <_Event_Surrender+0x54> 4000694c: 19 10 00 6c sethi %hi(0x4001b000), %o4 if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 40006950: 80 a0 c0 0d cmp %g3, %o5 40006954: 02 80 00 1b be 400069c0 <_Event_Surrender+0xac> 40006958: 80 8c a0 02 btst 2, %l2 4000695c: 12 80 00 1a bne 400069c4 <_Event_Surrender+0xb0> 40006960: 82 29 00 0d andn %g4, %o5, %g1 } return; } } switch ( _Event_Sync_state ) { 40006964: 19 10 00 6c sethi %hi(0x4001b000), %o4 <== NOT EXECUTED 40006968: c2 03 20 a4 ld [ %o4 + 0xa4 ], %g1 ! 4001b0a4 <_Event_Sync_state> <== NOT EXECUTED 4000696c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40006970: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40006974: 18 80 00 11 bgu 400069b8 <_Event_Surrender+0xa4> <== NOT EXECUTED 40006978: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED case EVENT_SYNC_SATISFIED: break; case EVENT_SYNC_NOTHING_HAPPENED: case EVENT_SYNC_TIMEOUT: if ( !_Thread_Is_executing( the_thread ) ) 4000697c: c4 00 62 6c ld [ %g1 + 0x26c ], %g2 ! 4001ae6c <_Thread_Executing> <== NOT EXECUTED 40006980: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED 40006984: 12 80 00 0d bne 400069b8 <_Event_Surrender+0xa4> <== NOT EXECUTED 40006988: 80 a0 c0 0d cmp %g3, %o5 <== NOT EXECUTED break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 4000698c: 02 80 00 04 be 4000699c <_Event_Surrender+0x88> <== NOT EXECUTED 40006990: 80 8c a0 02 btst 2, %l2 <== NOT EXECUTED 40006994: 02 80 00 09 be 400069b8 <_Event_Surrender+0xa4> <== NOT EXECUTED 40006998: 01 00 00 00 nop <== NOT EXECUTED api->pending_events = 4000699c: 82 29 00 0d andn %g4, %o5, %g1 <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 400069a0: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED case EVENT_SYNC_TIMEOUT: if ( !_Thread_Is_executing( the_thread ) ) break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { api->pending_events = 400069a4: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 400069a8: c0 26 60 24 clr [ %i1 + 0x24 ] <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; _Event_Sync_state = EVENT_SYNC_SATISFIED; 400069ac: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED if ( seized_events == event_condition || _Options_Is_any(option_set) ) { api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 400069b0: da 20 80 00 st %o5, [ %g2 ] <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_SATISFIED; 400069b4: c2 23 20 a4 st %g1, [ %o4 + 0xa4 ] <== NOT EXECUTED } break; } } _ISR_Enable( level ); 400069b8: 7f ff ed 89 call 40001fdc 400069bc: 91 e8 00 11 restore %g0, %l1, %o0 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { api->pending_events = 400069c0: 82 29 00 0d andn %g4, %o5, %g1 _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 400069c4: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { api->pending_events = 400069c8: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 400069cc: c0 26 60 24 clr [ %i1 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 400069d0: da 20 80 00 st %o5, [ %g2 ] _ISR_Flash( level ); 400069d4: 7f ff ed 82 call 40001fdc 400069d8: 01 00 00 00 nop 400069dc: 7f ff ed 7c call 40001fcc 400069e0: 01 00 00 00 nop if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 400069e4: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 400069e8: 80 a0 60 02 cmp %g1, 2 400069ec: 02 80 00 08 be 40006a0c <_Event_Surrender+0xf8> 400069f0: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 400069f4: 90 10 00 11 mov %l1, %o0 400069f8: 7f ff ed 79 call 40001fdc 400069fc: 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 ); 40006a00: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 40006a04: 40 00 0d 83 call 4000a010 <_Thread_Clear_state> 40006a08: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 40006a0c: c2 26 60 50 st %g1, [ %i1 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 40006a10: 7f ff ed 73 call 40001fdc 40006a14: 90 10 00 11 mov %l1, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 40006a18: 40 00 13 c4 call 4000b928 <_Watchdog_Remove> 40006a1c: 90 06 60 48 add %i1, 0x48, %o0 40006a20: 33 04 00 ff sethi %hi(0x1003fc00), %i1 40006a24: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 40006a28: 40 00 0d 7a call 4000a010 <_Thread_Clear_state> 40006a2c: 81 e8 00 00 restore 40006a30: 01 00 00 00 nop 40006a34 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 40006a34: 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 ) ) { 40006a38: 92 96 20 00 orcc %i0, 0, %o1 40006a3c: 12 80 00 25 bne 40006ad0 <_Event_Timeout+0x9c> 40006a40: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006a44: 21 10 00 6b sethi %hi(0x4001ac00), %l0 <== NOT EXECUTED 40006a48: c2 04 21 90 ld [ %l0 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40006a4c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40006a50: c2 24 21 90 st %g1, [ %l0 + 0x190 ] <== 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; 40006a54: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40006a58: f0 00 62 6c ld [ %g1 + 0x26c ], %i0 ! 4001ae6c <_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; 40006a5c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 40006a60: 7f ff ed 5b call 40001fcc 40006a64: 01 00 00 00 nop 40006a68: 88 10 00 08 mov %o0, %g4 if ( the_thread->Wait.count ) { /* verify thread is waiting */ 40006a6c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 40006a70: 80 a0 60 00 cmp %g1, 0 40006a74: 02 80 00 3a be 40006b5c <_Event_Timeout+0x128> 40006a78: 07 10 00 6c sethi %hi(0x4001b000), %g3 the_thread->Wait.count = 0; if ( _Event_Sync_state != EVENT_SYNC_SYNCHRONIZED && 40006a7c: c2 00 e0 a4 ld [ %g3 + 0xa4 ], %g1 ! 4001b0a4 <_Event_Sync_state> 40006a80: 80 a0 60 00 cmp %g1, 0 40006a84: 02 80 00 29 be 40006b28 <_Event_Timeout+0xf4> 40006a88: c0 26 20 24 clr [ %i0 + 0x24 ] 40006a8c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40006a90: c4 00 62 6c ld [ %g1 + 0x26c ], %g2 ! 4001ae6c <_Thread_Executing> <== NOT EXECUTED 40006a94: 80 a6 00 02 cmp %i0, %g2 <== NOT EXECUTED 40006a98: 12 80 00 25 bne 40006b2c <_Event_Timeout+0xf8> <== NOT EXECUTED 40006a9c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { 40006aa0: c2 00 e0 a4 ld [ %g3 + 0xa4 ], %g1 <== NOT EXECUTED 40006aa4: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 40006aa8: 02 80 00 03 be 40006ab4 <_Event_Timeout+0x80> <== NOT EXECUTED 40006aac: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_TIMEOUT; 40006ab0: c2 20 e0 a4 st %g1, [ %g3 + 0xa4 ] <== NOT EXECUTED } _ISR_Enable( level ); 40006ab4: 7f ff ed 4a call 40001fdc <== NOT EXECUTED 40006ab8: 01 00 00 00 nop <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 40006abc: c2 04 21 90 ld [ %l0 + 0x190 ], %g1 <== NOT EXECUTED 40006ac0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40006ac4: c2 24 21 90 st %g1, [ %l0 + 0x190 ] <== NOT EXECUTED 40006ac8: 81 c7 e0 08 ret <== NOT EXECUTED 40006acc: 81 e8 00 00 restore <== NOT EXECUTED 40006ad0: 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 ) { 40006ad4: 80 a0 a0 04 cmp %g2, 4 40006ad8: 18 bf ff fc bgu 40006ac8 <_Event_Timeout+0x94> 40006adc: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40006ae0: 80 a0 60 01 cmp %g1, 1 40006ae4: 12 bf ff f9 bne 40006ac8 <_Event_Timeout+0x94> 40006ae8: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40006aec: 05 10 00 6b sethi %hi(0x4001ac00), %g2 40006af0: 84 10 a0 f0 or %g2, 0xf0, %g2 ! 4001acf0 <_Objects_Information_table> 40006af4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40006af8: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40006afc: 80 a2 20 00 cmp %o0, 0 40006b00: 02 80 00 15 be 40006b54 <_Event_Timeout+0x120> 40006b04: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40006b08: 40 00 08 cf call 40008e44 <_Objects_Get> 40006b0c: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40006b10: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006b14: 80 a0 60 00 cmp %g1, 0 40006b18: 12 bf ff ec bne 40006ac8 <_Event_Timeout+0x94> 40006b1c: b0 10 00 08 mov %o0, %i0 40006b20: 10 bf ff d0 b 40006a60 <_Event_Timeout+0x2c> 40006b24: 21 10 00 6b sethi %hi(0x4001ac00), %l0 if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { _Event_Sync_state = EVENT_SYNC_TIMEOUT; } _ISR_Enable( level ); } else { the_thread->Wait.return_code = RTEMS_TIMEOUT; 40006b28: 82 10 20 06 mov 6, %g1 40006b2c: c2 26 20 34 st %g1, [ %i0 + 0x34 ] _ISR_Enable( level ); 40006b30: 7f ff ed 2b call 40001fdc 40006b34: 90 10 00 04 mov %g4, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 40006b38: 13 04 00 ff sethi %hi(0x1003fc00), %o1 40006b3c: 90 10 00 18 mov %i0, %o0 40006b40: 40 00 0d 34 call 4000a010 <_Thread_Clear_state> 40006b44: 92 12 63 f8 or %o1, 0x3f8, %o1 */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 40006b48: c2 04 21 90 ld [ %l0 + 0x190 ], %g1 40006b4c: 82 00 7f ff add %g1, -1, %g1 40006b50: c2 24 21 90 st %g1, [ %l0 + 0x190 ] 40006b54: 81 c7 e0 08 ret 40006b58: 81 e8 00 00 restore _Thread_Unblock( the_thread ); } } else { _ISR_Enable( level ); 40006b5c: 7f ff ed 20 call 40001fdc <== NOT EXECUTED 40006b60: 01 00 00 00 nop <== NOT EXECUTED 40006b64: 30 bf ff f9 b,a 40006b48 <_Event_Timeout+0x114> <== NOT EXECUTED 40008384 <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 40008384: 9d e3 bf 98 save %sp, -104, %sp Heap_Block *the_block; void *ptr = NULL; Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); the_size = 40008388: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 4000838c: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 40008390: 90 10 00 19 mov %i1, %o0 40008394: 40 00 00 cd call 400086c8 <_Heap_Calc_block_size> 40008398: a0 10 00 18 mov %i0, %l0 _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 4000839c: 80 a2 20 00 cmp %o0, 0 400083a0: 22 80 00 1a be,a 40008408 <_Heap_Allocate+0x84> 400083a4: b0 10 20 00 clr %i0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 400083a8: f0 06 20 08 ld [ %i0 + 8 ], %i0 return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 400083ac: 80 a4 00 18 cmp %l0, %i0 400083b0: 22 80 00 16 be,a 40008408 <_Heap_Allocate+0x84> 400083b4: b0 10 20 00 clr %i0 /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 400083b8: c2 06 20 04 ld [ %i0 + 4 ], %g1 400083bc: 80 a2 00 01 cmp %o0, %g1 400083c0: 08 80 00 16 bleu 40008418 <_Heap_Allocate+0x94> 400083c4: b2 10 20 00 clr %i1 return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 400083c8: 10 80 00 07 b 400083e4 <_Heap_Allocate+0x60> 400083cc: f0 06 20 08 ld [ %i0 + 8 ], %i0 /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 400083d0: c2 06 20 04 ld [ %i0 + 4 ], %g1 400083d4: 80 a2 00 01 cmp %o0, %g1 400083d8: 08 80 00 11 bleu 4000841c <_Heap_Allocate+0x98> 400083dc: 94 10 00 08 mov %o0, %o2 return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 400083e0: f0 06 20 08 ld [ %i0 + 8 ], %i0 if(the_size == 0) return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 400083e4: 80 a4 00 18 cmp %l0, %i0 400083e8: 12 bf ff fa bne 400083d0 <_Heap_Allocate+0x4c> 400083ec: b2 06 60 01 inc %i1 400083f0: b0 10 20 00 clr %i0 _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 400083f4: c2 04 20 44 ld [ %l0 + 0x44 ], %g1 400083f8: 80 a6 40 01 cmp %i1, %g1 400083fc: 08 80 00 05 bleu 40008410 <_Heap_Allocate+0x8c> 40008400: 01 00 00 00 nop stats->max_search = search_count; 40008404: f2 24 20 44 st %i1, [ %l0 + 0x44 ] 40008408: 81 c7 e0 08 ret 4000840c: 81 e8 00 00 restore return ptr; } 40008410: 81 c7 e0 08 ret 40008414: 81 e8 00 00 restore _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 40008418: 94 10 00 08 mov %o0, %o2 4000841c: 92 10 00 18 mov %i0, %o1 40008420: 40 00 00 7e call 40008618 <_Heap_Block_allocate> 40008424: 90 10 00 10 mov %l0, %o0 ptr = _Heap_User_area(the_block); stats->allocs += 1; 40008428: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 stats->searches += search_count + 1; 4000842c: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); ptr = _Heap_User_area(the_block); stats->allocs += 1; 40008430: 82 00 60 01 inc %g1 stats->searches += search_count + 1; 40008434: 84 00 a0 01 inc %g2 if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); ptr = _Heap_User_area(the_block); stats->allocs += 1; 40008438: c2 24 20 48 st %g1, [ %l0 + 0x48 ] stats->searches += search_count + 1; 4000843c: 84 00 80 19 add %g2, %i1, %g2 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( void *base, uint32_t offset ) { return (void *)((char *)base + offset); 40008440: b0 06 20 08 add %i0, 8, %i0 40008444: 10 bf ff ec b 400083f4 <_Heap_Allocate+0x70> 40008448: c4 24 20 4c st %g2, [ %l0 + 0x4c ] 400086c8 <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 400086c8: 9d e3 bf 98 save %sp, -104, %sp 400086cc: a0 10 00 19 mov %i1, %l0 uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 400086d0: b2 06 20 04 add %i0, 4, %i1 uint32_t alignment ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; 400086d4: 92 10 00 10 mov %l0, %o1 400086d8: 40 00 37 ce call 40016610 <.urem> 400086dc: 90 10 00 19 mov %i1, %o0 *value = r ? v - r + a : v; 400086e0: 80 a2 20 00 cmp %o0, 0 400086e4: 02 80 00 04 be 400086f4 <_Heap_Calc_block_size+0x2c> 400086e8: 82 10 00 19 mov %i1, %g1 400086ec: 82 04 00 19 add %l0, %i1, %g1 400086f0: 82 20 40 08 sub %g1, %o0, %g1 400086f4: 80 a0 40 1a cmp %g1, %i2 400086f8: 2a 80 00 02 bcs,a 40008700 <_Heap_Calc_block_size+0x38> 400086fc: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED _Heap_Align_up(&block_size, page_size); if (block_size < min_size) block_size = min_size; /* 'block_size' becomes <= 'size' if and only if overflow occured. */ return (block_size > size) ? block_size : 0; 40008700: 80 a6 00 01 cmp %i0, %g1 40008704: 1a 80 00 03 bcc 40008710 <_Heap_Calc_block_size+0x48> 40008708: b0 10 20 00 clr %i0 4000870c: b0 10 00 01 mov %g1, %i0 } 40008710: 81 c7 e0 08 ret 40008714: 81 e8 00 00 restore 4001bd1c <_Heap_Get_free_information>: */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 4001bd1c: 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; 4001bd20: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED info->largest = 0; 4001bd24: c0 22 60 04 clr [ %o1 + 4 ] <== NOT EXECUTED info->total = 0; 4001bd28: c0 22 60 08 clr [ %o1 + 8 ] <== NOT EXECUTED for(the_block = _Heap_First(the_heap); the_block != tail; 4001bd2c: 80 a2 00 0d cmp %o0, %o5 <== NOT EXECUTED 4001bd30: 02 80 00 12 be 4001bd78 <_Heap_Get_free_information+0x5c> <== NOT EXECUTED 4001bd34: 98 10 20 00 clr %o4 <== NOT EXECUTED 4001bd38: 84 10 00 0c mov %o4, %g2 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 4001bd3c: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; info->total += the_size; if ( info->largest < the_size ) 4001bd40: c6 02 60 04 ld [ %o1 + 4 ], %g3 <== NOT EXECUTED 4001bd44: 88 08 7f fe and %g1, -2, %g4 <== NOT EXECUTED uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 4001bd48: 84 00 a0 01 inc %g2 <== NOT EXECUTED info->total += the_size; 4001bd4c: 82 03 00 04 add %o4, %g4, %g1 <== NOT EXECUTED uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 4001bd50: c4 22 40 00 st %g2, [ %o1 ] <== NOT EXECUTED info->total += the_size; 4001bd54: c2 22 60 08 st %g1, [ %o1 + 8 ] <== NOT EXECUTED if ( info->largest < the_size ) 4001bd58: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED 4001bd5c: 08 80 00 03 bleu 4001bd68 <_Heap_Get_free_information+0x4c> <== NOT EXECUTED 4001bd60: 98 10 00 01 mov %g1, %o4 <== NOT EXECUTED info->largest = the_size; 4001bd64: c8 22 60 04 st %g4, [ %o1 + 4 ] <== NOT EXECUTED info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 4001bd68: 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; 4001bd6c: 80 a2 00 0d cmp %o0, %o5 <== NOT EXECUTED 4001bd70: 32 bf ff f4 bne,a 4001bd40 <_Heap_Get_free_information+0x24> <== NOT EXECUTED 4001bd74: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED 4001bd78: 81 c3 e0 08 retl <== NOT EXECUTED 4001bd7c: 01 00 00 00 nop 40008718 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 40008718: 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) 4000871c: 80 a6 e0 00 cmp %i3, 0 40008720: 12 80 00 43 bne 4000882c <_Heap_Initialize+0x114> 40008724: 84 8e e0 07 andcc %i3, 7, %g2 40008728: b6 10 20 08 mov 8, %i3 <== NOT EXECUTED 4000872c: a4 10 20 00 clr %l2 <== NOT EXECUTED /* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET (value of user pointer) is aligned on 'page_size' boundary. Make sure resulting 'aligned_start' is not below 'starting_address'. */ start = _H_p2u(starting_address); aligned_start = start + HEAP_BLOCK_USER_OFFSET; 40008730: a0 06 60 08 add %i1, 8, %l0 uint32_t alignment ) { _H_uptr_t v = *value; uint32_t a = alignment; _H_uptr_t r = v % a; 40008734: 92 10 00 1b mov %i3, %o1 40008738: 40 00 37 b6 call 40016610 <.urem> 4000873c: 90 10 00 10 mov %l0, %o0 *value = r ? v - r + a : v; 40008740: 80 a2 20 00 cmp %o0, 0 40008744: 02 80 00 05 be 40008758 <_Heap_Initialize+0x40> 40008748: a2 04 3f f8 add %l0, -8, %l1 4000874c: 82 06 c0 10 add %i3, %l0, %g1 40008750: a0 20 40 08 sub %g1, %o0, %l0 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 40008754: a2 04 3f f8 add %l0, -8, %l1 ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 40008758: 80 a4 a0 00 cmp %l2, 0 4000875c: 02 80 00 04 be 4000876c <_Heap_Initialize+0x54> 40008760: 82 10 20 10 mov 0x10, %g1 40008764: 82 06 e0 10 add %i3, 0x10, %g1 40008768: 82 20 40 12 sub %g1, %l2, %g1 4000876c: c2 26 20 14 st %g1, [ %i0 + 0x14 ] /* Calculate 'the_size' -- size of the first block so that there is enough space at the end for the permanent last block. It is equal to 'size' minus total overhead aligned down to the nearest multiple of 'page_size'. */ overhead = HEAP_OVERHEAD + (aligned_start - start); 40008770: 82 24 40 19 sub %l1, %i1, %g1 40008774: 82 00 60 08 add %g1, 8, %g1 if ( size < overhead ) 40008778: 80 a0 40 1a cmp %g1, %i2 4000877c: 18 80 00 2a bgu 40008824 <_Heap_Initialize+0x10c> 40008780: a0 26 80 01 sub %i2, %g1, %l0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 40008784: 92 10 00 1b mov %i3, %o1 40008788: 40 00 37 a2 call 40016610 <.urem> 4000878c: 90 10 00 10 mov %l0, %o0 return 0; /* Too small area for the heap */ the_size = size - overhead; _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 40008790: a0 a4 00 08 subcc %l0, %o0, %l0 40008794: 02 80 00 24 be 40008824 <_Heap_Initialize+0x10c> 40008798: 09 10 00 6a sethi %hi(0x4001a800), %g4 return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 4000879c: f6 26 20 10 st %i3, [ %i0 + 0x10 ] the_heap->begin = starting_address; the_heap->end = starting_address + size; the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 400087a0: f6 24 40 00 st %i3, [ %l1 ] the_block->size = the_size | HEAP_PREV_USED; 400087a4: 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++; 400087a8: c6 01 23 6c ld [ %g4 + 0x36c ], %g3 the_heap->end = starting_address + size; the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; 400087ac: c2 24 60 04 st %g1, [ %l1 + 4 ] _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ 400087b0: e0 24 40 10 st %l0, [ %l1 + %l0 ] RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 400087b4: 9a 04 40 10 add %l1, %l0, %o5 the_block->size = page_size; 400087b8: f6 23 60 04 st %i3, [ %o5 + 4 ] the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; the_block->next = _Heap_Tail( the_heap ); 400087bc: f0 24 60 08 st %i0, [ %l1 + 8 ] the_block->prev = _Heap_Head( the_heap ); 400087c0: f0 24 60 0c st %i0, [ %l1 + 0xc ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 400087c4: c6 26 20 28 st %g3, [ %i0 + 0x28 ] the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ the_block->size = page_size; stats->size = size; 400087c8: f4 26 20 2c st %i2, [ %i0 + 0x2c ] stats->free_size = the_size; 400087cc: e0 26 20 30 st %l0, [ %i0 + 0x30 ] stats->min_free_size = the_size; 400087d0: e0 26 20 34 st %l0, [ %i0 + 0x34 ] stats->free_blocks = 1; stats->max_free_blocks = 1; stats->used_blocks = 0; 400087d4: c0 26 20 40 clr [ %i0 + 0x40 ] stats->max_search = 0; 400087d8: c0 26 20 44 clr [ %i0 + 0x44 ] stats->allocs = 0; 400087dc: c0 26 20 48 clr [ %i0 + 0x48 ] stats->searches = 0; 400087e0: c0 26 20 4c clr [ %i0 + 0x4c ] stats->frees = 0; 400087e4: c0 26 20 50 clr [ %i0 + 0x50 ] stats->resizes = 0; 400087e8: c0 26 20 54 clr [ %i0 + 0x54 ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 400087ec: 84 10 20 01 mov 1, %g2 stats->max_free_blocks = 1; 400087f0: c4 26 20 3c st %g2, [ %i0 + 0x3c ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 400087f4: c4 26 20 38 st %g2, [ %i0 + 0x38 ] if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 400087f8: 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++; 400087fc: 86 00 e0 01 inc %g3 if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 40008800: 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; 40008804: 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; 40008808: e2 26 20 08 st %l1, [ %i0 + 8 ] _Heap_Tail(the_heap)->prev = the_block; 4000880c: e2 26 20 0c st %l1, [ %i0 + 0xc ] the_heap->start = the_block; 40008810: e2 26 20 20 st %l1, [ %i0 + 0x20 ] _HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT)); _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ 40008814: da 26 20 24 st %o5, [ %i0 + 0x24 ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 40008818: c6 21 23 6c st %g3, [ %g4 + 0x36c ] return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 4000881c: 81 c7 e0 08 ret 40008820: 91 ec 3f fc restore %l0, -4, %o0 } 40008824: 81 c7 e0 08 ret 40008828: 91 e8 20 00 restore %g0, 0, %o0 ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 4000882c: 02 80 00 04 be 4000883c <_Heap_Initialize+0x124> 40008830: 90 10 20 10 mov 0x10, %o0 40008834: 82 06 e0 08 add %i3, 8, %g1 40008838: b6 20 40 02 sub %g1, %g2, %i3 4000883c: 40 00 37 75 call 40016610 <.urem> 40008840: 92 10 00 1b mov %i3, %o1 40008844: 10 bf ff bb b 40008730 <_Heap_Initialize+0x18> 40008848: a4 10 00 08 mov %o0, %l2 4000dec8 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 4000dec8: 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; 4000decc: 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; 4000ded0: ee 06 20 14 ld [ %i0 + 0x14 ], %l7 <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; *old_mem_size = 0; 4000ded4: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED *avail_mem_size = 0; 4000ded8: 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); 4000dedc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4000dee0: 40 00 21 cc call 40016610 <.urem> <== NOT EXECUTED 4000dee4: 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 ); 4000dee8: 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); 4000deec: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 4000def0: 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)) 4000def4: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED 4000def8: 1a 80 00 05 bcc 4000df0c <_Heap_Resize_block+0x44> <== NOT EXECUTED 4000defc: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 4000df00: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED } 4000df04: 81 c7 e0 08 ret <== NOT EXECUTED 4000df08: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED *old_mem_size = 0; *avail_mem_size = 0; _Heap_Start_of_block(the_heap, starting_address, &the_block); _HAssert(_Heap_Is_block_in(the_heap, the_block)); if (!_Heap_Is_block_in(the_heap, the_block)) 4000df0c: 80 a4 80 02 cmp %l2, %g2 <== NOT EXECUTED 4000df10: 38 bf ff fd bgu,a 4000df04 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 4000df14: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 4000df18: 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); 4000df1c: a8 08 ff fe and %g3, -2, %l4 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 4000df20: a2 04 80 14 add %l2, %l4, %l1 <== NOT EXECUTED old_block_size = _Heap_Block_size(the_block); next_block = _Heap_Block_at(the_block, old_block_size); _HAssert(_Heap_Is_block_in(the_heap, next_block)); _HAssert(_Heap_Is_prev_used(next_block)); if ( !_Heap_Is_block_in(the_heap, next_block) || 4000df24: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 4000df28: 2a bf ff f7 bcs,a 4000df04 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 4000df2c: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 4000df30: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 4000df34: 38 bf ff f4 bgu,a 4000df04 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 4000df38: 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); 4000df3c: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED 4000df40: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 4000df44: 02 bf ff ef be 4000df00 <_Heap_Resize_block+0x38> <== NOT EXECUTED 4000df48: aa 08 7f fe and %g1, -2, %l5 <== NOT EXECUTED !_Heap_Is_prev_used(next_block)) return HEAP_RESIZE_FATAL_ERROR; next_block_size = _Heap_Block_size(next_block); next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || 4000df4c: 80 a0 80 11 cmp %g2, %l1 <== NOT EXECUTED 4000df50: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED 4000df54: 02 80 00 04 be 4000df64 <_Heap_Resize_block+0x9c> <== NOT EXECUTED 4000df58: ba 04 40 15 add %l1, %l5, %i5 <== NOT EXECUTED 4000df5c: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED 4000df60: 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) 4000df64: 82 24 40 19 sub %l1, %i1, %g1 <== NOT EXECUTED 4000df68: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 4000df6c: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED if (size > old_user_size) { 4000df70: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED 4000df74: 1a 80 00 16 bcc 4000dfcc <_Heap_Resize_block+0x104> <== NOT EXECUTED 4000df78: 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 */ 4000df7c: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 4000df80: 12 80 00 10 bne 4000dfc0 <_Heap_Resize_block+0xf8> <== NOT EXECUTED 4000df84: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 4000df88: 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; 4000df8c: 40 00 21 a1 call 40016610 <.urem> <== NOT EXECUTED 4000df90: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED *value = r ? v - r + a : v; 4000df94: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000df98: 02 80 00 05 be 4000dfac <_Heap_Resize_block+0xe4> <== NOT EXECUTED 4000df9c: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED 4000dfa0: 82 04 00 13 add %l0, %l3, %g1 <== NOT EXECUTED 4000dfa4: a0 20 40 08 sub %g1, %o0, %l0 <== NOT EXECUTED 4000dfa8: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED 4000dfac: 0a 80 00 1d bcs 4000e020 <_Heap_Resize_block+0x158> <== NOT EXECUTED 4000dfb0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Heap_Align_up(&add_block_size, page_size); if (add_block_size < min_block_size) add_block_size = min_block_size; if (add_block_size > next_block_size) 4000dfb4: 80 a5 40 08 cmp %l5, %o0 <== NOT EXECUTED 4000dfb8: 1a 80 00 1f bcc 4000e034 <_Heap_Resize_block+0x16c> <== NOT EXECUTED 4000dfbc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 4000dfc0: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED } 4000dfc4: 81 c7 e0 08 ret <== NOT EXECUTED 4000dfc8: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED --stats->used_blocks; } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 4000dfcc: a0 20 40 1a sub %g1, %i2, %l0 <== NOT EXECUTED uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 4000dfd0: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 4000dfd4: 40 00 21 8f call 40016610 <.urem> <== NOT EXECUTED 4000dfd8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 4000dfdc: a0 a4 00 08 subcc %l0, %o0, %l0 <== NOT EXECUTED 4000dfe0: 22 80 00 0b be,a 4000e00c <_Heap_Resize_block+0x144> <== NOT EXECUTED 4000dfe4: 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; 4000dfe8: 86 25 00 10 sub %l4, %l0, %g3 <== NOT EXECUTED if (new_block_size < min_block_size) { 4000dfec: 80 a5 c0 03 cmp %l7, %g3 <== NOT EXECUTED 4000dff0: 08 80 00 1c bleu 4000e060 <_Heap_Resize_block+0x198> <== NOT EXECUTED 4000dff4: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 4000dff8: 82 25 c0 03 sub %l7, %g3, %g1 <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 4000dffc: a0 a4 00 01 subcc %l0, %g1, %l0 <== NOT EXECUTED 4000e000: 32 80 00 17 bne,a 4000e05c <_Heap_Resize_block+0x194> <== NOT EXECUTED 4000e004: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 4000e008: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 4000e00c: 84 10 20 00 clr %g2 <== NOT EXECUTED 4000e010: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000e014: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } 4000e018: 81 c7 e0 08 ret <== NOT EXECUTED 4000e01c: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 4000e020: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED else { uint32_t add_block_size = size - old_user_size; _Heap_Align_up(&add_block_size, page_size); if (add_block_size < min_block_size) add_block_size = min_block_size; if (add_block_size > next_block_size) 4000e024: 80 a5 40 08 cmp %l5, %o0 <== NOT EXECUTED 4000e028: 0a bf ff e7 bcs 4000dfc4 <_Heap_Resize_block+0xfc> <== NOT EXECUTED 4000e02c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 4000e030: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4000e034: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 4000e038: 7f ff e9 78 call 40008618 <_Heap_Block_allocate> <== NOT EXECUTED 4000e03c: 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; 4000e040: 90 02 00 14 add %o0, %l4, %o0 <== NOT EXECUTED 4000e044: 90 12 00 1b or %o0, %i3, %o0 <== NOT EXECUTED 4000e048: d0 24 a0 04 st %o0, [ %l2 + 4 ] <== NOT EXECUTED --stats->used_blocks; 4000e04c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED 4000e050: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000e054: 10 bf ff ed b 4000e008 <_Heap_Resize_block+0x140> <== NOT EXECUTED 4000e058: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED _HAssert(new_block_size >= min_block_size); _HAssert(new_block_size + free_block_size == old_block_size); _HAssert(_Heap_Is_aligned(new_block_size, page_size)); _HAssert(_Heap_Is_aligned(free_block_size, page_size)); if (!next_is_used) { 4000e05c: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 4000e060: 12 80 00 15 bne 4000e0b4 <_Heap_Resize_block+0x1ec> <== NOT EXECUTED 4000e064: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED Heap_Block *const new_next_block = _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 4000e068: 82 10 c0 1b or %g3, %i3, %g1 <== NOT EXECUTED 4000e06c: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 4000e070: 86 04 80 03 add %l2, %g3, %g3 <== NOT EXECUTED if (!next_is_used) { /* Extend the next block to the low addresses by 'free_block_size' */ Heap_Block *const new_next_block = _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; 4000e074: 88 04 00 15 add %l0, %l5, %g4 <== NOT EXECUTED Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; 4000e078: d8 04 60 0c ld [ %l1 + 0xc ], %o4 <== NOT EXECUTED _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; new_next_block->size = new_next_block_size | HEAP_PREV_USED; next_next_block->prev_size = new_next_block_size; 4000e07c: c8 27 40 00 st %g4, [ %i5 ] <== NOT EXECUTED Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; 4000e080: da 04 60 08 ld [ %l1 + 8 ], %o5 <== NOT EXECUTED _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; new_next_block->size = new_next_block_size | HEAP_PREV_USED; 4000e084: 84 11 20 01 or %g4, 1, %g2 <== NOT EXECUTED 4000e088: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; _Heap_Block_replace(next_block, new_next_block); the_heap->stats.free_size += free_block_size; 4000e08c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED Heap_Block *prev = block->prev; block = new_block; block->next = next; 4000e090: da 20 e0 08 st %o5, [ %g3 + 8 ] <== NOT EXECUTED 4000e094: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED block->prev = prev; 4000e098: d8 20 e0 0c st %o4, [ %g3 + 0xc ] <== NOT EXECUTED 4000e09c: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 4000e0a0: 88 01 3f fc add %g4, -4, %g4 <== NOT EXECUTED next->prev = prev->next = block; 4000e0a4: c6 23 60 0c st %g3, [ %o5 + 0xc ] <== NOT EXECUTED 4000e0a8: c6 23 20 08 st %g3, [ %o4 + 8 ] <== NOT EXECUTED 4000e0ac: 10 bf ff d7 b 4000e008 <_Heap_Resize_block+0x140> <== NOT EXECUTED 4000e0b0: c8 27 00 00 st %g4, [ %i4 ] <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 4000e0b4: 2a bf ff d6 bcs,a 4000e00c <_Heap_Resize_block+0x144> <== NOT EXECUTED 4000e0b8: 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; 4000e0bc: 82 10 c0 1b or %g3, %i3, %g1 <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 4000e0c0: 84 14 20 01 or %l0, 1, %g2 <== NOT EXECUTED the_heap->stats.free_size += free_block_size; *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; } else if (free_block_size >= min_block_size) { /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; 4000e0c4: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 4000e0c8: 92 04 80 03 add %l2, %g3, %o1 <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 4000e0cc: c4 22 60 04 st %g2, [ %o1 + 4 ] <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 4000e0d0: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000e0d4: 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 */ 4000e0d8: 82 00 60 01 inc %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000e0dc: 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 */ 4000e0e0: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000e0e4: c4 26 20 50 st %g2, [ %i0 + 0x50 ] <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 4000e0e8: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 4000e0ec: 7f ff e8 d8 call 4000844c <_Heap_Free> <== NOT EXECUTED 4000e0f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 4000e0f4: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED 4000e0f8: 10 bf ff c4 b 4000e008 <_Heap_Resize_block+0x140> <== NOT EXECUTED 4000e0fc: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED 4000e100 <_Heap_Size_of_user_area>: boolean _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 4000e100: 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( 4000e104: e0 06 20 20 ld [ %i0 + 0x20 ], %l0 <== NOT EXECUTED 4000e108: 80 a6 40 10 cmp %i1, %l0 <== NOT EXECUTED 4000e10c: 0a 80 00 05 bcs 4000e120 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000e110: e2 06 20 24 ld [ %i0 + 0x24 ], %l1 <== NOT EXECUTED 4000e114: 80 a6 40 11 cmp %i1, %l1 <== NOT EXECUTED 4000e118: 28 80 00 04 bleu,a 4000e128 <_Heap_Size_of_user_area+0x28> <== NOT EXECUTED 4000e11c: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 <== NOT EXECUTED *size = _Addresses_Subtract ( next_block, starting_address ) + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); } 4000e120: 81 c7 e0 08 ret <== NOT EXECUTED 4000e124: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED /* The address passed could be greater than the block address plus * HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user * pointers. To get rid of this offset we need to align the address down * to the nearest 'page_size' boundary. */ _Heap_Align_down_uptr ( &addr, the_heap->page_size ); *the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET); 4000e128: 40 00 21 3a call 40016610 <.urem> <== NOT EXECUTED 4000e12c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4000e130: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 4000e134: 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 ) ) 4000e138: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 4000e13c: 0a bf ff f9 bcs 4000e120 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000e140: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 4000e144: 18 bf ff f7 bgu 4000e120 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000e148: 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 ); 4000e14c: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4000e150: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 4000e154: 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 ( 4000e158: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 4000e15c: 0a bf ff f1 bcs 4000e120 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000e160: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 4000e164: 18 bf ff ef bgu 4000e120 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000e168: 01 00 00 00 nop <== NOT EXECUTED 4000e16c: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4000e170: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 4000e174: 02 bf ff eb be 4000e120 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000e178: 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 ) 4000e17c: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED 4000e180: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 4000e184: 81 c7 e0 08 ret <== NOT EXECUTED 4000e188: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED 40007be4 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 40007be4: 9d e3 bf 98 save %sp, -104, %sp /* * If the user claims there are less drivers than are actually in * the table, then let's just go with the table's count. */ if ( number_of_drivers <= drivers_in_table ) 40007be8: 80 a6 80 19 cmp %i2, %i1 40007bec: 08 80 00 27 bleu 40007c88 <_IO_Manager_initialization+0xa4> 40007bf0: 03 10 00 6c sethi %hi(0x4001b000), %g1 /* * The application requested extra slots in the driver table, so we * have to allocate a new driver table and copy theirs to it. */ _IO_Driver_address_table = (rtems_driver_address_table *) 40007bf4: 83 2e a0 03 sll %i2, 3, %g1 <== NOT EXECUTED 40007bf8: a1 2e a0 05 sll %i2, 5, %l0 <== NOT EXECUTED 40007bfc: a0 24 00 01 sub %l0, %g1, %l0 <== NOT EXECUTED 40007c00: 40 00 0f ab call 4000baac <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 40007c04: 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; 40007c08: 03 10 00 6c sethi %hi(0x4001b000), %g1 <== NOT EXECUTED memset( 40007c0c: 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; 40007c10: f4 20 60 f4 st %i2, [ %g1 + 0xf4 ] <== 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 *) 40007c14: 21 10 00 6c sethi %hi(0x4001b000), %l0 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 40007c18: 92 10 20 00 clr %o1 <== NOT EXECUTED 40007c1c: 40 00 1f aa call 4000fac4 <== NOT EXECUTED 40007c20: d0 24 20 f8 st %o0, [ %l0 + 0xf8 ] <== NOT EXECUTED _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 40007c24: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40007c28: 02 80 00 16 be 40007c80 <_IO_Manager_initialization+0x9c> <== NOT EXECUTED 40007c2c: d4 04 20 f8 ld [ %l0 + 0xf8 ], %o2 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40007c30: 96 10 20 00 clr %o3 <== NOT EXECUTED 40007c34: 98 10 20 00 clr %o4 <== NOT EXECUTED 40007c38: c2 03 00 18 ld [ %o4 + %i0 ], %g1 <== NOT EXECUTED 40007c3c: 9a 03 00 18 add %o4, %i0, %o5 <== NOT EXECUTED 40007c40: c2 23 00 0a st %g1, [ %o4 + %o2 ] <== NOT EXECUTED 40007c44: c4 03 60 04 ld [ %o5 + 4 ], %g2 <== NOT EXECUTED 40007c48: 86 03 00 0a add %o4, %o2, %g3 <== NOT EXECUTED 40007c4c: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED 40007c50: c2 03 60 08 ld [ %o5 + 8 ], %g1 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 40007c54: 96 02 e0 01 inc %o3 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40007c58: c2 20 e0 08 st %g1, [ %g3 + 8 ] <== NOT EXECUTED 40007c5c: c4 03 60 0c ld [ %o5 + 0xc ], %g2 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 40007c60: 98 03 20 18 add %o4, 0x18, %o4 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40007c64: c4 20 e0 0c st %g2, [ %g3 + 0xc ] <== NOT EXECUTED 40007c68: c8 03 60 10 ld [ %o5 + 0x10 ], %g4 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 40007c6c: 80 a2 c0 19 cmp %o3, %i1 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40007c70: c8 20 e0 10 st %g4, [ %g3 + 0x10 ] <== NOT EXECUTED 40007c74: c2 03 60 14 ld [ %o5 + 0x14 ], %g1 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 40007c78: 12 bf ff f0 bne 40007c38 <_IO_Manager_initialization+0x54> <== NOT EXECUTED 40007c7c: c2 20 e0 14 st %g1, [ %g3 + 0x14 ] <== NOT EXECUTED 40007c80: 81 c7 e0 08 ret <== NOT EXECUTED 40007c84: 81 e8 00 00 restore <== NOT EXECUTED * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; _IO_Number_of_drivers = number_of_drivers; 40007c88: 05 10 00 6c sethi %hi(0x4001b000), %g2 * If the maximum number of driver is the same as the number in the * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; 40007c8c: f0 20 60 f8 st %i0, [ %g1 + 0xf8 ] _IO_Number_of_drivers = number_of_drivers; 40007c90: f2 20 a0 f4 st %i1, [ %g2 + 0xf4 ] 40007c94: 81 c7 e0 08 ret 40007c98: 81 e8 00 00 restore 4000888c <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 4000888c: 9d e3 bf 98 save %sp, -104, %sp _ISR_Signals_to_thread_executing = FALSE; 40008890: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _ISR_Nest_level = 0; 40008894: 05 10 00 6b sethi %hi(0x4001ac00), %g2 * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { _ISR_Signals_to_thread_executing = FALSE; 40008898: c0 20 63 18 clr [ %g1 + 0x318 ] _ISR_Nest_level = 0; 4000889c: c0 20 a2 54 clr [ %g2 + 0x254 ] _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 400088a0: 40 00 0c 83 call 4000baac <_Workspace_Allocate_or_fatal_error> 400088a4: 90 10 24 00 mov 0x400, %o0 _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 400088a8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400088ac: a0 10 61 a4 or %g1, 0x1a4, %l0 ! 4001ada4 <_CPU_Table> 400088b0: 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( 400088b4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 400088b8: 80 a0 af ff cmp %g2, 0xfff 400088bc: 18 80 00 07 bgu 400088d8 <_ISR_Handler_initialization+0x4c> 400088c0: d0 20 62 34 st %o0, [ %g1 + 0x234 ] _Internal_error_Occurred( 400088c4: 90 10 20 00 clr %o0 <== NOT EXECUTED 400088c8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400088cc: 7f ff ff e0 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 400088d0: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED 400088d4: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 400088d8: 40 00 0c 75 call 4000baac <_Workspace_Allocate_or_fatal_error> 400088dc: 90 10 00 02 mov %g2, %o0 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 400088e0: c6 04 20 18 ld [ %l0 + 0x18 ], %g3 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 400088e4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 400088e8: 86 02 00 03 add %o0, %g3, %g3 400088ec: 05 10 00 6b sethi %hi(0x4001ac00), %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 400088f0: d0 20 61 a0 st %o0, [ %g1 + 0x1a0 ] _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 400088f4: c6 20 a0 ec st %g3, [ %g2 + 0xec ] #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 400088f8: 81 c7 e0 08 ret 400088fc: 81 e8 00 00 restore 4000e19c <_Objects_Compare_name_string>: boolean _Objects_Compare_name_string( void *name_1, void *name_2, uint16_t length ) { 4000e19c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if ( !strncmp( name_1, name_2, length ) ) 4000e1a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000e1a4: 95 2e a0 10 sll %i2, 0x10, %o2 <== NOT EXECUTED 4000e1a8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000e1ac: 40 00 09 42 call 400106b4 <== NOT EXECUTED 4000e1b0: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED return TRUE; return FALSE; } 4000e1b4: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 4000e1b8: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 4000e1bc: 81 c7 e0 08 ret <== NOT EXECUTED 4000e1c0: 81 e8 00 00 restore <== NOT EXECUTED 4001a53c <_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; 4001a53c: 95 32 a0 02 srl %o2, 2, %o2 <== NOT EXECUTED while ( tmp_length-- ) 4001a540: 80 a2 a0 00 cmp %o2, 0 <== NOT EXECUTED 4001a544: 02 80 00 09 be 4001a568 <_Objects_Copy_name_raw+0x2c> <== NOT EXECUTED 4001a548: 86 10 20 00 clr %g3 <== NOT EXECUTED 4001a54c: 84 10 20 00 clr %g2 <== NOT EXECUTED *destination_p++ = *source_p++; 4001a550: c2 00 80 08 ld [ %g2 + %o0 ], %g1 <== NOT EXECUTED 4001a554: 86 00 e0 01 inc %g3 <== NOT EXECUTED 4001a558: c2 20 80 09 st %g1, [ %g2 + %o1 ] <== NOT EXECUTED { uint32_t *source_p = (uint32_t *) source; uint32_t *destination_p = (uint32_t *) destination; size_t tmp_length = length / OBJECTS_NAME_ALIGNMENT; while ( tmp_length-- ) 4001a55c: 80 a0 c0 0a cmp %g3, %o2 <== NOT EXECUTED 4001a560: 12 bf ff fc bne 4001a550 <_Objects_Copy_name_raw+0x14> <== NOT EXECUTED 4001a564: 84 00 a0 04 add %g2, 4, %g2 <== NOT EXECUTED 4001a568: 81 c3 e0 08 retl <== NOT EXECUTED 4001a56c: 01 00 00 00 nop 400089b4 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 400089b4: 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; 400089b8: 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 ) 400089bc: e4 16 20 10 lduh [ %i0 + 0x10 ], %l2 400089c0: 03 00 00 3f sethi %hi(0xfc00), %g1 400089c4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400089c8: a2 08 80 01 and %g2, %g1, %l1 400089cc: 80 a4 40 12 cmp %l1, %l2 400089d0: 08 80 00 8c bleu 40008c00 <_Objects_Extend_information+0x24c> 400089d4: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 400089d8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; if ( information->maximum < minimum_index ) 400089dc: a8 10 00 11 mov %l1, %l4 400089e0: ac 10 20 00 clr %l6 400089e4: a6 10 20 01 mov 1, %l3 400089e8: 90 10 20 03 mov 3, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 400089ec: 80 a0 60 00 cmp %g1, 0 400089f0: 12 80 00 a4 bne 40008c80 <_Objects_Extend_information+0x2cc> 400089f4: ba 04 00 12 add %l0, %l2, %i5 if ( !object_blocks ) return; } else { object_blocks = (void**) 400089f8: 90 02 00 11 add %o0, %l1, %o0 400089fc: 90 02 00 1d add %o0, %i5, %o0 40008a00: 40 00 0c 2b call 4000baac <_Workspace_Allocate_or_fatal_error> 40008a04: 91 2a 20 02 sll %o0, 2, %o0 40008a08: ae 10 00 08 mov %o0, %l7 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 40008a0c: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 40008a10: 83 2c e0 02 sll %l3, 2, %g1 /* * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; 40008a14: 86 04 ff ff add %l3, -1, %g3 if ( information->maximum > minimum_index ) { 40008a18: 80 a4 40 02 cmp %l1, %g2 /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 40008a1c: a6 05 c0 01 add %l7, %g1, %l3 object_blocks, block_count * sizeof(void*) ); name_table = (Objects_Name *) _Addresses_Add_offset( 40008a20: aa 00 40 13 add %g1, %l3, %l5 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 40008a24: 0a 80 00 ac bcs 40008cd4 <_Objects_Extend_information+0x320> 40008a28: a4 00 40 15 add %g1, %l5, %l2 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 40008a2c: 80 a4 60 00 cmp %l1, 0 40008a30: 02 80 00 09 be 40008a54 <_Objects_Extend_information+0xa0> 40008a34: a1 28 e0 02 sll %g3, 2, %l0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 40008a38: 84 10 20 00 clr %g2 /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 40008a3c: 83 28 a0 02 sll %g2, 2, %g1 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 40008a40: 84 00 a0 01 inc %g2 40008a44: 80 a0 80 11 cmp %g2, %l1 40008a48: 12 bf ff fd bne 40008a3c <_Objects_Extend_information+0x88> 40008a4c: c0 20 40 12 clr [ %g1 + %l2 ] 40008a50: a1 28 e0 02 sll %g3, 2, %l0 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 40008a54: c0 24 00 17 clr [ %l0 + %l7 ] inactive_per_block[block_count] = 0; 40008a58: c0 24 00 13 clr [ %l0 + %l3 ] name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); 40008a5c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40008a60: 86 05 00 01 add %l4, %g1, %g3 40008a64: 80 a0 c0 14 cmp %g3, %l4 40008a68: 08 80 00 0a bleu 40008a90 <_Objects_Extend_information+0xdc> 40008a6c: c0 25 40 10 clr [ %l5 + %l0 ] 40008a70: 83 2d 20 02 sll %l4, 2, %g1 40008a74: 84 04 80 01 add %l2, %g1, %g2 40008a78: 82 10 00 14 mov %l4, %g1 index++ ) { local_table[ index ] = NULL; 40008a7c: c0 20 80 00 clr [ %g2 ] inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 40008a80: 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 ); 40008a84: 80 a0 40 03 cmp %g1, %g3 40008a88: 12 bf ff fd bne 40008a7c <_Objects_Extend_information+0xc8> 40008a8c: 84 00 a0 04 add %g2, 4, %g2 index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 40008a90: 7f ff e5 4f call 40001fcc 40008a94: 01 00 00 00 nop information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 40008a98: c4 06 00 00 ld [ %i0 ], %g2 40008a9c: c8 16 20 04 lduh [ %i0 + 4 ], %g4 40008aa0: 87 2f 60 10 sll %i5, 0x10, %g3 40008aa4: 89 29 20 1b sll %g4, 0x1b, %g4 40008aa8: 87 30 e0 10 srl %g3, 0x10, %g3 local_table[ index ] = NULL; } _ISR_Disable( level ); old_tables = information->object_blocks; 40008aac: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 40008ab0: 03 00 00 40 sethi %hi(0x10000), %g1 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; 40008ab4: e6 26 20 38 st %l3, [ %i0 + 0x38 ] information->name_table = name_table; 40008ab8: ea 26 20 24 st %l5, [ %i0 + 0x24 ] information->local_table = local_table; 40008abc: e4 26 20 20 st %l2, [ %i0 + 0x20 ] information->maximum = maximum; information->maximum_id = _Objects_Build_id( 40008ac0: 85 28 a0 18 sll %g2, 0x18, %g2 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; 40008ac4: fa 36 20 10 sth %i5, [ %i0 + 0x10 ] information->maximum_id = _Objects_Build_id( 40008ac8: 84 10 80 01 or %g2, %g1, %g2 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; 40008acc: ee 26 20 3c st %l7, [ %i0 + 0x3c ] information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 40008ad0: 84 10 80 04 or %g2, %g4, %g2 40008ad4: 84 10 80 03 or %g2, %g3, %g2 40008ad8: c4 26 20 0c st %g2, [ %i0 + 0xc ] information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 40008adc: 7f ff e5 40 call 40001fdc 40008ae0: 01 00 00 00 nop if ( old_tables ) 40008ae4: 80 a4 20 00 cmp %l0, 0 40008ae8: 02 80 00 05 be 40008afc <_Objects_Extend_information+0x148> 40008aec: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 40008af0: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40008af4: 7f ff fe 56 call 4000844c <_Heap_Free> 40008af8: 90 12 21 dc or %o0, 0x1dc, %o0 ! 4001addc <_Workspace_Area> /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 40008afc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40008b00: 80 a0 60 00 cmp %g1, 0 40008b04: 02 80 00 6a be 40008cac <_Objects_Extend_information+0x2f8> 40008b08: c2 16 20 44 lduh [ %i0 + 0x44 ], %g1 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 40008b0c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40008b10: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 information->object_blocks[ block ] = 40008b14: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 40008b18: 40 00 35 d8 call 40016278 <.umul> 40008b1c: 90 00 40 08 add %g1, %o0, %o0 40008b20: 92 10 00 08 mov %o0, %o1 40008b24: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40008b28: 7f ff fe 17 call 40008384 <_Heap_Allocate> 40008b2c: 90 12 21 dc or %o0, 0x1dc, %o0 ! 4001addc <_Workspace_Area> _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 40008b30: e4 06 20 3c ld [ %i0 + 0x3c ], %l2 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { information->object_blocks[ block ] = 40008b34: a7 2d a0 02 sll %l6, 2, %l3 40008b38: d0 24 c0 10 st %o0, [ %l3 + %l0 ] _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 40008b3c: c2 04 c0 12 ld [ %l3 + %l2 ], %g1 40008b40: 80 a0 60 00 cmp %g1, 0 40008b44: 02 80 00 7b be 40008d30 <_Objects_Extend_information+0x37c> 40008b48: 01 00 00 00 nop 40008b4c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40008b50: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 40008b54: 40 00 35 c9 call 40016278 <.umul> 40008b58: a2 10 00 14 mov %l4, %l1 40008b5c: c2 04 80 13 ld [ %l2 + %l3 ], %g1 name_area = (Objects_Name *) _Addresses_Add_offset( information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 40008b60: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 40008b64: a0 02 00 01 add %o0, %g1, %l0 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 40008b68: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 name_area = (Objects_Name *) _Addresses_Add_offset( information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 40008b6c: e0 20 80 13 st %l0, [ %g2 + %l3 ] /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 40008b70: d6 06 20 1c ld [ %i0 + 0x1c ], %o3 40008b74: d2 04 80 13 ld [ %l2 + %l3 ], %o1 40008b78: a8 07 bf ec add %fp, -20, %l4 index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 40008b7c: 2b 00 00 40 sethi %hi(0x10000), %l5 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 40008b80: 90 10 00 14 mov %l4, %o0 40008b84: 40 00 14 6d call 4000dd38 <_Chain_Initialize> 40008b88: a4 06 20 28 add %i0, 0x28, %l2 40008b8c: 30 80 00 0f b,a 40008bc8 <_Objects_Extend_information+0x214> index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 40008b90: c4 16 20 04 lduh [ %i0 + 4 ], %g2 40008b94: c6 16 20 44 lduh [ %i0 + 0x44 ], %g3 40008b98: 83 28 60 18 sll %g1, 0x18, %g1 40008b9c: 85 28 a0 1b sll %g2, 0x1b, %g2 40008ba0: 82 10 40 15 or %g1, %l5, %g1 40008ba4: 82 10 40 02 or %g1, %g2, %g1 40008ba8: 82 10 40 11 or %g1, %l1, %g1 information->the_class, _Objects_Local_node, index ); the_object->name = (void *) name_area; 40008bac: e0 22 20 0c st %l0, [ %o0 + 0xc ] index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 40008bb0: c2 22 20 08 st %g1, [ %o0 + 8 ] the_object->name = (void *) name_area; name_area = _Addresses_Add_offset( name_area, information->name_length ); _Chain_Append( &information->Inactive, &the_object->Node ); 40008bb4: 92 10 00 08 mov %o0, %o1 40008bb8: a0 04 00 03 add %l0, %g3, %l0 index++; 40008bbc: a2 04 60 01 inc %l1 the_object->name = (void *) name_area; name_area = _Addresses_Add_offset( name_area, information->name_length ); _Chain_Append( &information->Inactive, &the_object->Node ); 40008bc0: 7f ff fc a0 call 40007e40 <_Chain_Append> 40008bc4: 90 10 00 12 mov %l2, %o0 * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 40008bc8: 7f ff fc aa call 40007e70 <_Chain_Get> 40008bcc: 90 10 00 14 mov %l4, %o0 40008bd0: 80 a2 20 00 cmp %o0, 0 40008bd4: 32 bf ff ef bne,a 40008b90 <_Objects_Extend_information+0x1dc> 40008bd8: c2 06 00 00 ld [ %i0 ], %g1 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 40008bdc: c6 06 20 38 ld [ %i0 + 0x38 ], %g3 40008be0: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 information->inactive += information->allocation_size; 40008be4: c8 16 20 34 lduh [ %i0 + 0x34 ], %g4 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 40008be8: c4 20 c0 13 st %g2, [ %g3 + %l3 ] information->inactive += information->allocation_size; 40008bec: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40008bf0: 82 00 40 04 add %g1, %g4, %g1 40008bf4: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 40008bf8: 81 c7 e0 08 ret 40008bfc: 81 e8 00 00 restore block = 0; if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; 40008c00: 90 10 00 12 mov %l2, %o0 40008c04: 40 00 35 d7 call 40016360 <.udiv> 40008c08: 92 10 00 10 mov %l0, %o1 for ( ; block < block_count; block++ ) { 40008c0c: 80 a2 20 00 cmp %o0, 0 40008c10: 02 80 00 46 be 40008d28 <_Objects_Extend_information+0x374> 40008c14: a8 10 00 11 mov %l1, %l4 if ( information->object_blocks[ block ] == NULL ) 40008c18: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 40008c1c: c2 00 80 00 ld [ %g2 ], %g1 40008c20: 80 a0 60 00 cmp %g1, 0 40008c24: 12 80 00 08 bne 40008c44 <_Objects_Extend_information+0x290> 40008c28: ac 10 20 00 clr %l6 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 40008c2c: 10 80 00 0c b 40008c5c <_Objects_Extend_information+0x2a8> <== NOT EXECUTED 40008c30: 80 a5 00 12 cmp %l4, %l2 <== NOT EXECUTED block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 40008c34: c2 00 40 02 ld [ %g1 + %g2 ], %g1 40008c38: 80 a0 60 00 cmp %g1, 0 40008c3c: 02 80 00 08 be 40008c5c <_Objects_Extend_information+0x2a8> 40008c40: 80 a5 00 12 cmp %l4, %l2 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 40008c44: ac 05 a0 01 inc %l6 if ( information->object_blocks[ block ] == NULL ) break; else index_base += information->allocation_size; 40008c48: a8 05 00 10 add %l4, %l0, %l4 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 40008c4c: 80 a5 80 08 cmp %l6, %o0 40008c50: 12 bf ff f9 bne 40008c34 <_Objects_Extend_information+0x280> 40008c54: 83 2d a0 02 sll %l6, 2, %g1 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 40008c58: 80 a5 00 12 cmp %l4, %l2 40008c5c: 2a bf ff a9 bcs,a 40008b00 <_Objects_Extend_information+0x14c> 40008c60: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40008c64: a6 02 20 01 add %o0, 1, %l3 40008c68: 83 2c e0 01 sll %l3, 1, %g1 40008c6c: 90 00 40 13 add %g1, %l3, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 40008c70: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40008c74: 80 a0 60 00 cmp %g1, 0 40008c78: 02 bf ff 60 be 400089f8 <_Objects_Extend_information+0x44> 40008c7c: ba 04 00 12 add %l0, %l2, %i5 40008c80: 92 02 00 11 add %o0, %l1, %o1 40008c84: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40008c88: 92 02 40 1d add %o1, %i5, %o1 40008c8c: 90 12 21 dc or %o0, 0x1dc, %o0 40008c90: 7f ff fd bd call 40008384 <_Heap_Allocate> 40008c94: 93 2a 60 02 sll %o1, 2, %o1 block_count * (sizeof(void *) + sizeof(uint32_t ) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 40008c98: ae 92 20 00 orcc %o0, 0, %l7 40008c9c: 32 bf ff 5d bne,a 40008a10 <_Objects_Extend_information+0x5c> 40008ca0: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 40008ca4: 81 c7 e0 08 ret <== NOT EXECUTED 40008ca8: 81 e8 00 00 restore <== NOT EXECUTED if ( !information->object_blocks[ block ] ) return; } else { information->object_blocks[ block ] = 40008cac: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 40008cb0: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40008cb4: 40 00 35 71 call 40016278 <.umul> 40008cb8: 90 00 40 08 add %g1, %o0, %o0 40008cbc: 40 00 0b 7c call 4000baac <_Workspace_Allocate_or_fatal_error> 40008cc0: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 40008cc4: e4 06 20 3c ld [ %i0 + 0x3c ], %l2 40008cc8: a7 2d a0 02 sll %l6, 2, %l3 40008ccc: 10 bf ff a0 b 40008b4c <_Objects_Extend_information+0x198> 40008cd0: d0 24 c0 10 st %o0, [ %l3 + %l0 ] /* * Copy each section of the table over. This has to be performed as * separate parts as size of each block has changed. */ memcpy( object_blocks, 40008cd4: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 40008cd8: a1 28 e0 02 sll %g3, 2, %l0 40008cdc: 90 10 00 17 mov %l7, %o0 40008ce0: 40 00 1b 4c call 4000fa10 40008ce4: 94 10 00 10 mov %l0, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 40008ce8: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 40008cec: 94 10 00 10 mov %l0, %o2 40008cf0: 40 00 1b 48 call 4000fa10 40008cf4: 90 10 00 13 mov %l3, %o0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, 40008cf8: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 40008cfc: 94 10 00 10 mov %l0, %o2 40008d00: 40 00 1b 44 call 4000fa10 40008d04: 90 10 00 15 mov %l5, %o0 information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 40008d08: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 40008d0c: d2 06 20 20 ld [ %i0 + 0x20 ], %o1 40008d10: 94 02 80 11 add %o2, %l1, %o2 40008d14: 90 10 00 12 mov %l2, %o0 40008d18: 40 00 1b 3e call 4000fa10 40008d1c: 95 2a a0 02 sll %o2, 2, %o2 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 40008d20: 10 bf ff 4e b 40008a58 <_Objects_Extend_information+0xa4> 40008d24: c0 24 00 17 clr [ %l0 + %l7 ] if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 40008d28: 10 bf ff cc b 40008c58 <_Objects_Extend_information+0x2a4> <== NOT EXECUTED 40008d2c: ac 10 20 00 clr %l6 <== NOT EXECUTED 40008d30: 81 c7 e0 08 ret <== NOT EXECUTED 40008d34: 81 e8 00 00 restore <== NOT EXECUTED 40008dcc <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 40008dcc: 9d e3 bf 98 save %sp, -104, %sp Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 40008dd0: c2 06 20 08 ld [ %i0 + 8 ], %g1 _ISR_Disable( level ); 40008dd4: 7f ff e4 7e call 40001fcc 40008dd8: b2 26 40 01 sub %i1, %g1, %i1 { Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 40008ddc: b2 06 60 01 inc %i1 _ISR_Disable( level ); if ( information->maximum >= index ) { 40008de0: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 40008de4: 80 a6 40 01 cmp %i1, %g1 40008de8: 18 80 00 0b bgu 40008e14 <_Objects_Get_isr_disable+0x48> 40008dec: 83 2e 60 02 sll %i1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 40008df0: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 40008df4: f0 00 80 01 ld [ %g2 + %g1 ], %i0 40008df8: 80 a6 20 00 cmp %i0, 0 40008dfc: 02 80 00 0c be 40008e2c <_Objects_Get_isr_disable+0x60> 40008e00: 01 00 00 00 nop *location = OBJECTS_LOCAL; *level_p = level; 40008e04: 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; 40008e08: c0 26 80 00 clr [ %i2 ] 40008e0c: 81 c7 e0 08 ret 40008e10: 81 e8 00 00 restore } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 40008e14: 7f ff e4 72 call 40001fdc 40008e18: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; 40008e1c: 82 10 20 02 mov 2, %g1 40008e20: c2 26 80 00 st %g1, [ %i2 ] _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 40008e24: 81 c7 e0 08 ret 40008e28: 81 e8 00 00 restore if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; *level_p = level; return the_object; } _ISR_Enable( level ); 40008e2c: 7f ff e4 6c call 40001fdc <== NOT EXECUTED 40008e30: 01 00 00 00 nop <== NOT EXECUTED *location = OBJECTS_ERROR; 40008e34: 82 10 20 02 mov 2, %g1 ! 2 <== NOT EXECUTED 40008e38: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 40008e3c: 81 c7 e0 08 ret <== NOT EXECUTED 40008e40: 81 e8 00 00 restore <== NOT EXECUTED 4000a8e0 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 4000a8e0: 9d e3 bf 88 save %sp, -120, %sp 4000a8e4: 92 10 00 18 mov %i0, %o1 uint32_t i; char lname[5]; Objects_Control *the_object; Objects_Locations location; if ( length == 0 ) 4000a8e8: 80 a6 60 00 cmp %i1, 0 4000a8ec: 12 80 00 04 bne 4000a8fc <_Objects_Get_name_as_string+0x1c> 4000a8f0: b0 10 00 1a mov %i2, %i0 _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 4000a8f4: 81 c7 e0 08 ret <== NOT EXECUTED 4000a8f8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED Objects_Locations location; if ( length == 0 ) return NULL; if ( name == NULL ) 4000a8fc: 80 a6 a0 00 cmp %i2, 0 4000a900: 02 80 00 40 be 4000aa00 <_Objects_Get_name_as_string+0x120> 4000a904: 87 32 60 16 srl %o1, 0x16, %g3 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 4000a908: 03 10 00 9c sethi %hi(0x40027000), %g1 4000a90c: 86 08 e0 1c and %g3, 0x1c, %g3 4000a910: 82 10 62 c0 or %g1, 0x2c0, %g1 4000a914: c8 00 40 03 ld [ %g1 + %g3 ], %g4 4000a918: 85 32 60 1b srl %o1, 0x1b, %g2 4000a91c: 85 28 a0 02 sll %g2, 2, %g2 4000a920: f4 01 00 02 ld [ %g4 + %g2 ], %i2 return NULL; information = _Objects_Get_information( id ); if ( !information ) 4000a924: 80 a6 a0 00 cmp %i2, 0 4000a928: 22 80 00 36 be,a 4000aa00 <_Objects_Get_name_as_string+0x120> 4000a92c: b0 10 20 00 clr %i0 <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, id, &location ); 4000a930: 90 10 00 1a mov %i2, %o0 4000a934: 40 00 00 3f call 4000aa30 <_Objects_Get> 4000a938: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 4000a93c: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000a940: 80 a0 60 00 cmp %g1, 0 4000a944: 32 80 00 2f bne,a 4000aa00 <_Objects_Get_name_as_string+0x120> 4000a948: b0 10 20 00 clr %i0 <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 4000a94c: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1 4000a950: 80 a0 60 00 cmp %g1, 0 4000a954: 22 80 00 2d be,a 4000aa08 <_Objects_Get_name_as_string+0x128> 4000a958: c2 02 20 0c ld [ %o0 + 0xc ], %g1 s = the_object->name; 4000a95c: d0 02 20 0c ld [ %o0 + 0xc ], %o0 lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { 4000a960: 80 a6 60 01 cmp %i1, 1 4000a964: 02 80 00 1c be 4000a9d4 <_Objects_Get_name_as_string+0xf4> 4000a968: 9a 10 00 18 mov %i0, %o5 4000a96c: c8 0a 00 00 ldub [ %o0 ], %g4 4000a970: 85 29 20 18 sll %g4, 0x18, %g2 4000a974: 80 a0 a0 00 cmp %g2, 0 4000a978: 22 80 00 18 be,a 4000a9d8 <_Objects_Get_name_as_string+0xf8> 4000a97c: c0 2b 40 00 clrb [ %o5 ] <== NOT EXECUTED 4000a980: b2 06 7f ff add %i1, -1, %i1 4000a984: 98 10 20 00 clr %o4 4000a988: 10 80 00 07 b 4000a9a4 <_Objects_Get_name_as_string+0xc4> 4000a98c: 17 10 00 7b sethi %hi(0x4001ec00), %o3 4000a990: c8 0a 00 00 ldub [ %o0 ], %g4 4000a994: 85 29 20 18 sll %g4, 0x18, %g2 4000a998: 80 a0 a0 00 cmp %g2, 0 4000a99c: 22 80 00 0f be,a 4000a9d8 <_Objects_Get_name_as_string+0xf8> 4000a9a0: c0 2b 40 00 clrb [ %o5 ] <== NOT EXECUTED *d = (!isprint(*s)) ? '*' : *s; 4000a9a4: c2 02 e0 38 ld [ %o3 + 0x38 ], %g1 4000a9a8: 85 38 a0 18 sra %g2, 0x18, %g2 4000a9ac: c6 48 80 01 ldsb [ %g2 + %g1 ], %g3 4000a9b0: 80 88 e0 97 btst 0x97, %g3 4000a9b4: 12 80 00 03 bne 4000a9c0 <_Objects_Get_name_as_string+0xe0> 4000a9b8: 90 02 20 01 inc %o0 4000a9bc: 88 10 20 2a mov 0x2a, %g4 <== NOT EXECUTED 4000a9c0: c8 2b 40 00 stb %g4, [ %o5 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { 4000a9c4: 98 03 20 01 inc %o4 4000a9c8: 80 a3 00 19 cmp %o4, %i1 4000a9cc: 12 bf ff f1 bne 4000a990 <_Objects_Get_name_as_string+0xb0> 4000a9d0: 9a 03 60 01 inc %o5 *d = (!isprint(*s)) ? '*' : *s; } *d = '\0'; 4000a9d4: c0 2b 40 00 clrb [ %o5 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000a9d8: 03 10 00 9c sethi %hi(0x40027000), %g1 4000a9dc: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40027360 <_Thread_Dispatch_disable_level> 4000a9e0: 84 00 bf ff add %g2, -1, %g2 4000a9e4: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 4000a9e8: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 4000a9ec: 80 a0 e0 00 cmp %g3, 0 4000a9f0: 12 80 00 04 bne 4000aa00 <_Objects_Get_name_as_string+0x120> 4000a9f4: 01 00 00 00 nop _Thread_Dispatch(); 4000a9f8: 40 00 04 fa call 4000bde0 <_Thread_Dispatch> 4000a9fc: 01 00 00 00 nop 4000aa00: 81 c7 e0 08 ret 4000aa04: 81 e8 00 00 restore lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 4000aa08: c0 2f bf f3 clrb [ %fp + -13 ] if ( information->is_string ) { s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; 4000aa0c: 85 30 60 18 srl %g1, 0x18, %g2 lname[ 1 ] = (u32_name >> 16) & 0xff; 4000aa10: 87 30 60 10 srl %g1, 0x10, %g3 lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; 4000aa14: c2 2f bf f2 stb %g1, [ %fp + -14 ] if ( information->is_string ) { s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; 4000aa18: c4 2f bf ef stb %g2, [ %fp + -17 ] lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 4000aa1c: 83 30 60 08 srl %g1, 8, %g1 s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; 4000aa20: c6 2f bf f0 stb %g3, [ %fp + -16 ] lname[ 2 ] = (u32_name >> 8) & 0xff; 4000aa24: c2 2f bf f1 stb %g1, [ %fp + -15 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 4000aa28: 10 bf ff ce b 4000a960 <_Objects_Get_name_as_string+0x80> 4000aa2c: 90 07 bf ef add %fp, -17, %o0 4001a570 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 4001a570: 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) 4001a574: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 4001a578: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <== NOT EXECUTED 4001a57c: 80 8e 40 01 btst %i1, %g1 <== NOT EXECUTED 4001a580: 22 80 00 02 be,a 4001a588 <_Objects_Get_next+0x18> <== NOT EXECUTED 4001a584: 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) 4001a588: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 4001a58c: a0 10 63 ff or %g1, 0x3ff, %l0 ! ffff <== NOT EXECUTED 4001a590: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED 4001a594: 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); 4001a598: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001a59c: 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) 4001a5a0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 4001a5a4: 18 80 00 0b bgu 4001a5d0 <_Objects_Get_next+0x60> <== NOT EXECUTED 4001a5a8: 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); 4001a5ac: 7f ff d6 bb call 40010098 <_Objects_Get> <== NOT EXECUTED 4001a5b0: b2 06 60 01 inc %i1 <== NOT EXECUTED next_id++; } while (*location_p != OBJECTS_LOCAL); 4001a5b4: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 4001a5b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001a5bc: 32 bf ff f6 bne,a 4001a594 <_Objects_Get_next+0x24> <== NOT EXECUTED 4001a5c0: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED *next_id_p = next_id; 4001a5c4: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 4001a5c8: 81 c7 e0 08 ret <== NOT EXECUTED 4001a5cc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 4001a5d0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 4001a5d4: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED 4001a5d8: 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; 4001a5dc: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 4001a5e0: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED return 0; } 4001a5e4: 81 c7 e0 08 ret <== NOT EXECUTED 4001a5e8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 4001663c <_Objects_Get_no_protection>: ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 4001663c: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->maximum >= index ) { 40016640: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 40016644: 92 22 40 01 sub %o1, %g1, %o1 40016648: 82 02 60 01 add %o1, 1, %g1 if ( information->maximum >= index ) { 4001664c: 80 a0 40 02 cmp %g1, %g2 40016650: 18 80 00 09 bgu 40016674 <_Objects_Get_no_protection+0x38> 40016654: 83 28 60 02 sll %g1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 40016658: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4001665c: d0 00 80 01 ld [ %g2 + %g1 ], %o0 40016660: 80 a2 20 00 cmp %o0, 0 40016664: 02 80 00 08 be 40016684 <_Objects_Get_no_protection+0x48> 40016668: 82 10 20 02 mov 2, %g1 *location = OBJECTS_LOCAL; 4001666c: 81 c3 e0 08 retl 40016670: c0 22 80 00 clr [ %o2 ] return the_object; } *location = OBJECTS_ERROR; return NULL; } *location = OBJECTS_ERROR; 40016674: 82 10 20 02 mov 2, %g1 40016678: 90 10 20 00 clr %o0 /* * Not supported for multiprocessing */ return NULL; } 4001667c: 81 c3 e0 08 retl 40016680: c2 22 80 00 st %g1, [ %o2 ] if ( information->maximum >= index ) { if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; return the_object; } *location = OBJECTS_ERROR; 40016684: 81 c3 e0 08 retl <== NOT EXECUTED 40016688: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED 400090a8 <_Objects_Handler_initialization>: uint32_t node, uint32_t maximum_nodes, uint32_t maximum_global_objects ) { if ( node < 1 || node > maximum_nodes ) 400090a8: 80 a2 20 00 cmp %o0, 0 400090ac: 22 80 00 07 be,a 400090c8 <_Objects_Handler_initialization+0x20> 400090b0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400090b4: 80 a2 00 09 cmp %o0, %o1 400090b8: 18 80 00 04 bgu 400090c8 <_Objects_Handler_initialization+0x20> 400090bc: 90 10 20 00 clr %o0 400090c0: 81 c3 e0 08 retl 400090c4: 01 00 00 00 nop _Internal_error_Occurred( 400090c8: 92 10 20 01 mov 1, %o1 ! 1 <== NOT EXECUTED 400090cc: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED 400090d0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 400090d4: 7f ff fd de call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 400090d8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 400090dc: 01 00 00 00 nop 4000a3dc <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 4000a3dc: 9d e3 bf 90 save %sp, -112, %sp 4000a3e0: 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 ) 4000a3e4: 80 a6 60 00 cmp %i1, 0 4000a3e8: 02 80 00 24 be 4000a478 <_Objects_Id_to_name+0x9c> 4000a3ec: 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); 4000a3f0: 83 32 60 18 srl %o1, 0x18, %g1 4000a3f4: 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 ) 4000a3f8: 80 a0 60 04 cmp %g1, 4 4000a3fc: 18 80 00 25 bgu 4000a490 <_Objects_Id_to_name+0xb4> 4000a400: 87 28 60 02 sll %g1, 2, %g3 return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( id ); information = _Objects_Information_table[ the_api ][ the_class ]; 4000a404: 03 10 00 7c sethi %hi(0x4001f000), %g1 4000a408: 82 10 60 20 or %g1, 0x20, %g1 ! 4001f020 <_Objects_Information_table> 4000a40c: c8 00 40 03 ld [ %g1 + %g3 ], %g4 4000a410: 85 32 60 1b srl %o1, 0x1b, %g2 4000a414: 85 28 a0 02 sll %g2, 2, %g2 4000a418: d0 01 00 02 ld [ %g4 + %g2 ], %o0 if ( !information ) 4000a41c: 80 a2 20 00 cmp %o0, 0 4000a420: 02 80 00 1c be 4000a490 <_Objects_Id_to_name+0xb4> 4000a424: 01 00 00 00 nop return OBJECTS_INVALID_ID; if ( information->is_string ) 4000a428: c2 02 20 40 ld [ %o0 + 0x40 ], %g1 4000a42c: 80 a0 60 00 cmp %g1, 0 4000a430: 12 80 00 18 bne 4000a490 <_Objects_Id_to_name+0xb4> 4000a434: 01 00 00 00 nop return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, id, &ignored_location ); 4000a438: 7f ff ff c2 call 4000a340 <_Objects_Get> 4000a43c: 94 07 bf f4 add %fp, -12, %o2 if ( !the_object ) 4000a440: 80 a2 20 00 cmp %o0, 0 4000a444: 02 80 00 13 be 4000a490 <_Objects_Id_to_name+0xb4> 4000a448: 01 00 00 00 nop return OBJECTS_INVALID_ID; *name = the_object->name; 4000a44c: c2 02 20 0c ld [ %o0 + 0xc ], %g1 4000a450: 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 ) 4000a454: 07 10 00 7c sethi %hi(0x4001f000), %g3 4000a458: c2 00 e0 c0 ld [ %g3 + 0xc0 ], %g1 ! 4001f0c0 <_Thread_Dispatch_disable_level> 4000a45c: b0 10 20 00 clr %i0 4000a460: 82 00 7f ff add %g1, -1, %g1 4000a464: c2 20 e0 c0 st %g1, [ %g3 + 0xc0 ] 4000a468: c4 00 e0 c0 ld [ %g3 + 0xc0 ], %g2 4000a46c: 80 a0 a0 00 cmp %g2, 0 4000a470: 02 80 00 04 be 4000a480 <_Objects_Id_to_name+0xa4> 4000a474: 01 00 00 00 nop _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 4000a478: 81 c7 e0 08 ret <== NOT EXECUTED 4000a47c: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4000a480: 40 00 05 07 call 4000b89c <_Thread_Dispatch> 4000a484: 01 00 00 00 nop 4000a488: 81 c7 e0 08 ret 4000a48c: 81 e8 00 00 restore 4000a490: 81 c7 e0 08 ret <== NOT EXECUTED 4000a494: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED 40008ee0 <_Objects_Initialize_information>: , boolean supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 40008ee0: 9d e3 bf 98 save %sp, -104, %sp /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 40008ee4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40008ee8: 85 2e 60 02 sll %i1, 2, %g2 40008eec: 82 10 60 f0 or %g1, 0xf0, %g1 40008ef0: c8 00 40 02 ld [ %g1 + %g2 ], %g4 , boolean supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 40008ef4: de 07 a0 5c ld [ %fp + 0x5c ], %o7 /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; 40008ef8: 83 36 e0 1f srl %i3, 0x1f, %g1 maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 40008efc: 05 20 00 00 sethi %hi(0x80000000), %g2 /* * Set the size of the object */ information->size = size; 40008f00: b9 2f 20 10 sll %i4, 0x10, %i4 40008f04: b9 37 20 10 srl %i4, 0x10, %i4 uint32_t index; #endif information->the_api = the_api; information->the_class = the_class; information->is_string = is_string; 40008f08: fa 26 20 40 st %i5, [ %i0 + 0x40 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40008f0c: 87 2e 60 18 sll %i1, 0x18, %g3 40008f10: bb 2e a0 1b sll %i2, 0x1b, %i5 /* * Set the size of the object */ information->size = size; 40008f14: f8 26 20 1c st %i4, [ %i0 + 0x1c ] #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; information->the_class = the_class; 40008f18: f4 36 20 04 sth %i2, [ %i0 + 4 ] /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 40008f1c: b8 2e c0 02 andn %i3, %g2, %i4 /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 40008f20: b5 2e a0 02 sll %i2, 2, %i2 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40008f24: 80 a0 00 1c cmp %g0, %i4 /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 40008f28: f0 21 00 1a st %i0, [ %g4 + %i2 ] /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; 40008f2c: c2 26 20 14 st %g1, [ %i0 + 0x14 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40008f30: 88 40 20 00 addx %g0, 0, %g4 /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 40008f34: 03 10 00 6a sethi %hi(0x4001a800), %g1 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40008f38: 05 00 00 40 sethi %hi(0x10000), %g2 /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 40008f3c: 82 10 63 70 or %g1, 0x370, %g1 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40008f40: 86 10 c0 02 or %g3, %g2, %g3 /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 40008f44: c2 26 20 20 st %g1, [ %i0 + 0x20 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40008f48: 86 10 c0 1d or %g3, %i5, %g3 uint32_t name_length; #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; 40008f4c: f2 26 00 00 st %i1, [ %i0 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40008f50: 86 10 c0 04 or %g3, %g4, %g3 information->the_api = the_api; information->the_class = the_class; information->is_string = is_string; information->local_table = 0; information->name_table = 0; 40008f54: c0 26 20 24 clr [ %i0 + 0x24 ] information->inactive_per_block = 0; 40008f58: c0 26 20 38 clr [ %i0 + 0x38 ] information->object_blocks = 0; 40008f5c: c0 26 20 3c clr [ %i0 + 0x3c ] information->inactive = 0; 40008f60: c0 36 20 34 clrh [ %i0 + 0x34 ] /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 40008f64: f8 26 20 18 st %i4, [ %i0 + 0x18 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40008f68: c6 26 20 08 st %g3, [ %i0 + 8 ] * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) 40008f6c: 80 8b e0 03 btst 3, %o7 40008f70: 02 80 00 04 be 40008f80 <_Objects_Initialize_information+0xa0> 40008f74: 82 10 00 0f mov %o7, %g1 name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 40008f78: 82 03 e0 04 add %o7, 4, %g1 <== NOT EXECUTED 40008f7c: 82 08 7f fc and %g1, -4, %g1 <== NOT EXECUTED ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 40008f80: c2 36 20 44 sth %g1, [ %i0 + 0x44 ] Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40008f84: 84 06 20 28 add %i0, 0x28, %g2 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40008f88: 82 06 20 2c add %i0, 0x2c, %g1 the_chain->permanent_null = NULL; 40008f8c: 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); 40008f90: c2 26 20 28 st %g1, [ %i0 + 0x28 ] /* * Initialize objects .. if there are any */ if ( maximum ) { 40008f94: 80 a7 20 00 cmp %i4, 0 40008f98: 12 80 00 04 bne 40008fa8 <_Objects_Initialize_information+0xc8> 40008f9c: c4 26 20 30 st %g2, [ %i0 + 0x30 ] 40008fa0: 81 c7 e0 08 ret 40008fa4: 81 e8 00 00 restore /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 40008fa8: 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 ); 40008fac: 7f ff fe 82 call 400089b4 <_Objects_Extend_information> 40008fb0: 81 e8 00 00 restore 40008fb4: 01 00 00 00 nop 40008fb8 <_Objects_Name_to_id>: Objects_Information *information, Objects_Name name, uint32_t node, Objects_Id *id ) { 40008fb8: 9d e3 bf 98 save %sp, -104, %sp 40008fbc: 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 ) 40008fc0: 80 a6 e0 00 cmp %i3, 0 40008fc4: 02 80 00 2d be 40009078 <_Objects_Name_to_id+0xc0> 40008fc8: b0 10 20 02 mov 2, %i0 return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 40008fcc: 80 a6 60 00 cmp %i1, 0 40008fd0: 02 80 00 28 be 40009070 <_Objects_Name_to_id+0xb8> 40008fd4: 01 00 00 00 nop return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40008fd8: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 40008fdc: 86 90 60 00 orcc %g1, 0, %g3 40008fe0: 02 80 00 24 be 40009070 <_Objects_Name_to_id+0xb8> 40008fe4: 80 a6 a0 00 cmp %i2, 0 40008fe8: 12 80 00 26 bne 40009080 <_Objects_Name_to_id+0xc8> 40008fec: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; 40008ff0: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 40008ff4: 05 10 00 38 sethi %hi(0x4000e000), %g2 40008ff8: 80 a0 60 00 cmp %g1, 0 40008ffc: a4 10 a1 8c or %g2, 0x18c, %l2 40009000: 02 80 00 04 be 40009010 <_Objects_Name_to_id+0x58> 40009004: c8 14 60 44 lduh [ %l1 + 0x44 ], %g4 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40009008: 03 10 00 38 sethi %hi(0x4000e000), %g1 <== NOT EXECUTED 4000900c: a4 10 61 9c or %g1, 0x19c, %l2 ! 4000e19c <_Objects_Compare_name_string> <== NOT EXECUTED for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; if ( !the_object || !the_object->name ) continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 40009010: 83 29 20 10 sll %g4, 0x10, %g1 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40009014: 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 ) ) { 40009018: 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 ]; 4000901c: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 40009020: 83 2c 20 02 sll %l0, 2, %g1 40009024: f4 00 80 01 ld [ %g2 + %g1 ], %i2 if ( !the_object || !the_object->name ) 40009028: 80 a6 a0 00 cmp %i2, 0 4000902c: 02 80 00 0c be 4000905c <_Objects_Name_to_id+0xa4> 40009030: a0 04 20 01 inc %l0 40009034: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 40009038: 80 a2 60 00 cmp %o1, 0 4000903c: 02 80 00 08 be 4000905c <_Objects_Name_to_id+0xa4> 40009040: 90 10 00 19 mov %i1, %o0 continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 40009044: 9f c4 80 00 call %l2 40009048: 94 10 00 18 mov %i0, %o2 4000904c: 80 a2 20 00 cmp %o0, 0 40009050: 32 80 00 13 bne,a 4000909c <_Objects_Name_to_id+0xe4> 40009054: c2 06 a0 08 ld [ %i2 + 8 ], %g1 40009058: c6 14 60 10 lduh [ %l1 + 0x10 ], %g3 name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; else compare_them = _Objects_Compare_name_raw; for ( index = 1; index <= information->maximum; index++ ) { 4000905c: 83 28 e0 10 sll %g3, 0x10, %g1 40009060: 83 30 60 10 srl %g1, 0x10, %g1 40009064: 80 a0 40 10 cmp %g1, %l0 40009068: 3a bf ff ee bcc,a 40009020 <_Objects_Name_to_id+0x68> 4000906c: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 40009070: 81 c7 e0 08 ret 40009074: 91 e8 20 01 restore %g0, 1, %o0 return ( _Objects_MP_Global_name_search( information, name, node, id ) ); #else return OBJECTS_INVALID_NAME; #endif } 40009078: 81 c7 e0 08 ret <== NOT EXECUTED 4000907c: 81 e8 00 00 restore <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40009080: 82 10 63 ff or %g1, 0x3ff, %g1 40009084: 80 a6 80 01 cmp %i2, %g1 40009088: 02 bf ff da be 40008ff0 <_Objects_Name_to_id+0x38> 4000908c: 80 a6 a0 01 cmp %i2, 1 40009090: 22 bf ff d9 be,a 40008ff4 <_Objects_Name_to_id+0x3c> 40009094: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 40009098: 30 bf ff f6 b,a 40009070 <_Objects_Name_to_id+0xb8> the_object = information->local_table[ index ]; if ( !the_object || !the_object->name ) continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { *id = the_object->id; 4000909c: c2 26 c0 00 st %g1, [ %i3 ] 400090a0: 81 c7 e0 08 ret 400090a4: 91 e8 20 00 restore %g0, 0, %o0 400090e0 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 400090e0: 9d e3 bf 98 save %sp, -104, %sp 400090e4: 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; 400090e8: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 400090ec: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0 400090f0: 03 00 00 3f sethi %hi(0xfc00), %g1 400090f4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400090f8: 92 10 00 10 mov %l0, %o1 400090fc: a2 08 80 01 and %g2, %g1, %l1 40009100: 40 00 34 98 call 40016360 <.udiv> 40009104: 90 22 00 11 sub %o0, %l1, %o0 for ( block = 0; block < block_count; block++ ) { 40009108: 80 a2 20 00 cmp %o0, 0 4000910c: 02 80 00 15 be 40009160 <_Objects_Shrink_information+0x80> 40009110: 86 10 20 00 clr %g3 if ( information->inactive_per_block[ block ] == information->allocation_size ) { 40009114: c8 06 20 38 ld [ %i0 + 0x38 ], %g4 40009118: c2 01 00 00 ld [ %g4 ], %g1 4000911c: 84 10 20 04 mov 4, %g2 40009120: 80 a4 00 01 cmp %l0, %g1 40009124: a8 10 20 00 clr %l4 40009128: 12 80 00 0a bne 40009150 <_Objects_Shrink_information+0x70> 4000912c: a4 10 20 00 clr %l2 /* * XXX - Not to sure how to use a chain where you need to iterate and * and remove elements. */ the_object = (Objects_Control *) information->Inactive.first; 40009130: 10 80 00 10 b 40009170 <_Objects_Shrink_information+0x90> <== NOT EXECUTED 40009134: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 <== NOT EXECUTED information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 40009138: a2 04 40 10 add %l1, %l0, %l1 index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == information->allocation_size ) { 4000913c: 80 a4 00 01 cmp %l0, %g1 information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 40009140: a4 10 00 02 mov %g2, %l2 index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == information->allocation_size ) { 40009144: 02 80 00 09 be 40009168 <_Objects_Shrink_information+0x88> 40009148: 82 00 a0 04 add %g2, 4, %g1 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; return; 4000914c: 84 10 00 01 mov %g1, %g2 */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 40009150: 86 00 e0 01 inc %g3 40009154: 80 a0 c0 08 cmp %g3, %o0 40009158: 32 bf ff f8 bne,a 40009138 <_Objects_Shrink_information+0x58> 4000915c: c2 00 80 04 ld [ %g2 + %g4 ], %g1 40009160: 81 c7 e0 08 ret 40009164: 81 e8 00 00 restore if ( information->inactive_per_block[ block ] == information->allocation_size ) { 40009168: a8 10 00 02 mov %g2, %l4 /* * XXX - Not to sure how to use a chain where you need to iterate and * and remove elements. */ the_object = (Objects_Control *) information->Inactive.first; 4000916c: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 40009170: 03 00 00 3f sethi %hi(0xfc00), %g1 40009174: e0 02 00 00 ld [ %o0 ], %l0 40009178: 10 80 00 10 b 400091b8 <_Objects_Shrink_information+0xd8> 4000917c: a6 10 63 ff or %g1, 0x3ff, %l3 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 40009180: 82 04 40 01 add %l1, %g1, %g1 40009184: 80 a0 80 01 cmp %g2, %g1 40009188: 3a 80 00 12 bcc,a 400091d0 <_Objects_Shrink_information+0xf0> 4000918c: 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 ); 40009190: 40 00 12 e0 call 4000dd10 <_Chain_Extract> 40009194: 01 00 00 00 nop 40009198: 90 10 00 10 mov %l0, %o0 } else { the_object = (Objects_Control *) the_object->Node.next; } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 4000919c: 80 a2 20 00 cmp %o0, 0 400091a0: 22 80 00 10 be,a 400091e0 <_Objects_Shrink_information+0x100> 400091a4: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_last( const Chain_Node *the_node ) { return (the_node->next == NULL); 400091a8: e0 02 00 00 ld [ %o0 ], %l0 400091ac: 80 a4 20 00 cmp %l0, 0 400091b0: 22 80 00 0c be,a 400091e0 <_Objects_Shrink_information+0x100> 400091b4: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 400091b8: c2 02 20 08 ld [ %o0 + 8 ], %g1 400091bc: 84 08 40 13 and %g1, %l3, %g2 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 400091c0: 80 a0 80 11 cmp %g2, %l1 400091c4: 3a bf ff ef bcc,a 40009180 <_Objects_Shrink_information+0xa0> 400091c8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 400091cc: 90 10 00 10 mov %l0, %o0 } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 400091d0: 80 a2 20 00 cmp %o0, 0 400091d4: 32 bf ff f6 bne,a 400091ac <_Objects_Shrink_information+0xcc> 400091d8: e0 02 00 00 ld [ %o0 ], %l0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 400091dc: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED 400091e0: 11 10 00 6b sethi %hi(0x4001ac00), %o0 400091e4: d2 00 40 14 ld [ %g1 + %l4 ], %o1 400091e8: 7f ff fc 99 call 4000844c <_Heap_Free> 400091ec: 90 12 21 dc or %o0, 0x1dc, %o0 */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 400091f0: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 400091f4: c8 06 20 24 ld [ %i0 + 0x24 ], %g4 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 400091f8: c0 24 80 02 clr [ %l2 + %g2 ] information->inactive -= information->allocation_size; 400091fc: c2 16 20 34 lduh [ %i0 + 0x34 ], %g1 * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; 40009200: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 40009204: c6 06 20 18 ld [ %i0 + 0x18 ], %g3 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 40009208: c0 25 00 04 clr [ %l4 + %g4 ] information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 4000920c: 82 20 40 03 sub %g1, %g3, %g1 * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; 40009210: c0 25 00 02 clr [ %l4 + %g2 ] information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 40009214: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 40009218: 81 c7 e0 08 ret 4000921c: 81 e8 00 00 restore 40009220 <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 40009220: 9d e3 bf 98 save %sp, -104, %sp void *p; _RTEMS_Lock_allocator(); 40009224: 7f ff e3 6a call 40001fcc 40009228: 01 00 00 00 nop 4000922c: a4 10 00 08 mov %o0, %l2 40009230: 23 10 00 6b sethi %hi(0x4001ac00), %l1 40009234: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> 40009238: 80 a0 60 00 cmp %g1, 0 4000923c: 02 80 00 0b be 40009268 <_Protected_heap_Allocate+0x48> 40009240: 27 10 00 6b sethi %hi(0x4001ac00), %l3 40009244: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40009248: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 4001af70 <_System_state_Current> 4000924c: 80 a0 a0 01 cmp %g2, 1 40009250: 08 80 00 06 bleu 40009268 <_Protected_heap_Allocate+0x48> 40009254: 90 10 20 00 clr %o0 40009258: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000925c: 7f ff fd 7c call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 40009260: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40009264: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40009268: 09 10 00 6b sethi %hi(0x4001ac00), %g4 4000926c: e0 04 e2 64 ld [ %l3 + 0x264 ], %l0 40009270: c4 01 22 6c ld [ %g4 + 0x26c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40009274: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40009278: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 4000927c: 80 a0 60 00 cmp %g1, 0 40009280: 22 80 00 27 be,a 4000931c <_Protected_heap_Allocate+0xfc> 40009284: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40009288: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 4000928c: 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; 40009290: 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; 40009294: 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; 40009298: 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; 4000929c: 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 ) || 400092a0: 80 a0 e0 02 cmp %g3, 2 400092a4: 12 80 00 2d bne 40009358 <_Protected_heap_Allocate+0x138> 400092a8: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400092ac: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400092b0: 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++; 400092b4: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400092b8: 02 80 00 46 be 400093d0 <_Protected_heap_Allocate+0x1b0> 400092bc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 400092c0: 7f ff e3 47 call 40001fdc 400092c4: 90 10 00 12 mov %l2, %o0 p = _Heap_Allocate( the_heap, size ); 400092c8: 90 10 00 18 mov %i0, %o0 400092cc: 7f ff fc 2e call 40008384 <_Heap_Allocate> 400092d0: 92 10 00 19 mov %i1, %o1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400092d4: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 400092d8: b0 10 00 08 mov %o0, %i0 400092dc: 82 00 60 01 inc %g1 400092e0: c2 24 61 90 st %g1, [ %l1 + 0x190 ] _RTEMS_Unlock_allocator(); 400092e4: d0 04 e2 64 ld [ %l3 + 0x264 ], %o0 400092e8: 94 10 20 00 clr %o2 400092ec: d2 02 20 08 ld [ %o0 + 8 ], %o1 400092f0: 7f ff fb 54 call 40008040 <_CORE_mutex_Surrender> 400092f4: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400092f8: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 400092fc: 82 00 7f ff add %g1, -1, %g1 40009300: c2 24 61 90 st %g1, [ %l1 + 0x190 ] 40009304: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 40009308: 80 a0 a0 00 cmp %g2, 0 4000930c: 02 80 00 2d be 400093c0 <_Protected_heap_Allocate+0x1a0> 40009310: 01 00 00 00 nop return p; } 40009314: 81 c7 e0 08 ret 40009318: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 4000931c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40009320: 12 80 00 16 bne 40009378 <_Protected_heap_Allocate+0x158> <== NOT EXECUTED 40009324: c6 04 e2 64 ld [ %l3 + 0x264 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40009328: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 4000932c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009330: 22 80 00 43 be,a 4000943c <_Protected_heap_Allocate+0x21c> <== NOT EXECUTED 40009334: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40009338: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000933c: 12 80 00 0f bne 40009378 <_Protected_heap_Allocate+0x158> <== NOT EXECUTED 40009340: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40009344: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40009348: 7f ff e3 25 call 40001fdc <== NOT EXECUTED 4000934c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { void *p; _RTEMS_Lock_allocator(); p = _Heap_Allocate( the_heap, size ); 40009350: 10 bf ff df b 400092cc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40009354: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40009358: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 4000935c: 12 bf ff d9 bne 400092c0 <_Protected_heap_Allocate+0xa0> <== NOT EXECUTED 40009360: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40009364: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40009368: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000936c: 02 80 00 19 be 400093d0 <_Protected_heap_Allocate+0x1b0> <== NOT EXECUTED 40009370: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40009374: 30 bf ff d3 b,a 400092c0 <_Protected_heap_Allocate+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009378: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED size_t size ) { void *p; _RTEMS_Lock_allocator(); 4000937c: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40009380: c8 01 22 6c ld [ %g4 + 0x26c ], %g4 <== NOT EXECUTED 40009384: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009388: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 4000938c: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40009390: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 40009394: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40009398: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 4000939c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 400093a0: 7f ff e3 0f call 40001fdc <== NOT EXECUTED 400093a4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400093a8: d0 04 e2 64 ld [ %l3 + 0x264 ], %o0 <== NOT EXECUTED 400093ac: 92 10 20 00 clr %o1 <== NOT EXECUTED 400093b0: 7f ff fb 00 call 40007fb0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 400093b4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 400093b8: 10 bf ff c5 b 400092cc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 400093bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 400093c0: 40 00 03 c9 call 4000a2e4 <_Thread_Dispatch> 400093c4: 01 00 00 00 nop 400093c8: 81 c7 e0 08 ret 400093cc: 81 e8 00 00 restore */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 400093d0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 400093d4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 400093d8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 400093dc: 02 80 00 28 be 4000947c <_Protected_heap_Allocate+0x25c> <== NOT EXECUTED 400093e0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 400093e4: 1a 80 00 1c bcc 40009454 <_Protected_heap_Allocate+0x234> <== NOT EXECUTED 400093e8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400093ec: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 400093f0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400093f4: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 400093f8: 7f ff e2 f9 call 40001fdc <== NOT EXECUTED 400093fc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40009400: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40009404: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40009408: 40 00 02 93 call 40009e54 <_Thread_Change_priority> <== NOT EXECUTED 4000940c: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40009410: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009414: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40009418: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 4000941c: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 <== NOT EXECUTED 40009420: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40009424: 32 bf ff aa bne,a 400092cc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40009428: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000942c: 40 00 03 ae call 4000a2e4 <_Thread_Dispatch> <== NOT EXECUTED 40009430: 01 00 00 00 nop <== NOT EXECUTED 40009434: 10 bf ff a6 b 400092cc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40009438: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 4000943c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009440: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40009444: 7f ff e2 e6 call 40001fdc <== NOT EXECUTED 40009448: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000944c: 10 bf ff a0 b 400092cc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40009450: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40009454: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40009458: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4000945c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40009460: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40009464: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40009468: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000946c: 7f ff e2 dc call 40001fdc <== NOT EXECUTED 40009470: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009474: 10 bf ff 96 b 400092cc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40009478: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 4000947c: 7f ff e2 d8 call 40001fdc <== NOT EXECUTED 40009480: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009484: 10 bf ff 92 b 400092cc <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40009488: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000948c <_Protected_heap_Extend>: boolean _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 4000948c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 40009490: 7f ff e2 cf call 40001fcc <== NOT EXECUTED 40009494: 01 00 00 00 nop <== NOT EXECUTED 40009498: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 4000949c: 23 10 00 6b sethi %hi(0x4001ac00), %l1 <== NOT EXECUTED 400094a0: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400094a4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400094a8: 02 80 00 0b be 400094d4 <_Protected_heap_Extend+0x48> <== NOT EXECUTED 400094ac: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED 400094b0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 400094b4: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 4001af70 <_System_state_Current> <== NOT EXECUTED 400094b8: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 400094bc: 08 80 00 06 bleu 400094d4 <_Protected_heap_Extend+0x48> <== NOT EXECUTED 400094c0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400094c4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400094c8: 7f ff fc e1 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 400094cc: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400094d0: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400094d4: 09 10 00 6b sethi %hi(0x4001ac00), %g4 <== NOT EXECUTED 400094d8: e0 04 e2 64 ld [ %l3 + 0x264 ], %l0 <== NOT EXECUTED 400094dc: c4 01 22 6c ld [ %g4 + 0x26c ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 400094e0: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 400094e4: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 400094e8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400094ec: 22 80 00 2d be,a 400095a0 <_Protected_heap_Extend+0x114> <== NOT EXECUTED 400094f0: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 400094f4: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400094f8: 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; 400094fc: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 40009500: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40009504: 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; 40009508: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4000950c: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 40009510: 12 80 00 33 bne 400095dc <_Protected_heap_Extend+0x150> <== NOT EXECUTED 40009514: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40009518: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000951c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40009520: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40009524: 02 80 00 48 be 40009644 <_Protected_heap_Extend+0x1b8> <== NOT EXECUTED 40009528: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000952c: 7f ff e2 ac call 40001fdc <== NOT EXECUTED 40009530: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 40009534: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009538: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000953c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40009540: 40 00 12 2f call 4000ddfc <_Heap_Extend> <== NOT EXECUTED 40009544: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009548: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 4000954c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 40009550: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009554: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 40009558: d0 04 e2 64 ld [ %l3 + 0x264 ], %o0 <== NOT EXECUTED 4000955c: 94 10 20 00 clr %o2 <== NOT EXECUTED 40009560: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40009564: 7f ff fa b7 call 40008040 <_CORE_mutex_Surrender> <== NOT EXECUTED 40009568: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000956c: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009570: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40009574: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40009578: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 <== NOT EXECUTED 4000957c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40009580: 12 80 00 05 bne 40009594 <_Protected_heap_Extend+0x108> <== NOT EXECUTED 40009584: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED _Thread_Dispatch(); 40009588: 40 00 03 57 call 4000a2e4 <_Thread_Dispatch> <== NOT EXECUTED 4000958c: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 40009590: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 40009594: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 40009598: 81 c7 e0 08 ret <== NOT EXECUTED 4000959c: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 400095a0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400095a4: 12 80 00 16 bne 400095fc <_Protected_heap_Extend+0x170> <== NOT EXECUTED 400095a8: c6 04 e2 64 ld [ %l3 + 0x264 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400095ac: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400095b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400095b4: 22 80 00 3f be,a 400096b0 <_Protected_heap_Extend+0x224> <== NOT EXECUTED 400095b8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 400095bc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400095c0: 12 80 00 0f bne 400095fc <_Protected_heap_Extend+0x170> <== NOT EXECUTED 400095c4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 400095c8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400095cc: 7f ff e2 84 call 40001fdc <== NOT EXECUTED 400095d0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 400095d4: 10 bf ff d9 b 40009538 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 400095d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400095dc: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 400095e0: 12 bf ff d3 bne 4000952c <_Protected_heap_Extend+0xa0> <== NOT EXECUTED 400095e4: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400095e8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400095ec: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400095f0: 02 80 00 15 be 40009644 <_Protected_heap_Extend+0x1b8> <== NOT EXECUTED 400095f4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 400095f8: 30 bf ff cd b,a 4000952c <_Protected_heap_Extend+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400095fc: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED ) { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 40009600: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40009604: c8 01 22 6c ld [ %g4 + 0x26c ], %g4 <== NOT EXECUTED 40009608: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000960c: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40009610: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40009614: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40009618: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4000961c: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40009620: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40009624: 7f ff e2 6e call 40001fdc <== NOT EXECUTED 40009628: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000962c: d0 04 e2 64 ld [ %l3 + 0x264 ], %o0 <== NOT EXECUTED 40009630: 92 10 20 00 clr %o1 <== NOT EXECUTED 40009634: 7f ff fa 5f call 40007fb0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40009638: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 4000963c: 10 bf ff bf b 40009538 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 40009640: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40009644: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40009648: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 4000964c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40009650: 02 80 00 28 be 400096f0 <_Protected_heap_Extend+0x264> <== NOT EXECUTED 40009654: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40009658: 1a 80 00 1c bcc 400096c8 <_Protected_heap_Extend+0x23c> <== NOT EXECUTED 4000965c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 40009660: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009664: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009668: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 4000966c: 7f ff e2 5c call 40001fdc <== NOT EXECUTED 40009670: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40009674: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40009678: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 4000967c: 40 00 01 f6 call 40009e54 <_Thread_Change_priority> <== NOT EXECUTED 40009680: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40009684: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009688: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000968c: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40009690: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 <== NOT EXECUTED 40009694: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40009698: 32 bf ff a8 bne,a 40009538 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 4000969c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 400096a0: 40 00 03 11 call 4000a2e4 <_Thread_Dispatch> <== NOT EXECUTED 400096a4: 01 00 00 00 nop <== NOT EXECUTED 400096a8: 10 bf ff a4 b 40009538 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 400096ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 400096b0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400096b4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400096b8: 7f ff e2 49 call 40001fdc <== NOT EXECUTED 400096bc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400096c0: 10 bf ff 9e b 40009538 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 400096c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 400096c8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400096cc: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 400096d0: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 400096d4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400096d8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400096dc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400096e0: 7f ff e2 3f call 40001fdc <== NOT EXECUTED 400096e4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400096e8: 10 bf ff 94 b 40009538 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 400096ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 400096f0: 7f ff e2 3b call 40001fdc <== NOT EXECUTED 400096f4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400096f8: 10 bf ff 90 b 40009538 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 400096fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009700 <_Protected_heap_Free>: boolean _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 40009700: 9d e3 bf 98 save %sp, -104, %sp boolean status; _RTEMS_Lock_allocator(); 40009704: 7f ff e2 32 call 40001fcc 40009708: 01 00 00 00 nop 4000970c: a4 10 00 08 mov %o0, %l2 40009710: 23 10 00 6b sethi %hi(0x4001ac00), %l1 40009714: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> 40009718: 80 a0 60 00 cmp %g1, 0 4000971c: 02 80 00 0b be 40009748 <_Protected_heap_Free+0x48> 40009720: 27 10 00 6b sethi %hi(0x4001ac00), %l3 40009724: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009728: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 4001af70 <_System_state_Current> <== NOT EXECUTED 4000972c: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40009730: 08 80 00 06 bleu 40009748 <_Protected_heap_Free+0x48> <== NOT EXECUTED 40009734: 90 10 20 00 clr %o0 <== NOT EXECUTED 40009738: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000973c: 7f ff fc 44 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 40009740: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40009744: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40009748: 09 10 00 6b sethi %hi(0x4001ac00), %g4 4000974c: e0 04 e2 64 ld [ %l3 + 0x264 ], %l0 40009750: c4 01 22 6c ld [ %g4 + 0x26c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40009754: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40009758: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 4000975c: 80 a0 60 00 cmp %g1, 0 40009760: 22 80 00 27 be,a 400097fc <_Protected_heap_Free+0xfc> 40009764: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40009768: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 4000976c: 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; 40009770: 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; 40009774: 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; 40009778: 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; 4000977c: 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 ) || 40009780: 80 a0 e0 02 cmp %g3, 2 40009784: 12 80 00 2d bne 40009838 <_Protected_heap_Free+0x138> 40009788: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4000978c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40009790: 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++; 40009794: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40009798: 02 80 00 46 be 400098b0 <_Protected_heap_Free+0x1b0> 4000979c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 400097a0: 7f ff e2 0f call 40001fdc 400097a4: 90 10 00 12 mov %l2, %o0 status = _Heap_Free( the_heap, start_address ); 400097a8: 90 10 00 18 mov %i0, %o0 400097ac: 7f ff fb 28 call 4000844c <_Heap_Free> 400097b0: 92 10 00 19 mov %i1, %o1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400097b4: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 400097b8: b0 10 00 08 mov %o0, %i0 400097bc: 82 00 60 01 inc %g1 400097c0: c2 24 61 90 st %g1, [ %l1 + 0x190 ] _RTEMS_Unlock_allocator(); 400097c4: d0 04 e2 64 ld [ %l3 + 0x264 ], %o0 400097c8: 94 10 20 00 clr %o2 400097cc: d2 02 20 08 ld [ %o0 + 8 ], %o1 400097d0: 7f ff fa 1c call 40008040 <_CORE_mutex_Surrender> 400097d4: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400097d8: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 400097dc: 82 00 7f ff add %g1, -1, %g1 400097e0: c2 24 61 90 st %g1, [ %l1 + 0x190 ] 400097e4: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 400097e8: 80 a0 a0 00 cmp %g2, 0 400097ec: 02 80 00 2d be 400098a0 <_Protected_heap_Free+0x1a0> 400097f0: 01 00 00 00 nop return status; } 400097f4: 81 c7 e0 08 ret <== NOT EXECUTED 400097f8: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 400097fc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40009800: 12 80 00 16 bne 40009858 <_Protected_heap_Free+0x158> <== NOT EXECUTED 40009804: c6 04 e2 64 ld [ %l3 + 0x264 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40009808: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 4000980c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009810: 22 80 00 43 be,a 4000991c <_Protected_heap_Free+0x21c> <== NOT EXECUTED 40009814: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40009818: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000981c: 12 80 00 0f bne 40009858 <_Protected_heap_Free+0x158> <== NOT EXECUTED 40009820: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40009824: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40009828: 7f ff e1 ed call 40001fdc <== NOT EXECUTED 4000982c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { boolean status; _RTEMS_Lock_allocator(); status = _Heap_Free( the_heap, start_address ); 40009830: 10 bf ff df b 400097ac <_Protected_heap_Free+0xac> <== NOT EXECUTED 40009834: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40009838: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 4000983c: 12 bf ff d9 bne 400097a0 <_Protected_heap_Free+0xa0> <== NOT EXECUTED 40009840: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40009844: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40009848: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000984c: 02 80 00 19 be 400098b0 <_Protected_heap_Free+0x1b0> <== NOT EXECUTED 40009850: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40009854: 30 bf ff d3 b,a 400097a0 <_Protected_heap_Free+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009858: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED void *start_address ) { boolean status; _RTEMS_Lock_allocator(); 4000985c: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40009860: c8 01 22 6c ld [ %g4 + 0x26c ], %g4 <== NOT EXECUTED 40009864: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009868: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 4000986c: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40009870: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40009874: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40009878: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 4000987c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40009880: 7f ff e1 d7 call 40001fdc <== NOT EXECUTED 40009884: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009888: d0 04 e2 64 ld [ %l3 + 0x264 ], %o0 <== NOT EXECUTED 4000988c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40009890: 7f ff f9 c8 call 40007fb0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40009894: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 40009898: 10 bf ff c5 b 400097ac <_Protected_heap_Free+0xac> <== NOT EXECUTED 4000989c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 400098a0: 40 00 02 91 call 4000a2e4 <_Thread_Dispatch> 400098a4: 01 00 00 00 nop 400098a8: 81 c7 e0 08 ret 400098ac: 81 e8 00 00 restore */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 400098b0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 400098b4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 400098b8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 400098bc: 02 80 00 28 be 4000995c <_Protected_heap_Free+0x25c> <== NOT EXECUTED 400098c0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 400098c4: 1a 80 00 1c bcc 40009934 <_Protected_heap_Free+0x234> <== NOT EXECUTED 400098c8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400098cc: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 400098d0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400098d4: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 400098d8: 7f ff e1 c1 call 40001fdc <== NOT EXECUTED 400098dc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 400098e0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 400098e4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 400098e8: 40 00 01 5b call 40009e54 <_Thread_Change_priority> <== NOT EXECUTED 400098ec: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400098f0: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 400098f4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400098f8: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 400098fc: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 <== NOT EXECUTED 40009900: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40009904: 32 bf ff aa bne,a 400097ac <_Protected_heap_Free+0xac> <== NOT EXECUTED 40009908: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000990c: 40 00 02 76 call 4000a2e4 <_Thread_Dispatch> <== NOT EXECUTED 40009910: 01 00 00 00 nop <== NOT EXECUTED 40009914: 10 bf ff a6 b 400097ac <_Protected_heap_Free+0xac> <== NOT EXECUTED 40009918: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 4000991c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009920: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40009924: 7f ff e1 ae call 40001fdc <== NOT EXECUTED 40009928: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000992c: 10 bf ff a0 b 400097ac <_Protected_heap_Free+0xac> <== NOT EXECUTED 40009930: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40009934: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40009938: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4000993c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40009940: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40009944: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40009948: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000994c: 7f ff e1 a4 call 40001fdc <== NOT EXECUTED 40009950: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009954: 10 bf ff 96 b 400097ac <_Protected_heap_Free+0xac> <== NOT EXECUTED 40009958: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 4000995c: 7f ff e1 a0 call 40001fdc <== NOT EXECUTED 40009960: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009964: 10 bf ff 92 b 400097ac <_Protected_heap_Free+0xac> <== NOT EXECUTED 40009968: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000996c <_Protected_heap_Get_block_size>: boolean _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 4000996c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED boolean status; _RTEMS_Lock_allocator(); 40009970: 7f ff e1 97 call 40001fcc <== NOT EXECUTED 40009974: 01 00 00 00 nop <== NOT EXECUTED 40009978: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 4000997c: 23 10 00 6b sethi %hi(0x4001ac00), %l1 <== NOT EXECUTED 40009980: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009984: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009988: 02 80 00 0b be 400099b4 <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 4000998c: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED 40009990: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009994: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 4001af70 <_System_state_Current> <== NOT EXECUTED 40009998: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 4000999c: 08 80 00 06 bleu 400099b4 <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 400099a0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400099a4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400099a8: 7f ff fb a9 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 400099ac: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400099b0: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400099b4: 09 10 00 6b sethi %hi(0x4001ac00), %g4 <== NOT EXECUTED 400099b8: e0 04 e2 64 ld [ %l3 + 0x264 ], %l0 <== NOT EXECUTED 400099bc: c4 01 22 6c ld [ %g4 + 0x26c ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 400099c0: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 400099c4: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 400099c8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400099cc: 22 80 00 28 be,a 40009a6c <_Protected_heap_Get_block_size+0x100> <== NOT EXECUTED 400099d0: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 400099d4: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400099d8: 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; 400099dc: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 400099e0: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400099e4: 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; 400099e8: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400099ec: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 400099f0: 12 80 00 2e bne 40009aa8 <_Protected_heap_Get_block_size+0x13c> <== NOT EXECUTED 400099f4: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400099f8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400099fc: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40009a00: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40009a04: 02 80 00 47 be 40009b20 <_Protected_heap_Get_block_size+0x1b4> <== NOT EXECUTED 40009a08: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40009a0c: 7f ff e1 74 call 40001fdc <== NOT EXECUTED 40009a10: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 40009a14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009a18: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40009a1c: 40 00 11 b9 call 4000e100 <_Heap_Size_of_user_area> <== NOT EXECUTED 40009a20: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009a24: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009a28: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 40009a2c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009a30: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 40009a34: d0 04 e2 64 ld [ %l3 + 0x264 ], %o0 <== NOT EXECUTED 40009a38: 94 10 20 00 clr %o2 <== NOT EXECUTED 40009a3c: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40009a40: 7f ff f9 80 call 40008040 <_CORE_mutex_Surrender> <== NOT EXECUTED 40009a44: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40009a48: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009a4c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40009a50: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40009a54: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 <== NOT EXECUTED 40009a58: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40009a5c: 02 80 00 2d be 40009b10 <_Protected_heap_Get_block_size+0x1a4> <== NOT EXECUTED 40009a60: 01 00 00 00 nop <== NOT EXECUTED return status; } 40009a64: 81 c7 e0 08 ret <== NOT EXECUTED 40009a68: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 40009a6c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40009a70: 12 80 00 16 bne 40009ac8 <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 40009a74: c6 04 e2 64 ld [ %l3 + 0x264 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40009a78: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40009a7c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009a80: 22 80 00 43 be,a 40009b8c <_Protected_heap_Get_block_size+0x220> <== NOT EXECUTED 40009a84: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40009a88: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40009a8c: 12 80 00 0f bne 40009ac8 <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 40009a90: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40009a94: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40009a98: 7f ff e1 51 call 40001fdc <== NOT EXECUTED 40009a9c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { boolean status; _RTEMS_Lock_allocator(); status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 40009aa0: 10 bf ff de b 40009a18 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40009aa4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40009aa8: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40009aac: 12 bf ff d8 bne 40009a0c <_Protected_heap_Get_block_size+0xa0> <== NOT EXECUTED 40009ab0: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40009ab4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40009ab8: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40009abc: 02 80 00 19 be 40009b20 <_Protected_heap_Get_block_size+0x1b4> <== NOT EXECUTED 40009ac0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40009ac4: 30 bf ff d2 b,a 40009a0c <_Protected_heap_Get_block_size+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009ac8: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED size_t *size ) { boolean status; _RTEMS_Lock_allocator(); 40009acc: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40009ad0: c8 01 22 6c ld [ %g4 + 0x26c ], %g4 <== NOT EXECUTED 40009ad4: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009ad8: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40009adc: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40009ae0: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40009ae4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40009ae8: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40009aec: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40009af0: 7f ff e1 3b call 40001fdc <== NOT EXECUTED 40009af4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009af8: d0 04 e2 64 ld [ %l3 + 0x264 ], %o0 <== NOT EXECUTED 40009afc: 92 10 20 00 clr %o1 <== NOT EXECUTED 40009b00: 7f ff f9 2c call 40007fb0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40009b04: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 40009b08: 10 bf ff c4 b 40009a18 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40009b0c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40009b10: 40 00 01 f5 call 4000a2e4 <_Thread_Dispatch> <== NOT EXECUTED 40009b14: 01 00 00 00 nop <== NOT EXECUTED 40009b18: 81 c7 e0 08 ret <== NOT EXECUTED 40009b1c: 81 e8 00 00 restore <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40009b20: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40009b24: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40009b28: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40009b2c: 02 80 00 28 be 40009bcc <_Protected_heap_Get_block_size+0x260> <== NOT EXECUTED 40009b30: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40009b34: 1a 80 00 1c bcc 40009ba4 <_Protected_heap_Get_block_size+0x238> <== NOT EXECUTED 40009b38: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009b3c: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009b40: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009b44: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40009b48: 7f ff e1 25 call 40001fdc <== NOT EXECUTED 40009b4c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40009b50: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40009b54: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40009b58: 40 00 00 bf call 40009e54 <_Thread_Change_priority> <== NOT EXECUTED 40009b5c: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40009b60: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009b64: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40009b68: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40009b6c: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 <== NOT EXECUTED 40009b70: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40009b74: 32 bf ff a9 bne,a 40009a18 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40009b78: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40009b7c: 40 00 01 da call 4000a2e4 <_Thread_Dispatch> <== NOT EXECUTED 40009b80: 01 00 00 00 nop <== NOT EXECUTED 40009b84: 10 bf ff a5 b 40009a18 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40009b88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40009b8c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009b90: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40009b94: 7f ff e1 12 call 40001fdc <== NOT EXECUTED 40009b98: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009b9c: 10 bf ff 9f b 40009a18 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40009ba0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40009ba4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40009ba8: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40009bac: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40009bb0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40009bb4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40009bb8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40009bbc: 7f ff e1 08 call 40001fdc <== NOT EXECUTED 40009bc0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009bc4: 10 bf ff 95 b 40009a18 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40009bc8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40009bcc: 7f ff e1 04 call 40001fdc <== NOT EXECUTED 40009bd0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009bd4: 10 bf ff 91 b 40009a18 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40009bd8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000d3b8 <_Protected_heap_Get_free_information>: void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 4000d3b8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 4000d3bc: 7f ff da b7 call 40003e98 <== NOT EXECUTED 4000d3c0: 01 00 00 00 nop <== NOT EXECUTED 4000d3c4: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 4000d3c8: 23 10 00 f8 sethi %hi(0x4003e000), %l1 <== NOT EXECUTED 4000d3cc: c2 04 63 20 ld [ %l1 + 0x320 ], %g1 ! 4003e320 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000d3d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000d3d4: 02 80 00 0b be 4000d400 <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 4000d3d8: 27 10 00 f8 sethi %hi(0x4003e000), %l3 <== NOT EXECUTED 4000d3dc: 03 10 00 f9 sethi %hi(0x4003e400), %g1 <== NOT EXECUTED 4000d3e0: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 4003e500 <_System_state_Current> <== NOT EXECUTED 4000d3e4: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 4000d3e8: 08 80 00 06 bleu 4000d400 <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 4000d3ec: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000d3f0: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000d3f4: 7f ff fb 49 call 4000c118 <_Internal_error_Occurred> <== NOT EXECUTED 4000d3f8: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 4000d3fc: 27 10 00 f8 sethi %hi(0x4003e000), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 4000d400: 09 10 00 f8 sethi %hi(0x4003e000), %g4 <== NOT EXECUTED 4000d404: e0 04 e3 f4 ld [ %l3 + 0x3f4 ], %l0 <== NOT EXECUTED 4000d408: c4 01 23 fc ld [ %g4 + 0x3fc ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 4000d40c: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 4000d410: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 4000d414: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000d418: 22 80 00 26 be,a 4000d4b0 <_Protected_heap_Get_free_information+0xf8> <== NOT EXECUTED 4000d41c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 4000d420: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 4000d424: 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; 4000d428: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 4000d42c: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 4000d430: 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; 4000d434: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4000d438: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 4000d43c: 12 80 00 2c bne 4000d4ec <_Protected_heap_Get_free_information+0x134> <== NOT EXECUTED 4000d440: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4000d444: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000d448: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4000d44c: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000d450: 02 80 00 43 be 4000d55c <_Protected_heap_Get_free_information+0x1a4> <== NOT EXECUTED 4000d454: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000d458: 7f ff da 94 call 40003ea8 <== NOT EXECUTED 4000d45c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 4000d460: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000d464: 40 00 3a 2e call 4001bd1c <_Heap_Get_free_information> <== NOT EXECUTED 4000d468: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000d46c: c2 04 63 20 ld [ %l1 + 0x320 ], %g1 <== NOT EXECUTED 4000d470: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000d474: c2 24 63 20 st %g1, [ %l1 + 0x320 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 4000d478: d0 04 e3 f4 ld [ %l3 + 0x3f4 ], %o0 <== NOT EXECUTED 4000d47c: 94 10 20 00 clr %o2 <== NOT EXECUTED 4000d480: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 4000d484: 7f ff f9 22 call 4000b90c <_CORE_mutex_Surrender> <== NOT EXECUTED 4000d488: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000d48c: c2 04 63 20 ld [ %l1 + 0x320 ], %g1 <== NOT EXECUTED 4000d490: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000d494: c2 24 63 20 st %g1, [ %l1 + 0x320 ] <== NOT EXECUTED 4000d498: c4 04 63 20 ld [ %l1 + 0x320 ], %g2 <== NOT EXECUTED 4000d49c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000d4a0: 02 80 00 2d be 4000d554 <_Protected_heap_Get_free_information+0x19c> <== NOT EXECUTED 4000d4a4: 01 00 00 00 nop <== NOT EXECUTED 4000d4a8: 81 c7 e0 08 ret <== NOT EXECUTED 4000d4ac: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 4000d4b0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 4000d4b4: 12 80 00 16 bne 4000d50c <_Protected_heap_Get_free_information+0x154> <== NOT EXECUTED 4000d4b8: c6 04 e3 f4 ld [ %l3 + 0x3f4 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 4000d4bc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 4000d4c0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000d4c4: 22 80 00 41 be,a 4000d5c8 <_Protected_heap_Get_free_information+0x210> <== NOT EXECUTED 4000d4c8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 4000d4cc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000d4d0: 12 80 00 0f bne 4000d50c <_Protected_heap_Get_free_information+0x154> <== NOT EXECUTED 4000d4d4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 4000d4d8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 4000d4dc: 7f ff da 73 call 40003ea8 <== NOT EXECUTED 4000d4e0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); _Heap_Get_free_information( the_heap, info ); 4000d4e4: 10 bf ff e0 b 4000d464 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000d4e8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4000d4ec: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 4000d4f0: 12 bf ff da bne 4000d458 <_Protected_heap_Get_free_information+0xa0> <== NOT EXECUTED 4000d4f4: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4000d4f8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4000d4fc: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000d500: 02 80 00 17 be 4000d55c <_Protected_heap_Get_free_information+0x1a4> <== NOT EXECUTED 4000d504: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 4000d508: 30 bf ff d4 b,a 4000d458 <_Protected_heap_Get_free_information+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000d50c: c2 04 63 20 ld [ %l1 + 0x320 ], %g1 <== NOT EXECUTED void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); 4000d510: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 4000d514: c8 01 23 fc ld [ %g4 + 0x3fc ], %g4 <== NOT EXECUTED 4000d518: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000d51c: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 4000d520: c2 24 63 20 st %g1, [ %l1 + 0x320 ] <== NOT EXECUTED 4000d524: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 4000d528: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4000d52c: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 4000d530: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 4000d534: 7f ff da 5d call 40003ea8 <== NOT EXECUTED 4000d538: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000d53c: d0 04 e3 f4 ld [ %l3 + 0x3f4 ], %o0 <== NOT EXECUTED 4000d540: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000d544: 7f ff f8 ce call 4000b87c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 4000d548: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 4000d54c: 10 bf ff c6 b 4000d464 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000d550: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4000d554: 40 00 01 f3 call 4000dd20 <_Thread_Dispatch> <== NOT EXECUTED 4000d558: 81 e8 00 00 restore <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 4000d55c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 4000d560: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 4000d564: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4000d568: 02 80 00 28 be 4000d608 <_Protected_heap_Get_free_information+0x250> <== NOT EXECUTED 4000d56c: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 4000d570: 1a 80 00 1c bcc 4000d5e0 <_Protected_heap_Get_free_information+0x228> <== NOT EXECUTED 4000d574: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000d578: c2 04 63 20 ld [ %l1 + 0x320 ], %g1 <== NOT EXECUTED 4000d57c: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000d580: c2 24 63 20 st %g1, [ %l1 + 0x320 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 4000d584: 7f ff da 49 call 40003ea8 <== NOT EXECUTED 4000d588: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 4000d58c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 4000d590: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 4000d594: 40 00 00 bf call 4000d890 <_Thread_Change_priority> <== NOT EXECUTED 4000d598: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000d59c: c2 04 63 20 ld [ %l1 + 0x320 ], %g1 <== NOT EXECUTED 4000d5a0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000d5a4: c2 24 63 20 st %g1, [ %l1 + 0x320 ] <== NOT EXECUTED 4000d5a8: c4 04 63 20 ld [ %l1 + 0x320 ], %g2 <== NOT EXECUTED 4000d5ac: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000d5b0: 32 bf ff ad bne,a 4000d464 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000d5b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000d5b8: 40 00 01 da call 4000dd20 <_Thread_Dispatch> <== NOT EXECUTED 4000d5bc: 01 00 00 00 nop <== NOT EXECUTED 4000d5c0: 10 bf ff a9 b 4000d464 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000d5c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 4000d5c8: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000d5cc: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 4000d5d0: 7f ff da 36 call 40003ea8 <== NOT EXECUTED 4000d5d4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000d5d8: 10 bf ff a3 b 4000d464 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000d5dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 4000d5e0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 4000d5e4: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4000d5e8: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 4000d5ec: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4000d5f0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000d5f4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000d5f8: 7f ff da 2c call 40003ea8 <== NOT EXECUTED 4000d5fc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000d600: 10 bf ff 99 b 4000d464 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000d604: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 4000d608: 7f ff da 28 call 40003ea8 <== NOT EXECUTED 4000d60c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000d610: 10 bf ff 95 b 4000d464 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000d614: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009bdc <_Protected_heap_Resize_block>: boolean _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 40009bdc: 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(); 40009be0: 7f ff e0 fb call 40001fcc <== NOT EXECUTED 40009be4: 01 00 00 00 nop <== NOT EXECUTED 40009be8: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 40009bec: 23 10 00 6b sethi %hi(0x4001ac00), %l1 <== NOT EXECUTED 40009bf0: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009bf4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009bf8: 02 80 00 0b be 40009c24 <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 40009bfc: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED 40009c00: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40009c04: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 4001af70 <_System_state_Current> <== NOT EXECUTED 40009c08: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40009c0c: 08 80 00 06 bleu 40009c24 <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 40009c10: 90 10 20 00 clr %o0 <== NOT EXECUTED 40009c14: 92 10 20 00 clr %o1 <== NOT EXECUTED 40009c18: 7f ff fb 0d call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 40009c1c: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40009c20: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40009c24: 09 10 00 6b sethi %hi(0x4001ac00), %g4 <== NOT EXECUTED 40009c28: e0 04 e2 64 ld [ %l3 + 0x264 ], %l0 <== NOT EXECUTED 40009c2c: c4 01 22 6c ld [ %g4 + 0x26c ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40009c30: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40009c34: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 40009c38: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009c3c: 22 80 00 2e be,a 40009cf4 <_Protected_heap_Resize_block+0x118> <== NOT EXECUTED 40009c40: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40009c44: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40009c48: 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; 40009c4c: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 40009c50: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40009c54: 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; 40009c58: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40009c5c: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 40009c60: 12 80 00 34 bne 40009d30 <_Protected_heap_Resize_block+0x154> <== NOT EXECUTED 40009c64: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40009c68: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40009c6c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40009c70: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40009c74: 02 80 00 49 be 40009d98 <_Protected_heap_Resize_block+0x1bc> <== NOT EXECUTED 40009c78: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40009c7c: 7f ff e0 d8 call 40001fdc <== NOT EXECUTED 40009c80: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 40009c84: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009c88: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40009c8c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40009c90: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 40009c94: 40 00 10 8d call 4000dec8 <_Heap_Resize_block> <== NOT EXECUTED 40009c98: 98 07 bf f0 add %fp, -16, %o4 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009c9c: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009ca0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 40009ca4: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009ca8: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 40009cac: d0 04 e2 64 ld [ %l3 + 0x264 ], %o0 <== NOT EXECUTED 40009cb0: 94 10 20 00 clr %o2 <== NOT EXECUTED 40009cb4: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40009cb8: 7f ff f8 e2 call 40008040 <_CORE_mutex_Surrender> <== NOT EXECUTED 40009cbc: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40009cc0: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009cc4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40009cc8: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40009ccc: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 <== NOT EXECUTED 40009cd0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40009cd4: 12 80 00 05 bne 40009ce8 <_Protected_heap_Resize_block+0x10c> <== NOT EXECUTED 40009cd8: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED _Thread_Dispatch(); 40009cdc: 40 00 01 82 call 4000a2e4 <_Thread_Dispatch> <== NOT EXECUTED 40009ce0: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 40009ce4: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 40009ce8: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 40009cec: 81 c7 e0 08 ret <== NOT EXECUTED 40009cf0: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 40009cf4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40009cf8: 12 80 00 16 bne 40009d50 <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 40009cfc: c6 04 e2 64 ld [ %l3 + 0x264 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40009d00: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40009d04: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009d08: 22 80 00 3f be,a 40009e04 <_Protected_heap_Resize_block+0x228> <== NOT EXECUTED 40009d0c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40009d10: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40009d14: 12 80 00 0f bne 40009d50 <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 40009d18: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40009d1c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40009d20: 7f ff e0 af call 40001fdc <== NOT EXECUTED 40009d24: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); status = _Heap_Resize_block( 40009d28: 10 bf ff d8 b 40009c88 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40009d2c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40009d30: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40009d34: 12 bf ff d2 bne 40009c7c <_Protected_heap_Resize_block+0xa0> <== NOT EXECUTED 40009d38: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40009d3c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40009d40: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40009d44: 02 80 00 15 be 40009d98 <_Protected_heap_Resize_block+0x1bc> <== NOT EXECUTED 40009d48: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40009d4c: 30 bf ff cc b,a 40009c7c <_Protected_heap_Resize_block+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009d50: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED { Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 40009d54: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40009d58: c8 01 22 6c ld [ %g4 + 0x26c ], %g4 <== NOT EXECUTED 40009d5c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009d60: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40009d64: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40009d68: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40009d6c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40009d70: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40009d74: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40009d78: 7f ff e0 99 call 40001fdc <== NOT EXECUTED 40009d7c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009d80: d0 04 e2 64 ld [ %l3 + 0x264 ], %o0 <== NOT EXECUTED 40009d84: 92 10 20 00 clr %o1 <== NOT EXECUTED 40009d88: 7f ff f8 8a call 40007fb0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40009d8c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 40009d90: 10 bf ff be b 40009c88 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40009d94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40009d98: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40009d9c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40009da0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40009da4: 02 80 00 28 be 40009e44 <_Protected_heap_Resize_block+0x268> <== NOT EXECUTED 40009da8: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40009dac: 1a 80 00 1c bcc 40009e1c <_Protected_heap_Resize_block+0x240> <== NOT EXECUTED 40009db0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 40009db4: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009db8: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009dbc: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40009dc0: 7f ff e0 87 call 40001fdc <== NOT EXECUTED 40009dc4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40009dc8: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40009dcc: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40009dd0: 40 00 00 21 call 40009e54 <_Thread_Change_priority> <== NOT EXECUTED 40009dd4: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40009dd8: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40009ddc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40009de0: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40009de4: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 <== NOT EXECUTED 40009de8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40009dec: 32 bf ff a7 bne,a 40009c88 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40009df0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40009df4: 40 00 01 3c call 4000a2e4 <_Thread_Dispatch> <== NOT EXECUTED 40009df8: 01 00 00 00 nop <== NOT EXECUTED 40009dfc: 10 bf ff a3 b 40009c88 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40009e00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40009e04: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009e08: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40009e0c: 7f ff e0 74 call 40001fdc <== NOT EXECUTED 40009e10: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009e14: 10 bf ff 9d b 40009c88 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40009e18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40009e1c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40009e20: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40009e24: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40009e28: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40009e2c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40009e30: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40009e34: 7f ff e0 6a call 40001fdc <== NOT EXECUTED 40009e38: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009e3c: 10 bf ff 93 b 40009c88 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40009e40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40009e44: 7f ff e0 66 call 40001fdc <== NOT EXECUTED 40009e48: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40009e4c: 10 bf ff 8f b 40009c88 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40009e50: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000dbac <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 4000dbac: 9d e3 bf 98 save %sp, -104, %sp /* * Free per task variable memory */ tvp = deleted->task_variables; 4000dbb0: e0 06 61 7c ld [ %i1 + 0x17c ], %l0 deleted->task_variables = NULL; 4000dbb4: c0 26 61 7c clr [ %i1 + 0x17c ] while (tvp) { 4000dbb8: 80 a4 20 00 cmp %l0, 0 4000dbbc: 02 80 00 25 be 4000dc50 <_RTEMS_tasks_Delete_extension+0xa4> 4000dbc0: 29 10 00 6b sethi %hi(0x4001ac00), %l4 4000dbc4: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED 4000dbc8: 10 80 00 12 b 4000dc10 <_RTEMS_tasks_Delete_extension+0x64> <== NOT EXECUTED 4000dbcc: a4 15 21 dc or %l4, 0x1dc, %l2 <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { if (tvp->dtor) 4000dbd0: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED 4000dbd4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000dbd8: 22 80 00 06 be,a 4000dbf0 <_RTEMS_tasks_Delete_extension+0x44> <== NOT EXECUTED 4000dbdc: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED (*tvp->dtor)(*tvp->ptr); 4000dbe0: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 4000dbe4: 9f c0 80 00 call %g2 <== NOT EXECUTED 4000dbe8: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 4000dbec: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED 4000dbf0: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 4000dbf4: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4000dbf8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 4000dbfc: 7f ff ea 14 call 4000844c <_Heap_Free> <== NOT EXECUTED 4000dc00: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 4000dc04: a0 94 60 00 orcc %l1, 0, %l0 <== NOT EXECUTED 4000dc08: 22 80 00 13 be,a 4000dc54 <_RTEMS_tasks_Delete_extension+0xa8> <== NOT EXECUTED 4000dc0c: d2 06 61 6c ld [ %i1 + 0x16c ], %o1 <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 4000dc10: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 <== NOT EXECUTED 4000dc14: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 4000dc18: 02 bf ff ee be 4000dbd0 <_RTEMS_tasks_Delete_extension+0x24> <== NOT EXECUTED 4000dc1c: e2 04 00 00 ld [ %l0 ], %l1 <== NOT EXECUTED if (tvp->dtor) (*tvp->dtor)(*tvp->ptr); *tvp->ptr = tvp->gval; } else { if (tvp->dtor) 4000dc20: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 4000dc24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000dc28: 02 bf ff f5 be 4000dbfc <_RTEMS_tasks_Delete_extension+0x50> <== NOT EXECUTED 4000dc2c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 4000dc30: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000dc34: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED 4000dc38: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 4000dc3c: 7f ff ea 04 call 4000844c <_Heap_Free> <== NOT EXECUTED 4000dc40: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 4000dc44: a0 94 60 00 orcc %l1, 0, %l0 <== NOT EXECUTED 4000dc48: 12 bf ff f3 bne 4000dc14 <_RTEMS_tasks_Delete_extension+0x68> <== NOT EXECUTED 4000dc4c: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 <== NOT EXECUTED 4000dc50: d2 06 61 6c ld [ %i1 + 0x16c ], %o1 4000dc54: 7f ff e9 fe call 4000844c <_Heap_Free> 4000dc58: 90 15 21 dc or %l4, 0x1dc, %o0 /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 4000dc5c: c0 26 61 6c clr [ %i1 + 0x16c ] } 4000dc60: 81 c7 e0 08 ret 4000dc64: 81 e8 00 00 restore 400076a0 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 400076a0: 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; 400076a4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400076a8: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 4001ae50 <_Configuration_Table> 400076ac: c6 00 a0 2c ld [ %g2 + 0x2c ], %g3 /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 400076b0: d0 00 e0 28 ld [ %g3 + 0x28 ], %o0 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) 400076b4: 80 a2 20 00 cmp %o0, 0 400076b8: 02 80 00 2f be 40007774 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 400076bc: e4 00 e0 24 ld [ %g3 + 0x24 ], %l2 400076c0: 80 a4 a0 00 cmp %l2, 0 400076c4: 02 80 00 2c be 40007774 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 400076c8: a0 10 00 08 mov %o0, %l0 return; for ( index=0 ; index < maximum ; index++ ) { 400076cc: a2 10 20 00 clr %l1 400076d0: 10 80 00 0c b 40007700 <_RTEMS_tasks_Initialize_user_tasks_body+0x60> 400076d4: a6 07 bf f4 add %fp, -12, %l3 ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); return_value = rtems_task_start( 400076d8: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 400076dc: d0 07 bf f4 ld [ %fp + -12 ], %o0 400076e0: 40 00 00 27 call 4000777c 400076e4: a2 04 60 01 inc %l1 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 400076e8: 80 a2 20 00 cmp %o0, 0 400076ec: 12 80 00 1c bne 4000775c <_RTEMS_tasks_Initialize_user_tasks_body+0xbc> 400076f0: 94 10 00 08 mov %o0, %o2 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 400076f4: 80 a4 40 12 cmp %l1, %l2 400076f8: 02 80 00 1f be 40007774 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 400076fc: a0 04 20 1c add %l0, 0x1c, %l0 return_value = rtems_task_create( 40007700: d6 04 20 14 ld [ %l0 + 0x14 ], %o3 40007704: d8 04 20 0c ld [ %l0 + 0xc ], %o4 40007708: d2 04 20 08 ld [ %l0 + 8 ], %o1 4000770c: d4 04 20 04 ld [ %l0 + 4 ], %o2 40007710: d0 04 00 00 ld [ %l0 ], %o0 40007714: 7f ff ff 1a call 4000737c 40007718: 9a 10 00 13 mov %l3, %o5 user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 4000771c: 80 a2 20 00 cmp %o0, 0 40007720: 22 bf ff ee be,a 400076d8 <_RTEMS_tasks_Initialize_user_tasks_body+0x38> 40007724: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 40007728: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4000772c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40007730: 40 00 04 47 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 40007734: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED return_value = rtems_task_start( 40007738: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED 4000773c: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 <== NOT EXECUTED 40007740: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED 40007744: 40 00 00 0e call 4000777c <== NOT EXECUTED 40007748: a2 04 60 01 inc %l1 <== NOT EXECUTED id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 4000774c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007750: 02 bf ff ea be 400076f8 <_RTEMS_tasks_Initialize_user_tasks_body+0x58> <== NOT EXECUTED 40007754: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 40007758: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4000775c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40007760: 40 00 04 3b call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 40007764: 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++ ) { 40007768: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED 4000776c: 12 bf ff e5 bne 40007700 <_RTEMS_tasks_Initialize_user_tasks_body+0x60> <== NOT EXECUTED 40007770: a0 04 20 1c add %l0, 0x1c, %l0 <== NOT EXECUTED 40007774: 81 c7 e0 08 ret 40007778: 81 e8 00 00 restore 4000dabc <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 4000dabc: 9d e3 bf 90 save %sp, -112, %sp * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 4000dac0: 7f ff d1 43 call 40001fcc 4000dac4: f0 06 21 6c ld [ %i0 + 0x16c ], %i0 signal_set = asr->signals_posted; 4000dac8: e4 06 20 54 ld [ %i0 + 0x54 ], %l2 asr->signals_posted = 0; 4000dacc: c0 26 20 54 clr [ %i0 + 0x54 ] _ISR_Enable( level ); 4000dad0: 7f ff d1 43 call 40001fdc 4000dad4: 01 00 00 00 nop if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 4000dad8: 80 a4 a0 00 cmp %l2, 0 4000dadc: 32 80 00 04 bne,a 4000daec <_RTEMS_tasks_Post_switch_extension+0x30> 4000dae0: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 4000dae4: 81 c7 e0 08 ret <== NOT EXECUTED 4000dae8: 81 e8 00 00 restore <== NOT EXECUTED return; asr->nest_level += 1; rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000daec: d0 06 20 50 ld [ %i0 + 0x50 ], %o0 if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ return; asr->nest_level += 1; 4000daf0: 82 00 60 01 inc %g1 rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000daf4: a2 07 bf f4 add %fp, -12, %l1 if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ return; asr->nest_level += 1; 4000daf8: c2 26 20 5c st %g1, [ %i0 + 0x5c ] rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000dafc: 94 10 00 11 mov %l1, %o2 4000db00: 21 00 00 3f sethi %hi(0xfc00), %l0 4000db04: 40 00 04 5a call 4000ec6c 4000db08: 92 14 23 ff or %l0, 0x3ff, %o1 ! ffff (*asr->handler)( signal_set ); 4000db0c: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 4000db10: 9f c0 40 00 call %g1 4000db14: 90 10 00 12 mov %l2, %o0 asr->nest_level -= 1; 4000db18: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000db1c: d0 07 bf f4 ld [ %fp + -12 ], %o0 asr->nest_level += 1; rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); (*asr->handler)( signal_set ); asr->nest_level -= 1; 4000db20: 82 00 7f ff add %g1, -1, %g1 rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000db24: 92 14 23 ff or %l0, 0x3ff, %o1 asr->nest_level += 1; rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); (*asr->handler)( signal_set ); asr->nest_level -= 1; 4000db28: c2 26 20 5c st %g1, [ %i0 + 0x5c ] rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000db2c: 40 00 04 50 call 4000ec6c 4000db30: 94 10 00 11 mov %l1, %o2 4000db34: 81 c7 e0 08 ret 4000db38: 81 e8 00 00 restore 40008360 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 40008360: 9d e3 bf 90 save %sp, -112, %sp 40008364: 11 10 00 7d sethi %hi(0x4001f400), %o0 40008368: 92 10 00 18 mov %i0, %o1 4000836c: 90 12 20 4c or %o0, 0x4c, %o0 40008370: 40 00 09 a7 call 4000aa0c <_Objects_Get> 40008374: 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 ) { 40008378: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000837c: 80 a0 60 00 cmp %g1, 0 40008380: 12 80 00 11 bne 400083c4 <_Rate_monotonic_Timeout+0x64> 40008384: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: /* impossible */ case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; 40008388: d0 02 20 50 ld [ %o0 + 0x50 ], %o0 if ( _States_Is_waiting_for_period( the_thread->current_state ) && 4000838c: 03 00 00 10 sethi %hi(0x4000), %g1 40008390: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 40008394: 80 88 80 01 btst %g2, %g1 40008398: 32 80 00 0d bne,a 400083cc <_Rate_monotonic_Timeout+0x6c> 4000839c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 400083a0: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 400083a4: 80 a0 60 01 cmp %g1, 1 400083a8: 02 80 00 17 be 40008404 <_Rate_monotonic_Timeout+0xa4> 400083ac: 82 10 20 04 mov 4, %g1 the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 400083b0: 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; 400083b4: 05 10 00 7d sethi %hi(0x4001f400), %g2 400083b8: c2 00 a1 e0 ld [ %g2 + 0x1e0 ], %g1 ! 4001f5e0 <_Thread_Dispatch_disable_level> 400083bc: 82 00 7f ff add %g1, -1, %g1 400083c0: c2 20 a1 e0 st %g1, [ %g2 + 0x1e0 ] 400083c4: 81 c7 e0 08 ret 400083c8: 81 e8 00 00 restore case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; if ( _States_Is_waiting_for_period( the_thread->current_state ) && 400083cc: c2 06 20 08 ld [ %i0 + 8 ], %g1 400083d0: 80 a0 80 01 cmp %g2, %g1 400083d4: 32 bf ff f4 bne,a 400083a4 <_Rate_monotonic_Timeout+0x44> 400083d8: 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 ); 400083dc: 13 04 00 ff sethi %hi(0x1003fc00), %o1 400083e0: 40 00 0d fe call 4000bbd8 <_Thread_Clear_state> 400083e4: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400083e8: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400083ec: 92 06 20 10 add %i0, 0x10, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400083f0: c2 26 20 1c st %g1, [ %i0 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400083f4: 11 10 00 7d sethi %hi(0x4001f400), %o0 400083f8: 40 00 14 33 call 4000d4c4 <_Watchdog_Insert> 400083fc: 90 12 22 dc or %o0, 0x2dc, %o0 ! 4001f6dc <_Watchdog_Ticks_chain> 40008400: 30 bf ff ed b,a 400083b4 <_Rate_monotonic_Timeout+0x54> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40008404: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 <== NOT EXECUTED the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 40008408: 84 10 20 03 mov 3, %g2 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4000840c: 92 06 20 10 add %i0, 0x10, %o1 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40008410: c2 26 20 1c st %g1, [ %i0 + 0x1c ] <== NOT EXECUTED 40008414: c4 26 20 38 st %g2, [ %i0 + 0x38 ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40008418: 11 10 00 7d sethi %hi(0x4001f400), %o0 <== NOT EXECUTED 4000841c: 40 00 14 2a call 4000d4c4 <_Watchdog_Insert> <== NOT EXECUTED 40008420: 90 12 22 dc or %o0, 0x2dc, %o0 ! 4001f6dc <_Watchdog_Ticks_chain> <== NOT EXECUTED 40008424: 30 bf ff e4 b,a 400083b4 <_Rate_monotonic_Timeout+0x54> <== NOT EXECUTED 4001b75c <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 4001b75c: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001b760: 27 10 00 d1 sethi %hi(0x40034400), %l3 4001b764: c2 04 e3 60 ld [ %l3 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 4001b768: 82 00 60 01 inc %g1 4001b76c: c2 24 e3 60 st %g1, [ %l3 + 0x360 ] 4001b770: c2 04 e3 60 ld [ %l3 + 0x360 ], %g1 4001b774: 82 00 60 01 inc %g1 4001b778: c2 24 e3 60 st %g1, [ %l3 + 0x360 ] * NOTE: Be sure to disable dispatching before unlocking the mutex * since we do not want to open a window where a context * switch could occur. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 4001b77c: 03 10 00 d2 sethi %hi(0x40034800), %g1 4001b780: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 ! 40034834 <_RTEMS_Allocator_Mutex> 4001b784: 94 10 20 00 clr %o2 4001b788: d2 02 20 08 ld [ %o0 + 8 ], %o1 4001b78c: 7f ff e7 b5 call 40015660 <_CORE_mutex_Surrender> 4001b790: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001b794: c2 04 e3 60 ld [ %l3 + 0x360 ], %g1 4001b798: a2 06 20 10 add %i0, 0x10, %l1 4001b79c: 82 00 7f ff add %g1, -1, %g1 4001b7a0: c2 24 e3 60 st %g1, [ %l3 + 0x360 ] 4001b7a4: c4 04 e3 60 ld [ %l3 + 0x360 ], %g2 4001b7a8: 80 a0 a0 00 cmp %g2, 0 4001b7ac: 02 80 00 21 be 4001b830 <_Region_Process_queue+0xd4> 4001b7b0: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 4001b7b4: 10 80 00 10 b 4001b7f4 <_Region_Process_queue+0x98> 4001b7b8: a4 06 20 68 add %i0, 0x68, %l2 the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 4001b7bc: 7f ff e8 bd call 40015ab0 <_Heap_Allocate> 4001b7c0: d2 04 20 24 ld [ %l0 + 0x24 ], %o1 4001b7c4: 80 a2 20 00 cmp %o0, 0 4001b7c8: 02 80 00 11 be 4001b80c <_Region_Process_queue+0xb0> 4001b7cc: 01 00 00 00 nop break; *(void **)the_thread->Wait.return_argument = the_segment; the_region->number_of_used_blocks += 1; 4001b7d0: c2 06 20 64 ld [ %i0 + 0x64 ], %g1 ); if ( the_segment == NULL ) break; *(void **)the_thread->Wait.return_argument = the_segment; 4001b7d4: c4 04 20 28 ld [ %l0 + 0x28 ], %g2 the_region->number_of_used_blocks += 1; 4001b7d8: 82 00 60 01 inc %g1 ); if ( the_segment == NULL ) break; *(void **)the_thread->Wait.return_argument = the_segment; 4001b7dc: d0 20 80 00 st %o0, [ %g2 ] the_region->number_of_used_blocks += 1; 4001b7e0: c2 26 20 64 st %g1, [ %i0 + 0x64 ] _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 4001b7e4: 90 10 00 11 mov %l1, %o0 4001b7e8: 40 00 02 79 call 4001c1cc <_Thread_queue_Extract> 4001b7ec: 92 10 00 10 mov %l0, %o1 the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 4001b7f0: c0 24 20 34 clr [ %l0 + 0x34 ] /* * NOTE: The following loop is O(n) where n is the number of * threads whose memory request is satisfied. */ for ( ; ; ) { the_thread = _Thread_queue_First( &the_region->Wait_queue ); 4001b7f4: 40 00 02 c0 call 4001c2f4 <_Thread_queue_First> 4001b7f8: 90 10 00 11 mov %l1, %o0 4001b7fc: a0 10 00 08 mov %o0, %l0 if ( the_thread == NULL ) 4001b800: 80 a4 20 00 cmp %l0, 0 4001b804: 12 bf ff ee bne 4001b7bc <_Region_Process_queue+0x60> 4001b808: 90 10 00 12 mov %l2, %o0 4001b80c: c2 04 e3 60 ld [ %l3 + 0x360 ], %g1 4001b810: 82 00 7f ff add %g1, -1, %g1 4001b814: c2 24 e3 60 st %g1, [ %l3 + 0x360 ] 4001b818: c4 04 e3 60 ld [ %l3 + 0x360 ], %g2 4001b81c: 80 a0 a0 00 cmp %g2, 0 4001b820: 02 80 00 07 be 4001b83c <_Region_Process_queue+0xe0> 4001b824: 01 00 00 00 nop 4001b828: 81 c7 e0 08 ret <== NOT EXECUTED 4001b82c: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4001b830: 7f ff f0 bf call 40017b2c <_Thread_Dispatch> <== NOT EXECUTED 4001b834: a4 06 20 68 add %i0, 0x68, %l2 <== NOT EXECUTED 4001b838: 30 bf ff ef b,a 4001b7f4 <_Region_Process_queue+0x98> <== NOT EXECUTED 4001b83c: 7f ff f0 bc call 40017b2c <_Thread_Dispatch> 4001b840: 81 e8 00 00 restore 4001b844: 01 00 00 00 nop 40009c54 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 40009c54: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009c58: 23 10 00 9c sethi %hi(0x40027000), %l1 40009c5c: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 40027360 <_Thread_Dispatch_disable_level> 40009c60: 82 00 60 01 inc %g1 40009c64: c2 24 63 60 st %g1, [ %l1 + 0x360 ] _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 40009c68: 21 10 00 9d sethi %hi(0x40027400), %l0 40009c6c: c2 06 00 00 ld [ %i0 ], %g1 40009c70: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 40009c74: 80 a0 40 0a cmp %g1, %o2 40009c78: 36 80 00 18 bge,a 40009cd8 <_TOD_Set+0x84> 40009c7c: 94 20 40 0a sub %g1, %o2, %o2 Watchdog_Adjust_directions direction, Watchdog_Interval units ) { _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units ); 40009c80: 11 10 00 9d sethi %hi(0x40027400), %o0 40009c84: 94 22 80 01 sub %o2, %g1, %o2 40009c88: 90 12 20 50 or %o0, 0x50, %o0 40009c8c: 40 00 0e ea call 4000d834 <_Watchdog_Adjust> 40009c90: 92 10 20 01 mov 1, %o1 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 40009c94: c4 06 00 00 ld [ %i0 ], %g2 40009c98: 86 14 20 18 or %l0, 0x18, %g3 40009c9c: c4 24 20 18 st %g2, [ %l0 + 0x18 ] 40009ca0: c2 06 20 04 ld [ %i0 + 4 ], %g1 _TOD_Is_set = TRUE; 40009ca4: 84 10 20 01 mov 1, %g2 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 40009ca8: c2 20 e0 04 st %g1, [ %g3 + 4 ] _TOD_Is_set = TRUE; 40009cac: 03 10 00 9c sethi %hi(0x40027000), %g1 40009cb0: c4 20 63 9c st %g2, [ %g1 + 0x39c ] ! 4002739c <_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 ) 40009cb4: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40009cb8: 82 00 7f ff add %g1, -1, %g1 40009cbc: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40009cc0: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40009cc4: 80 a0 a0 00 cmp %g2, 0 40009cc8: 02 80 00 0a be 40009cf0 <_TOD_Set+0x9c> 40009ccc: 01 00 00 00 nop 40009cd0: 81 c7 e0 08 ret 40009cd4: 81 e8 00 00 restore 40009cd8: 11 10 00 9d sethi %hi(0x40027400), %o0 40009cdc: 92 10 20 00 clr %o1 40009ce0: 40 00 0e d5 call 4000d834 <_Watchdog_Adjust> 40009ce4: 90 12 20 50 or %o0, 0x50, %o0 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 40009ce8: 10 bf ff ec b 40009c98 <_TOD_Set+0x44> 40009cec: c4 06 00 00 ld [ %i0 ], %g2 _Thread_Dispatch(); 40009cf0: 40 00 08 3c call 4000bde0 <_Thread_Dispatch> <== NOT EXECUTED 40009cf4: 81 e8 00 00 restore <== NOT EXECUTED 40009cf8: 01 00 00 00 nop 4000a194 <_Thread_Create_idle>: */ const char *_Thread_Idle_name = "IDLE"; void _Thread_Create_idle( void ) { 4000a194: 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 ); 4000a198: 39 10 00 6b sethi %hi(0x4001ac00), %i4 4000a19c: 7f ff f9 d9 call 40008900 <_Objects_Allocate> 4000a1a0: 90 17 23 20 or %i4, 0x320, %o0 ! 4001af20 <_Thread_Internal_information> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 4000a1a4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a1a8: 96 10 61 a4 or %g1, 0x1a4, %o3 ! 4001ada4 <_CPU_Table> 4000a1ac: c4 02 e0 0c ld [ %o3 + 0xc ], %g2 * The entire workspace is zeroed during its initialization. Thus, all * fields not explicitly assigned were explicitly zeroed by * _Workspace_Initialization. */ _Thread_Idle = _Thread_Internal_allocate(); 4000a1b0: 37 10 00 6b sethi %hi(0x4001ac00), %i3 4000a1b4: d0 26 e3 78 st %o0, [ %i3 + 0x378 ] ! 4001af78 <_Thread_Idle> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 4000a1b8: 03 10 00 29 sethi %hi(0x4000a400), %g1 4000a1bc: 92 10 00 08 mov %o0, %o1 4000a1c0: 80 a0 a0 00 cmp %g2, 0 4000a1c4: 02 80 00 03 be 4000a1d0 <_Thread_Create_idle+0x3c> 4000a1c8: b4 10 60 40 or %g1, 0x40, %i2 idle = _CPU_Table.idle_task; 4000a1cc: b4 10 00 02 mov %g2, %i2 <== NOT EXECUTED idle_task_stack_size = _CPU_Table.idle_task_stack_size; 4000a1d0: d6 02 e0 14 ld [ %o3 + 0x14 ], %o3 if ( idle_task_stack_size < STACK_MINIMUM_SIZE ) 4000a1d4: 80 a2 ef ff cmp %o3, 0xfff 4000a1d8: 28 80 00 02 bleu,a 4000a1e0 <_Thread_Create_idle+0x4c> 4000a1dc: 17 00 00 04 sethi %hi(0x1000), %o3 idle_task_stack_size = STACK_MINIMUM_SIZE; _Thread_Initialize( 4000a1e0: 03 10 00 68 sethi %hi(0x4001a000), %g1 4000a1e4: c4 00 61 98 ld [ %g1 + 0x198 ], %g2 ! 4001a198 <_Thread_Idle_name> 4000a1e8: 82 10 20 01 mov 1, %g1 4000a1ec: c4 23 a0 6c st %g2, [ %sp + 0x6c ] 4000a1f0: 90 17 23 20 or %i4, 0x320, %o0 4000a1f4: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 4000a1f8: c0 23 a0 60 clr [ %sp + 0x60 ] 4000a1fc: c0 23 a0 64 clr [ %sp + 0x64 ] 4000a200: c0 23 a0 68 clr [ %sp + 0x68 ] 4000a204: 94 10 20 00 clr %o2 4000a208: 98 10 20 00 clr %o4 4000a20c: 40 00 00 8e call 4000a444 <_Thread_Initialize> 4000a210: 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 = 4000a214: c6 06 e3 78 ld [ %i3 + 0x378 ], %g3 4000a218: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a21c: 05 10 00 6b sethi %hi(0x4001ac00), %g2 _Thread_Executing = _Thread_Idle; _Thread_Start( 4000a220: b0 10 00 03 mov %g3, %i0 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 4000a224: c6 20 62 6c st %g3, [ %g1 + 0x26c ] 4000a228: c6 20 a2 44 st %g3, [ %g2 + 0x244 ] _Thread_Executing = _Thread_Idle; _Thread_Start( 4000a22c: b2 10 20 00 clr %i1 4000a230: b6 10 20 00 clr %i3 4000a234: 40 00 04 07 call 4000b250 <_Thread_Start> 4000a238: 99 e8 20 00 restore %g0, 0, %o4 4000a23c: 01 00 00 00 nop 4000a240 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 4000a240: 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 ) ) { 4000a244: 92 96 20 00 orcc %i0, 0, %o1 4000a248: 12 80 00 11 bne 4000a28c <_Thread_Delay_ended+0x4c> 4000a24c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000a250: 31 10 00 6b sethi %hi(0x4001ac00), %i0 <== NOT EXECUTED 4000a254: c2 06 21 90 ld [ %i0 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000a258: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000a25c: c2 26 21 90 st %g1, [ %i0 + 0x190 ] <== 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; 4000a260: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000a264: d0 00 62 6c ld [ %g1 + 0x26c ], %o0 ! 4001ae6c <_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; 4000a268: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000a26c: 13 04 00 ff sethi %hi(0x1003fc00), %o1 <== NOT EXECUTED 4000a270: 7f ff ff 68 call 4000a010 <_Thread_Clear_state> 4000a274: 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; 4000a278: c2 06 21 90 ld [ %i0 + 0x190 ], %g1 4000a27c: 82 00 7f ff add %g1, -1, %g1 4000a280: c2 26 21 90 st %g1, [ %i0 + 0x190 ] 4000a284: 81 c7 e0 08 ret 4000a288: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 4000a28c: 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 ) { 4000a290: 80 a0 a0 04 cmp %g2, 4 4000a294: 18 bf ff fc bgu 4000a284 <_Thread_Delay_ended+0x44> 4000a298: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4000a29c: 80 a0 60 01 cmp %g1, 1 4000a2a0: 12 bf ff f9 bne 4000a284 <_Thread_Delay_ended+0x44> 4000a2a4: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4000a2a8: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000a2ac: 84 10 a0 f0 or %g2, 0xf0, %g2 ! 4001acf0 <_Objects_Information_table> 4000a2b0: c6 00 80 01 ld [ %g2 + %g1 ], %g3 4000a2b4: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 4000a2b8: 80 a2 20 00 cmp %o0, 0 4000a2bc: 02 bf ff f2 be 4000a284 <_Thread_Delay_ended+0x44> 4000a2c0: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4000a2c4: 7f ff fa e0 call 40008e44 <_Objects_Get> 4000a2c8: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000a2cc: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000a2d0: 80 a0 60 00 cmp %g1, 0 4000a2d4: 12 bf ff ec bne 4000a284 <_Thread_Delay_ended+0x44> 4000a2d8: 31 10 00 6b sethi %hi(0x4001ac00), %i0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000a2dc: 10 bf ff e5 b 4000a270 <_Thread_Delay_ended+0x30> 4000a2e0: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000f020 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 4000f020: 9d e3 bf 98 save %sp, -104, %sp #endif #if defined(__USE__MAIN__) extern void _main(void); #endif executing = _Thread_Executing; 4000f024: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000f028: f4 00 62 6c ld [ %g1 + 0x26c ], %i2 ! 4001ae6c <_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(); 4000f02c: 3f 10 00 3c sethi %hi(0x4000f000), %i7 4000f030: be 17 e0 20 or %i7, 0x20, %i7 ! 4000f020 <_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); 4000f034: d0 06 a0 c4 ld [ %i2 + 0xc4 ], %o0 4000f038: 7f ff cb e9 call 40001fdc 4000f03c: 91 2a 20 08 sll %o0, 8, %o0 #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 4000f040: 05 10 00 6a sethi %hi(0x4001a800), %g2 doneConstructors = 1; 4000f044: 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; 4000f048: f2 08 a3 b0 ldub [ %g2 + 0x3b0 ], %i1 * Take care that 'begin' extensions get to complete before * 'switch' extensions can run. This means must keep dispatch * disabled until all 'begin' extensions complete. */ _User_extensions_Thread_begin( executing ); 4000f04c: 90 10 00 1a mov %i2, %o0 4000f050: 7f ff f1 3e call 4000b548 <_User_extensions_Thread_begin> 4000f054: c2 28 a3 b0 stb %g1, [ %g2 + 0x3b0 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f058: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000f05c: c2 00 a1 90 ld [ %g2 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> 4000f060: 82 00 7f ff add %g1, -1, %g1 4000f064: c2 20 a1 90 st %g1, [ %g2 + 0x190 ] 4000f068: c6 00 a1 90 ld [ %g2 + 0x190 ], %g3 4000f06c: 80 a0 e0 00 cmp %g3, 0 4000f070: 02 80 00 36 be 4000f148 <_Thread_Handler+0x128> 4000f074: 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) */ 4000f078: 83 2e 60 18 sll %i1, 0x18, %g1 <== NOT EXECUTED 4000f07c: 80 a0 60 00 cmp %g1, 0 4000f080: 02 80 00 22 be 4000f108 <_Thread_Handler+0xe8> 4000f084: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 4000f088: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 4000f08c: 80 a0 60 01 cmp %g1, 1 4000f090: 22 80 00 25 be,a 4000f124 <_Thread_Handler+0x104> 4000f094: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 4000f098: 80 a0 60 01 cmp %g1, 1 4000f09c: 1a 80 00 0c bcc 4000f0cc <_Thread_Handler+0xac> 4000f0a0: 80 a0 60 02 cmp %g1, 2 case THREAD_START_NUMERIC: executing->Wait.return_argument = 4000f0a4: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 4000f0a8: 9f c0 40 00 call %g1 4000f0ac: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 4000f0b0: d0 26 a0 28 st %o0, [ %i2 + 0x28 ] * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 4000f0b4: 90 10 00 1a mov %i2, %o0 4000f0b8: 7f ff f1 4c call 4000b5e8 <_User_extensions_Thread_exitted> 4000f0bc: b0 10 20 00 clr %i0 _Internal_error_Occurred( 4000f0c0: b2 10 20 01 mov 1, %i1 4000f0c4: 7f ff e5 e2 call 4000884c <_Internal_error_Occurred> 4000f0c8: 95 e8 20 06 restore %g0, 6, %o2 #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 4000f0cc: 02 80 00 23 be 4000f158 <_Thread_Handler+0x138> <== NOT EXECUTED 4000f0d0: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 4000f0d4: 12 bf ff f9 bne 4000f0b8 <_Thread_Handler+0x98> <== NOT EXECUTED 4000f0d8: 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 = 4000f0dc: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 4000f0e0: d2 06 a0 b0 ld [ %i2 + 0xb0 ], %o1 <== NOT EXECUTED 4000f0e4: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 <== NOT EXECUTED 4000f0e8: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000f0ec: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000f0f0: 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 ); 4000f0f4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000f0f8: 7f ff f1 3c call 4000b5e8 <_User_extensions_Thread_exitted> <== NOT EXECUTED 4000f0fc: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 4000f100: 7f ff e5 d3 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 4000f104: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED * _init could be a weak symbol and we SHOULD test it but it isn't * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (!doneCons) /* && (volatile void *)_init) */ _init (); 4000f108: 40 00 2a bc call 40019bf8 <_init> 4000f10c: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 4000f110: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 4000f114: 80 a0 60 01 cmp %g1, 1 4000f118: 12 bf ff e1 bne 4000f09c <_Thread_Handler+0x7c> 4000f11c: 01 00 00 00 nop (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 4000f120: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 4000f124: d0 06 a0 b0 ld [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED 4000f128: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000f12c: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000f130: 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 ); 4000f134: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000f138: 7f ff f1 2c call 4000b5e8 <_User_extensions_Thread_exitted> <== NOT EXECUTED 4000f13c: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 4000f140: 7f ff e5 c3 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 4000f144: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED _Thread_Dispatch(); 4000f148: 7f ff ec 67 call 4000a2e4 <_Thread_Dispatch> 4000f14c: 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) */ 4000f150: 10 bf ff cb b 4000f07c <_Thread_Handler+0x5c> 4000f154: 83 2e 60 18 sll %i1, 0x18, %g1 (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 4000f158: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 4000f15c: d0 1e a0 b0 ldd [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED 4000f160: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000f164: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000f168: 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 ); 4000f16c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000f170: 7f ff f1 1e call 4000b5e8 <_User_extensions_Thread_exitted> <== NOT EXECUTED 4000f174: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 4000f178: 7f ff e5 b5 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 4000f17c: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED 4000f180: 01 00 00 00 nop 4000a600 <_Thread_Handler_initialization>: void _Thread_Handler_initialization( uint32_t ticks_per_timeslice, uint32_t maximum_extensions, uint32_t maximum_proxies ) { 4000a600: 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 ) 4000a604: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a608: 82 10 61 a4 or %g1, 0x1a4, %g1 ! 4001ada4 <_CPU_Table> 4000a60c: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 4000a610: c6 00 60 24 ld [ %g1 + 0x24 ], %g3 4000a614: 80 a0 00 02 cmp %g0, %g2 4000a618: 88 60 3f ff subx %g0, -1, %g4 4000a61c: 80 a0 00 03 cmp %g0, %g3 4000a620: 82 60 3f ff subx %g0, -1, %g1 4000a624: 80 a1 00 01 cmp %g4, %g1 4000a628: 12 80 00 2c bne 4000a6d8 <_Thread_Handler_initialization+0xd8> 4000a62c: 90 10 20 00 clr %o0 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 4000a630: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _Thread_Executing = NULL; 4000a634: 05 10 00 6b sethi %hi(0x4001ac00), %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 4000a638: c0 20 62 7c clr [ %g1 + 0x27c ] _Thread_Executing = NULL; 4000a63c: c0 20 a2 6c clr [ %g2 + 0x26c ] _Thread_Heir = NULL; 4000a640: 03 10 00 6b sethi %hi(0x4001ac00), %g1 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; 4000a644: 05 10 00 6b sethi %hi(0x4001ac00), %g2 INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; _Thread_Executing = NULL; _Thread_Heir = NULL; 4000a648: c0 20 62 44 clr [ %g1 + 0x244 ] #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; 4000a64c: c0 20 a2 5c clr [ %g2 + 0x25c ] _Thread_Maximum_extensions = maximum_extensions; 4000a650: 03 10 00 6b sethi %hi(0x4001ac00), %g1 _Thread_Ticks_per_timeslice = ticks_per_timeslice; 4000a654: 05 10 00 6b sethi %hi(0x4001ac00), %g2 _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; _Thread_Maximum_extensions = maximum_extensions; 4000a658: f2 20 62 58 st %i1, [ %g1 + 0x258 ] _Thread_Ticks_per_timeslice = ticks_per_timeslice; 4000a65c: f0 20 a0 e8 st %i0, [ %g2 + 0xe8 ] _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 4000a660: 40 00 05 13 call 4000baac <_Workspace_Allocate_or_fatal_error> 4000a664: 90 10 2c 00 mov 0xc00, %o0 4000a668: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a66c: 84 10 00 08 mov %o0, %g2 4000a670: d0 20 60 e4 st %o0, [ %g1 + 0xe4 ] 4000a674: 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); 4000a678: 82 00 a0 04 add %g2, 4, %g1 the_chain->permanent_null = NULL; 4000a67c: c0 20 a0 04 clr [ %g2 + 4 ] the_chain->last = _Chain_Head(the_chain); 4000a680: 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); 4000a684: c2 20 80 00 st %g1, [ %g2 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4000a688: 84 00 a0 0c add %g2, 0xc, %g2 (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 4000a68c: 80 a0 80 03 cmp %g2, %g3 4000a690: 12 bf ff fb bne 4000a67c <_Thread_Handler_initialization+0x7c> 4000a694: 82 00 a0 04 add %g2, 4, %g1 /* * Initialize this class of objects. */ _Objects_Initialize_information( 4000a698: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000a69c: c4 00 62 98 ld [ %g1 + 0x298 ], %g2 ! 4001ae98 <_System_state_Is_multiprocessing> 4000a6a0: 82 10 20 08 mov 8, %g1 4000a6a4: 80 a0 00 02 cmp %g0, %g2 4000a6a8: 96 10 20 02 mov 2, %o3 4000a6ac: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 4000a6b0: 96 42 ff ff addx %o3, -1, %o3 4000a6b4: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000a6b8: 92 10 20 01 mov 1, %o1 4000a6bc: 90 12 23 20 or %o0, 0x320, %o0 4000a6c0: 94 10 20 01 mov 1, %o2 4000a6c4: 98 10 21 80 mov 0x180, %o4 4000a6c8: 7f ff fa 06 call 40008ee0 <_Objects_Initialize_information> 4000a6cc: 9a 10 20 01 mov 1, %o5 FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 4000a6d0: 81 c7 e0 08 ret 4000a6d4: 81 e8 00 00 restore * Do not allow mixture. */ if ( !( ( _CPU_Table.stack_allocate_hook == 0 ) == ( _CPU_Table.stack_free_hook == 0 ) ) ) _Internal_error_Occurred( 4000a6d8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 4000a6dc: 7f ff f8 5c call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 4000a6e0: 94 10 20 0f mov 0xf, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 4000a6e4: 10 bf ff d4 b 4000a634 <_Thread_Handler_initialization+0x34> <== NOT EXECUTED 4000a6e8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000a444 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 4000a444: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the Ada self pointer */ the_thread->rtems_ada_self = NULL; 4000a448: c0 26 60 80 clr [ %i1 + 0x80 ] /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 4000a44c: 80 a6 a0 00 cmp %i2, 0 4000a450: 02 80 00 59 be 4000a5b4 <_Thread_Initialize+0x170> 4000a454: e2 07 a0 60 ld [ %fp + 0x60 ], %l1 stack = the_thread->Start.stack; the_thread->Start.core_allocated_stack = TRUE; } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 4000a458: c0 26 60 cc clr [ %i1 + 0xcc ] <== NOT EXECUTED 4000a45c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 4000a460: 21 10 00 6b sethi %hi(0x4001ac00), %l0 4000a464: d2 04 22 58 ld [ %l0 + 0x258 ], %o1 ! 4001ae58 <_Thread_Maximum_extensions> Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 4000a468: f4 26 60 d4 st %i2, [ %i1 + 0xd4 ] the_stack->size = size; 4000a46c: d0 26 60 d0 st %o0, [ %i1 + 0xd0 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4000a470: c0 26 60 50 clr [ %i1 + 0x50 ] the_watchdog->routine = routine; 4000a474: c0 26 60 64 clr [ %i1 + 0x64 ] the_watchdog->id = id; 4000a478: c0 26 60 68 clr [ %i1 + 0x68 ] the_watchdog->user_data = user_data; 4000a47c: c0 26 60 6c clr [ %i1 + 0x6c ] 4000a480: 80 a2 60 00 cmp %o1, 0 4000a484: 12 80 00 38 bne 4000a564 <_Thread_Initialize+0x120> 4000a488: c0 26 61 68 clr [ %i1 + 0x168 ] return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 4000a48c: c0 26 61 78 clr [ %i1 + 0x178 ] 4000a490: b6 10 20 00 clr %i3 /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 4000a494: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 the_thread->Start.budget_algorithm = budget_algorithm; 4000a498: e2 26 60 bc st %l1, [ %i1 + 0xbc ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 4000a49c: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 4000a4a0: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 switch ( budget_algorithm ) { 4000a4a4: 80 a4 60 02 cmp %l1, 2 4000a4a8: 12 80 00 05 bne 4000a4bc <_Thread_Initialize+0x78> 4000a4ac: 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; 4000a4b0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000a4b4: c4 00 60 e8 ld [ %g1 + 0xe8 ], %g2 ! 4001ace8 <_Thread_Ticks_per_timeslice> <== NOT EXECUTED 4000a4b8: c4 26 60 84 st %g2, [ %i1 + 0x84 ] <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 4000a4bc: c2 07 a0 68 ld [ %fp + 0x68 ], %g1 the_thread->current_state = STATES_DORMANT; the_thread->Wait.queue = NULL; 4000a4c0: c0 26 60 44 clr [ %i1 + 0x44 ] break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 4000a4c4: c2 26 60 c4 st %g1, [ %i1 + 0xc4 ] the_thread->current_state = STATES_DORMANT; 4000a4c8: 82 10 20 01 mov 1, %g1 the_thread->Wait.queue = NULL; the_thread->resource_count = 0; 4000a4cc: c0 26 60 1c clr [ %i1 + 0x1c ] break; } the_thread->Start.isr_level = isr_level; the_thread->current_state = STATES_DORMANT; 4000a4d0: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_thread->Wait.queue = NULL; the_thread->resource_count = 0; the_thread->suspend_count = 0; 4000a4d4: c0 26 60 70 clr [ %i1 + 0x70 ] the_thread->real_priority = priority; 4000a4d8: fa 26 60 18 st %i5, [ %i1 + 0x18 ] the_thread->Start.initial_priority = priority; 4000a4dc: fa 26 60 c8 st %i5, [ %i1 + 0xc8 ] _Thread_Set_priority( the_thread, priority ); 4000a4e0: 92 10 00 1d mov %i5, %o1 4000a4e4: 40 00 02 76 call 4000aebc <_Thread_Set_priority> 4000a4e8: 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 ); 4000a4ec: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000a4f0: 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; 4000a4f4: c0 26 60 90 clr [ %i1 + 0x90 ] 4000a4f8: 03 00 00 3f sethi %hi(0xfc00), %g1 4000a4fc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000a500: 82 08 80 01 and %g2, %g1, %g1 4000a504: 80 a0 40 03 cmp %g1, %g3 4000a508: 08 80 00 13 bleu 4000a554 <_Thread_Initialize+0x110> 4000a50c: c0 26 60 94 clr [ %i1 + 0x94 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 4000a510: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 /* * Invoke create extensions */ if ( !_User_extensions_Thread_create( the_thread ) ) { 4000a514: 90 10 00 19 mov %i1, %o0 4000a518: c2 26 60 0c st %g1, [ %i1 + 0xc ] 4000a51c: 40 00 04 46 call 4000b634 <_User_extensions_Thread_create> 4000a520: b0 10 20 01 mov 1, %i0 4000a524: 80 a2 20 00 cmp %o0, 0 4000a528: 12 80 00 34 bne 4000a5f8 <_Thread_Initialize+0x1b4> 4000a52c: 80 a6 e0 00 cmp %i3, 0 if ( extensions_area ) 4000a530: 02 80 00 05 be 4000a544 <_Thread_Initialize+0x100> 4000a534: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000a538: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 4000a53c: 7f ff f7 c4 call 4000844c <_Heap_Free> <== NOT EXECUTED 4000a540: 90 12 21 dc or %o0, 0x1dc, %o0 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); 4000a544: 40 00 03 22 call 4000b1cc <_Thread_Stack_Free> 4000a548: 90 10 00 19 mov %i1, %o0 4000a54c: 81 c7 e0 08 ret 4000a550: 91 e8 20 00 restore %g0, 0, %o0 uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) information->local_table[ index ] = the_object; 4000a554: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 4000a558: 83 28 60 02 sll %g1, 2, %g1 4000a55c: 10 bf ff ed b 4000a510 <_Thread_Initialize+0xcc> 4000a560: f2 20 80 01 st %i1, [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 4000a564: 92 02 60 01 inc %o1 4000a568: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000a56c: 93 2a 60 02 sll %o1, 2, %o1 4000a570: 7f ff f7 85 call 40008384 <_Heap_Allocate> 4000a574: 90 12 21 dc or %o0, 0x1dc, %o0 if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 4000a578: b6 92 20 00 orcc %o0, 0, %i3 4000a57c: 02 80 00 1c be 4000a5ec <_Thread_Initialize+0x1a8> 4000a580: c2 04 22 58 ld [ %l0 + 0x258 ], %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 4000a584: 80 a0 7f ff cmp %g1, -1 4000a588: 02 bf ff c3 be 4000a494 <_Thread_Initialize+0x50> 4000a58c: f6 26 61 78 st %i3, [ %i1 + 0x178 ] 4000a590: 86 00 60 01 add %g1, 1, %g3 4000a594: 84 10 20 00 clr %g2 the_thread->extensions[i] = NULL; 4000a598: 83 28 a0 02 sll %g2, 2, %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 4000a59c: 84 00 a0 01 inc %g2 4000a5a0: 80 a0 80 03 cmp %g2, %g3 4000a5a4: 12 bf ff fd bne 4000a598 <_Thread_Initialize+0x154> 4000a5a8: c0 26 c0 01 clr [ %i3 + %g1 ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 4000a5ac: 10 bf ff bb b 4000a498 <_Thread_Initialize+0x54> 4000a5b0: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { if ( !_Stack_Is_enough( stack_size ) ) 4000a5b4: 80 a6 ef ff cmp %i3, 0xfff 4000a5b8: 08 80 00 03 bleu 4000a5c4 <_Thread_Initialize+0x180> 4000a5bc: 13 00 00 04 sethi %hi(0x1000), %o1 4000a5c0: 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 ); 4000a5c4: 40 00 02 e7 call 4000b160 <_Thread_Stack_Allocate> 4000a5c8: 90 10 00 19 mov %i1, %o0 if ( !actual_stack_size || actual_stack_size < stack_size ) 4000a5cc: 80 a2 20 00 cmp %o0, 0 4000a5d0: 02 bf ff df be 4000a54c <_Thread_Initialize+0x108> 4000a5d4: 80 a6 c0 08 cmp %i3, %o0 4000a5d8: 18 bf ff dd bgu 4000a54c <_Thread_Initialize+0x108> 4000a5dc: 82 10 20 01 mov 1, %g1 return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 4000a5e0: f4 06 60 d8 ld [ %i1 + 0xd8 ], %i2 the_thread->Start.core_allocated_stack = TRUE; 4000a5e4: 10 bf ff 9f b 4000a460 <_Thread_Initialize+0x1c> 4000a5e8: c2 26 60 cc st %g1, [ %i1 + 0xcc ] #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); 4000a5ec: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4000a5f0: 40 00 02 f7 call 4000b1cc <_Thread_Stack_Free> <== NOT EXECUTED 4000a5f4: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000a5f8: 81 c7 e0 08 ret 4000a5fc: 81 e8 00 00 restore 4000f420 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { 4000f420: 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; 4000f424: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000f428: c4 06 20 bc ld [ %i0 + 0xbc ], %g2 the_thread->budget_callout = the_thread->Start.budget_callout; 4000f42c: 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; 4000f430: 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; 4000f434: c4 3e 20 88 std %g2, [ %i0 + 0x88 ] the_thread->Start.pointer_argument = pointer_argument; 4000f438: f2 26 20 b0 st %i1, [ %i0 + 0xb0 ] the_thread->Start.numeric_argument = numeric_argument; 4000f43c: f4 26 20 b4 st %i2, [ %i0 + 0xb4 ] Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { the_thread->resource_count = 0; 4000f440: c0 26 20 1c clr [ %i0 + 0x1c ] the_thread->suspend_count = 0; 4000f444: 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 ) ) { 4000f448: 7f ff f1 24 call 4000b8d8 <_Thread_queue_Extract_with_proxy> 4000f44c: 90 10 00 18 mov %i0, %o0 4000f450: 80 a2 20 00 cmp %o0, 0 4000f454: 32 80 00 07 bne,a 4000f470 <_Thread_Reset+0x50> 4000f458: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 if ( _Watchdog_Is_active( &the_thread->Timer ) ) 4000f45c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000f460: 80 a0 60 02 cmp %g1, 2 4000f464: 02 80 00 0c be 4000f494 <_Thread_Reset+0x74> 4000f468: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 4000f46c: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 4000f470: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4000f474: 80 a0 40 19 cmp %g1, %i1 4000f478: 02 80 00 05 be 4000f48c <_Thread_Reset+0x6c> 4000f47c: 01 00 00 00 nop the_thread->real_priority = the_thread->Start.initial_priority; 4000f480: f2 26 20 18 st %i1, [ %i0 + 0x18 ] _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 4000f484: 7f ff f1 d6 call 4000bbdc <_Thread_Set_priority> 4000f488: 81 e8 00 00 restore 4000f48c: 81 c7 e0 08 ret 4000f490: 81 e8 00 00 restore the_thread->Start.numeric_argument = numeric_argument; if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 4000f494: 7f ff f4 81 call 4000c698 <_Watchdog_Remove> <== NOT EXECUTED 4000f498: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 4000f49c: 10 bf ff f5 b 4000f470 <_Thread_Reset+0x50> <== NOT EXECUTED 4000f4a0: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 <== NOT EXECUTED 4000e628 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 4000e628: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 4000e62c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000e630: e0 00 62 6c ld [ %g1 + 0x26c ], %l0 ! 4001ae6c <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 4000e634: 7f ff ce 66 call 40001fcc 4000e638: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 4000e63c: b0 10 00 08 mov %o0, %i0 if ( _Chain_Has_only_one_node( ready ) ) { 4000e640: c4 04 40 00 ld [ %l1 ], %g2 4000e644: c2 04 60 08 ld [ %l1 + 8 ], %g1 4000e648: 80 a0 80 01 cmp %g2, %g1 4000e64c: 32 80 00 04 bne,a 4000e65c <_Thread_Reset_timeslice+0x34> 4000e650: c6 04 00 00 ld [ %l0 ], %g3 _ISR_Enable( level ); 4000e654: 7f ff ce 62 call 40001fdc 4000e658: 81 e8 00 00 restore { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 4000e65c: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000e660: 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; 4000e664: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000e668: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000e66c: 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; 4000e670: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 4000e674: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000e678: 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; 4000e67c: e0 20 40 00 st %l0, [ %g1 ] return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 4000e680: 7f ff ce 57 call 40001fdc 4000e684: 01 00 00 00 nop 4000e688: 7f ff ce 51 call 40001fcc 4000e68c: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 4000e690: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000e694: c2 00 a2 44 ld [ %g2 + 0x244 ], %g1 ! 4001ae44 <_Thread_Heir> 4000e698: 80 a4 00 01 cmp %l0, %g1 4000e69c: 32 80 00 05 bne,a 4000e6b0 <_Thread_Reset_timeslice+0x88> 4000e6a0: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 4000e6a4: c2 04 40 00 ld [ %l1 ], %g1 4000e6a8: c2 20 a2 44 st %g1, [ %g2 + 0x244 ] _Context_Switch_necessary = TRUE; 4000e6ac: 84 10 20 01 mov 1, %g2 4000e6b0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000e6b4: c4 20 62 7c st %g2, [ %g1 + 0x27c ] ! 4001ae7c <_Context_Switch_necessary> _ISR_Enable( level ); 4000e6b8: 7f ff ce 49 call 40001fdc 4000e6bc: 81 e8 00 00 restore 4000e6c0: 01 00 00 00 nop 4000ca10 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, boolean force ) { 4000ca10: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; States_Control current_state; _ISR_Disable( level ); 4000ca14: 7f ff d8 b6 call 40002cec 4000ca18: 01 00 00 00 nop 4000ca1c: a0 10 00 08 mov %o0, %l0 if ( force == TRUE ) 4000ca20: 80 a6 60 01 cmp %i1, 1 4000ca24: 22 80 00 13 be,a 4000ca70 <_Thread_Resume+0x60> 4000ca28: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 the_thread->suspend_count = 0; else the_thread->suspend_count--; 4000ca2c: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED 4000ca30: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 4000ca34: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000ca38: 12 80 00 0c bne 4000ca68 <_Thread_Resume+0x58> <== NOT EXECUTED 4000ca3c: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED _ISR_Enable( level ); return; } current_state = the_thread->current_state; 4000ca40: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 4000ca44: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 4000ca48: 02 80 00 06 be 4000ca60 <_Thread_Resume+0x50> <== NOT EXECUTED 4000ca4c: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 4000ca50: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 4000ca54: 80 a0 60 00 cmp %g1, 0 4000ca58: 02 80 00 0b be 4000ca84 <_Thread_Resume+0x74> 4000ca5c: c2 26 20 10 st %g1, [ %i0 + 0x10 ] _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 4000ca60: 7f ff d8 a7 call 40002cfc 4000ca64: 91 e8 00 10 restore %g0, %l0, %o0 the_thread->suspend_count = 0; else the_thread->suspend_count--; if ( the_thread->suspend_count > 0 ) { _ISR_Enable( level ); 4000ca68: 7f ff d8 a5 call 40002cfc <== NOT EXECUTED 4000ca6c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { 4000ca70: 80 88 60 02 btst 2, %g1 4000ca74: 02 bf ff fb be 4000ca60 <_Thread_Resume+0x50> 4000ca78: c0 26 20 70 clr [ %i0 + 0x70 ] 4000ca7c: 10 bf ff f6 b 4000ca54 <_Thread_Resume+0x44> 4000ca80: 82 08 7f fd and %g1, -3, %g1 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 4000ca84: c8 06 20 9c ld [ %i0 + 0x9c ], %g4 4000ca88: c4 16 20 a2 lduh [ %i0 + 0xa2 ], %g2 4000ca8c: c2 11 00 00 lduh [ %g4 ], %g1 if ( _States_Is_ready( current_state ) ) { _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 4000ca90: c6 06 20 98 ld [ %i0 + 0x98 ], %g3 4000ca94: 82 10 40 02 or %g1, %g2, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 4000ca98: 1b 10 00 9d sethi %hi(0x40027400), %o5 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 4000ca9c: c2 31 00 00 sth %g1, [ %g4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000caa0: 82 00 e0 04 add %g3, 4, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 4000caa4: d8 16 20 a0 lduh [ %i0 + 0xa0 ], %o4 4000caa8: c2 26 00 00 st %g1, [ %i0 ] 4000caac: c4 13 60 30 lduh [ %o5 + 0x30 ], %g2 old_last_node = the_chain->last; 4000cab0: c8 00 e0 08 ld [ %g3 + 8 ], %g4 the_chain->last = the_node; 4000cab4: f0 20 e0 08 st %i0, [ %g3 + 8 ] 4000cab8: 84 10 80 0c or %g2, %o4, %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 4000cabc: c8 26 20 04 st %g4, [ %i0 + 4 ] 4000cac0: c4 33 60 30 sth %g2, [ %o5 + 0x30 ] 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; 4000cac4: f0 21 00 00 st %i0, [ %g4 ] _ISR_Flash( level ); 4000cac8: 7f ff d8 8d call 40002cfc 4000cacc: 90 10 00 10 mov %l0, %o0 4000cad0: 7f ff d8 87 call 40002cec 4000cad4: 01 00 00 00 nop if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 4000cad8: 09 10 00 9d sethi %hi(0x40027400), %g4 4000cadc: c4 01 20 14 ld [ %g4 + 0x14 ], %g2 ! 40027414 <_Thread_Heir> 4000cae0: c6 06 20 14 ld [ %i0 + 0x14 ], %g3 4000cae4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 4000cae8: 80 a0 c0 01 cmp %g3, %g1 4000caec: 1a bf ff dd bcc 4000ca60 <_Thread_Resume+0x50> 4000caf0: 01 00 00 00 nop _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 4000caf4: 03 10 00 9d sethi %hi(0x40027400), %g1 4000caf8: c4 00 60 3c ld [ %g1 + 0x3c ], %g2 ! 4002743c <_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; 4000cafc: f0 21 20 14 st %i0, [ %g4 + 0x14 ] if ( _Thread_Executing->is_preemptible || 4000cb00: c2 00 a0 7c ld [ %g2 + 0x7c ], %g1 4000cb04: 80 a0 60 00 cmp %g1, 0 4000cb08: 02 80 00 06 be 4000cb20 <_Thread_Resume+0x110> 4000cb0c: 80 a0 e0 00 cmp %g3, 0 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 4000cb10: 84 10 20 01 mov 1, %g2 4000cb14: 03 10 00 9d sethi %hi(0x40027400), %g1 4000cb18: c4 20 60 4c st %g2, [ %g1 + 0x4c ] ! 4002744c <_Context_Switch_necessary> 4000cb1c: 30 bf ff d1 b,a 4000ca60 <_Thread_Resume+0x50> _ISR_Flash( level ); if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 4000cb20: 12 bf ff d0 bne 4000ca60 <_Thread_Resume+0x50> 4000cb24: 84 10 20 01 mov 1, %g2 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 4000cb28: 10 bf ff fc b 4000cb18 <_Thread_Resume+0x108> <== NOT EXECUTED 4000cb2c: 03 10 00 9d sethi %hi(0x40027400), %g1 <== NOT EXECUTED 4000b160 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 4000b160: 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 ) ) 4000b164: 80 a6 6f ff cmp %i1, 0xfff 4000b168: 28 80 00 02 bleu,a 4000b170 <_Thread_Stack_Allocate+0x10> 4000b16c: 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 ) { 4000b170: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000b174: c2 00 61 c4 ld [ %g1 + 0x1c4 ], %g1 ! 4001adc4 <_CPU_Table+0x20> 4000b178: 80 a0 60 00 cmp %g1, 0 4000b17c: 02 80 00 0a be 4000b1a4 <_Thread_Stack_Allocate+0x44> 4000b180: 92 06 60 10 add %i1, 0x10, %o1 stack_addr = (*_CPU_Table.stack_allocate_hook)( the_stack_size ); 4000b184: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000b188: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 4000b18c: d0 26 20 d8 st %o0, [ %i0 + 0xd8 ] <== NOT EXECUTED the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 4000b190: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 4000b194: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 4000b198: b0 0e 40 18 and %i1, %i0, %i0 <== NOT EXECUTED 4000b19c: 81 c7 e0 08 ret <== NOT EXECUTED 4000b1a0: 81 e8 00 00 restore <== NOT EXECUTED 4000b1a4: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000b1a8: b2 10 00 09 mov %o1, %i1 4000b1ac: 7f ff f4 76 call 40008384 <_Heap_Allocate> 4000b1b0: 90 12 21 dc or %o0, 0x1dc, %o0 } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 4000b1b4: d0 26 20 d8 st %o0, [ %i0 + 0xd8 ] the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 4000b1b8: 80 a0 00 08 cmp %g0, %o0 4000b1bc: b0 60 20 00 subx %g0, 0, %i0 the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 4000b1c0: b0 0e 40 18 and %i1, %i0, %i0 4000b1c4: 81 c7 e0 08 ret 4000b1c8: 81 e8 00 00 restore 4000b1cc <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 4000b1cc: 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 ) 4000b1d0: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 4000b1d4: 80 a0 60 00 cmp %g1, 0 4000b1d8: 02 80 00 08 be 4000b1f8 <_Thread_Stack_Free+0x2c> 4000b1dc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( _CPU_Table.stack_free_hook ) 4000b1e0: c2 00 61 c8 ld [ %g1 + 0x1c8 ], %g1 ! 4001adc8 <_CPU_Table+0x24> 4000b1e4: 80 a0 60 00 cmp %g1, 0 4000b1e8: 22 80 00 06 be,a 4000b200 <_Thread_Stack_Free+0x34> 4000b1ec: f2 06 20 d4 ld [ %i0 + 0xd4 ], %i1 (*_CPU_Table.stack_free_hook)( the_thread->Start.Initial_stack.area ); 4000b1f0: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000b1f4: d0 06 20 d4 ld [ %i0 + 0xd4 ], %o0 <== NOT EXECUTED 4000b1f8: 81 c7 e0 08 ret <== NOT EXECUTED 4000b1fc: 81 e8 00 00 restore <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4000b200: 31 10 00 6b sethi %hi(0x4001ac00), %i0 4000b204: 7f ff f4 92 call 4000844c <_Heap_Free> 4000b208: 91 ee 21 dc restore %i0, 0x1dc, %o0 4000b20c: 01 00 00 00 nop 4000b298 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 4000b298: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; 4000b29c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000b2a0: e0 00 62 6c ld [ %g1 + 0x26c ], %l0 ! 4001ae6c <_Thread_Executing> /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 4000b2a4: c4 04 20 7c ld [ %l0 + 0x7c ], %g2 4000b2a8: 80 a0 a0 00 cmp %g2, 0 4000b2ac: 02 80 00 24 be 4000b33c <_Thread_Tickle_timeslice+0xa4> 4000b2b0: 01 00 00 00 nop return; if ( !_States_Is_ready( executing->current_state ) ) 4000b2b4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 4000b2b8: 80 a0 60 00 cmp %g1, 0 4000b2bc: 12 80 00 20 bne 4000b33c <_Thread_Tickle_timeslice+0xa4> 4000b2c0: 01 00 00 00 nop /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 4000b2c4: c2 04 20 88 ld [ %l0 + 0x88 ], %g1 4000b2c8: 80 a0 60 01 cmp %g1, 1 4000b2cc: 0a 80 00 09 bcs 4000b2f0 <_Thread_Tickle_timeslice+0x58> 4000b2d0: 80 a0 60 02 cmp %g1, 2 4000b2d4: 18 80 00 09 bgu 4000b2f8 <_Thread_Tickle_timeslice+0x60> 4000b2d8: 80 a0 60 03 cmp %g1, 3 case THREAD_CPU_BUDGET_ALGORITHM_NONE: break; case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: if ( (int)(--executing->cpu_time_budget) <= 0 ) { 4000b2dc: c2 04 20 84 ld [ %l0 + 0x84 ], %g1 4000b2e0: 82 00 7f ff add %g1, -1, %g1 4000b2e4: 80 a0 60 00 cmp %g1, 0 4000b2e8: 04 80 00 10 ble 4000b328 <_Thread_Tickle_timeslice+0x90> 4000b2ec: c2 24 20 84 st %g1, [ %l0 + 0x84 ] 4000b2f0: 81 c7 e0 08 ret 4000b2f4: 81 e8 00 00 restore /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 4000b2f8: 12 80 00 11 bne 4000b33c <_Thread_Tickle_timeslice+0xa4> <== NOT EXECUTED 4000b2fc: 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 ) 4000b300: c2 04 20 84 ld [ %l0 + 0x84 ], %g1 <== NOT EXECUTED 4000b304: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000b308: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000b30c: 12 bf ff f9 bne 4000b2f0 <_Thread_Tickle_timeslice+0x58> <== NOT EXECUTED 4000b310: c2 24 20 84 st %g1, [ %l0 + 0x84 ] <== NOT EXECUTED (*executing->budget_callout)( executing ); 4000b314: c2 04 20 8c ld [ %l0 + 0x8c ], %g1 <== NOT EXECUTED 4000b318: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000b31c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 4000b320: 81 c7 e0 08 ret <== NOT EXECUTED 4000b324: 81 e8 00 00 restore <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: if ( (int)(--executing->cpu_time_budget) <= 0 ) { _Thread_Reset_timeslice(); 4000b328: 40 00 0c c0 call 4000e628 <_Thread_Reset_timeslice> 4000b32c: 01 00 00 00 nop executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 4000b330: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000b334: c4 00 60 e8 ld [ %g1 + 0xe8 ], %g2 ! 4001ace8 <_Thread_Ticks_per_timeslice> 4000b338: c4 24 20 84 st %g2, [ %l0 + 0x84 ] 4000b33c: 81 c7 e0 08 ret 4000b340: 81 e8 00 00 restore 4000b344 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 4000b344: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 4000b348: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000b34c: e0 00 62 6c ld [ %g1 + 0x26c ], %l0 ! 4001ae6c <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 4000b350: 7f ff db 1f call 40001fcc 4000b354: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 4000b358: b0 10 00 08 mov %o0, %i0 if ( !_Chain_Has_only_one_node( ready ) ) { 4000b35c: c4 04 40 00 ld [ %l1 ], %g2 4000b360: c2 04 60 08 ld [ %l1 + 8 ], %g1 4000b364: 80 a0 80 01 cmp %g2, %g1 4000b368: 12 80 00 0b bne 4000b394 <_Thread_Yield_processor+0x50> 4000b36c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 4000b370: c4 00 62 44 ld [ %g1 + 0x244 ], %g2 ! 4001ae44 <_Thread_Heir> 4000b374: 80 a4 00 02 cmp %l0, %g2 4000b378: 02 80 00 05 be 4000b38c <_Thread_Yield_processor+0x48> 4000b37c: 01 00 00 00 nop _Context_Switch_necessary = TRUE; 4000b380: 84 10 20 01 mov 1, %g2 ! 1 4000b384: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000b388: c4 20 62 7c st %g2, [ %g1 + 0x27c ] ! 4001ae7c <_Context_Switch_necessary> _ISR_Enable( level ); 4000b38c: 7f ff db 14 call 40001fdc 4000b390: 81 e8 00 00 restore ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 4000b394: c6 04 00 00 ld [ %l0 ], %g3 previous = the_node->previous; 4000b398: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000b39c: 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; 4000b3a0: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000b3a4: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000b3a8: 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; 4000b3ac: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 4000b3b0: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000b3b4: 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; 4000b3b8: e0 20 40 00 st %l0, [ %g1 ] _ISR_Disable( level ); if ( !_Chain_Has_only_one_node( ready ) ) { _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 4000b3bc: 7f ff db 08 call 40001fdc 4000b3c0: 01 00 00 00 nop 4000b3c4: 7f ff db 02 call 40001fcc 4000b3c8: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 4000b3cc: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000b3d0: c2 00 a2 44 ld [ %g2 + 0x244 ], %g1 ! 4001ae44 <_Thread_Heir> 4000b3d4: 80 a4 00 01 cmp %l0, %g1 4000b3d8: 32 bf ff eb bne,a 4000b384 <_Thread_Yield_processor+0x40> 4000b3dc: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 4000b3e0: c2 04 40 00 ld [ %l1 ], %g1 4000b3e4: 10 bf ff e7 b 4000b380 <_Thread_Yield_processor+0x3c> 4000b3e8: c2 20 a2 44 st %g1, [ %g2 + 0x244 ] 4000a6ec <_Thread_queue_Dequeue>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 4000a6ec: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4000a6f0: 80 a0 60 00 cmp %g1, 0 4000a6f4: 12 80 00 05 bne 4000a708 <_Thread_queue_Dequeue+0x1c> 4000a6f8: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); 4000a6fc: 82 13 c0 00 mov %o7, %g1 4000a700: 40 00 0e c2 call 4000e208 <_Thread_queue_Dequeue_fifo> 4000a704: 9e 10 40 00 mov %g1, %o7 Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 4000a708: 02 80 00 04 be 4000a718 <_Thread_queue_Dequeue+0x2c> 4000a70c: 01 00 00 00 nop the_thread = NULL; break; } return( the_thread ); } 4000a710: 81 c3 e0 08 retl <== NOT EXECUTED 4000a714: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED switch ( the_thread_queue->discipline ) { case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_Dequeue_priority( the_thread_queue ); 4000a718: 82 13 c0 00 mov %o7, %g1 4000a71c: 40 00 00 03 call 4000a728 <_Thread_queue_Dequeue_priority> 4000a720: 9e 10 40 00 mov %g1, %o7 4000a724: 01 00 00 00 nop 4000e208 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 4000e208: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 4000e20c: 7f ff cf 70 call 40001fcc 4000e210: a0 10 00 18 mov %i0, %l0 4000e214: 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)); 4000e218: f0 06 00 00 ld [ %i0 ], %i0 if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 4000e21c: 82 04 20 04 add %l0, 4, %g1 4000e220: 80 a6 00 01 cmp %i0, %g1 4000e224: 22 80 00 1d be,a 4000e298 <_Thread_queue_Dequeue_fifo+0x90> 4000e228: 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; 4000e22c: c2 06 00 00 ld [ %i0 ], %g1 the_chain->first = new_first; 4000e230: 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 ) ) { 4000e234: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 new_first->previous = _Chain_Head(the_chain); 4000e238: e0 20 60 04 st %l0, [ %g1 + 4 ] 4000e23c: 80 a0 a0 02 cmp %g2, 2 4000e240: 02 80 00 0a be 4000e268 <_Thread_queue_Dequeue_fifo+0x60> 4000e244: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 4000e248: 7f ff cf 65 call 40001fdc 4000e24c: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000e250: 90 10 00 18 mov %i0, %o0 4000e254: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000e258: 7f ff ef 6e call 4000a010 <_Thread_Clear_state> 4000e25c: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 4000e260: 81 c7 e0 08 ret 4000e264: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 4000e268: 82 10 20 03 mov 3, %g1 4000e26c: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000e270: 7f ff cf 5b call 40001fdc 4000e274: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 4000e278: 7f ff f5 ac call 4000b928 <_Watchdog_Remove> 4000e27c: 90 06 20 48 add %i0, 0x48, %o0 4000e280: 90 10 00 18 mov %i0, %o0 4000e284: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000e288: 7f ff ef 62 call 4000a010 <_Thread_Clear_state> 4000e28c: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 4000e290: 81 c7 e0 08 ret 4000e294: 81 e8 00 00 restore #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 4000e298: 80 a0 60 02 cmp %g1, 2 4000e29c: 18 80 00 0c bgu 4000e2cc <_Thread_queue_Dequeue_fifo+0xc4> 4000e2a0: 80 a0 60 03 cmp %g1, 3 4000e2a4: 80 a0 60 01 cmp %g1, 1 4000e2a8: 0a 80 00 0b bcs 4000e2d4 <_Thread_queue_Dequeue_fifo+0xcc> 4000e2ac: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 4000e2b0: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 4000e2b4: 7f ff cf 4a call 40001fdc <== NOT EXECUTED 4000e2b8: 01 00 00 00 nop <== NOT EXECUTED return _Thread_Executing; 4000e2bc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000e2c0: f0 00 62 6c ld [ %g1 + 0x26c ], %i0 ! 4001ae6c <_Thread_Executing> <== NOT EXECUTED } return NULL; /* this is only to prevent warnings */ } 4000e2c4: 81 c7 e0 08 ret <== NOT EXECUTED 4000e2c8: 81 e8 00 00 restore <== NOT EXECUTED #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 4000e2cc: 12 bf ff e5 bne 4000e260 <_Thread_queue_Dequeue_fifo+0x58> <== NOT EXECUTED 4000e2d0: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 4000e2d4: b0 10 20 00 clr %i0 4000e2d8: 7f ff cf 41 call 40001fdc 4000e2dc: 90 10 00 02 mov %g2, %o0 4000e2e0: 81 c7 e0 08 ret 4000e2e4: 81 e8 00 00 restore 4000a728 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 4000a728: 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 ); 4000a72c: 7f ff de 28 call 40001fcc 4000a730: 01 00 00 00 nop 4000a734: 9a 10 00 08 mov %o0, %o5 4000a738: 86 10 20 00 clr %g3 4000a73c: 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)); 4000a740: 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 ] ) ) { 4000a744: 85 28 e0 02 sll %g3, 2, %g2 4000a748: 83 28 e0 04 sll %g3, 4, %g1 4000a74c: 82 20 40 02 sub %g1, %g2, %g1 4000a750: 82 06 00 01 add %i0, %g1, %g1 4000a754: 82 00 60 04 add %g1, 4, %g1 4000a758: 80 a2 00 01 cmp %o0, %g1 4000a75c: 12 80 00 50 bne 4000a89c <_Thread_queue_Dequeue_priority+0x174> 4000a760: 88 01 20 0c add %g4, 0xc, %g4 Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 4000a764: 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 ; 4000a768: 80 a0 e0 04 cmp %g3, 4 4000a76c: 32 bf ff f6 bne,a 4000a744 <_Thread_queue_Dequeue_priority+0x1c> 4000a770: d0 01 00 18 ld [ %g4 + %i0 ], %o0 the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 4000a774: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 4000a778: 80 a0 60 02 cmp %g1, 2 4000a77c: 08 80 00 23 bleu 4000a808 <_Thread_queue_Dequeue_priority+0xe0> 4000a780: 80 a0 60 01 cmp %g1, 1 4000a784: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 4000a788: 02 80 00 29 be 4000a82c <_Thread_queue_Dequeue_priority+0x104> <== NOT EXECUTED 4000a78c: b0 10 20 00 clr %i0 <== NOT EXECUTED return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; new_first_node = the_thread->Wait.Block2n.first; 4000a790: 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 ) ) { 4000a794: 82 06 20 3c add %i0, 0x3c, %g1 _ISR_Enable( level ); return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; 4000a798: 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 ) ) { 4000a79c: 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; 4000a7a0: c4 06 00 00 ld [ %i0 ], %g2 previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 4000a7a4: 02 80 00 27 be 4000a840 <_Thread_queue_Dequeue_priority+0x118> 4000a7a8: c2 06 20 04 ld [ %i0 + 4 ], %g1 last_node = the_thread->Wait.Block2n.last; 4000a7ac: d8 06 20 40 ld [ %i0 + 0x40 ], %o4 new_second_node = new_first_node->next; 4000a7b0: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 4000a7b4: 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; 4000a7b8: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 4000a7bc: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 4000a7c0: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 4000a7c4: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 4000a7c8: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 4000a7cc: 80 a0 80 01 cmp %g2, %g1 4000a7d0: 12 80 00 2d bne 4000a884 <_Thread_queue_Dequeue_priority+0x15c> 4000a7d4: 82 00 e0 38 add %g3, 0x38, %g1 } else { previous_node->next = next_node; next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 4000a7d8: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000a7dc: 80 a0 60 02 cmp %g1, 2 4000a7e0: 02 80 00 1e be 4000a858 <_Thread_queue_Dequeue_priority+0x130> 4000a7e4: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 4000a7e8: 7f ff dd fd call 40001fdc 4000a7ec: 90 10 00 0d mov %o5, %o0 4000a7f0: 90 10 00 18 mov %i0, %o0 4000a7f4: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000a7f8: 7f ff fe 06 call 4000a010 <_Thread_Clear_state> 4000a7fc: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 4000a800: 81 c7 e0 08 ret 4000a804: 81 e8 00 00 restore the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 4000a808: 0a 80 00 09 bcs 4000a82c <_Thread_queue_Dequeue_priority+0x104> 4000a80c: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 4000a810: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 4000a814: 7f ff dd f2 call 40001fdc <== NOT EXECUTED 4000a818: 90 10 00 0d mov %o5, %o0 <== NOT EXECUTED return _Thread_Executing; 4000a81c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000a820: f0 00 62 6c ld [ %g1 + 0x26c ], %i0 ! 4001ae6c <_Thread_Executing> <== NOT EXECUTED 4000a824: 81 c7 e0 08 ret <== NOT EXECUTED 4000a828: 81 e8 00 00 restore <== NOT EXECUTED } switch ( the_thread_queue->sync_state ) { case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 4000a82c: b0 10 20 00 clr %i0 4000a830: 7f ff dd eb call 40001fdc 4000a834: 90 10 00 0d mov %o5, %o0 4000a838: 81 c7 e0 08 ret 4000a83c: 81 e8 00 00 restore last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; next_node->previous = previous_node; 4000a840: 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; 4000a844: c4 20 40 00 st %g2, [ %g1 ] next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 4000a848: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000a84c: 80 a0 60 02 cmp %g1, 2 4000a850: 12 bf ff e6 bne 4000a7e8 <_Thread_queue_Dequeue_priority+0xc0> 4000a854: 82 10 20 03 mov 3, %g1 RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 4000a858: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000a85c: 7f ff dd e0 call 40001fdc 4000a860: 90 10 00 0d mov %o5, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 4000a864: 40 00 04 31 call 4000b928 <_Watchdog_Remove> 4000a868: 90 06 20 48 add %i0, 0x48, %o0 4000a86c: 90 10 00 18 mov %i0, %o0 4000a870: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000a874: 7f ff fd e7 call 4000a010 <_Thread_Clear_state> 4000a878: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 4000a87c: 81 c7 e0 08 ret 4000a880: 81 e8 00 00 restore new_first_node->next = next_node; new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ new_second_node->previous = 4000a884: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 4000a888: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] new_first_thread->Wait.Block2n.last = last_node; 4000a88c: d8 20 e0 40 st %o4, [ %g3 + 0x40 ] last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 4000a890: 82 00 e0 3c add %g3, 0x3c, %g1 4000a894: 10 bf ff d1 b 4000a7d8 <_Thread_queue_Dequeue_priority+0xb0> 4000a898: c2 23 00 00 st %g1, [ %o4 ] _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { the_thread = (Thread_Control *) 4000a89c: 10 bf ff bd b 4000a790 <_Thread_queue_Dequeue_priority+0x68> 4000a8a0: b0 10 00 08 mov %o0, %i0 4000e2e8 <_Thread_queue_Enqueue_fifo>: void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000e2e8: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); 4000e2ec: 7f ff cf 38 call 40001fcc 4000e2f0: 01 00 00 00 nop sync_state = the_thread_queue->sync_state; 4000e2f4: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 4000e2f8: 80 a0 a0 02 cmp %g2, 2 4000e2fc: 02 80 00 22 be 4000e384 <_Thread_queue_Enqueue_fifo+0x9c> 4000e300: c0 26 20 30 clr [ %i0 + 0x30 ] 4000e304: 80 a0 a0 03 cmp %g2, 3 4000e308: 02 80 00 11 be 4000e34c <_Thread_queue_Enqueue_fifo+0x64> 4000e30c: 80 a0 a0 01 cmp %g2, 1 4000e310: 02 80 00 07 be 4000e32c <_Thread_queue_Enqueue_fifo+0x44> 4000e314: 82 06 20 04 add %i0, 4, %g1 4000e318: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000e31c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000e320: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000e324: 7f ff ef 3b call 4000a010 <_Thread_Clear_state> <== NOT EXECUTED 4000e328: 81 e8 00 00 restore <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000e32c: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 4000e330: c4 06 20 08 ld [ %i0 + 8 ], %g2 the_chain->last = the_node; 4000e334: f2 26 20 08 st %i1, [ %i0 + 8 ] case THREAD_QUEUE_NOTHING_HAPPENED: _Chain_Append_unprotected( &the_thread_queue->Queues.Fifo, &the_thread->Object.Node ); the_thread->Wait.queue = the_thread_queue; 4000e338: f0 26 60 44 st %i0, [ %i1 + 0x44 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000e33c: c4 26 60 04 st %g2, [ %i1 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 4000e340: f2 20 80 00 st %i1, [ %g2 ] _ISR_Enable( level ); 4000e344: 7f ff cf 26 call 40001fdc 4000e348: 91 e8 00 08 restore %g0, %o0, %o0 the_thread->Wait.queue = NULL; _ISR_Enable( level ); break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 4000e34c: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 4000e350: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000e354: 12 80 00 16 bne 4000e3ac <_Thread_queue_Enqueue_fifo+0xc4> <== NOT EXECUTED 4000e358: 01 00 00 00 nop <== NOT EXECUTED 4000e35c: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 4000e360: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 4000e364: 7f ff cf 1e call 40001fdc <== NOT EXECUTED 4000e368: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 4000e36c: 7f ff f5 6f call 4000b928 <_Watchdog_Remove> <== NOT EXECUTED 4000e370: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 4000e374: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000e378: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000e37c: 7f ff ef 25 call 4000a010 <_Thread_Clear_state> <== NOT EXECUTED 4000e380: 81 e8 00 00 restore <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 4000e384: c4 06 60 44 ld [ %i1 + 0x44 ], %g2 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000e388: 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; 4000e38c: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED 4000e390: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 4000e394: 7f ff cf 12 call 40001fdc <== NOT EXECUTED 4000e398: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000e39c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000e3a0: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000e3a4: 7f ff ef 1b call 4000a010 <_Thread_Clear_state> <== NOT EXECUTED 4000e3a8: 81 e8 00 00 restore <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); } else _ISR_Enable( level ); 4000e3ac: 7f ff cf 0c call 40001fdc <== NOT EXECUTED 4000e3b0: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000e3b4: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000e3b8: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000e3bc: 7f ff ef 15 call 4000a010 <_Thread_Clear_state> <== NOT EXECUTED 4000e3c0: 81 e8 00 00 restore <== NOT EXECUTED 4000e3c4: 01 00 00 00 nop 4000a928 <_Thread_queue_Enqueue_priority>: void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000a928: 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; 4000a92c: 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); 4000a930: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4000a934: 84 06 60 38 add %i1, 0x38, %g2 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 4000a938: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; 4000a93c: c0 26 60 3c clr [ %i1 + 0x3c ] the_chain->last = _Chain_Head(the_chain); 4000a940: c4 26 60 40 st %g2, [ %i1 + 0x40 ] void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000a944: aa 10 00 18 mov %i0, %l5 priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 4000a948: 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); 4000a94c: 83 34 a0 06 srl %l2, 6, %g1 4000a950: 12 80 00 40 bne 4000aa50 <_Thread_queue_Enqueue_priority+0x128> 4000a954: e8 06 20 38 ld [ %i0 + 0x38 ], %l4 4000a958: 85 28 60 04 sll %g1, 4, %g2 4000a95c: 83 28 60 02 sll %g1, 2, %g1 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 4000a960: ac 20 80 01 sub %g2, %g1, %l6 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4000a964: 82 06 00 16 add %i0, %l6, %g1 4000a968: a6 00 60 04 add %g1, 4, %l3 if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 4000a96c: 7f ff dd 98 call 40001fcc 4000a970: 01 00 00 00 nop 4000a974: b0 10 00 08 mov %o0, %i0 search_thread = (Thread_Control *) header->first; 4000a978: e0 05 40 16 ld [ %l5 + %l6 ], %l0 while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 4000a97c: 80 a4 00 13 cmp %l0, %l3 4000a980: 02 80 00 24 be 4000aa10 <_Thread_queue_Enqueue_priority+0xe8> 4000a984: a2 10 3f ff mov -1, %l1 search_priority = search_thread->current_priority; 4000a988: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 4000a98c: 80 a4 80 11 cmp %l2, %l1 4000a990: 28 80 00 21 bleu,a 4000aa14 <_Thread_queue_Enqueue_priority+0xec> 4000a994: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 4000a998: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 4000a99c: 80 a4 c0 10 cmp %l3, %l0 4000a9a0: 32 80 00 19 bne,a 4000aa04 <_Thread_queue_Enqueue_priority+0xdc> 4000a9a4: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 4000a9a8: 10 80 00 1b b 4000aa14 <_Thread_queue_Enqueue_priority+0xec> 4000a9ac: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 4000a9b0: 7f ff dd 8b call 40001fdc 4000a9b4: 90 10 00 18 mov %i0, %o0 4000a9b8: 7f ff dd 85 call 40001fcc 4000a9bc: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 4000a9c0: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 4000a9c4: 80 8d 00 01 btst %l4, %g1 4000a9c8: 02 80 00 91 be 4000ac0c <_Thread_queue_Enqueue_priority+0x2e4> 4000a9cc: 01 00 00 00 nop _ISR_Enable( level ); goto restart_forward_search; } search_thread = 4000a9d0: e0 04 00 00 ld [ %l0 ], %l0 restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 4000a9d4: 80 a4 00 13 cmp %l0, %l3 4000a9d8: 22 80 00 0f be,a 4000aa14 <_Thread_queue_Enqueue_priority+0xec> 4000a9dc: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 search_priority = search_thread->current_priority; 4000a9e0: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 4000a9e4: 80 a4 80 11 cmp %l2, %l1 4000a9e8: 28 80 00 0b bleu,a 4000aa14 <_Thread_queue_Enqueue_priority+0xec> 4000a9ec: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 4000a9f0: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 4000a9f4: 80 a4 00 13 cmp %l0, %l3 4000a9f8: 22 80 00 07 be,a 4000aa14 <_Thread_queue_Enqueue_priority+0xec> 4000a9fc: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 4000aa00: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 4000aa04: 80 a4 80 11 cmp %l2, %l1 4000aa08: 18 bf ff ea bgu 4000a9b0 <_Thread_queue_Enqueue_priority+0x88> 4000aa0c: 01 00 00 00 nop } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 4000aa10: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 4000aa14: 80 a0 60 01 cmp %g1, 1 4000aa18: 02 80 00 63 be 4000aba4 <_Thread_queue_Enqueue_priority+0x27c> 4000aa1c: 80 a4 80 11 cmp %l2, %l1 return; synchronize: sync_state = the_thread_queue->sync_state; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; 4000aa20: c0 25 60 30 clr [ %l5 + 0x30 ] <== NOT EXECUTED switch ( sync_state ) { 4000aa24: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000aa28: 02 80 00 54 be 4000ab78 <_Thread_queue_Enqueue_priority+0x250> <== NOT EXECUTED 4000aa2c: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED 4000aa30: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 4000aa34: 22 80 00 43 be,a 4000ab40 <_Thread_queue_Enqueue_priority+0x218> <== NOT EXECUTED 4000aa38: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 4000aa3c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000aa40: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000aa44: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000aa48: 7f ff fd 72 call 4000a010 <_Thread_Clear_state> <== NOT EXECUTED 4000aa4c: 81 e8 00 00 restore <== NOT EXECUTED 4000aa50: 85 28 60 04 sll %g1, 4, %g2 4000aa54: 83 28 60 02 sll %g1, 2, %g1 restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 4000aa58: 82 20 80 01 sub %g2, %g1, %g1 4000aa5c: a6 00 40 18 add %g1, %i0, %l3 return; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); 4000aa60: 7f ff dd 5b call 40001fcc 4000aa64: 01 00 00 00 nop 4000aa68: b0 10 00 08 mov %o0, %i0 search_thread = (Thread_Control *) header->last; 4000aa6c: e0 04 e0 08 ld [ %l3 + 8 ], %l0 while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 4000aa70: 80 a4 00 13 cmp %l0, %l3 4000aa74: 02 80 00 24 be 4000ab04 <_Thread_queue_Enqueue_priority+0x1dc> 4000aa78: a2 10 21 00 mov 0x100, %l1 search_priority = search_thread->current_priority; 4000aa7c: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority >= search_priority ) 4000aa80: 80 a4 80 11 cmp %l2, %l1 4000aa84: 3a 80 00 21 bcc,a 4000ab08 <_Thread_queue_Enqueue_priority+0x1e0> 4000aa88: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 4000aa8c: e0 04 20 04 ld [ %l0 + 4 ], %l0 if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 4000aa90: 80 a4 c0 10 cmp %l3, %l0 4000aa94: 32 80 00 19 bne,a 4000aaf8 <_Thread_queue_Enqueue_priority+0x1d0> 4000aa98: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 4000aa9c: 10 80 00 1b b 4000ab08 <_Thread_queue_Enqueue_priority+0x1e0> 4000aaa0: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 4000aaa4: 7f ff dd 4e call 40001fdc 4000aaa8: 90 10 00 18 mov %i0, %o0 4000aaac: 7f ff dd 48 call 40001fcc 4000aab0: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 4000aab4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 4000aab8: 80 8d 00 01 btst %l4, %g1 4000aabc: 02 80 00 57 be 4000ac18 <_Thread_queue_Enqueue_priority+0x2f0> 4000aac0: 01 00 00 00 nop _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 4000aac4: e0 04 20 04 ld [ %l0 + 4 ], %l0 restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 4000aac8: 80 a4 00 13 cmp %l0, %l3 4000aacc: 22 80 00 0f be,a 4000ab08 <_Thread_queue_Enqueue_priority+0x1e0> 4000aad0: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 search_priority = search_thread->current_priority; 4000aad4: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED if ( priority >= search_priority ) 4000aad8: 80 a4 80 11 cmp %l2, %l1 <== NOT EXECUTED 4000aadc: 3a 80 00 0b bcc,a 4000ab08 <_Thread_queue_Enqueue_priority+0x1e0> <== NOT EXECUTED 4000aae0: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 <== NOT EXECUTED break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 4000aae4: e0 04 20 04 ld [ %l0 + 4 ], %l0 <== NOT EXECUTED if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 4000aae8: 80 a4 00 13 cmp %l0, %l3 <== NOT EXECUTED 4000aaec: 22 80 00 07 be,a 4000ab08 <_Thread_queue_Enqueue_priority+0x1e0> <== NOT EXECUTED 4000aaf0: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 <== NOT EXECUTED break; search_priority = search_thread->current_priority; 4000aaf4: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED if ( priority >= search_priority ) 4000aaf8: 80 a4 80 11 cmp %l2, %l1 4000aafc: 0a bf ff ea bcs 4000aaa4 <_Thread_queue_Enqueue_priority+0x17c> 4000ab00: 01 00 00 00 nop } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 4000ab04: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 4000ab08: 80 a0 60 01 cmp %g1, 1 4000ab0c: 12 bf ff c6 bne 4000aa24 <_Thread_queue_Enqueue_priority+0xfc> 4000ab10: c0 25 60 30 clr [ %l5 + 0x30 ] goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 4000ab14: 80 a4 80 11 cmp %l2, %l1 4000ab18: 22 80 00 35 be,a 4000abec <_Thread_queue_Enqueue_priority+0x2c4> 4000ab1c: 82 04 20 3c add %l0, 0x3c, %g1 goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 4000ab20: c2 04 00 00 ld [ %l0 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 4000ab24: 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; 4000ab28: 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; 4000ab2c: ea 26 60 44 st %l5, [ %i1 + 0x44 ] next_node = search_node->next; the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; search_node->next = the_node; 4000ab30: f2 24 00 00 st %i1, [ %l0 ] next_node->previous = the_node; 4000ab34: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 4000ab38: 7f ff dd 29 call 40001fdc 4000ab3c: 81 e8 00 00 restore the_thread->Wait.queue = NULL; _ISR_Enable( level ); break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 4000ab40: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000ab44: 12 80 00 22 bne 4000abcc <_Thread_queue_Enqueue_priority+0x2a4> <== NOT EXECUTED 4000ab48: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 4000ab4c: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 4000ab50: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 4000ab54: 7f ff dd 22 call 40001fdc <== NOT EXECUTED 4000ab58: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 4000ab5c: 40 00 03 73 call 4000b928 <_Watchdog_Remove> <== NOT EXECUTED 4000ab60: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 4000ab64: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000ab68: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000ab6c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000ab70: 7f ff fd 28 call 4000a010 <_Thread_Clear_state> <== NOT EXECUTED 4000ab74: 81 e8 00 00 restore <== NOT EXECUTED * This should never happen. All of this was dealt with above. */ break; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 4000ab78: c4 06 60 44 ld [ %i1 + 0x44 ], %g2 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000ab7c: 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; 4000ab80: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED 4000ab84: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 4000ab88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000ab8c: 7f ff dd 14 call 40001fdc <== NOT EXECUTED 4000ab90: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000ab94: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000ab98: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000ab9c: 7f ff fd 1d call 4000a010 <_Thread_Clear_state> <== NOT EXECUTED 4000aba0: 81 e8 00 00 restore <== NOT EXECUTED if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 4000aba4: 02 80 00 11 be 4000abe8 <_Thread_queue_Enqueue_priority+0x2c0> 4000aba8: c0 25 60 30 clr [ %l5 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 4000abac: c2 04 20 04 ld [ %l0 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 4000abb0: e0 26 40 00 st %l0, [ %i1 ] the_node->previous = previous_node; 4000abb4: 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; 4000abb8: ea 26 60 44 st %l5, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 4000abbc: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 4000abc0: f2 24 20 04 st %i1, [ %l0 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 4000abc4: 7f ff dd 06 call 40001fdc 4000abc8: 81 e8 00 00 restore _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); } else _ISR_Enable( level ); 4000abcc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000abd0: 7f ff dd 03 call 40001fdc <== NOT EXECUTED 4000abd4: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000abd8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000abdc: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000abe0: 7f ff fd 0c call 4000a010 <_Thread_Clear_state> <== NOT EXECUTED 4000abe4: 81 e8 00 00 restore <== NOT EXECUTED 4000abe8: 82 04 20 3c add %l0, 0x3c, %g1 _ISR_Enable( level ); return; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 4000abec: c4 00 60 04 ld [ %g1 + 4 ], %g2 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 4000abf0: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = previous_node; 4000abf4: 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; 4000abf8: ea 26 60 44 st %l5, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 4000abfc: f2 20 80 00 st %i1, [ %g2 ] search_node->previous = the_node; 4000ac00: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 4000ac04: 7f ff dc f6 call 40001fdc 4000ac08: 81 e8 00 00 restore if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 4000ac0c: 7f ff dc f4 call 40001fdc <== NOT EXECUTED 4000ac10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000ac14: 30 bf ff 56 b,a 4000a96c <_Thread_queue_Enqueue_priority+0x44> <== NOT EXECUTED if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 4000ac18: 7f ff dc f1 call 40001fdc <== NOT EXECUTED 4000ac1c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000ac20: 30 bf ff 90 b,a 4000aa60 <_Thread_queue_Enqueue_priority+0x138> <== NOT EXECUTED 4000a8a4 <_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 ) { 4000a8a4: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; the_thread = _Thread_Executing; 4000a8a8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 4000a8ac: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 Thread_queue_Timeout_callout handler ) { Thread_Control *the_thread; the_thread = _Thread_Executing; 4000a8b0: e0 00 62 6c ld [ %g1 + 0x26c ], %l0 void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 4000a8b4: 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 ); 4000a8b8: 40 00 01 9b call 4000af24 <_Thread_Set_state> 4000a8bc: 90 10 00 10 mov %l0, %o0 /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 4000a8c0: 80 a6 60 00 cmp %i1, 0 4000a8c4: 32 80 00 0e bne,a 4000a8fc <_Thread_queue_Enqueue_with_handler+0x58> 4000a8c8: c2 04 20 08 ld [ %l0 + 8 ], %g1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 4000a8cc: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 4000a8d0: 80 a0 60 00 cmp %g1, 0 4000a8d4: 12 80 00 04 bne 4000a8e4 <_Thread_queue_Enqueue_with_handler+0x40> 4000a8d8: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); 4000a8dc: 40 00 0e 83 call 4000e2e8 <_Thread_queue_Enqueue_fifo> 4000a8e0: 93 e8 00 10 restore %g0, %l0, %o1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 4000a8e4: 02 80 00 04 be 4000a8f4 <_Thread_queue_Enqueue_with_handler+0x50> 4000a8e8: 01 00 00 00 nop 4000a8ec: 81 c7 e0 08 ret <== NOT EXECUTED 4000a8f0: 81 e8 00 00 restore <== NOT EXECUTED case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Enqueue_priority( the_thread_queue, the_thread ); 4000a8f4: 40 00 00 0d call 4000a928 <_Thread_queue_Enqueue_priority> 4000a8f8: 93 e8 00 10 restore %g0, %l0, %o1 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 4000a8fc: f4 24 20 64 st %i2, [ %l0 + 0x64 ] the_watchdog->id = id; 4000a900: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000a904: f2 24 20 54 st %i1, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4000a908: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 4000a90c: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4000a910: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000a914: 92 04 20 48 add %l0, 0x48, %o1 4000a918: 40 00 03 9a call 4000b780 <_Watchdog_Insert> 4000a91c: 90 12 22 8c or %o0, 0x28c, %o0 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 4000a920: 10 bf ff ec b 4000a8d0 <_Thread_queue_Enqueue_with_handler+0x2c> 4000a924: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 4000e3c8 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 4000e3c8: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4000e3cc: 80 a0 60 00 cmp %g1, 0 4000e3d0: 12 80 00 05 bne 4000e3e4 <_Thread_queue_Extract+0x1c> 4000e3d4: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 4000e3d8: 82 13 c0 00 mov %o7, %g1 4000e3dc: 40 00 03 6a call 4000f184 <_Thread_queue_Extract_fifo> 4000e3e0: 9e 10 40 00 mov %g1, %o7 void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 4000e3e4: 02 80 00 04 be 4000e3f4 <_Thread_queue_Extract+0x2c> 4000e3e8: 94 10 20 00 clr %o2 4000e3ec: 81 c3 e0 08 retl <== NOT EXECUTED 4000e3f0: 01 00 00 00 nop <== NOT EXECUTED case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 4000e3f4: 82 13 c0 00 mov %o7, %g1 4000e3f8: 40 00 00 03 call 4000e404 <_Thread_queue_Extract_priority_helper> 4000e3fc: 9e 10 40 00 mov %g1, %o7 4000e400: 01 00 00 00 nop 4000f184 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000f184: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 4000f188: 7f ff cb 91 call 40001fcc 4000f18c: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 4000f190: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 4000f194: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000f198: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000f19c: 80 88 80 01 btst %g2, %g1 4000f1a0: 02 80 00 19 be 4000f204 <_Thread_queue_Extract_fifo+0x80> 4000f1a4: 01 00 00 00 nop ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 4000f1a8: c2 06 40 00 ld [ %i1 ], %g1 previous = the_node->previous; 4000f1ac: 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 ) ) { 4000f1b0: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 next->previous = previous; previous->next = next; 4000f1b4: c2 20 80 00 st %g1, [ %g2 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000f1b8: c4 20 60 04 st %g2, [ %g1 + 4 ] 4000f1bc: 80 a0 e0 02 cmp %g3, 2 4000f1c0: 12 80 00 0c bne 4000f1f0 <_Thread_queue_Extract_fifo+0x6c> 4000f1c4: c0 26 60 44 clr [ %i1 + 0x44 ] 4000f1c8: 82 10 20 03 mov 3, %g1 4000f1cc: c2 26 60 50 st %g1, [ %i1 + 0x50 ] _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000f1d0: 7f ff cb 83 call 40001fdc 4000f1d4: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 4000f1d8: 7f ff f1 d4 call 4000b928 <_Watchdog_Remove> 4000f1dc: 90 06 60 48 add %i1, 0x48, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000f1e0: 33 04 00 ff sethi %hi(0x1003fc00), %i1 4000f1e4: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000f1e8: 7f ff eb 8a call 4000a010 <_Thread_Clear_state> 4000f1ec: 81 e8 00 00 restore _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); 4000f1f0: 7f ff cb 7b call 40001fdc 4000f1f4: 33 04 00 ff sethi %hi(0x1003fc00), %i1 4000f1f8: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000f1fc: 7f ff eb 85 call 4000a010 <_Thread_Clear_state> 4000f200: 81 e8 00 00 restore ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 4000f204: 7f ff cb 76 call 40001fdc <== NOT EXECUTED 4000f208: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 4000f20c: 01 00 00 00 nop 4000e404 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, boolean requeuing ) { 4000e404: 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 ); 4000e408: 7f ff ce f1 call 40001fcc 4000e40c: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 4000e410: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 4000e414: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000e418: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000e41c: 80 88 80 01 btst %g2, %g1 4000e420: 02 80 00 29 be 4000e4c4 <_Thread_queue_Extract_priority_helper+0xc0> 4000e424: 82 06 60 3c add %i1, 0x3c, %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 4000e428: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 4000e42c: c4 06 40 00 ld [ %i1 ], %g2 previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 4000e430: 80 a0 c0 01 cmp %g3, %g1 4000e434: 12 80 00 10 bne 4000e474 <_Thread_queue_Extract_priority_helper+0x70> 4000e438: c2 06 60 04 ld [ %i1 + 4 ], %g1 new_first_thread->Wait.Block2n.last = last_node; last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; next_node->previous = previous_node; 4000e43c: 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; 4000e440: c4 20 40 00 st %g2, [ %g1 ] /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 4000e444: 80 a6 a0 00 cmp %i2, 0 4000e448: 12 80 00 1d bne 4000e4bc <_Thread_queue_Extract_priority_helper+0xb8> 4000e44c: 01 00 00 00 nop _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 4000e450: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000e454: 80 a0 60 02 cmp %g1, 2 4000e458: 02 80 00 1d be 4000e4cc <_Thread_queue_Extract_priority_helper+0xc8> 4000e45c: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 4000e460: 7f ff ce df call 40001fdc 4000e464: 33 04 00 ff sethi %hi(0x1003fc00), %i1 4000e468: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000e46c: 7f ff ee e9 call 4000a010 <_Thread_Clear_state> 4000e470: 81 e8 00 00 restore previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 4000e474: da 06 60 40 ld [ %i1 + 0x40 ], %o5 new_second_node = new_first_node->next; 4000e478: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 4000e47c: 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; 4000e480: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 4000e484: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 4000e488: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 4000e48c: c4 06 60 38 ld [ %i1 + 0x38 ], %g2 4000e490: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 4000e494: 80 a0 80 01 cmp %g2, %g1 4000e498: 02 bf ff ec be 4000e448 <_Thread_queue_Extract_priority_helper+0x44> 4000e49c: 80 a6 a0 00 cmp %i2, 0 /* > two threads on 2-n */ new_second_node->previous = 4000e4a0: 82 00 e0 38 add %g3, 0x38, %g1 <== NOT EXECUTED 4000e4a4: 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; 4000e4a8: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 4000e4ac: da 20 e0 40 st %o5, [ %g3 + 0x40 ] <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 4000e4b0: 82 00 e0 3c add %g3, 0x3c, %g1 <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 4000e4b4: 02 bf ff e7 be 4000e450 <_Thread_queue_Extract_priority_helper+0x4c> <== NOT EXECUTED 4000e4b8: c2 23 40 00 st %g1, [ %o5 ] <== NOT EXECUTED _ISR_Enable( level ); 4000e4bc: 7f ff ce c8 call 40001fdc 4000e4c0: 91 e8 00 08 restore %g0, %o0, %o0 Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 4000e4c4: 7f ff ce c6 call 40001fdc <== NOT EXECUTED 4000e4c8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 4000e4cc: c2 26 20 50 st %g1, [ %i0 + 0x50 ] <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000e4d0: 7f ff ce c3 call 40001fdc <== NOT EXECUTED 4000e4d4: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 4000e4d8: 7f ff f5 14 call 4000b928 <_Watchdog_Remove> <== NOT EXECUTED 4000e4dc: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED 4000e4e0: b2 16 63 f8 or %i1, 0x3f8, %i1 <== NOT EXECUTED 4000e4e4: 7f ff ee cb call 4000a010 <_Thread_Clear_state> <== NOT EXECUTED 4000e4e8: 81 e8 00 00 restore <== NOT EXECUTED 4000e4ec: 01 00 00 00 nop 4000ac24 <_Thread_queue_Extract_with_proxy>: */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 4000ac24: 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; 4000ac28: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 4000ac2c: 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 ) ) { 4000ac30: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000ac34: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000ac38: 80 88 80 01 btst %g2, %g1 4000ac3c: 02 80 00 1e be 4000acb4 <_Thread_queue_Extract_with_proxy+0x90> 4000ac40: b0 10 20 00 clr %i0 if ( _States_Is_waiting_for_rpc_reply( state ) && 4000ac44: 03 00 00 08 sethi %hi(0x2000), %g1 4000ac48: 80 88 80 01 btst %g2, %g1 4000ac4c: 22 80 00 17 be,a 4000aca8 <_Thread_queue_Extract_with_proxy+0x84> 4000ac50: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 4000ac54: 03 00 00 e7 sethi %hi(0x39c00), %g1 <== NOT EXECUTED 4000ac58: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 39ee0 <== NOT EXECUTED 4000ac5c: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 4000ac60: 22 80 00 12 be,a 4000aca8 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 4000ac64: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED _States_Is_locally_blocked( state ) ) { the_information = _Objects_Get_information( the_thread->Wait.id ); 4000ac68: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED proxy_extract_callout = 4000ac6c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000ac70: 85 30 e0 16 srl %g3, 0x16, %g2 <== NOT EXECUTED 4000ac74: 82 10 60 f0 or %g1, 0xf0, %g1 <== NOT EXECUTED 4000ac78: 84 08 a0 1c and %g2, 0x1c, %g2 <== NOT EXECUTED 4000ac7c: c8 00 40 02 ld [ %g1 + %g2 ], %g4 <== NOT EXECUTED 4000ac80: 87 30 e0 1b srl %g3, 0x1b, %g3 <== NOT EXECUTED 4000ac84: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED 4000ac88: c2 01 00 03 ld [ %g4 + %g3 ], %g1 <== NOT EXECUTED 4000ac8c: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 <== NOT EXECUTED (Objects_Thread_queue_Extract_callout) the_information->extract; if ( proxy_extract_callout ) 4000ac90: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000ac94: 22 80 00 05 be,a 4000aca8 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 4000ac98: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED (*proxy_extract_callout)( the_thread ); 4000ac9c: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000aca0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 4000aca4: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED 4000aca8: 92 10 00 10 mov %l0, %o1 4000acac: 40 00 0d c7 call 4000e3c8 <_Thread_queue_Extract> 4000acb0: b0 10 20 01 mov 1, %i0 return TRUE; } return FALSE; } 4000acb4: 81 c7 e0 08 ret 4000acb8: 81 e8 00 00 restore 4001c2f4 <_Thread_queue_First>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 4001c2f4: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4001c2f8: 80 a0 60 00 cmp %g1, 0 4001c2fc: 12 80 00 05 bne 4001c310 <_Thread_queue_First+0x1c> 4001c300: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); 4001c304: 82 13 c0 00 mov %o7, %g1 4001c308: 40 00 03 1b call 4001cf74 <_Thread_queue_First_fifo> 4001c30c: 9e 10 40 00 mov %g1, %o7 Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 4001c310: 02 80 00 04 be 4001c320 <_Thread_queue_First+0x2c> 4001c314: 01 00 00 00 nop the_thread = NULL; break; } return the_thread; } 4001c318: 81 c3 e0 08 retl <== NOT EXECUTED 4001c31c: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED switch ( the_thread_queue->discipline ) { case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_First_priority( the_thread_queue ); 4001c320: 82 13 c0 00 mov %o7, %g1 4001c324: 40 00 00 03 call 4001c330 <_Thread_queue_First_priority> 4001c328: 9e 10 40 00 mov %g1, %o7 4001c32c: 01 00 00 00 nop 4000acdc <_Thread_queue_Initialize>: uint32_t timeout_status ) { uint32_t index; the_thread_queue->state = state; 4000acdc: d4 22 20 38 st %o2, [ %o0 + 0x38 ] the_thread_queue->discipline = the_discipline; the_thread_queue->timeout_status = timeout_status; 4000ace0: d6 22 20 3c st %o3, [ %o0 + 0x3c ] the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; 4000ace4: c0 22 20 30 clr [ %o0 + 0x30 ] switch ( the_discipline ) { 4000ace8: 80 a2 60 00 cmp %o1, 0 4000acec: 12 80 00 07 bne 4000ad08 <_Thread_queue_Initialize+0x2c> 4000acf0: d2 22 20 34 st %o1, [ %o0 + 0x34 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 4000acf4: 82 02 20 04 add %o0, 4, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4000acf8: d0 22 20 08 st %o0, [ %o0 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 4000acfc: c0 22 20 04 clr [ %o0 + 4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 4000ad00: 81 c3 e0 08 retl 4000ad04: c2 22 00 00 st %g1, [ %o0 ] 4000ad08: 80 a2 60 01 cmp %o1, 1 4000ad0c: 02 80 00 04 be 4000ad1c <_Thread_queue_Initialize+0x40> 4000ad10: 82 02 20 04 add %o0, 4, %g1 4000ad14: 81 c3 e0 08 retl <== NOT EXECUTED 4000ad18: 01 00 00 00 nop <== NOT EXECUTED 4000ad1c: 84 02 20 10 add %o0, 0x10, %g2 4000ad20: c2 22 00 00 st %g1, [ %o0 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4000ad24: 82 02 20 0c add %o0, 0xc, %g1 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 4000ad28: c4 22 20 0c st %g2, [ %o0 + 0xc ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4000ad2c: c2 22 20 14 st %g1, [ %o0 + 0x14 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 4000ad30: 84 02 20 1c add %o0, 0x1c, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4000ad34: 82 02 20 18 add %o0, 0x18, %g1 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 4000ad38: c4 22 20 18 st %g2, [ %o0 + 0x18 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4000ad3c: c2 22 20 20 st %g1, [ %o0 + 0x20 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 4000ad40: 84 02 20 28 add %o0, 0x28, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4000ad44: 82 02 20 24 add %o0, 0x24, %g1 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 4000ad48: c0 22 20 04 clr [ %o0 + 4 ] the_chain->last = _Chain_Head(the_chain); 4000ad4c: d0 22 20 08 st %o0, [ %o0 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 4000ad50: c0 22 20 10 clr [ %o0 + 0x10 ] 4000ad54: c0 22 20 1c clr [ %o0 + 0x1c ] 4000ad58: c0 22 20 28 clr [ %o0 + 0x28 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 4000ad5c: c4 22 20 24 st %g2, [ %o0 + 0x24 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4000ad60: 81 c3 e0 08 retl 4000ad64: c2 22 20 2c st %g1, [ %o0 + 0x2c ] 4000ad68 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000ad68: 9d e3 bf 98 save %sp, -104, %sp /* just in case the thread really wasn't blocked here */ if ( !the_thread_queue ) { 4000ad6c: 80 a6 20 00 cmp %i0, 0 4000ad70: 02 80 00 06 be 4000ad88 <_Thread_queue_Requeue+0x20> 4000ad74: 01 00 00 00 nop return; } switch ( the_thread_queue->discipline ) { 4000ad78: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 4000ad7c: 80 a4 20 01 cmp %l0, 1 4000ad80: 02 80 00 04 be 4000ad90 <_Thread_queue_Requeue+0x28> 4000ad84: 01 00 00 00 nop 4000ad88: 81 c7 e0 08 ret <== NOT EXECUTED 4000ad8c: 81 e8 00 00 restore <== NOT EXECUTED break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; _ISR_Disable( level ); 4000ad90: 7f ff dc 8f call 40001fcc 4000ad94: 01 00 00 00 nop 4000ad98: a2 10 00 08 mov %o0, %l1 if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 4000ad9c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 4000ada0: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000ada4: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000ada8: 80 88 80 01 btst %g2, %g1 4000adac: 12 80 00 04 bne 4000adbc <_Thread_queue_Requeue+0x54> 4000adb0: 94 10 20 01 mov 1, %o2 _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); _Thread_queue_Enqueue_priority( tq, the_thread ); } _ISR_Enable( level ); 4000adb4: 7f ff dc 8a call 40001fdc <== NOT EXECUTED 4000adb8: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 4000adbc: 90 10 00 18 mov %i0, %o0 4000adc0: 92 10 00 19 mov %i1, %o1 4000adc4: 40 00 0d 90 call 4000e404 <_Thread_queue_Extract_priority_helper> 4000adc8: e0 26 20 30 st %l0, [ %i0 + 0x30 ] _Thread_queue_Enqueue_priority( tq, the_thread ); 4000adcc: 90 10 00 18 mov %i0, %o0 4000add0: 7f ff fe d6 call 4000a928 <_Thread_queue_Enqueue_priority> 4000add4: 92 10 00 19 mov %i1, %o1 } _ISR_Enable( level ); 4000add8: 7f ff dc 81 call 40001fdc 4000addc: 91 e8 00 11 restore %g0, %l1, %o0 4000ade0: 01 00 00 00 nop 4000ade4 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 4000ade4: 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 ) ) { 4000ade8: 92 96 20 00 orcc %i0, 0, %o1 4000adec: 12 80 00 1a bne 4000ae54 <_Thread_queue_Timeout+0x70> 4000adf0: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000adf4: 31 10 00 6b sethi %hi(0x4001ac00), %i0 <== NOT EXECUTED 4000adf8: c2 06 21 90 ld [ %i0 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000adfc: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000ae00: c2 26 21 90 st %g1, [ %i0 + 0x190 ] <== 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; 4000ae04: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000ae08: d2 00 62 6c ld [ %g1 + 0x26c ], %o1 ! 4001ae6c <_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; 4000ae0c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED */ static inline void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 4000ae10: d0 02 60 44 ld [ %o1 + 0x44 ], %o0 * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && 4000ae14: c6 02 20 30 ld [ %o0 + 0x30 ], %g3 4000ae18: 80 a0 e0 00 cmp %g3, 0 4000ae1c: 02 80 00 06 be 4000ae34 <_Thread_queue_Timeout+0x50> 4000ae20: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000ae24: c4 00 62 6c ld [ %g1 + 0x26c ], %g2 ! 4001ae6c <_Thread_Executing> <== NOT EXECUTED 4000ae28: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED 4000ae2c: 02 80 00 20 be 4000aeac <_Thread_queue_Timeout+0xc8> <== NOT EXECUTED 4000ae30: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 4000ae34: c2 02 20 3c ld [ %o0 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 4000ae38: 40 00 0d 64 call 4000e3c8 <_Thread_queue_Extract> 4000ae3c: 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; 4000ae40: c2 06 21 90 ld [ %i0 + 0x190 ], %g1 4000ae44: 82 00 7f ff add %g1, -1, %g1 4000ae48: c2 26 21 90 st %g1, [ %i0 + 0x190 ] 4000ae4c: 81 c7 e0 08 ret 4000ae50: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 4000ae54: 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 ) { 4000ae58: 80 a0 a0 04 cmp %g2, 4 4000ae5c: 18 bf ff fc bgu 4000ae4c <_Thread_queue_Timeout+0x68> 4000ae60: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4000ae64: 80 a0 60 01 cmp %g1, 1 4000ae68: 12 bf ff f9 bne 4000ae4c <_Thread_queue_Timeout+0x68> 4000ae6c: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4000ae70: 05 10 00 6b sethi %hi(0x4001ac00), %g2 4000ae74: 84 10 a0 f0 or %g2, 0xf0, %g2 ! 4001acf0 <_Objects_Information_table> 4000ae78: c6 00 80 01 ld [ %g2 + %g1 ], %g3 4000ae7c: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 4000ae80: 80 a2 20 00 cmp %o0, 0 4000ae84: 02 bf ff f2 be 4000ae4c <_Thread_queue_Timeout+0x68> 4000ae88: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4000ae8c: 7f ff f7 ee call 40008e44 <_Objects_Get> 4000ae90: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000ae94: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000ae98: 80 a0 60 00 cmp %g1, 0 4000ae9c: 12 bf ff ec bne 4000ae4c <_Thread_queue_Timeout+0x68> 4000aea0: 92 10 00 08 mov %o0, %o1 4000aea4: 10 bf ff db b 4000ae10 <_Thread_queue_Timeout+0x2c> 4000aea8: 31 10 00 6b sethi %hi(0x4001ac00), %i0 * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 4000aeac: 02 bf ff e5 be 4000ae40 <_Thread_queue_Timeout+0x5c> <== NOT EXECUTED 4000aeb0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 4000aeb4: 10 bf ff e3 b 4000ae40 <_Thread_queue_Timeout+0x5c> <== NOT EXECUTED 4000aeb8: c2 22 20 30 st %g1, [ %o0 + 0x30 ] <== NOT EXECUTED 40014544 <_Timer_Server_body>: */ Thread _Timer_Server_body( uint32_t ignored ) { 40014544: 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; 40014548: 03 10 00 d2 sethi %hi(0x40034800), %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001454c: 21 10 00 d1 sethi %hi(0x40034400), %l0 40014550: c6 00 60 e4 ld [ %g1 + 0xe4 ], %g3 _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 40014554: 05 10 00 d2 sethi %hi(0x40034800), %g2 40014558: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 4001455c: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4 /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 40014560: 05 10 00 d1 sethi %hi(0x40034400), %g2 40014564: 82 00 60 01 inc %g1 40014568: c6 20 a2 6c st %g3, [ %g2 + 0x26c ] 4001456c: c2 24 23 60 st %g1, [ %l0 + 0x360 ] _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 40014570: 05 10 00 d1 sethi %hi(0x40034400), %g2 40014574: c8 20 a2 68 st %g4, [ %g2 + 0x268 ] ! 40034668 <_Timer_Server_seconds_last_time> RTEMS_COMPILER_MEMORY_BARRIER(); 40014578: 03 10 00 d1 sethi %hi(0x40034400), %g1 4001457c: 05 10 00 d2 sethi %hi(0x40034800), %g2 40014580: ba 10 62 60 or %g1, 0x260, %i5 40014584: 03 10 00 d1 sethi %hi(0x40034400), %g1 40014588: 39 10 00 d2 sethi %hi(0x40034800), %i4 /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 4001458c: b4 10 a0 5c or %g2, 0x5c, %i2 40014590: ae 10 62 74 or %g1, 0x274, %l7 40014594: 05 10 00 d1 sethi %hi(0x40034400), %g2 40014598: 03 10 00 d2 sethi %hi(0x40034800), %g1 4001459c: a6 10 a2 7c or %g2, 0x27c, %l3 400145a0: b6 10 60 50 or %g1, 0x50, %i3 400145a4: 2d 10 00 d1 sethi %hi(0x40034400), %l6 400145a8: 2b 10 00 d1 sethi %hi(0x40034400), %l5 400145ac: a4 10 00 1c mov %i4, %l2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400145b0: a2 10 00 10 mov %l0, %l1 400145b4: 10 80 00 18 b 40014614 <_Timer_Server_body+0xd0> 400145b8: a8 10 00 13 mov %l3, %l4 _Timer_Server_reset_ticks_timer(); _Timer_Server_reset_seconds_timer(); 400145bc: 80 a0 40 17 cmp %g1, %l7 400145c0: 32 80 00 27 bne,a 4001465c <_Timer_Server_body+0x118> 400145c4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED 400145c8: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 400145cc: 82 00 7f ff add %g1, -1, %g1 400145d0: c2 24 23 60 st %g1, [ %l0 + 0x360 ] 400145d4: c4 04 23 60 ld [ %l0 + 0x360 ], %g2 400145d8: 80 a0 a0 00 cmp %g2, 0 400145dc: 02 80 00 2b be 40014688 <_Timer_Server_body+0x144> 400145e0: 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(); 400145e4: d0 04 a3 18 ld [ %l2 + 0x318 ], %o0 <== NOT EXECUTED 400145e8: 40 00 14 19 call 4001964c <_Watchdog_Remove> 400145ec: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_stop_seconds_timer(); 400145f0: 40 00 14 17 call 4001964c <_Watchdog_Remove> 400145f4: 90 10 00 14 mov %l4, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400145f8: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 400145fc: 82 00 60 01 inc %g1 40014600: c2 24 63 60 st %g1, [ %l1 + 0x360 ] * 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(); 40014604: 7f ff ff bf call 40014500 <_Timer_Server_process_ticks_chain> 40014608: 01 00 00 00 nop _Timer_Server_process_seconds_chain(); 4001460c: 7f ff ff a2 call 40014494 <_Timer_Server_process_seconds_chain> 40014610: 01 00 00 00 nop /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 40014614: d0 07 23 18 ld [ %i4 + 0x318 ], %o0 40014618: 40 00 10 b8 call 400188f8 <_Thread_Set_state> 4001461c: 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)); 40014620: c2 05 a2 5c ld [ %l6 + 0x25c ], %g1 _Timer_Server_reset_ticks_timer(); 40014624: 80 a0 40 1d cmp %g1, %i5 40014628: 22 bf ff e5 be,a 400145bc <_Timer_Server_body+0x78> 4001462c: c2 05 62 70 ld [ %l5 + 0x270 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40014630: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 40014634: d2 04 a3 18 ld [ %l2 + 0x318 ], %o1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40014638: 90 10 00 1a mov %i2, %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4001463c: c2 22 60 54 st %g1, [ %o1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40014640: 40 00 13 99 call 400194a4 <_Watchdog_Insert> 40014644: 92 02 60 48 add %o1, 0x48, %o1 40014648: c2 05 62 70 ld [ %l5 + 0x270 ], %g1 _Timer_Server_reset_seconds_timer(); 4001464c: 80 a0 40 17 cmp %g1, %l7 40014650: 02 bf ff de be 400145c8 <_Timer_Server_body+0x84> 40014654: 01 00 00 00 nop Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40014658: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 4001465c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40014660: c2 24 e0 0c st %g1, [ %l3 + 0xc ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 40014664: 40 00 13 90 call 400194a4 <_Watchdog_Insert> <== NOT EXECUTED 40014668: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001466c: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 <== NOT EXECUTED 40014670: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40014674: c2 24 23 60 st %g1, [ %l0 + 0x360 ] <== NOT EXECUTED 40014678: c4 04 23 60 ld [ %l0 + 0x360 ], %g2 <== NOT EXECUTED 4001467c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40014680: 32 bf ff da bne,a 400145e8 <_Timer_Server_body+0xa4> <== NOT EXECUTED 40014684: d0 04 a3 18 ld [ %l2 + 0x318 ], %o0 <== NOT EXECUTED _Thread_Dispatch(); 40014688: 40 00 0d 29 call 40017b2c <_Thread_Dispatch> 4001468c: 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(); 40014690: 10 bf ff d6 b 400145e8 <_Timer_Server_body+0xa4> 40014694: d0 04 a3 18 ld [ %l2 + 0x318 ], %o0 40014500 <_Timer_Server_process_ticks_chain>: void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 40014500: 03 10 00 d2 sethi %hi(0x40034800), %g1 if ( snapshot >= _Timer_Server_ticks_last_time ) 40014504: 07 10 00 d1 sethi %hi(0x40034400), %g3 void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 40014508: c4 00 60 e4 ld [ %g1 + 0xe4 ], %g2 if ( snapshot >= _Timer_Server_ticks_last_time ) 4001450c: c2 00 e2 6c ld [ %g3 + 0x26c ], %g1 40014510: 80 a0 80 01 cmp %g2, %g1 40014514: 1a 80 00 04 bcc 40014524 <_Timer_Server_process_ticks_chain+0x24> 40014518: 94 20 80 01 sub %g2, %g1, %o2 ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 4001451c: 82 38 00 01 xnor %g0, %g1, %g1 <== NOT EXECUTED 40014520: 94 00 40 02 add %g1, %g2, %o2 <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 40014524: 11 10 00 d1 sethi %hi(0x40034400), %o0 if ( snapshot >= _Timer_Server_ticks_last_time ) ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; _Timer_Server_ticks_last_time = snapshot; 40014528: c4 20 e2 6c st %g2, [ %g3 + 0x26c ] _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 4001452c: 90 12 22 5c or %o0, 0x25c, %o0 40014530: 92 10 20 00 clr %o1 40014534: 82 13 c0 00 mov %o7, %g1 40014538: 40 00 13 aa call 400193e0 <_Watchdog_Adjust> 4001453c: 9e 10 40 00 mov %g1, %o7 40014540: 01 00 00 00 nop 4000d27c <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 4000d27c: 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; 4000d280: 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; 4000d284: de 06 20 04 ld [ %i0 + 4 ], %o7 right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4000d288: 96 10 00 01 mov %g1, %o3 4000d28c: 95 38 60 1f sra %g1, 0x1f, %o2 4000d290: 83 30 60 1d srl %g1, 0x1d, %g1 4000d294: 9b 2a e0 03 sll %o3, 3, %o5 4000d298: 99 2a a0 03 sll %o2, 3, %o4 4000d29c: 98 10 40 0c or %g1, %o4, %o4 4000d2a0: 83 33 60 1b srl %o5, 0x1b, %g1 4000d2a4: 85 2b 20 05 sll %o4, 5, %g2 4000d2a8: 87 2b 60 05 sll %o5, 5, %g3 4000d2ac: 84 10 40 02 or %g1, %g2, %g2 4000d2b0: 86 a0 c0 0d subcc %g3, %o5, %g3 4000d2b4: 83 30 e0 1a srl %g3, 0x1a, %g1 4000d2b8: 84 60 80 0c subx %g2, %o4, %g2 4000d2bc: 9b 28 e0 06 sll %g3, 6, %o5 4000d2c0: 99 28 a0 06 sll %g2, 6, %o4 4000d2c4: 9a a3 40 03 subcc %o5, %g3, %o5 4000d2c8: 98 10 40 0c or %g1, %o4, %o4 4000d2cc: 98 63 00 02 subx %o4, %g2, %o4 4000d2d0: 9a 83 40 0b addcc %o5, %o3, %o5 4000d2d4: 83 33 60 1e srl %o5, 0x1e, %g1 4000d2d8: 98 43 00 0a addx %o4, %o2, %o4 4000d2dc: 87 2b 60 02 sll %o5, 2, %g3 4000d2e0: 85 2b 20 02 sll %o4, 2, %g2 4000d2e4: 9a 83 40 03 addcc %o5, %g3, %o5 4000d2e8: 84 10 40 02 or %g1, %g2, %g2 4000d2ec: 83 33 60 1e srl %o5, 0x1e, %g1 4000d2f0: 98 43 00 02 addx %o4, %g2, %o4 4000d2f4: 87 2b 60 02 sll %o5, 2, %g3 4000d2f8: 85 2b 20 02 sll %o4, 2, %g2 4000d2fc: 9a 83 40 03 addcc %o5, %g3, %o5 4000d300: 84 10 40 02 or %g1, %g2, %g2 4000d304: 83 33 60 1e srl %o5, 0x1e, %g1 4000d308: 98 43 00 02 addx %o4, %g2, %o4 4000d30c: 85 2b 20 02 sll %o4, 2, %g2 4000d310: 84 10 40 02 or %g1, %g2, %g2 right += rhs->tv_nsec; 4000d314: 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; 4000d318: 87 2b 60 02 sll %o5, 2, %g3 4000d31c: 9a 83 40 03 addcc %o5, %g3, %o5 right += rhs->tv_nsec; 4000d320: 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; 4000d324: 98 43 00 02 addx %o4, %g2, %o4 4000d328: 89 33 60 17 srl %o5, 0x17, %g4 4000d32c: 85 2b 20 09 sll %o4, 9, %g2 4000d330: 87 2b 60 09 sll %o5, 9, %g3 4000d334: 84 11 00 02 or %g4, %g2, %g2 right += rhs->tv_nsec; 4000d338: 96 80 c0 01 addcc %g3, %g1, %o3 4000d33c: 94 40 80 0a addx %g2, %o2, %o2 if ( right == 0 ) { 4000d340: 80 92 80 0b orcc %o2, %o3, %g0 4000d344: 12 80 00 06 bne 4000d35c <_Timespec_Divide+0xe0> 4000d348: f0 06 00 00 ld [ %i0 ], %i0 *ival_percentage = 0; 4000d34c: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED *fval_percentage = 0; 4000d350: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 4000d354: 81 c7 e0 08 ret <== NOT EXECUTED 4000d358: 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; 4000d35c: 83 36 20 1d srl %i0, 0x1d, %g1 4000d360: 9b 2e 20 03 sll %i0, 3, %o5 4000d364: 91 3e 20 1f sra %i0, 0x1f, %o0 4000d368: 99 2a 20 03 sll %o0, 3, %o4 4000d36c: 98 10 40 0c or %g1, %o4, %o4 4000d370: 83 33 60 1b srl %o5, 0x1b, %g1 4000d374: 85 2b 20 05 sll %o4, 5, %g2 4000d378: 87 2b 60 05 sll %o5, 5, %g3 4000d37c: 84 10 40 02 or %g1, %g2, %g2 4000d380: 86 a0 c0 0d subcc %g3, %o5, %g3 4000d384: 83 30 e0 1a srl %g3, 0x1a, %g1 4000d388: 84 60 80 0c subx %g2, %o4, %g2 4000d38c: 9b 28 e0 06 sll %g3, 6, %o5 4000d390: 99 28 a0 06 sll %g2, 6, %o4 4000d394: 9a a3 40 03 subcc %o5, %g3, %o5 4000d398: 98 10 40 0c or %g1, %o4, %o4 4000d39c: 98 63 00 02 subx %o4, %g2, %o4 4000d3a0: 9a 83 40 18 addcc %o5, %i0, %o5 4000d3a4: 83 33 60 1e srl %o5, 0x1e, %g1 4000d3a8: 98 43 00 08 addx %o4, %o0, %o4 4000d3ac: 87 2b 60 02 sll %o5, 2, %g3 4000d3b0: 85 2b 20 02 sll %o4, 2, %g2 4000d3b4: 9a 83 40 03 addcc %o5, %g3, %o5 4000d3b8: 84 10 40 02 or %g1, %g2, %g2 4000d3bc: 83 33 60 1e srl %o5, 0x1e, %g1 4000d3c0: 98 43 00 02 addx %o4, %g2, %o4 4000d3c4: 87 2b 60 02 sll %o5, 2, %g3 4000d3c8: 85 2b 20 02 sll %o4, 2, %g2 4000d3cc: 9a 83 40 03 addcc %o5, %g3, %o5 4000d3d0: 84 10 40 02 or %g1, %g2, %g2 4000d3d4: 83 33 60 1e srl %o5, 0x1e, %g1 4000d3d8: 98 43 00 02 addx %o4, %g2, %o4 4000d3dc: 87 2b 60 02 sll %o5, 2, %g3 4000d3e0: 85 2b 20 02 sll %o4, 2, %g2 4000d3e4: 9a 83 40 03 addcc %o5, %g3, %o5 4000d3e8: 84 10 40 02 or %g1, %g2, %g2 4000d3ec: 83 33 60 17 srl %o5, 0x17, %g1 4000d3f0: 98 43 00 02 addx %o4, %g2, %o4 4000d3f4: 93 2b 60 09 sll %o5, 9, %o1 4000d3f8: 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; 4000d3fc: 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; 4000d400: 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; 4000d404: 83 32 60 1e srl %o1, 0x1e, %g1 4000d408: a1 3b e0 1f sra %o7, 0x1f, %l0 4000d40c: 87 2a 60 02 sll %o1, 2, %g3 4000d410: 90 42 00 10 addx %o0, %l0, %o0 4000d414: 85 2a 20 02 sll %o0, 2, %g2 4000d418: 84 10 40 02 or %g1, %g2, %g2 4000d41c: 83 30 e0 1b srl %g3, 0x1b, %g1 4000d420: 99 28 a0 05 sll %g2, 5, %o4 4000d424: 9b 28 e0 05 sll %g3, 5, %o5 4000d428: 98 10 40 0c or %g1, %o4, %o4 4000d42c: 9a a3 40 03 subcc %o5, %g3, %o5 4000d430: 98 63 00 02 subx %o4, %g2, %o4 4000d434: 9a 83 40 09 addcc %o5, %o1, %o5 4000d438: 83 33 60 1e srl %o5, 0x1e, %g1 4000d43c: 98 43 00 08 addx %o4, %o0, %o4 4000d440: 87 2b 60 02 sll %o5, 2, %g3 4000d444: 85 2b 20 02 sll %o4, 2, %g2 4000d448: 9a 83 40 03 addcc %o5, %g3, %o5 4000d44c: 84 10 40 02 or %g1, %g2, %g2 4000d450: 83 33 60 1e srl %o5, 0x1e, %g1 4000d454: 87 2b 60 02 sll %o5, 2, %g3 4000d458: 98 43 00 02 addx %o4, %g2, %o4 4000d45c: 9a 83 40 03 addcc %o5, %g3, %o5 4000d460: 85 2b 20 02 sll %o4, 2, %g2 4000d464: 84 10 40 02 or %g1, %g2, %g2 4000d468: 83 33 60 1b srl %o5, 0x1b, %g1 4000d46c: 98 43 00 02 addx %o4, %g2, %o4 4000d470: 93 2b 60 05 sll %o5, 5, %o1 4000d474: 91 2b 20 05 sll %o4, 5, %o0 4000d478: 40 00 33 56 call 4001a1d0 <__udivdi3> 4000d47c: 90 10 40 08 or %g1, %o0, %o0 *ival_percentage = answer / 1000; 4000d480: 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; 4000d484: a0 10 00 08 mov %o0, %l0 4000d488: a2 10 00 09 mov %o1, %l1 *ival_percentage = answer / 1000; 4000d48c: 96 10 23 e8 mov 0x3e8, %o3 4000d490: 40 00 33 50 call 4001a1d0 <__udivdi3> 4000d494: 90 10 00 10 mov %l0, %o0 *fval_percentage = answer % 1000; 4000d498: 90 10 00 10 mov %l0, %o0 * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 4000d49c: d2 26 80 00 st %o1, [ %i2 ] *fval_percentage = answer % 1000; 4000d4a0: 94 10 20 00 clr %o2 4000d4a4: 92 10 00 11 mov %l1, %o1 4000d4a8: 40 00 34 29 call 4001a54c <__umoddi3> 4000d4ac: 96 10 23 e8 mov 0x3e8, %o3 4000d4b0: d2 26 c0 00 st %o1, [ %i3 ] 4000d4b4: 81 c7 e0 08 ret 4000d4b8: 81 e8 00 00 restore 40017f9c <_Timespec_From_ticks>: void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 40017f9c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 40017fa0: 03 10 00 b1 sethi %hi(0x4002c400), %g1 <== NOT EXECUTED 40017fa4: d2 00 61 ec ld [ %g1 + 0x1ec ], %o1 ! 4002c5ec <_TOD_Microseconds_per_tick> <== NOT EXECUTED 40017fa8: 40 00 2f c0 call 40023ea8 <.umul> <== NOT EXECUTED 40017fac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 40017fb0: 21 00 03 d0 sethi %hi(0xf4000), %l0 <== NOT EXECUTED struct timespec *time ) { uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 40017fb4: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 40017fb8: 7f ff a6 0f call 400017f4 <.udiv> <== NOT EXECUTED 40017fbc: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 40017fc0: 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; 40017fc4: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 40017fc8: 40 00 2f f2 call 40023f90 <.urem> <== NOT EXECUTED 40017fcc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40017fd0: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED 40017fd4: 83 2a 20 07 sll %o0, 7, %g1 <== NOT EXECUTED 40017fd8: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 40017fdc: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 40017fe0: 83 28 60 03 sll %g1, 3, %g1 <== NOT EXECUTED 40017fe4: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 40017fe8: 81 c7 e0 08 ret <== NOT EXECUTED 40017fec: 81 e8 00 00 restore <== NOT EXECUTED 40017ff0 <_Timespec_Is_valid>: boolean _Timespec_Is_valid( const struct timespec *time ) { if ( !time ) 40017ff0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40017ff4: 02 80 00 0e be 4001802c <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 40017ff8: 01 00 00 00 nop <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) 40017ffc: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 40018000: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40018004: 06 80 00 0a bl 4001802c <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 40018008: 01 00 00 00 nop <== NOT EXECUTED return FALSE; if ( time->tv_nsec < 0 ) 4001800c: d0 02 20 04 ld [ %o0 + 4 ], %o0 <== NOT EXECUTED 40018010: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40018014: 06 80 00 06 bl 4001802c <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 40018018: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 <== NOT EXECUTED 4001801c: 82 10 61 ff or %g1, 0x1ff, %g1 ! 3b9ac9ff <== NOT EXECUTED 40018020: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED 40018024: 81 c3 e0 08 retl <== NOT EXECUTED 40018028: 90 60 3f ff subx %g0, -1, %o0 <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 4001802c: 81 c3 e0 08 retl <== NOT EXECUTED 40018030: 90 10 20 00 clr %o0 <== NOT EXECUTED 40018034 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 40018034: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 40018038: e0 06 00 00 ld [ %i0 ], %l0 <== NOT EXECUTED 4001803c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 40018040: 02 80 00 15 be 40018094 <_Timespec_To_ticks+0x60> <== NOT EXECUTED 40018044: e4 06 20 04 ld [ %i0 + 4 ], %l2 <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 40018048: 03 10 00 b1 sethi %hi(0x4002c400), %g1 <== NOT EXECUTED 4001804c: e2 00 61 ec ld [ %g1 + 0x1ec ], %l1 ! 4002c5ec <_TOD_Microseconds_per_tick> <== NOT EXECUTED 40018050: 11 00 03 d0 sethi %hi(0xf4000), %o0 <== NOT EXECUTED 40018054: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 40018058: 7f ff a5 e7 call 400017f4 <.udiv> <== NOT EXECUTED 4001805c: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED 40018060: 40 00 2f 92 call 40023ea8 <.umul> <== NOT EXECUTED 40018064: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 40018068: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 4001806c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 40018070: 7f ff a5 e1 call 400017f4 <.udiv> <== NOT EXECUTED 40018074: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40018078: 7f ff a5 df call 400017f4 <.udiv> <== NOT EXECUTED 4001807c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED _TOD_Microseconds_per_tick; if (ticks) 40018080: b0 82 00 10 addcc %o0, %l0, %i0 <== NOT EXECUTED 40018084: 02 80 00 08 be 400180a4 <_Timespec_To_ticks+0x70> <== NOT EXECUTED 40018088: 01 00 00 00 nop <== NOT EXECUTED return ticks; return 1; } 4001808c: 81 c7 e0 08 ret <== NOT EXECUTED 40018090: 81 e8 00 00 restore <== NOT EXECUTED const struct timespec *time ) { uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 40018094: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 40018098: 12 bf ff ec bne 40018048 <_Timespec_To_ticks+0x14> <== NOT EXECUTED 4001809c: b0 10 20 00 clr %i0 <== NOT EXECUTED 400180a0: 30 bf ff fb b,a 4001808c <_Timespec_To_ticks+0x58> <== NOT EXECUTED if (ticks) return ticks; return 1; } 400180a4: 81 c7 e0 08 ret <== NOT EXECUTED 400180a8: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED 4000e6c4 <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 4000e6c4: 9d e3 bf 98 save %sp, -104, %sp _Chain_Append( &_User_extensions_List, &the_extension->Node ); 4000e6c8: 11 10 00 6c sethi %hi(0x4001b000), %o0 4000e6cc: 92 10 00 18 mov %i0, %o1 4000e6d0: 7f ff e5 dc call 40007e40 <_Chain_Append> 4000e6d4: 90 12 20 14 or %o0, 0x14, %o0 /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 4000e6d8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 4000e6dc: 80 a0 60 00 cmp %g1, 0 4000e6e0: 02 80 00 06 be 4000e6f8 <_User_extensions_Add_API_set+0x34> 4000e6e4: b2 06 20 08 add %i0, 8, %i1 the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 4000e6e8: c2 26 20 10 st %g1, [ %i0 + 0x10 ] _Chain_Append( 4000e6ec: 31 10 00 6b sethi %hi(0x4001ac00), %i0 4000e6f0: 7f ff e5 d4 call 40007e40 <_Chain_Append> 4000e6f4: 91 ee 21 94 restore %i0, 0x194, %o0 4000e6f8: 81 c7 e0 08 ret <== NOT EXECUTED 4000e6fc: 81 e8 00 00 restore <== NOT EXECUTED 4000b598 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, boolean is_internal, uint32_t the_error ) { 4000b598: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 4000b59c: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000b5a0: 82 10 60 14 or %g1, 0x14, %g1 ! 4001b014 <_User_extensions_List> 4000b5a4: e0 00 60 08 ld [ %g1 + 8 ], %l0 !_Chain_Is_head( &_User_extensions_List, the_node ) ; 4000b5a8: 80 a4 00 01 cmp %l0, %g1 4000b5ac: 02 80 00 0d be 4000b5e0 <_User_extensions_Fatal+0x48> 4000b5b0: a2 10 00 01 mov %g1, %l1 the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 4000b5b4: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 4000b5b8: 80 a0 60 00 cmp %g1, 0 4000b5bc: 02 80 00 05 be 4000b5d0 <_User_extensions_Fatal+0x38> 4000b5c0: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 4000b5c4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000b5c8: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000b5cc: 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 ) { 4000b5d0: 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 ) ; 4000b5d4: 80 a4 00 11 cmp %l0, %l1 4000b5d8: 32 bf ff f8 bne,a 4000b5b8 <_User_extensions_Fatal+0x20> 4000b5dc: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 <== NOT EXECUTED 4000b5e0: 81 c7 e0 08 ret 4000b5e4: 81 e8 00 00 restore 40012840 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 40012840: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 40012844: 40 00 12 b2 call 4001730c <_Chain_Extract> <== NOT EXECUTED 40012848: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 4001284c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED 40012850: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40012854: 02 80 00 04 be 40012864 <_User_extensions_Remove_set+0x24> <== NOT EXECUTED 40012858: 01 00 00 00 nop <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 4001285c: 40 00 12 ac call 4001730c <_Chain_Extract> <== NOT EXECUTED 40012860: 91 ee 20 08 restore %i0, 8, %o0 <== NOT EXECUTED 40012864: 81 c7 e0 08 ret <== NOT EXECUTED 40012868: 81 e8 00 00 restore <== NOT EXECUTED 4000b5e8 <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 4000b5e8: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 4000b5ec: 03 10 00 6c sethi %hi(0x4001b000), %g1 4000b5f0: 82 10 60 14 or %g1, 0x14, %g1 ! 4001b014 <_User_extensions_List> 4000b5f4: e0 00 60 08 ld [ %g1 + 8 ], %l0 !_Chain_Is_head( &_User_extensions_List, the_node ) ; 4000b5f8: 80 a4 00 01 cmp %l0, %g1 4000b5fc: 02 80 00 0c be 4000b62c <_User_extensions_Thread_exitted+0x44> 4000b600: a2 10 00 01 mov %g1, %l1 the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 4000b604: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 4000b608: 80 a0 60 00 cmp %g1, 0 4000b60c: 02 80 00 04 be 4000b61c <_User_extensions_Thread_exitted+0x34> 4000b610: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.thread_exitted)( executing ); 4000b614: 9f c0 40 00 call %g1 4000b618: 01 00 00 00 nop Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 4000b61c: 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 ) ; 4000b620: 80 a4 00 11 cmp %l0, %l1 4000b624: 32 bf ff f9 bne,a 4000b608 <_User_extensions_Thread_exitted+0x20> 4000b628: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 <== NOT EXECUTED 4000b62c: 81 c7 e0 08 ret 4000b630: 81 e8 00 00 restore 4000b780 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 4000b780: 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; 4000b784: 03 10 00 6b sethi %hi(0x4001ac00), %g1 void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 4000b788: ac 10 00 18 mov %i0, %l6 Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 4000b78c: e6 00 62 54 ld [ %g1 + 0x254 ], %l3 _ISR_Disable( level ); 4000b790: 7f ff da 0f call 40001fcc 4000b794: 01 00 00 00 nop 4000b798: 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 ) { 4000b79c: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000b7a0: 80 a0 60 00 cmp %g1, 0 4000b7a4: 12 80 00 49 bne 4000b8c8 <_Watchdog_Insert+0x148> 4000b7a8: 01 00 00 00 nop _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 4000b7ac: 2b 10 00 6b sethi %hi(0x4001ac00), %l5 4000b7b0: c2 05 63 10 ld [ %l5 + 0x310 ], %g1 ! 4001af10 <_Watchdog_Sync_count> if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 4000b7b4: 84 10 20 01 mov 1, %g2 _Watchdog_Sync_count++; 4000b7b8: 82 00 60 01 inc %g1 4000b7bc: 29 10 00 6b sethi %hi(0x4001ac00), %l4 if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 4000b7c0: c4 26 60 08 st %g2, [ %i1 + 8 ] _Watchdog_Sync_count++; 4000b7c4: c2 25 63 10 st %g1, [ %l5 + 0x310 ] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 4000b7c8: ae 10 00 14 mov %l4, %l7 the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 4000b7cc: 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 ; 4000b7d0: e2 05 80 00 ld [ %l6 ], %l1 ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 4000b7d4: 80 a4 a0 00 cmp %l2, 0 4000b7d8: 02 80 00 2b be 4000b884 <_Watchdog_Insert+0x104> 4000b7dc: 03 10 00 6b sethi %hi(0x4001ac00), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 4000b7e0: c2 04 40 00 ld [ %l1 ], %g1 4000b7e4: 80 a0 60 00 cmp %g1, 0 4000b7e8: 02 80 00 27 be 4000b884 <_Watchdog_Insert+0x104> 4000b7ec: 03 10 00 6b sethi %hi(0x4001ac00), %g1 break; if ( delta_interval < after->delta_interval ) { 4000b7f0: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 4000b7f4: 80 a4 80 10 cmp %l2, %l0 4000b7f8: 1a 80 00 13 bcc 4000b844 <_Watchdog_Insert+0xc4> 4000b7fc: 01 00 00 00 nop after->delta_interval -= delta_interval; 4000b800: 10 80 00 1f b 4000b87c <_Watchdog_Insert+0xfc> 4000b804: a0 24 00 12 sub %l0, %l2, %l0 if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 4000b808: c2 05 22 68 ld [ %l4 + 0x268 ], %g1 4000b80c: 80 a4 c0 01 cmp %l3, %g1 4000b810: 0a 80 00 30 bcs 4000b8d0 <_Watchdog_Insert+0x150> 4000b814: 01 00 00 00 nop */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 4000b818: a4 a4 80 10 subcc %l2, %l0, %l2 4000b81c: 02 80 00 19 be 4000b880 <_Watchdog_Insert+0x100> 4000b820: e2 04 40 00 ld [ %l1 ], %l1 4000b824: c2 04 40 00 ld [ %l1 ], %g1 4000b828: 80 a0 60 00 cmp %g1, 0 4000b82c: 02 80 00 16 be 4000b884 <_Watchdog_Insert+0x104> 4000b830: 03 10 00 6b sethi %hi(0x4001ac00), %g1 break; if ( delta_interval < after->delta_interval ) { 4000b834: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 4000b838: 80 a4 00 12 cmp %l0, %l2 4000b83c: 38 80 00 10 bgu,a 4000b87c <_Watchdog_Insert+0xfc> 4000b840: a0 24 00 12 sub %l0, %l2, %l0 * used around this flash point allowed interrupts to execute * which violated the design assumptions. The critical section * mechanism used here WAS redesigned to address this. */ _ISR_Flash( level ); 4000b844: 7f ff d9 e6 call 40001fdc 4000b848: 90 10 00 18 mov %i0, %o0 4000b84c: 7f ff d9 e0 call 40001fcc 4000b850: 01 00 00 00 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 4000b854: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000b858: 80 a0 60 01 cmp %g1, 1 4000b85c: 02 bf ff eb be 4000b808 <_Watchdog_Insert+0x88> 4000b860: 01 00 00 00 nop _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 4000b864: e6 25 22 68 st %l3, [ %l4 + 0x268 ] <== NOT EXECUTED _Watchdog_Sync_count--; 4000b868: c2 05 63 10 ld [ %l5 + 0x310 ], %g1 <== NOT EXECUTED 4000b86c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000b870: c2 25 63 10 st %g1, [ %l5 + 0x310 ] <== NOT EXECUTED _ISR_Enable( level ); 4000b874: 7f ff d9 da call 40001fdc <== NOT EXECUTED 4000b878: 81 e8 00 00 restore <== NOT EXECUTED if ( delta_interval == 0 || !_Watchdog_Next( after ) ) break; if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; 4000b87c: e0 24 60 10 st %l0, [ %l1 + 0x10 ] the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; 4000b880: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000b884: c6 00 63 14 ld [ %g1 + 0x314 ], %g3 ! 4001af14 <_Watchdog_Ticks_since_boot> _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 4000b888: c4 04 60 04 ld [ %l1 + 4 ], %g2 the_watchdog->start_time = _Watchdog_Ticks_since_boot; 4000b88c: c6 26 60 14 st %g3, [ %i1 + 0x14 ] } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 4000b890: e4 26 60 10 st %l2, [ %i1 + 0x10 ] RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 4000b894: 82 10 20 02 mov 2, %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 4000b898: c8 00 80 00 ld [ %g2 ], %g4 _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 4000b89c: e6 25 22 68 st %l3, [ %l4 + 0x268 ] 4000b8a0: c2 26 60 08 st %g1, [ %i1 + 8 ] _Watchdog_Sync_count--; 4000b8a4: c2 05 63 10 ld [ %l5 + 0x310 ], %g1 after_node->next = the_node; 4000b8a8: f2 20 80 00 st %i1, [ %g2 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 4000b8ac: c4 26 60 04 st %g2, [ %i1 + 4 ] 4000b8b0: 82 00 7f ff add %g1, -1, %g1 before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; before_node->previous = the_node; 4000b8b4: f2 21 20 04 st %i1, [ %g4 + 4 ] Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 4000b8b8: c8 26 40 00 st %g4, [ %i1 ] 4000b8bc: c2 25 63 10 st %g1, [ %l5 + 0x310 ] _ISR_Enable( level ); 4000b8c0: 7f ff d9 c7 call 40001fdc 4000b8c4: 81 e8 00 00 restore * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 4000b8c8: 7f ff d9 c5 call 40001fdc <== NOT EXECUTED 4000b8cc: 81 e8 00 00 restore <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { _Watchdog_Sync_level = insert_isr_nest_level; 4000b8d0: e6 25 e2 68 st %l3, [ %l7 + 0x268 ] the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 4000b8d4: 10 bf ff bf b 4000b7d0 <_Watchdog_Insert+0x50> 4000b8d8: e4 06 60 0c ld [ %i1 + 0xc ], %l2 4000b928 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 4000b928: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 4000b92c: 7f ff d9 a8 call 40001fcc 4000b930: a0 10 00 18 mov %i0, %l0 previous_state = the_watchdog->state; 4000b934: f0 06 20 08 ld [ %i0 + 8 ], %i0 switch ( previous_state ) { 4000b938: 80 a6 20 01 cmp %i0, 1 4000b93c: 02 80 00 2a be 4000b9e4 <_Watchdog_Remove+0xbc> 4000b940: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000b944: 1a 80 00 09 bcc 4000b968 <_Watchdog_Remove+0x40> 4000b948: 80 a6 20 03 cmp %i0, 3 _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 4000b94c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000b950: c4 00 63 14 ld [ %g1 + 0x314 ], %g2 ! 4001af14 <_Watchdog_Ticks_since_boot> 4000b954: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 4000b958: 7f ff d9 a1 call 40001fdc 4000b95c: 01 00 00 00 nop return( previous_state ); } 4000b960: 81 c7 e0 08 ret 4000b964: 81 e8 00 00 restore Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 4000b968: 18 bf ff fa bgu 4000b950 <_Watchdog_Remove+0x28> 4000b96c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 4000b970: c8 04 00 00 ld [ %l0 ], %g4 break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 4000b974: c0 24 20 08 clr [ %l0 + 8 ] next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 4000b978: c2 01 00 00 ld [ %g4 ], %g1 4000b97c: 80 a0 60 00 cmp %g1, 0 4000b980: 02 80 00 07 be 4000b99c <_Watchdog_Remove+0x74> 4000b984: 03 10 00 6b sethi %hi(0x4001ac00), %g1 next_watchdog->delta_interval += the_watchdog->delta_interval; 4000b988: c2 01 20 10 ld [ %g4 + 0x10 ], %g1 4000b98c: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 4000b990: 82 00 40 02 add %g1, %g2, %g1 4000b994: c2 21 20 10 st %g1, [ %g4 + 0x10 ] if ( _Watchdog_Sync_count ) 4000b998: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000b99c: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 4001af10 <_Watchdog_Sync_count> 4000b9a0: 80 a0 a0 00 cmp %g2, 0 4000b9a4: 22 80 00 07 be,a 4000b9c0 <_Watchdog_Remove+0x98> 4000b9a8: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Watchdog_Sync_level = _ISR_Nest_level; 4000b9ac: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 4000b9b0: c6 00 62 54 ld [ %g1 + 0x254 ], %g3 ! 4001ae54 <_ISR_Nest_level> <== NOT EXECUTED 4000b9b4: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 4000b9b8: c6 20 a2 68 st %g3, [ %g2 + 0x268 ] ! 4001ae68 <_Watchdog_Sync_level> <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 4000b9bc: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 4000b9c0: c8 20 40 00 st %g4, [ %g1 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000b9c4: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 4000b9c8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000b9cc: c4 00 63 14 ld [ %g1 + 0x314 ], %g2 ! 4001af14 <_Watchdog_Ticks_since_boot> 4000b9d0: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 4000b9d4: 7f ff d9 82 call 40001fdc 4000b9d8: 01 00 00 00 nop return( previous_state ); } 4000b9dc: 81 c7 e0 08 ret 4000b9e0: 81 e8 00 00 restore _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 4000b9e4: c4 00 63 14 ld [ %g1 + 0x314 ], %g2 <== NOT EXECUTED /* * It is not actually on the chain so just change the state and * the Insert operation we interrupted will be aborted. */ the_watchdog->state = WATCHDOG_INACTIVE; 4000b9e8: c0 24 20 08 clr [ %l0 + 8 ] <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 4000b9ec: c4 24 20 18 st %g2, [ %l0 + 0x18 ] <== NOT EXECUTED _ISR_Enable( level ); 4000b9f0: 7f ff d9 7b call 40001fdc <== NOT EXECUTED 4000b9f4: 01 00 00 00 nop <== NOT EXECUTED return( previous_state ); } 4000b9f8: 81 c7 e0 08 ret <== NOT EXECUTED 4000b9fc: 81 e8 00 00 restore <== NOT EXECUTED 4000baac <_Workspace_Allocate_or_fatal_error>: */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 4000baac: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 4000bab0: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000bab4: 92 10 00 18 mov %i0, %o1 4000bab8: 7f ff f2 33 call 40008384 <_Heap_Allocate> 4000babc: 90 12 21 dc or %o0, 0x1dc, %o0 void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 4000bac0: b0 92 20 00 orcc %o0, 0, %i0 4000bac4: 12 80 00 04 bne 4000bad4 <_Workspace_Allocate_or_fatal_error+0x28> 4000bac8: 92 10 20 01 mov 1, %o1 _Internal_error_Occurred( 4000bacc: 7f ff f3 60 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 4000bad0: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 4000bad4: 81 c7 e0 08 ret 4000bad8: 81 e8 00 00 restore 4000badc <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 4000badc: 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 ) ) 4000bae0: 80 a6 20 00 cmp %i0, 0 4000bae4: 02 80 00 1d be 4000bb58 <_Workspace_Handler_initialization+0x7c> 4000bae8: 80 8e 20 07 btst 7, %i0 4000baec: 12 80 00 1c bne 4000bb5c <_Workspace_Handler_initialization+0x80> 4000baf0: 90 10 20 00 clr %o0 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { 4000baf4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000baf8: c4 00 61 b4 ld [ %g1 + 0x1b4 ], %g2 ! 4001adb4 <_CPU_Table+0x10> 4000bafc: 80 a0 a0 00 cmp %g2, 0 4000bb00: 02 80 00 0c be 4000bb30 <_Workspace_Handler_initialization+0x54> 4000bb04: 92 10 00 18 mov %i0, %o1 for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; 4000bb08: 87 36 60 02 srl %i1, 2, %g3 <== NOT EXECUTED 4000bb0c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000bb10: 02 80 00 08 be 4000bb30 <_Workspace_Handler_initialization+0x54> <== NOT EXECUTED 4000bb14: 84 10 20 00 clr %g2 <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; 4000bb18: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; index++ ) 4000bb1c: 84 00 a0 01 inc %g2 <== NOT EXECUTED INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; 4000bb20: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED 4000bb24: 12 bf ff fd bne 4000bb18 <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED 4000bb28: c0 20 40 18 clr [ %g1 + %i0 ] <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 4000bb2c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000bb30: 94 10 00 19 mov %i1, %o2 4000bb34: 11 10 00 6b sethi %hi(0x4001ac00), %o0 4000bb38: 96 10 20 08 mov 8, %o3 4000bb3c: 7f ff f2 f7 call 40008718 <_Heap_Initialize> 4000bb40: 90 12 21 dc or %o0, 0x1dc, %o0 starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 4000bb44: 80 a2 20 00 cmp %o0, 0 4000bb48: 02 80 00 0a be 4000bb70 <_Workspace_Handler_initialization+0x94> 4000bb4c: b0 10 20 00 clr %i0 4000bb50: 81 c7 e0 08 ret 4000bb54: 81 e8 00 00 restore uint32_t *zero_out_array; uint32_t index; uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) _Internal_error_Occurred( 4000bb58: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000bb5c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 4000bb60: 7f ff f3 3b call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 4000bb64: 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 ) { 4000bb68: 10 bf ff e4 b 4000baf8 <_Workspace_Handler_initialization+0x1c> <== NOT EXECUTED 4000bb6c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 4000bb70: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED 4000bb74: 7f ff f3 36 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 4000bb78: 95 e8 20 03 restore %g0, 3, %o2 <== NOT EXECUTED 4000bb7c: 01 00 00 00 nop 400073b4 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 400073b4: 9d e3 bf 90 save %sp, -112, %sp Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 400073b8: a4 96 20 00 orcc %i0, 0, %l2 400073bc: 02 80 00 20 be 4000743c 400073c0: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 400073c4: 80 a6 e0 00 cmp %i3, 0 400073c8: 02 80 00 1d be 4000743c 400073cc: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 400073d0: 80 8e 60 10 btst 0x10, %i1 400073d4: 02 80 00 39 be 400074b8 400073d8: 80 a6 a0 00 cmp %i2, 0 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 400073dc: 02 80 00 18 be 4000743c 400073e0: 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; 400073e4: c0 27 bf f0 clr [ %fp + -16 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400073e8: 21 10 00 7b sethi %hi(0x4001ec00), %l0 400073ec: c2 04 21 f0 ld [ %l0 + 0x1f0 ], %g1 ! 4001edf0 <_Thread_Dispatch_disable_level> if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 400073f0: f4 27 bf f4 st %i2, [ %fp + -12 ] 400073f4: 82 00 60 01 inc %g1 400073f8: c2 24 21 f0 st %g1, [ %l0 + 0x1f0 ] * 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 ); 400073fc: 23 10 00 7b sethi %hi(0x4001ec00), %l1 40007400: 40 00 0a 45 call 40009d14 <_Objects_Allocate> 40007404: 90 14 60 58 or %l1, 0x58, %o0 ! 4001ec58 <_Barrier_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 40007408: b4 92 20 00 orcc %o0, 0, %i2 4000740c: 12 80 00 0e bne 40007444 40007410: 90 06 a0 14 add %i2, 0x14, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007414: c2 04 21 f0 ld [ %l0 + 0x1f0 ], %g1 40007418: b0 10 20 05 mov 5, %i0 4000741c: 82 00 7f ff add %g1, -1, %g1 40007420: c2 24 21 f0 st %g1, [ %l0 + 0x1f0 ] 40007424: c4 04 21 f0 ld [ %l0 + 0x1f0 ], %g2 40007428: 80 a0 a0 00 cmp %g2, 0 4000742c: 12 80 00 21 bne 400074b0 40007430: 01 00 00 00 nop _Thread_Dispatch(); 40007434: 40 00 10 b1 call 4000b6f8 <_Thread_Dispatch> 40007438: 01 00 00 00 nop 4000743c: 81 c7 e0 08 ret 40007440: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 40007444: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 40007448: 40 00 07 67 call 400091e4 <_CORE_barrier_Initialize> 4000744c: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40007450: 90 14 60 58 or %l1, 0x58, %o0 Objects_Name name ) { uint32_t index; index = _Objects_Get_index( the_object->id ); 40007454: c6 06 a0 08 ld [ %i2 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40007458: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 4000745c: 03 00 00 3f sethi %hi(0xfc00), %g1 40007460: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40007464: 82 08 c0 01 and %g3, %g1, %g1 40007468: 80 a0 40 02 cmp %g1, %g2 4000746c: 38 80 00 06 bgu,a 40007484 40007470: e4 26 a0 0c st %l2, [ %i2 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40007474: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40007478: 83 28 60 02 sll %g1, 2, %g1 4000747c: 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; 40007480: e4 26 a0 0c st %l2, [ %i2 + 0xc ] &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 40007484: c6 26 c0 00 st %g3, [ %i3 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007488: c2 04 21 f0 ld [ %l0 + 0x1f0 ], %g1 4000748c: b0 10 20 00 clr %i0 40007490: 82 00 7f ff add %g1, -1, %g1 40007494: c2 24 21 f0 st %g1, [ %l0 + 0x1f0 ] 40007498: c4 04 21 f0 ld [ %l0 + 0x1f0 ], %g2 4000749c: 80 a0 a0 00 cmp %g2, 0 400074a0: 12 80 00 04 bne 400074b0 400074a4: 01 00 00 00 nop _Thread_Dispatch(); 400074a8: 40 00 10 94 call 4000b6f8 <_Thread_Dispatch> 400074ac: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 400074b0: 81 c7 e0 08 ret 400074b4: 81 e8 00 00 restore if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 400074b8: 82 10 20 01 mov 1, %g1 400074bc: 10 bf ff cb b 400073e8 400074c0: c2 27 bf f0 st %g1, [ %fp + -16 ] 400074c4 : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 400074c4: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 400074c8: 21 10 00 7b sethi %hi(0x4001ec00), %l0 400074cc: 92 10 00 18 mov %i0, %o1 400074d0: 94 07 bf f4 add %fp, -12, %o2 400074d4: 40 00 0b 61 call 4000a258 <_Objects_Get> 400074d8: 90 14 20 58 or %l0, 0x58, %o0 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 400074dc: c2 07 bf f4 ld [ %fp + -12 ], %g1 400074e0: 80 a0 60 00 cmp %g1, 0 400074e4: 12 80 00 20 bne 40007564 400074e8: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Flush( 400074ec: 90 02 20 14 add %o0, 0x14, %o0 400074f0: 92 10 20 00 clr %o1 400074f4: 40 00 12 f7 call 4000c0d0 <_Thread_queue_Flush> 400074f8: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400074fc: 90 14 20 58 or %l0, 0x58, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40007500: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40007504: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40007508: 05 00 00 3f sethi %hi(0xfc00), %g2 4000750c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40007510: 82 08 40 02 and %g1, %g2, %g1 40007514: 80 a0 40 03 cmp %g1, %g3 40007518: 38 80 00 06 bgu,a 40007530 4000751c: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40007520: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40007524: 83 28 60 02 sll %g1, 2, %g1 40007528: 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; 4000752c: c0 26 20 0c clr [ %i0 + 0xc ] */ RTEMS_INLINE_ROUTINE void _Barrier_Free ( Barrier_Control *the_barrier ) { _Objects_Free( &_Barrier_Information, &the_barrier->Object ); 40007530: 40 00 0b 07 call 4000a14c <_Objects_Free> 40007534: 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 ) 40007538: 03 10 00 7b sethi %hi(0x4001ec00), %g1 4000753c: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 4001edf0 <_Thread_Dispatch_disable_level> 40007540: b0 10 20 00 clr %i0 40007544: 84 00 bf ff add %g2, -1, %g2 40007548: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 4000754c: c6 00 61 f0 ld [ %g1 + 0x1f0 ], %g3 40007550: 80 a0 e0 00 cmp %g3, 0 40007554: 02 80 00 09 be 40007578 40007558: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000755c: 81 c7 e0 08 ret 40007560: 81 e8 00 00 restore { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 40007564: 80 a0 60 02 cmp %g1, 2 40007568: 08 bf ff fd bleu 4000755c 4000756c: b0 10 20 04 mov 4, %i0 40007570: 81 c7 e0 08 ret <== NOT EXECUTED 40007574: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40007578: 40 00 10 60 call 4000b6f8 <_Thread_Dispatch> 4000757c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007580: 81 c7 e0 08 ret 40007584: 81 e8 00 00 restore 400075c0 : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 400075c0: 9d e3 bf 90 save %sp, -112, %sp 400075c4: a0 10 00 18 mov %i0, %l0 Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 400075c8: 80 a6 60 00 cmp %i1, 0 400075cc: 02 80 00 1f be 40007648 400075d0: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 400075d4: 11 10 00 7b sethi %hi(0x4001ec00), %o0 400075d8: 92 10 00 10 mov %l0, %o1 400075dc: 90 12 20 58 or %o0, 0x58, %o0 400075e0: 40 00 0b 1e call 4000a258 <_Objects_Get> 400075e4: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 400075e8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400075ec: 80 a0 60 00 cmp %g1, 0 400075f0: 02 80 00 07 be 4000760c 400075f4: 92 10 00 10 mov %l0, %o1 400075f8: 80 a0 60 02 cmp %g1, 2 400075fc: 08 80 00 13 bleu 40007648 40007600: b0 10 20 04 mov 4, %i0 40007604: 81 c7 e0 08 ret <== NOT EXECUTED 40007608: 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 ); 4000760c: 94 10 20 00 clr %o2 40007610: 40 00 07 01 call 40009214 <_CORE_barrier_Release> 40007614: 90 02 20 14 add %o0, 0x14, %o0 40007618: 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 ) 4000761c: 03 10 00 7b sethi %hi(0x4001ec00), %g1 40007620: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 4001edf0 <_Thread_Dispatch_disable_level> 40007624: b0 10 20 00 clr %i0 40007628: 84 00 bf ff add %g2, -1, %g2 4000762c: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 40007630: c6 00 61 f0 ld [ %g1 + 0x1f0 ], %g3 40007634: 80 a0 e0 00 cmp %g3, 0 40007638: 12 80 00 04 bne 40007648 4000763c: 01 00 00 00 nop _Thread_Dispatch(); 40007640: 40 00 10 2e call 4000b6f8 <_Thread_Dispatch> 40007644: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007648: 81 c7 e0 08 ret 4000764c: 81 e8 00 00 restore 40007650 : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 40007650: 9d e3 bf 90 save %sp, -112, %sp 40007654: 11 10 00 7b sethi %hi(0x4001ec00), %o0 40007658: 92 10 00 18 mov %i0, %o1 4000765c: 90 12 20 58 or %o0, 0x58, %o0 40007660: 40 00 0a fe call 4000a258 <_Objects_Get> 40007664: 94 07 bf f4 add %fp, -12, %o2 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 40007668: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000766c: 80 a0 60 00 cmp %g1, 0 40007670: 12 80 00 14 bne 400076c0 40007674: 96 10 00 19 mov %i1, %o3 case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Wait( 40007678: 90 02 20 14 add %o0, 0x14, %o0 4000767c: 92 10 00 18 mov %i0, %o1 40007680: 94 10 20 01 mov 1, %o2 40007684: 40 00 06 ef call 40009240 <_CORE_barrier_Wait> 40007688: 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 ) 4000768c: 03 10 00 7b sethi %hi(0x4001ec00), %g1 40007690: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 4001edf0 <_Thread_Dispatch_disable_level> 40007694: 84 00 bf ff add %g2, -1, %g2 40007698: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 4000769c: c6 00 61 f0 ld [ %g1 + 0x1f0 ], %g3 400076a0: 80 a0 e0 00 cmp %g3, 0 400076a4: 02 80 00 0d be 400076d8 400076a8: 03 10 00 7b sethi %hi(0x4001ec00), %g1 TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 400076ac: c4 00 62 cc ld [ %g1 + 0x2cc ], %g2 ! 4001eecc <_Thread_Executing> <== NOT EXECUTED 400076b0: 40 00 1d 9a call 4000ed18 <_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 400076b4: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 <== NOT EXECUTED _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400076b8: 81 c7 e0 08 ret 400076bc: 91 e8 00 08 restore %g0, %o0, %o0 { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 400076c0: 80 a0 60 02 cmp %g1, 2 400076c4: 08 bf ff fd bleu 400076b8 400076c8: 90 10 20 04 mov 4, %o0 400076cc: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400076d0: 81 c7 e0 08 ret <== NOT EXECUTED 400076d4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 400076d8: 40 00 10 08 call 4000b6f8 <_Thread_Dispatch> 400076dc: 01 00 00 00 nop TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 400076e0: 03 10 00 7b sethi %hi(0x4001ec00), %g1 400076e4: c4 00 62 cc ld [ %g1 + 0x2cc ], %g2 ! 4001eecc <_Thread_Executing> 400076e8: 40 00 1d 8c call 4000ed18 <_Barrier_Translate_core_barrier_return_code> 400076ec: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 400076f0: 30 bf ff f2 b,a 400076b8 400063c8 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 400063c8: 9d e3 bf 60 save %sp, -160, %sp 400063cc: 82 10 00 18 mov %i0, %g1 if ( !time_buffer ) 400063d0: 80 a6 60 00 cmp %i1, 0 400063d4: 02 80 00 19 be 40006438 400063d8: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; switch ( option ) { 400063dc: 80 a0 60 04 cmp %g1, 4 400063e0: 18 80 00 16 bgu 40006438 400063e4: b0 10 20 19 mov 0x19, %i0 400063e8: 83 28 60 02 sll %g1, 2, %g1 400063ec: 05 10 00 18 sethi %hi(0x40006000), %g2 400063f0: 84 10 a3 b4 or %g2, 0x3b4, %g2 ! 400063b4 400063f4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 400063f8: 81 c0 c0 00 jmp %g3 400063fc: 01 00 00 00 nop } case RTEMS_CLOCK_GET_TIME_VALUE: { struct timeval *time = (struct timeval *)time_buffer; if ( !_TOD_Is_set ) 40006400: 03 10 00 6b sethi %hi(0x4001ac00), %g1 <== NOT EXECUTED 40006404: c4 00 61 cc ld [ %g1 + 0x1cc ], %g2 ! 4001adcc <_TOD_Is_set> <== NOT EXECUTED 40006408: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000640c: 12 80 00 46 bne 40006524 <== NOT EXECUTED 40006410: 01 00 00 00 nop <== NOT EXECUTED } } return RTEMS_INTERNAL_ERROR; /* should never get here */ } 40006414: 81 c7 e0 08 ret 40006418: 91 e8 20 0b restore %g0, 0xb, %o0 } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick; 4000641c: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006420: d2 00 63 6c ld [ %g1 + 0x36c ], %o1 ! 4001af6c <_TOD_Microseconds_per_tick> 40006424: 11 00 03 d0 sethi %hi(0xf4000), %o0 40006428: b0 10 20 00 clr %i0 4000642c: 40 00 3f cd call 40016360 <.udiv> 40006430: 90 12 22 40 or %o0, 0x240, %o0 40006434: d0 26 40 00 st %o0, [ %i1 ] 40006438: 81 c7 e0 08 ret 4000643c: 81 e8 00 00 restore } case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = _Watchdog_Ticks_since_boot; 40006440: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006444: c4 00 63 14 ld [ %g1 + 0x314 ], %g2 ! 4001af14 <_Watchdog_Ticks_since_boot> 40006448: c4 26 40 00 st %g2, [ %i1 ] 4000644c: 81 c7 e0 08 ret 40006450: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: { rtems_interval *interval = (rtems_interval *)time_buffer; if ( !_TOD_Is_set ) 40006454: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006458: c4 00 61 cc ld [ %g1 + 0x1cc ], %g2 ! 4001adcc <_TOD_Is_set> 4000645c: 80 a0 a0 00 cmp %g2, 0 40006460: 02 bf ff ed be 40006414 40006464: 03 10 00 6b sethi %hi(0x4001ac00), %g1 return RTEMS_NOT_DEFINED; *interval = _TOD_Seconds_since_epoch; 40006468: c4 00 62 48 ld [ %g1 + 0x248 ], %g2 ! 4001ae48 <_TOD_Now> 4000646c: c4 26 40 00 st %g2, [ %i1 ] 40006470: 81 c7 e0 08 ret 40006474: 91 e8 20 00 restore %g0, 0, %o0 case RTEMS_CLOCK_GET_TOD: { struct tm time; struct timeval now; rtems_time_of_day *tmbuf = (rtems_time_of_day *)time_buffer; if ( !_TOD_Is_set ) 40006478: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000647c: c4 00 61 cc ld [ %g1 + 0x1cc ], %g2 ! 4001adcc <_TOD_Is_set> 40006480: 80 a0 a0 00 cmp %g2, 0 40006484: 02 bf ff e4 be 40006414 40006488: 01 00 00 00 nop ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 4000648c: 7f ff ee d0 call 40001fcc 40006490: 01 00 00 00 nop 40006494: a0 10 00 08 mov %o0, %l0 _TOD_Get( &now ); 40006498: 40 00 07 71 call 4000825c <_TOD_Get> 4000649c: 90 07 bf e8 add %fp, -24, %o0 _ISR_Enable(level); 400064a0: 7f ff ee cf call 40001fdc 400064a4: 90 10 00 10 mov %l0, %o0 time->tv_sec = now.tv_sec; 400064a8: c2 07 bf e8 ld [ %fp + -24 ], %g1 time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 400064ac: d0 07 bf ec ld [ %fp + -20 ], %o0 _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 400064b0: c2 27 bf f0 st %g1, [ %fp + -16 ] time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 400064b4: 40 00 3f ab call 40016360 <.udiv> 400064b8: 92 10 23 e8 mov 0x3e8, %o1 /* Obtain the current time */ _TOD_Get_timeval( &now ); /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 400064bc: 92 07 bf c4 add %fp, -60, %o1 400064c0: d0 27 bf f4 st %o0, [ %fp + -12 ] 400064c4: 40 00 25 4e call 4000f9fc 400064c8: 90 07 bf f0 add %fp, -16, %o0 /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; 400064cc: c4 07 bf d0 ld [ %fp + -48 ], %g2 tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 400064d0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400064d4: d2 00 63 6c ld [ %g1 + 0x36c ], %o1 ! 4001af6c <_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; 400064d8: c4 26 60 08 st %g2, [ %i1 + 8 ] tmbuf->hour = time.tm_hour; 400064dc: c2 07 bf cc ld [ %fp + -52 ], %g1 tmbuf->minute = time.tm_min; 400064e0: c4 07 bf c8 ld [ %fp + -56 ], %g2 /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; 400064e4: c2 26 60 0c st %g1, [ %i1 + 0xc ] tmbuf->minute = time.tm_min; 400064e8: c4 26 60 10 st %g2, [ %i1 + 0x10 ] /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 400064ec: c2 07 bf d8 ld [ %fp + -40 ], %g1 tmbuf->month = time.tm_mon + 1; 400064f0: c4 07 bf d4 ld [ %fp + -44 ], %g2 tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; 400064f4: c6 07 bf c4 ld [ %fp + -60 ], %g3 tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 400064f8: d0 07 bf f4 ld [ %fp + -12 ], %o0 /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 400064fc: 82 00 67 6c add %g1, 0x76c, %g1 tmbuf->month = time.tm_mon + 1; 40006500: 84 00 a0 01 inc %g2 tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; 40006504: c6 26 60 14 st %g3, [ %i1 + 0x14 ] /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 40006508: c2 26 40 00 st %g1, [ %i1 ] tmbuf->month = time.tm_mon + 1; 4000650c: c4 26 60 04 st %g2, [ %i1 + 4 ] tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 40006510: 40 00 3f 94 call 40016360 <.udiv> 40006514: b0 10 20 00 clr %i0 40006518: d0 26 60 18 st %o0, [ %i1 + 0x18 ] 4000651c: 81 c7 e0 08 ret 40006520: 81 e8 00 00 restore ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 40006524: 7f ff ee aa call 40001fcc <== NOT EXECUTED 40006528: 01 00 00 00 nop <== NOT EXECUTED 4000652c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED _TOD_Get( &now ); 40006530: 40 00 07 4b call 4000825c <_TOD_Get> <== NOT EXECUTED 40006534: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED _ISR_Enable(level); 40006538: 7f ff ee a9 call 40001fdc <== NOT EXECUTED 4000653c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED time->tv_sec = now.tv_sec; 40006540: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 40006544: d0 07 bf ec ld [ %fp + -20 ], %o0 <== NOT EXECUTED 40006548: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 4000654c: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 40006550: 40 00 3f 84 call 40016360 <.udiv> <== NOT EXECUTED 40006554: b0 10 20 00 clr %i0 <== NOT EXECUTED 40006558: d0 26 60 04 st %o0, [ %i1 + 4 ] <== NOT EXECUTED 4000655c: 81 c7 e0 08 ret <== NOT EXECUTED 40006560: 81 e8 00 00 restore <== NOT EXECUTED 40006584 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 40006584: 9d e3 bf 98 save %sp, -104, %sp _TOD_Tickle_ticks(); 40006588: 40 00 07 5d call 400082fc <_TOD_Tickle_ticks> 4000658c: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 40006590: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40006594: 40 00 15 1b call 4000ba00 <_Watchdog_Tickle> 40006598: 90 12 22 8c or %o0, 0x28c, %o0 ! 4001ae8c <_Watchdog_Ticks_chain> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 4000659c: 40 00 13 3f call 4000b298 <_Thread_Tickle_timeslice> 400065a0: 01 00 00 00 nop * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_context_switch_necessary( void ) { return ( _Context_Switch_necessary ); 400065a4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400065a8: c4 00 62 7c ld [ %g1 + 0x27c ], %g2 ! 4001ae7c <_Context_Switch_necessary> if ( _Thread_Is_context_switch_necessary() && 400065ac: 80 a0 a0 00 cmp %g2, 0 400065b0: 02 80 00 06 be 400065c8 400065b4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 400065b8: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 4001ad90 <_Thread_Dispatch_disable_level> 400065bc: 80 a0 a0 00 cmp %g2, 0 400065c0: 02 80 00 04 be 400065d0 400065c4: 01 00 00 00 nop _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 400065c8: 81 c7 e0 08 ret 400065cc: 91 e8 20 00 restore %g0, 0, %o0 _Thread_Tickle_timeslice(); if ( _Thread_Is_context_switch_necessary() && _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 400065d0: 40 00 0f 45 call 4000a2e4 <_Thread_Dispatch> <== NOT EXECUTED 400065d4: b0 10 20 00 clr %i0 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 400065d8: 81 c7 e0 08 ret <== NOT EXECUTED 400065dc: 81 e8 00 00 restore <== NOT EXECUTED 40006818 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 40006818: 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 ) ) { 4000681c: 92 96 20 00 orcc %i0, 0, %o1 40006820: 12 80 00 1c bne 40006890 40006824: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006828: 23 10 00 6b sethi %hi(0x4001ac00), %l1 4000682c: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> 40006830: 82 00 60 01 inc %g1 40006834: c2 24 61 90 st %g1, [ %l1 + 0x190 ] 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; 40006838: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000683c: f0 00 62 6c ld [ %g1 + 0x26c ], %i0 ! 4001ae6c <_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; 40006840: c0 27 bf f4 clr [ %fp + -12 ] rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 40006844: 7f ff ed e2 call 40001fcc 40006848: e0 06 21 6c ld [ %i0 + 0x16c ], %l0 *the_event_set |= the_new_events; 4000684c: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 40006850: 82 10 40 19 or %g1, %i1, %g1 40006854: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _ISR_Enable( level ); 40006858: 7f ff ed e1 call 40001fdc 4000685c: 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 ); 40006860: 40 00 00 2d call 40006914 <_Event_Surrender> 40006864: 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 ) 40006868: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 4000686c: b0 10 20 00 clr %i0 40006870: 82 00 7f ff add %g1, -1, %g1 40006874: c2 24 61 90 st %g1, [ %l1 + 0x190 ] 40006878: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 4000687c: 80 a0 a0 00 cmp %g2, 0 40006880: 02 80 00 0a be 400068a8 40006884: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006888: 81 c7 e0 08 ret 4000688c: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40006890: 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 ) { 40006894: 80 a0 a0 04 cmp %g2, 4 40006898: 08 80 00 08 bleu 400068b8 4000689c: 83 32 60 1b srl %o1, 0x1b, %g1 400068a0: 81 c7 e0 08 ret <== NOT EXECUTED 400068a4: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 400068a8: 40 00 0e 8f call 4000a2e4 <_Thread_Dispatch> 400068ac: 01 00 00 00 nop 400068b0: 81 c7 e0 08 ret 400068b4: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 400068b8: 80 a0 60 01 cmp %g1, 1 400068bc: 12 bf ff f3 bne 40006888 400068c0: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400068c4: 83 28 a0 02 sll %g2, 2, %g1 400068c8: 05 10 00 6b sethi %hi(0x4001ac00), %g2 400068cc: 84 10 a0 f0 or %g2, 0xf0, %g2 ! 4001acf0 <_Objects_Information_table> 400068d0: c6 00 80 01 ld [ %g2 + %g1 ], %g3 400068d4: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 400068d8: 80 a2 20 00 cmp %o0, 0 400068dc: 02 bf ff f5 be 400068b0 400068e0: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 400068e4: 40 00 09 58 call 40008e44 <_Objects_Get> 400068e8: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); switch ( location ) { 400068ec: c2 07 bf f4 ld [ %fp + -12 ], %g1 400068f0: b0 10 00 08 mov %o0, %i0 400068f4: 80 a0 60 00 cmp %g1, 0 400068f8: 02 bf ff d3 be 40006844 400068fc: 23 10 00 6b sethi %hi(0x4001ac00), %l1 40006900: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40006904: 18 bf ff e1 bgu 40006888 <== NOT EXECUTED 40006908: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4000690c: 81 c7 e0 08 ret <== NOT EXECUTED 40006910: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 4000ec04 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 4000ec04: 9d e3 bf 98 save %sp, -104, %sp Extension_Control *the_extension; if ( !rtems_is_name_valid( name ) ) 4000ec08: a6 96 20 00 orcc %i0, 0, %l3 4000ec0c: 02 80 00 16 be 4000ec64 4000ec10: b0 10 20 03 mov 3, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000ec14: 23 10 00 b1 sethi %hi(0x4002c400), %l1 4000ec18: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 ! 4002c410 <_Thread_Dispatch_disable_level> 4000ec1c: 82 00 60 01 inc %g1 4000ec20: c2 24 60 10 st %g1, [ %l1 + 0x10 ] * the inactive chain of free extension control blocks. */ RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void ) { return (Extension_Control *) _Objects_Allocate( &_Extension_Information ); 4000ec24: 25 10 00 b1 sethi %hi(0x4002c400), %l2 4000ec28: 40 00 03 cb call 4000fb54 <_Objects_Allocate> 4000ec2c: 90 14 a2 ac or %l2, 0x2ac, %o0 ! 4002c6ac <_Extension_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 4000ec30: a0 92 20 00 orcc %o0, 0, %l0 4000ec34: 12 80 00 0e bne 4000ec6c 4000ec38: 90 04 20 10 add %l0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000ec3c: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 <== NOT EXECUTED 4000ec40: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 4000ec44: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000ec48: c2 24 60 10 st %g1, [ %l1 + 0x10 ] <== NOT EXECUTED 4000ec4c: c4 04 60 10 ld [ %l1 + 0x10 ], %g2 <== NOT EXECUTED 4000ec50: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000ec54: 12 80 00 20 bne 4000ecd4 <== NOT EXECUTED 4000ec58: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4000ec5c: 40 00 0a 37 call 40011538 <_Thread_Dispatch> <== NOT EXECUTED 4000ec60: 01 00 00 00 nop <== NOT EXECUTED 4000ec64: 81 c7 e0 08 ret <== NOT EXECUTED 4000ec68: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 4000ec6c: 40 00 0e bb call 40012758 <_User_extensions_Add_set> 4000ec70: 92 10 00 19 mov %i1, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000ec74: 90 14 a2 ac or %l2, 0x2ac, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000ec78: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000ec7c: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 4000ec80: 03 00 00 3f sethi %hi(0xfc00), %g1 4000ec84: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000ec88: 82 08 c0 01 and %g3, %g1, %g1 4000ec8c: 80 a0 40 02 cmp %g1, %g2 4000ec90: 38 80 00 06 bgu,a 4000eca8 4000ec94: e6 24 20 0c st %l3, [ %l0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000ec98: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000ec9c: 83 28 60 02 sll %g1, 2, %g1 4000eca0: e0 20 80 01 st %l0, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 4000eca4: e6 24 20 0c st %l3, [ %l0 + 0xc ] &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 4000eca8: c6 26 80 00 st %g3, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000ecac: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 4000ecb0: b0 10 20 00 clr %i0 4000ecb4: 82 00 7f ff add %g1, -1, %g1 4000ecb8: c2 24 60 10 st %g1, [ %l1 + 0x10 ] 4000ecbc: c4 04 60 10 ld [ %l1 + 0x10 ], %g2 4000ecc0: 80 a0 a0 00 cmp %g2, 0 4000ecc4: 12 80 00 04 bne 4000ecd4 4000ecc8: 01 00 00 00 nop _Thread_Dispatch(); 4000eccc: 40 00 0a 1b call 40011538 <_Thread_Dispatch> 4000ecd0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 4000ecd4: 81 c7 e0 08 ret 4000ecd8: 81 e8 00 00 restore 4000ecdc : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 4000ecdc: 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 *) 4000ece0: 21 10 00 b1 sethi %hi(0x4002c400), %l0 <== NOT EXECUTED 4000ece4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000ece8: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 4000ecec: 40 00 04 eb call 40010098 <_Objects_Get> <== NOT EXECUTED 4000ecf0: 90 14 22 ac or %l0, 0x2ac, %o0 <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 4000ecf4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4000ecf8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000ecfc: 12 80 00 1e bne 4000ed74 <== NOT EXECUTED 4000ed00: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never return this */ return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 4000ed04: 40 00 0e cf call 40012840 <_User_extensions_Remove_set> <== NOT EXECUTED 4000ed08: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000ed0c: 90 14 22 ac or %l0, 0x2ac, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000ed10: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000ed14: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 <== NOT EXECUTED 4000ed18: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED 4000ed1c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <== NOT EXECUTED 4000ed20: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 4000ed24: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4000ed28: 38 80 00 06 bgu,a 4000ed40 <== NOT EXECUTED 4000ed2c: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000ed30: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 <== NOT EXECUTED 4000ed34: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4000ed38: 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; 4000ed3c: 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 ); 4000ed40: 40 00 04 93 call 4000ff8c <_Objects_Free> <== NOT EXECUTED 4000ed44: 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 ) 4000ed48: 03 10 00 b1 sethi %hi(0x4002c400), %g1 <== NOT EXECUTED 4000ed4c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 4002c410 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000ed50: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000ed54: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 4000ed58: c4 20 60 10 st %g2, [ %g1 + 0x10 ] <== NOT EXECUTED 4000ed5c: c6 00 60 10 ld [ %g1 + 0x10 ], %g3 <== NOT EXECUTED 4000ed60: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000ed64: 02 80 00 09 be 4000ed88 <== NOT EXECUTED 4000ed68: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000ed6c: 81 c7 e0 08 ret <== NOT EXECUTED 4000ed70: 81 e8 00 00 restore <== NOT EXECUTED { Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 4000ed74: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000ed78: 08 bf ff fd bleu 4000ed6c <== NOT EXECUTED 4000ed7c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 4000ed80: 81 c7 e0 08 ret <== NOT EXECUTED 4000ed84: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000ed88: 40 00 09 ec call 40011538 <_Thread_Dispatch> <== NOT EXECUTED 4000ed8c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000ed90: 81 c7 e0 08 ret <== NOT EXECUTED 4000ed94: 81 e8 00 00 restore <== NOT EXECUTED 40007b78 : */ void rtems_fatal_error_occurred( uint32_t the_error ) { 40007b78: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error ); 40007b7c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40007b80: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 40007b84: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40007b88: 40 00 03 31 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 40007b8c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 40007b90: 01 00 00 00 nop 40007b94 : #include const char *rtems_get_version_string(void) { return _RTEMS_version; } 40007b94: 11 10 00 66 sethi %hi(0x40019800), %o0 <== NOT EXECUTED 40007b98: 81 c3 e0 08 retl <== NOT EXECUTED 40007b9c: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 40019bd0 <_RTEMS_version> <== NOT EXECUTED 40007940 : rtems_interrupt_level rtems_initialize_executive_early( rtems_configuration_table *configuration_table, rtems_cpu_table *cpu_table ) { 40007940: 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 ); 40007944: 7f ff e9 a2 call 40001fcc 40007948: 01 00 00 00 nop 4000794c: a6 10 00 08 mov %o0, %l3 if ( configuration_table == NULL ) 40007950: 80 a6 20 00 cmp %i0, 0 40007954: 22 80 00 77 be,a 40007b30 40007958: 90 10 20 00 clr %o0 <== NOT EXECUTED /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 4000795c: 05 10 00 6b sethi %hi(0x4001ac00), %g2 RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; _System_state_Is_multiprocessing = is_multiprocessing; 40007960: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40007964: a4 10 a1 a4 or %g2, 0x1a4, %l2 40007968: 94 10 20 28 mov 0x28, %o2 4000796c: 92 10 00 19 mov %i1, %o1 40007970: c0 20 62 98 clr [ %g1 + 0x298 ] RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; 40007974: 29 10 00 6b sethi %hi(0x4001ac00), %l4 40007978: 90 10 00 12 mov %l2, %o0 4000797c: 40 00 20 25 call 4000fa10 40007980: c0 25 23 70 clr [ %l4 + 0x370 ] /* * Provided just for user convenience. */ _Configuration_Table = configuration_table; 40007984: 03 10 00 6b sethi %hi(0x4001ac00), %g1 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_NO_CPU_TABLE ); _CPU_Initialize( cpu_table, _Thread_Dispatch ); 40007988: 90 10 00 19 mov %i1, %o0 4000798c: 13 10 00 28 sethi %hi(0x4000a000), %o1 40007990: 92 12 62 e4 or %o1, 0x2e4, %o1 ! 4000a2e4 <_Thread_Dispatch> 40007994: 40 00 11 80 call 4000bf94 <_CPU_Initialize> 40007998: f0 20 62 50 st %i0, [ %g1 + 0x250 ] /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 4000799c: 40 00 18 bd call 4000dc90 <_Debug_Manager_initialization> 400079a0: a2 10 20 01 mov 1, %l1 _API_extensions_Initialization(); 400079a4: 40 00 00 dd call 40007d18 <_API_extensions_Initialization> 400079a8: 01 00 00 00 nop _Thread_Dispatch_initialization(); _Workspace_Handler_initialization( 400079ac: d2 06 20 04 ld [ %i0 + 4 ], %o1 400079b0: 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; 400079b4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400079b8: e2 20 61 90 st %l1, [ %g1 + 0x190 ] ! 4001ad90 <_Thread_Dispatch_disable_level> 400079bc: 40 00 10 48 call 4000badc <_Workspace_Handler_initialization> 400079c0: 21 10 00 6b sethi %hi(0x4001ac00), %l0 (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 400079c4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 400079c8: 40 00 0e b9 call 4000b4ac <_User_extensions_Handler_initialization> 400079cc: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 400079d0: 40 00 03 af call 4000888c <_ISR_Handler_initialization> 400079d4: 01 00 00 00 nop _Objects_Handler_initialization( 400079d8: 90 10 20 01 mov 1, %o0 ! 1 400079dc: 92 10 20 01 mov 1, %o1 400079e0: 40 00 05 b2 call 400090a8 <_Objects_Handler_initialization> 400079e4: 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; 400079e8: 05 10 00 6b sethi %hi(0x4001ac00), %g2 /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 400079ec: 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; 400079f0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400079f4: 82 10 61 d0 or %g1, 0x1d0, %g1 ! 4001add0 <_Internal_Objects> /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 400079f8: 92 10 20 01 mov 1, %o1 multiprocessing_table->node, multiprocessing_table->maximum_nodes, multiprocessing_table->maximum_global_objects ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 400079fc: c2 20 a0 f4 st %g1, [ %g2 + 0xf4 ] /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 40007a00: 94 10 20 02 mov 2, %o2 40007a04: 96 10 20 01 mov 1, %o3 40007a08: 98 10 20 74 mov 0x74, %o4 40007a0c: 9a 10 20 00 clr %o5 40007a10: 40 00 05 34 call 40008ee0 <_Objects_Initialize_information> 40007a14: 90 14 22 9c or %l0, 0x29c, %o0 _API_Mutex_Allocate( _RTEMS_Allocator_Mutex ); 40007a18: 82 10 20 02 mov 2, %g1 40007a1c: e2 27 bf e8 st %l1, [ %fp + -24 ] 40007a20: c2 27 bf f0 st %g1, [ %fp + -16 ] 40007a24: c0 27 bf ec clr [ %fp + -20 ] 40007a28: c0 27 bf f4 clr [ %fp + -12 ] 40007a2c: 40 00 03 b5 call 40008900 <_Objects_Allocate> 40007a30: 90 14 22 9c or %l0, 0x29c, %o0 40007a34: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40007a38: 84 10 00 08 mov %o0, %g2 40007a3c: 92 07 bf e8 add %fp, -24, %o1 40007a40: c4 20 62 64 st %g2, [ %g1 + 0x264 ] 40007a44: 90 02 20 10 add %o0, 0x10, %o0 40007a48: 40 00 01 21 call 40007ecc <_CORE_mutex_Initialize> 40007a4c: 94 10 20 01 mov 1, %o2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 40007a50: 03 10 00 6b sethi %hi(0x4001ac00), %g1 for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 40007a54: 05 10 00 6b sethi %hi(0x4001ac00), %g2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 40007a58: c0 30 62 60 clrh [ %g1 + 0x260 ] for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 40007a5c: c0 30 a2 f0 clrh [ %g2 + 0x2f0 ] 40007a60: 82 10 20 02 mov 2, %g1 40007a64: 84 10 a2 f0 or %g2, 0x2f0, %g2 40007a68: c0 30 40 02 clrh [ %g1 + %g2 ] 40007a6c: 82 00 60 02 add %g1, 2, %g1 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; for ( index=0 ; index <16 ; index++ ) 40007a70: 80 a0 60 20 cmp %g1, 0x20 40007a74: 32 bf ff fe bne,a 40007a6c 40007a78: c0 30 40 02 clrh [ %g1 + %g2 ] _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 40007a7c: 40 00 0f 98 call 4000b8dc <_Watchdog_Handler_initialization> 40007a80: 01 00 00 00 nop _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 40007a84: 40 00 02 0f call 400082c0 <_TOD_Handler_initialization> 40007a88: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _Thread_Handler_initialization( 40007a8c: d2 06 20 08 ld [ %i0 + 8 ], %o1 40007a90: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 40007a94: 40 00 0a db call 4000a600 <_Thread_Handler_initialization> 40007a98: 94 10 20 00 clr %o2 ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 40007a9c: 40 00 00 80 call 40007c9c <_RTEMS_API_Initialize> 40007aa0: 90 10 00 18 mov %i0, %o0 _Extension_Manager_initialization( configuration_table->maximum_extensions ); 40007aa4: 40 00 00 28 call 40007b44 <_Extension_Manager_initialization> 40007aa8: d0 06 20 08 ld [ %i0 + 8 ], %o0 _IO_Manager_initialization( 40007aac: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 40007ab0: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 40007ab4: 40 00 00 4c call 40007be4 <_IO_Manager_initialization> 40007ab8: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 40007abc: 82 10 20 01 mov 1, %g1 * * At this point all API extensions are in place. After the call to * _Thread_Create_idle() _Thread_Executing and _Thread_Heir will be set. */ _Thread_Create_idle(); 40007ac0: 40 00 09 b5 call 4000a194 <_Thread_Create_idle> 40007ac4: c2 25 23 70 st %g1, [ %l4 + 0x370 ] /* * Scheduling can properly occur now as long as we avoid dispatching. */ if ( cpu_table->pretasking_hook ) 40007ac8: d0 06 40 00 ld [ %i1 ], %o0 40007acc: 80 a2 20 00 cmp %o0, 0 40007ad0: 02 80 00 04 be 40007ae0 40007ad4: 01 00 00 00 nop (*cpu_table->pretasking_hook)(); 40007ad8: 9f c2 00 00 call %o0 40007adc: 01 00 00 00 nop /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 40007ae0: 40 00 00 b0 call 40007da0 <_API_extensions_Run_predriver> 40007ae4: 01 00 00 00 nop if ( _CPU_Table.predriver_hook ) 40007ae8: c2 04 a0 04 ld [ %l2 + 4 ], %g1 40007aec: 80 a0 60 00 cmp %g1, 0 40007af0: 02 80 00 04 be 40007b00 40007af4: 01 00 00 00 nop (*_CPU_Table.predriver_hook)(); 40007af8: 9f c0 40 00 call %g1 40007afc: 01 00 00 00 nop * Initialize all the device drivers and initialize the MPCI layer. * * NOTE: The MPCI may be build upon a device driver. */ _IO_Initialize_all_drivers(); 40007b00: 40 00 00 28 call 40007ba0 <_IO_Initialize_all_drivers> 40007b04: 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(); 40007b08: 40 00 00 8b call 40007d34 <_API_extensions_Run_postdriver> 40007b0c: 01 00 00 00 nop if ( _CPU_Table.postdriver_hook ) 40007b10: c4 04 a0 08 ld [ %l2 + 8 ], %g2 40007b14: 80 a0 a0 00 cmp %g2, 0 40007b18: 02 80 00 04 be 40007b28 40007b1c: 01 00 00 00 nop (*_CPU_Table.postdriver_hook)(); 40007b20: 9f c0 80 00 call %g2 40007b24: 01 00 00 00 nop return bsp_level; } 40007b28: 81 c7 e0 08 ret 40007b2c: 91 e8 00 13 restore %g0, %l3, %o0 */ _ISR_Disable( bsp_level ); if ( configuration_table == NULL ) _Internal_error_Occurred( 40007b30: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40007b34: 40 00 03 46 call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 40007b38: 94 10 20 00 clr %o2 <== NOT EXECUTED /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 40007b3c: 10 bf ff 89 b 40007960 <== NOT EXECUTED 40007b40: 05 10 00 6b sethi %hi(0x4001ac00), %g2 <== NOT EXECUTED 40008ca8 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 40008ca8: 9d e3 bf 98 save %sp, -104, %sp /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 40008cac: 80 a6 60 00 cmp %i1, 0 40008cb0: 02 80 00 3e be 40008da8 40008cb4: 90 10 00 18 mov %i0, %o0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 40008cb8: 80 a6 a0 00 cmp %i2, 0 40008cbc: 02 80 00 3b be 40008da8 40008cc0: 01 00 00 00 nop return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 40008cc4: c2 06 40 00 ld [ %i1 ], %g1 40008cc8: 80 a0 60 00 cmp %g1, 0 40008ccc: 22 80 00 34 be,a 40008d9c 40008cd0: c2 06 60 04 ld [ %i1 + 4 ], %g1 return RTEMS_INVALID_ADDRESS; *registered_major = 0; 40008cd4: c0 26 80 00 clr [ %i2 ] /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 40008cd8: 03 10 00 7b sethi %hi(0x4001ec00), %g1 40008cdc: c6 00 60 5c ld [ %g1 + 0x5c ], %g3 ! 4001ec5c <_IO_Number_of_drivers> 40008ce0: 80 a0 c0 08 cmp %g3, %o0 40008ce4: 08 80 00 43 bleu 40008df0 40008ce8: b0 10 20 0a mov 0xa, %i0 /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 40008cec: 80 a2 20 00 cmp %o0, 0 40008cf0: 12 80 00 1f bne 40008d6c 40008cf4: 03 10 00 7b sethi %hi(0x4001ec00), %g1 boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 40008cf8: 90 80 ff ff addcc %g3, -1, %o0 40008cfc: 02 80 00 26 be 40008d94 40008d00: c8 00 60 60 ld [ %g1 + 0x60 ], %g4 if ( !_IO_Driver_address_table[major].initialization_entry && 40008d04: 85 28 e0 05 sll %g3, 5, %g2 40008d08: 83 28 e0 03 sll %g3, 3, %g1 40008d0c: 84 20 80 01 sub %g2, %g1, %g2 40008d10: 84 00 bf e8 add %g2, -24, %g2 40008d14: 10 80 00 04 b 40008d24 40008d18: 84 00 80 04 add %g2, %g4, %g2 * in use. */ if ( major == 0 ) { boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 40008d1c: 02 80 00 1e be 40008d94 40008d20: 84 00 bf e8 add %g2, -24, %g2 if ( !_IO_Driver_address_table[major].initialization_entry && 40008d24: c2 00 80 00 ld [ %g2 ], %g1 40008d28: 80 a0 60 00 cmp %g1, 0 40008d2c: 32 bf ff fc bne,a 40008d1c 40008d30: 90 82 3f ff addcc %o0, -1, %o0 40008d34: c2 00 a0 04 ld [ %g2 + 4 ], %g1 40008d38: 80 a0 60 00 cmp %g1, 0 40008d3c: 32 bf ff f8 bne,a 40008d1c 40008d40: 90 82 3f ff addcc %o0, -1, %o0 <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 40008d44: 85 2a 20 03 sll %o0, 3, %g2 40008d48: 83 2a 20 05 sll %o0, 5, %g1 40008d4c: 82 20 40 02 sub %g1, %g2, %g1 40008d50: 88 01 00 01 add %g4, %g1, %g4 40008d54: c2 01 20 04 ld [ %g4 + 4 ], %g1 40008d58: 80 a0 60 00 cmp %g1, 0 40008d5c: 22 80 00 15 be,a 40008db0 40008d60: c2 06 40 00 ld [ %i1 ], %g1 _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 40008d64: 81 c7 e0 08 ret <== NOT EXECUTED 40008d68: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 40008d6c: c8 00 60 60 ld [ %g1 + 0x60 ], %g4 40008d70: 85 2a 20 03 sll %o0, 3, %g2 40008d74: 83 2a 20 05 sll %o0, 5, %g1 40008d78: 82 20 40 02 sub %g1, %g2, %g1 40008d7c: c6 00 40 04 ld [ %g1 + %g4 ], %g3 40008d80: 80 a0 e0 00 cmp %g3, 0 40008d84: 02 bf ff f4 be 40008d54 40008d88: 88 00 40 04 add %g1, %g4, %g4 _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 40008d8c: 81 c7 e0 08 ret 40008d90: 91 e8 20 0c restore %g0, 0xc, %o0 40008d94: 81 c7 e0 08 ret 40008d98: 91 e8 20 05 restore %g0, 5, %o0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 40008d9c: 80 a0 60 00 cmp %g1, 0 40008da0: 32 bf ff ce bne,a 40008cd8 40008da4: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 40008da8: 81 c7 e0 08 ret 40008dac: 91 e8 20 09 restore %g0, 9, %o0 _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; *registered_major = major; 40008db0: d0 26 80 00 st %o0, [ %i2 ] if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 40008db4: c2 21 00 00 st %g1, [ %g4 ] 40008db8: c4 06 60 04 ld [ %i1 + 4 ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40008dbc: 92 10 20 00 clr %o1 if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 40008dc0: c4 21 20 04 st %g2, [ %g4 + 4 ] 40008dc4: c2 06 60 08 ld [ %i1 + 8 ], %g1 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40008dc8: 94 10 20 00 clr %o2 if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 40008dcc: c2 21 20 08 st %g1, [ %g4 + 8 ] 40008dd0: c4 06 60 0c ld [ %i1 + 0xc ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40008dd4: b0 10 20 00 clr %i0 if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 40008dd8: c4 21 20 0c st %g2, [ %g4 + 0xc ] 40008ddc: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 40008de0: c2 21 20 10 st %g1, [ %g4 + 0x10 ] 40008de4: c4 06 60 14 ld [ %i1 + 0x14 ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40008de8: 7f ff ff 30 call 40008aa8 40008dec: c4 21 20 14 st %g2, [ %g4 + 0x14 ] 40008df0: 81 c7 e0 08 ret 40008df4: 81 e8 00 00 restore 4000a300 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 4000a300: 9d e3 bf 98 save %sp, -104, %sp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 4000a304: 80 a6 20 00 cmp %i0, 0 4000a308: 02 80 00 23 be 4000a394 4000a30c: 03 10 00 9c sethi %hi(0x40027000), %g1 return; 4000a310: a4 10 62 c4 or %g1, 0x2c4, %l2 ! 400272c4 <_Objects_Information_table+0x4> 4000a314: a6 04 a0 10 add %l2, 0x10, %l3 for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 4000a318: c2 04 80 00 ld [ %l2 ], %g1 4000a31c: 80 a0 60 00 cmp %g1, 0 4000a320: 22 80 00 1a be,a 4000a388 4000a324: a4 04 a0 04 add %l2, 4, %l2 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 4000a328: e2 00 60 04 ld [ %g1 + 4 ], %l1 if ( information ) { 4000a32c: 80 a4 60 00 cmp %l1, 0 4000a330: 22 80 00 16 be,a 4000a388 4000a334: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 4000a338: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 4000a33c: 86 90 60 00 orcc %g1, 0, %g3 4000a340: 22 80 00 12 be,a 4000a388 4000a344: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED 4000a348: a0 10 20 01 mov 1, %l0 the_thread = (Thread_Control *)information->local_table[ i ]; 4000a34c: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 4000a350: 83 2c 20 02 sll %l0, 2, %g1 4000a354: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( !the_thread ) 4000a358: 80 a2 20 00 cmp %o0, 0 4000a35c: 02 80 00 05 be 4000a370 4000a360: a0 04 20 01 inc %l0 continue; (*routine)(the_thread); 4000a364: 9f c6 00 00 call %i0 4000a368: 01 00 00 00 nop 4000a36c: c6 14 60 10 lduh [ %l1 + 0x10 ], %g3 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 4000a370: 83 28 e0 10 sll %g3, 0x10, %g1 4000a374: 83 30 60 10 srl %g1, 0x10, %g1 4000a378: 80 a0 40 10 cmp %g1, %l0 4000a37c: 3a bf ff f5 bcc,a 4000a350 4000a380: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 4000a384: a4 04 a0 04 add %l2, 4, %l2 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 4000a388: 80 a4 80 13 cmp %l2, %l3 4000a38c: 32 bf ff e4 bne,a 4000a31c 4000a390: c2 04 80 00 ld [ %l2 ], %g1 4000a394: 81 c7 e0 08 ret 4000a398: 81 e8 00 00 restore 400100f4 : Objects_Id id, void *buffer, size_t size, uint32_t *count ) { 400100f4: 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 ) 400100f8: 80 a6 60 00 cmp %i1, 0 400100fc: 02 80 00 28 be 4001019c 40010100: 80 a6 e0 00 cmp %i3, 0 return RTEMS_INVALID_ADDRESS; if ( !count ) 40010104: 02 80 00 26 be 4001019c 40010108: 92 10 00 18 mov %i0, %o1 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 4001010c: 11 10 00 d2 sethi %hi(0x40034800), %o0 40010110: 90 12 22 80 or %o0, 0x280, %o0 ! 40034a80 <_Message_queue_Information> 40010114: 40 00 19 5e call 4001668c <_Objects_Get> 40010118: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 4001011c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40010120: 80 a0 60 00 cmp %g1, 0 40010124: 02 80 00 08 be 40010144 40010128: 9a 10 00 1b mov %i3, %o5 4001012c: 80 a0 60 02 cmp %g1, 2 40010130: 08 80 00 03 bleu 4001013c 40010134: 90 10 20 04 mov 4, %o0 40010138: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code( core_status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001013c: 81 c7 e0 08 ret 40010140: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 40010144: 92 10 00 19 mov %i1, %o1 40010148: 94 10 00 1a mov %i2, %o2 4001014c: 96 10 00 18 mov %i0, %o3 40010150: 98 10 20 00 clr %o4 40010154: 40 00 13 d2 call 4001509c <_CORE_message_queue_Broadcast> 40010158: 90 02 20 14 add %o0, 0x14, %o0 4001015c: 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 ) 40010160: 03 10 00 d1 sethi %hi(0x40034400), %g1 40010164: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 40010168: 84 00 bf ff add %g2, -1, %g2 4001016c: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 40010170: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 40010174: 80 a0 e0 00 cmp %g3, 0 40010178: 02 80 00 06 be 40010190 4001017c: 01 00 00 00 nop #endif count ); _Thread_Enable_dispatch(); return 40010180: 40 00 01 35 call 40010654 <_Message_queue_Translate_core_message_queue_return_code> 40010184: 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 */ } 40010188: 81 c7 e0 08 ret 4001018c: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40010190: 40 00 1e 67 call 40017b2c <_Thread_Dispatch> 40010194: 01 00 00 00 nop 40010198: 30 bf ff fa b,a 40010180 #endif count ); _Thread_Enable_dispatch(); return 4001019c: 10 bf ff e8 b 4001013c <== NOT EXECUTED 400101a0: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED 400101a4 : uint32_t count, uint32_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 400101a4: 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 ) ) 400101a8: a4 96 20 00 orcc %i0, 0, %l2 400101ac: 02 80 00 1f be 40010228 400101b0: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 400101b4: 80 a7 20 00 cmp %i4, 0 400101b8: 02 80 00 1c be 40010228 400101bc: 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 ) 400101c0: 80 a6 60 00 cmp %i1, 0 400101c4: 02 80 00 19 be 40010228 400101c8: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 400101cc: 80 a6 a0 00 cmp %i2, 0 400101d0: 02 80 00 16 be 40010228 400101d4: b0 10 20 08 mov 8, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400101d8: 23 10 00 d1 sethi %hi(0x40034400), %l1 400101dc: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 400101e0: 82 00 60 01 inc %g1 400101e4: c2 24 63 60 st %g1, [ %l1 + 0x360 ] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate( count, max_message_size ); 400101e8: 90 10 00 19 mov %i1, %o0 400101ec: 40 00 2d 2f call 4001b6a8 <_Message_queue_Allocate> 400101f0: 92 10 00 1a mov %i2, %o1 if ( !the_message_queue ) { 400101f4: a0 92 20 00 orcc %o0, 0, %l0 400101f8: 12 80 00 0e bne 40010230 400101fc: 80 8e e0 04 btst 4, %i3 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010200: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40010204: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 40010208: 82 00 7f ff add %g1, -1, %g1 4001020c: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40010210: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40010214: 80 a0 a0 00 cmp %g2, 0 40010218: 12 80 00 33 bne 400102e4 4001021c: 01 00 00 00 nop 40010220: 40 00 1e 43 call 40017b2c <_Thread_Dispatch> 40010224: 01 00 00 00 nop 40010228: 81 c7 e0 08 ret 4001022c: 81 e8 00 00 restore } #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) 40010230: 12 80 00 11 bne 40010274 40010234: f6 24 20 10 st %i3, [ %l0 + 0x10 ] the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 40010238: c0 27 bf f4 clr [ %fp + -12 ] if ( ! _CORE_message_queue_Initialize( 4001023c: 94 10 00 19 mov %i1, %o2 40010240: 96 10 00 1a mov %i2, %o3 40010244: 90 04 20 14 add %l0, 0x14, %o0 40010248: 40 00 13 e2 call 400151d0 <_CORE_message_queue_Initialize> 4001024c: 92 07 bf f4 add %fp, -12, %o1 40010250: 80 a2 20 00 cmp %o0, 0 40010254: 12 80 00 0b bne 40010280 40010258: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 4001025c: 11 10 00 d2 sethi %hi(0x40034800), %o0 <== NOT EXECUTED 40010260: 40 00 18 b4 call 40016530 <_Objects_Free> <== NOT EXECUTED 40010264: 90 12 22 80 or %o0, 0x280, %o0 ! 40034a80 <_Message_queue_Information> <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010268: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 4001026c: 10 bf ff e7 b 40010208 <== NOT EXECUTED 40010270: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 40010274: 82 10 20 01 mov 1, %g1 40010278: 10 bf ff f1 b 4001023c 4001027c: c2 27 bf f4 st %g1, [ %fp + -12 ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40010280: 03 10 00 d2 sethi %hi(0x40034800), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40010284: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40010288: 88 10 62 80 or %g1, 0x280, %g4 4001028c: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 40010290: 03 00 00 3f sethi %hi(0xfc00), %g1 40010294: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40010298: 82 08 c0 01 and %g3, %g1, %g1 4001029c: 80 a0 40 02 cmp %g1, %g2 400102a0: 38 80 00 06 bgu,a 400102b8 400102a4: e4 24 20 0c st %l2, [ %l0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 400102a8: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 400102ac: 83 28 60 02 sll %g1, 2, %g1 400102b0: e0 20 80 01 st %l0, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 400102b4: e4 24 20 0c st %l2, [ %l0 + 0xc ] &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 400102b8: c6 27 00 00 st %g3, [ %i4 ] 400102bc: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 400102c0: b0 10 20 00 clr %i0 400102c4: 82 00 7f ff add %g1, -1, %g1 400102c8: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 400102cc: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 400102d0: 80 a0 a0 00 cmp %g2, 0 400102d4: 12 80 00 04 bne 400102e4 400102d8: 01 00 00 00 nop _Thread_Dispatch(); 400102dc: 40 00 1e 14 call 40017b2c <_Thread_Dispatch> 400102e0: 01 00 00 00 nop ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 400102e4: 81 c7 e0 08 ret 400102e8: 81 e8 00 00 restore 40016c34 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 40016c34: 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 *) 40016c38: 21 10 00 b1 sethi %hi(0x4002c400), %l0 40016c3c: 92 10 00 18 mov %i0, %o1 40016c40: 94 07 bf f4 add %fp, -12, %o2 40016c44: 7f ff e5 15 call 40010098 <_Objects_Get> 40016c48: 90 14 23 ac or %l0, 0x3ac, %o0 register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 40016c4c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40016c50: 80 a0 60 00 cmp %g1, 0 40016c54: 12 80 00 20 bne 40016cd4 40016c58: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40016c5c: a0 14 23 ac or %l0, 0x3ac, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40016c60: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40016c64: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 40016c68: 05 00 00 3f sethi %hi(0xfc00), %g2 40016c6c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40016c70: 82 08 40 02 and %g1, %g2, %g1 40016c74: 80 a0 40 03 cmp %g1, %g3 40016c78: 18 80 00 05 bgu 40016c8c 40016c7c: 94 10 20 05 mov 5, %o2 information->local_table[ index ] = the_object; 40016c80: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 40016c84: 83 28 60 02 sll %g1, 2, %g1 40016c88: c0 20 80 01 clr [ %g2 + %g1 ] case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, &the_message_queue->Object ); _CORE_message_queue_Close( 40016c8c: 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; 40016c90: c0 26 20 0c clr [ %i0 + 0xc ] 40016c94: 40 00 01 c0 call 40017394 <_CORE_message_queue_Close> 40016c98: 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 ); 40016c9c: 90 10 00 10 mov %l0, %o0 40016ca0: 7f ff e4 bb call 4000ff8c <_Objects_Free> 40016ca4: 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 ) 40016ca8: 03 10 00 b1 sethi %hi(0x4002c400), %g1 40016cac: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 4002c410 <_Thread_Dispatch_disable_level> 40016cb0: b0 10 20 00 clr %i0 40016cb4: 84 00 bf ff add %g2, -1, %g2 40016cb8: c4 20 60 10 st %g2, [ %g1 + 0x10 ] 40016cbc: c6 00 60 10 ld [ %g1 + 0x10 ], %g3 40016cc0: 80 a0 e0 00 cmp %g3, 0 40016cc4: 02 80 00 09 be 40016ce8 40016cc8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40016ccc: 81 c7 e0 08 ret 40016cd0: 81 e8 00 00 restore { register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 40016cd4: 80 a0 60 02 cmp %g1, 2 40016cd8: 08 bf ff fd bleu 40016ccc 40016cdc: b0 10 20 04 mov 4, %i0 40016ce0: 81 c7 e0 08 ret <== NOT EXECUTED 40016ce4: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40016ce8: 7f ff ea 14 call 40011538 <_Thread_Dispatch> 40016cec: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40016cf0: 81 c7 e0 08 ret 40016cf4: 81 e8 00 00 restore 400103b0 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 400103b0: 9d e3 bf 90 save %sp, -112, %sp 400103b4: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 400103b8: 80 a6 60 00 cmp %i1, 0 400103bc: 02 80 00 1c be 4001042c 400103c0: 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 *) 400103c4: 11 10 00 d2 sethi %hi(0x40034800), %o0 400103c8: 94 07 bf f4 add %fp, -12, %o2 400103cc: 40 00 18 b0 call 4001668c <_Objects_Get> 400103d0: 90 12 22 80 or %o0, 0x280, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 400103d4: c2 07 bf f4 ld [ %fp + -12 ], %g1 400103d8: 80 a0 60 00 cmp %g1, 0 400103dc: 02 80 00 06 be 400103f4 400103e0: 80 a0 60 02 cmp %g1, 2 400103e4: 08 80 00 12 bleu 4001042c 400103e8: b0 10 20 04 mov 4, %i0 400103ec: 81 c7 e0 08 ret <== NOT EXECUTED 400103f0: 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 ); 400103f4: 40 00 13 57 call 40015150 <_CORE_message_queue_Flush> 400103f8: 90 02 20 14 add %o0, 0x14, %o0 400103fc: 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 ) 40010400: 03 10 00 d1 sethi %hi(0x40034400), %g1 40010404: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 40010408: b0 10 20 00 clr %i0 4001040c: 84 00 bf ff add %g2, -1, %g2 40010410: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 40010414: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 40010418: 80 a0 e0 00 cmp %g3, 0 4001041c: 12 80 00 04 bne 4001042c 40010420: 01 00 00 00 nop _Thread_Dispatch(); 40010424: 40 00 1d c2 call 40017b2c <_Thread_Dispatch> 40010428: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001042c: 81 c7 e0 08 ret 40010430: 81 e8 00 00 restore 40010434 : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 40010434: 9d e3 bf 90 save %sp, -112, %sp 40010438: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 4001043c: 80 a6 60 00 cmp %i1, 0 40010440: 02 80 00 1b be 400104ac 40010444: b0 10 20 09 mov 9, %i0 40010448: 11 10 00 d2 sethi %hi(0x40034800), %o0 4001044c: 94 07 bf f4 add %fp, -12, %o2 40010450: 40 00 18 8f call 4001668c <_Objects_Get> 40010454: 90 12 22 80 or %o0, 0x280, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 40010458: c2 07 bf f4 ld [ %fp + -12 ], %g1 4001045c: 80 a0 60 00 cmp %g1, 0 40010460: 22 80 00 07 be,a 4001047c 40010464: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 40010468: 80 a0 60 02 cmp %g1, 2 4001046c: 08 80 00 10 bleu 400104ac 40010470: b0 10 20 04 mov 4, %i0 40010474: 81 c7 e0 08 ret <== NOT EXECUTED 40010478: 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; 4001047c: 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 ) 40010480: 07 10 00 d1 sethi %hi(0x40034400), %g3 40010484: c2 00 e3 60 ld [ %g3 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 40010488: b0 10 20 00 clr %i0 4001048c: 82 00 7f ff add %g1, -1, %g1 40010490: c2 20 e3 60 st %g1, [ %g3 + 0x360 ] 40010494: c4 00 e3 60 ld [ %g3 + 0x360 ], %g2 40010498: 80 a0 a0 00 cmp %g2, 0 4001049c: 12 80 00 04 bne 400104ac 400104a0: 01 00 00 00 nop _Thread_Dispatch(); 400104a4: 40 00 1d a2 call 40017b2c <_Thread_Dispatch> 400104a8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400104ac: 81 c7 e0 08 ret 400104b0: 81 e8 00 00 restore 40016d2c : void *buffer, size_t *size, uint32_t option_set, rtems_interval timeout ) { 40016d2c: 9d e3 bf 90 save %sp, -112, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; boolean wait; if ( !buffer ) 40016d30: 80 a6 60 00 cmp %i1, 0 40016d34: 02 80 00 2b be 40016de0 40016d38: 92 10 00 18 mov %i0, %o1 return RTEMS_INVALID_ADDRESS; if ( !size ) 40016d3c: 80 a6 a0 00 cmp %i2, 0 40016d40: 02 80 00 28 be 40016de0 40016d44: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 40016d48: 11 10 00 b1 sethi %hi(0x4002c400), %o0 40016d4c: 7f ff e4 d3 call 40010098 <_Objects_Get> 40016d50: 90 12 23 ac or %o0, 0x3ac, %o0 ! 4002c7ac <_Message_queue_Information> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 40016d54: c2 07 bf f4 ld [ %fp + -12 ], %g1 40016d58: 80 a0 60 00 cmp %g1, 0 40016d5c: 22 80 00 08 be,a 40016d7c 40016d60: d2 02 20 08 ld [ %o0 + 8 ], %o1 40016d64: 80 a0 60 02 cmp %g1, 2 40016d68: 08 80 00 03 bleu 40016d74 40016d6c: 90 10 20 04 mov 4, %o0 40016d70: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40016d74: 81 c7 e0 08 ret 40016d78: 91 e8 00 08 restore %g0, %o0, %o0 40016d7c: 98 0e e0 01 and %i3, 1, %o4 if ( _Options_Is_no_wait( option_set ) ) wait = FALSE; else wait = TRUE; _CORE_message_queue_Seize( 40016d80: 94 10 00 19 mov %i1, %o2 40016d84: 96 10 00 1a mov %i2, %o3 40016d88: 98 1b 20 01 xor %o4, 1, %o4 40016d8c: 9a 10 00 1c mov %i4, %o5 40016d90: 40 00 01 a7 call 4001742c <_CORE_message_queue_Seize> 40016d94: 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 ) 40016d98: 05 10 00 b1 sethi %hi(0x4002c400), %g2 40016d9c: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 ! 4002c410 <_Thread_Dispatch_disable_level> 40016da0: 82 00 7f ff add %g1, -1, %g1 40016da4: c2 20 a0 10 st %g1, [ %g2 + 0x10 ] 40016da8: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3 40016dac: 80 a0 e0 00 cmp %g3, 0 40016db0: 02 80 00 08 be 40016dd0 40016db4: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 40016db8: 03 10 00 b1 sethi %hi(0x4002c400), %g1 <== NOT EXECUTED 40016dbc: c4 00 60 ec ld [ %g1 + 0xec ], %g2 ! 4002c4ec <_Thread_Executing> 40016dc0: 40 00 00 36 call 40016e98 <_Message_queue_Translate_core_message_queue_return_code> 40016dc4: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40016dc8: 81 c7 e0 08 ret 40016dcc: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40016dd0: 7f ff e9 da call 40011538 <_Thread_Dispatch> 40016dd4: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 40016dd8: 10 bf ff f9 b 40016dbc 40016ddc: 03 10 00 b1 sethi %hi(0x4002c400), %g1 40016de0: 10 bf ff e5 b 40016d74 <== NOT EXECUTED 40016de4: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED 40016de8 : rtems_status_code rtems_message_queue_send( Objects_Id id, void *buffer, size_t size ) { 40016de8: 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 ) 40016dec: 80 a6 60 00 cmp %i1, 0 40016df0: 02 80 00 20 be 40016e70 40016df4: 90 10 20 09 mov 9, %o0 40016df8: 11 10 00 b1 sethi %hi(0x4002c400), %o0 40016dfc: 92 10 00 18 mov %i0, %o1 40016e00: 90 12 23 ac or %o0, 0x3ac, %o0 40016e04: 7f ff e4 a5 call 40010098 <_Objects_Get> 40016e08: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 40016e0c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40016e10: 80 a0 60 00 cmp %g1, 0 40016e14: 12 80 00 19 bne 40016e78 40016e18: 80 a0 60 02 cmp %g1, 2 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 40016e1c: 94 10 00 1a mov %i2, %o2 40016e20: c0 23 a0 5c clr [ %sp + 0x5c ] 40016e24: c0 23 a0 60 clr [ %sp + 0x60 ] 40016e28: 92 10 00 19 mov %i1, %o1 40016e2c: 96 10 00 18 mov %i0, %o3 40016e30: 98 10 20 00 clr %o4 40016e34: 90 02 20 14 add %o0, 0x14, %o0 40016e38: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5 40016e3c: 40 00 01 c3 call 40017548 <_CORE_message_queue_Submit> 40016e40: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff 40016e44: 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 ) 40016e48: 05 10 00 b1 sethi %hi(0x4002c400), %g2 40016e4c: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 ! 4002c410 <_Thread_Dispatch_disable_level> 40016e50: 82 00 7f ff add %g1, -1, %g1 40016e54: c2 20 a0 10 st %g1, [ %g2 + 0x10 ] 40016e58: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3 40016e5c: 80 a0 e0 00 cmp %g3, 0 40016e60: 02 80 00 0b be 40016e8c 40016e64: 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); 40016e68: 40 00 00 0c call 40016e98 <_Message_queue_Translate_core_message_queue_return_code> 40016e6c: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40016e70: 81 c7 e0 08 ret 40016e74: 91 e8 00 08 restore %g0, %o0, %o0 if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 40016e78: 08 bf ff fe bleu 40016e70 40016e7c: 90 10 20 04 mov 4, %o0 40016e80: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code(status); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40016e84: 81 c7 e0 08 ret <== NOT EXECUTED 40016e88: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40016e8c: 7f ff e9 ab call 40011538 <_Thread_Dispatch> 40016e90: 01 00 00 00 nop 40016e94: 30 bf ff f5 b,a 40016e68 400099f4 : rtems_status_code rtems_message_queue_urgent( Objects_Id id, void *buffer, size_t size ) { 400099f4: 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 ) 400099f8: 80 a6 60 00 cmp %i1, 0 400099fc: 02 80 00 1f be 40009a78 40009a00: 90 10 20 09 mov 9, %o0 40009a04: 11 10 00 8a sethi %hi(0x40022800), %o0 40009a08: 92 10 00 18 mov %i0, %o1 40009a0c: 90 12 21 a8 or %o0, 0x1a8, %o0 40009a10: 40 00 0a 21 call 4000c294 <_Objects_Get> 40009a14: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 40009a18: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009a1c: 80 a0 60 00 cmp %g1, 0 40009a20: 12 80 00 18 bne 40009a80 40009a24: 80 a0 60 02 cmp %g1, 2 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 40009a28: 94 10 00 1a mov %i2, %o2 40009a2c: c0 23 a0 5c clr [ %sp + 0x5c ] 40009a30: c0 23 a0 60 clr [ %sp + 0x60 ] 40009a34: 92 10 00 19 mov %i1, %o1 40009a38: 96 10 00 18 mov %i0, %o3 40009a3c: 98 10 20 00 clr %o4 40009a40: 1b 20 00 00 sethi %hi(0x80000000), %o5 40009a44: 40 00 05 e8 call 4000b1e4 <_CORE_message_queue_Submit> 40009a48: 90 02 20 14 add %o0, 0x14, %o0 40009a4c: 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 ) 40009a50: 03 10 00 89 sethi %hi(0x40022400), %g1 40009a54: c4 00 62 90 ld [ %g1 + 0x290 ], %g2 ! 40022690 <_Thread_Dispatch_disable_level> 40009a58: 84 00 bf ff add %g2, -1, %g2 40009a5c: c4 20 62 90 st %g2, [ %g1 + 0x290 ] 40009a60: c6 00 62 90 ld [ %g1 + 0x290 ], %g3 40009a64: 80 a0 e0 00 cmp %g3, 0 40009a68: 02 80 00 0b be 40009a94 40009a6c: 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); 40009a70: 7f ff ff d7 call 400099cc <_Message_queue_Translate_core_message_queue_return_code> 40009a74: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40009a78: 81 c7 e0 08 ret 40009a7c: 91 e8 00 08 restore %g0, %o0, %o0 if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 40009a80: 08 bf ff fe bleu 40009a78 <== NOT EXECUTED 40009a84: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED 40009a88: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code(status); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40009a8c: 81 c7 e0 08 ret <== NOT EXECUTED 40009a90: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40009a94: 40 00 0f 28 call 4000d734 <_Thread_Dispatch> 40009a98: 01 00 00 00 nop 40009a9c: 30 bf ff f5 b,a 40009a70 4001067c : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 4001067c: 9d e3 bf 98 save %sp, -104, %sp register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 40010680: a8 96 20 00 orcc %i0, 0, %l4 40010684: 02 80 00 29 be 40010728 40010688: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 4001068c: 80 a6 60 00 cmp %i1, 0 40010690: 02 80 00 11 be 400106d4 40010694: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 40010698: 02 80 00 0f be 400106d4 4001069c: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 400106a0: 12 80 00 04 bne 400106b0 400106a4: 80 a6 e0 00 cmp %i3, 0 ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 400106a8: 81 c7 e0 08 ret 400106ac: 91 e8 20 08 restore %g0, 8, %o0 return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 400106b0: 02 80 00 1e be 40010728 400106b4: b0 10 20 08 mov 8, %i0 400106b8: 80 a6 80 1b cmp %i2, %i3 400106bc: 0a 80 00 1b bcs 40010728 400106c0: 80 8e e0 07 btst 7, %i3 400106c4: 12 80 00 19 bne 40010728 400106c8: 80 8e 60 07 btst 7, %i1 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 400106cc: 02 80 00 04 be 400106dc 400106d0: 25 10 00 d1 sethi %hi(0x40034400), %l2 400106d4: 81 c7 e0 08 ret 400106d8: 91 e8 20 09 restore %g0, 9, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400106dc: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 400106e0: 82 00 60 01 inc %g1 400106e4: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 400106e8: 27 10 00 d1 sethi %hi(0x40034400), %l3 400106ec: 40 00 16 83 call 400160f8 <_Objects_Allocate> 400106f0: 90 14 e0 e0 or %l3, 0xe0, %o0 ! 400344e0 <_Partition_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 400106f4: a2 92 20 00 orcc %o0, 0, %l1 400106f8: 12 80 00 0e bne 40010730 400106fc: 92 10 00 1b mov %i3, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010700: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 40010704: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 40010708: 82 00 7f ff add %g1, -1, %g1 4001070c: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] 40010710: c4 04 a3 60 ld [ %l2 + 0x360 ], %g2 40010714: 80 a0 a0 00 cmp %g2, 0 40010718: 12 80 00 04 bne 40010728 4001071c: 01 00 00 00 nop 40010720: 40 00 1d 03 call 40017b2c <_Thread_Dispatch> 40010724: 01 00 00 00 nop 40010728: 81 c7 e0 08 ret 4001072c: 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; 40010730: f8 24 60 1c st %i4, [ %l1 + 0x1c ] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 40010734: f2 24 60 10 st %i1, [ %l1 + 0x10 ] the_partition->length = length; 40010738: f4 24 60 14 st %i2, [ %l1 + 0x14 ] the_partition->buffer_size = buffer_size; 4001073c: f6 24 60 18 st %i3, [ %l1 + 0x18 ] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 40010740: c0 24 60 20 clr [ %l1 + 0x20 ] _Chain_Initialize( &the_partition->Memory, starting_address, 40010744: 40 00 55 1e call 40025bbc <.udiv> 40010748: 90 10 00 1a mov %i2, %o0 4001074c: a0 04 60 24 add %l1, 0x24, %l0 40010750: 94 10 00 08 mov %o0, %o2 40010754: 92 10 00 19 mov %i1, %o1 40010758: 90 10 00 10 mov %l0, %o0 4001075c: 40 00 12 38 call 4001503c <_Chain_Initialize> 40010760: 96 10 00 1b mov %i3, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40010764: 90 14 e0 e0 or %l3, 0xe0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40010768: c6 04 60 08 ld [ %l1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4001076c: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40010770: 03 00 00 3f sethi %hi(0xfc00), %g1 40010774: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40010778: 82 08 c0 01 and %g3, %g1, %g1 4001077c: 80 a0 40 02 cmp %g1, %g2 40010780: 38 80 00 06 bgu,a 40010798 40010784: e8 24 60 0c st %l4, [ %l1 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40010788: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4001078c: 83 28 60 02 sll %g1, 2, %g1 40010790: e2 20 80 01 st %l1, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 40010794: e8 24 60 0c st %l4, [ %l1 + 0xc ] &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 40010798: c6 27 40 00 st %g3, [ %i5 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001079c: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 400107a0: 10 bf ff da b 40010708 400107a4: b0 10 20 00 clr %i0 400107a8 : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 400107a8: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 400107ac: 92 10 00 18 mov %i0, %o1 400107b0: 94 07 bf f4 add %fp, -12, %o2 400107b4: 31 10 00 d1 sethi %hi(0x40034400), %i0 400107b8: 40 00 17 b5 call 4001668c <_Objects_Get> 400107bc: 90 16 20 e0 or %i0, 0xe0, %o0 ! 400344e0 <_Partition_Information> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 400107c0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400107c4: 80 a0 60 00 cmp %g1, 0 400107c8: 12 80 00 13 bne 40010814 400107cc: 92 10 00 08 mov %o0, %o1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 400107d0: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 400107d4: 80 a0 60 00 cmp %g1, 0 400107d8: 02 80 00 14 be 40010828 400107dc: 90 16 20 e0 or %i0, 0xe0, %o0 400107e0: 03 10 00 d1 sethi %hi(0x40034400), %g1 400107e4: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 400107e8: b0 10 20 0c mov 0xc, %i0 400107ec: 84 00 bf ff add %g2, -1, %g2 400107f0: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 400107f4: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 400107f8: 80 a0 e0 00 cmp %g3, 0 400107fc: 12 80 00 22 bne 40010884 40010800: 01 00 00 00 nop _Thread_Dispatch(); 40010804: 40 00 1c ca call 40017b2c <_Thread_Dispatch> 40010808: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001080c: 81 c7 e0 08 ret 40010810: 81 e8 00 00 restore { register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 40010814: 80 a0 60 02 cmp %g1, 2 40010818: 08 bf ff fd bleu 4001080c 4001081c: b0 10 20 04 mov 4, %i0 40010820: 81 c7 e0 08 ret <== NOT EXECUTED 40010824: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40010828: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4001082c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40010830: 05 00 00 3f sethi %hi(0xfc00), %g2 40010834: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40010838: 82 08 40 02 and %g1, %g2, %g1 4001083c: 80 a0 40 03 cmp %g1, %g3 40010840: 18 80 00 04 bgu 40010850 40010844: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 40010848: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4001084c: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Partition_Free ( Partition_Control *the_partition ) { _Objects_Free( &_Partition_Information, &the_partition->Object ); 40010850: 40 00 17 38 call 40016530 <_Objects_Free> 40010854: c0 22 60 0c clr [ %o1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010858: 03 10 00 d1 sethi %hi(0x40034400), %g1 4001085c: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 40010860: b0 10 20 00 clr %i0 40010864: 84 00 bf ff add %g2, -1, %g2 40010868: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 4001086c: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 40010870: 80 a0 e0 00 cmp %g3, 0 40010874: 12 80 00 04 bne 40010884 40010878: 01 00 00 00 nop _Thread_Dispatch(); 4001087c: 40 00 1c ac call 40017b2c <_Thread_Dispatch> 40010880: 01 00 00 00 nop 40010884: 81 c7 e0 08 ret 40010888: 81 e8 00 00 restore 4001088c : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 4001088c: 9d e3 bf 90 save %sp, -112, %sp 40010890: 92 10 00 18 mov %i0, %o1 register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 40010894: 80 a6 60 00 cmp %i1, 0 40010898: 02 80 00 1a be 40010900 4001089c: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 400108a0: 11 10 00 d1 sethi %hi(0x40034400), %o0 400108a4: 94 07 bf f4 add %fp, -12, %o2 400108a8: 40 00 17 79 call 4001668c <_Objects_Get> 400108ac: 90 12 20 e0 or %o0, 0xe0, %o0 return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 400108b0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400108b4: 80 a0 60 00 cmp %g1, 0 400108b8: 12 80 00 14 bne 40010908 400108bc: b0 10 00 08 mov %o0, %i0 RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 400108c0: 40 00 11 cc call 40014ff0 <_Chain_Get> 400108c4: 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 ) { 400108c8: a0 92 20 00 orcc %o0, 0, %l0 400108cc: 32 80 00 14 bne,a 4001091c 400108d0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400108d4: 03 10 00 d1 sethi %hi(0x40034400), %g1 400108d8: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 400108dc: b0 10 20 0d mov 0xd, %i0 400108e0: 84 00 bf ff add %g2, -1, %g2 400108e4: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 400108e8: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 400108ec: 80 a0 e0 00 cmp %g3, 0 400108f0: 12 80 00 04 bne 40010900 400108f4: 01 00 00 00 nop _Thread_Dispatch(); 400108f8: 40 00 1c 8d call 40017b2c <_Thread_Dispatch> 400108fc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_UNSATISFIED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40010900: 81 c7 e0 08 ret 40010904: 81 e8 00 00 restore if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 40010908: 80 a0 60 02 cmp %g1, 2 4001090c: 08 bf ff fd bleu 40010900 40010910: b0 10 20 04 mov 4, %i0 40010914: 81 c7 e0 08 ret <== NOT EXECUTED 40010918: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { the_partition->number_of_used_blocks += 1; 4001091c: 82 00 60 01 inc %g1 40010920: c2 26 20 20 st %g1, [ %i0 + 0x20 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010924: 05 10 00 d1 sethi %hi(0x40034400), %g2 40010928: c2 00 a3 60 ld [ %g2 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 4001092c: 82 00 7f ff add %g1, -1, %g1 40010930: c2 20 a3 60 st %g1, [ %g2 + 0x360 ] 40010934: c6 00 a3 60 ld [ %g2 + 0x360 ], %g3 40010938: 80 a0 e0 00 cmp %g3, 0 4001093c: 02 80 00 05 be 40010950 40010940: 01 00 00 00 nop _Thread_Enable_dispatch(); *buffer = the_buffer; 40010944: e0 26 40 00 st %l0, [ %i1 ] <== NOT EXECUTED 40010948: 81 c7 e0 08 ret 4001094c: 91 e8 20 00 restore %g0, 0, %o0 _Thread_Dispatch(); 40010950: 40 00 1c 77 call 40017b2c <_Thread_Dispatch> 40010954: 01 00 00 00 nop 40010958: 10 bf ff fc b 40010948 4001095c: e0 26 40 00 st %l0, [ %i1 ] 40010994 : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 40010994: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 40010998: 11 10 00 d1 sethi %hi(0x40034400), %o0 4001099c: 92 10 00 18 mov %i0, %o1 400109a0: 90 12 20 e0 or %o0, 0xe0, %o0 400109a4: 40 00 17 3a call 4001668c <_Objects_Get> 400109a8: 94 07 bf f4 add %fp, -12, %o2 register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 400109ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 400109b0: 80 a0 60 00 cmp %g1, 0 400109b4: 12 80 00 12 bne 400109fc 400109b8: b0 10 00 08 mov %o0, %i0 ) { void *starting; void *ending; starting = the_partition->starting_address; 400109bc: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( 400109c0: 80 a0 80 19 cmp %g2, %i1 400109c4: 28 80 00 13 bleu,a 40010a10 400109c8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400109cc: 03 10 00 d1 sethi %hi(0x40034400), %g1 400109d0: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 400109d4: 84 00 bf ff add %g2, -1, %g2 400109d8: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 400109dc: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 400109e0: 80 a0 e0 00 cmp %g3, 0 400109e4: 12 80 00 27 bne 40010a80 400109e8: 01 00 00 00 nop _Thread_Dispatch(); 400109ec: 40 00 1c 50 call 40017b2c <_Thread_Dispatch> 400109f0: b0 10 20 09 mov 9, %i0 ! 9 400109f4: 81 c7 e0 08 ret 400109f8: 81 e8 00 00 restore 400109fc: 80 a0 60 02 cmp %g1, 2 40010a00: 08 bf ff fd bleu 400109f4 40010a04: b0 10 20 04 mov 4, %i0 40010a08: 81 c7 e0 08 ret <== NOT EXECUTED 40010a0c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 40010a10: 82 00 80 01 add %g2, %g1, %g1 40010a14: 80 a0 40 19 cmp %g1, %i1 40010a18: 0a bf ff ed bcs 400109cc 40010a1c: 01 00 00 00 nop 40010a20: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 40010a24: 40 00 55 12 call 40025e6c <.urem> 40010a28: 90 26 40 02 sub %i1, %g2, %o0 40010a2c: 80 a2 20 00 cmp %o0, 0 40010a30: 12 bf ff e7 bne 400109cc 40010a34: 92 10 00 19 mov %i1, %o1 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 40010a38: 40 00 11 62 call 40014fc0 <_Chain_Append> 40010a3c: 90 06 20 24 add %i0, 0x24, %o0 return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 40010a40: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 40010a44: 82 00 7f ff add %g1, -1, %g1 40010a48: c2 26 20 20 st %g1, [ %i0 + 0x20 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40010a4c: 07 10 00 d1 sethi %hi(0x40034400), %g3 40010a50: c2 00 e3 60 ld [ %g3 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 40010a54: b0 10 20 00 clr %i0 40010a58: 82 00 7f ff add %g1, -1, %g1 40010a5c: c2 20 e3 60 st %g1, [ %g3 + 0x360 ] 40010a60: c4 00 e3 60 ld [ %g3 + 0x360 ], %g2 40010a64: 80 a0 a0 00 cmp %g2, 0 40010a68: 12 80 00 04 bne 40010a78 40010a6c: 01 00 00 00 nop _Thread_Dispatch(); 40010a70: 40 00 1c 2f call 40017b2c <_Thread_Dispatch> 40010a74: 01 00 00 00 nop 40010a78: 81 c7 e0 08 ret 40010a7c: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40010a80: 81 c7 e0 08 ret <== NOT EXECUTED 40010a84: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED 4000f900 : */ rtems_status_code rtems_port_delete( Objects_Id id ) { 4000f900: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Get ( Objects_Id id, Objects_Locations *location ) { return (Dual_ported_memory_Control *) 4000f904: 92 10 00 18 mov %i0, %o1 4000f908: 94 07 bf f4 add %fp, -12, %o2 4000f90c: 31 10 00 d1 sethi %hi(0x40034400), %i0 4000f910: 40 00 1b 5f call 4001668c <_Objects_Get> 4000f914: 90 16 20 94 or %i0, 0x94, %o0 ! 40034494 <_Dual_ported_memory_Information> register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 4000f918: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f91c: 80 a0 60 00 cmp %g1, 0 4000f920: 12 80 00 1a bne 4000f988 4000f924: 92 10 00 08 mov %o0, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f928: 90 16 20 94 or %i0, 0x94, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000f92c: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f930: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4000f934: 05 00 00 3f sethi %hi(0xfc00), %g2 4000f938: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000f93c: 82 08 40 02 and %g1, %g2, %g1 4000f940: 80 a0 40 03 cmp %g1, %g3 4000f944: 18 80 00 04 bgu 4000f954 4000f948: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 4000f94c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000f950: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Dual_ported_memory_Free ( Dual_ported_memory_Control *the_port ) { _Objects_Free( &_Dual_ported_memory_Information, &the_port->Object ); 4000f954: 40 00 1a f7 call 40016530 <_Objects_Free> 4000f958: c0 22 60 0c clr [ %o1 + 0xc ] 4000f95c: 03 10 00 d1 sethi %hi(0x40034400), %g1 4000f960: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 4000f964: b0 10 20 00 clr %i0 4000f968: 84 00 bf ff add %g2, -1, %g2 4000f96c: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 4000f970: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 4000f974: 80 a0 e0 00 cmp %g3, 0 4000f978: 02 80 00 0a be 4000f9a0 4000f97c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f980: 81 c7 e0 08 ret <== NOT EXECUTED 4000f984: 81 e8 00 00 restore <== NOT EXECUTED { register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 4000f988: 82 18 60 02 xor %g1, 2, %g1 4000f98c: 80 a0 00 01 cmp %g0, %g1 4000f990: 84 60 20 00 subx %g0, 0, %g2 4000f994: b0 08 a0 15 and %g2, 0x15, %i0 4000f998: 81 c7 e0 08 ret 4000f99c: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 4000f9a0: 40 00 20 63 call 40017b2c <_Thread_Dispatch> 4000f9a4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f9a8: 81 c7 e0 08 ret 4000f9ac: 81 e8 00 00 restore 40010c9c : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 40010c9c: 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 *) 40010ca0: 21 10 00 d1 sethi %hi(0x40034400), %l0 40010ca4: 92 10 00 18 mov %i0, %o1 40010ca8: 94 07 bf f4 add %fp, -12, %o2 40010cac: 40 00 16 78 call 4001668c <_Objects_Get> 40010cb0: 90 14 21 2c or %l0, 0x12c, %o0 Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 40010cb4: c2 07 bf f4 ld [ %fp + -12 ], %g1 40010cb8: 80 a0 60 00 cmp %g1, 0 40010cbc: 12 80 00 20 bne 40010d3c 40010cc0: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40010cc4: a0 14 21 2c or %l0, 0x12c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40010cc8: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40010ccc: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 40010cd0: 05 00 00 3f sethi %hi(0xfc00), %g2 40010cd4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40010cd8: 82 08 40 02 and %g1, %g2, %g1 40010cdc: 80 a0 40 03 cmp %g1, %g3 40010ce0: 38 80 00 06 bgu,a 40010cf8 40010ce4: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40010ce8: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 40010cec: 83 28 60 02 sll %g1, 2, %g1 40010cf0: 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; 40010cf4: 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 ); 40010cf8: 40 00 22 55 call 4001964c <_Watchdog_Remove> 40010cfc: 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 ); 40010d00: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_INACTIVE; 40010d04: c0 26 20 38 clr [ %i0 + 0x38 ] 40010d08: 40 00 16 0a call 40016530 <_Objects_Free> 40010d0c: 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 ) 40010d10: 03 10 00 d1 sethi %hi(0x40034400), %g1 40010d14: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 40010d18: b0 10 20 00 clr %i0 40010d1c: 84 00 bf ff add %g2, -1, %g2 40010d20: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 40010d24: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 40010d28: 80 a0 e0 00 cmp %g3, 0 40010d2c: 02 80 00 0a be 40010d54 40010d30: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40010d34: 81 c7 e0 08 ret <== NOT EXECUTED 40010d38: 81 e8 00 00 restore <== NOT EXECUTED { Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 40010d3c: 82 18 60 02 xor %g1, 2, %g1 40010d40: 80 a0 00 01 cmp %g0, %g1 40010d44: 84 60 20 00 subx %g0, 0, %g2 40010d48: b0 08 a0 15 and %g2, 0x15, %i0 40010d4c: 81 c7 e0 08 ret 40010d50: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 40010d54: 40 00 1b 76 call 40017b2c <_Thread_Dispatch> 40010d58: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40010d5c: 81 c7 e0 08 ret 40010d60: 81 e8 00 00 restore 4000f72c : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 4000f72c: 9d e3 bf 90 save %sp, -112, %sp 4000f730: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 4000f734: 80 a6 60 00 cmp %i1, 0 4000f738: 02 80 00 17 be 4000f794 4000f73c: b0 10 20 09 mov 9, %i0 4000f740: 11 10 00 7d sethi %hi(0x4001f400), %o0 4000f744: 94 07 bf f4 add %fp, -12, %o2 4000f748: 7f ff ec b1 call 4000aa0c <_Objects_Get> 4000f74c: 90 12 20 4c or %o0, 0x4c, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000f750: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f754: 80 a0 60 00 cmp %g1, 0 4000f758: 12 80 00 11 bne 4000f79c 4000f75c: 92 10 00 08 mov %o0, %o1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: *statistics = the_period->Statistics; 4000f760: 90 10 00 19 mov %i1, %o0 4000f764: 92 02 60 54 add %o1, 0x54, %o1 4000f768: 40 00 08 00 call 40011768 4000f76c: 94 10 20 38 mov 0x38, %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f770: 03 10 00 7d sethi %hi(0x4001f400), %g1 4000f774: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 4001f5e0 <_Thread_Dispatch_disable_level> 4000f778: b0 10 20 00 clr %i0 4000f77c: 84 00 bf ff add %g2, -1, %g2 4000f780: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 4000f784: c6 00 61 e0 ld [ %g1 + 0x1e0 ], %g3 4000f788: 80 a0 e0 00 cmp %g3, 0 4000f78c: 02 80 00 0a be 4000f7b4 4000f790: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f794: 81 c7 e0 08 ret <== NOT EXECUTED 4000f798: 81 e8 00 00 restore <== NOT EXECUTED if ( !statistics ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000f79c: 82 18 60 02 xor %g1, 2, %g1 4000f7a0: 80 a0 00 01 cmp %g0, %g1 4000f7a4: 84 60 20 00 subx %g0, 0, %g2 4000f7a8: b0 08 a0 15 and %g2, 0x15, %i0 4000f7ac: 81 c7 e0 08 ret 4000f7b0: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 4000f7b4: 7f ff f1 be call 4000beac <_Thread_Dispatch> 4000f7b8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f7bc: 81 c7 e0 08 ret 4000f7c0: 81 e8 00 00 restore 4000f7c4 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 4000f7c4: 9d e3 bf 88 save %sp, -120, %sp 4000f7c8: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 4000f7cc: 80 a6 60 00 cmp %i1, 0 4000f7d0: 02 80 00 21 be 4000f854 4000f7d4: b0 10 20 09 mov 9, %i0 4000f7d8: 11 10 00 7d sethi %hi(0x4001f400), %o0 4000f7dc: 94 07 bf f4 add %fp, -12, %o2 4000f7e0: 7f ff ec 8b call 4000aa0c <_Objects_Get> 4000f7e4: 90 12 20 4c or %o0, 0x4c, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000f7e8: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f7ec: 80 a0 60 00 cmp %g1, 0 4000f7f0: 12 80 00 1b bne 4000f85c 4000f7f4: b0 10 00 08 mov %o0, %i0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 4000f7f8: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 4000f7fc: 80 a0 60 00 cmp %g1, 0 4000f800: 02 80 00 03 be 4000f80c 4000f804: 84 10 20 00 clr %g2 4000f808: c4 00 60 08 ld [ %g1 + 8 ], %g2 status->state = the_period->state; 4000f80c: 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); 4000f810: c4 26 40 00 st %g2, [ %i1 ] status->state = the_period->state; if ( status->state == RATE_MONOTONIC_INACTIVE ) { 4000f814: 80 a0 60 00 cmp %g1, 0 4000f818: 12 80 00 1b bne 4000f884 4000f81c: 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; 4000f820: 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; 4000f824: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 4000f828: 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; 4000f82c: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000f830: 03 10 00 7d sethi %hi(0x4001f400), %g1 4000f834: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 4001f5e0 <_Thread_Dispatch_disable_level> 4000f838: b0 10 20 00 clr %i0 4000f83c: 84 00 bf ff add %g2, -1, %g2 4000f840: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 4000f844: c6 00 61 e0 ld [ %g1 + 0x1e0 ], %g3 4000f848: 80 a0 e0 00 cmp %g3, 0 4000f84c: 02 80 00 0a be 4000f874 4000f850: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f854: 81 c7 e0 08 ret <== NOT EXECUTED 4000f858: 81 e8 00 00 restore <== NOT EXECUTED if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000f85c: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 4000f860: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 4000f864: 84 60 20 00 subx %g0, 0, %g2 <== NOT EXECUTED 4000f868: b0 08 a0 15 and %g2, 0x15, %i0 <== NOT EXECUTED 4000f86c: 81 c7 e0 08 ret <== NOT EXECUTED 4000f870: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000f874: 7f ff f1 8e call 4000beac <_Thread_Dispatch> 4000f878: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f87c: 81 c7 e0 08 ret 4000f880: 81 e8 00 00 restore * This lets them share one single invocation of _TOD_Get_uptime(). */ #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 4000f884: a0 07 bf ec add %fp, -20, %l0 4000f888: 7f ff e9 13 call 40009cd4 <_TOD_Get_uptime> 4000f88c: 90 10 00 10 mov %l0, %o0 #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 4000f890: 90 06 20 44 add %i0, 0x44, %o0 4000f894: 92 10 00 10 mov %l0, %o1 4000f898: 7f ff f6 40 call 4000d198 <_Timespec_Subtract> 4000f89c: 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( 4000f8a0: 92 10 00 10 mov %l0, %o1 4000f8a4: 94 06 60 10 add %i1, 0x10, %o2 4000f8a8: 11 10 00 7d sethi %hi(0x4001f400), %o0 4000f8ac: 7f ff f6 3b call 4000d198 <_Timespec_Subtract> 4000f8b0: 90 12 22 c4 or %o0, 0x2c4, %o0 ! 4001f6c4 <_Thread_Time_of_last_context_switch> 4000f8b4: 30 bf ff df b,a 4000f830 40007d38 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 40007d38: 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 *) 40007d3c: 11 10 00 7d sethi %hi(0x4001f400), %o0 40007d40: 92 10 00 18 mov %i0, %o1 40007d44: 90 12 20 4c or %o0, 0x4c, %o0 40007d48: 40 00 0b 31 call 4000aa0c <_Objects_Get> 40007d4c: 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 ) { 40007d50: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007d54: 80 a0 60 00 cmp %g1, 0 40007d58: 12 80 00 15 bne 40007dac 40007d5c: a2 10 00 08 mov %o0, %l1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 40007d60: 25 10 00 7d sethi %hi(0x4001f400), %l2 40007d64: c4 02 20 50 ld [ %o0 + 0x50 ], %g2 40007d68: c2 04 a2 bc ld [ %l2 + 0x2bc ], %g1 40007d6c: 80 a0 80 01 cmp %g2, %g1 40007d70: 02 80 00 14 be 40007dc0 40007d74: 80 a6 60 00 cmp %i1, 0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007d78: 03 10 00 7d sethi %hi(0x4001f400), %g1 40007d7c: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 4001f5e0 <_Thread_Dispatch_disable_level> 40007d80: b0 10 20 17 mov 0x17, %i0 _Thread_Dispatch(); 40007d84: 84 00 bf ff add %g2, -1, %g2 40007d88: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 40007d8c: c6 00 61 e0 ld [ %g1 + 0x1e0 ], %g3 40007d90: 80 a0 e0 00 cmp %g3, 0 40007d94: 12 80 00 66 bne 40007f2c 40007d98: 01 00 00 00 nop 40007d9c: 40 00 10 44 call 4000beac <_Thread_Dispatch> 40007da0: 01 00 00 00 nop 40007da4: 81 c7 e0 08 ret 40007da8: 81 e8 00 00 restore rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 40007dac: 80 a0 60 02 cmp %g1, 2 40007db0: 02 bf ff fd be 40007da4 40007db4: b0 10 20 04 mov 4, %i0 break; } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007db8: 81 c7 e0 08 ret <== NOT EXECUTED 40007dbc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 40007dc0: 22 80 00 73 be,a 40007f8c 40007dc4: d0 02 20 38 ld [ %o0 + 0x38 ], %o0 } _Thread_Enable_dispatch(); return( return_value ); } _ISR_Disable( level ); 40007dc8: 7f ff eb 73 call 40002b94 40007dcc: 01 00 00 00 nop 40007dd0: a0 10 00 08 mov %o0, %l0 switch ( the_period->state ) { 40007dd4: e6 04 60 38 ld [ %l1 + 0x38 ], %l3 40007dd8: 80 a4 e0 02 cmp %l3, 2 40007ddc: 02 80 00 34 be 40007eac 40007de0: 80 a4 e0 04 cmp %l3, 4 40007de4: 02 80 00 54 be 40007f34 40007de8: 80 a4 e0 00 cmp %l3, 0 40007dec: 32 bf ff ee bne,a 40007da4 40007df0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED /* * No need to update statistics -- there are not a period active */ _ISR_Enable( level ); 40007df4: 7f ff eb 6c call 40002ba4 40007df8: 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 ); 40007dfc: 40 00 07 b6 call 40009cd4 <_TOD_Get_uptime> 40007e00: 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; 40007e04: c2 07 bf ec ld [ %fp + -20 ], %g1 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40007e08: c6 04 a2 bc ld [ %l2 + 0x2bc ], %g3 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS /* * Since the statistics didn't update the starting time, * we do it here. */ the_period->time_at_period = uptime; 40007e0c: c2 24 60 44 st %g1, [ %l1 + 0x44 ] 40007e10: 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( 40007e14: 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; 40007e18: c2 24 60 48 st %g1, [ %l1 + 0x48 ] #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40007e1c: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40007e20: a0 07 bf e4 add %fp, -28, %l0 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40007e24: c4 24 60 3c st %g2, [ %l1 + 0x3c ] 40007e28: c2 00 e0 94 ld [ %g3 + 0x94 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40007e2c: 94 10 00 10 mov %l0, %o2 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40007e30: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40007e34: 11 10 00 7d sethi %hi(0x4001f400), %o0 40007e38: 40 00 14 d8 call 4000d198 <_Timespec_Subtract> 40007e3c: 90 12 22 c4 or %o0, 0x2c4, %o0 ! 4001f6c4 <_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 ); 40007e40: 92 10 00 10 mov %l0, %o1 40007e44: 40 00 14 72 call 4000d00c <_Timespec_Add_to> 40007e48: 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; 40007e4c: 84 10 20 02 mov 2, %g2 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40007e50: 03 10 00 20 sethi %hi(0x40008000), %g1 40007e54: 82 10 63 60 or %g1, 0x360, %g1 ! 40008360 <_Rate_monotonic_Timeout> the_watchdog->id = id; 40007e58: f0 24 60 30 st %i0, [ %l1 + 0x30 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40007e5c: f2 24 60 1c st %i1, [ %l1 + 0x1c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40007e60: c0 24 60 18 clr [ %l1 + 0x18 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 40007e64: c0 24 60 34 clr [ %l1 + 0x34 ] _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 40007e68: f2 24 60 4c st %i1, [ %l1 + 0x4c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40007e6c: 92 04 60 10 add %l1, 0x10, %o1 #else the_period->owner_ticks_executed_at_period = _Thread_Executing->ticks_executed; #endif the_period->state = RATE_MONOTONIC_ACTIVE; 40007e70: c4 24 60 38 st %g2, [ %l1 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40007e74: c2 24 60 2c st %g1, [ %l1 + 0x2c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40007e78: 11 10 00 7d sethi %hi(0x4001f400), %o0 40007e7c: 40 00 15 92 call 4000d4c4 <_Watchdog_Insert> 40007e80: 90 12 22 dc or %o0, 0x2dc, %o0 ! 4001f6dc <_Watchdog_Ticks_chain> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007e84: 05 10 00 7d sethi %hi(0x4001f400), %g2 40007e88: c2 00 a1 e0 ld [ %g2 + 0x1e0 ], %g1 ! 4001f5e0 <_Thread_Dispatch_disable_level> 40007e8c: 82 00 7f ff add %g1, -1, %g1 40007e90: c2 20 a1 e0 st %g1, [ %g2 + 0x1e0 ] 40007e94: c6 00 a1 e0 ld [ %g2 + 0x1e0 ], %g3 40007e98: 80 a0 e0 00 cmp %g3, 0 40007e9c: 02 80 00 22 be 40007f24 40007ea0: 01 00 00 00 nop _Thread_Dispatch(); 40007ea4: 81 c7 e0 08 ret <== NOT EXECUTED 40007ea8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 40007eac: 7f ff ff 43 call 40007bb8 <_Rate_monotonic_Update_statistics> 40007eb0: 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; 40007eb4: 82 10 20 01 mov 1, %g1 the_period->next_length = length; 40007eb8: 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; 40007ebc: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; _ISR_Enable( level ); 40007ec0: 7f ff eb 39 call 40002ba4 40007ec4: 90 10 00 10 mov %l0, %o0 _Thread_Executing->Wait.id = the_period->Object.id; 40007ec8: c2 04 a2 bc ld [ %l2 + 0x2bc ], %g1 40007ecc: c4 04 60 08 ld [ %l1 + 8 ], %g2 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 40007ed0: 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; 40007ed4: c4 20 60 20 st %g2, [ %g1 + 0x20 ] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 40007ed8: 40 00 13 1b call 4000cb44 <_Thread_Set_state> 40007edc: 13 00 00 10 sethi %hi(0x4000), %o1 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 40007ee0: 7f ff eb 2d call 40002b94 40007ee4: 01 00 00 00 nop local_state = the_period->state; 40007ee8: e0 04 60 38 ld [ %l1 + 0x38 ], %l0 the_period->state = RATE_MONOTONIC_ACTIVE; 40007eec: e6 24 60 38 st %l3, [ %l1 + 0x38 ] _ISR_Enable( level ); 40007ef0: 7f ff eb 2d call 40002ba4 40007ef4: 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 ) 40007ef8: 80 a4 20 03 cmp %l0, 3 40007efc: 02 80 00 32 be 40007fc4 40007f00: d0 04 a2 bc ld [ %l2 + 0x2bc ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007f04: 03 10 00 7d sethi %hi(0x4001f400), %g1 40007f08: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 4001f5e0 <_Thread_Dispatch_disable_level> 40007f0c: 84 00 bf ff add %g2, -1, %g2 40007f10: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 40007f14: c6 00 61 e0 ld [ %g1 + 0x1e0 ], %g3 40007f18: 80 a0 e0 00 cmp %g3, 0 40007f1c: 12 bf ff e2 bne 40007ea4 40007f20: 01 00 00 00 nop _Thread_Dispatch(); 40007f24: 40 00 0f e2 call 4000beac <_Thread_Dispatch> 40007f28: b0 10 20 00 clr %i0 ! 0 40007f2c: 81 c7 e0 08 ret 40007f30: 81 e8 00 00 restore case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 40007f34: 7f ff ff 21 call 40007bb8 <_Rate_monotonic_Update_statistics> 40007f38: 90 10 00 11 mov %l1, %o0 _ISR_Enable( level ); 40007f3c: 7f ff eb 1a call 40002ba4 40007f40: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 40007f44: 82 10 20 02 mov 2, %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40007f48: f2 24 60 1c st %i1, [ %l1 + 0x1c ] the_period->next_length = length; 40007f4c: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40007f50: 92 04 60 10 add %l1, 0x10, %o1 */ _Rate_monotonic_Update_statistics( the_period ); _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 40007f54: c2 24 60 38 st %g1, [ %l1 + 0x38 ] 40007f58: 11 10 00 7d sethi %hi(0x4001f400), %o0 40007f5c: 40 00 15 5a call 4000d4c4 <_Watchdog_Insert> 40007f60: 90 12 22 dc or %o0, 0x2dc, %o0 ! 4001f6dc <_Watchdog_Ticks_chain> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007f64: 07 10 00 7d sethi %hi(0x4001f400), %g3 40007f68: c2 00 e1 e0 ld [ %g3 + 0x1e0 ], %g1 ! 4001f5e0 <_Thread_Dispatch_disable_level> 40007f6c: b0 10 20 06 mov 6, %i0 40007f70: 82 00 7f ff add %g1, -1, %g1 40007f74: c2 20 e1 e0 st %g1, [ %g3 + 0x1e0 ] 40007f78: c4 00 e1 e0 ld [ %g3 + 0x1e0 ], %g2 40007f7c: 80 a0 a0 00 cmp %g2, 0 40007f80: 02 bf ff 87 be 40007d9c 40007f84: 01 00 00 00 nop 40007f88: 30 bf ff e9 b,a 40007f2c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 40007f8c: 80 a2 20 02 cmp %o0, 2 40007f90: 02 80 00 09 be 40007fb4 40007f94: b0 10 20 00 clr %i0 40007f98: 80 a2 20 04 cmp %o0, 4 40007f9c: 02 80 00 06 be 40007fb4 40007fa0: b0 10 20 06 mov 6, %i0 40007fa4: 80 a2 20 00 cmp %o0, 0 40007fa8: 02 80 00 03 be 40007fb4 40007fac: b0 10 20 0b mov 0xb, %i0 40007fb0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 40007fb4: 03 10 00 7d sethi %hi(0x4001f400), %g1 40007fb8: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 4001f5e0 <_Thread_Dispatch_disable_level> 40007fbc: 10 bf ff 73 b 40007d88 40007fc0: 84 00 bf ff add %g2, -1, %g2 * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 40007fc4: 40 00 0f 05 call 4000bbd8 <_Thread_Clear_state> <== NOT EXECUTED 40007fc8: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED 40007fcc: 30 bf ff ce b,a 40007f04 <== NOT EXECUTED 40007fd0 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 40007fd0: 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 ) 40007fd4: 80 a6 60 00 cmp %i1, 0 40007fd8: 02 80 00 4e be 40008110 40007fdc: 90 10 00 18 mov %i0, %o0 return; (*print)( context, "Period information by period\n" ); 40007fe0: 13 10 00 73 sethi %hi(0x4001cc00), %o1 40007fe4: 9f c6 40 00 call %i1 40007fe8: 92 12 62 28 or %o1, 0x228, %o1 ! 4001ce28 #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 40007fec: 90 10 00 18 mov %i0, %o0 40007ff0: 13 10 00 73 sethi %hi(0x4001cc00), %o1 40007ff4: 9f c6 40 00 call %i1 40007ff8: 92 12 62 48 or %o1, 0x248, %o1 ! 4001ce48 #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 40007ffc: 90 10 00 18 mov %i0, %o0 40008000: 13 10 00 73 sethi %hi(0x4001cc00), %o1 40008004: 9f c6 40 00 call %i1 40008008: 92 12 62 70 or %o1, 0x270, %o1 ! 4001ce70 Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 4000800c: 90 10 00 18 mov %i0, %o0 40008010: 13 10 00 73 sethi %hi(0x4001cc00), %o1 40008014: 9f c6 40 00 call %i1 40008018: 92 12 62 98 or %o1, 0x298, %o1 ! 4001ce98 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 4000801c: 90 10 00 18 mov %i0, %o0 40008020: 13 10 00 73 sethi %hi(0x4001cc00), %o1 40008024: 9f c6 40 00 call %i1 40008028: 92 12 62 e8 or %o1, 0x2e8, %o1 ! 4001cee8 /* * 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 ; 4000802c: 03 10 00 7d sethi %hi(0x4001f400), %g1 40008030: a6 10 60 4c or %g1, 0x4c, %l3 ! 4001f44c <_Rate_monotonic_Information> 40008034: e4 04 e0 08 ld [ %l3 + 8 ], %l2 id <= _Rate_monotonic_Information.maximum_id ; 40008038: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 4000803c: 80 a4 80 01 cmp %l2, %g1 40008040: 18 80 00 34 bgu 40008110 40008044: 03 10 00 73 sethi %hi(0x4001cc00), %g1 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 40008048: 05 10 00 73 sethi %hi(0x4001cc00), %g2 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 4000804c: b6 10 63 38 or %g1, 0x338, %i3 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 40008050: b8 10 a2 68 or %g2, 0x268, %i4 40008054: a8 07 bf 98 add %fp, -104, %l4 status = rtems_rate_monotonic_get_statistics( id, &the_stats ); if ( status != RTEMS_SUCCESSFUL ) continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 40008058: aa 07 bf d0 add %fp, -48, %l5 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 4000805c: ba 07 bf b0 add %fp, -80, %i5 40008060: ac 07 bf e8 add %fp, -24, %l6 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 40008064: b4 07 bf c8 add %fp, -56, %i2 40008068: 10 80 00 06 b 40008080 4000806c: ae 07 bf f3 add %fp, -13, %l7 * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 40008070: 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 ; 40008074: 80 a0 40 12 cmp %g1, %l2 40008078: 0a 80 00 26 bcs 40008110 4000807c: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 40008080: 90 10 00 12 mov %l2, %o0 40008084: 40 00 1d aa call 4000f72c 40008088: 92 10 00 14 mov %l4, %o1 if ( status != RTEMS_SUCCESSFUL ) 4000808c: 80 a2 20 00 cmp %o0, 0 40008090: 32 bf ff f8 bne,a 40008070 40008094: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 40008098: 92 10 00 15 mov %l5, %o1 4000809c: 40 00 1d ca call 4000f7c4 400080a0: 90 10 00 12 mov %l2, %o0 if ( status != RTEMS_SUCCESSFUL ) 400080a4: 80 a2 20 00 cmp %o0, 0 400080a8: 32 bf ff f2 bne,a 40008070 400080ac: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 <== NOT EXECUTED continue; name[ 0 ] = '\0'; if ( the_status.owner ) { 400080b0: d0 07 bf d0 ld [ %fp + -48 ], %o0 /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); if ( status != RTEMS_SUCCESSFUL ) continue; name[ 0 ] = '\0'; 400080b4: c0 2f bf f3 clrb [ %fp + -13 ] if ( the_status.owner ) { 400080b8: 80 a2 20 00 cmp %o0, 0 400080bc: 12 80 00 4b bne 400081e8 400080c0: a0 10 00 17 mov %l7, %l0 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 400080c4: d8 1f bf 98 ldd [ %fp + -104 ], %o4 <== NOT EXECUTED 400080c8: 94 10 00 12 mov %l2, %o2 400080cc: 92 10 00 1b mov %i3, %o1 400080d0: 96 10 00 10 mov %l0, %o3 400080d4: 9f c6 40 00 call %i1 400080d8: 90 10 00 18 mov %i0, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 400080dc: c2 07 bf 98 ld [ %fp + -104 ], %g1 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 400080e0: 94 10 00 16 mov %l6, %o2 400080e4: 90 10 00 1d mov %i5, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 400080e8: 80 a0 60 00 cmp %g1, 0 400080ec: 12 80 00 0b bne 40008118 400080f0: 92 10 00 1c mov %i4, %o1 (*print)( context, "\n" ); 400080f4: 9f c6 40 00 call %i1 400080f8: 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 ; 400080fc: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 id++ ) { 40008100: 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 ; 40008104: 80 a0 40 12 cmp %g1, %l2 40008108: 1a bf ff df bcc 40008084 4000810c: 90 10 00 12 mov %l2, %o0 40008110: 81 c7 e0 08 ret 40008114: 81 e8 00 00 restore */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 40008118: 40 00 13 d7 call 4000d074 <_Timespec_Divide_by_integer> 4000811c: 92 10 00 01 mov %g1, %o1 &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 40008120: d0 07 bf a4 ld [ %fp + -92 ], %o0 40008124: 40 00 46 a2 call 40019bac <.div> 40008128: 92 10 23 e8 mov 0x3e8, %o1 4000812c: a2 10 00 08 mov %o0, %l1 40008130: d0 07 bf ac ld [ %fp + -84 ], %o0 40008134: 40 00 46 9e call 40019bac <.div> 40008138: 92 10 23 e8 mov 0x3e8, %o1 4000813c: c2 07 bf e8 ld [ %fp + -24 ], %g1 40008140: a0 10 00 08 mov %o0, %l0 40008144: d0 07 bf ec ld [ %fp + -20 ], %o0 40008148: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 4000814c: 40 00 46 98 call 40019bac <.div> 40008150: 92 10 23 e8 mov 0x3e8, %o1 40008154: d8 07 bf a8 ld [ %fp + -88 ], %o4 40008158: d4 07 bf a0 ld [ %fp + -96 ], %o2 4000815c: 96 10 00 11 mov %l1, %o3 40008160: 9a 10 00 10 mov %l0, %o5 40008164: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 40008168: 13 10 00 73 sethi %hi(0x4001cc00), %o1 4000816c: 90 10 00 18 mov %i0, %o0 40008170: 9f c6 40 00 call %i1 40008174: 92 12 63 50 or %o1, 0x350, %o1 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 40008178: d2 07 bf 98 ld [ %fp + -104 ], %o1 4000817c: 94 10 00 16 mov %l6, %o2 40008180: 40 00 13 bd call 4000d074 <_Timespec_Divide_by_integer> 40008184: 90 10 00 1a mov %i2, %o0 &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 40008188: d0 07 bf bc ld [ %fp + -68 ], %o0 4000818c: 40 00 46 88 call 40019bac <.div> 40008190: 92 10 23 e8 mov 0x3e8, %o1 40008194: a2 10 00 08 mov %o0, %l1 40008198: d0 07 bf c4 ld [ %fp + -60 ], %o0 4000819c: 40 00 46 84 call 40019bac <.div> 400081a0: 92 10 23 e8 mov 0x3e8, %o1 400081a4: c2 07 bf e8 ld [ %fp + -24 ], %g1 400081a8: a0 10 00 08 mov %o0, %l0 400081ac: d0 07 bf ec ld [ %fp + -20 ], %o0 400081b0: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 400081b4: 40 00 46 7e call 40019bac <.div> 400081b8: 92 10 23 e8 mov 0x3e8, %o1 400081bc: d4 07 bf b8 ld [ %fp + -72 ], %o2 400081c0: d8 07 bf c0 ld [ %fp + -64 ], %o4 400081c4: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 400081c8: 96 10 00 11 mov %l1, %o3 400081cc: 9a 10 00 10 mov %l0, %o5 400081d0: 90 10 00 18 mov %i0, %o0 400081d4: 13 10 00 73 sethi %hi(0x4001cc00), %o1 400081d8: 9f c6 40 00 call %i1 400081dc: 92 12 63 70 or %o1, 0x370, %o1 ! 4001cf70 /* * 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 ; 400081e0: 10 bf ff a4 b 40008070 400081e4: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 continue; name[ 0 ] = '\0'; if ( the_status.owner ) { rtems_object_get_name( the_status.owner, sizeof(name), name ); 400081e8: 92 10 20 05 mov 5, %o1 400081ec: 40 00 00 8f call 40008428 400081f0: 94 10 00 17 mov %l7, %o2 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 400081f4: 10 bf ff b5 b 400080c8 400081f8: d8 1f bf 98 ldd [ %fp + -104 ], %o4 40008218 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 40008218: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000821c: 25 10 00 7d sethi %hi(0x4001f400), %l2 40008220: c2 04 a1 e0 ld [ %l2 + 0x1e0 ], %g1 ! 4001f5e0 <_Thread_Dispatch_disable_level> 40008224: 82 00 60 01 inc %g1 40008228: c2 24 a1 e0 st %g1, [ %l2 + 0x1e0 ] /* * 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 ; 4000822c: 03 10 00 7d sethi %hi(0x4001f400), %g1 40008230: a2 10 60 4c or %g1, 0x4c, %l1 ! 4001f44c <_Rate_monotonic_Information> 40008234: e0 04 60 08 ld [ %l1 + 8 ], %l0 id <= _Rate_monotonic_Information.maximum_id ; 40008238: c2 04 60 0c ld [ %l1 + 0xc ], %g1 4000823c: 80 a4 00 01 cmp %l0, %g1 40008240: 18 80 00 09 bgu 40008264 40008244: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 40008248: 40 00 00 13 call 40008294 4000824c: 90 10 00 10 mov %l0, %o0 /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 40008250: c2 04 60 0c ld [ %l1 + 0xc ], %g1 id++ ) { 40008254: 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 ; 40008258: 80 a0 40 10 cmp %g1, %l0 4000825c: 1a bf ff fb bcc 40008248 40008260: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008264: c2 04 a1 e0 ld [ %l2 + 0x1e0 ], %g1 40008268: 82 00 7f ff add %g1, -1, %g1 4000826c: c2 24 a1 e0 st %g1, [ %l2 + 0x1e0 ] 40008270: c4 04 a1 e0 ld [ %l2 + 0x1e0 ], %g2 40008274: 80 a0 a0 00 cmp %g2, 0 40008278: 02 80 00 04 be 40008288 4000827c: 01 00 00 00 nop 40008280: 81 c7 e0 08 ret <== NOT EXECUTED 40008284: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40008288: 40 00 0f 09 call 4000beac <_Thread_Dispatch> 4000828c: 81 e8 00 00 restore 40008290: 01 00 00 00 nop 4001127c : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 4001127c: 9d e3 bf 98 save %sp, -104, %sp Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 40011280: a8 96 20 00 orcc %i0, 0, %l4 40011284: 02 80 00 58 be 400113e4 40011288: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 4001128c: 80 a6 60 00 cmp %i1, 0 40011290: 02 80 00 06 be 400112a8 40011294: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 40011298: 02 80 00 04 be 400112a8 4001129c: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 400112a0: 02 80 00 04 be 400112b0 400112a4: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 400112a8: 81 c7 e0 08 ret 400112ac: 91 e8 20 09 restore %g0, 9, %o0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 400112b0: 7f ff e6 8f call 4000acec 400112b4: 01 00 00 00 nop 400112b8: a2 10 00 08 mov %o0, %l1 400112bc: 25 10 00 d1 sethi %hi(0x40034400), %l2 400112c0: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 400112c4: 80 a0 60 00 cmp %g1, 0 400112c8: 02 80 00 0b be 400112f4 400112cc: 03 10 00 d2 sethi %hi(0x40034800), %g1 400112d0: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 400112d4: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 40034940 <_System_state_Current> <== NOT EXECUTED 400112d8: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 400112dc: 08 80 00 05 bleu 400112f0 <== NOT EXECUTED 400112e0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400112e4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400112e8: 40 00 13 57 call 40016044 <_Internal_error_Occurred> <== NOT EXECUTED 400112ec: 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; 400112f0: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 400112f4: 27 10 00 d2 sethi %hi(0x40034800), %l3 400112f8: c6 00 60 3c ld [ %g1 + 0x3c ], %g3 400112fc: e0 04 e0 34 ld [ %l3 + 0x34 ], %l0 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40011300: c0 20 e0 34 clr [ %g3 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40011304: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40011308: 80 a0 60 00 cmp %g1, 0 4001130c: 22 80 00 12 be,a 40011354 40011310: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40011314: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40011318: c2 00 e0 08 ld [ %g3 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 4001131c: c4 04 20 58 ld [ %l0 + 0x58 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 40011320: 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; 40011324: 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; 40011328: c6 24 20 6c st %g3, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 4001132c: 80 a0 a0 02 cmp %g2, 2 40011330: 12 80 00 2f bne 400113ec 40011334: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40011338: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 4001133c: 82 00 60 01 inc %g1 40011340: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 40011344: 7f ff e6 6e call 4000acfc 40011348: 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 ); 4001134c: 10 80 00 0f b 40011388 40011350: 23 10 00 d1 sethi %hi(0x40034400), %l1 /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 40011354: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 40011358: 32 80 00 48 bne,a 40011478 <== NOT EXECUTED 4001135c: c4 04 20 08 ld [ %l0 + 8 ], %g2 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40011360: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40011364: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40011368: 12 80 00 41 bne 4001146c <== NOT EXECUTED 4001136c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40011370: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40011374: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011378: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 4001137c: 7f ff e6 60 call 4000acfc <== NOT EXECUTED 40011380: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40011384: 23 10 00 d1 sethi %hi(0x40034400), %l1 <== NOT EXECUTED 40011388: 40 00 13 5c call 400160f8 <_Objects_Allocate> 4001138c: 90 14 61 78 or %l1, 0x178, %o0 ! 40034578 <_Region_Information> the_region = _Region_Allocate(); if ( !the_region ) { 40011390: a0 92 20 00 orcc %o0, 0, %l0 40011394: 32 80 00 4e bne,a 400114cc 40011398: 90 04 20 68 add %l0, 0x68, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001139c: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 400113a0: 82 00 60 01 inc %g1 400113a4: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] _RTEMS_Unlock_allocator(); 400113a8: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 400113ac: 94 10 20 00 clr %o2 400113b0: d2 02 20 08 ld [ %o0 + 8 ], %o1 400113b4: 40 00 10 ab call 40015660 <_CORE_mutex_Surrender> 400113b8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400113bc: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 400113c0: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 400113c4: 82 00 7f ff add %g1, -1, %g1 400113c8: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] 400113cc: c4 04 a3 60 ld [ %l2 + 0x360 ], %g2 400113d0: 80 a0 a0 00 cmp %g2, 0 400113d4: 12 80 00 04 bne 400113e4 400113d8: 01 00 00 00 nop 400113dc: 40 00 19 d4 call 40017b2c <_Thread_Dispatch> 400113e0: 01 00 00 00 nop 400113e4: 81 c7 e0 08 ret 400113e8: 81 e8 00 00 restore if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400113ec: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 400113f0: 12 bf ff d5 bne 40011344 <== NOT EXECUTED 400113f4: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400113f8: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 400113fc: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2 <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40011400: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011404: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40011408: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED current = executing->current_priority; if ( current == ceiling ) { 4001140c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 40011410: 02 80 00 4e be 40011548 <== NOT EXECUTED 40011414: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40011418: 1a 80 00 42 bcc 40011520 <== NOT EXECUTED 4001141c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011420: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 <== NOT EXECUTED 40011424: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011428: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 4001142c: 7f ff e6 34 call 4000acfc <== NOT EXECUTED 40011430: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 40011434: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40011438: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 4001143c: 40 00 18 98 call 4001769c <_Thread_Change_priority> <== NOT EXECUTED 40011440: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011444: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 <== NOT EXECUTED 40011448: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001144c: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] <== NOT EXECUTED 40011450: c4 04 a3 60 ld [ %l2 + 0x360 ], %g2 <== NOT EXECUTED 40011454: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40011458: 12 bf ff cc bne 40011388 <== NOT EXECUTED 4001145c: 23 10 00 d1 sethi %hi(0x40034400), %l1 <== NOT EXECUTED _Thread_Dispatch(); 40011460: 40 00 19 b3 call 40017b2c <_Thread_Dispatch> <== NOT EXECUTED 40011464: 01 00 00 00 nop <== NOT EXECUTED 40011468: 30 bf ff c8 b,a 40011388 <== NOT EXECUTED * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 4001146c: 02 80 00 13 be 400114b8 <== NOT EXECUTED 40011470: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 40011474: c4 04 20 08 ld [ %l0 + 8 ], %g2 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011478: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 <== NOT EXECUTED 4001147c: c4 20 e0 20 st %g2, [ %g3 + 0x20 ] <== NOT EXECUTED 40011480: 82 00 60 01 inc %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 40011484: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 40011488: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] <== NOT EXECUTED 4001148c: c4 24 20 40 st %g2, [ %l0 + 0x40 ] <== NOT EXECUTED 40011490: 82 04 20 10 add %l0, 0x10, %g1 <== NOT EXECUTED 40011494: c2 20 e0 44 st %g1, [ %g3 + 0x44 ] <== NOT EXECUTED 40011498: 7f ff e6 19 call 4000acfc <== NOT EXECUTED 4001149c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400114a0: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 400114a4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400114a8: 40 00 10 4a call 400155d0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 400114ac: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 400114b0: 10 bf ff b6 b 40011388 <== NOT EXECUTED 400114b4: 23 10 00 d1 sethi %hi(0x40034400), %l1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 400114b8: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400114bc: 7f ff e6 10 call 4000acfc <== NOT EXECUTED 400114c0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400114c4: 10 bf ff b1 b 40011388 <== NOT EXECUTED 400114c8: 23 10 00 d1 sethi %hi(0x40034400), %l1 <== NOT EXECUTED if ( !the_region ) { _RTEMS_Unlock_allocator(); return RTEMS_TOO_MANY; } the_region->maximum_segment_size = 400114cc: 92 10 00 19 mov %i1, %o1 400114d0: 94 10 00 1a mov %i2, %o2 400114d4: 40 00 12 8f call 40015f10 <_Heap_Initialize> 400114d8: 96 10 00 1b mov %i3, %o3 _Heap_Initialize(&the_region->Memory, starting_address, length, page_size); if ( !the_region->maximum_segment_size ) { 400114dc: 80 a2 20 00 cmp %o0, 0 400114e0: 12 80 00 1e bne 40011558 400114e4: 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 ); 400114e8: 90 14 61 78 or %l1, 0x178, %o0 400114ec: 40 00 14 11 call 40016530 <_Objects_Free> 400114f0: 92 10 00 10 mov %l0, %o1 400114f4: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 400114f8: 82 00 60 01 inc %g1 400114fc: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 40011500: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 40011504: 94 10 20 00 clr %o2 40011508: d2 02 20 08 ld [ %o0 + 8 ], %o1 4001150c: 40 00 10 55 call 40015660 <_CORE_mutex_Surrender> 40011510: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011514: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 40011518: 10 bf ff ab b 400113c4 4001151c: b0 10 20 08 mov 8, %i0 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40011520: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40011524: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40011528: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 4001152c: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 40011530: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40011534: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40011538: 7f ff e5 f1 call 4000acfc <== NOT EXECUTED 4001153c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED * the inactive chain of free region control blocks. */ RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void ) { return (Region_Control *) _Objects_Allocate( &_Region_Information ); 40011540: 10 bf ff 92 b 40011388 <== NOT EXECUTED 40011544: 23 10 00 d1 sethi %hi(0x40034400), %l1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40011548: 7f ff e5 ed call 4000acfc <== NOT EXECUTED 4001154c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40011550: 10 bf ff 8e b 40011388 <== NOT EXECUTED 40011554: 23 10 00 d1 sethi %hi(0x40034400), %l1 <== NOT EXECUTED the_region->length = length; the_region->page_size = page_size; the_region->attribute_set = attribute_set; the_region->number_of_used_blocks = 0; _Thread_queue_Initialize( 40011558: 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; 4001155c: f2 24 20 50 st %i1, [ %l0 + 0x50 ] the_region->length = length; 40011560: f4 24 20 54 st %i2, [ %l0 + 0x54 ] the_region->page_size = page_size; 40011564: f6 24 20 58 st %i3, [ %l0 + 0x58 ] the_region->attribute_set = attribute_set; 40011568: f8 24 20 60 st %i4, [ %l0 + 0x60 ] the_region->number_of_used_blocks = 0; 4001156c: c0 24 20 64 clr [ %l0 + 0x64 ] _Thread_queue_Initialize( 40011570: 93 37 20 02 srl %i4, 2, %o1 40011574: 94 10 20 40 mov 0x40, %o2 40011578: 92 0a 60 01 and %o1, 1, %o1 4001157c: 40 00 1b ea call 40018524 <_Thread_queue_Initialize> 40011580: 96 10 20 06 mov 6, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40011584: 90 14 61 78 or %l1, 0x178, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40011588: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4001158c: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40011590: 03 00 00 3f sethi %hi(0xfc00), %g1 40011594: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40011598: 82 08 c0 01 and %g3, %g1, %g1 4001159c: 80 a0 40 02 cmp %g1, %g2 400115a0: 38 80 00 06 bgu,a 400115b8 400115a4: c6 27 40 00 st %g3, [ %i5 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 400115a8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400115ac: 83 28 60 02 sll %g1, 2, %g1 400115b0: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 400115b4: c6 27 40 00 st %g3, [ %i5 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400115b8: c2 04 a3 60 ld [ %l2 + 0x360 ], %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; 400115bc: e8 24 20 0c st %l4, [ %l0 + 0xc ] 400115c0: 82 00 60 01 inc %g1 400115c4: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] _RTEMS_Unlock_allocator(); 400115c8: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 400115cc: 94 10 20 00 clr %o2 400115d0: d2 02 20 08 ld [ %o0 + 8 ], %o1 400115d4: 40 00 10 23 call 40015660 <_CORE_mutex_Surrender> 400115d8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400115dc: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 400115e0: 10 bf ff 79 b 400113c4 400115e4: b0 10 20 00 clr %i0 400115e8 : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 400115e8: 9d e3 bf 90 save %sp, -112, %sp register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 400115ec: 7f ff e5 c0 call 4000acec 400115f0: 01 00 00 00 nop 400115f4: a2 10 00 08 mov %o0, %l1 400115f8: 25 10 00 d1 sethi %hi(0x40034400), %l2 400115fc: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 40011600: 80 a0 60 00 cmp %g1, 0 40011604: 02 80 00 0b be 40011630 40011608: 27 10 00 d2 sethi %hi(0x40034800), %l3 4001160c: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40011610: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 40034940 <_System_state_Current> <== NOT EXECUTED 40011614: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40011618: 08 80 00 06 bleu 40011630 <== NOT EXECUTED 4001161c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40011620: 92 10 20 00 clr %o1 <== NOT EXECUTED 40011624: 40 00 12 88 call 40016044 <_Internal_error_Occurred> <== NOT EXECUTED 40011628: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 4001162c: 27 10 00 d2 sethi %hi(0x40034800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40011630: 09 10 00 d2 sethi %hi(0x40034800), %g4 40011634: e0 04 e0 34 ld [ %l3 + 0x34 ], %l0 40011638: c4 01 20 3c ld [ %g4 + 0x3c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 4001163c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40011640: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40011644: 80 a0 60 00 cmp %g1, 0 40011648: 22 80 00 36 be,a 40011720 4001164c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40011650: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40011654: 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; 40011658: 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; 4001165c: 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; 40011660: 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; 40011664: 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 ) || 40011668: 80 a0 e0 02 cmp %g3, 2 4001166c: 12 80 00 56 bne 400117c4 40011670: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40011674: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40011678: 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++; 4001167c: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40011680: 02 80 00 7c be 40011870 40011684: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 40011688: 7f ff e5 9d call 4000acfc 4001168c: 90 10 00 11 mov %l1, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 40011690: 92 10 00 18 mov %i0, %o1 40011694: 21 10 00 d1 sethi %hi(0x40034400), %l0 40011698: 94 07 bf f4 add %fp, -12, %o2 4001169c: 40 00 13 e8 call 4001663c <_Objects_Get_no_protection> 400116a0: 90 14 21 78 or %l0, 0x178, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 400116a4: c2 07 bf f4 ld [ %fp + -12 ], %g1 400116a8: 80 a0 60 01 cmp %g1, 1 400116ac: 02 80 00 33 be 40011778 400116b0: 92 10 00 08 mov %o0, %o1 400116b4: 80 a0 60 01 cmp %g1, 1 400116b8: 1a 80 00 5f bcc 40011834 400116bc: 80 a0 60 02 cmp %g1, 2 _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks == 0 ) { 400116c0: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 400116c4: 80 a0 60 00 cmp %g1, 0 400116c8: 22 80 00 99 be,a 4001192c 400116cc: 90 14 21 78 or %l0, 0x178, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400116d0: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 400116d4: 82 00 60 01 inc %g1 400116d8: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } _RTEMS_Unlock_allocator(); 400116dc: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 400116e0: 94 10 20 00 clr %o2 400116e4: d2 02 20 08 ld [ %o0 + 8 ], %o1 400116e8: 40 00 0f de call 40015660 <_CORE_mutex_Surrender> 400116ec: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400116f0: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 400116f4: b0 10 20 0c mov 0xc, %i0 400116f8: 82 00 7f ff add %g1, -1, %g1 400116fc: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] 40011700: c4 04 a3 60 ld [ %l2 + 0x360 ], %g2 40011704: 80 a0 a0 00 cmp %g2, 0 40011708: 12 80 00 49 bne 4001182c 4001170c: 01 00 00 00 nop _Thread_Dispatch(); 40011710: 40 00 19 07 call 40017b2c <_Thread_Dispatch> 40011714: 01 00 00 00 nop 40011718: 81 c7 e0 08 ret 4001171c: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 40011720: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40011724: 12 80 00 30 bne 400117e4 <== NOT EXECUTED 40011728: c6 04 e0 34 ld [ %l3 + 0x34 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 4001172c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40011730: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40011734: 22 80 00 6a be,a 400118dc <== NOT EXECUTED 40011738: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 4001173c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40011740: 12 80 00 29 bne 400117e4 <== NOT EXECUTED 40011744: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40011748: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 4001174c: 7f ff e5 6c call 4000acfc <== NOT EXECUTED 40011750: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40011754: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 40011758: 21 10 00 d1 sethi %hi(0x40034400), %l0 <== NOT EXECUTED 4001175c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 40011760: 40 00 13 b7 call 4001663c <_Objects_Get_no_protection> <== NOT EXECUTED 40011764: 90 14 21 78 or %l0, 0x178, %o0 <== NOT EXECUTED register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 40011768: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4001176c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40011770: 12 bf ff d2 bne 400116b8 <== NOT EXECUTED 40011774: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011778: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 <== NOT EXECUTED 4001177c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011780: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 40011784: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 40011788: 94 10 20 00 clr %o2 <== NOT EXECUTED 4001178c: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40011790: 40 00 0f b4 call 40015660 <_CORE_mutex_Surrender> <== NOT EXECUTED 40011794: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011798: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 <== NOT EXECUTED 4001179c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400117a0: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] <== NOT EXECUTED 400117a4: c4 04 a3 60 ld [ %l2 + 0x360 ], %g2 <== NOT EXECUTED 400117a8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400117ac: 12 80 00 24 bne 4001183c <== NOT EXECUTED 400117b0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 400117b4: 40 00 18 de call 40017b2c <_Thread_Dispatch> <== NOT EXECUTED 400117b8: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 400117bc: 81 c7 e0 08 ret <== NOT EXECUTED 400117c0: 81 e8 00 00 restore <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400117c4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 400117c8: 12 bf ff b0 bne 40011688 <== NOT EXECUTED 400117cc: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400117d0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400117d4: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400117d8: 02 80 00 26 be 40011870 <== NOT EXECUTED 400117dc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 400117e0: 30 bf ff aa b,a 40011688 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400117e4: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 <== NOT EXECUTED ) { register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 400117e8: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 400117ec: c8 01 20 3c ld [ %g4 + 0x3c ], %g4 <== NOT EXECUTED 400117f0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400117f4: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 400117f8: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] <== NOT EXECUTED 400117fc: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40011800: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40011804: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40011808: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 4001180c: 7f ff e5 3c call 4000acfc <== NOT EXECUTED 40011810: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40011814: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 40011818: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001181c: 40 00 0f 6d call 400155d0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40011820: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40011824: 10 bf ff 9c b 40011694 <== NOT EXECUTED 40011828: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _RTEMS_Unlock_allocator(); return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001182c: 81 c7 e0 08 ret <== NOT EXECUTED 40011830: 81 e8 00 00 restore <== NOT EXECUTED register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 40011834: 02 80 00 04 be 40011844 40011838: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4001183c: 81 c7 e0 08 ret <== NOT EXECUTED 40011840: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011844: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 40011848: 82 00 60 01 inc %g1 4001184c: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40011850: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 40011854: 94 10 20 00 clr %o2 40011858: d2 02 20 08 ld [ %o0 + 8 ], %o1 4001185c: 40 00 0f 81 call 40015660 <_CORE_mutex_Surrender> 40011860: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011864: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 40011868: 10 bf ff a4 b 400116f8 4001186c: b0 10 20 04 mov 4, %i0 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40011870: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40011874: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40011878: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4001187c: 02 80 00 28 be 4001191c <== NOT EXECUTED 40011880: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40011884: 1a 80 00 1c bcc 400118f4 <== NOT EXECUTED 40011888: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001188c: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 <== NOT EXECUTED 40011890: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011894: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40011898: 7f ff e5 19 call 4000acfc <== NOT EXECUTED 4001189c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 400118a0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 400118a4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 400118a8: 40 00 17 7d call 4001769c <_Thread_Change_priority> <== NOT EXECUTED 400118ac: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400118b0: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 <== NOT EXECUTED 400118b4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400118b8: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] <== NOT EXECUTED 400118bc: c4 04 a3 60 ld [ %l2 + 0x360 ], %g2 <== NOT EXECUTED 400118c0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400118c4: 32 bf ff 74 bne,a 40011694 <== NOT EXECUTED 400118c8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _Thread_Dispatch(); 400118cc: 40 00 18 98 call 40017b2c <_Thread_Dispatch> <== NOT EXECUTED 400118d0: 01 00 00 00 nop <== NOT EXECUTED 400118d4: 10 bf ff 70 b 40011694 <== NOT EXECUTED 400118d8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 400118dc: 82 00 60 01 inc %g1 <== NOT EXECUTED 400118e0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400118e4: 7f ff e5 06 call 4000acfc <== NOT EXECUTED 400118e8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400118ec: 10 bf ff 6a b 40011694 <== NOT EXECUTED 400118f0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 400118f4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400118f8: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 400118fc: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40011900: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40011904: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40011908: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4001190c: 7f ff e4 fc call 4000acfc <== NOT EXECUTED 40011910: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40011914: 10 bf ff 60 b 40011694 <== NOT EXECUTED 40011918: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 4001191c: 7f ff e4 f8 call 4000acfc <== NOT EXECUTED 40011920: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40011924: 10 bf ff 5c b 40011694 <== NOT EXECUTED 40011928: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4001192c: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40011930: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40011934: 05 00 00 3f sethi %hi(0xfc00), %g2 40011938: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4001193c: 82 08 40 02 and %g1, %g2, %g1 40011940: 80 a0 40 03 cmp %g1, %g3 40011944: 18 80 00 05 bgu 40011958 40011948: 01 00 00 00 nop information->local_table[ index ] = the_object; 4001194c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40011950: 83 28 60 02 sll %g1, 2, %g1 40011954: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 40011958: 40 00 12 f6 call 40016530 <_Objects_Free> 4001195c: c0 22 60 0c clr [ %o1 + 0xc ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011960: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 40011964: 82 00 60 01 inc %g1 40011968: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks == 0 ) { _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 4001196c: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 40011970: 94 10 20 00 clr %o2 40011974: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011978: 40 00 0f 3a call 40015660 <_CORE_mutex_Surrender> 4001197c: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011980: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 40011984: 10 bf ff 5d b 400116f8 40011988: b0 10 20 00 clr %i0 4001198c : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 4001198c: 9d e3 bf 90 save %sp, -112, %sp 40011990: a8 10 00 18 mov %i0, %l4 Objects_Locations location; uint32_t amount_extended; Heap_Extend_status heap_status; rtems_status_code status; if ( !starting_address ) 40011994: 80 a6 60 00 cmp %i1, 0 40011998: 02 80 00 59 be 40011afc 4001199c: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 400119a0: 7f ff e4 d3 call 4000acec 400119a4: 01 00 00 00 nop 400119a8: a4 10 00 08 mov %o0, %l2 400119ac: 23 10 00 d1 sethi %hi(0x40034400), %l1 400119b0: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 400119b4: 80 a0 60 00 cmp %g1, 0 400119b8: 02 80 00 0b be 400119e4 400119bc: 27 10 00 d2 sethi %hi(0x40034800), %l3 400119c0: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 400119c4: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 40034940 <_System_state_Current> <== NOT EXECUTED 400119c8: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 400119cc: 08 80 00 06 bleu 400119e4 <== NOT EXECUTED 400119d0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400119d4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400119d8: 40 00 11 9b call 40016044 <_Internal_error_Occurred> <== NOT EXECUTED 400119dc: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400119e0: 27 10 00 d2 sethi %hi(0x40034800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400119e4: 09 10 00 d2 sethi %hi(0x40034800), %g4 400119e8: e0 04 e0 34 ld [ %l3 + 0x34 ], %l0 400119ec: c4 01 20 3c ld [ %g4 + 0x3c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 400119f0: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 400119f4: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 400119f8: 80 a0 60 00 cmp %g1, 0 400119fc: 22 80 00 42 be,a 40011b04 40011a00: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40011a04: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40011a08: 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; 40011a0c: 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; 40011a10: 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; 40011a14: 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; 40011a18: 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 ) || 40011a1c: 80 a0 e0 02 cmp %g3, 2 40011a20: 02 80 00 61 be 40011ba4 40011a24: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 40011a28: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40011a2c: 22 80 00 60 be,a 40011bac <== NOT EXECUTED 40011a30: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 40011a34: 7f ff e4 b2 call 4000acfc 40011a38: 90 10 00 12 mov %l2, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 40011a3c: 92 10 00 14 mov %l4, %o1 40011a40: 11 10 00 d1 sethi %hi(0x40034400), %o0 40011a44: 94 07 bf f4 add %fp, -12, %o2 40011a48: 40 00 12 fd call 4001663c <_Objects_Get_no_protection> 40011a4c: 90 12 21 78 or %o0, 0x178, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 40011a50: c2 07 bf f4 ld [ %fp + -12 ], %g1 40011a54: 80 a0 60 01 cmp %g1, 1 40011a58: 02 80 00 40 be 40011b58 40011a5c: a0 10 00 08 mov %o0, %l0 40011a60: 80 a0 60 01 cmp %g1, 1 40011a64: 1a 80 00 70 bcc 40011c24 40011a68: 80 a0 60 02 cmp %g1, 2 _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: heap_status = _Heap_Extend( 40011a6c: 92 10 00 19 mov %i1, %o1 40011a70: 94 10 00 1a mov %i2, %o2 40011a74: 90 02 20 68 add %o0, 0x68, %o0 40011a78: 96 07 bf f0 add %fp, -16, %o3 40011a7c: 40 00 10 3f call 40015b78 <_Heap_Extend> 40011a80: b0 10 20 09 mov 9, %i0 starting_address, length, &amount_extended ); switch ( heap_status ) { 40011a84: 80 a2 20 01 cmp %o0, 1 40011a88: 02 80 00 0c be 40011ab8 40011a8c: 01 00 00 00 nop 40011a90: 1a 80 00 8e bcc 40011cc8 40011a94: 82 1a 20 02 xor %o0, 2, %g1 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 40011a98: c6 07 bf f0 ld [ %fp + -16 ], %g3 40011a9c: c4 04 20 54 ld [ %l0 + 0x54 ], %g2 the_region->maximum_segment_size += amount_extended; 40011aa0: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 40011aa4: 84 00 80 03 add %g2, %g3, %g2 the_region->maximum_segment_size += amount_extended; 40011aa8: 82 00 40 03 add %g1, %g3, %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 40011aac: c4 24 20 54 st %g2, [ %l0 + 0x54 ] the_region->maximum_segment_size += amount_extended; 40011ab0: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 40011ab4: b0 10 20 00 clr %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011ab8: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40011abc: 82 00 60 01 inc %g1 40011ac0: c2 24 63 60 st %g1, [ %l1 + 0x360 ] break; case HEAP_EXTEND_NOT_IMPLEMENTED: status = RTEMS_NOT_IMPLEMENTED; break; } _RTEMS_Unlock_allocator(); 40011ac4: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 40011ac8: 94 10 20 00 clr %o2 40011acc: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011ad0: 40 00 0e e4 call 40015660 <_CORE_mutex_Surrender> 40011ad4: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011ad8: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40011adc: 82 00 7f ff add %g1, -1, %g1 40011ae0: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40011ae4: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40011ae8: 80 a0 a0 00 cmp %g2, 0 40011aec: 12 80 00 2c bne 40011b9c 40011af0: 01 00 00 00 nop _Thread_Dispatch(); 40011af4: 40 00 18 0e call 40017b2c <_Thread_Dispatch> 40011af8: 01 00 00 00 nop 40011afc: 81 c7 e0 08 ret 40011b00: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 40011b04: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40011b08: 12 80 00 4d bne 40011c3c <== NOT EXECUTED 40011b0c: c6 04 e0 34 ld [ %l3 + 0x34 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40011b10: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40011b14: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40011b18: 12 80 00 47 bne 40011c34 <== NOT EXECUTED 40011b1c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40011b20: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40011b24: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011b28: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40011b2c: 7f ff e4 74 call 4000acfc <== NOT EXECUTED 40011b30: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40011b34: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 40011b38: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED 40011b3c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 40011b40: 40 00 12 bf call 4001663c <_Objects_Get_no_protection> <== NOT EXECUTED 40011b44: 90 12 21 78 or %o0, 0x178, %o0 <== NOT EXECUTED status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 40011b48: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 40011b4c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40011b50: 12 bf ff c5 bne 40011a64 <== NOT EXECUTED 40011b54: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011b58: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40011b5c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011b60: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 40011b64: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 40011b68: 94 10 20 00 clr %o2 <== NOT EXECUTED 40011b6c: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40011b70: 40 00 0e bc call 40015660 <_CORE_mutex_Surrender> <== NOT EXECUTED 40011b74: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011b78: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40011b7c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40011b80: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40011b84: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 40011b88: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40011b8c: 12 80 00 28 bne 40011c2c <== NOT EXECUTED 40011b90: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 40011b94: 40 00 17 e6 call 40017b2c <_Thread_Dispatch> <== NOT EXECUTED 40011b98: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 40011b9c: 81 c7 e0 08 ret <== NOT EXECUTED 40011ba0: 81 e8 00 00 restore <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40011ba4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40011ba8: 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++; 40011bac: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40011bb0: 12 bf ff a1 bne 40011a34 40011bb4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40011bb8: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40011bbc: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40011bc0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40011bc4: 02 80 00 50 be 40011d04 <== NOT EXECUTED 40011bc8: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40011bcc: 1a 80 00 44 bcc 40011cdc <== NOT EXECUTED 40011bd0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011bd4: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40011bd8: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011bdc: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40011be0: 7f ff e4 47 call 4000acfc <== NOT EXECUTED 40011be4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40011be8: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40011bec: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40011bf0: 40 00 16 ab call 4001769c <_Thread_Change_priority> <== NOT EXECUTED 40011bf4: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011bf8: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40011bfc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40011c00: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40011c04: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 40011c08: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40011c0c: 32 bf ff 8d bne,a 40011a40 <== NOT EXECUTED 40011c10: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED _Thread_Dispatch(); 40011c14: 40 00 17 c6 call 40017b2c <_Thread_Dispatch> <== NOT EXECUTED 40011c18: 01 00 00 00 nop <== NOT EXECUTED 40011c1c: 10 bf ff 89 b 40011a40 <== NOT EXECUTED 40011c20: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 40011c24: 02 80 00 18 be 40011c84 40011c28: 01 00 00 00 nop 40011c2c: 81 c7 e0 08 ret <== NOT EXECUTED 40011c30: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40011c34: 02 80 00 1f be 40011cb0 <== NOT EXECUTED 40011c38: c6 04 e0 34 ld [ %l3 + 0x34 ], %g3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011c3c: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED if ( !starting_address ) return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 40011c40: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40011c44: c8 01 20 3c ld [ %g4 + 0x3c ], %g4 <== NOT EXECUTED 40011c48: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011c4c: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40011c50: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40011c54: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40011c58: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40011c5c: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40011c60: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40011c64: 7f ff e4 26 call 4000acfc <== NOT EXECUTED 40011c68: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40011c6c: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 40011c70: 92 10 20 00 clr %o1 <== NOT EXECUTED 40011c74: 40 00 0e 57 call 400155d0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40011c78: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40011c7c: 10 bf ff 71 b 40011a40 <== NOT EXECUTED 40011c80: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 40011c84: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40011c88: 82 00 60 01 inc %g1 40011c8c: c2 24 63 60 st %g1, [ %l1 + 0x360 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40011c90: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 40011c94: 94 10 20 00 clr %o2 40011c98: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011c9c: 40 00 0e 71 call 40015660 <_CORE_mutex_Surrender> 40011ca0: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011ca4: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40011ca8: 10 bf ff 8d b 40011adc 40011cac: b0 10 20 04 mov 4, %i0 case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40011cb0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40011cb4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40011cb8: 7f ff e4 11 call 4000acfc <== NOT EXECUTED 40011cbc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40011cc0: 10 bf ff 60 b 40011a40 <== NOT EXECUTED 40011cc4: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 40011cc8: 80 a0 00 01 cmp %g0, %g1 40011ccc: 84 60 20 00 subx %g0, 0, %g2 40011cd0: b0 08 bf e8 and %g2, -24, %i0 40011cd4: 10 bf ff 79 b 40011ab8 40011cd8: b0 06 20 18 add %i0, 0x18, %i0 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40011cdc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40011ce0: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40011ce4: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40011ce8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40011cec: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40011cf0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40011cf4: 7f ff e4 02 call 4000acfc <== NOT EXECUTED 40011cf8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40011cfc: 10 bf ff 51 b 40011a40 <== NOT EXECUTED 40011d00: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40011d04: 7f ff e3 fe call 4000acfc <== NOT EXECUTED 40011d08: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40011d0c: 10 bf ff 4d b 40011a40 <== NOT EXECUTED 40011d10: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 40011d14 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 40011d14: 9d e3 bf 90 save %sp, -112, %sp 40011d18: aa 10 00 18 mov %i0, %l5 register Region_Control *the_region; Objects_Locations location; Thread_Control *executing; void *the_segment; if ( !segment ) 40011d1c: 80 a7 20 00 cmp %i4, 0 40011d20: 02 80 00 4e be 40011e58 40011d24: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; *segment = NULL; if ( size == 0 ) 40011d28: 80 a6 60 00 cmp %i1, 0 40011d2c: 02 80 00 c8 be 4001204c 40011d30: c0 27 00 00 clr [ %i4 ] return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 40011d34: 7f ff e3 ee call 4000acec 40011d38: 01 00 00 00 nop 40011d3c: a4 10 00 08 mov %o0, %l2 40011d40: 23 10 00 d1 sethi %hi(0x40034400), %l1 40011d44: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 40011d48: 80 a0 60 00 cmp %g1, 0 40011d4c: 02 80 00 0b be 40011d78 40011d50: 29 10 00 d2 sethi %hi(0x40034800), %l4 40011d54: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40011d58: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 40034940 <_System_state_Current> <== NOT EXECUTED 40011d5c: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40011d60: 08 80 00 06 bleu 40011d78 <== NOT EXECUTED 40011d64: 90 10 20 00 clr %o0 <== NOT EXECUTED 40011d68: 92 10 20 00 clr %o1 <== NOT EXECUTED 40011d6c: 40 00 10 b6 call 40016044 <_Internal_error_Occurred> <== NOT EXECUTED 40011d70: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40011d74: 29 10 00 d2 sethi %hi(0x40034800), %l4 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40011d78: 27 10 00 d2 sethi %hi(0x40034800), %l3 40011d7c: e0 05 20 34 ld [ %l4 + 0x34 ], %l0 40011d80: c4 04 e0 3c ld [ %l3 + 0x3c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40011d84: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40011d88: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40011d8c: 80 a0 60 00 cmp %g1, 0 40011d90: 22 80 00 34 be,a 40011e60 40011d94: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40011d98: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40011d9c: 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; 40011da0: 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; 40011da4: 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; 40011da8: 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; 40011dac: 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 ) || 40011db0: 80 a0 e0 02 cmp %g3, 2 40011db4: 02 80 00 54 be 40011f04 40011db8: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 40011dbc: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40011dc0: 22 80 00 53 be,a 40011f0c <== NOT EXECUTED 40011dc4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 40011dc8: 7f ff e3 cd call 4000acfc 40011dcc: 90 10 00 12 mov %l2, %o0 executing = _Thread_Executing; 40011dd0: f0 04 e0 3c ld [ %l3 + 0x3c ], %i0 40011dd4: 11 10 00 d1 sethi %hi(0x40034400), %o0 40011dd8: 92 10 00 15 mov %l5, %o1 40011ddc: 90 12 21 78 or %o0, 0x178, %o0 40011de0: 40 00 12 17 call 4001663c <_Objects_Get_no_protection> 40011de4: 94 07 bf f4 add %fp, -12, %o2 the_region = _Region_Get( id, &location ); switch ( location ) { 40011de8: c2 07 bf f4 ld [ %fp + -12 ], %g1 40011dec: 80 a0 60 01 cmp %g1, 1 40011df0: 02 80 00 32 be 40011eb8 40011df4: a0 10 00 08 mov %o0, %l0 40011df8: 80 a0 60 01 cmp %g1, 1 40011dfc: 1a 80 00 62 bcc 40011f84 40011e00: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) { 40011e04: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 40011e08: 80 a6 40 01 cmp %i1, %g1 40011e0c: 28 80 00 a0 bleu,a 4001208c 40011e10: 90 02 20 68 add %o0, 0x68, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011e14: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40011e18: 82 00 60 01 inc %g1 40011e1c: c2 24 63 60 st %g1, [ %l1 + 0x360 ] _RTEMS_Unlock_allocator(); 40011e20: d0 05 20 34 ld [ %l4 + 0x34 ], %o0 40011e24: 94 10 20 00 clr %o2 40011e28: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011e2c: 40 00 0e 0d call 40015660 <_CORE_mutex_Surrender> 40011e30: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011e34: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40011e38: 82 00 7f ff add %g1, -1, %g1 40011e3c: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40011e40: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40011e44: 80 a0 a0 00 cmp %g2, 0 40011e48: 12 80 00 81 bne 4001204c 40011e4c: 01 00 00 00 nop _Thread_Dispatch(); 40011e50: 40 00 17 37 call 40017b2c <_Thread_Dispatch> 40011e54: b0 10 20 08 mov 8, %i0 ! 8 40011e58: 81 c7 e0 08 ret 40011e5c: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 40011e60: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40011e64: 12 80 00 4e bne 40011f9c <== NOT EXECUTED 40011e68: c6 05 20 34 ld [ %l4 + 0x34 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40011e6c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40011e70: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40011e74: 12 80 00 48 bne 40011f94 <== NOT EXECUTED 40011e78: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40011e7c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40011e80: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011e84: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40011e88: 7f ff e3 9d call 4000acfc <== NOT EXECUTED 40011e8c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40011e90: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40011e94: f0 04 e0 3c ld [ %l3 + 0x3c ], %i0 <== NOT EXECUTED 40011e98: 90 12 21 78 or %o0, 0x178, %o0 <== NOT EXECUTED 40011e9c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED 40011ea0: 40 00 11 e7 call 4001663c <_Objects_Get_no_protection> <== NOT EXECUTED 40011ea4: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 40011ea8: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 40011eac: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40011eb0: 12 bf ff d3 bne 40011dfc <== NOT EXECUTED 40011eb4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011eb8: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40011ebc: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011ec0: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 40011ec4: d0 05 20 34 ld [ %l4 + 0x34 ], %o0 <== NOT EXECUTED 40011ec8: 94 10 20 00 clr %o2 <== NOT EXECUTED 40011ecc: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40011ed0: 40 00 0d e4 call 40015660 <_CORE_mutex_Surrender> <== NOT EXECUTED 40011ed4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011ed8: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40011edc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40011ee0: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40011ee4: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 40011ee8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40011eec: 12 80 00 28 bne 40011f8c <== NOT EXECUTED 40011ef0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 40011ef4: 40 00 17 0e call 40017b2c <_Thread_Dispatch> <== NOT EXECUTED 40011ef8: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 40011efc: 81 c7 e0 08 ret <== NOT EXECUTED 40011f00: 81 e8 00 00 restore <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40011f04: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40011f08: 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++; 40011f0c: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40011f10: 12 bf ff ae bne 40011dc8 40011f14: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40011f18: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40011f1c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40011f20: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40011f24: 02 80 00 56 be 4001207c <== NOT EXECUTED 40011f28: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40011f2c: 1a 80 00 4a bcc 40012054 <== NOT EXECUTED 40011f30: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011f34: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40011f38: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011f3c: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40011f40: 7f ff e3 6f call 4000acfc <== NOT EXECUTED 40011f44: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40011f48: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40011f4c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40011f50: 40 00 15 d3 call 4001769c <_Thread_Change_priority> <== NOT EXECUTED 40011f54: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40011f58: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40011f5c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40011f60: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40011f64: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 40011f68: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40011f6c: 32 bf ff 9a bne,a 40011dd4 <== NOT EXECUTED 40011f70: f0 04 e0 3c ld [ %l3 + 0x3c ], %i0 <== NOT EXECUTED _Thread_Dispatch(); 40011f74: 40 00 16 ee call 40017b2c <_Thread_Dispatch> <== NOT EXECUTED 40011f78: 01 00 00 00 nop <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40011f7c: 10 bf ff 96 b 40011dd4 <== NOT EXECUTED 40011f80: f0 04 e0 3c ld [ %l3 + 0x3c ], %i0 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 40011f84: 02 80 00 18 be 40011fe4 40011f88: 01 00 00 00 nop _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 40011f8c: 81 c7 e0 08 ret <== NOT EXECUTED 40011f90: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40011f94: 02 80 00 28 be 40012034 <== NOT EXECUTED 40011f98: c6 05 20 34 ld [ %l4 + 0x34 ], %g3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011f9c: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 40011fa0: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40011fa4: c8 04 e0 3c ld [ %l3 + 0x3c ], %g4 <== NOT EXECUTED 40011fa8: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011fac: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40011fb0: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40011fb4: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40011fb8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40011fbc: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40011fc0: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40011fc4: 7f ff e3 4e call 4000acfc <== NOT EXECUTED 40011fc8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40011fcc: d0 05 20 34 ld [ %l4 + 0x34 ], %o0 <== NOT EXECUTED 40011fd0: 92 10 20 00 clr %o1 <== NOT EXECUTED 40011fd4: 40 00 0d 7f call 400155d0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40011fd8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED executing = _Thread_Executing; 40011fdc: 10 bf ff 7e b 40011dd4 <== NOT EXECUTED 40011fe0: f0 04 e0 3c ld [ %l3 + 0x3c ], %i0 <== NOT EXECUTED 40011fe4: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40011fe8: 82 00 60 01 inc %g1 40011fec: c2 24 63 60 st %g1, [ %l1 + 0x360 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40011ff0: d0 05 20 34 ld [ %l4 + 0x34 ], %o0 40011ff4: 94 10 20 00 clr %o2 40011ff8: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011ffc: 40 00 0d 99 call 40015660 <_CORE_mutex_Surrender> 40012000: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012004: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40012008: b0 10 20 04 mov 4, %i0 _Thread_Dispatch(); 4001200c: 82 00 7f ff add %g1, -1, %g1 40012010: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40012014: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40012018: 80 a0 a0 00 cmp %g2, 0 4001201c: 12 80 00 6d bne 400121d0 40012020: 01 00 00 00 nop 40012024: 40 00 16 c2 call 40017b2c <_Thread_Dispatch> 40012028: 01 00 00 00 nop 4001202c: 81 c7 e0 08 ret 40012030: 81 e8 00 00 restore case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 40012034: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40012038: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 4001203c: 7f ff e3 30 call 4000acfc <== NOT EXECUTED 40012040: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40012044: 10 bf ff 64 b 40011dd4 <== NOT EXECUTED 40012048: f0 04 e0 3c ld [ %l3 + 0x3c ], %i0 <== NOT EXECUTED _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 4001204c: 81 c7 e0 08 ret <== NOT EXECUTED 40012050: 91 e8 20 08 restore %g0, 8, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40012054: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40012058: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4001205c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40012060: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40012064: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40012068: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4001206c: 7f ff e3 24 call 4000acfc <== NOT EXECUTED 40012070: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40012074: 10 bf ff 58 b 40011dd4 <== NOT EXECUTED 40012078: f0 04 e0 3c ld [ %l3 + 0x3c ], %i0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 4001207c: 7f ff e3 20 call 4000acfc <== NOT EXECUTED 40012080: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40012084: 10 bf ff 54 b 40011dd4 <== NOT EXECUTED 40012088: f0 04 e0 3c ld [ %l3 + 0x3c ], %i0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 4001208c: 40 00 0e 89 call 40015ab0 <_Heap_Allocate> 40012090: 92 10 00 19 mov %i1, %o1 the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 40012094: a4 92 20 00 orcc %o0, 0, %l2 40012098: 02 80 00 17 be 400120f4 4001209c: 80 8e a0 01 btst 1, %i2 the_region->number_of_used_blocks += 1; 400120a0: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400120a4: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 400120a8: 82 00 60 01 inc %g1 400120ac: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 400120b0: 84 00 a0 01 inc %g2 400120b4: c4 24 63 60 st %g2, [ %l1 + 0x360 ] _RTEMS_Unlock_allocator(); 400120b8: d0 05 20 34 ld [ %l4 + 0x34 ], %o0 400120bc: 94 10 20 00 clr %o2 400120c0: d2 02 20 08 ld [ %o0 + 8 ], %o1 400120c4: 40 00 0d 67 call 40015660 <_CORE_mutex_Surrender> 400120c8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400120cc: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 400120d0: 82 00 7f ff add %g1, -1, %g1 400120d4: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 400120d8: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 400120dc: 80 a0 a0 00 cmp %g2, 0 400120e0: 02 80 00 12 be 40012128 400120e4: 01 00 00 00 nop *segment = the_segment; 400120e8: e4 27 00 00 st %l2, [ %i4 ] <== NOT EXECUTED 400120ec: 81 c7 e0 08 ret 400120f0: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; } if ( _Options_Is_no_wait( option_set ) ) { 400120f4: 02 80 00 11 be 40012138 400120f8: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400120fc: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40012100: 82 00 60 01 inc %g1 40012104: c2 24 63 60 st %g1, [ %l1 + 0x360 ] _RTEMS_Unlock_allocator(); 40012108: d0 05 20 34 ld [ %l4 + 0x34 ], %o0 4001210c: 94 10 20 00 clr %o2 40012110: d2 02 20 08 ld [ %o0 + 8 ], %o1 40012114: 40 00 0d 53 call 40015660 <_CORE_mutex_Surrender> 40012118: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001211c: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40012120: 10 bf ff bb b 4001200c 40012124: b0 10 20 0d mov 0xd, %i0 _Thread_Dispatch(); 40012128: 40 00 16 81 call 40017b2c <_Thread_Dispatch> 4001212c: 01 00 00 00 nop _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { the_region->number_of_used_blocks += 1; _RTEMS_Unlock_allocator(); *segment = the_segment; 40012130: 10 bf ff ef b 400120ec 40012134: e4 27 00 00 st %l2, [ %i4 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40012138: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 4001213c: 25 10 00 d1 sethi %hi(0x40034400), %l2 40012140: 82 00 60 01 inc %g1 40012144: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40012148: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 4001214c: 82 00 60 01 inc %g1 40012150: c2 24 63 60 st %g1, [ %l1 + 0x360 ] * 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(); 40012154: d0 05 20 34 ld [ %l4 + 0x34 ], %o0 40012158: 94 10 20 00 clr %o2 4001215c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40012160: 40 00 0d 40 call 40015660 <_CORE_mutex_Surrender> 40012164: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012168: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 4001216c: 82 00 7f ff add %g1, -1, %g1 40012170: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40012174: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40012178: 80 a0 a0 00 cmp %g2, 0 4001217c: 02 80 00 17 be 400121d8 40012180: 01 00 00 00 nop 40012184: 82 10 20 01 mov 1, %g1 ! 1 executing->Wait.queue = &the_region->Wait_queue; 40012188: 90 04 20 10 add %l0, 0x10, %o0 executing->Wait.id = id; 4001218c: ea 26 20 20 st %l5, [ %i0 + 0x20 ] executing->Wait.count = size; 40012190: f2 26 20 24 st %i1, [ %i0 + 0x24 ] executing->Wait.return_argument = segment; 40012194: 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 ); 40012198: 92 10 00 1b mov %i3, %o1 * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; 4001219c: d0 26 20 44 st %o0, [ %i0 + 0x44 ] 400121a0: c2 24 20 40 st %g1, [ %l0 + 0x40 ] executing->Wait.count = size; executing->Wait.return_argument = segment; _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 400121a4: 15 10 00 61 sethi %hi(0x40018400), %o2 400121a8: 40 00 17 d1 call 400180ec <_Thread_queue_Enqueue_with_handler> 400121ac: 94 12 a2 2c or %o2, 0x22c, %o2 ! 4001862c <_Thread_queue_Timeout> 400121b0: c2 04 a3 60 ld [ %l2 + 0x360 ], %g1 400121b4: 82 00 7f ff add %g1, -1, %g1 400121b8: c2 24 a3 60 st %g1, [ %l2 + 0x360 ] 400121bc: c4 04 a3 60 ld [ %l2 + 0x360 ], %g2 400121c0: 80 a0 a0 00 cmp %g2, 0 400121c4: 02 80 00 09 be 400121e8 400121c8: 01 00 00 00 nop _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 400121cc: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 <== NOT EXECUTED 400121d0: 81 c7 e0 08 ret <== NOT EXECUTED 400121d4: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 400121d8: 40 00 16 55 call 40017b2c <_Thread_Dispatch> <== NOT EXECUTED 400121dc: 01 00 00 00 nop <== NOT EXECUTED 400121e0: 10 bf ff ea b 40012188 <== NOT EXECUTED 400121e4: 82 10 20 01 mov 1, %g1 ! 1 <== NOT EXECUTED 400121e8: 40 00 16 51 call 40017b2c <_Thread_Dispatch> 400121ec: 01 00 00 00 nop 400121f0: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 400121f4: 81 c7 e0 08 ret 400121f8: 81 e8 00 00 restore 40012234 : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 40012234: 9d e3 bf 90 save %sp, -112, %sp #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 40012238: 7f ff e2 ad call 4000acec 4001223c: 01 00 00 00 nop 40012240: a4 10 00 08 mov %o0, %l2 40012244: 23 10 00 d1 sethi %hi(0x40034400), %l1 40012248: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 4001224c: 80 a0 60 00 cmp %g1, 0 40012250: 02 80 00 0b be 4001227c 40012254: 27 10 00 d2 sethi %hi(0x40034800), %l3 40012258: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 4001225c: c4 00 61 40 ld [ %g1 + 0x140 ], %g2 ! 40034940 <_System_state_Current> <== NOT EXECUTED 40012260: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40012264: 08 80 00 06 bleu 4001227c <== NOT EXECUTED 40012268: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001226c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40012270: 40 00 0f 75 call 40016044 <_Internal_error_Occurred> <== NOT EXECUTED 40012274: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40012278: 27 10 00 d2 sethi %hi(0x40034800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 4001227c: 09 10 00 d2 sethi %hi(0x40034800), %g4 40012280: e0 04 e0 34 ld [ %l3 + 0x34 ], %l0 40012284: c4 01 20 3c ld [ %g4 + 0x3c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40012288: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 4001228c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40012290: 80 a0 60 00 cmp %g1, 0 40012294: 22 80 00 38 be,a 40012374 40012298: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 4001229c: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400122a0: 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; 400122a4: 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; 400122a8: 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; 400122ac: 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; 400122b0: 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 ) || 400122b4: 80 a0 e0 02 cmp %g3, 2 400122b8: 12 80 00 58 bne 40012418 400122bc: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400122c0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400122c4: 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++; 400122c8: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400122cc: 02 80 00 7c be 400124bc 400122d0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 400122d4: 7f ff e2 8a call 4000acfc 400122d8: 90 10 00 12 mov %l2, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 400122dc: 92 10 00 18 mov %i0, %o1 400122e0: 11 10 00 d1 sethi %hi(0x40034400), %o0 400122e4: 94 07 bf f4 add %fp, -12, %o2 400122e8: 40 00 10 d5 call 4001663c <_Objects_Get_no_protection> 400122ec: 90 12 21 78 or %o0, 0x178, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 400122f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400122f4: 80 a0 60 01 cmp %g1, 1 400122f8: 02 80 00 35 be 400123cc 400122fc: a0 10 00 08 mov %o0, %l0 40012300: 80 a0 60 01 cmp %g1, 1 40012304: 1a 80 00 5f bcc 40012480 40012308: 80 a0 60 02 cmp %g1, 2 RTEMS_INLINE_ROUTINE boolean _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 4001230c: 92 10 00 19 mov %i1, %o1 40012310: 40 00 0e 4d call 40015c44 <_Heap_Free> 40012314: 90 02 20 68 add %o0, 0x68, %o0 status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) { 40012318: 80 a2 20 00 cmp %o0, 0 4001231c: 32 80 00 97 bne,a 40012578 40012320: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40012324: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40012328: 82 00 60 01 inc %g1 4001232c: c2 24 63 60 st %g1, [ %l1 + 0x360 ] _RTEMS_Unlock_allocator(); 40012330: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 40012334: 94 10 20 00 clr %o2 40012338: d2 02 20 08 ld [ %o0 + 8 ], %o1 4001233c: 40 00 0c c9 call 40015660 <_CORE_mutex_Surrender> 40012340: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012344: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40012348: b0 10 20 09 mov 9, %i0 4001234c: 82 00 7f ff add %g1, -1, %g1 40012350: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40012354: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40012358: 80 a0 a0 00 cmp %g2, 0 4001235c: 12 80 00 8c bne 4001258c 40012360: 01 00 00 00 nop _Thread_Dispatch(); 40012364: 40 00 15 f2 call 40017b2c <_Thread_Dispatch> 40012368: 01 00 00 00 nop 4001236c: 81 c7 e0 08 ret 40012370: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 40012374: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40012378: 12 80 00 30 bne 40012438 <== NOT EXECUTED 4001237c: c6 04 e0 34 ld [ %l3 + 0x34 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40012380: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40012384: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40012388: 22 80 00 68 be,a 40012528 <== NOT EXECUTED 4001238c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40012390: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40012394: 12 80 00 29 bne 40012438 <== NOT EXECUTED 40012398: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; _ISR_Enable( level ); return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 4001239c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400123a0: 7f ff e2 57 call 4000acfc <== NOT EXECUTED 400123a4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 400123a8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 400123ac: 11 10 00 d1 sethi %hi(0x40034400), %o0 <== NOT EXECUTED 400123b0: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 400123b4: 40 00 10 a2 call 4001663c <_Objects_Get_no_protection> <== NOT EXECUTED 400123b8: 90 12 21 78 or %o0, 0x178, %o0 <== NOT EXECUTED #endif int status; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 400123bc: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 400123c0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400123c4: 12 bf ff d0 bne 40012304 <== NOT EXECUTED 400123c8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400123cc: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 400123d0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400123d4: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 400123d8: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 400123dc: 94 10 20 00 clr %o2 <== NOT EXECUTED 400123e0: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 400123e4: 40 00 0c 9f call 40015660 <_CORE_mutex_Surrender> <== NOT EXECUTED 400123e8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400123ec: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 400123f0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400123f4: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 400123f8: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 400123fc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40012400: 12 80 00 22 bne 40012488 <== NOT EXECUTED 40012404: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 40012408: 40 00 15 c9 call 40017b2c <_Thread_Dispatch> <== NOT EXECUTED 4001240c: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 40012410: 81 c7 e0 08 ret <== NOT EXECUTED 40012414: 81 e8 00 00 restore <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40012418: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 4001241c: 12 bf ff ae bne 400122d4 <== NOT EXECUTED 40012420: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40012424: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40012428: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4001242c: 02 80 00 24 be 400124bc <== NOT EXECUTED 40012430: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40012434: 30 bf ff a8 b,a 400122d4 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40012438: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 4001243c: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40012440: c8 01 20 3c ld [ %g4 + 0x3c ], %g4 <== NOT EXECUTED 40012444: 82 00 60 01 inc %g1 <== NOT EXECUTED 40012448: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 4001244c: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40012450: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40012454: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40012458: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 4001245c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40012460: 7f ff e2 27 call 4000acfc <== NOT EXECUTED 40012464: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40012468: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 <== NOT EXECUTED 4001246c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40012470: 40 00 0c 58 call 400155d0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40012474: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40012478: 10 bf ff 9a b 400122e0 <== NOT EXECUTED 4001247c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 40012480: 02 80 00 04 be 40012490 40012484: 01 00 00 00 nop the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator internally */ return RTEMS_SUCCESSFUL; 40012488: 81 c7 e0 08 ret <== NOT EXECUTED 4001248c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 40012490: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40012494: 82 00 60 01 inc %g1 40012498: c2 24 63 60 st %g1, [ %l1 + 0x360 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 4001249c: d0 04 e0 34 ld [ %l3 + 0x34 ], %o0 400124a0: 94 10 20 00 clr %o2 400124a4: d2 02 20 08 ld [ %o0 + 8 ], %o1 400124a8: 40 00 0c 6e call 40015660 <_CORE_mutex_Surrender> 400124ac: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400124b0: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 400124b4: 10 bf ff a6 b 4001234c 400124b8: b0 10 20 04 mov 4, %i0 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 400124bc: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 400124c0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 400124c4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 400124c8: 02 80 00 28 be 40012568 <== NOT EXECUTED 400124cc: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 400124d0: 1a 80 00 1c bcc 40012540 <== NOT EXECUTED 400124d4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400124d8: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 400124dc: 82 00 60 01 inc %g1 <== NOT EXECUTED 400124e0: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 400124e4: 7f ff e2 06 call 4000acfc <== NOT EXECUTED 400124e8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 400124ec: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 400124f0: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 400124f4: 40 00 14 6a call 4001769c <_Thread_Change_priority> <== NOT EXECUTED 400124f8: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400124fc: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 <== NOT EXECUTED 40012500: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40012504: c2 24 63 60 st %g1, [ %l1 + 0x360 ] <== NOT EXECUTED 40012508: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 <== NOT EXECUTED 4001250c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40012510: 32 bf ff 74 bne,a 400122e0 <== NOT EXECUTED 40012514: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _Thread_Dispatch(); 40012518: 40 00 15 85 call 40017b2c <_Thread_Dispatch> <== NOT EXECUTED 4001251c: 01 00 00 00 nop <== NOT EXECUTED 40012520: 10 bf ff 70 b 400122e0 <== NOT EXECUTED 40012524: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40012528: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001252c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40012530: 7f ff e1 f3 call 4000acfc <== NOT EXECUTED 40012534: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40012538: 10 bf ff 6a b 400122e0 <== NOT EXECUTED 4001253c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40012540: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40012544: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40012548: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 4001254c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40012550: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40012554: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40012558: 7f ff e1 e9 call 4000acfc <== NOT EXECUTED 4001255c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40012560: 10 bf ff 60 b 400122e0 <== NOT EXECUTED 40012564: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40012568: 7f ff e1 e5 call 4000acfc <== NOT EXECUTED 4001256c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40012570: 10 bf ff 5c b 400122e0 <== NOT EXECUTED 40012574: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator internally */ 40012578: 90 10 00 10 mov %l0, %o0 if ( !status ) { _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 4001257c: 82 00 7f ff add %g1, -1, %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 40012580: b0 10 20 00 clr %i0 40012584: 40 00 24 76 call 4001b75c <_Region_Process_queue> 40012588: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 4001258c: 81 c7 e0 08 ret 40012590: 81 e8 00 00 restore 40006bb0 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 40006bb0: 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 ) ) 40006bb4: aa 96 20 00 orcc %i0, 0, %l5 40006bb8: 02 80 00 12 be 40006c00 40006bbc: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 40006bc0: 80 a7 20 00 cmp %i4, 0 40006bc4: 02 80 00 0f be 40006c00 40006bc8: b0 10 20 09 mov 9, %i0 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 40006bcc: a4 8e a0 40 andcc %i2, 0x40, %l2 40006bd0: 12 80 00 0e bne 40006c08 40006bd4: a0 0e a0 30 and %i2, 0x30, %l0 40006bd8: 80 8e a0 80 btst 0x80, %i2 40006bdc: 12 80 00 0c bne 40006c0c 40006be0: 80 a4 20 10 cmp %l0, 0x10 RTEMS_INLINE_ROUTINE boolean _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 40006be4: 80 a0 00 10 cmp %g0, %l0 40006be8: a2 60 3f ff subx %g0, -1, %l1 if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 40006bec: 80 a4 60 00 cmp %l1, 0 40006bf0: 12 80 00 17 bne 40006c4c 40006bf4: 80 a6 60 01 cmp %i1, 1 40006bf8: 08 80 00 15 bleu 40006c4c 40006bfc: b0 10 20 0a mov 0xa, %i0 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 40006c00: 81 c7 e0 08 ret 40006c04: 81 e8 00 00 restore #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 40006c08: 80 a4 20 10 cmp %l0, 0x10 40006c0c: 12 80 00 0b bne 40006c38 40006c10: 80 a4 20 20 cmp %l0, 0x20 40006c14: 80 8e a0 04 btst 4, %i2 40006c18: 02 80 00 06 be 40006c30 40006c1c: 80 a4 a0 00 cmp %l2, 0 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 40006c20: 02 bf ff f1 be 40006be4 40006c24: 80 8e a0 80 btst 0x80, %i2 40006c28: 02 bf ff f0 be 40006be8 40006c2c: 80 a0 00 10 cmp %g0, %l0 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 40006c30: 81 c7 e0 08 ret 40006c34: 91 e8 20 0b restore %g0, 0xb, %o0 #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 40006c38: 12 bf ff fe bne 40006c30 40006c3c: 80 8e a0 04 btst 4, %i2 40006c40: 12 bf ff f8 bne 40006c20 40006c44: 80 a4 a0 00 cmp %l2, 0 40006c48: 30 bf ff fa b,a 40006c30 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006c4c: 29 10 00 6b sethi %hi(0x4001ac00), %l4 40006c50: c2 05 21 90 ld [ %l4 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> 40006c54: 82 00 60 01 inc %g1 40006c58: c2 25 21 90 st %g1, [ %l4 + 0x190 ] * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 40006c5c: 31 10 00 6b sethi %hi(0x4001ac00), %i0 40006c60: 40 00 07 28 call 40008900 <_Objects_Allocate> 40006c64: 90 16 20 48 or %i0, 0x48, %o0 ! 4001ac48 <_Semaphore_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 40006c68: a6 92 20 00 orcc %o0, 0, %l3 40006c6c: 12 80 00 0e bne 40006ca4 40006c70: 80 a4 60 00 cmp %l1, 0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006c74: c2 05 21 90 ld [ %l4 + 0x190 ], %g1 40006c78: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 40006c7c: 82 00 7f ff add %g1, -1, %g1 40006c80: c2 25 21 90 st %g1, [ %l4 + 0x190 ] 40006c84: c4 05 21 90 ld [ %l4 + 0x190 ], %g2 40006c88: 80 a0 a0 00 cmp %g2, 0 40006c8c: 12 80 00 04 bne 40006c9c 40006c90: 01 00 00 00 nop 40006c94: 40 00 0d 94 call 4000a2e4 <_Thread_Dispatch> 40006c98: 01 00 00 00 nop 40006c9c: 81 c7 e0 08 ret 40006ca0: 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 ) ) { 40006ca4: 12 80 00 1e bne 40006d1c 40006ca8: f4 24 e0 10 st %i2, [ %l3 + 0x10 ] CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 40006cac: 80 a4 a0 00 cmp %l2, 0 40006cb0: 02 80 00 39 be 40006d94 40006cb4: 80 8e a0 80 btst 0x80, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 40006cb8: 82 10 20 02 mov 2, %g1 40006cbc: c2 27 bf e8 st %g1, [ %fp + -24 ] the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 40006cc0: 80 a4 20 10 cmp %l0, 0x10 40006cc4: 12 80 00 39 bne 40006da8 40006cc8: 82 10 20 02 mov 2, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 40006ccc: c2 07 bf e8 ld [ %fp + -24 ], %g1 40006cd0: 80 a0 60 01 cmp %g1, 1 40006cd4: 18 80 00 3d bgu 40006dc8 40006cd8: c0 27 bf e0 clr [ %fp + -32 ] case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; 40006cdc: c0 27 bf e4 clr [ %fp + -28 ] the_mutex_attributes.only_owner_release = FALSE; } the_mutex_attributes.priority_ceiling = priority_ceiling; mutex_status = _CORE_mutex_Initialize( 40006ce0: 82 1e 60 01 xor %i1, 1, %g1 40006ce4: 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; 40006ce8: f6 27 bf ec st %i3, [ %fp + -20 ] mutex_status = _CORE_mutex_Initialize( 40006cec: 94 60 3f ff subx %g0, -1, %o2 40006cf0: 90 04 e0 14 add %l3, 0x14, %o0 40006cf4: 40 00 04 76 call 40007ecc <_CORE_mutex_Initialize> 40006cf8: 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 ) { 40006cfc: 80 a2 20 06 cmp %o0, 6 40006d00: 12 80 00 14 bne 40006d50 40006d04: 90 16 20 48 or %i0, 0x48, %o0 RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 40006d08: 40 00 08 0c call 40008d38 <_Objects_Free> <== NOT EXECUTED 40006d0c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006d10: c2 05 21 90 ld [ %l4 + 0x190 ], %g1 <== NOT EXECUTED 40006d14: 10 bf ff da b 40006c7c <== NOT EXECUTED 40006d18: b0 10 20 13 mov 0x13, %i0 <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) 40006d1c: 80 8e a0 04 btst 4, %i2 40006d20: 22 80 00 04 be,a 40006d30 40006d24: c0 27 bf f4 clr [ %fp + -12 ] the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 40006d28: 82 10 20 01 mov 1, %g1 40006d2c: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 40006d30: 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; 40006d34: c0 27 bf e0 clr [ %fp + -32 ] the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 40006d38: c0 27 bf ec clr [ %fp + -20 ] _CORE_semaphore_Initialize( 40006d3c: 94 10 00 19 mov %i1, %o2 /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 40006d40: 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( 40006d44: 90 04 e0 14 add %l3, 0x14, %o0 40006d48: 40 00 05 1e call 400081c0 <_CORE_semaphore_Initialize> 40006d4c: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006d50: 90 16 20 48 or %i0, 0x48, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40006d54: c6 04 e0 08 ld [ %l3 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006d58: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40006d5c: 03 00 00 3f sethi %hi(0xfc00), %g1 40006d60: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40006d64: 82 08 c0 01 and %g3, %g1, %g1 40006d68: 80 a0 40 02 cmp %g1, %g2 40006d6c: 38 80 00 06 bgu,a 40006d84 40006d70: ea 24 e0 0c st %l5, [ %l3 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40006d74: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006d78: 83 28 60 02 sll %g1, 2, %g1 40006d7c: e6 20 80 01 st %l3, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 40006d80: ea 24 e0 0c st %l5, [ %l3 + 0xc ] &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 40006d84: c6 27 00 00 st %g3, [ %i4 ] 40006d88: c2 05 21 90 ld [ %l4 + 0x190 ], %g1 40006d8c: 10 bf ff bc b 40006c7c 40006d90: b0 10 20 00 clr %i0 if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 40006d94: 02 80 00 08 be 40006db4 40006d98: 80 8e a0 04 btst 4, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 40006d9c: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 40006da0: 10 bf ff c8 b 40006cc0 <== NOT EXECUTED 40006da4: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED the_mutex_attributes.only_owner_release = TRUE; break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; the_mutex_attributes.only_owner_release = FALSE; 40006da8: 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; 40006dac: 10 bf ff cd b 40006ce0 40006db0: c2 27 bf e0 st %g1, [ %fp + -32 ] if ( _Attributes_Is_inherit_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; else if ( _Attributes_Is_priority( attribute_set ) ) 40006db4: 22 bf ff c3 be,a 40006cc0 40006db8: c0 27 bf e8 clr [ %fp + -24 ] the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 40006dbc: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40006dc0: 10 bf ff c0 b 40006cc0 <== NOT EXECUTED 40006dc4: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 40006dc8: 80 a0 60 03 cmp %g1, 3 40006dcc: 18 bf ff c6 bgu 40006ce4 40006dd0: 82 1e 60 01 xor %i1, 1, %g1 case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 40006dd4: 82 10 20 01 mov 1, %g1 40006dd8: 10 bf ff c2 b 40006ce0 40006ddc: c2 27 bf e4 st %g1, [ %fp + -28 ] 40006de0 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 40006de0: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 40006de4: 21 10 00 6b sethi %hi(0x4001ac00), %l0 40006de8: 92 10 00 18 mov %i0, %o1 40006dec: 94 07 bf f4 add %fp, -12, %o2 40006df0: 40 00 08 15 call 40008e44 <_Objects_Get> 40006df4: 90 14 20 48 or %l0, 0x48, %o0 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 40006df8: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006dfc: 80 a0 60 00 cmp %g1, 0 40006e00: 12 80 00 19 bne 40006e64 40006e04: b0 10 00 08 mov %o0, %i0 40006e08: 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) ) { 40006e0c: 84 88 60 30 andcc %g1, 0x30, %g2 40006e10: 22 80 00 1a be,a 40006e78 40006e14: 90 02 20 14 add %o0, 0x14, %o0 if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 40006e18: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 40006e1c: 80 a0 60 00 cmp %g1, 0 40006e20: 12 80 00 35 bne 40006ef4 40006e24: 80 a0 a0 20 cmp %g2, 0x20 40006e28: 02 80 00 34 be 40006ef8 40006e2c: 90 06 20 14 add %i0, 0x14, %o0 40006e30: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006e34: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 4001ad90 <_Thread_Dispatch_disable_level> 40006e38: b0 10 20 0c mov 0xc, %i0 40006e3c: 84 00 bf ff add %g2, -1, %g2 40006e40: c4 20 61 90 st %g2, [ %g1 + 0x190 ] 40006e44: c6 00 61 90 ld [ %g1 + 0x190 ], %g3 40006e48: 80 a0 e0 00 cmp %g3, 0 40006e4c: 12 80 00 28 bne 40006eec 40006e50: 01 00 00 00 nop _Thread_Dispatch(); 40006e54: 40 00 0d 24 call 4000a2e4 <_Thread_Dispatch> 40006e58: 01 00 00 00 nop 40006e5c: 81 c7 e0 08 ret 40006e60: 81 e8 00 00 restore { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 40006e64: 80 a0 60 02 cmp %g1, 2 40006e68: 08 bf ff fd bleu 40006e5c 40006e6c: b0 10 20 04 mov 4, %i0 40006e70: 81 c7 e0 08 ret <== NOT EXECUTED 40006e74: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 40006e78: 92 10 20 00 clr %o1 40006e7c: 40 00 04 cd call 400081b0 <_CORE_semaphore_Flush> 40006e80: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006e84: 90 14 20 48 or %l0, 0x48, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40006e88: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006e8c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40006e90: 05 00 00 3f sethi %hi(0xfc00), %g2 40006e94: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40006e98: 82 08 40 02 and %g1, %g2, %g1 40006e9c: 80 a0 40 03 cmp %g1, %g3 40006ea0: 38 80 00 06 bgu,a 40006eb8 40006ea4: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40006ea8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40006eac: 83 28 60 02 sll %g1, 2, %g1 40006eb0: 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; 40006eb4: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 40006eb8: 40 00 07 a0 call 40008d38 <_Objects_Free> 40006ebc: 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 ) 40006ec0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006ec4: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 4001ad90 <_Thread_Dispatch_disable_level> 40006ec8: b0 10 20 00 clr %i0 40006ecc: 84 00 bf ff add %g2, -1, %g2 40006ed0: c4 20 61 90 st %g2, [ %g1 + 0x190 ] 40006ed4: c6 00 61 90 ld [ %g1 + 0x190 ], %g3 40006ed8: 80 a0 e0 00 cmp %g3, 0 40006edc: 12 80 00 04 bne 40006eec 40006ee0: 01 00 00 00 nop _Thread_Dispatch(); 40006ee4: 40 00 0d 00 call 4000a2e4 <_Thread_Dispatch> 40006ee8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006eec: 81 c7 e0 08 ret 40006ef0: 81 e8 00 00 restore !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 40006ef4: 90 06 20 14 add %i0, 0x14, %o0 40006ef8: 92 10 20 00 clr %o1 40006efc: 40 00 03 f0 call 40007ebc <_CORE_mutex_Flush> 40006f00: 94 10 20 04 mov 4, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006f04: 10 bf ff e1 b 40006e88 40006f08: 90 14 20 48 or %l0, 0x48, %o0 400073ac : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 400073ac: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 400073b0: 11 10 00 71 sethi %hi(0x4001c400), %o0 400073b4: 92 10 00 18 mov %i0, %o1 400073b8: 90 12 23 50 or %o0, 0x350, %o0 400073bc: 40 00 08 75 call 40009590 <_Objects_Get> 400073c0: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 400073c4: c2 07 bf f4 ld [ %fp + -12 ], %g1 400073c8: 80 a0 60 00 cmp %g1, 0 400073cc: 12 80 00 16 bne 40007424 400073d0: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 400073d4: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 400073d8: 80 88 60 30 btst 0x30, %g1 400073dc: 12 80 00 16 bne 40007434 400073e0: 90 02 20 14 add %o0, 0x14, %o0 &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 400073e4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400073e8: 40 00 05 45 call 400088fc <_CORE_semaphore_Flush> <== NOT EXECUTED 400073ec: 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 ) 400073f0: 03 10 00 72 sethi %hi(0x4001c800), %g1 400073f4: c4 00 60 a0 ld [ %g1 + 0xa0 ], %g2 ! 4001c8a0 <_Thread_Dispatch_disable_level> 400073f8: b0 10 20 00 clr %i0 400073fc: 84 00 bf ff add %g2, -1, %g2 40007400: c4 20 60 a0 st %g2, [ %g1 + 0xa0 ] 40007404: c6 00 60 a0 ld [ %g1 + 0xa0 ], %g3 40007408: 80 a0 e0 00 cmp %g3, 0 4000740c: 12 80 00 04 bne 4000741c 40007410: 01 00 00 00 nop _Thread_Dispatch(); 40007414: 40 00 0d 4b call 4000a940 <_Thread_Dispatch> 40007418: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000741c: 81 c7 e0 08 ret 40007420: 81 e8 00 00 restore { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 40007424: 08 bf ff fe bleu 4000741c <== NOT EXECUTED 40007428: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 4000742c: 81 c7 e0 08 ret <== NOT EXECUTED 40007430: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Flush( 40007434: 92 10 20 00 clr %o1 40007438: 40 00 04 74 call 40008608 <_CORE_mutex_Flush> 4000743c: 94 10 20 01 mov 1, %o2 40007440: 30 bf ff ec b,a 400073f0 40006f0c : rtems_status_code rtems_semaphore_obtain( rtems_id id, uint32_t option_set, rtems_interval timeout ) { 40006f0c: 9d e3 bf 90 save %sp, -112, %sp Objects_Id id, Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) 40006f10: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40006f14: 92 10 00 18 mov %i0, %o1 40006f18: 90 12 20 48 or %o0, 0x48, %o0 40006f1c: 94 07 bf f4 add %fp, -12, %o2 40006f20: 40 00 07 ab call 40008dcc <_Objects_Get_isr_disable> 40006f24: 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 ) { 40006f28: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006f2c: 80 a0 60 00 cmp %g1, 0 40006f30: 12 80 00 19 bne 40006f94 40006f34: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 40006f38: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40006f3c: 80 88 60 30 btst 0x30, %g1 40006f40: 12 80 00 1b bne 40006fac 40006f44: 23 10 00 6b sethi %hi(0x4001ac00), %l1 Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40006f48: 27 10 00 6b sethi %hi(0x4001ac00), %l3 40006f4c: e4 04 e2 6c ld [ %l3 + 0x26c ], %l2 ! 4001ae6c <_Thread_Executing> Watchdog_Interval timeout, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 40006f50: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 40006f54: c0 24 a0 34 clr [ %l2 + 0x34 ] if ( the_semaphore->count != 0 ) { 40006f58: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 40006f5c: 80 a0 60 00 cmp %g1, 0 40006f60: 12 80 00 8f bne 4000719c 40006f64: 80 8e 60 01 btst 1, %i1 the_semaphore->count -= 1; _ISR_Enable( level ); return; } if ( !wait ) { 40006f68: 02 80 00 73 be 40007134 40006f6c: 01 00 00 00 nop _ISR_Enable( level ); 40006f70: 7f ff ec 1b call 40001fdc 40006f74: 01 00 00 00 nop executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 40006f78: 82 10 20 01 mov 1, %g1 ! 1 40006f7c: c2 24 a0 34 st %g1, [ %l2 + 0x34 ] id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 40006f80: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 40006f84: 40 00 00 f4 call 40007354 <_Semaphore_Translate_core_semaphore_return_code> 40006f88: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006f8c: 81 c7 e0 08 ret 40006f90: 91 e8 00 08 restore %g0, %o0, %o0 register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 40006f94: 80 a0 60 02 cmp %g1, 2 40006f98: 08 bf ff fd bleu 40006f8c 40006f9c: 90 10 20 04 mov 4, %o0 40006fa0: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Semaphore_Translate_core_semaphore_return_code( _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006fa4: 81 c7 e0 08 ret <== NOT EXECUTED 40006fa8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 40006fac: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 40006fb0: 80 a0 60 00 cmp %g1, 0 40006fb4: 02 80 00 0e be 40006fec 40006fb8: 27 10 00 6b sethi %hi(0x4001ac00), %l3 40006fbc: 80 8e 60 01 btst 1, %i1 40006fc0: 12 80 00 0c bne 40006ff0 40006fc4: c6 04 e2 6c ld [ %l3 + 0x26c ], %g3 40006fc8: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40006fcc: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 4001af70 <_System_state_Current> 40006fd0: 80 a0 a0 01 cmp %g2, 1 40006fd4: 08 80 00 07 bleu 40006ff0 40006fd8: 90 10 20 00 clr %o0 40006fdc: 92 10 20 00 clr %o1 <== NOT EXECUTED 40006fe0: 40 00 06 1b call 4000884c <_Internal_error_Occurred> <== NOT EXECUTED 40006fe4: 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; 40006fe8: 27 10 00 6b sethi %hi(0x4001ac00), %l3 <== NOT EXECUTED 40006fec: c6 04 e2 6c ld [ %l3 + 0x26c ], %g3 ! 4001ae6c <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 40006ff0: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40006ff4: c0 20 e0 34 clr [ %g3 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40006ff8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 40006ffc: 80 a0 60 00 cmp %g1, 0 40007000: 22 80 00 37 be,a 400070dc 40007004: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 40007008: c0 24 20 64 clr [ %l0 + 0x64 ] the_mutex->holder = executing; 4000700c: c6 24 20 70 st %g3, [ %l0 + 0x70 ] the_mutex->holder_id = executing->Object.id; 40007010: c2 00 e0 08 ld [ %g3 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 40007014: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 40007018: 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; 4000701c: c2 24 20 74 st %g1, [ %l0 + 0x74 ] the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40007020: 80 a0 a0 02 cmp %g2, 2 40007024: 12 80 00 24 bne 400070b4 40007028: c8 24 20 68 st %g4, [ %l0 + 0x68 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4000702c: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 40007030: 82 00 60 01 inc %g1 40007034: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40007038: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 4000703c: 80 a0 a0 03 cmp %g2, 3 40007040: 12 80 00 20 bne 400070c0 40007044: 01 00 00 00 nop */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40007048: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 <== NOT EXECUTED current = executing->current_priority; 4000704c: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40007050: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40007054: 02 80 00 79 be 40007238 <== NOT EXECUTED 40007058: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 4000705c: 1a 80 00 6d bcc 40007210 <== NOT EXECUTED 40007060: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007064: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 40007068: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000706c: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40007070: 7f ff eb db call 40001fdc <== NOT EXECUTED 40007074: 01 00 00 00 nop <== NOT EXECUTED _Thread_Change_priority( 40007078: d2 04 20 60 ld [ %l0 + 0x60 ], %o1 <== NOT EXECUTED 4000707c: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 <== NOT EXECUTED 40007080: 40 00 0b 75 call 40009e54 <_Thread_Change_priority> <== NOT EXECUTED 40007084: 94 10 20 00 clr %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007088: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 4000708c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40007090: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 40007094: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 <== NOT EXECUTED 40007098: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000709c: 32 80 00 0c bne,a 400070cc <== NOT EXECUTED 400070a0: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 400070a4: 40 00 0c 90 call 4000a2e4 <_Thread_Dispatch> <== NOT EXECUTED 400070a8: 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( 400070ac: 10 80 00 08 b 400070cc <== NOT EXECUTED 400070b0: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 400070b4: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 400070b8: 22 bf ff de be,a 40007030 <== NOT EXECUTED 400070bc: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 400070c0: 7f ff eb c7 call 40001fdc 400070c4: 01 00 00 00 nop 400070c8: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 400070cc: 40 00 00 98 call 4000732c <_Semaphore_Translate_core_mutex_return_code> 400070d0: 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 */ } 400070d4: 81 c7 e0 08 ret 400070d8: 91 e8 00 08 restore %g0, %o0, %o0 /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 400070dc: 80 a0 40 03 cmp %g1, %g3 400070e0: 12 80 00 0d bne 40007114 400070e4: 80 8e 60 01 btst 1, %i1 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400070e8: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 400070ec: 80 a0 60 00 cmp %g1, 0 400070f0: 12 80 00 40 bne 400071f0 400070f4: 80 a0 60 01 cmp %g1, 1 case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 400070f8: c2 04 20 68 ld [ %l0 + 0x68 ], %g1 400070fc: 82 00 60 01 inc %g1 40007100: c2 24 20 68 st %g1, [ %l0 + 0x68 ] _ISR_Enable( level ); 40007104: 7f ff eb b6 call 40001fdc 40007108: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 4000710c: 10 bf ff f0 b 400070cc 40007110: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 40007114: 02 80 00 28 be 400071b4 40007118: c6 04 e2 6c ld [ %l3 + 0x26c ], %g3 4000711c: 7f ff eb b0 call 40001fdc 40007120: d0 07 bf f0 ld [ %fp + -16 ], %o0 40007124: c4 04 e2 6c ld [ %l3 + 0x26c ], %g2 40007128: 82 10 20 01 mov 1, %g1 4000712c: 10 bf ff e7 b 400070c8 40007130: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007134: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 40007138: 82 00 60 01 inc %g1 4000713c: c2 24 61 90 st %g1, [ %l1 + 0x190 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 40007140: 82 10 20 01 mov 1, %g1 40007144: 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; 40007148: f0 24 a0 20 st %i0, [ %l2 + 0x20 ] return; } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 4000714c: a0 04 20 14 add %l0, 0x14, %l0 40007150: e0 24 a0 44 st %l0, [ %l2 + 0x44 ] executing->Wait.id = id; _ISR_Enable( level ); 40007154: 7f ff eb a2 call 40001fdc 40007158: 01 00 00 00 nop _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 4000715c: 90 10 00 10 mov %l0, %o0 40007160: 92 10 00 1a mov %i2, %o1 40007164: 15 10 00 2b sethi %hi(0x4000ac00), %o2 40007168: 40 00 0d cf call 4000a8a4 <_Thread_queue_Enqueue_with_handler> 4000716c: 94 12 a1 e4 or %o2, 0x1e4, %o2 ! 4000ade4 <_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 ) 40007170: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 40007174: 82 00 7f ff add %g1, -1, %g1 40007178: c2 24 61 90 st %g1, [ %l1 + 0x190 ] 4000717c: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 40007180: 80 a0 a0 00 cmp %g2, 0 40007184: 32 bf ff 80 bne,a 40006f84 40007188: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 4000718c: 40 00 0c 56 call 4000a2e4 <_Thread_Dispatch> 40007190: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 40007194: 10 bf ff 7c b 40006f84 40007198: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; 4000719c: 82 00 7f ff add %g1, -1, %g1 400071a0: c2 24 20 5c st %g1, [ %l0 + 0x5c ] _ISR_Enable( level ); 400071a4: 7f ff eb 8e call 40001fdc 400071a8: 01 00 00 00 nop 400071ac: 10 bf ff 76 b 40006f84 400071b0: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400071b4: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 400071b8: 82 10 20 01 mov 1, %g1 400071bc: c2 24 20 44 st %g1, [ %l0 + 0x44 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 400071c0: f0 20 e0 20 st %i0, [ %g3 + 0x20 ] 400071c4: 84 00 a0 01 inc %g2 400071c8: a0 04 20 14 add %l0, 0x14, %l0 400071cc: c4 24 61 90 st %g2, [ %l1 + 0x190 ] 400071d0: e0 20 e0 44 st %l0, [ %g3 + 0x44 ] 400071d4: 7f ff eb 82 call 40001fdc 400071d8: d0 07 bf f0 ld [ %fp + -16 ], %o0 400071dc: 90 10 00 10 mov %l0, %o0 400071e0: 40 00 03 74 call 40007fb0 <_CORE_mutex_Seize_interrupt_blocking> 400071e4: 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( 400071e8: 10 bf ff b9 b 400070cc 400071ec: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400071f0: 12 bf ff c9 bne 40007114 400071f4: 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; 400071f8: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 400071fc: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40007200: 7f ff eb 77 call 40001fdc <== NOT EXECUTED 40007204: 01 00 00 00 nop <== NOT EXECUTED 40007208: 10 bf ff b1 b 400070cc <== NOT EXECUTED 4000720c: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 40007210: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40007214: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40007218: c0 24 20 68 clr [ %l0 + 0x68 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 4000721c: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 40007220: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40007224: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40007228: 7f ff eb 6d call 40001fdc <== NOT EXECUTED 4000722c: 01 00 00 00 nop <== NOT EXECUTED 40007230: 10 bf ff a7 b 400070cc <== NOT EXECUTED 40007234: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40007238: 7f ff eb 69 call 40001fdc <== NOT EXECUTED 4000723c: 01 00 00 00 nop <== NOT EXECUTED 40007240: 10 bf ff a3 b 400070cc <== NOT EXECUTED 40007244: c2 04 e2 6c ld [ %l3 + 0x26c ], %g1 <== NOT EXECUTED 40007248 : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 40007248: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 4000724c: 11 10 00 6b sethi %hi(0x4001ac00), %o0 40007250: 92 10 00 18 mov %i0, %o1 40007254: 90 12 20 48 or %o0, 0x48, %o0 40007258: 40 00 06 fb call 40008e44 <_Objects_Get> 4000725c: 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 ) { 40007260: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007264: 80 a0 60 00 cmp %g1, 0 40007268: 12 80 00 16 bne 400072c0 4000726c: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 40007270: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40007274: 80 88 60 30 btst 0x30, %g1 40007278: 02 80 00 17 be 400072d4 4000727c: 92 10 00 18 mov %i0, %o1 mutex_status = _CORE_mutex_Surrender( 40007280: 94 10 20 00 clr %o2 40007284: 40 00 03 6f call 40008040 <_CORE_mutex_Surrender> 40007288: 90 02 20 14 add %o0, 0x14, %o0 4000728c: b0 10 00 08 mov %o0, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007290: 03 10 00 6b sethi %hi(0x4001ac00), %g1 40007294: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 4001ad90 <_Thread_Dispatch_disable_level> 40007298: 84 00 bf ff add %g2, -1, %g2 4000729c: c4 20 61 90 st %g2, [ %g1 + 0x190 ] 400072a0: c6 00 61 90 ld [ %g1 + 0x190 ], %g3 400072a4: 80 a0 e0 00 cmp %g3, 0 400072a8: 02 80 00 1e be 40007320 400072ac: 01 00 00 00 nop &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 400072b0: 40 00 00 1f call 4000732c <_Semaphore_Translate_core_mutex_return_code> 400072b4: 90 10 00 18 mov %i0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400072b8: 81 c7 e0 08 ret 400072bc: 91 e8 00 08 restore %g0, %o0, %o0 Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 400072c0: 08 bf ff fe bleu 400072b8 400072c4: 90 10 20 04 mov 4, %o0 400072c8: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400072cc: 81 c7 e0 08 ret <== NOT EXECUTED 400072d0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 400072d4: 94 10 20 00 clr %o2 400072d8: 40 00 03 c9 call 400081fc <_CORE_semaphore_Surrender> 400072dc: 90 02 20 14 add %o0, 0x14, %o0 400072e0: b0 10 00 08 mov %o0, %i0 400072e4: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400072e8: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 4001ad90 <_Thread_Dispatch_disable_level> 400072ec: 84 00 bf ff add %g2, -1, %g2 400072f0: c4 20 61 90 st %g2, [ %g1 + 0x190 ] 400072f4: c6 00 61 90 ld [ %g1 + 0x190 ], %g3 400072f8: 80 a0 e0 00 cmp %g3, 0 400072fc: 02 80 00 06 be 40007314 40007300: 01 00 00 00 nop &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return 40007304: 40 00 00 14 call 40007354 <_Semaphore_Translate_core_semaphore_return_code> 40007308: 90 10 00 18 mov %i0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000730c: 81 c7 e0 08 ret 40007310: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40007314: 40 00 0b f4 call 4000a2e4 <_Thread_Dispatch> 40007318: 01 00 00 00 nop 4000731c: 30 bf ff fa b,a 40007304 40007320: 40 00 0b f1 call 4000a2e4 <_Thread_Dispatch> 40007324: 01 00 00 00 nop 40007328: 30 bf ff e2 b,a 400072b0 400189c0 : */ void rtems_shutdown_executive( uint32_t result ) { 400189c0: 9d e3 bf 98 save %sp, -104, %sp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 400189c4: 33 10 00 6b sethi %hi(0x4001ac00), %i1 400189c8: c2 06 63 70 ld [ %i1 + 0x370 ], %g1 ! 4001af70 <_System_state_Current> 400189cc: 80 a0 60 04 cmp %g1, 4 400189d0: 02 80 00 0c be 40018a00 400189d4: 11 10 00 67 sethi %hi(0x40019c00), %o0 #if defined(__USE_INIT_FINI__) extern void _fini( void ); atexit( _fini ); 400189d8: 7f ff da 31 call 4000f29c 400189dc: 90 12 20 14 or %o0, 0x14, %o0 ! 40019c14 <_fini> * routine which initialized the system. */ RTEMS_INLINE_ROUTINE void _Thread_Stop_multitasking( void ) { _Context_Switch( &_Thread_Executing->Registers, &_Thread_BSP_context ); 400189e0: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400189e4: f0 00 62 6c ld [ %g1 + 0x26c ], %i0 ! 4001ae6c <_Thread_Executing> 400189e8: 84 10 20 04 mov 4, %g2 400189ec: b0 06 20 e0 add %i0, 0xe0, %i0 400189f0: c4 26 63 70 st %g2, [ %i1 + 0x370 ] 400189f4: 33 10 00 6b sethi %hi(0x4001ac00), %i1 400189f8: 7f ff cc 62 call 4000bb80 <_CPU_Context_switch> 400189fc: 93 ee 61 08 restore %i1, 0x108, %o1 40018a00: 81 c7 e0 08 ret <== NOT EXECUTED 40018a04: 81 e8 00 00 restore <== NOT EXECUTED 40012d94 : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 40012d94: 9d e3 bf 90 save %sp, -112, %sp 40012d98: 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 ) 40012d9c: 80 a6 60 00 cmp %i1, 0 40012da0: 02 80 00 1b be 40012e0c 40012da4: 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 ) ) { 40012da8: 80 a2 60 00 cmp %o1, 0 40012dac: 12 80 00 1a bne 40012e14 40012db0: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40012db4: 23 10 00 d1 sethi %hi(0x40034400), %l1 40012db8: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 40012dbc: 82 00 60 01 inc %g1 40012dc0: c2 24 63 60 st %g1, [ %l1 + 0x360 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 40012dc4: 03 10 00 d2 sethi %hi(0x40034800), %g1 40012dc8: e0 00 60 3c ld [ %g1 + 0x3c ], %l0 ! 4003483c <_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; 40012dcc: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 40012dd0: f0 04 21 6c ld [ %l0 + 0x16c ], %i0 asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 40012dd4: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 40012dd8: 80 a0 60 00 cmp %g1, 0 40012ddc: 32 80 00 2c bne,a 40012e8c 40012de0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012de4: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40012de8: b0 10 20 0b mov 0xb, %i0 40012dec: 82 00 7f ff add %g1, -1, %g1 40012df0: c2 24 63 60 st %g1, [ %l1 + 0x360 ] 40012df4: c4 04 63 60 ld [ %l1 + 0x360 ], %g2 40012df8: 80 a0 a0 00 cmp %g2, 0 40012dfc: 12 80 00 0b bne 40012e28 40012e00: 01 00 00 00 nop _Thread_Dispatch(); 40012e04: 40 00 13 4a call 40017b2c <_Thread_Dispatch> 40012e08: 01 00 00 00 nop 40012e0c: 81 c7 e0 08 ret 40012e10: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40012e14: 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 ) { 40012e18: 80 a0 a0 04 cmp %g2, 4 40012e1c: 08 80 00 05 bleu 40012e30 40012e20: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40012e24: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012e28: 81 c7 e0 08 ret 40012e2c: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40012e30: 80 a0 60 01 cmp %g1, 1 40012e34: 12 bf ff f6 bne 40012e0c 40012e38: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40012e3c: 83 28 a0 02 sll %g2, 2, %g1 40012e40: 05 10 00 d1 sethi %hi(0x40034400), %g2 40012e44: 84 10 a2 c0 or %g2, 0x2c0, %g2 ! 400346c0 <_Objects_Information_table> 40012e48: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40012e4c: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40012e50: 80 a2 20 00 cmp %o0, 0 40012e54: 02 bf ff f5 be 40012e28 40012e58: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40012e5c: 40 00 0e 0c call 4001668c <_Objects_Get> 40012e60: 94 07 bf f4 add %fp, -12, %o2 if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40012e64: c2 07 bf f4 ld [ %fp + -12 ], %g1 40012e68: a0 10 00 08 mov %o0, %l0 40012e6c: 80 a0 60 00 cmp %g1, 0 40012e70: 02 bf ff d8 be 40012dd0 40012e74: 23 10 00 d1 sethi %hi(0x40034400), %l1 40012e78: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40012e7c: 18 bf ff e4 bgu 40012e0c <== NOT EXECUTED 40012e80: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40012e84: 81 c7 e0 08 ret <== NOT EXECUTED 40012e88: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { if ( asr->is_enabled ) { 40012e8c: 80 a0 60 00 cmp %g1, 0 40012e90: 02 80 00 19 be 40012ef4 40012e94: 01 00 00 00 nop rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 40012e98: 7f ff df 95 call 4000acec 40012e9c: 01 00 00 00 nop *signal_set |= signals; 40012ea0: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 40012ea4: 82 10 40 19 or %g1, %i1, %g1 40012ea8: c2 26 20 54 st %g1, [ %i0 + 0x54 ] _ISR_Enable( _level ); 40012eac: 7f ff df 94 call 4000acfc 40012eb0: 01 00 00 00 nop _ASR_Post_signals( signal_set, &asr->signals_posted ); the_thread->do_post_task_switch_extension = TRUE; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 40012eb4: 03 10 00 d2 sethi %hi(0x40034800), %g1 40012eb8: c4 00 60 24 ld [ %g1 + 0x24 ], %g2 ! 40034824 <_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; 40012ebc: 86 10 20 01 mov 1, %g3 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 40012ec0: 80 a0 a0 00 cmp %g2, 0 40012ec4: 02 80 00 09 be 40012ee8 40012ec8: c6 24 20 78 st %g3, [ %l0 + 0x78 ] 40012ecc: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40012ed0: c4 00 60 3c ld [ %g1 + 0x3c ], %g2 ! 4003483c <_Thread_Executing> <== NOT EXECUTED 40012ed4: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 40012ed8: 12 80 00 04 bne 40012ee8 <== NOT EXECUTED 40012edc: 01 00 00 00 nop <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 40012ee0: 03 10 00 d2 sethi %hi(0x40034800), %g1 <== NOT EXECUTED 40012ee4: c6 20 60 e8 st %g3, [ %g1 + 0xe8 ] ! 400348e8 <_ISR_Signals_to_thread_executing> <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012ee8: c2 04 63 60 ld [ %l1 + 0x360 ], %g1 40012eec: 10 bf ff c0 b 40012dec 40012ef0: b0 10 20 00 clr %i0 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 40012ef4: 7f ff df 7e call 4000acec 40012ef8: 01 00 00 00 nop *signal_set |= signals; 40012efc: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 40012f00: 82 10 40 19 or %g1, %i1, %g1 40012f04: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _ISR_Enable( _level ); 40012f08: 7f ff df 7d call 4000acfc 40012f0c: 01 00 00 00 nop 40012f10: 30 bf ff f6 b,a 40012ee8 400074e8 : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 400074e8: 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 ) ) { 400074ec: 92 96 20 00 orcc %i0, 0, %o1 400074f0: 12 80 00 20 bne 40007570 400074f4: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400074f8: 21 10 00 6b sethi %hi(0x4001ac00), %l0 400074fc: c2 04 21 90 ld [ %l0 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> 40007500: 82 00 60 01 inc %g1 40007504: c2 24 21 90 st %g1, [ %l0 + 0x190 ] 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; 40007508: 03 10 00 6b sethi %hi(0x4001ac00), %g1 4000750c: f0 00 62 6c ld [ %g1 + 0x26c ], %i0 ! 4001ae6c <_Thread_Executing> 40007510: 07 10 00 6b sethi %hi(0x4001ac00), %g3 Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; 40007514: c0 27 bf f4 clr [ %fp + -12 ] 40007518: a2 10 e0 f0 or %g3, 0xf0, %l1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_information = _Objects_Get_information( the_thread->Object.id ); 4000751c: c2 06 20 08 ld [ %i0 + 8 ], %g1 40007520: 85 30 60 16 srl %g1, 0x16, %g2 40007524: 84 08 a0 1c and %g2, 0x1c, %g2 40007528: c6 04 40 02 ld [ %l1 + %g2 ], %g3 4000752c: 83 30 60 1b srl %g1, 0x1b, %g1 40007530: 83 28 60 02 sll %g1, 2, %g1 40007534: d0 00 c0 01 ld [ %g3 + %g1 ], %o0 if ( !the_information ) { 40007538: 80 a2 20 00 cmp %o0, 0 4000753c: 12 80 00 13 bne 40007588 40007540: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007544: c2 04 21 90 ld [ %l0 + 0x190 ], %g1 <== NOT EXECUTED 40007548: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000754c: c2 24 21 90 st %g1, [ %l0 + 0x190 ] <== NOT EXECUTED 40007550: c4 04 21 90 ld [ %l0 + 0x190 ], %g2 <== NOT EXECUTED 40007554: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40007558: 12 80 00 04 bne 40007568 <== NOT EXECUTED 4000755c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Dispatch(); 40007560: 40 00 0b 61 call 4000a2e4 <_Thread_Dispatch> <== NOT EXECUTED 40007564: 01 00 00 00 nop <== NOT EXECUTED 40007568: 81 c7 e0 08 ret 4000756c: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40007570: 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 ) { 40007574: 80 a0 a0 04 cmp %g2, 4 40007578: 08 80 00 1b bleu 400075e4 4000757c: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007580: 81 c7 e0 08 ret <== NOT EXECUTED 40007584: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INVALID_ID; /* This should never happen if _Thread_Get() works right */ } _Thread_Close( the_information, the_thread ); 40007588: 40 00 0a d9 call 4000a0ec <_Thread_Close> 4000758c: 92 10 00 18 mov %i0, %o1 40007590: c4 06 20 08 ld [ %i0 + 8 ], %g2 40007594: 92 10 00 18 mov %i0, %o1 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 40007598: 83 30 a0 16 srl %g2, 0x16, %g1 4000759c: 82 08 60 1c and %g1, 0x1c, %g1 400075a0: c6 04 40 01 ld [ %l1 + %g1 ], %g3 400075a4: 85 30 a0 1b srl %g2, 0x1b, %g2 400075a8: 85 28 a0 02 sll %g2, 2, %g2 400075ac: 40 00 05 e3 call 40008d38 <_Objects_Free> 400075b0: d0 00 c0 02 ld [ %g3 + %g2 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400075b4: c2 04 21 90 ld [ %l0 + 0x190 ], %g1 400075b8: b0 10 20 00 clr %i0 400075bc: 82 00 7f ff add %g1, -1, %g1 400075c0: c2 24 21 90 st %g1, [ %l0 + 0x190 ] 400075c4: c4 04 21 90 ld [ %l0 + 0x190 ], %g2 400075c8: 80 a0 a0 00 cmp %g2, 0 400075cc: 12 80 00 04 bne 400075dc 400075d0: 01 00 00 00 nop _Thread_Dispatch(); 400075d4: 40 00 0b 44 call 4000a2e4 <_Thread_Dispatch> 400075d8: 01 00 00 00 nop 400075dc: 81 c7 e0 08 ret 400075e0: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 400075e4: 80 a0 60 01 cmp %g1, 1 400075e8: 12 bf ff e0 bne 40007568 400075ec: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400075f0: 85 28 a0 02 sll %g2, 2, %g2 400075f4: 07 10 00 6b sethi %hi(0x4001ac00), %g3 400075f8: a2 10 e0 f0 or %g3, 0xf0, %l1 ! 4001acf0 <_Objects_Information_table> 400075fc: c2 04 40 02 ld [ %l1 + %g2 ], %g1 40007600: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 40007604: 80 a2 20 00 cmp %o0, 0 40007608: 02 bf ff f5 be 400075dc 4000760c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007610: 40 00 06 0d call 40008e44 <_Objects_Get> 40007614: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007618: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000761c: b0 10 00 08 mov %o0, %i0 40007620: 80 a0 60 00 cmp %g1, 0 40007624: 02 bf ff be be 4000751c 40007628: 21 10 00 6b sethi %hi(0x4001ac00), %l0 4000762c: 80 a0 60 02 cmp %g1, 2 40007630: 18 bf ff ce bgu 40007568 40007634: b0 10 20 19 mov 0x19, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40007638: 81 c7 e0 08 ret 4000763c: 91 e8 20 04 restore %g0, 4, %o0 40008df4 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 40008df4: 9d e3 bf 90 save %sp, -112, %sp 40008df8: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !note ) 40008dfc: 80 a6 a0 00 cmp %i2, 0 40008e00: 02 80 00 3b be 40008eec 40008e04: 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 ) 40008e08: 80 a6 60 0f cmp %i1, 0xf 40008e0c: 18 80 00 38 bgu 40008eec 40008e10: 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 ) || 40008e14: 80 a2 60 00 cmp %o1, 0 40008e18: 12 80 00 09 bne 40008e3c 40008e1c: 07 10 00 80 sethi %hi(0x40020000), %g3 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 40008e20: c2 00 e0 7c ld [ %g3 + 0x7c ], %g1 ! 4002007c <_Thread_Executing> 40008e24: 87 2e 60 02 sll %i1, 2, %g3 40008e28: c4 00 61 6c ld [ %g1 + 0x16c ], %g2 40008e2c: c2 00 80 03 ld [ %g2 + %g3 ], %g1 40008e30: c2 26 80 00 st %g1, [ %i2 ] 40008e34: 81 c7 e0 08 ret 40008e38: 91 e8 20 00 restore %g0, 0, %o0 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 40008e3c: c2 00 e0 7c ld [ %g3 + 0x7c ], %g1 40008e40: c4 00 60 08 ld [ %g1 + 8 ], %g2 40008e44: 80 a2 40 02 cmp %o1, %g2 40008e48: 22 bf ff f8 be,a 40008e28 40008e4c: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40008e50: 83 32 60 18 srl %o1, 0x18, %g1 40008e54: 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 ) { 40008e58: 80 a0 a0 04 cmp %g2, 4 40008e5c: 08 80 00 04 bleu 40008e6c 40008e60: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008e64: 81 c7 e0 08 ret <== NOT EXECUTED 40008e68: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40008e6c: 80 a0 60 01 cmp %g1, 1 40008e70: 12 80 00 1f bne 40008eec 40008e74: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40008e78: 83 28 a0 02 sll %g2, 2, %g1 40008e7c: 05 10 00 7f sethi %hi(0x4001fc00), %g2 40008e80: 84 10 a3 00 or %g2, 0x300, %g2 ! 4001ff00 <_Objects_Information_table> 40008e84: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40008e88: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40008e8c: 80 a2 20 00 cmp %o0, 0 40008e90: 02 80 00 17 be 40008eec 40008e94: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40008e98: 40 00 07 53 call 4000abe4 <_Objects_Get> 40008e9c: 94 07 bf f4 add %fp, -12, %o2 *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40008ea0: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008ea4: 80 a0 60 00 cmp %g1, 0 40008ea8: 12 80 00 13 bne 40008ef4 40008eac: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 40008eb0: c6 02 21 6c ld [ %o0 + 0x16c ], %g3 40008eb4: 83 2e 60 02 sll %i1, 2, %g1 40008eb8: c4 00 c0 01 ld [ %g3 + %g1 ], %g2 40008ebc: c4 26 80 00 st %g2, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008ec0: 07 10 00 7f sethi %hi(0x4001fc00), %g3 40008ec4: c2 00 e3 a0 ld [ %g3 + 0x3a0 ], %g1 ! 4001ffa0 <_Thread_Dispatch_disable_level> 40008ec8: b0 10 20 00 clr %i0 40008ecc: 82 00 7f ff add %g1, -1, %g1 40008ed0: c2 20 e3 a0 st %g1, [ %g3 + 0x3a0 ] 40008ed4: c4 00 e3 a0 ld [ %g3 + 0x3a0 ], %g2 40008ed8: 80 a0 a0 00 cmp %g2, 0 40008edc: 12 80 00 04 bne 40008eec 40008ee0: 01 00 00 00 nop _Thread_Dispatch(); 40008ee4: 40 00 0c 2c call 4000bf94 <_Thread_Dispatch> 40008ee8: 01 00 00 00 nop 40008eec: 81 c7 e0 08 ret 40008ef0: 81 e8 00 00 restore *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40008ef4: 18 bf ff fe bgu 40008eec <== NOT EXECUTED 40008ef8: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 40008efc: 81 c7 e0 08 ret <== NOT EXECUTED 40008f00: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40007cd0 : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 40007cd0: 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 ) ) { 40007cd4: 92 96 20 00 orcc %i0, 0, %o1 40007cd8: 12 80 00 19 bne 40007d3c 40007cdc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007ce0: 05 10 00 77 sethi %hi(0x4001dc00), %g2 <== NOT EXECUTED 40007ce4: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 ! 4001de30 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40007ce8: 82 00 60 01 inc %g1 <== NOT EXECUTED 40007cec: c2 20 a2 30 st %g1, [ %g2 + 0x230 ] <== 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; 40007cf0: 03 10 00 77 sethi %hi(0x4001dc00), %g1 <== NOT EXECUTED 40007cf4: d0 00 63 0c ld [ %g1 + 0x30c ], %o0 ! 4001df0c <_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; 40007cf8: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 40007cfc: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40007d00: 80 88 60 02 btst 2, %g1 40007d04: 02 80 00 15 be 40007d58 40007d08: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007d0c: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 40007d10: b0 10 20 0f mov 0xf, %i0 40007d14: 82 00 7f ff add %g1, -1, %g1 40007d18: c2 20 a2 30 st %g1, [ %g2 + 0x230 ] 40007d1c: c4 00 a2 30 ld [ %g2 + 0x230 ], %g2 40007d20: 80 a0 a0 00 cmp %g2, 0 40007d24: 12 80 00 0b bne 40007d50 40007d28: 01 00 00 00 nop _Thread_Dispatch(); 40007d2c: 40 00 0b 4e call 4000aa64 <_Thread_Dispatch> 40007d30: 01 00 00 00 nop 40007d34: 81 c7 e0 08 ret 40007d38: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40007d3c: 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 ) { 40007d40: 80 a0 a0 04 cmp %g2, 4 40007d44: 08 80 00 08 bleu 40007d64 40007d48: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40007d4c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007d50: 81 c7 e0 08 ret <== NOT EXECUTED 40007d54: 81 e8 00 00 restore <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40007d58: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 40007d5c: 10 bf ff ee b 40007d14 40007d60: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40007d64: 80 a0 60 01 cmp %g1, 1 40007d68: 12 bf ff f3 bne 40007d34 40007d6c: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007d70: 83 28 a0 02 sll %g2, 2, %g1 40007d74: 05 10 00 77 sethi %hi(0x4001dc00), %g2 40007d78: 84 10 a1 90 or %g2, 0x190, %g2 ! 4001dd90 <_Objects_Information_table> 40007d7c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40007d80: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40007d84: 80 a2 20 00 cmp %o0, 0 40007d88: 02 bf ff f2 be 40007d50 40007d8c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007d90: 40 00 06 49 call 400096b4 <_Objects_Get> 40007d94: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007d98: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007d9c: 80 a0 60 00 cmp %g1, 0 40007da0: 02 bf ff d7 be 40007cfc 40007da4: 05 10 00 77 sethi %hi(0x4001dc00), %g2 40007da8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40007dac: 18 bf ff e2 bgu 40007d34 <== NOT EXECUTED 40007db0: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40007db4: 81 c7 e0 08 ret <== NOT EXECUTED 40007db8: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 400082ac : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 400082ac: 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 ) ) { 400082b0: 92 96 20 00 orcc %i0, 0, %o1 400082b4: 12 80 00 1b bne 40008320 400082b8: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400082bc: 21 10 00 78 sethi %hi(0x4001e000), %l0 400082c0: c2 04 22 e0 ld [ %l0 + 0x2e0 ], %g1 ! 4001e2e0 <_Thread_Dispatch_disable_level> 400082c4: 82 00 60 01 inc %g1 400082c8: c2 24 22 e0 st %g1, [ %l0 + 0x2e0 ] 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; 400082cc: 03 10 00 78 sethi %hi(0x4001e000), %g1 400082d0: d0 00 63 bc ld [ %g1 + 0x3bc ], %o0 ! 4001e3bc <_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; 400082d4: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 400082d8: 94 10 00 19 mov %i1, %o2 400082dc: 40 00 0e 25 call 4000bb70 <_Thread_Restart> 400082e0: 92 10 20 00 clr %o1 400082e4: 80 a2 20 00 cmp %o0, 0 400082e8: 12 80 00 15 bne 4000833c 400082ec: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400082f0: c2 04 22 e0 ld [ %l0 + 0x2e0 ], %g1 400082f4: b0 10 20 0e mov 0xe, %i0 400082f8: 82 00 7f ff add %g1, -1, %g1 400082fc: c2 24 22 e0 st %g1, [ %l0 + 0x2e0 ] 40008300: c4 04 22 e0 ld [ %l0 + 0x2e0 ], %g2 40008304: 80 a0 a0 00 cmp %g2, 0 40008308: 12 80 00 0b bne 40008334 4000830c: 01 00 00 00 nop _Thread_Dispatch(); 40008310: 40 00 0b 22 call 4000af98 <_Thread_Dispatch> 40008314: 01 00 00 00 nop 40008318: 81 c7 e0 08 ret 4000831c: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40008320: 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 ) { 40008324: 80 a0 a0 04 cmp %g2, 4 40008328: 08 80 00 08 bleu 40008348 4000832c: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40008330: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008334: 81 c7 e0 08 ret <== NOT EXECUTED 40008338: 81 e8 00 00 restore <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000833c: c2 04 22 e0 ld [ %l0 + 0x2e0 ], %g1 40008340: 10 bf ff ee b 400082f8 40008344: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40008348: 80 a0 60 01 cmp %g1, 1 4000834c: 12 bf ff f3 bne 40008318 40008350: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40008354: 83 28 a0 02 sll %g2, 2, %g1 40008358: 05 10 00 78 sethi %hi(0x4001e000), %g2 4000835c: 84 10 a2 40 or %g2, 0x240, %g2 ! 4001e240 <_Objects_Information_table> 40008360: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40008364: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40008368: 80 a2 20 00 cmp %o0, 0 4000836c: 02 bf ff f2 be 40008334 40008370: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40008374: 40 00 06 1d call 40009be8 <_Objects_Get> 40008378: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000837c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008380: 80 a0 60 00 cmp %g1, 0 40008384: 02 bf ff d5 be 400082d8 40008388: 21 10 00 78 sethi %hi(0x4001e000), %l0 4000838c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40008390: 18 bf ff e2 bgu 40008318 <== NOT EXECUTED 40008394: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40008398: 81 c7 e0 08 ret <== NOT EXECUTED 4000839c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40008d68 : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 40008d68: 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 ) ) { 40008d6c: 92 96 20 00 orcc %i0, 0, %o1 40008d70: 12 80 00 19 bne 40008dd4 40008d74: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008d78: 21 10 00 9c sethi %hi(0x40027000), %l0 40008d7c: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 ! 40027360 <_Thread_Dispatch_disable_level> 40008d80: 82 00 60 01 inc %g1 40008d84: c2 24 23 60 st %g1, [ %l0 + 0x360 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 40008d88: 03 10 00 9d sethi %hi(0x40027400), %g1 40008d8c: d0 00 60 3c ld [ %g1 + 0x3c ], %o0 ! 4002743c <_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; 40008d90: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 40008d94: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40008d98: 80 88 60 02 btst 2, %g1 40008d9c: 12 80 00 2b bne 40008e48 40008da0: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008da4: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 40008da8: b0 10 20 0e mov 0xe, %i0 40008dac: 82 00 7f ff add %g1, -1, %g1 40008db0: c2 24 23 60 st %g1, [ %l0 + 0x360 ] 40008db4: c4 04 23 60 ld [ %l0 + 0x360 ], %g2 40008db8: 80 a0 a0 00 cmp %g2, 0 40008dbc: 12 80 00 0b bne 40008de8 40008dc0: 01 00 00 00 nop _Thread_Dispatch(); 40008dc4: 40 00 0c 07 call 4000bde0 <_Thread_Dispatch> 40008dc8: 01 00 00 00 nop 40008dcc: 81 c7 e0 08 ret 40008dd0: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40008dd4: 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 ) { 40008dd8: 80 a0 a0 04 cmp %g2, 4 40008ddc: 08 80 00 05 bleu 40008df0 40008de0: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40008de4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008de8: 81 c7 e0 08 ret 40008dec: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40008df0: 80 a0 60 01 cmp %g1, 1 40008df4: 12 bf ff f6 bne 40008dcc 40008df8: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40008dfc: 83 28 a0 02 sll %g2, 2, %g1 40008e00: 05 10 00 9c sethi %hi(0x40027000), %g2 40008e04: 84 10 a2 c0 or %g2, 0x2c0, %g2 ! 400272c0 <_Objects_Information_table> 40008e08: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40008e0c: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40008e10: 80 a2 20 00 cmp %o0, 0 40008e14: 02 bf ff f5 be 40008de8 40008e18: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40008e1c: 40 00 07 05 call 4000aa30 <_Objects_Get> 40008e20: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40008e24: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008e28: 80 a0 60 00 cmp %g1, 0 40008e2c: 02 bf ff da be 40008d94 40008e30: 21 10 00 9c sethi %hi(0x40027000), %l0 40008e34: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40008e38: 18 bf ff e5 bgu 40008dcc <== NOT EXECUTED 40008e3c: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40008e40: 81 c7 e0 08 ret <== NOT EXECUTED 40008e44: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { _Thread_Resume( the_thread, TRUE ); 40008e48: 40 00 0e f2 call 4000ca10 <_Thread_Resume> 40008e4c: 92 10 20 01 mov 1, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008e50: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 40008e54: 10 bf ff d6 b 40008dac 40008e58: b0 10 20 00 clr %i0 400090d4 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 400090d4: 9d e3 bf 90 save %sp, -112, %sp 400090d8: 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 ) 400090dc: 80 a6 60 0f cmp %i1, 0xf 400090e0: 18 80 00 36 bgu 400091b8 400090e4: 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 ) || 400090e8: 80 a2 60 00 cmp %o1, 0 400090ec: 12 80 00 08 bne 4000910c 400090f0: 07 10 00 80 sethi %hi(0x40020000), %g3 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 400090f4: c2 00 e0 7c ld [ %g3 + 0x7c ], %g1 ! 4002007c <_Thread_Executing> <== NOT EXECUTED 400090f8: c4 00 61 6c ld [ %g1 + 0x16c ], %g2 <== NOT EXECUTED 400090fc: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED 40009100: f4 20 80 03 st %i2, [ %g2 + %g3 ] <== NOT EXECUTED 40009104: 81 c7 e0 08 ret <== NOT EXECUTED 40009108: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 4000910c: c2 00 e0 7c ld [ %g3 + 0x7c ], %g1 40009110: c4 00 60 08 ld [ %g1 + 8 ], %g2 40009114: 80 a2 40 02 cmp %o1, %g2 40009118: 22 bf ff f9 be,a 400090fc 4000911c: c4 00 61 6c ld [ %g1 + 0x16c ], %g2 <== NOT EXECUTED 40009120: 83 32 60 18 srl %o1, 0x18, %g1 40009124: 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 ) { 40009128: 80 a0 a0 04 cmp %g2, 4 4000912c: 08 80 00 04 bleu 4000913c 40009130: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40009134: 81 c7 e0 08 ret <== NOT EXECUTED 40009138: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4000913c: 80 a0 60 01 cmp %g1, 1 40009140: 12 80 00 1e bne 400091b8 40009144: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40009148: 83 28 a0 02 sll %g2, 2, %g1 4000914c: 05 10 00 7f sethi %hi(0x4001fc00), %g2 40009150: 84 10 a3 00 or %g2, 0x300, %g2 ! 4001ff00 <_Objects_Information_table> 40009154: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40009158: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 4000915c: 80 a2 20 00 cmp %o0, 0 40009160: 02 80 00 16 be 400091b8 40009164: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40009168: 40 00 06 9f call 4000abe4 <_Objects_Get> 4000916c: 94 07 bf f4 add %fp, -12, %o2 api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40009170: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009174: 80 a0 60 00 cmp %g1, 0 40009178: 12 80 00 12 bne 400091c0 4000917c: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 40009180: c4 02 21 6c ld [ %o0 + 0x16c ], %g2 40009184: 83 2e 60 02 sll %i1, 2, %g1 40009188: 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 ) 4000918c: 07 10 00 7f sethi %hi(0x4001fc00), %g3 40009190: c2 00 e3 a0 ld [ %g3 + 0x3a0 ], %g1 ! 4001ffa0 <_Thread_Dispatch_disable_level> 40009194: b0 10 20 00 clr %i0 40009198: 82 00 7f ff add %g1, -1, %g1 4000919c: c2 20 e3 a0 st %g1, [ %g3 + 0x3a0 ] 400091a0: c4 00 e3 a0 ld [ %g3 + 0x3a0 ], %g2 400091a4: 80 a0 a0 00 cmp %g2, 0 400091a8: 12 80 00 04 bne 400091b8 400091ac: 01 00 00 00 nop _Thread_Dispatch(); 400091b0: 40 00 0b 79 call 4000bf94 <_Thread_Dispatch> 400091b4: 01 00 00 00 nop 400091b8: 81 c7 e0 08 ret 400091bc: 81 e8 00 00 restore api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 400091c0: 18 bf ff fe bgu 400091b8 <== NOT EXECUTED 400091c4: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 400091c8: 81 c7 e0 08 ret <== NOT EXECUTED 400091cc: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 4000e6bc : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 4000e6bc: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 4000e6c0: 80 a6 60 00 cmp %i1, 0 4000e6c4: 02 80 00 06 be 4000e6dc 4000e6c8: 92 10 00 18 mov %i0, %o1 4000e6cc: 82 06 7f ff add %i1, -1, %g1 4000e6d0: 80 a0 60 fe cmp %g1, 0xfe 4000e6d4: 18 80 00 26 bgu 4000e76c 4000e6d8: b0 10 20 13 mov 0x13, %i0 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 4000e6dc: 80 a6 a0 00 cmp %i2, 0 4000e6e0: 02 80 00 23 be 4000e76c 4000e6e4: 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 ) ) { 4000e6e8: 80 a2 60 00 cmp %o1, 0 4000e6ec: 12 80 00 22 bne 4000e774 4000e6f0: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000e6f4: 21 10 00 b1 sethi %hi(0x4002c400), %l0 4000e6f8: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 ! 4002c410 <_Thread_Dispatch_disable_level> 4000e6fc: 82 00 60 01 inc %g1 4000e700: c2 24 20 10 st %g1, [ %l0 + 0x10 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 4000e704: 03 10 00 b1 sethi %hi(0x4002c400), %g1 4000e708: d0 00 60 ec ld [ %g1 + 0xec ], %o0 ! 4002c4ec <_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; 4000e70c: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: /* XXX convert from core priority */ *old_priority = the_thread->current_priority; 4000e710: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 4000e714: 80 a6 60 00 cmp %i1, 0 4000e718: 02 80 00 0d be 4000e74c 4000e71c: c2 26 80 00 st %g1, [ %i2 ] the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 4000e720: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 4000e724: 80 a0 60 00 cmp %g1, 0 4000e728: 02 80 00 06 be 4000e740 4000e72c: f2 22 20 18 st %i1, [ %o0 + 0x18 ] 4000e730: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 4000e734: 80 a6 40 01 cmp %i1, %g1 4000e738: 1a 80 00 05 bcc 4000e74c 4000e73c: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 4000e740: 92 10 00 19 mov %i1, %o1 4000e744: 40 00 0a 59 call 400110a8 <_Thread_Change_priority> 4000e748: 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 ) 4000e74c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 4000e750: b0 10 20 00 clr %i0 4000e754: 82 00 7f ff add %g1, -1, %g1 4000e758: c2 24 20 10 st %g1, [ %l0 + 0x10 ] 4000e75c: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 4000e760: 80 a0 a0 00 cmp %g2, 0 4000e764: 02 80 00 0a be 4000e78c 4000e768: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000e76c: 81 c7 e0 08 ret 4000e770: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 4000e774: 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 ) { 4000e778: 80 a0 a0 04 cmp %g2, 4 4000e77c: 08 80 00 08 bleu 4000e79c 4000e780: 83 32 60 1b srl %o1, 0x1b, %g1 4000e784: 81 c7 e0 08 ret <== NOT EXECUTED 4000e788: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4000e78c: 40 00 0b 6b call 40011538 <_Thread_Dispatch> 4000e790: 01 00 00 00 nop 4000e794: 81 c7 e0 08 ret 4000e798: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4000e79c: 80 a0 60 01 cmp %g1, 1 4000e7a0: 12 bf ff f3 bne 4000e76c 4000e7a4: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4000e7a8: 83 28 a0 02 sll %g2, 2, %g1 4000e7ac: 05 10 00 b0 sethi %hi(0x4002c000), %g2 4000e7b0: 84 10 a3 70 or %g2, 0x370, %g2 ! 4002c370 <_Objects_Information_table> 4000e7b4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 4000e7b8: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 4000e7bc: 80 a2 20 00 cmp %o0, 0 4000e7c0: 02 bf ff f5 be 4000e794 4000e7c4: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4000e7c8: 40 00 06 34 call 40010098 <_Objects_Get> 4000e7cc: 94 07 bf f4 add %fp, -12, %o2 if ( !old_priority ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000e7d0: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000e7d4: 80 a0 60 00 cmp %g1, 0 4000e7d8: 02 bf ff ce be 4000e710 4000e7dc: 21 10 00 b1 sethi %hi(0x4002c400), %l0 4000e7e0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000e7e4: 18 bf ff e2 bgu 4000e76c <== NOT EXECUTED 4000e7e8: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4000e7ec: 81 c7 e0 08 ret <== NOT EXECUTED 4000e7f0: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 4000777c : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 4000777c: 9d e3 bf 90 save %sp, -112, %sp 40007780: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 40007784: 80 a6 60 00 cmp %i1, 0 40007788: 02 80 00 1e be 40007800 4000778c: 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 ) ) { 40007790: 80 a2 60 00 cmp %o1, 0 40007794: 12 80 00 1d bne 40007808 40007798: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000779c: 21 10 00 6b sethi %hi(0x4001ac00), %l0 400077a0: c2 04 21 90 ld [ %l0 + 0x190 ], %g1 ! 4001ad90 <_Thread_Dispatch_disable_level> 400077a4: 82 00 60 01 inc %g1 400077a8: c2 24 21 90 st %g1, [ %l0 + 0x190 ] 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; 400077ac: 03 10 00 6b sethi %hi(0x4001ac00), %g1 400077b0: d0 00 62 6c ld [ %g1 + 0x26c ], %o0 ! 4001ae6c <_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; 400077b4: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Start( 400077b8: 94 10 00 19 mov %i1, %o2 400077bc: 98 10 00 1a mov %i2, %o4 400077c0: 92 10 20 00 clr %o1 400077c4: 40 00 0e a3 call 4000b250 <_Thread_Start> 400077c8: 96 10 20 00 clr %o3 400077cc: 80 a2 20 00 cmp %o0, 0 400077d0: 12 80 00 2b bne 4000787c 400077d4: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400077d8: c2 04 21 90 ld [ %l0 + 0x190 ], %g1 400077dc: b0 10 20 0e mov 0xe, %i0 400077e0: 82 00 7f ff add %g1, -1, %g1 400077e4: c2 24 21 90 st %g1, [ %l0 + 0x190 ] 400077e8: c4 04 21 90 ld [ %l0 + 0x190 ], %g2 400077ec: 80 a0 a0 00 cmp %g2, 0 400077f0: 12 80 00 0b bne 4000781c 400077f4: 01 00 00 00 nop _Thread_Dispatch(); 400077f8: 40 00 0a bb call 4000a2e4 <_Thread_Dispatch> 400077fc: 01 00 00 00 nop 40007800: 81 c7 e0 08 ret 40007804: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 40007808: 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 ) { 4000780c: 80 a0 a0 04 cmp %g2, 4 40007810: 08 80 00 05 bleu 40007824 40007814: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40007818: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000781c: 81 c7 e0 08 ret 40007820: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40007824: 80 a0 60 01 cmp %g1, 1 40007828: 12 bf ff f6 bne 40007800 4000782c: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007830: 83 28 a0 02 sll %g2, 2, %g1 40007834: 05 10 00 6b sethi %hi(0x4001ac00), %g2 40007838: 84 10 a0 f0 or %g2, 0xf0, %g2 ! 4001acf0 <_Objects_Information_table> 4000783c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40007840: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40007844: 80 a2 20 00 cmp %o0, 0 40007848: 02 bf ff f5 be 4000781c 4000784c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007850: 40 00 05 7d call 40008e44 <_Objects_Get> 40007854: 94 07 bf f4 add %fp, -12, %o2 if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007858: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000785c: 80 a0 60 00 cmp %g1, 0 40007860: 02 bf ff d6 be 400077b8 40007864: 21 10 00 6b sethi %hi(0x4001ac00), %l0 40007868: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000786c: 18 bf ff e5 bgu 40007800 <== NOT EXECUTED 40007870: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40007874: 81 c7 e0 08 ret <== NOT EXECUTED 40007878: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000787c: c2 04 21 90 ld [ %l0 + 0x190 ], %g1 40007880: 10 bf ff d8 b 400077e0 40007884: b0 10 20 00 clr %i0 40008f68 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 40008f68: 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 ) ) { 40008f6c: 92 96 20 00 orcc %i0, 0, %o1 40008f70: 12 80 00 19 bne 40008fd4 40008f74: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008f78: 21 10 00 9c sethi %hi(0x40027000), %l0 40008f7c: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 ! 40027360 <_Thread_Dispatch_disable_level> 40008f80: 82 00 60 01 inc %g1 40008f84: c2 24 23 60 st %g1, [ %l0 + 0x360 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 40008f88: 03 10 00 9d sethi %hi(0x40027400), %g1 40008f8c: d0 00 60 3c ld [ %g1 + 0x3c ], %o0 ! 4002743c <_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; 40008f90: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 40008f94: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40008f98: 80 88 60 02 btst 2, %g1 40008f9c: 02 80 00 2b be 40009048 40008fa0: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40008fa4: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 40008fa8: b0 10 20 0f mov 0xf, %i0 40008fac: 82 00 7f ff add %g1, -1, %g1 40008fb0: c2 24 23 60 st %g1, [ %l0 + 0x360 ] 40008fb4: c4 04 23 60 ld [ %l0 + 0x360 ], %g2 40008fb8: 80 a0 a0 00 cmp %g2, 0 40008fbc: 12 80 00 0b bne 40008fe8 40008fc0: 01 00 00 00 nop _Thread_Dispatch(); 40008fc4: 40 00 0b 87 call 4000bde0 <_Thread_Dispatch> 40008fc8: 01 00 00 00 nop 40008fcc: 81 c7 e0 08 ret 40008fd0: 81 e8 00 00 restore 40008fd4: 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 ) { 40008fd8: 80 a0 a0 04 cmp %g2, 4 40008fdc: 08 80 00 05 bleu 40008ff0 40008fe0: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40008fe4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008fe8: 81 c7 e0 08 ret <== NOT EXECUTED 40008fec: 81 e8 00 00 restore <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 40008ff0: 80 a0 60 01 cmp %g1, 1 40008ff4: 12 bf ff f6 bne 40008fcc 40008ff8: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40008ffc: 83 28 a0 02 sll %g2, 2, %g1 40009000: 05 10 00 9c sethi %hi(0x40027000), %g2 40009004: 84 10 a2 c0 or %g2, 0x2c0, %g2 ! 400272c0 <_Objects_Information_table> 40009008: c6 00 80 01 ld [ %g2 + %g1 ], %g3 4000900c: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40009010: 80 a2 20 00 cmp %o0, 0 40009014: 02 bf ff f5 be 40008fe8 40009018: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4000901c: 40 00 06 85 call 4000aa30 <_Objects_Get> 40009020: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40009024: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009028: 80 a0 60 00 cmp %g1, 0 4000902c: 02 bf ff da be 40008f94 40009030: 21 10 00 9c sethi %hi(0x40027000), %l0 40009034: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40009038: 18 bf ff e5 bgu 40008fcc <== NOT EXECUTED 4000903c: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 40009040: 81 c7 e0 08 ret <== NOT EXECUTED 40009044: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Suspend( the_thread ); 40009048: 40 00 0f b1 call 4000cf0c <_Thread_Suspend> 4000904c: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40009050: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 40009054: 10 bf ff d6 b 40008fac 40009058: b0 10 20 00 clr %i0 4001b5d4 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 4001b5d4: 9d e3 bf 90 save %sp, -112, %sp 4001b5d8: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 4001b5dc: 80 a6 60 00 cmp %i1, 0 4001b5e0: 02 80 00 22 be 4001b668 4001b5e4: 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 ) ) { 4001b5e8: 80 a2 60 00 cmp %o1, 0 4001b5ec: 12 80 00 21 bne 4001b670 4001b5f0: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001b5f4: 21 10 00 f8 sethi %hi(0x4003e000), %l0 4001b5f8: c2 04 23 20 ld [ %l0 + 0x320 ], %g1 ! 4003e320 <_Thread_Dispatch_disable_level> 4001b5fc: 82 00 60 01 inc %g1 4001b600: c2 24 23 20 st %g1, [ %l0 + 0x320 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 4001b604: 03 10 00 f8 sethi %hi(0x4003e000), %g1 4001b608: f0 00 63 fc ld [ %g1 + 0x3fc ], %i0 ! 4003e3fc <_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; 4001b60c: c0 27 bf f4 clr [ %fp + -12 ] /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 4001b610: c4 06 21 7c ld [ %i0 + 0x17c ], %g2 while (tvp) { 4001b614: 80 a0 a0 00 cmp %g2, 0 4001b618: 32 80 00 08 bne,a 4001b638 4001b61c: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 4001b620: 10 80 00 1a b 4001b688 4001b624: 11 10 00 f8 sethi %hi(0x4003e000), %o0 4001b628: 84 90 60 00 orcc %g1, 0, %g2 <== NOT EXECUTED 4001b62c: 02 80 00 17 be 4001b688 <== NOT EXECUTED 4001b630: 11 10 00 f8 sethi %hi(0x4003e000), %o0 <== NOT EXECUTED if (tvp->ptr == ptr) { 4001b634: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 4001b638: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 4001b63c: 32 bf ff fb bne,a 4001b628 <== NOT EXECUTED 4001b640: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED tvp->dtor = dtor; 4001b644: f4 20 a0 10 st %i2, [ %g2 + 0x10 ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001b648: c2 04 23 20 ld [ %l0 + 0x320 ], %g1 _Thread_Dispatch(); 4001b64c: b0 10 20 00 clr %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001b650: 82 00 7f ff add %g1, -1, %g1 4001b654: c2 24 23 20 st %g1, [ %l0 + 0x320 ] 4001b658: c4 04 23 20 ld [ %l0 + 0x320 ], %g2 4001b65c: 80 a0 a0 00 cmp %g2, 0 4001b660: 02 80 00 1c be 4001b6d0 4001b664: 01 00 00 00 nop the_thread->task_variables = new; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001b668: 81 c7 e0 08 ret <== NOT EXECUTED 4001b66c: 81 e8 00 00 restore <== NOT EXECUTED 4001b670: 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 ) { 4001b674: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 4001b678: 08 80 00 21 bleu 4001b6fc <== NOT EXECUTED 4001b67c: 83 32 60 1b srl %o1, 0x1b, %g1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4001b680: 81 c7 e0 08 ret <== NOT EXECUTED 4001b684: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 4001b688: 92 10 20 14 mov 0x14, %o1 4001b68c: 7f ff c1 71 call 4000bc50 <_Heap_Allocate> 4001b690: 90 12 23 6c or %o0, 0x36c, %o0 * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 4001b694: 80 a2 20 00 cmp %o0, 0 4001b698: 32 80 00 12 bne,a 4001b6e0 4001b69c: c4 06 21 7c ld [ %i0 + 0x17c ], %g2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001b6a0: c2 04 23 20 ld [ %l0 + 0x320 ], %g1 <== NOT EXECUTED 4001b6a4: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED 4001b6a8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001b6ac: c2 24 23 20 st %g1, [ %l0 + 0x320 ] <== NOT EXECUTED 4001b6b0: c4 04 23 20 ld [ %l0 + 0x320 ], %g2 <== NOT EXECUTED 4001b6b4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001b6b8: 12 80 00 08 bne 4001b6d8 <== NOT EXECUTED 4001b6bc: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4001b6c0: 7f ff c9 98 call 4000dd20 <_Thread_Dispatch> <== NOT EXECUTED 4001b6c4: 01 00 00 00 nop <== NOT EXECUTED 4001b6c8: 81 c7 e0 08 ret <== NOT EXECUTED 4001b6cc: 81 e8 00 00 restore <== NOT EXECUTED 4001b6d0: 7f ff c9 94 call 4000dd20 <_Thread_Dispatch> 4001b6d4: b0 10 20 00 clr %i0 4001b6d8: 81 c7 e0 08 ret 4001b6dc: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 4001b6e0: 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; 4001b6e4: d0 26 21 7c st %o0, [ %i0 + 0x17c ] _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 4001b6e8: c2 22 20 08 st %g1, [ %o0 + 8 ] new->ptr = ptr; 4001b6ec: f2 22 20 04 st %i1, [ %o0 + 4 ] new->dtor = dtor; 4001b6f0: f4 22 20 10 st %i2, [ %o0 + 0x10 ] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 4001b6f4: 10 bf ff d5 b 4001b648 4001b6f8: c4 22 00 00 st %g2, [ %o0 ] *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4001b6fc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001b700: 12 bf ff e0 bne 4001b680 <== NOT EXECUTED 4001b704: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4001b708: 05 10 00 f8 sethi %hi(0x4003e000), %g2 <== NOT EXECUTED 4001b70c: 84 10 a2 80 or %g2, 0x280, %g2 ! 4003e280 <_Objects_Information_table> <== NOT EXECUTED 4001b710: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 4001b714: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 4001b718: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b71c: 02 bf ff d9 be 4001b680 <== NOT EXECUTED 4001b720: 01 00 00 00 nop <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4001b724: 7f ff c3 fb call 4000c710 <_Objects_Get> <== NOT EXECUTED 4001b728: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 4001b72c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4001b730: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 4001b734: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001b738: 02 bf ff b6 be 4001b610 <== NOT EXECUTED 4001b73c: 21 10 00 f8 sethi %hi(0x4003e000), %l0 <== NOT EXECUTED 4001b740: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4001b744: 18 bf ff c9 bgu 4001b668 <== NOT EXECUTED 4001b748: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 4001b74c: 30 bf ff cd b,a 4001b680 <== NOT EXECUTED 4001b750 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 4001b750: 9d e3 bf 90 save %sp, -112, %sp Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 4001b754: 80 a6 60 00 cmp %i1, 0 4001b758: 02 80 00 50 be 4001b898 4001b75c: 92 10 00 18 mov %i0, %o1 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 4001b760: 80 a6 20 00 cmp %i0, 0 4001b764: 12 80 00 26 bne 4001b7fc 4001b768: 83 36 20 18 srl %i0, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001b76c: 21 10 00 f8 sethi %hi(0x4003e000), %l0 4001b770: c2 04 23 20 ld [ %l0 + 0x320 ], %g1 ! 4003e320 <_Thread_Dispatch_disable_level> 4001b774: 82 00 60 01 inc %g1 4001b778: c2 24 23 20 st %g1, [ %l0 + 0x320 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 4001b77c: 03 10 00 f8 sethi %hi(0x4003e000), %g1 4001b780: d0 00 63 fc ld [ %g1 + 0x3fc ], %o0 ! 4003e3fc <_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; 4001b784: c0 27 bf f4 clr [ %fp + -12 ] default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; 4001b788: c6 02 21 7c ld [ %o0 + 0x17c ], %g3 while (tvp) { 4001b78c: 80 a0 e0 00 cmp %g3, 0 4001b790: 02 80 00 10 be 4001b7d0 4001b794: 01 00 00 00 nop if (tvp->ptr == ptr) { 4001b798: c2 00 e0 04 ld [ %g3 + 4 ], %g1 4001b79c: 80 a0 40 19 cmp %g1, %i1 4001b7a0: 32 80 00 09 bne,a 4001b7c4 4001b7a4: c4 00 c0 00 ld [ %g3 ], %g2 <== NOT EXECUTED if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 4001b7a8: 10 80 00 5b b 4001b914 4001b7ac: c2 00 c0 00 ld [ %g3 ], %g1 return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 4001b7b0: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 4001b7b4: 02 80 00 18 be 4001b814 <== NOT EXECUTED 4001b7b8: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4001b7bc: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED _Workspace_Free(tvp); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 4001b7c0: c4 00 c0 00 ld [ %g3 ], %g2 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 4001b7c4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001b7c8: 32 bf ff fa bne,a 4001b7b0 <== NOT EXECUTED 4001b7cc: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001b7d0: c2 04 23 20 ld [ %l0 + 0x320 ], %g1 <== NOT EXECUTED 4001b7d4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001b7d8: c2 24 23 20 st %g1, [ %l0 + 0x320 ] <== NOT EXECUTED 4001b7dc: c4 04 23 20 ld [ %l0 + 0x320 ], %g2 <== NOT EXECUTED 4001b7e0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001b7e4: 12 80 00 2d bne 4001b898 <== NOT EXECUTED 4001b7e8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4001b7ec: 7f ff c9 4d call 4000dd20 <_Thread_Dispatch> <== NOT EXECUTED 4001b7f0: b0 10 20 09 mov 9, %i0 ! 9 <== NOT EXECUTED 4001b7f4: 81 c7 e0 08 ret <== NOT EXECUTED 4001b7f8: 81 e8 00 00 restore <== NOT EXECUTED 4001b7fc: 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 ) { 4001b800: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 4001b804: 08 80 00 2e bleu 4001b8bc <== NOT EXECUTED 4001b808: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001b80c: 81 c7 e0 08 ret <== NOT EXECUTED 4001b810: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 4001b814: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED 4001b818: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(the_thread)) { 4001b81c: 03 10 00 f8 sethi %hi(0x4003e000), %g1 4001b820: c4 00 63 fc ld [ %g1 + 0x3fc ], %g2 ! 4003e3fc <_Thread_Executing> 4001b824: 80 a2 00 02 cmp %o0, %g2 4001b828: 32 80 00 1e bne,a 4001b8a0 4001b82c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED if (tvp->dtor) 4001b830: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 4001b834: 80 a0 a0 00 cmp %g2, 0 4001b838: 22 80 00 06 be,a 4001b850 4001b83c: c4 06 20 04 ld [ %i0 + 4 ], %g2 (*tvp->dtor)(*tvp->ptr); 4001b840: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 4001b844: 9f c0 80 00 call %g2 <== NOT EXECUTED 4001b848: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 4001b84c: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED 4001b850: c2 06 20 08 ld [ %i0 + 8 ], %g1 4001b854: c2 20 80 00 st %g1, [ %g2 ] RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4001b858: 92 10 00 18 mov %i0, %o1 4001b85c: 11 10 00 f8 sethi %hi(0x4003e000), %o0 4001b860: 7f ff c1 2e call 4000bd18 <_Heap_Free> 4001b864: 90 12 23 6c or %o0, 0x36c, %o0 ! 4003e36c <_Workspace_Area> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001b868: c2 04 23 20 ld [ %l0 + 0x320 ], %g1 4001b86c: b0 10 20 00 clr %i0 4001b870: 82 00 7f ff add %g1, -1, %g1 4001b874: c2 24 23 20 st %g1, [ %l0 + 0x320 ] 4001b878: c4 04 23 20 ld [ %l0 + 0x320 ], %g2 4001b87c: 80 a0 a0 00 cmp %g2, 0 4001b880: 12 80 00 04 bne 4001b890 4001b884: 01 00 00 00 nop _Thread_Dispatch(); 4001b888: 7f ff c9 26 call 4000dd20 <_Thread_Dispatch> 4001b88c: 01 00 00 00 nop 4001b890: 81 c7 e0 08 ret 4001b894: 81 e8 00 00 restore 4001b898: 81 c7 e0 08 ret <== NOT EXECUTED 4001b89c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED } else { if (tvp->dtor) 4001b8a0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001b8a4: 22 bf ff ee be,a 4001b85c <== NOT EXECUTED 4001b8a8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 4001b8ac: 9f c0 40 00 call %g1 <== NOT EXECUTED 4001b8b0: d0 06 20 0c ld [ %i0 + 0xc ], %o0 <== NOT EXECUTED 4001b8b4: 10 bf ff ea b 4001b85c <== NOT EXECUTED 4001b8b8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4001b8bc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001b8c0: 32 bf ff cd bne,a 4001b7f4 <== NOT EXECUTED 4001b8c4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4001b8c8: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 4001b8cc: 05 10 00 f8 sethi %hi(0x4003e000), %g2 <== NOT EXECUTED 4001b8d0: 84 10 a2 80 or %g2, 0x280, %g2 ! 4003e280 <_Objects_Information_table> <== NOT EXECUTED 4001b8d4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 4001b8d8: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 4001b8dc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b8e0: 22 bf ff c5 be,a 4001b7f4 <== NOT EXECUTED 4001b8e4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4001b8e8: 7f ff c3 8a call 4000c710 <_Objects_Get> <== NOT EXECUTED 4001b8ec: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 4001b8f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4001b8f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001b8f8: 02 bf ff a4 be 4001b788 <== NOT EXECUTED 4001b8fc: 21 10 00 f8 sethi %hi(0x4003e000), %l0 <== NOT EXECUTED 4001b900: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4001b904: 18 bf ff bc bgu 4001b7f4 <== NOT EXECUTED 4001b908: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4001b90c: 81 c7 e0 08 ret <== NOT EXECUTED 4001b910: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 4001b914: b0 10 00 03 mov %g3, %i0 4001b918: 10 bf ff c1 b 4001b81c 4001b91c: c2 22 21 7c st %g1, [ %o0 + 0x17c ] 4001b920 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 4001b920: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 4001b924: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4001b928: 02 80 00 3b be 4001ba14 <== NOT EXECUTED 4001b92c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 4001b930: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 4001b934: 02 80 00 38 be 4001ba14 <== NOT EXECUTED 4001b938: 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 ) ) { 4001b93c: 12 80 00 21 bne 4001b9c0 <== NOT EXECUTED 4001b940: 83 36 20 18 srl %i0, 0x18, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001b944: 05 10 00 f8 sethi %hi(0x4003e000), %g2 <== NOT EXECUTED 4001b948: c2 00 a3 20 ld [ %g2 + 0x320 ], %g1 ! 4003e320 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4001b94c: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001b950: c2 20 a3 20 st %g1, [ %g2 + 0x320 ] <== NOT EXECUTED Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 4001b954: 03 10 00 f8 sethi %hi(0x4003e000), %g1 <== NOT EXECUTED 4001b958: d0 00 63 fc ld [ %g1 + 0x3fc ], %o0 ! 4003e3fc <_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; 4001b95c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 4001b960: d0 02 21 7c ld [ %o0 + 0x17c ], %o0 <== NOT EXECUTED while (tvp) { 4001b964: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b968: 32 80 00 07 bne,a 4001b984 <== NOT EXECUTED 4001b96c: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4001b970: 30 80 00 1a b,a 4001b9d8 <== NOT EXECUTED 4001b974: 90 90 60 00 orcc %g1, 0, %o0 <== NOT EXECUTED 4001b978: 02 80 00 18 be 4001b9d8 <== NOT EXECUTED 4001b97c: 01 00 00 00 nop <== NOT EXECUTED if (tvp->ptr == ptr) { 4001b980: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4001b984: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 4001b988: 32 bf ff fb bne,a 4001b974 <== NOT EXECUTED 4001b98c: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 4001b990: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED 4001b994: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001b998: c2 00 a3 20 ld [ %g2 + 0x320 ], %g1 <== NOT EXECUTED 4001b99c: b0 10 20 00 clr %i0 <== NOT EXECUTED 4001b9a0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001b9a4: c2 20 a3 20 st %g1, [ %g2 + 0x320 ] <== NOT EXECUTED 4001b9a8: c4 00 a3 20 ld [ %g2 + 0x320 ], %g2 <== NOT EXECUTED 4001b9ac: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001b9b0: 02 80 00 15 be 4001ba04 <== NOT EXECUTED 4001b9b4: 01 00 00 00 nop <== NOT EXECUTED } _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001b9b8: 81 c7 e0 08 ret <== NOT EXECUTED 4001b9bc: 81 e8 00 00 restore <== NOT EXECUTED 4001b9c0: 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 ) { 4001b9c4: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 4001b9c8: 08 80 00 15 bleu 4001ba1c <== NOT EXECUTED 4001b9cc: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED 4001b9d0: 81 c7 e0 08 ret <== NOT EXECUTED 4001b9d4: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001b9d8: c2 00 a3 20 ld [ %g2 + 0x320 ], %g1 <== NOT EXECUTED 4001b9dc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001b9e0: c2 20 a3 20 st %g1, [ %g2 + 0x320 ] <== NOT EXECUTED 4001b9e4: c4 00 a3 20 ld [ %g2 + 0x320 ], %g2 <== NOT EXECUTED 4001b9e8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001b9ec: 12 80 00 0a bne 4001ba14 <== NOT EXECUTED 4001b9f0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4001b9f4: 7f ff c8 cb call 4000dd20 <_Thread_Dispatch> <== NOT EXECUTED 4001b9f8: b0 10 20 09 mov 9, %i0 ! 9 <== NOT EXECUTED 4001b9fc: 81 c7 e0 08 ret <== NOT EXECUTED 4001ba00: 81 e8 00 00 restore <== NOT EXECUTED 4001ba04: 7f ff c8 c7 call 4000dd20 <_Thread_Dispatch> <== NOT EXECUTED 4001ba08: 01 00 00 00 nop <== NOT EXECUTED 4001ba0c: 81 c7 e0 08 ret <== NOT EXECUTED 4001ba10: 81 e8 00 00 restore <== NOT EXECUTED 4001ba14: 81 c7 e0 08 ret <== NOT EXECUTED 4001ba18: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 4001ba1c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001ba20: 32 bf ff e6 bne,a 4001b9b8 <== NOT EXECUTED 4001ba24: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4001ba28: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 4001ba2c: 05 10 00 f8 sethi %hi(0x4003e000), %g2 <== NOT EXECUTED 4001ba30: 84 10 a2 80 or %g2, 0x280, %g2 ! 4003e280 <_Objects_Information_table> <== NOT EXECUTED 4001ba34: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 4001ba38: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 4001ba3c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001ba40: 22 bf ff de be,a 4001b9b8 <== NOT EXECUTED 4001ba44: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4001ba48: 7f ff c3 32 call 4000c710 <_Objects_Get> <== NOT EXECUTED 4001ba4c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 4001ba50: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4001ba54: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001ba58: 02 bf ff c2 be 4001b960 <== NOT EXECUTED 4001ba5c: 05 10 00 f8 sethi %hi(0x4003e000), %g2 <== NOT EXECUTED 4001ba60: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4001ba64: 18 bf ff d5 bgu 4001b9b8 <== NOT EXECUTED 4001ba68: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 4001ba6c: 81 c7 e0 08 ret <== NOT EXECUTED 4001ba70: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40013bcc : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 40013bcc: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40013bd0: 11 10 00 d2 sethi %hi(0x40034800), %o0 40013bd4: 92 10 00 18 mov %i0, %o1 40013bd8: 90 12 22 cc or %o0, 0x2cc, %o0 40013bdc: 40 00 0a ac call 4001668c <_Objects_Get> 40013be0: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40013be4: c2 07 bf f4 ld [ %fp + -12 ], %g1 40013be8: 80 a0 60 00 cmp %g1, 0 40013bec: 12 80 00 11 bne 40013c30 40013bf0: 82 18 60 02 xor %g1, 2, %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 40013bf4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 40013bf8: 80 a0 60 04 cmp %g1, 4 40013bfc: 12 80 00 16 bne 40013c54 40013c00: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40013c04: 03 10 00 d1 sethi %hi(0x40034400), %g1 <== NOT EXECUTED 40013c08: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40013c0c: b0 10 20 00 clr %i0 <== NOT EXECUTED 40013c10: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 40013c14: c4 20 63 60 st %g2, [ %g1 + 0x360 ] <== NOT EXECUTED 40013c18: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 <== NOT EXECUTED 40013c1c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40013c20: 02 80 00 09 be 40013c44 <== NOT EXECUTED 40013c24: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40013c28: 81 c7 e0 08 ret <== NOT EXECUTED 40013c2c: 81 e8 00 00 restore <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40013c30: 80 a0 00 01 cmp %g0, %g1 40013c34: 84 60 20 00 subx %g0, 0, %g2 40013c38: b0 08 a0 15 and %g2, 0x15, %i0 40013c3c: 81 c7 e0 08 ret 40013c40: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 40013c44: 40 00 0f ba call 40017b2c <_Thread_Dispatch> 40013c48: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40013c4c: 81 c7 e0 08 ret 40013c50: 81 e8 00 00 restore case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) (void) _Watchdog_Remove( &the_timer->Ticker ); 40013c54: 40 00 16 7e call 4001964c <_Watchdog_Remove> 40013c58: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40013c5c: 03 10 00 d1 sethi %hi(0x40034400), %g1 40013c60: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 40013c64: b0 10 20 00 clr %i0 40013c68: 84 00 bf ff add %g2, -1, %g2 40013c6c: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 40013c70: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 40013c74: 80 a0 e0 00 cmp %g3, 0 40013c78: 12 bf ff f5 bne 40013c4c 40013c7c: 01 00 00 00 nop 40013c80: 30 bf ff f1 b,a 40013c44 40013d70 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 40013d70: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40013d74: 21 10 00 d2 sethi %hi(0x40034800), %l0 40013d78: 92 10 00 18 mov %i0, %o1 40013d7c: 94 07 bf f4 add %fp, -12, %o2 40013d80: 40 00 0a 43 call 4001668c <_Objects_Get> 40013d84: 90 14 22 cc or %l0, 0x2cc, %o0 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40013d88: c2 07 bf f4 ld [ %fp + -12 ], %g1 40013d8c: 80 a0 60 00 cmp %g1, 0 40013d90: 12 80 00 1f bne 40013e0c 40013d94: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40013d98: a0 14 22 cc or %l0, 0x2cc, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40013d9c: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40013da0: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 40013da4: 05 00 00 3f sethi %hi(0xfc00), %g2 40013da8: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40013dac: 82 08 40 02 and %g1, %g2, %g1 40013db0: 80 a0 40 03 cmp %g1, %g3 40013db4: 38 80 00 06 bgu,a 40013dcc 40013db8: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40013dbc: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 40013dc0: 83 28 60 02 sll %g1, 2, %g1 40013dc4: 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; 40013dc8: 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 ); 40013dcc: 40 00 16 20 call 4001964c <_Watchdog_Remove> 40013dd0: 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 ); 40013dd4: 90 10 00 10 mov %l0, %o0 40013dd8: 40 00 09 d6 call 40016530 <_Objects_Free> 40013ddc: 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 ) 40013de0: 03 10 00 d1 sethi %hi(0x40034400), %g1 40013de4: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 40013de8: b0 10 20 00 clr %i0 40013dec: 84 00 bf ff add %g2, -1, %g2 40013df0: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 40013df4: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 40013df8: 80 a0 e0 00 cmp %g3, 0 40013dfc: 02 80 00 0a be 40013e24 40013e00: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40013e04: 81 c7 e0 08 ret <== NOT EXECUTED 40013e08: 81 e8 00 00 restore <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40013e0c: 82 18 60 02 xor %g1, 2, %g1 40013e10: 80 a0 00 01 cmp %g0, %g1 40013e14: 84 60 20 00 subx %g0, 0, %g2 40013e18: b0 08 a0 15 and %g2, 0x15, %i0 40013e1c: 81 c7 e0 08 ret 40013e20: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 40013e24: 40 00 0f 42 call 40017b2c <_Thread_Dispatch> 40013e28: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40013e2c: 81 c7 e0 08 ret 40013e30: 81 e8 00 00 restore 40013e34 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 40013e34: 9d e3 bf 90 save %sp, -112, %sp 40013e38: a4 10 00 18 mov %i0, %l2 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 40013e3c: 80 a6 60 00 cmp %i1, 0 40013e40: 02 80 00 3e be 40013f38 40013e44: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( !routine ) 40013e48: 80 a6 a0 00 cmp %i2, 0 40013e4c: 02 80 00 3b be 40013f38 40013e50: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40013e54: 11 10 00 d2 sethi %hi(0x40034800), %o0 40013e58: 92 10 00 12 mov %l2, %o1 40013e5c: 90 12 22 cc or %o0, 0x2cc, %o0 40013e60: 40 00 0a 0b call 4001668c <_Objects_Get> 40013e64: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40013e68: c2 07 bf f4 ld [ %fp + -12 ], %g1 40013e6c: 80 a0 60 00 cmp %g1, 0 40013e70: 12 80 00 17 bne 40013ecc 40013e74: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 40013e78: a2 02 20 10 add %o0, 0x10, %l1 40013e7c: 40 00 15 f4 call 4001964c <_Watchdog_Remove> 40013e80: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 40013e84: 7f ff db 9a call 4000acec 40013e88: 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 ) { 40013e8c: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 40013e90: 80 a0 60 00 cmp %g1, 0 40013e94: 22 80 00 14 be,a 40013ee4 40013e98: f4 24 20 2c st %i2, [ %l0 + 0x2c ] _ISR_Enable( level ); 40013e9c: 7f ff db 98 call 4000acfc <== NOT EXECUTED 40013ea0: 01 00 00 00 nop <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40013ea4: 03 10 00 d1 sethi %hi(0x40034400), %g1 <== NOT EXECUTED 40013ea8: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40013eac: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 40013eb0: c4 20 63 60 st %g2, [ %g1 + 0x360 ] <== NOT EXECUTED 40013eb4: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 <== NOT EXECUTED 40013eb8: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40013ebc: 02 80 00 1d be 40013f30 <== NOT EXECUTED 40013ec0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40013ec4: 81 c7 e0 08 ret <== NOT EXECUTED 40013ec8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40013ecc: 82 18 60 02 xor %g1, 2, %g1 40013ed0: 80 a0 00 01 cmp %g0, %g1 40013ed4: 84 60 20 00 subx %g0, 0, %g2 40013ed8: b0 08 a0 15 and %g2, 0x15, %i0 40013edc: 81 c7 e0 08 ret 40013ee0: 91 ee 20 04 restore %i0, 4, %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 40013ee4: e4 24 20 30 st %l2, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 40013ee8: 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; 40013eec: c0 24 20 38 clr [ %l0 + 0x38 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40013ef0: c0 24 20 18 clr [ %l0 + 0x18 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 40013ef4: 7f ff db 82 call 4000acfc 40013ef8: 01 00 00 00 nop ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40013efc: 92 10 00 11 mov %l1, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40013f00: f2 24 20 1c st %i1, [ %l0 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40013f04: 11 10 00 d2 sethi %hi(0x40034800), %o0 40013f08: 40 00 15 67 call 400194a4 <_Watchdog_Insert> 40013f0c: 90 12 20 5c or %o0, 0x5c, %o0 ! 4003485c <_Watchdog_Ticks_chain> 40013f10: 05 10 00 d1 sethi %hi(0x40034400), %g2 40013f14: c2 00 a3 60 ld [ %g2 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 40013f18: 82 00 7f ff add %g1, -1, %g1 40013f1c: c2 20 a3 60 st %g1, [ %g2 + 0x360 ] 40013f20: c6 00 a3 60 ld [ %g2 + 0x360 ], %g3 40013f24: 80 a0 e0 00 cmp %g3, 0 40013f28: 32 80 00 04 bne,a 40013f38 40013f2c: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Dispatch(); 40013f30: 40 00 0e ff call 40017b2c <_Thread_Dispatch> 40013f34: b0 10 20 00 clr %i0 40013f38: 81 c7 e0 08 ret 40013f3c: 81 e8 00 00 restore 4000977c : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 4000977c: 9d e3 bf 90 save %sp, -112, %sp 40009780: 92 10 00 18 mov %i0, %o1 Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 40009784: 80 a6 60 00 cmp %i1, 0 40009788: 02 80 00 1b be 400097f4 4000978c: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40009790: 11 10 00 81 sethi %hi(0x40020400), %o0 40009794: 94 07 bf f4 add %fp, -12, %o2 40009798: 40 00 07 90 call 4000b5d8 <_Objects_Get> 4000979c: 90 12 22 28 or %o0, 0x228, %o0 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 400097a0: c2 07 bf f4 ld [ %fp + -12 ], %g1 400097a4: 80 a0 60 00 cmp %g1, 0 400097a8: 12 80 00 15 bne 400097fc 400097ac: 82 18 60 02 xor %g1, 2, %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; the_info->initial = the_timer->Ticker.initial; 400097b0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 400097b4: c6 02 20 38 ld [ %o0 + 0x38 ], %g3 the_info->initial = the_timer->Ticker.initial; 400097b8: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->start_time = the_timer->Ticker.start_time; 400097bc: c4 02 20 24 ld [ %o0 + 0x24 ], %g2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 400097c0: c6 26 40 00 st %g3, [ %i1 ] the_info->initial = the_timer->Ticker.initial; the_info->start_time = the_timer->Ticker.start_time; 400097c4: c4 26 60 08 st %g2, [ %i1 + 8 ] the_info->stop_time = the_timer->Ticker.stop_time; 400097c8: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 400097cc: 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 ) 400097d0: 07 10 00 82 sethi %hi(0x40020800), %g3 400097d4: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1 ! 40020810 <_Thread_Dispatch_disable_level> 400097d8: b0 10 20 00 clr %i0 400097dc: 82 00 7f ff add %g1, -1, %g1 400097e0: c2 20 e0 10 st %g1, [ %g3 + 0x10 ] 400097e4: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2 400097e8: 80 a0 a0 00 cmp %g2, 0 400097ec: 02 80 00 09 be 40009810 400097f0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400097f4: 81 c7 e0 08 ret <== NOT EXECUTED 400097f8: 81 e8 00 00 restore <== NOT EXECUTED if ( !the_info ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 400097fc: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 40009800: 84 60 20 00 subx %g0, 0, %g2 <== NOT EXECUTED 40009804: b0 08 a0 15 and %g2, 0x15, %i0 <== NOT EXECUTED 40009808: 81 c7 e0 08 ret <== NOT EXECUTED 4000980c: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40009810: 40 00 0c 9a call 4000ca78 <_Thread_Dispatch> 40009814: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40009818: 81 c7 e0 08 ret 4000981c: 81 e8 00 00 restore 40014698 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 40014698: 9d e3 bf 90 save %sp, -112, %sp /* * Make sure the requested priority is valid. */ _priority = priority; if ( priority == RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 4001469c: 92 10 20 00 clr %o1 400146a0: 80 a6 3f ff cmp %i0, -1 400146a4: 02 80 00 07 be 400146c0 400146a8: 94 10 00 19 mov %i1, %o2 _priority = 0; else if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) 400146ac: 82 06 3f ff add %i0, -1, %g1 400146b0: 80 a0 60 fe cmp %g1, 0xfe 400146b4: 18 80 00 16 bgu 4001470c 400146b8: a2 10 20 13 mov 0x13, %l1 400146bc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400146c0: 21 10 00 d1 sethi %hi(0x40034400), %l0 400146c4: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 ! 40034760 <_Thread_Dispatch_disable_level> 400146c8: 82 00 60 01 inc %g1 400146cc: c2 24 23 60 st %g1, [ %l0 + 0x360 ] * Just to make sure the test versus create/start operation are atomic. */ _Thread_Disable_dispatch(); if ( _Timer_Server ) { 400146d0: 33 10 00 d2 sethi %hi(0x40034800), %i1 400146d4: c2 06 63 18 ld [ %i1 + 0x318 ], %g1 ! 40034b18 <_Timer_Server> 400146d8: 80 a0 60 00 cmp %g1, 0 400146dc: 02 80 00 0e be 40014714 400146e0: 19 00 00 20 sethi %hi(0x8000), %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400146e4: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 <== NOT EXECUTED 400146e8: a2 10 20 0e mov 0xe, %l1 <== NOT EXECUTED _Thread_Dispatch(); 400146ec: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400146f0: c2 24 23 60 st %g1, [ %l0 + 0x360 ] 400146f4: c4 04 23 60 ld [ %l0 + 0x360 ], %g2 400146f8: 80 a0 a0 00 cmp %g2, 0 400146fc: 12 80 00 04 bne 4001470c 40014700: 01 00 00 00 nop 40014704: 40 00 0d 0a call 40017b2c <_Thread_Dispatch> 40014708: 01 00 00 00 nop _Watchdog_Initialize( &_Timer_Server->Timer, _Thread_Delay_ended, id, NULL ); _Watchdog_Initialize( &_Timer_Seconds_timer, _Thread_Delay_ended, id, NULL ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 4001470c: 81 c7 e0 08 ret 40014710: 91 e8 00 11 restore %g0, %l1, %o0 * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 40014714: 11 15 12 53 sethi %hi(0x54494c00), %o0 40014718: 98 16 80 0c or %i2, %o4, %o4 4001471c: 90 12 21 45 or %o0, 0x145, %o0 40014720: 96 10 21 00 mov 0x100, %o3 40014724: 7f ff f9 fc call 40012f14 40014728: 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) { 4001472c: a2 92 20 00 orcc %o0, 0, %l1 40014730: 02 80 00 05 be 40014744 40014734: d0 07 bf f4 ld [ %fp + -12 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40014738: c2 04 23 60 ld [ %l0 + 0x360 ], %g1 4001473c: 10 bf ff ed b 400146f0 40014740: 82 00 7f ff add %g1, -1, %g1 _Thread_Enable_dispatch(); return status; } status = rtems_task_start( 40014744: 13 10 00 51 sethi %hi(0x40014400), %o1 40014748: 94 10 20 00 clr %o2 4001474c: 7f ff fc 3d call 40013840 40014750: 92 12 61 44 or %o1, 0x144, %o1 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 40014754: a2 92 20 00 orcc %o0, 0, %l1 40014758: 12 bf ff f8 bne 40014738 4001475c: 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 ) 40014760: 03 10 00 d1 sethi %hi(0x40034400), %g1 40014764: 9a 10 62 10 or %g1, 0x210, %o5 ! 40034610 <_RTEMS_tasks_Information> 40014768: c4 13 60 10 lduh [ %o5 + 0x10 ], %g2 4001476c: 03 00 00 3f sethi %hi(0xfc00), %g1 40014770: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40014774: 86 09 00 01 and %g4, %g1, %g3 40014778: 80 a0 c0 02 cmp %g3, %g2 4001477c: 18 80 00 05 bgu 40014790 40014780: 82 10 20 00 clr %g1 40014784: c4 03 60 20 ld [ %o5 + 0x20 ], %g2 40014788: 83 28 e0 02 sll %g3, 2, %g1 4001478c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 40014790: c0 20 60 6c clr [ %g1 + 0x6c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40014794: c0 20 60 50 clr [ %g1 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; 40014798: c8 20 60 68 st %g4, [ %g1 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 4001479c: 07 10 00 5e sethi %hi(0x40017800), %g3 * * NOTE: Setting the pointer to the Timer Server TCB to a value other than * NULL indicates that task-based timer support is initialized. */ _Timer_Server = (Thread_Control *)_Objects_Get_local_object( 400147a0: c2 26 63 18 st %g1, [ %i1 + 0x318 ] 400147a4: 86 10 e2 88 or %g3, 0x288, %g3 400147a8: c6 20 60 64 st %g3, [ %g1 + 0x64 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 400147ac: 03 10 00 d1 sethi %hi(0x40034400), %g1 400147b0: 82 10 62 60 or %g1, 0x260, %g1 ! 40034660 <_Timer_Ticks_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 400147b4: c2 20 7f fc st %g1, [ %g1 + -4 ] 400147b8: 82 00 7f fc add %g1, -4, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 400147bc: 05 10 00 d1 sethi %hi(0x40034400), %g2 Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 400147c0: c2 20 60 08 st %g1, [ %g1 + 8 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 400147c4: 84 10 a2 74 or %g2, 0x274, %g2 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 400147c8: c0 20 60 04 clr [ %g1 + 4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 400147cc: c4 20 bf fc st %g2, [ %g2 + -4 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 400147d0: 03 10 00 d1 sethi %hi(0x40034400), %g1 400147d4: 84 00 bf fc add %g2, -4, %g2 400147d8: 82 10 62 7c or %g1, 0x27c, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 400147dc: c4 20 a0 08 st %g2, [ %g2 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 400147e0: c0 20 a0 04 clr [ %g2 + 4 ] the_watchdog->routine = routine; 400147e4: c6 20 60 1c st %g3, [ %g1 + 0x1c ] the_watchdog->id = id; 400147e8: c8 20 60 20 st %g4, [ %g1 + 0x20 ] the_watchdog->user_data = user_data; 400147ec: c0 20 60 24 clr [ %g1 + 0x24 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 400147f0: 10 bf ff d2 b 40014738 400147f4: c0 20 60 08 clr [ %g1 + 8 ] 4001408c : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 4001408c: 9d e3 bf 90 save %sp, -112, %sp 40014090: 11 10 00 d2 sethi %hi(0x40034800), %o0 40014094: 92 10 00 18 mov %i0, %o1 40014098: 90 12 22 cc or %o0, 0x2cc, %o0 4001409c: 40 00 09 7c call 4001668c <_Objects_Get> 400140a0: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 400140a4: c2 07 bf f4 ld [ %fp + -12 ], %g1 400140a8: 80 a0 60 00 cmp %g1, 0 400140ac: 12 80 00 18 bne 4001410c 400140b0: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 400140b4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 400140b8: 80 a0 60 01 cmp %g1, 1 400140bc: 22 80 00 2f be,a 40014178 400140c0: 31 10 00 d2 sethi %hi(0x40034800), %i0 400140c4: 2a 80 00 18 bcs,a 40014124 400140c8: a0 02 20 10 add %o0, 0x10, %l0 400140cc: 80 a0 60 04 cmp %g1, 4 400140d0: 18 80 00 1b bgu 4001413c 400140d4: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400140d8: 03 10 00 d1 sethi %hi(0x40034400), %g1 400140dc: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 400140e0: b0 10 20 0b mov 0xb, %i0 400140e4: 84 00 bf ff add %g2, -1, %g2 400140e8: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 400140ec: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 400140f0: 80 a0 e0 00 cmp %g3, 0 400140f4: 12 80 00 1f bne 40014170 400140f8: 01 00 00 00 nop _Thread_Dispatch(); 400140fc: 40 00 0e 8c call 40017b2c <_Thread_Dispatch> 40014100: 01 00 00 00 nop 40014104: 81 c7 e0 08 ret 40014108: 81 e8 00 00 restore { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 4001410c: 82 18 60 02 xor %g1, 2, %g1 40014110: 80 a0 00 01 cmp %g0, %g1 40014114: 84 60 20 00 subx %g0, 0, %g2 40014118: b0 08 a0 15 and %g2, 0x15, %i0 4001411c: 81 c7 e0 08 ret 40014120: 91 ee 20 04 restore %i0, 4, %o0 return RTEMS_INVALID_ID; case OBJECTS_LOCAL: switch ( the_timer->the_class ) { case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); 40014124: 40 00 15 4a call 4001964c <_Watchdog_Remove> 40014128: 90 10 00 10 mov %l0, %o0 _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 4001412c: 11 10 00 d2 sethi %hi(0x40034800), %o0 40014130: 92 10 00 10 mov %l0, %o1 40014134: 40 00 14 dc call 400194a4 <_Watchdog_Insert> 40014138: 90 12 20 5c or %o0, 0x5c, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4001413c: 03 10 00 d1 sethi %hi(0x40034400), %g1 40014140: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> 40014144: b0 10 20 00 clr %i0 40014148: 84 00 bf ff add %g2, -1, %g2 4001414c: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 40014150: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 40014154: 80 a0 e0 00 cmp %g3, 0 40014158: 02 80 00 04 be 40014168 4001415c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40014160: 81 c7 e0 08 ret <== NOT EXECUTED 40014164: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40014168: 40 00 0e 71 call 40017b2c <_Thread_Dispatch> 4001416c: 01 00 00 00 nop 40014170: 81 c7 e0 08 ret 40014174: 81 e8 00 00 restore case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: _Timer_Server_stop_ticks_timer(); 40014178: d0 06 23 18 ld [ %i0 + 0x318 ], %o0 _Watchdog_Remove( &the_timer->Ticker ); 4001417c: a2 04 20 10 add %l0, 0x10, %l1 case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: _Timer_Server_stop_ticks_timer(); 40014180: 40 00 15 33 call 4001964c <_Watchdog_Remove> 40014184: 90 02 20 48 add %o0, 0x48, %o0 _Watchdog_Remove( &the_timer->Ticker ); 40014188: 40 00 15 31 call 4001964c <_Watchdog_Remove> 4001418c: 90 10 00 11 mov %l1, %o0 _Timer_Server_process_ticks_chain(); 40014190: 40 00 00 dc call 40014500 <_Timer_Server_process_ticks_chain> 40014194: 21 10 00 d1 sethi %hi(0x40034400), %l0 _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 40014198: 92 10 00 11 mov %l1, %o1 4001419c: 40 00 14 c2 call 400194a4 <_Watchdog_Insert> 400141a0: 90 14 22 5c or %l0, 0x25c, %o0 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 400141a4: c4 04 22 5c ld [ %l0 + 0x25c ], %g2 400141a8: a0 14 22 5c or %l0, 0x25c, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 400141ac: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 400141b0: 80 a0 80 10 cmp %g2, %l0 400141b4: 02 bf ff e2 be 4001413c 400141b8: c2 06 23 18 ld [ %i0 + 0x318 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400141bc: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400141c0: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400141c4: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400141c8: 11 10 00 d2 sethi %hi(0x40034800), %o0 400141cc: 40 00 14 b6 call 400194a4 <_Watchdog_Insert> 400141d0: 90 12 20 5c or %o0, 0x5c, %o0 ! 4003485c <_Watchdog_Ticks_chain> 400141d4: 30 bf ff da b,a 4001413c 400141d8 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 400141d8: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 400141dc: 23 10 00 d2 sethi %hi(0x40034800), %l1 400141e0: c2 04 63 18 ld [ %l1 + 0x318 ], %g1 ! 40034b18 <_Timer_Server> Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 400141e4: a6 10 00 18 mov %i0, %l3 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 400141e8: 80 a0 60 00 cmp %g1, 0 400141ec: 02 80 00 3b be 400142d8 400141f0: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; if ( !routine ) 400141f4: 80 a6 a0 00 cmp %i2, 0 400141f8: 02 80 00 38 be 400142d8 400141fc: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 40014200: 80 a6 60 00 cmp %i1, 0 40014204: 02 80 00 35 be 400142d8 40014208: b0 10 20 0a mov 0xa, %i0 4001420c: 11 10 00 d2 sethi %hi(0x40034800), %o0 40014210: 92 10 00 13 mov %l3, %o1 40014214: 90 12 22 cc or %o0, 0x2cc, %o0 40014218: 40 00 09 1d call 4001668c <_Objects_Get> 4001421c: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40014220: c2 07 bf f4 ld [ %fp + -12 ], %g1 40014224: 80 a0 60 00 cmp %g1, 0 40014228: 12 80 00 30 bne 400142e8 4001422c: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 40014230: a4 02 20 10 add %o0, 0x10, %l2 40014234: 40 00 15 06 call 4001964c <_Watchdog_Remove> 40014238: 90 10 00 12 mov %l2, %o0 _ISR_Disable( level ); 4001423c: 7f ff da ac call 4000acec 40014240: 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 ) { 40014244: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 40014248: 80 a0 60 00 cmp %g1, 0 4001424c: 12 80 00 2d bne 40014300 40014250: 82 10 20 01 mov 1, %g1 * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL_ON_TASK; _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 40014254: f2 24 20 1c st %i1, [ %l0 + 0x1c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40014258: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 4001425c: e6 24 20 30 st %l3, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 40014260: f6 24 20 34 st %i3, [ %l0 + 0x34 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40014264: 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; 40014268: 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 ); 4001426c: 7f ff da a4 call 4000acfc 40014270: 21 10 00 d1 sethi %hi(0x40034400), %l0 _Timer_Server_stop_ticks_timer(); 40014274: d0 04 63 18 ld [ %l1 + 0x318 ], %o0 40014278: 40 00 14 f5 call 4001964c <_Watchdog_Remove> 4001427c: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_process_ticks_chain(); 40014280: 40 00 00 a0 call 40014500 <_Timer_Server_process_ticks_chain> 40014284: 01 00 00 00 nop _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 40014288: 90 14 22 5c or %l0, 0x25c, %o0 4001428c: 40 00 14 86 call 400194a4 <_Watchdog_Insert> 40014290: 92 10 00 12 mov %l2, %o1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 40014294: c4 04 22 5c ld [ %l0 + 0x25c ], %g2 40014298: a0 14 22 5c or %l0, 0x25c, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 4001429c: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 400142a0: 80 a0 80 10 cmp %g2, %l0 400142a4: 12 80 00 1a bne 4001430c 400142a8: c2 04 63 18 ld [ %l1 + 0x318 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400142ac: 03 10 00 d1 sethi %hi(0x40034400), %g1 400142b0: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 40034760 <_Thread_Dispatch_disable_level> _Thread_Dispatch(); 400142b4: b0 10 20 00 clr %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 400142b8: 84 00 bf ff add %g2, -1, %g2 400142bc: c4 20 63 60 st %g2, [ %g1 + 0x360 ] 400142c0: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 400142c4: 80 a0 e0 00 cmp %g3, 0 400142c8: 12 80 00 06 bne 400142e0 400142cc: 01 00 00 00 nop _Thread_Dispatch(); 400142d0: 40 00 0e 17 call 40017b2c <_Thread_Dispatch> 400142d4: b0 10 20 00 clr %i0 ! 0 400142d8: 81 c7 e0 08 ret 400142dc: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400142e0: 81 c7 e0 08 ret <== NOT EXECUTED 400142e4: 81 e8 00 00 restore <== NOT EXECUTED if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 400142e8: 82 18 60 02 xor %g1, 2, %g1 400142ec: 80 a0 00 01 cmp %g0, %g1 400142f0: 84 60 20 00 subx %g0, 0, %g2 400142f4: b0 08 a0 15 and %g2, 0x15, %i0 400142f8: 81 c7 e0 08 ret 400142fc: 91 ee 20 04 restore %i0, 4, %o0 * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 40014300: 7f ff da 7f call 4000acfc <== NOT EXECUTED 40014304: 01 00 00 00 nop <== NOT EXECUTED 40014308: 30 bf ff e9 b,a 400142ac <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4001430c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40014310: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40014314: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40014318: 11 10 00 d2 sethi %hi(0x40034800), %o0 4001431c: 40 00 14 62 call 400194a4 <_Watchdog_Insert> 40014320: 90 12 20 5c or %o0, 0x5c, %o0 ! 4003485c <_Watchdog_Ticks_chain> 40014324: 30 bf ff e2 b,a 400142ac