40006bb0 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 40006bb0: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 40006bb4: 03 10 00 67 sethi %hi(0x40019c00), %g1 40006bb8: e0 00 61 a0 ld [ %g1 + 0x1a0 ], %l0 ! 40019da0 <_API_extensions_List> 40006bbc: 82 10 61 a0 or %g1, 0x1a0, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40006bc0: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 40006bc4: 80 a4 00 11 cmp %l0, %l1 40006bc8: 02 80 00 0c be 40006bf8 <_API_extensions_Run_postdriver+0x48> 40006bcc: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 40006bd0: c2 04 20 0c ld [ %l0 + 0xc ], %g1 40006bd4: 80 a0 60 00 cmp %g1, 0 40006bd8: 22 80 00 05 be,a 40006bec <_API_extensions_Run_postdriver+0x3c> 40006bdc: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postdriver_hook)(); 40006be0: 9f c0 40 00 call %g1 40006be4: 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 ) { 40006be8: 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 ) ; 40006bec: 80 a4 00 11 cmp %l0, %l1 40006bf0: 32 bf ff f9 bne,a 40006bd4 <_API_extensions_Run_postdriver+0x24> 40006bf4: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED 40006bf8: 81 c7 e0 08 ret 40006bfc: 81 e8 00 00 restore 40006c6c <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 40006c6c: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 40006c70: 03 10 00 67 sethi %hi(0x40019c00), %g1 40006c74: e0 00 61 a0 ld [ %g1 + 0x1a0 ], %l0 ! 40019da0 <_API_extensions_List> 40006c78: 82 10 61 a0 or %g1, 0x1a0, %g1 40006c7c: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 40006c80: 80 a4 00 11 cmp %l0, %l1 40006c84: 02 80 00 0c be 40006cb4 <_API_extensions_Run_postswitch+0x48> 40006c88: 25 10 00 66 sethi %hi(0x40019800), %l2 the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 40006c8c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 40006c90: 80 a0 60 00 cmp %g1, 0 40006c94: 22 80 00 05 be,a 40006ca8 <_API_extensions_Run_postswitch+0x3c> 40006c98: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 40006c9c: 9f c0 40 00 call %g1 40006ca0: d0 04 a3 ec ld [ %l2 + 0x3ec ], %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 ) { 40006ca4: 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 ) ; 40006ca8: 80 a4 00 11 cmp %l0, %l1 40006cac: 32 bf ff f9 bne,a 40006c90 <_API_extensions_Run_postswitch+0x24> 40006cb0: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 40006cb4: 81 c7 e0 08 ret 40006cb8: 81 e8 00 00 restore 40006c1c <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 40006c1c: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 40006c20: 03 10 00 67 sethi %hi(0x40019c00), %g1 40006c24: e0 00 61 a0 ld [ %g1 + 0x1a0 ], %l0 ! 40019da0 <_API_extensions_List> 40006c28: 82 10 61 a0 or %g1, 0x1a0, %g1 40006c2c: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 40006c30: 80 a4 00 11 cmp %l0, %l1 40006c34: 02 80 00 0c be 40006c64 <_API_extensions_Run_predriver+0x48> 40006c38: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 40006c3c: c2 04 20 08 ld [ %l0 + 8 ], %g1 40006c40: 80 a0 60 00 cmp %g1, 0 40006c44: 22 80 00 05 be,a 40006c58 <_API_extensions_Run_predriver+0x3c> 40006c48: e0 04 00 00 ld [ %l0 ], %l0 (*the_extension->predriver_hook)(); 40006c4c: 9f c0 40 00 call %g1 <== NOT EXECUTED 40006c50: 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 ) { 40006c54: 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 ) ; 40006c58: 80 a4 00 11 cmp %l0, %l1 40006c5c: 32 bf ff f9 bne,a 40006c40 <_API_extensions_Run_predriver+0x24> 40006c60: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 40006c64: 81 c7 e0 08 ret 40006c68: 81 e8 00 00 restore 40013f18 <_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 ) { 40013f18: 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 ) { 40013f1c: 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 ) { 40013f20: 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 ) { 40013f24: 80 a0 40 1a cmp %g1, %i2 40013f28: 0a 80 00 17 bcs 40013f84 <_CORE_message_queue_Broadcast+0x6c> 40013f2c: 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 ) { 40013f30: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1 40013f34: 80 a0 60 00 cmp %g1, 0 40013f38: 02 80 00 0a be 40013f60 <_CORE_message_queue_Broadcast+0x48> 40013f3c: a2 10 20 00 clr %l1 *count = 0; 40013f40: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED 40013f44: 81 c7 e0 08 ret <== NOT EXECUTED 40013f48: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 40013f4c: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 40013f50: 40 00 21 ab call 4001c5fc 40013f54: a2 04 60 01 inc %l1 buffer, waitp->return_argument, size ); *(uint32_t *)the_thread->Wait.return_argument_1 = size; 40013f58: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 40013f5c: 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))) { 40013f60: 40 00 0b 94 call 40016db0 <_Thread_queue_Dequeue> 40013f64: 90 10 00 12 mov %l2, %o0 40013f68: 92 10 00 19 mov %i1, %o1 40013f6c: a0 10 00 08 mov %o0, %l0 40013f70: 80 a2 20 00 cmp %o0, 0 40013f74: 12 bf ff f6 bne 40013f4c <_CORE_message_queue_Broadcast+0x34> 40013f78: 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; 40013f7c: e2 27 40 00 st %l1, [ %i5 ] 40013f80: b0 10 20 00 clr %i0 return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 40013f84: 81 c7 e0 08 ret 40013f88: 81 e8 00 00 restore 4001404c <_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 ) { 4001404c: 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; 40014050: 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; 40014054: 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; 40014058: 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; 4001405c: c0 26 20 60 clr [ %i0 + 0x60 ] the_message_queue->notify_argument = the_argument; 40014060: 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)) { 40014064: 80 8e e0 03 btst 3, %i3 40014068: 02 80 00 07 be 40014084 <_CORE_message_queue_Initialize+0x38> 4001406c: a0 10 00 1b mov %i3, %l0 allocated_message_size += sizeof(uint32_t); 40014070: 82 06 e0 04 add %i3, 4, %g1 allocated_message_size &= ~(sizeof(uint32_t) - 1); 40014074: a0 08 7f fc and %g1, -4, %l0 } if (allocated_message_size < maximum_message_size) 40014078: 80 a6 c0 10 cmp %i3, %l0 4001407c: 18 80 00 09 bgu 400140a0 <_CORE_message_queue_Initialize+0x54> 40014080: 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 * 40014084: b6 04 20 14 add %l0, 0x14, %i3 40014088: 92 10 00 1a mov %i2, %o1 4001408c: 40 00 42 31 call 40024950 <.umul> 40014090: 90 10 00 1b mov %i3, %o0 (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 40014094: 80 a2 00 10 cmp %o0, %l0 40014098: 1a 80 00 04 bcc 400140a8 <_CORE_message_queue_Initialize+0x5c> 4001409c: 92 10 00 08 mov %o0, %o1 STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return TRUE; } 400140a0: 81 c7 e0 08 ret <== NOT EXECUTED 400140a4: 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 ); 400140a8: 11 10 00 cd sethi %hi(0x40033400), %o0 400140ac: 40 00 02 20 call 4001492c <_Heap_Allocate> 400140b0: 90 12 21 2c or %o0, 0x12c, %o0 ! 4003352c <_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) 400140b4: 80 a2 20 00 cmp %o0, 0 400140b8: 02 bf ff fa be 400140a0 <_CORE_message_queue_Initialize+0x54> 400140bc: d0 26 20 5c st %o0, [ %i0 + 0x5c ] /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 400140c0: 92 10 00 08 mov %o0, %o1 400140c4: 94 10 00 1a mov %i2, %o2 400140c8: 90 06 20 68 add %i0, 0x68, %o0 400140cc: 7f ff ff 7b call 40013eb8 <_Chain_Initialize> 400140d0: 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( 400140d4: c2 06 40 00 ld [ %i1 ], %g1 400140d8: 84 06 20 50 add %i0, 0x50, %g2 400140dc: 82 18 60 01 xor %g1, 1, %g1 400140e0: 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); 400140e4: 82 06 20 54 add %i0, 0x54, %g1 the_chain->permanent_null = NULL; 400140e8: c0 26 20 54 clr [ %i0 + 0x54 ] 400140ec: 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); 400140f0: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 400140f4: c4 26 20 58 st %g2, [ %i0 + 0x58 ] 400140f8: 92 60 3f ff subx %g0, -1, %o1 400140fc: 94 10 20 80 mov 0x80, %o2 40014100: 96 10 20 06 mov 6, %o3 40014104: 40 00 0c a7 call 400173a0 <_Thread_queue_Initialize> 40014108: b0 10 20 01 mov 1, %i0 4001410c: 81 c7 e0 08 ret 40014110: 81 e8 00 00 restore 40019264 <_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 ) { 40019264: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; boolean notify = FALSE; the_message->priority = submit_type; switch ( submit_type ) { 40019268: 03 20 00 00 sethi %hi(0x80000000), %g1 4001926c: 80 a6 80 01 cmp %i2, %g1 40019270: 02 80 00 40 be 40019370 <_CORE_message_queue_Insert_message+0x10c> 40019274: f4 26 60 08 st %i2, [ %i1 + 8 ] 40019278: 82 00 7c 00 add %g1, -1024, %g1 4001927c: 82 10 63 ff or %g1, 0x3ff, %g1 40019280: 80 a6 80 01 cmp %i2, %g1 40019284: 02 80 00 29 be 40019328 <_CORE_message_queue_Insert_message+0xc4> 40019288: 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; 4001928c: e0 06 20 50 ld [ %i0 + 0x50 ], %l0 <== NOT EXECUTED while ( !_Chain_Is_tail( the_header, the_node ) ) { 40019290: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 40019294: 32 80 00 21 bne,a 40019318 <_CORE_message_queue_Insert_message+0xb4> <== NOT EXECUTED 40019298: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 4001929c: 7f ff a4 d8 call 400025fc <== NOT EXECUTED 400192a0: 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 ); 400192a4: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED } break; } _ISR_Disable( level ); if ( the_message_queue->number_of_pending_messages++ == 0 ) 400192a8: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 400192ac: c6 00 40 00 ld [ %g1 ], %g3 <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 400192b0: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; 400192b4: f2 20 40 00 st %i1, [ %g1 ] <== NOT EXECUTED 400192b8: 84 00 a0 01 inc %g2 <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 400192bc: f2 20 e0 04 st %i1, [ %g3 + 4 ] <== NOT EXECUTED 400192c0: 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; 400192c4: c6 26 40 00 st %g3, [ %i1 ] <== NOT EXECUTED 400192c8: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 400192cc: c4 26 20 48 st %g2, [ %i0 + 0x48 ] <== NOT EXECUTED 400192d0: a0 60 3f ff subx %g0, -1, %l0 <== NOT EXECUTED notify = TRUE; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); _ISR_Enable( level ); 400192d4: 7f ff a4 ce call 4000260c <== NOT EXECUTED 400192d8: 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 ) 400192dc: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 400192e0: 02 80 00 08 be 40019300 <_CORE_message_queue_Insert_message+0x9c> 400192e4: 01 00 00 00 nop 400192e8: c2 06 20 60 ld [ %i0 + 0x60 ], %g1 400192ec: 80 a0 60 00 cmp %g1, 0 400192f0: 02 80 00 04 be 40019300 <_CORE_message_queue_Insert_message+0x9c> 400192f4: 01 00 00 00 nop (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 400192f8: 9f c0 40 00 call %g1 <== NOT EXECUTED 400192fc: d0 06 20 64 ld [ %i0 + 0x64 ], %o0 <== NOT EXECUTED 40019300: 81 c7 e0 08 ret 40019304: 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 ) ) { 40019308: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 4001930c: 02 bf ff e4 be 4001929c <_CORE_message_queue_Insert_message+0x38> <== NOT EXECUTED 40019310: 01 00 00 00 nop <== NOT EXECUTED this_message = (CORE_message_queue_Buffer_control *) the_node; if ( this_message->priority <= the_message->priority ) { 40019314: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 40019318: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED 4001931c: 36 bf ff fb bge,a 40019308 <_CORE_message_queue_Insert_message+0xa4> <== NOT EXECUTED 40019320: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED 40019324: 30 bf ff de b,a 4001929c <_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 ); 40019328: 7f ff a4 b5 call 400025fc 4001932c: 01 00 00 00 nop if ( the_message_queue->number_of_pending_messages++ == 0 ) 40019330: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 40019334: 82 06 20 54 add %i0, 0x54, %g1 40019338: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 4001933c: c6 06 20 58 ld [ %i0 + 0x58 ], %g3 the_chain->last = the_node; 40019340: f2 26 20 58 st %i1, [ %i0 + 0x58 ] 40019344: 84 00 a0 01 inc %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 40019348: c6 26 60 04 st %g3, [ %i1 + 4 ] 4001934c: 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; 40019350: f2 20 c0 00 st %i1, [ %g3 ] 40019354: 80 a0 00 01 cmp %g0, %g1 40019358: c4 26 20 48 st %g2, [ %i0 + 0x48 ] 4001935c: a0 60 3f ff subx %g0, -1, %l0 notify = TRUE; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 40019360: 7f ff a4 ab call 4000260c 40019364: 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 ) 40019368: 10 bf ff de b 400192e0 <_CORE_message_queue_Insert_message+0x7c> 4001936c: 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 ); 40019370: 7f ff a4 a3 call 400025fc 40019374: 01 00 00 00 nop ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 40019378: c6 06 20 50 ld [ %i0 + 0x50 ], %g3 if ( the_message_queue->number_of_pending_messages++ == 0 ) 4001937c: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 40019380: 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; 40019384: f2 26 20 50 st %i1, [ %i0 + 0x50 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 40019388: c2 26 60 04 st %g1, [ %i1 + 4 ] 4001938c: 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; 40019390: f2 20 e0 04 st %i1, [ %g3 + 4 ] 40019394: 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; 40019398: c6 26 40 00 st %g3, [ %i1 ] 4001939c: 80 a0 00 01 cmp %g0, %g1 400193a0: c4 26 20 48 st %g2, [ %i0 + 0x48 ] 400193a4: a0 60 3f ff subx %g0, -1, %l0 notify = TRUE; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 400193a8: 7f ff a4 99 call 4000260c 400193ac: 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 ) 400193b0: 10 bf ff cc b 400192e0 <_CORE_message_queue_Insert_message+0x7c> 400193b4: 80 a4 20 00 cmp %l0, 0 400162a8 <_CORE_message_queue_Seize>: void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 400162a8: 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; 400162ac: 25 10 00 ac sethi %hi(0x4002b000), %l2 400162b0: e2 04 a2 6c ld [ %l2 + 0x26c ], %l1 ! 4002b26c <_Thread_Executing> void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 400162b4: 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 ); 400162b8: 7f ff b0 d1 call 400025fc 400162bc: c0 24 60 34 clr [ %l1 + 0x34 ] 400162c0: 88 10 00 08 mov %o0, %g4 if ( the_message_queue->number_of_pending_messages != 0 ) { 400162c4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 400162c8: 80 a0 60 00 cmp %g1, 0 400162cc: 02 80 00 23 be 40016358 <_CORE_message_queue_Seize+0xb0> 400162d0: 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)); 400162d4: c6 06 20 50 ld [ %i0 + 0x50 ], %g3 the_message_queue->number_of_pending_messages -= 1; 400162d8: 82 00 7f ff add %g1, -1, %g1 400162dc: 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)) 400162e0: 84 06 20 54 add %i0, 0x54, %g2 400162e4: 80 a0 c0 02 cmp %g3, %g2 400162e8: 12 80 00 24 bne 40016378 <_CORE_message_queue_Seize+0xd0> 400162ec: b2 10 20 00 clr %i1 the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); 400162f0: 7f ff b0 c7 call 4000260c 400162f4: 90 10 00 04 mov %g4, %o0 *size = the_message->Contents.size; 400162f8: d4 06 60 0c ld [ %i1 + 0xc ], %o2 _Thread_Executing->Wait.count = the_message->priority; 400162fc: c4 04 a2 6c ld [ %l2 + 0x26c ], %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; 40016300: d4 26 c0 00 st %o2, [ %i3 ] _Thread_Executing->Wait.count = the_message->priority; 40016304: c2 06 60 08 ld [ %i1 + 8 ], %g1 40016308: a2 06 60 10 add %i1, 0x10, %l1 4001630c: c2 20 a0 24 st %g1, [ %g2 + 0x24 ] const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 40016310: 92 10 00 11 mov %l1, %o1 40016314: 40 00 13 00 call 4001af14 40016318: 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 ); 4001631c: 7f ff e9 3e call 40010814 <_Thread_queue_Dequeue> 40016320: 90 10 00 10 mov %l0, %o0 if ( !the_thread ) { 40016324: 80 a2 20 00 cmp %o0, 0 40016328: 02 80 00 24 be 400163b8 <_CORE_message_queue_Seize+0x110> 4001632c: 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; 40016330: 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; 40016334: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED 40016338: d2 02 20 28 ld [ %o0 + 0x28 ], %o1 <== NOT EXECUTED the_message->Contents.size = (uint32_t)the_thread->Wait.option; 4001633c: 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; 40016340: c2 26 60 08 st %g1, [ %i1 + 8 ] <== NOT EXECUTED 40016344: 40 00 12 f4 call 4001af14 <== NOT EXECUTED 40016348: 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( 4001634c: f4 06 60 08 ld [ %i1 + 8 ], %i2 <== NOT EXECUTED 40016350: 40 00 0b c5 call 40019264 <_CORE_message_queue_Insert_message> <== NOT EXECUTED 40016354: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 40016358: 12 80 00 0e bne 40016390 <_CORE_message_queue_Seize+0xe8> 4001635c: 82 10 20 01 mov 1, %g1 _ISR_Enable( level ); 40016360: 7f ff b0 ab call 4000260c 40016364: 01 00 00 00 nop executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 40016368: 82 10 20 04 mov 4, %g1 ! 4 4001636c: 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 ); } 40016370: 81 c7 e0 08 ret 40016374: 81 e8 00 00 restore { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 40016378: c4 00 c0 00 ld [ %g3 ], %g2 the_chain->first = new_first; new_first->previous = _Chain_Head(the_chain); 4001637c: 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; 40016380: c4 26 20 50 st %g2, [ %i0 + 0x50 ] new_first->previous = _Chain_Head(the_chain); 40016384: b2 10 00 03 mov %g3, %i1 40016388: 10 bf ff da b 400162f0 <_CORE_message_queue_Seize+0x48> 4001638c: 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; 40016390: 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; 40016394: f0 24 60 44 st %i0, [ %l1 + 0x44 ] executing->Wait.id = id; 40016398: f2 24 60 20 st %i1, [ %l1 + 0x20 ] executing->Wait.return_argument = buffer; 4001639c: 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; 400163a0: 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 ); 400163a4: 7f ff b0 9a call 4000260c 400163a8: 35 10 00 43 sethi %hi(0x40010c00), %i2 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 400163ac: b2 10 00 1d mov %i5, %i1 400163b0: 7f ff e9 87 call 400109cc <_Thread_queue_Enqueue_with_handler> 400163b4: 95 ee a3 0c restore %i2, 0x30c, %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 ); 400163b8: 7f ff de d6 call 4000df10 <_Chain_Append> 400163bc: 91 ec 20 68 restore %l0, 0x68, %o0 400163c0: 01 00 00 00 nop 400163c4 <_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 ) { 400163c4: 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 ) { 400163c8: 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 ) { 400163cc: 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 ) { 400163d0: 80 a0 40 1a cmp %g1, %i2 400163d4: 0a 80 00 22 bcs 4001645c <_CORE_message_queue_Submit+0x98> 400163d8: 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 ) { 400163dc: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 400163e0: 80 a0 a0 00 cmp %g2, 0 400163e4: 02 80 00 22 be 4001646c <_CORE_message_queue_Submit+0xa8> 400163e8: 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 < 400163ec: c2 04 60 44 ld [ %l1 + 0x44 ], %g1 400163f0: 80 a0 40 02 cmp %g1, %g2 400163f4: 18 80 00 2b bgu 400164a0 <_CORE_message_queue_Submit+0xdc> 400163f8: 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 ) { 400163fc: 80 a0 60 00 cmp %g1, 0 40016400: 02 80 00 17 be 4001645c <_CORE_message_queue_Submit+0x98> 40016404: 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() ) { 40016408: 03 10 00 ac sethi %hi(0x4002b000), %g1 <== NOT EXECUTED 4001640c: c4 00 62 54 ld [ %g1 + 0x254 ], %g2 ! 4002b254 <_ISR_Nest_level> <== NOT EXECUTED 40016410: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40016414: 12 80 00 14 bne 40016464 <_CORE_message_queue_Submit+0xa0> <== NOT EXECUTED 40016418: 03 10 00 ac sethi %hi(0x4002b000), %g1 <== NOT EXECUTED */ { Thread_Control *executing = _Thread_Executing; _ISR_Disable( level ); 4001641c: 7f ff b0 78 call 400025fc <== NOT EXECUTED 40016420: e0 00 62 6c ld [ %g1 + 0x26c ], %l0 ! 4002b26c <_Thread_Executing> <== NOT EXECUTED 40016424: 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; 40016428: 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; 4001642c: f6 24 20 20 st %i3, [ %l0 + 0x20 ] <== NOT EXECUTED executing->Wait.return_argument = buffer; 40016430: f2 24 20 28 st %i1, [ %l0 + 0x28 ] <== NOT EXECUTED executing->Wait.option = size; 40016434: 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; 40016438: e2 24 20 44 st %l1, [ %l0 + 0x44 ] <== NOT EXECUTED 4001643c: 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 ); 40016440: 7f ff b0 73 call 4000260c <== NOT EXECUTED 40016444: b0 10 20 07 mov 7, %i0 <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 40016448: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 <== NOT EXECUTED 4001644c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40016450: 15 10 00 43 sethi %hi(0x40010c00), %o2 <== NOT EXECUTED 40016454: 7f ff e9 5e call 400109cc <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 40016458: 94 12 a3 0c or %o2, 0x30c, %o2 ! 40010f0c <_Thread_queue_Timeout> <== NOT EXECUTED 4001645c: 81 c7 e0 08 ret 40016460: 81 e8 00 00 restore } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 40016464: 81 c7 e0 08 ret <== NOT EXECUTED 40016468: 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 ); 4001646c: 7f ff e8 ea call 40010814 <_Thread_queue_Dequeue> 40016470: 90 10 00 11 mov %l1, %o0 if ( the_thread ) { 40016474: a0 92 20 00 orcc %o0, 0, %l0 40016478: 02 80 00 1b be 400164e4 <_CORE_message_queue_Submit+0x120> 4001647c: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 40016480: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 40016484: 40 00 12 a4 call 4001af14 40016488: 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; 4001648c: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 the_thread->Wait.count = submit_type; 40016490: 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; 40016494: f4 20 40 00 st %i2, [ %g1 ] the_thread->Wait.count = submit_type; 40016498: 81 c7 e0 08 ret 4001649c: 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 *) 400164a0: 7f ff de a8 call 4000df40 <_Chain_Get> 400164a4: 90 04 60 68 add %l1, 0x68, %o0 /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 400164a8: a0 92 20 00 orcc %o0, 0, %l0 400164ac: 02 bf ff ee be 40016464 <_CORE_message_queue_Submit+0xa0> 400164b0: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 400164b4: 94 10 00 1a mov %i2, %o2 400164b8: 40 00 12 97 call 4001af14 400164bc: 90 04 20 10 add %l0, 0x10, %o0 size ); the_message->Contents.size = size; the_message->priority = submit_type; _CORE_message_queue_Insert_message( 400164c0: 90 10 00 11 mov %l1, %o0 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 400164c4: f4 24 20 0c st %i2, [ %l0 + 0xc ] the_message->priority = submit_type; 400164c8: fa 24 20 08 st %i5, [ %l0 + 8 ] _CORE_message_queue_Insert_message( 400164cc: 92 10 00 10 mov %l0, %o1 400164d0: 94 10 00 1d mov %i5, %o2 400164d4: 40 00 0b 64 call 40019264 <_CORE_message_queue_Insert_message> 400164d8: b0 10 20 00 clr %i0 400164dc: 81 c7 e0 08 ret 400164e0: 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 ) { 400164e4: 10 bf ff c2 b 400163ec <_CORE_message_queue_Submit+0x28> 400164e8: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 40006d48 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 40006d48: 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; 40006d4c: 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 ) { 40006d50: 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; 40006d54: c2 26 20 40 st %g1, [ %i0 + 0x40 ] 40006d58: c4 06 60 04 ld [ %i1 + 4 ], %g2 the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 40006d5c: 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; 40006d60: c4 26 20 44 st %g2, [ %i0 + 0x44 ] 40006d64: c8 06 60 08 ld [ %i1 + 8 ], %g4 40006d68: c8 26 20 48 st %g4, [ %i0 + 0x48 ] 40006d6c: da 06 60 0c ld [ %i1 + 0xc ], %o5 the_mutex->lock = initial_lock; 40006d70: 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; 40006d74: da 26 20 4c st %o5, [ %i0 + 0x4c ] the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 40006d78: 12 80 00 1c bne 40006de8 <_CORE_mutex_Initialize+0xa0> 40006d7c: c0 26 20 58 clr [ %i0 + 0x58 ] the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; 40006d80: 19 10 00 66 sethi %hi(0x40019800), %o4 40006d84: c6 03 23 ec ld [ %o4 + 0x3ec ], %g3 ! 40019bec <_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; 40006d88: 82 10 20 01 mov 1, %g1 40006d8c: c2 26 20 54 st %g1, [ %i0 + 0x54 ] the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; 40006d90: 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; 40006d94: 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 ) || 40006d98: 80 a1 20 02 cmp %g4, 2 40006d9c: 12 80 00 1f bne 40006e18 <_CORE_mutex_Initialize+0xd0> 40006da0: c4 26 20 60 st %g2, [ %i0 + 0x60 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < 40006da4: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 40006da8: 80 a0 40 0d cmp %g1, %o5 40006dac: 0a 80 00 0d bcs 40006de0 <_CORE_mutex_Initialize+0x98> 40006db0: b0 10 20 06 mov 6, %i0 the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 40006db4: c4 03 23 ec ld [ %o4 + 0x3ec ], %g2 the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40006db8: 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++; 40006dbc: 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( 40006dc0: 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++; 40006dc4: 82 00 60 01 inc %g1 40006dc8: 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( 40006dcc: c2 06 60 08 ld [ %i1 + 8 ], %g1 40006dd0: b0 10 20 00 clr %i0 40006dd4: 80 a0 00 01 cmp %g0, %g1 40006dd8: 40 00 0b 60 call 40009b58 <_Thread_queue_Initialize> 40006ddc: 92 40 20 00 addx %g0, 0, %o1 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 40006de0: 81 c7 e0 08 ret 40006de4: 81 e8 00 00 restore the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40006de8: 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; 40006dec: c0 26 20 54 clr [ %i0 + 0x54 ] the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 40006df0: 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; 40006df4: c0 26 20 5c clr [ %i0 + 0x5c ] the_mutex->holder_id = 0; 40006df8: c0 26 20 60 clr [ %i0 + 0x60 ] } _Thread_queue_Initialize( 40006dfc: 92 40 20 00 addx %g0, 0, %o1 40006e00: 94 10 24 00 mov 0x400, %o2 40006e04: 96 10 20 05 mov 5, %o3 40006e08: 40 00 0b 54 call 40009b58 <_Thread_queue_Initialize> 40006e0c: b0 10 20 00 clr %i0 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 40006e10: 81 c7 e0 08 ret 40006e14: 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 ) || 40006e18: 80 a1 20 03 cmp %g4, 3 40006e1c: 32 bf ff e7 bne,a 40006db8 <_CORE_mutex_Initialize+0x70> 40006e20: c4 03 23 ec ld [ %o4 + 0x3ec ], %g2 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < 40006e24: 10 bf ff e1 b 40006da8 <_CORE_mutex_Initialize+0x60> <== NOT EXECUTED 40006e28: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED 40006e2c <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 40006e2c: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 40006e30: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 Watchdog_Interval timeout ) { Thread_Control *executing; executing = _Thread_Executing; 40006e34: 03 10 00 66 sethi %hi(0x40019800), %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 40006e38: 80 a0 a0 02 cmp %g2, 2 40006e3c: 12 80 00 08 bne 40006e5c <_CORE_mutex_Seize_interrupt_blocking+0x30> 40006e40: d2 00 63 ec ld [ %g1 + 0x3ec ], %o1 if ( the_mutex->holder->current_priority > executing->current_priority ) { 40006e44: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 40006e48: d2 02 60 14 ld [ %o1 + 0x14 ], %o1 40006e4c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40006e50: 80 a0 40 09 cmp %g1, %o1 40006e54: 18 80 00 16 bgu 40006eac <_CORE_mutex_Seize_interrupt_blocking+0x80> 40006e58: 01 00 00 00 nop FALSE ); } } the_mutex->blocked_count++; 40006e5c: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 40006e60: 90 10 00 18 mov %i0, %o0 FALSE ); } } the_mutex->blocked_count++; 40006e64: 82 00 60 01 inc %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 40006e68: 92 10 00 19 mov %i1, %o1 FALSE ); } } the_mutex->blocked_count++; 40006e6c: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 40006e70: 15 10 00 27 sethi %hi(0x40009c00), %o2 40006e74: 40 00 0a 2b call 40009720 <_Thread_queue_Enqueue_with_handler> 40006e78: 94 12 a0 60 or %o2, 0x60, %o2 ! 40009c60 <_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 ) 40006e7c: 05 10 00 66 sethi %hi(0x40019800), %g2 40006e80: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> 40006e84: 82 00 7f ff add %g1, -1, %g1 40006e88: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] 40006e8c: c6 00 a3 10 ld [ %g2 + 0x310 ], %g3 40006e90: 80 a0 e0 00 cmp %g3, 0 40006e94: 02 80 00 04 be 40006ea4 <_CORE_mutex_Seize_interrupt_blocking+0x78> 40006e98: 01 00 00 00 nop 40006e9c: 81 c7 e0 08 ret <== NOT EXECUTED 40006ea0: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40006ea4: 40 00 08 af call 40009160 <_Thread_Dispatch> 40006ea8: 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( 40006eac: 40 00 07 89 call 40008cd0 <_Thread_Change_priority> 40006eb0: 94 10 20 00 clr %o2 FALSE ); } } the_mutex->blocked_count++; 40006eb4: 10 bf ff eb b 40006e60 <_CORE_mutex_Seize_interrupt_blocking+0x34> 40006eb8: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 40006ebc <_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 ) { 40006ebc: 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 ) { 40006ec0: 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 ) { 40006ec4: 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 ) { 40006ec8: 80 a0 60 00 cmp %g1, 0 40006ecc: 02 80 00 07 be 40006ee8 <_CORE_mutex_Surrender+0x2c> 40006ed0: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 if ( !_Thread_Is_executing( holder ) ) 40006ed4: 03 10 00 66 sethi %hi(0x40019800), %g1 40006ed8: c4 00 63 ec ld [ %g1 + 0x3ec ], %g2 ! 40019bec <_Thread_Executing> 40006edc: 80 a2 00 02 cmp %o0, %g2 40006ee0: 12 80 00 49 bne 40007004 <_CORE_mutex_Surrender+0x148> 40006ee4: 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 ) 40006ee8: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 40006eec: 80 a0 60 00 cmp %g1, 0 40006ef0: 22 80 00 45 be,a 40007004 <_CORE_mutex_Surrender+0x148> 40006ef4: b0 10 20 00 clr %i0 return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 40006ef8: 82 00 7f ff add %g1, -1, %g1 if ( the_mutex->nest_count != 0 ) { 40006efc: 80 a0 60 00 cmp %g1, 0 40006f00: 02 80 00 09 be 40006f24 <_CORE_mutex_Surrender+0x68> 40006f04: c2 24 20 54 st %g1, [ %l0 + 0x54 ] switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40006f08: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 40006f0c: 80 a0 60 00 cmp %g1, 0 40006f10: 02 80 00 3d be 40007004 <_CORE_mutex_Surrender+0x148> 40006f14: b0 10 20 00 clr %i0 40006f18: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40006f1c: 02 80 00 3a be 40007004 <_CORE_mutex_Surrender+0x148> <== NOT EXECUTED 40006f20: 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; 40006f24: 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 ) || 40006f28: 80 a0 a0 02 cmp %g2, 2 40006f2c: 22 80 00 2a be,a 40006fd4 <_CORE_mutex_Surrender+0x118> 40006f30: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 40006f34: 80 a0 a0 03 cmp %g2, 3 40006f38: 22 80 00 27 be,a 40006fd4 <_CORE_mutex_Surrender+0x118> 40006f3c: 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; 40006f40: 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 ) || 40006f44: 80 a0 a0 02 cmp %g2, 2 40006f48: 02 80 00 17 be 40006fa4 <_CORE_mutex_Surrender+0xe8> 40006f4c: c0 24 20 60 clr [ %l0 + 0x60 ] 40006f50: 80 a0 a0 03 cmp %g2, 3 40006f54: 22 80 00 15 be,a 40006fa8 <_CORE_mutex_Surrender+0xec> 40006f58: 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 ) ) ) { 40006f5c: 40 00 09 83 call 40009568 <_Thread_queue_Dequeue> 40006f60: 90 10 00 10 mov %l0, %o0 40006f64: 86 92 20 00 orcc %o0, 0, %g3 40006f68: 02 80 00 2e be 40007020 <_CORE_mutex_Surrender+0x164> 40006f6c: 82 10 20 01 mov 1, %g1 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 40006f70: c2 00 e0 08 ld [ %g3 + 8 ], %g1 the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 40006f74: c4 04 20 48 ld [ %l0 + 0x48 ], %g2 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 40006f78: c2 24 20 60 st %g1, [ %l0 + 0x60 ] } else #endif { the_mutex->holder = the_thread; 40006f7c: c6 24 20 5c st %g3, [ %l0 + 0x5c ] the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; 40006f80: 82 10 20 01 mov 1, %g1 switch ( the_mutex->Attributes.discipline ) { 40006f84: 80 a0 a0 02 cmp %g2, 2 40006f88: 02 80 00 21 be 4000700c <_CORE_mutex_Surrender+0x150> 40006f8c: c2 24 20 54 st %g1, [ %l0 + 0x54 ] 40006f90: 80 a0 a0 03 cmp %g2, 3 40006f94: 22 80 00 13 be,a 40006fe0 <_CORE_mutex_Surrender+0x124> 40006f98: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 40006f9c: 81 c7 e0 08 ret 40006fa0: 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 && 40006fa4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 40006fa8: 80 a0 60 00 cmp %g1, 0 40006fac: 12 bf ff ec bne 40006f5c <_CORE_mutex_Surrender+0xa0> 40006fb0: 01 00 00 00 nop 40006fb4: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 40006fb8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 40006fbc: 80 a2 40 01 cmp %o1, %g1 40006fc0: 02 bf ff e7 be 40006f5c <_CORE_mutex_Surrender+0xa0> 40006fc4: 01 00 00 00 nop holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 40006fc8: 40 00 07 42 call 40008cd0 <_Thread_Change_priority> 40006fcc: 94 10 20 01 mov 1, %o2 ! 1 40006fd0: 30 bf ff e3 b,a 40006f5c <_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--; 40006fd4: 82 00 7f ff add %g1, -1, %g1 40006fd8: 10 bf ff da b 40006f40 <_CORE_mutex_Surrender+0x84> 40006fdc: 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 < 40006fe0: 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++; 40006fe4: 82 00 60 01 inc %g1 <== NOT EXECUTED 40006fe8: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 40006fec: d2 04 20 4c ld [ %l0 + 0x4c ], %o1 <== NOT EXECUTED 40006ff0: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED 40006ff4: 1a 80 00 04 bcc 40007004 <_CORE_mutex_Surrender+0x148> <== NOT EXECUTED 40006ff8: b0 10 20 00 clr %i0 <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 40006ffc: 40 00 07 35 call 40008cd0 <_Thread_Change_priority> <== NOT EXECUTED 40007000: 94 10 20 00 clr %o2 <== NOT EXECUTED 40007004: 81 c7 e0 08 ret 40007008: 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++; 4000700c: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 40007010: 82 00 60 01 inc %g1 40007014: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] 40007018: 81 c7 e0 08 ret 4000701c: 91 e8 20 00 restore %g0, 0, %o0 } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 40007020: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 40007024: 81 c7 e0 08 ret 40007028: 91 e8 20 00 restore %g0, 0, %o0 4000cb20 <_Debug_Is_enabled>: */ boolean _Debug_Is_enabled( rtems_debug_control level ) { 4000cb20: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 4000cb24: c4 00 63 f0 ld [ %g1 + 0x3f0 ], %g2 ! 40019bf0 <_Debug_Level> <== NOT EXECUTED 4000cb28: 90 0a 00 02 and %o0, %g2, %o0 <== NOT EXECUTED return (_Debug_Level & level) ? TRUE : FALSE; } 4000cb2c: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 4000cb30: 81 c3 e0 08 retl <== NOT EXECUTED 4000cb34: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED 400054ec <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 400054ec: 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; 400054f0: 03 10 00 66 sethi %hi(0x40019800), %g1 400054f4: e0 00 63 ec ld [ %g1 + 0x3ec ], %l0 ! 40019bec <_Thread_Executing> executing->Wait.return_code = RTEMS_SUCCESSFUL; 400054f8: c0 24 20 34 clr [ %l0 + 0x34 ] api = executing->API_Extensions[ THREAD_API_RTEMS ]; _ISR_Disable( level ); 400054fc: 7f ff f2 37 call 40001dd8 40005500: e4 04 21 6c ld [ %l0 + 0x16c ], %l2 40005504: 84 10 00 08 mov %o0, %g2 pending_events = api->pending_events; 40005508: c2 04 a0 40 ld [ %l2 + 0x40 ], %g1 seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 4000550c: a2 8e 00 01 andcc %i0, %g1, %l1 40005510: 02 80 00 0e be 40005548 <_Event_Seize+0x5c> 40005514: 80 8e 60 01 btst 1, %i1 40005518: 80 a6 00 11 cmp %i0, %l1 4000551c: 02 80 00 04 be 4000552c <_Event_Seize+0x40> 40005520: 80 8e 60 02 btst 2, %i1 40005524: 02 80 00 09 be 40005548 <_Event_Seize+0x5c> 40005528: 80 8e 60 01 btst 1, %i1 (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 4000552c: 82 28 40 11 andn %g1, %l1, %g1 40005530: c2 24 a0 40 st %g1, [ %l2 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 40005534: 7f ff f2 2d call 40001de8 40005538: 01 00 00 00 nop *event_out = seized_events; 4000553c: e2 26 c0 00 st %l1, [ %i3 ] 40005540: 81 c7 e0 08 ret 40005544: 81 e8 00 00 restore return; } if ( _Options_Is_no_wait( option_set ) ) { 40005548: 12 80 00 1e bne 400055c0 <_Event_Seize+0xd4> 4000554c: 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; 40005550: 23 10 00 67 sethi %hi(0x40019c00), %l1 executing->Wait.option = (uint32_t ) option_set; 40005554: f2 24 20 30 st %i1, [ %l0 + 0x30 ] executing->Wait.count = (uint32_t ) event_in; 40005558: f0 24 20 24 st %i0, [ %l0 + 0x24 ] executing->Wait.return_argument = event_out; 4000555c: 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; 40005560: c2 24 62 24 st %g1, [ %l1 + 0x224 ] executing->Wait.option = (uint32_t ) option_set; executing->Wait.count = (uint32_t ) event_in; executing->Wait.return_argument = event_out; _ISR_Enable( level ); 40005564: 7f ff f2 21 call 40001de8 40005568: 90 10 00 02 mov %g2, %o0 if ( ticks ) { 4000556c: 80 a6 a0 00 cmp %i2, 0 40005570: 32 80 00 24 bne,a 40005600 <_Event_Seize+0x114> 40005574: c2 04 20 08 ld [ %l0 + 8 ], %g1 NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 40005578: 90 10 00 10 mov %l0, %o0 4000557c: 40 00 12 09 call 40009da0 <_Thread_Set_state> 40005580: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 40005584: 7f ff f2 15 call 40001dd8 40005588: 01 00 00 00 nop 4000558c: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 40005590: c4 04 62 24 ld [ %l1 + 0x224 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 40005594: c0 24 62 24 clr [ %l1 + 0x224 ] switch ( sync_state ) { 40005598: 80 a0 a0 02 cmp %g2, 2 4000559c: 02 80 00 30 be 4000565c <_Event_Seize+0x170> 400055a0: 82 10 20 06 mov 6, %g1 400055a4: 80 a0 a0 03 cmp %g2, 3 400055a8: 02 80 00 0d be 400055dc <_Event_Seize+0xf0> 400055ac: 80 a0 a0 01 cmp %g2, 1 400055b0: 02 80 00 31 be 40005674 <_Event_Seize+0x188> 400055b4: 01 00 00 00 nop 400055b8: 81 c7 e0 08 ret <== NOT EXECUTED 400055bc: 81 e8 00 00 restore <== NOT EXECUTED *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 400055c0: 7f ff f2 0a call 40001de8 400055c4: 90 10 00 02 mov %g2, %o0 executing->Wait.return_code = RTEMS_UNSATISFIED; 400055c8: 82 10 20 0d mov 0xd, %g1 400055cc: c2 24 20 34 st %g1, [ %l0 + 0x34 ] *event_out = seized_events; 400055d0: e2 26 c0 00 st %l1, [ %i3 ] 400055d4: 81 c7 e0 08 ret 400055d8: 81 e8 00 00 restore _ISR_Enable( level ); _Thread_Unblock( executing ); return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { 400055dc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400055e0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 400055e4: 22 80 00 26 be,a 4000567c <_Event_Seize+0x190> <== NOT EXECUTED 400055e8: 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 ); 400055ec: 7f ff f1 ff call 40001de8 <== NOT EXECUTED 400055f0: 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 ); 400055f4: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 400055f8: 40 00 0e 25 call 40008e8c <_Thread_Clear_state> <== NOT EXECUTED 400055fc: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40005600: 92 04 20 48 add %l0, 0x48, %o1 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 40005604: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40005608: 03 10 00 16 sethi %hi(0x40005800), %g1 4000560c: 82 10 60 b0 or %g1, 0xb0, %g1 ! 400058b0 <_Event_Timeout> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40005610: f4 24 20 54 st %i2, [ %l0 + 0x54 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40005614: c2 24 20 64 st %g1, [ %l0 + 0x64 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40005618: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 4000561c: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40005620: 11 10 00 67 sethi %hi(0x40019c00), %o0 40005624: 40 00 13 f6 call 4000a5fc <_Watchdog_Insert> 40005628: 90 12 20 0c or %o0, 0xc, %o0 ! 40019c0c <_Watchdog_Ticks_chain> NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 4000562c: 90 10 00 10 mov %l0, %o0 40005630: 40 00 11 dc call 40009da0 <_Thread_Set_state> 40005634: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 40005638: 7f ff f1 e8 call 40001dd8 4000563c: 01 00 00 00 nop 40005640: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 40005644: c4 04 62 24 ld [ %l1 + 0x224 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 40005648: c0 24 62 24 clr [ %l1 + 0x224 ] switch ( sync_state ) { 4000564c: 80 a0 a0 02 cmp %g2, 2 40005650: 12 bf ff d6 bne 400055a8 <_Event_Seize+0xbc> 40005654: 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; 40005658: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 4000565c: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40005660: 7f ff f1 e2 call 40001de8 <== NOT EXECUTED 40005664: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 40005668: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000566c: 40 00 0e 08 call 40008e8c <_Thread_Clear_state> <== NOT EXECUTED 40005670: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED * enter the synchronization states above. */ return; case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); 40005674: 7f ff f1 dd call 40001de8 40005678: 81 e8 00 00 restore return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); 4000567c: 7f ff f1 db call 40001de8 <== NOT EXECUTED 40005680: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED (void) _Watchdog_Remove( &executing->Timer ); 40005684: 40 00 14 48 call 4000a7a4 <_Watchdog_Remove> <== NOT EXECUTED 40005688: 90 04 20 48 add %l0, 0x48, %o0 <== NOT EXECUTED 4000568c: 10 bf ff db b 400055f8 <_Event_Seize+0x10c> <== NOT EXECUTED 40005690: b2 16 63 f8 or %i1, 0x3f8, %i1 <== NOT EXECUTED 40005790 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 40005790: 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 ]; 40005794: e0 06 21 6c ld [ %i0 + 0x16c ], %l0 option_set = (rtems_option) the_thread->Wait.option; 40005798: e4 06 20 30 ld [ %i0 + 0x30 ], %l2 _ISR_Disable( level ); 4000579c: 7f ff f1 8f call 40001dd8 400057a0: b2 10 00 18 mov %i0, %i1 400057a4: a2 10 00 08 mov %o0, %l1 pending_events = api->pending_events; 400057a8: c8 04 20 40 ld [ %l0 + 0x40 ], %g4 event_condition = (rtems_event_set) the_thread->Wait.count; 400057ac: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { 400057b0: 9a 88 c0 04 andcc %g3, %g4, %o5 400057b4: 02 80 00 20 be 40005834 <_Event_Surrender+0xa4> 400057b8: 01 00 00 00 nop if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 400057bc: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 400057c0: 80 88 61 00 btst 0x100, %g1 400057c4: 02 80 00 08 be 400057e4 <_Event_Surrender+0x54> 400057c8: 19 10 00 67 sethi %hi(0x40019c00), %o4 if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 400057cc: 80 a0 c0 0d cmp %g3, %o5 400057d0: 02 80 00 1b be 4000583c <_Event_Surrender+0xac> 400057d4: 80 8c a0 02 btst 2, %l2 400057d8: 12 80 00 1a bne 40005840 <_Event_Surrender+0xb0> 400057dc: 82 29 00 0d andn %g4, %o5, %g1 } return; } } switch ( _Event_Sync_state ) { 400057e0: 19 10 00 67 sethi %hi(0x40019c00), %o4 <== NOT EXECUTED 400057e4: c2 03 22 24 ld [ %o4 + 0x224 ], %g1 ! 40019e24 <_Event_Sync_state> <== NOT EXECUTED 400057e8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400057ec: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400057f0: 18 80 00 11 bgu 40005834 <_Event_Surrender+0xa4> <== NOT EXECUTED 400057f4: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED case EVENT_SYNC_SATISFIED: break; case EVENT_SYNC_NOTHING_HAPPENED: case EVENT_SYNC_TIMEOUT: if ( !_Thread_Is_executing( the_thread ) ) 400057f8: c4 00 63 ec ld [ %g1 + 0x3ec ], %g2 ! 40019bec <_Thread_Executing> <== NOT EXECUTED 400057fc: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED 40005800: 12 80 00 0d bne 40005834 <_Event_Surrender+0xa4> <== NOT EXECUTED 40005804: 80 a0 c0 0d cmp %g3, %o5 <== NOT EXECUTED break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 40005808: 02 80 00 04 be 40005818 <_Event_Surrender+0x88> <== NOT EXECUTED 4000580c: 80 8c a0 02 btst 2, %l2 <== NOT EXECUTED 40005810: 02 80 00 09 be 40005834 <_Event_Surrender+0xa4> <== NOT EXECUTED 40005814: 01 00 00 00 nop <== NOT EXECUTED api->pending_events = 40005818: 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; 4000581c: 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 = 40005820: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 40005824: 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; 40005828: 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; 4000582c: da 20 80 00 st %o5, [ %g2 ] <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_SATISFIED; 40005830: c2 23 22 24 st %g1, [ %o4 + 0x224 ] <== NOT EXECUTED } break; } } _ISR_Enable( level ); 40005834: 7f ff f1 6d call 40001de8 40005838: 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 = 4000583c: 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; 40005840: 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 = 40005844: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 40005848: c0 26 60 24 clr [ %i1 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 4000584c: da 20 80 00 st %o5, [ %g2 ] _ISR_Flash( level ); 40005850: 7f ff f1 66 call 40001de8 40005854: 01 00 00 00 nop 40005858: 7f ff f1 60 call 40001dd8 4000585c: 01 00 00 00 nop if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 40005860: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 40005864: 80 a0 60 02 cmp %g1, 2 40005868: 02 80 00 08 be 40005888 <_Event_Surrender+0xf8> 4000586c: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 40005870: 90 10 00 11 mov %l1, %o0 40005874: 7f ff f1 5d call 40001de8 40005878: 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 ); 4000587c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 40005880: 40 00 0d 83 call 40008e8c <_Thread_Clear_state> 40005884: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 40005888: c2 26 60 50 st %g1, [ %i1 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000588c: 7f ff f1 57 call 40001de8 40005890: 90 10 00 11 mov %l1, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 40005894: 40 00 13 c4 call 4000a7a4 <_Watchdog_Remove> 40005898: 90 06 60 48 add %i1, 0x48, %o0 4000589c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 400058a0: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 400058a4: 40 00 0d 7a call 40008e8c <_Thread_Clear_state> 400058a8: 81 e8 00 00 restore 400058ac: 01 00 00 00 nop 400058b0 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 400058b0: 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 ) ) { 400058b4: 92 96 20 00 orcc %i0, 0, %o1 400058b8: 12 80 00 25 bne 4000594c <_Event_Timeout+0x9c> 400058bc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400058c0: 21 10 00 66 sethi %hi(0x40019800), %l0 <== NOT EXECUTED 400058c4: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400058c8: 82 00 60 01 inc %g1 <== NOT EXECUTED 400058cc: c2 24 23 10 st %g1, [ %l0 + 0x310 ] <== NOT EXECUTED Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 400058d0: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 400058d4: f0 00 63 ec ld [ %g1 + 0x3ec ], %i0 ! 40019bec <_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; 400058d8: 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 ); 400058dc: 7f ff f1 3f call 40001dd8 400058e0: 01 00 00 00 nop 400058e4: 88 10 00 08 mov %o0, %g4 if ( the_thread->Wait.count ) { /* verify thread is waiting */ 400058e8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 400058ec: 80 a0 60 00 cmp %g1, 0 400058f0: 02 80 00 3a be 400059d8 <_Event_Timeout+0x128> 400058f4: 07 10 00 67 sethi %hi(0x40019c00), %g3 the_thread->Wait.count = 0; if ( _Event_Sync_state != EVENT_SYNC_SYNCHRONIZED && 400058f8: c2 00 e2 24 ld [ %g3 + 0x224 ], %g1 ! 40019e24 <_Event_Sync_state> 400058fc: 80 a0 60 00 cmp %g1, 0 40005900: 02 80 00 29 be 400059a4 <_Event_Timeout+0xf4> 40005904: c0 26 20 24 clr [ %i0 + 0x24 ] 40005908: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 4000590c: c4 00 63 ec ld [ %g1 + 0x3ec ], %g2 ! 40019bec <_Thread_Executing> <== NOT EXECUTED 40005910: 80 a6 00 02 cmp %i0, %g2 <== NOT EXECUTED 40005914: 12 80 00 25 bne 400059a8 <_Event_Timeout+0xf8> <== NOT EXECUTED 40005918: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { 4000591c: c2 00 e2 24 ld [ %g3 + 0x224 ], %g1 <== NOT EXECUTED 40005920: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 40005924: 02 80 00 03 be 40005930 <_Event_Timeout+0x80> <== NOT EXECUTED 40005928: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_TIMEOUT; 4000592c: c2 20 e2 24 st %g1, [ %g3 + 0x224 ] <== NOT EXECUTED } _ISR_Enable( level ); 40005930: 7f ff f1 2e call 40001de8 <== NOT EXECUTED 40005934: 01 00 00 00 nop <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 40005938: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 <== NOT EXECUTED 4000593c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40005940: c2 24 23 10 st %g1, [ %l0 + 0x310 ] <== NOT EXECUTED 40005944: 81 c7 e0 08 ret <== NOT EXECUTED 40005948: 81 e8 00 00 restore <== NOT EXECUTED 4000594c: 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 ) { 40005950: 80 a0 a0 04 cmp %g2, 4 40005954: 18 bf ff fc bgu 40005944 <_Event_Timeout+0x94> 40005958: 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 :) */ 4000595c: 80 a0 60 01 cmp %g1, 1 40005960: 12 bf ff f9 bne 40005944 <_Event_Timeout+0x94> 40005964: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40005968: 05 10 00 66 sethi %hi(0x40019800), %g2 4000596c: 84 10 a2 70 or %g2, 0x270, %g2 ! 40019a70 <_Objects_Information_table> 40005970: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40005974: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40005978: 80 a2 20 00 cmp %o0, 0 4000597c: 02 80 00 15 be 400059d0 <_Event_Timeout+0x120> 40005980: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40005984: 40 00 08 cf call 40007cc0 <_Objects_Get> 40005988: 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 ) { 4000598c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005990: 80 a0 60 00 cmp %g1, 0 40005994: 12 bf ff ec bne 40005944 <_Event_Timeout+0x94> 40005998: b0 10 00 08 mov %o0, %i0 4000599c: 10 bf ff d0 b 400058dc <_Event_Timeout+0x2c> 400059a0: 21 10 00 66 sethi %hi(0x40019800), %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; 400059a4: 82 10 20 06 mov 6, %g1 400059a8: c2 26 20 34 st %g1, [ %i0 + 0x34 ] _ISR_Enable( level ); 400059ac: 7f ff f1 0f call 40001de8 400059b0: 90 10 00 04 mov %g4, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 400059b4: 13 04 00 ff sethi %hi(0x1003fc00), %o1 400059b8: 90 10 00 18 mov %i0, %o0 400059bc: 40 00 0d 34 call 40008e8c <_Thread_Clear_state> 400059c0: 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; 400059c4: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 400059c8: 82 00 7f ff add %g1, -1, %g1 400059cc: c2 24 23 10 st %g1, [ %l0 + 0x310 ] 400059d0: 81 c7 e0 08 ret 400059d4: 81 e8 00 00 restore _Thread_Unblock( the_thread ); } } else { _ISR_Enable( level ); 400059d8: 7f ff f1 04 call 40001de8 <== NOT EXECUTED 400059dc: 01 00 00 00 nop <== NOT EXECUTED 400059e0: 30 bf ff f9 b,a 400059c4 <_Event_Timeout+0x114> <== NOT EXECUTED 40007200 <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 40007200: 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 = 40007204: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 40007208: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 4000720c: 90 10 00 19 mov %i1, %o0 40007210: 40 00 00 cd call 40007544 <_Heap_Calc_block_size> 40007214: 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) 40007218: 80 a2 20 00 cmp %o0, 0 4000721c: 22 80 00 1a be,a 40007284 <_Heap_Allocate+0x84> 40007220: 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; 40007224: 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; 40007228: 80 a4 00 18 cmp %l0, %i0 4000722c: 22 80 00 16 be,a 40007284 <_Heap_Allocate+0x84> 40007230: 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) { 40007234: c2 06 20 04 ld [ %i0 + 4 ], %g1 40007238: 80 a2 00 01 cmp %o0, %g1 4000723c: 08 80 00 16 bleu 40007294 <_Heap_Allocate+0x94> 40007240: 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) 40007244: 10 80 00 07 b 40007260 <_Heap_Allocate+0x60> 40007248: 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) { 4000724c: c2 06 20 04 ld [ %i0 + 4 ], %g1 40007250: 80 a2 00 01 cmp %o0, %g1 40007254: 08 80 00 11 bleu 40007298 <_Heap_Allocate+0x98> 40007258: 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) 4000725c: 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; 40007260: 80 a4 00 18 cmp %l0, %i0 40007264: 12 bf ff fa bne 4000724c <_Heap_Allocate+0x4c> 40007268: b2 06 60 01 inc %i1 4000726c: b0 10 20 00 clr %i0 _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 40007270: c2 04 20 44 ld [ %l0 + 0x44 ], %g1 40007274: 80 a6 40 01 cmp %i1, %g1 40007278: 08 80 00 05 bleu 4000728c <_Heap_Allocate+0x8c> 4000727c: 01 00 00 00 nop stats->max_search = search_count; 40007280: f2 24 20 44 st %i1, [ %l0 + 0x44 ] 40007284: 81 c7 e0 08 ret 40007288: 81 e8 00 00 restore return ptr; } 4000728c: 81 c7 e0 08 ret 40007290: 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 ); 40007294: 94 10 00 08 mov %o0, %o2 40007298: 92 10 00 18 mov %i0, %o1 4000729c: 40 00 00 7e call 40007494 <_Heap_Block_allocate> 400072a0: 90 10 00 10 mov %l0, %o0 ptr = _Heap_User_area(the_block); stats->allocs += 1; 400072a4: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 stats->searches += search_count + 1; 400072a8: 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; 400072ac: 82 00 60 01 inc %g1 stats->searches += search_count + 1; 400072b0: 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; 400072b4: c2 24 20 48 st %g1, [ %l0 + 0x48 ] stats->searches += search_count + 1; 400072b8: 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); 400072bc: b0 06 20 08 add %i0, 8, %i0 400072c0: 10 bf ff ec b 40007270 <_Heap_Allocate+0x70> 400072c4: c4 24 20 4c st %g2, [ %l0 + 0x4c ] 40007544 <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 40007544: 9d e3 bf 98 save %sp, -104, %sp 40007548: a0 10 00 19 mov %i1, %l0 uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 4000754c: b2 06 20 04 add %i0, 4, %i1 uint32_t alignment ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; 40007550: 92 10 00 10 mov %l0, %o1 40007554: 40 00 37 ce call 4001548c <.urem> 40007558: 90 10 00 19 mov %i1, %o0 *value = r ? v - r + a : v; 4000755c: 80 a2 20 00 cmp %o0, 0 40007560: 02 80 00 04 be 40007570 <_Heap_Calc_block_size+0x2c> 40007564: 82 10 00 19 mov %i1, %g1 40007568: 82 04 00 19 add %l0, %i1, %g1 4000756c: 82 20 40 08 sub %g1, %o0, %g1 40007570: 80 a0 40 1a cmp %g1, %i2 40007574: 2a 80 00 02 bcs,a 4000757c <_Heap_Calc_block_size+0x38> 40007578: 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; 4000757c: 80 a6 00 01 cmp %i0, %g1 40007580: 1a 80 00 03 bcc 4000758c <_Heap_Calc_block_size+0x48> 40007584: b0 10 20 00 clr %i0 40007588: b0 10 00 01 mov %g1, %i0 } 4000758c: 81 c7 e0 08 ret 40007590: 81 e8 00 00 restore 4001ab98 <_Heap_Get_free_information>: */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 4001ab98: 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; 4001ab9c: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED info->largest = 0; 4001aba0: c0 22 60 04 clr [ %o1 + 4 ] <== NOT EXECUTED info->total = 0; 4001aba4: c0 22 60 08 clr [ %o1 + 8 ] <== NOT EXECUTED for(the_block = _Heap_First(the_heap); the_block != tail; 4001aba8: 80 a2 00 0d cmp %o0, %o5 <== NOT EXECUTED 4001abac: 02 80 00 12 be 4001abf4 <_Heap_Get_free_information+0x5c> <== NOT EXECUTED 4001abb0: 98 10 20 00 clr %o4 <== NOT EXECUTED 4001abb4: 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); 4001abb8: 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 ) 4001abbc: c6 02 60 04 ld [ %o1 + 4 ], %g3 <== NOT EXECUTED 4001abc0: 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++; 4001abc4: 84 00 a0 01 inc %g2 <== NOT EXECUTED info->total += the_size; 4001abc8: 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++; 4001abcc: c4 22 40 00 st %g2, [ %o1 ] <== NOT EXECUTED info->total += the_size; 4001abd0: c2 22 60 08 st %g1, [ %o1 + 8 ] <== NOT EXECUTED if ( info->largest < the_size ) 4001abd4: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED 4001abd8: 08 80 00 03 bleu 4001abe4 <_Heap_Get_free_information+0x4c> <== NOT EXECUTED 4001abdc: 98 10 00 01 mov %g1, %o4 <== NOT EXECUTED info->largest = the_size; 4001abe0: 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) 4001abe4: 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; 4001abe8: 80 a2 00 0d cmp %o0, %o5 <== NOT EXECUTED 4001abec: 32 bf ff f4 bne,a 4001abbc <_Heap_Get_free_information+0x24> <== NOT EXECUTED 4001abf0: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED 4001abf4: 81 c3 e0 08 retl <== NOT EXECUTED 4001abf8: 01 00 00 00 nop 40007594 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 40007594: 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) 40007598: 80 a6 e0 00 cmp %i3, 0 4000759c: 12 80 00 43 bne 400076a8 <_Heap_Initialize+0x114> 400075a0: 84 8e e0 07 andcc %i3, 7, %g2 400075a4: b6 10 20 08 mov 8, %i3 <== NOT EXECUTED 400075a8: 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; 400075ac: 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; 400075b0: 92 10 00 1b mov %i3, %o1 400075b4: 40 00 37 b6 call 4001548c <.urem> 400075b8: 90 10 00 10 mov %l0, %o0 *value = r ? v - r + a : v; 400075bc: 80 a2 20 00 cmp %o0, 0 400075c0: 02 80 00 05 be 400075d4 <_Heap_Initialize+0x40> 400075c4: a2 04 3f f8 add %l0, -8, %l1 400075c8: 82 06 c0 10 add %i3, %l0, %g1 400075cc: a0 20 40 08 sub %g1, %o0, %l0 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 400075d0: 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; 400075d4: 80 a4 a0 00 cmp %l2, 0 400075d8: 02 80 00 04 be 400075e8 <_Heap_Initialize+0x54> 400075dc: 82 10 20 10 mov 0x10, %g1 400075e0: 82 06 e0 10 add %i3, 0x10, %g1 400075e4: 82 20 40 12 sub %g1, %l2, %g1 400075e8: 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); 400075ec: 82 24 40 19 sub %l1, %i1, %g1 400075f0: 82 00 60 08 add %g1, 8, %g1 if ( size < overhead ) 400075f4: 80 a0 40 1a cmp %g1, %i2 400075f8: 18 80 00 2a bgu 400076a0 <_Heap_Initialize+0x10c> 400075fc: a0 26 80 01 sub %i2, %g1, %l0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 40007600: 92 10 00 1b mov %i3, %o1 40007604: 40 00 37 a2 call 4001548c <.urem> 40007608: 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 ) 4000760c: a0 a4 00 08 subcc %l0, %o0, %l0 40007610: 02 80 00 24 be 400076a0 <_Heap_Initialize+0x10c> 40007614: 09 10 00 66 sethi %hi(0x40019800), %g4 return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 40007618: 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; 4000761c: f6 24 40 00 st %i3, [ %l1 ] the_block->size = the_size | HEAP_PREV_USED; 40007620: 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++; 40007624: c6 01 20 e8 ld [ %g4 + 0xe8 ], %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; 40007628: 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 */ 4000762c: 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 ); 40007630: 9a 04 40 10 add %l1, %l0, %o5 the_block->size = page_size; 40007634: 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 ); 40007638: f0 24 60 08 st %i0, [ %l1 + 8 ] the_block->prev = _Heap_Head( the_heap ); 4000763c: 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++; 40007640: 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; 40007644: f4 26 20 2c st %i2, [ %i0 + 0x2c ] stats->free_size = the_size; 40007648: e0 26 20 30 st %l0, [ %i0 + 0x30 ] stats->min_free_size = the_size; 4000764c: e0 26 20 34 st %l0, [ %i0 + 0x34 ] stats->free_blocks = 1; stats->max_free_blocks = 1; stats->used_blocks = 0; 40007650: c0 26 20 40 clr [ %i0 + 0x40 ] stats->max_search = 0; 40007654: c0 26 20 44 clr [ %i0 + 0x44 ] stats->allocs = 0; 40007658: c0 26 20 48 clr [ %i0 + 0x48 ] stats->searches = 0; 4000765c: c0 26 20 4c clr [ %i0 + 0x4c ] stats->frees = 0; 40007660: c0 26 20 50 clr [ %i0 + 0x50 ] stats->resizes = 0; 40007664: 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; 40007668: 84 10 20 01 mov 1, %g2 stats->max_free_blocks = 1; 4000766c: 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; 40007670: 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; 40007674: 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++; 40007678: 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; 4000767c: 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; 40007680: 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; 40007684: e2 26 20 08 st %l1, [ %i0 + 8 ] _Heap_Tail(the_heap)->prev = the_block; 40007688: e2 26 20 0c st %l1, [ %i0 + 0xc ] the_heap->start = the_block; 4000768c: 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 */ 40007690: 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++; 40007694: c6 21 20 e8 st %g3, [ %g4 + 0xe8 ] return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 40007698: 81 c7 e0 08 ret 4000769c: 91 ec 3f fc restore %l0, -4, %o0 } 400076a0: 81 c7 e0 08 ret 400076a4: 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; 400076a8: 02 80 00 04 be 400076b8 <_Heap_Initialize+0x124> 400076ac: 90 10 20 10 mov 0x10, %o0 400076b0: 82 06 e0 08 add %i3, 8, %g1 400076b4: b6 20 40 02 sub %g1, %g2, %i3 400076b8: 40 00 37 75 call 4001548c <.urem> 400076bc: 92 10 00 1b mov %i3, %o1 400076c0: 10 bf ff bb b 400075ac <_Heap_Initialize+0x18> 400076c4: a4 10 00 08 mov %o0, %l2 4000cd44 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 4000cd44: 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; 4000cd48: 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; 4000cd4c: ee 06 20 14 ld [ %i0 + 0x14 ], %l7 <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; *old_mem_size = 0; 4000cd50: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED *avail_mem_size = 0; 4000cd54: 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); 4000cd58: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4000cd5c: 40 00 21 cc call 4001548c <.urem> <== NOT EXECUTED 4000cd60: 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 ); 4000cd64: 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); 4000cd68: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 4000cd6c: 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)) 4000cd70: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED 4000cd74: 1a 80 00 05 bcc 4000cd88 <_Heap_Resize_block+0x44> <== NOT EXECUTED 4000cd78: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 4000cd7c: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED } 4000cd80: 81 c7 e0 08 ret <== NOT EXECUTED 4000cd84: 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)) 4000cd88: 80 a4 80 02 cmp %l2, %g2 <== NOT EXECUTED 4000cd8c: 38 bf ff fd bgu,a 4000cd80 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 4000cd90: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 4000cd94: 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); 4000cd98: 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 ); 4000cd9c: 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) || 4000cda0: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 4000cda4: 2a bf ff f7 bcs,a 4000cd80 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 4000cda8: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 4000cdac: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 4000cdb0: 38 bf ff f4 bgu,a 4000cd80 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 4000cdb4: 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); 4000cdb8: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED 4000cdbc: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 4000cdc0: 02 bf ff ef be 4000cd7c <_Heap_Resize_block+0x38> <== NOT EXECUTED 4000cdc4: 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) || 4000cdc8: 80 a0 80 11 cmp %g2, %l1 <== NOT EXECUTED 4000cdcc: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED 4000cdd0: 02 80 00 04 be 4000cde0 <_Heap_Resize_block+0x9c> <== NOT EXECUTED 4000cdd4: ba 04 40 15 add %l1, %l5, %i5 <== NOT EXECUTED 4000cdd8: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED 4000cddc: 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) 4000cde0: 82 24 40 19 sub %l1, %i1, %g1 <== NOT EXECUTED 4000cde4: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 4000cde8: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED if (size > old_user_size) { 4000cdec: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED 4000cdf0: 1a 80 00 16 bcc 4000ce48 <_Heap_Resize_block+0x104> <== NOT EXECUTED 4000cdf4: 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 */ 4000cdf8: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 4000cdfc: 12 80 00 10 bne 4000ce3c <_Heap_Resize_block+0xf8> <== NOT EXECUTED 4000ce00: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 4000ce04: 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; 4000ce08: 40 00 21 a1 call 4001548c <.urem> <== NOT EXECUTED 4000ce0c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED *value = r ? v - r + a : v; 4000ce10: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000ce14: 02 80 00 05 be 4000ce28 <_Heap_Resize_block+0xe4> <== NOT EXECUTED 4000ce18: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED 4000ce1c: 82 04 00 13 add %l0, %l3, %g1 <== NOT EXECUTED 4000ce20: a0 20 40 08 sub %g1, %o0, %l0 <== NOT EXECUTED 4000ce24: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED 4000ce28: 0a 80 00 1d bcs 4000ce9c <_Heap_Resize_block+0x158> <== NOT EXECUTED 4000ce2c: 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) 4000ce30: 80 a5 40 08 cmp %l5, %o0 <== NOT EXECUTED 4000ce34: 1a 80 00 1f bcc 4000ceb0 <_Heap_Resize_block+0x16c> <== NOT EXECUTED 4000ce38: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 4000ce3c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED } 4000ce40: 81 c7 e0 08 ret <== NOT EXECUTED 4000ce44: 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; 4000ce48: a0 20 40 1a sub %g1, %i2, %l0 <== NOT EXECUTED uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 4000ce4c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 4000ce50: 40 00 21 8f call 4001548c <.urem> <== NOT EXECUTED 4000ce54: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 4000ce58: a0 a4 00 08 subcc %l0, %o0, %l0 <== NOT EXECUTED 4000ce5c: 22 80 00 0b be,a 4000ce88 <_Heap_Resize_block+0x144> <== NOT EXECUTED 4000ce60: 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; 4000ce64: 86 25 00 10 sub %l4, %l0, %g3 <== NOT EXECUTED if (new_block_size < min_block_size) { 4000ce68: 80 a5 c0 03 cmp %l7, %g3 <== NOT EXECUTED 4000ce6c: 08 80 00 1c bleu 4000cedc <_Heap_Resize_block+0x198> <== NOT EXECUTED 4000ce70: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 4000ce74: 82 25 c0 03 sub %l7, %g3, %g1 <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 4000ce78: a0 a4 00 01 subcc %l0, %g1, %l0 <== NOT EXECUTED 4000ce7c: 32 80 00 17 bne,a 4000ced8 <_Heap_Resize_block+0x194> <== NOT EXECUTED 4000ce80: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 4000ce84: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 4000ce88: 84 10 20 00 clr %g2 <== NOT EXECUTED 4000ce8c: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000ce90: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } 4000ce94: 81 c7 e0 08 ret <== NOT EXECUTED 4000ce98: 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; 4000ce9c: 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) 4000cea0: 80 a5 40 08 cmp %l5, %o0 <== NOT EXECUTED 4000cea4: 0a bf ff e7 bcs 4000ce40 <_Heap_Resize_block+0xfc> <== NOT EXECUTED 4000cea8: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 4000ceac: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4000ceb0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 4000ceb4: 7f ff e9 78 call 40007494 <_Heap_Block_allocate> <== NOT EXECUTED 4000ceb8: 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; 4000cebc: 90 02 00 14 add %o0, %l4, %o0 <== NOT EXECUTED 4000cec0: 90 12 00 1b or %o0, %i3, %o0 <== NOT EXECUTED 4000cec4: d0 24 a0 04 st %o0, [ %l2 + 4 ] <== NOT EXECUTED --stats->used_blocks; 4000cec8: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED 4000cecc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000ced0: 10 bf ff ed b 4000ce84 <_Heap_Resize_block+0x140> <== NOT EXECUTED 4000ced4: 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) { 4000ced8: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 4000cedc: 12 80 00 15 bne 4000cf30 <_Heap_Resize_block+0x1ec> <== NOT EXECUTED 4000cee0: 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; 4000cee4: 82 10 c0 1b or %g3, %i3, %g1 <== NOT EXECUTED 4000cee8: 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 ); 4000ceec: 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; 4000cef0: 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; 4000cef4: 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; 4000cef8: 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; 4000cefc: 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; 4000cf00: 84 11 20 01 or %g4, 1, %g2 <== NOT EXECUTED 4000cf04: 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; 4000cf08: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED Heap_Block *prev = block->prev; block = new_block; block->next = next; 4000cf0c: da 20 e0 08 st %o5, [ %g3 + 8 ] <== NOT EXECUTED 4000cf10: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED block->prev = prev; 4000cf14: d8 20 e0 0c st %o4, [ %g3 + 0xc ] <== NOT EXECUTED 4000cf18: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 4000cf1c: 88 01 3f fc add %g4, -4, %g4 <== NOT EXECUTED next->prev = prev->next = block; 4000cf20: c6 23 60 0c st %g3, [ %o5 + 0xc ] <== NOT EXECUTED 4000cf24: c6 23 20 08 st %g3, [ %o4 + 8 ] <== NOT EXECUTED 4000cf28: 10 bf ff d7 b 4000ce84 <_Heap_Resize_block+0x140> <== NOT EXECUTED 4000cf2c: c8 27 00 00 st %g4, [ %i4 ] <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 4000cf30: 2a bf ff d6 bcs,a 4000ce88 <_Heap_Resize_block+0x144> <== NOT EXECUTED 4000cf34: 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; 4000cf38: 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; 4000cf3c: 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; 4000cf40: 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 ); 4000cf44: 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; 4000cf48: c4 22 60 04 st %g2, [ %o1 + 4 ] <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 4000cf4c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000cf50: 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 */ 4000cf54: 82 00 60 01 inc %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000cf58: 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 */ 4000cf5c: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 4000cf60: c4 26 20 50 st %g2, [ %i0 + 0x50 ] <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 4000cf64: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 4000cf68: 7f ff e8 d8 call 400072c8 <_Heap_Free> <== NOT EXECUTED 4000cf6c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 4000cf70: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED 4000cf74: 10 bf ff c4 b 4000ce84 <_Heap_Resize_block+0x140> <== NOT EXECUTED 4000cf78: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED 4000cf7c <_Heap_Size_of_user_area>: boolean _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 4000cf7c: 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( 4000cf80: e0 06 20 20 ld [ %i0 + 0x20 ], %l0 <== NOT EXECUTED 4000cf84: 80 a6 40 10 cmp %i1, %l0 <== NOT EXECUTED 4000cf88: 0a 80 00 05 bcs 4000cf9c <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000cf8c: e2 06 20 24 ld [ %i0 + 0x24 ], %l1 <== NOT EXECUTED 4000cf90: 80 a6 40 11 cmp %i1, %l1 <== NOT EXECUTED 4000cf94: 28 80 00 04 bleu,a 4000cfa4 <_Heap_Size_of_user_area+0x28> <== NOT EXECUTED 4000cf98: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 <== NOT EXECUTED *size = _Addresses_Subtract ( next_block, starting_address ) + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); } 4000cf9c: 81 c7 e0 08 ret <== NOT EXECUTED 4000cfa0: 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); 4000cfa4: 40 00 21 3a call 4001548c <.urem> <== NOT EXECUTED 4000cfa8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4000cfac: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 4000cfb0: 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 ) ) 4000cfb4: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 4000cfb8: 0a bf ff f9 bcs 4000cf9c <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000cfbc: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 4000cfc0: 18 bf ff f7 bgu 4000cf9c <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000cfc4: 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 ); 4000cfc8: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4000cfcc: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 4000cfd0: 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 ( 4000cfd4: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 4000cfd8: 0a bf ff f1 bcs 4000cf9c <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000cfdc: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 4000cfe0: 18 bf ff ef bgu 4000cf9c <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000cfe4: 01 00 00 00 nop <== NOT EXECUTED 4000cfe8: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4000cfec: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 4000cff0: 02 bf ff eb be 4000cf9c <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 4000cff4: 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 ) 4000cff8: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED 4000cffc: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 4000d000: 81 c7 e0 08 ret <== NOT EXECUTED 4000d004: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED 40006a60 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 40006a60: 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 ) 40006a64: 80 a6 80 19 cmp %i2, %i1 40006a68: 08 80 00 27 bleu 40006b04 <_IO_Manager_initialization+0xa4> 40006a6c: 03 10 00 67 sethi %hi(0x40019c00), %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 *) 40006a70: 83 2e a0 03 sll %i2, 3, %g1 <== NOT EXECUTED 40006a74: a1 2e a0 05 sll %i2, 5, %l0 <== NOT EXECUTED 40006a78: a0 24 00 01 sub %l0, %g1, %l0 <== NOT EXECUTED 40006a7c: 40 00 0f ab call 4000a928 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 40006a80: 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; 40006a84: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED memset( 40006a88: 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; 40006a8c: f4 20 62 74 st %i2, [ %g1 + 0x274 ] <== 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 *) 40006a90: 21 10 00 67 sethi %hi(0x40019c00), %l0 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 40006a94: 92 10 20 00 clr %o1 <== NOT EXECUTED 40006a98: 40 00 1f aa call 4000e940 <== NOT EXECUTED 40006a9c: d0 24 22 78 st %o0, [ %l0 + 0x278 ] <== NOT EXECUTED _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 40006aa0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40006aa4: 02 80 00 16 be 40006afc <_IO_Manager_initialization+0x9c> <== NOT EXECUTED 40006aa8: d4 04 22 78 ld [ %l0 + 0x278 ], %o2 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40006aac: 96 10 20 00 clr %o3 <== NOT EXECUTED 40006ab0: 98 10 20 00 clr %o4 <== NOT EXECUTED 40006ab4: c2 03 00 18 ld [ %o4 + %i0 ], %g1 <== NOT EXECUTED 40006ab8: 9a 03 00 18 add %o4, %i0, %o5 <== NOT EXECUTED 40006abc: c2 23 00 0a st %g1, [ %o4 + %o2 ] <== NOT EXECUTED 40006ac0: c4 03 60 04 ld [ %o5 + 4 ], %g2 <== NOT EXECUTED 40006ac4: 86 03 00 0a add %o4, %o2, %g3 <== NOT EXECUTED 40006ac8: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED 40006acc: 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++ ) 40006ad0: 96 02 e0 01 inc %o3 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40006ad4: c2 20 e0 08 st %g1, [ %g3 + 8 ] <== NOT EXECUTED 40006ad8: 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++ ) 40006adc: 98 03 20 18 add %o4, 0x18, %o4 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40006ae0: c4 20 e0 0c st %g2, [ %g3 + 0xc ] <== NOT EXECUTED 40006ae4: 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++ ) 40006ae8: 80 a2 c0 19 cmp %o3, %i1 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 40006aec: c8 20 e0 10 st %g4, [ %g3 + 0x10 ] <== NOT EXECUTED 40006af0: 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++ ) 40006af4: 12 bf ff f0 bne 40006ab4 <_IO_Manager_initialization+0x54> <== NOT EXECUTED 40006af8: c2 20 e0 14 st %g1, [ %g3 + 0x14 ] <== NOT EXECUTED 40006afc: 81 c7 e0 08 ret <== NOT EXECUTED 40006b00: 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; 40006b04: 05 10 00 67 sethi %hi(0x40019c00), %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; 40006b08: f0 20 62 78 st %i0, [ %g1 + 0x278 ] _IO_Number_of_drivers = number_of_drivers; 40006b0c: f2 20 a2 74 st %i1, [ %g2 + 0x274 ] 40006b10: 81 c7 e0 08 ret 40006b14: 81 e8 00 00 restore 40007708 <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 40007708: 9d e3 bf 98 save %sp, -104, %sp _ISR_Signals_to_thread_executing = FALSE; 4000770c: 03 10 00 67 sethi %hi(0x40019c00), %g1 _ISR_Nest_level = 0; 40007710: 05 10 00 66 sethi %hi(0x40019800), %g2 * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { _ISR_Signals_to_thread_executing = FALSE; 40007714: c0 20 60 98 clr [ %g1 + 0x98 ] _ISR_Nest_level = 0; 40007718: c0 20 a3 d4 clr [ %g2 + 0x3d4 ] _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 4000771c: 40 00 0c 83 call 4000a928 <_Workspace_Allocate_or_fatal_error> 40007720: 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 ) 40007724: 03 10 00 66 sethi %hi(0x40019800), %g1 40007728: a0 10 63 24 or %g1, 0x324, %l0 ! 40019b24 <_CPU_Table> 4000772c: 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( 40007730: 03 10 00 66 sethi %hi(0x40019800), %g1 _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 40007734: 80 a0 af ff cmp %g2, 0xfff 40007738: 18 80 00 07 bgu 40007754 <_ISR_Handler_initialization+0x4c> 4000773c: d0 20 63 b4 st %o0, [ %g1 + 0x3b4 ] _Internal_error_Occurred( 40007740: 90 10 20 00 clr %o0 <== NOT EXECUTED 40007744: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40007748: 7f ff ff e0 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 4000774c: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED 40007750: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 40007754: 40 00 0c 75 call 4000a928 <_Workspace_Allocate_or_fatal_error> 40007758: 90 10 00 02 mov %g2, %o0 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 4000775c: c6 04 20 18 ld [ %l0 + 0x18 ], %g3 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 40007760: 03 10 00 66 sethi %hi(0x40019800), %g1 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 40007764: 86 02 00 03 add %o0, %g3, %g3 40007768: 05 10 00 66 sethi %hi(0x40019800), %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 4000776c: d0 20 63 20 st %o0, [ %g1 + 0x320 ] _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 40007770: c6 20 a2 6c st %g3, [ %g2 + 0x26c ] #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 40007774: 81 c7 e0 08 ret 40007778: 81 e8 00 00 restore 4000d018 <_Objects_Compare_name_string>: boolean _Objects_Compare_name_string( void *name_1, void *name_2, uint16_t length ) { 4000d018: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if ( !strncmp( name_1, name_2, length ) ) 4000d01c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000d020: 95 2e a0 10 sll %i2, 0x10, %o2 <== NOT EXECUTED 4000d024: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000d028: 40 00 09 42 call 4000f530 <== NOT EXECUTED 4000d02c: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED return TRUE; return FALSE; } 4000d030: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 4000d034: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 4000d038: 81 c7 e0 08 ret <== NOT EXECUTED 4000d03c: 81 e8 00 00 restore <== NOT EXECUTED 400193b8 <_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; 400193b8: 95 32 a0 02 srl %o2, 2, %o2 <== NOT EXECUTED while ( tmp_length-- ) 400193bc: 80 a2 a0 00 cmp %o2, 0 <== NOT EXECUTED 400193c0: 02 80 00 09 be 400193e4 <_Objects_Copy_name_raw+0x2c> <== NOT EXECUTED 400193c4: 86 10 20 00 clr %g3 <== NOT EXECUTED 400193c8: 84 10 20 00 clr %g2 <== NOT EXECUTED *destination_p++ = *source_p++; 400193cc: c2 00 80 08 ld [ %g2 + %o0 ], %g1 <== NOT EXECUTED 400193d0: 86 00 e0 01 inc %g3 <== NOT EXECUTED 400193d4: 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-- ) 400193d8: 80 a0 c0 0a cmp %g3, %o2 <== NOT EXECUTED 400193dc: 12 bf ff fc bne 400193cc <_Objects_Copy_name_raw+0x14> <== NOT EXECUTED 400193e0: 84 00 a0 04 add %g2, 4, %g2 <== NOT EXECUTED 400193e4: 81 c3 e0 08 retl <== NOT EXECUTED 400193e8: 01 00 00 00 nop 40007830 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 40007830: 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; 40007834: 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 ) 40007838: e4 16 20 10 lduh [ %i0 + 0x10 ], %l2 4000783c: 03 00 00 3f sethi %hi(0xfc00), %g1 40007840: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40007844: a2 08 80 01 and %g2, %g1, %l1 40007848: 80 a4 40 12 cmp %l1, %l2 4000784c: 08 80 00 8c bleu 40007a7c <_Objects_Extend_information+0x24c> 40007850: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 40007854: 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 ) 40007858: a8 10 00 11 mov %l1, %l4 4000785c: ac 10 20 00 clr %l6 40007860: a6 10 20 01 mov 1, %l3 40007864: 90 10 20 03 mov 3, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 40007868: 80 a0 60 00 cmp %g1, 0 4000786c: 12 80 00 a4 bne 40007afc <_Objects_Extend_information+0x2cc> 40007870: ba 04 00 12 add %l0, %l2, %i5 if ( !object_blocks ) return; } else { object_blocks = (void**) 40007874: 90 02 00 11 add %o0, %l1, %o0 40007878: 90 02 00 1d add %o0, %i5, %o0 4000787c: 40 00 0c 2b call 4000a928 <_Workspace_Allocate_or_fatal_error> 40007880: 91 2a 20 02 sll %o0, 2, %o0 40007884: ae 10 00 08 mov %o0, %l7 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 40007888: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 4000788c: 83 2c e0 02 sll %l3, 2, %g1 /* * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; 40007890: 86 04 ff ff add %l3, -1, %g3 if ( information->maximum > minimum_index ) { 40007894: 80 a4 40 02 cmp %l1, %g2 /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 40007898: a6 05 c0 01 add %l7, %g1, %l3 object_blocks, block_count * sizeof(void*) ); name_table = (Objects_Name *) _Addresses_Add_offset( 4000789c: aa 00 40 13 add %g1, %l3, %l5 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 400078a0: 0a 80 00 ac bcs 40007b50 <_Objects_Extend_information+0x320> 400078a4: 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++ ) { 400078a8: 80 a4 60 00 cmp %l1, 0 400078ac: 02 80 00 09 be 400078d0 <_Objects_Extend_information+0xa0> 400078b0: 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, 400078b4: 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; 400078b8: 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++ ) { 400078bc: 84 00 a0 01 inc %g2 400078c0: 80 a0 80 11 cmp %g2, %l1 400078c4: 12 bf ff fd bne 400078b8 <_Objects_Extend_information+0x88> 400078c8: c0 20 40 12 clr [ %g1 + %l2 ] 400078cc: a1 28 e0 02 sll %g3, 2, %l0 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 400078d0: c0 24 00 17 clr [ %l0 + %l7 ] inactive_per_block[block_count] = 0; 400078d4: c0 24 00 13 clr [ %l0 + %l3 ] name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); 400078d8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 400078dc: 86 05 00 01 add %l4, %g1, %g3 400078e0: 80 a0 c0 14 cmp %g3, %l4 400078e4: 08 80 00 0a bleu 4000790c <_Objects_Extend_information+0xdc> 400078e8: c0 25 40 10 clr [ %l5 + %l0 ] 400078ec: 83 2d 20 02 sll %l4, 2, %g1 400078f0: 84 04 80 01 add %l2, %g1, %g2 400078f4: 82 10 00 14 mov %l4, %g1 index++ ) { local_table[ index ] = NULL; 400078f8: 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++ ) { 400078fc: 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 ); 40007900: 80 a0 40 03 cmp %g1, %g3 40007904: 12 bf ff fd bne 400078f8 <_Objects_Extend_information+0xc8> 40007908: 84 00 a0 04 add %g2, 4, %g2 index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 4000790c: 7f ff e9 33 call 40001dd8 40007910: 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( 40007914: c4 06 00 00 ld [ %i0 ], %g2 40007918: c8 16 20 04 lduh [ %i0 + 4 ], %g4 4000791c: 87 2f 60 10 sll %i5, 0x10, %g3 40007920: 89 29 20 1b sll %g4, 0x1b, %g4 40007924: 87 30 e0 10 srl %g3, 0x10, %g3 local_table[ index ] = NULL; } _ISR_Disable( level ); old_tables = information->object_blocks; 40007928: 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( 4000792c: 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; 40007930: e6 26 20 38 st %l3, [ %i0 + 0x38 ] information->name_table = name_table; 40007934: ea 26 20 24 st %l5, [ %i0 + 0x24 ] information->local_table = local_table; 40007938: e4 26 20 20 st %l2, [ %i0 + 0x20 ] information->maximum = maximum; information->maximum_id = _Objects_Build_id( 4000793c: 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; 40007940: fa 36 20 10 sth %i5, [ %i0 + 0x10 ] information->maximum_id = _Objects_Build_id( 40007944: 84 10 80 01 or %g2, %g1, %g2 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; 40007948: 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( 4000794c: 84 10 80 04 or %g2, %g4, %g2 40007950: 84 10 80 03 or %g2, %g3, %g2 40007954: c4 26 20 0c st %g2, [ %i0 + 0xc ] information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 40007958: 7f ff e9 24 call 40001de8 4000795c: 01 00 00 00 nop if ( old_tables ) 40007960: 80 a4 20 00 cmp %l0, 0 40007964: 02 80 00 05 be 40007978 <_Objects_Extend_information+0x148> 40007968: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4000796c: 11 10 00 66 sethi %hi(0x40019800), %o0 40007970: 7f ff fe 56 call 400072c8 <_Heap_Free> 40007974: 90 12 23 5c or %o0, 0x35c, %o0 ! 40019b5c <_Workspace_Area> /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 40007978: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4000797c: 80 a0 60 00 cmp %g1, 0 40007980: 02 80 00 6a be 40007b28 <_Objects_Extend_information+0x2f8> 40007984: c2 16 20 44 lduh [ %i0 + 0x44 ], %g1 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 40007988: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 4000798c: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 information->object_blocks[ block ] = 40007990: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 40007994: 40 00 35 d8 call 400150f4 <.umul> 40007998: 90 00 40 08 add %g1, %o0, %o0 4000799c: 92 10 00 08 mov %o0, %o1 400079a0: 11 10 00 66 sethi %hi(0x40019800), %o0 400079a4: 7f ff fe 17 call 40007200 <_Heap_Allocate> 400079a8: 90 12 23 5c or %o0, 0x35c, %o0 ! 40019b5c <_Workspace_Area> _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 400079ac: e4 06 20 3c ld [ %i0 + 0x3c ], %l2 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { information->object_blocks[ block ] = 400079b0: a7 2d a0 02 sll %l6, 2, %l3 400079b4: 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 ] ) 400079b8: c2 04 c0 12 ld [ %l3 + %l2 ], %g1 400079bc: 80 a0 60 00 cmp %g1, 0 400079c0: 02 80 00 7b be 40007bac <_Objects_Extend_information+0x37c> 400079c4: 01 00 00 00 nop 400079c8: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 400079cc: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 400079d0: 40 00 35 c9 call 400150f4 <.umul> 400079d4: a2 10 00 14 mov %l4, %l1 400079d8: 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; 400079dc: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 400079e0: a0 02 00 01 add %o0, %g1, %l0 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 400079e4: 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; 400079e8: e0 20 80 13 st %l0, [ %g2 + %l3 ] /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 400079ec: d6 06 20 1c ld [ %i0 + 0x1c ], %o3 400079f0: d2 04 80 13 ld [ %l2 + %l3 ], %o1 400079f4: 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( 400079f8: 2b 00 00 40 sethi %hi(0x10000), %l5 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 400079fc: 90 10 00 14 mov %l4, %o0 40007a00: 40 00 14 6d call 4000cbb4 <_Chain_Initialize> 40007a04: a4 06 20 28 add %i0, 0x28, %l2 40007a08: 30 80 00 0f b,a 40007a44 <_Objects_Extend_information+0x214> index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 40007a0c: c4 16 20 04 lduh [ %i0 + 4 ], %g2 40007a10: c6 16 20 44 lduh [ %i0 + 0x44 ], %g3 40007a14: 83 28 60 18 sll %g1, 0x18, %g1 40007a18: 85 28 a0 1b sll %g2, 0x1b, %g2 40007a1c: 82 10 40 15 or %g1, %l5, %g1 40007a20: 82 10 40 02 or %g1, %g2, %g1 40007a24: 82 10 40 11 or %g1, %l1, %g1 information->the_class, _Objects_Local_node, index ); the_object->name = (void *) name_area; 40007a28: 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( 40007a2c: 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 ); 40007a30: 92 10 00 08 mov %o0, %o1 40007a34: a0 04 00 03 add %l0, %g3, %l0 index++; 40007a38: 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 ); 40007a3c: 7f ff fc a0 call 40006cbc <_Chain_Append> 40007a40: 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 ) { 40007a44: 7f ff fc aa call 40006cec <_Chain_Get> 40007a48: 90 10 00 14 mov %l4, %o0 40007a4c: 80 a2 20 00 cmp %o0, 0 40007a50: 32 bf ff ef bne,a 40007a0c <_Objects_Extend_information+0x1dc> 40007a54: c2 06 00 00 ld [ %i0 ], %g1 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 40007a58: c6 06 20 38 ld [ %i0 + 0x38 ], %g3 40007a5c: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 information->inactive += information->allocation_size; 40007a60: c8 16 20 34 lduh [ %i0 + 0x34 ], %g4 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 40007a64: c4 20 c0 13 st %g2, [ %g3 + %l3 ] information->inactive += information->allocation_size; 40007a68: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 40007a6c: 82 00 40 04 add %g1, %g4, %g1 40007a70: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 40007a74: 81 c7 e0 08 ret 40007a78: 81 e8 00 00 restore block = 0; if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; 40007a7c: 90 10 00 12 mov %l2, %o0 40007a80: 40 00 35 d7 call 400151dc <.udiv> 40007a84: 92 10 00 10 mov %l0, %o1 for ( ; block < block_count; block++ ) { 40007a88: 80 a2 20 00 cmp %o0, 0 40007a8c: 02 80 00 46 be 40007ba4 <_Objects_Extend_information+0x374> 40007a90: a8 10 00 11 mov %l1, %l4 if ( information->object_blocks[ block ] == NULL ) 40007a94: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 40007a98: c2 00 80 00 ld [ %g2 ], %g1 40007a9c: 80 a0 60 00 cmp %g1, 0 40007aa0: 12 80 00 08 bne 40007ac0 <_Objects_Extend_information+0x290> 40007aa4: ac 10 20 00 clr %l6 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 40007aa8: 10 80 00 0c b 40007ad8 <_Objects_Extend_information+0x2a8> <== NOT EXECUTED 40007aac: 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 ) 40007ab0: c2 00 40 02 ld [ %g1 + %g2 ], %g1 40007ab4: 80 a0 60 00 cmp %g1, 0 40007ab8: 02 80 00 08 be 40007ad8 <_Objects_Extend_information+0x2a8> 40007abc: 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++ ) { 40007ac0: ac 05 a0 01 inc %l6 if ( information->object_blocks[ block ] == NULL ) break; else index_base += information->allocation_size; 40007ac4: 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++ ) { 40007ac8: 80 a5 80 08 cmp %l6, %o0 40007acc: 12 bf ff f9 bne 40007ab0 <_Objects_Extend_information+0x280> 40007ad0: 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 ) { 40007ad4: 80 a5 00 12 cmp %l4, %l2 40007ad8: 2a bf ff a9 bcs,a 4000797c <_Objects_Extend_information+0x14c> 40007adc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40007ae0: a6 02 20 01 add %o0, 1, %l3 40007ae4: 83 2c e0 01 sll %l3, 1, %g1 40007ae8: 90 00 40 13 add %g1, %l3, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 40007aec: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 40007af0: 80 a0 60 00 cmp %g1, 0 40007af4: 02 bf ff 60 be 40007874 <_Objects_Extend_information+0x44> 40007af8: ba 04 00 12 add %l0, %l2, %i5 40007afc: 92 02 00 11 add %o0, %l1, %o1 40007b00: 11 10 00 66 sethi %hi(0x40019800), %o0 40007b04: 92 02 40 1d add %o1, %i5, %o1 40007b08: 90 12 23 5c or %o0, 0x35c, %o0 40007b0c: 7f ff fd bd call 40007200 <_Heap_Allocate> 40007b10: 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 ) 40007b14: ae 92 20 00 orcc %o0, 0, %l7 40007b18: 32 bf ff 5d bne,a 4000788c <_Objects_Extend_information+0x5c> 40007b1c: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 40007b20: 81 c7 e0 08 ret <== NOT EXECUTED 40007b24: 81 e8 00 00 restore <== NOT EXECUTED if ( !information->object_blocks[ block ] ) return; } else { information->object_blocks[ block ] = 40007b28: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 40007b2c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 40007b30: 40 00 35 71 call 400150f4 <.umul> 40007b34: 90 00 40 08 add %g1, %o0, %o0 40007b38: 40 00 0b 7c call 4000a928 <_Workspace_Allocate_or_fatal_error> 40007b3c: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 40007b40: e4 06 20 3c ld [ %i0 + 0x3c ], %l2 40007b44: a7 2d a0 02 sll %l6, 2, %l3 40007b48: 10 bf ff a0 b 400079c8 <_Objects_Extend_information+0x198> 40007b4c: 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, 40007b50: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 40007b54: a1 28 e0 02 sll %g3, 2, %l0 40007b58: 90 10 00 17 mov %l7, %o0 40007b5c: 40 00 1b 4c call 4000e88c 40007b60: 94 10 00 10 mov %l0, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 40007b64: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 40007b68: 94 10 00 10 mov %l0, %o2 40007b6c: 40 00 1b 48 call 4000e88c 40007b70: 90 10 00 13 mov %l3, %o0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, 40007b74: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 40007b78: 94 10 00 10 mov %l0, %o2 40007b7c: 40 00 1b 44 call 4000e88c 40007b80: 90 10 00 15 mov %l5, %o0 information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 40007b84: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 40007b88: d2 06 20 20 ld [ %i0 + 0x20 ], %o1 40007b8c: 94 02 80 11 add %o2, %l1, %o2 40007b90: 90 10 00 12 mov %l2, %o0 40007b94: 40 00 1b 3e call 4000e88c 40007b98: 95 2a a0 02 sll %o2, 2, %o2 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 40007b9c: 10 bf ff 4e b 400078d4 <_Objects_Extend_information+0xa4> 40007ba0: 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++ ) { 40007ba4: 10 bf ff cc b 40007ad4 <_Objects_Extend_information+0x2a4> <== NOT EXECUTED 40007ba8: ac 10 20 00 clr %l6 <== NOT EXECUTED 40007bac: 81 c7 e0 08 ret <== NOT EXECUTED 40007bb0: 81 e8 00 00 restore <== NOT EXECUTED 40007c48 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 40007c48: 9d e3 bf 98 save %sp, -104, %sp Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 40007c4c: c2 06 20 08 ld [ %i0 + 8 ], %g1 _ISR_Disable( level ); 40007c50: 7f ff e8 62 call 40001dd8 40007c54: b2 26 40 01 sub %i1, %g1, %i1 { Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 40007c58: b2 06 60 01 inc %i1 _ISR_Disable( level ); if ( information->maximum >= index ) { 40007c5c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 40007c60: 80 a6 40 01 cmp %i1, %g1 40007c64: 18 80 00 0b bgu 40007c90 <_Objects_Get_isr_disable+0x48> 40007c68: 83 2e 60 02 sll %i1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 40007c6c: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 40007c70: f0 00 80 01 ld [ %g2 + %g1 ], %i0 40007c74: 80 a6 20 00 cmp %i0, 0 40007c78: 02 80 00 0c be 40007ca8 <_Objects_Get_isr_disable+0x60> 40007c7c: 01 00 00 00 nop *location = OBJECTS_LOCAL; *level_p = level; 40007c80: 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; 40007c84: c0 26 80 00 clr [ %i2 ] 40007c88: 81 c7 e0 08 ret 40007c8c: 81 e8 00 00 restore } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 40007c90: 7f ff e8 56 call 40001de8 40007c94: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; 40007c98: 82 10 20 02 mov 2, %g1 40007c9c: c2 26 80 00 st %g1, [ %i2 ] _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 40007ca0: 81 c7 e0 08 ret 40007ca4: 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 ); 40007ca8: 7f ff e8 50 call 40001de8 <== NOT EXECUTED 40007cac: 01 00 00 00 nop <== NOT EXECUTED *location = OBJECTS_ERROR; 40007cb0: 82 10 20 02 mov 2, %g1 ! 2 <== NOT EXECUTED 40007cb4: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 40007cb8: 81 c7 e0 08 ret <== NOT EXECUTED 40007cbc: 81 e8 00 00 restore <== NOT EXECUTED 4000975c <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 4000975c: 9d e3 bf 88 save %sp, -120, %sp 40009760: 92 10 00 18 mov %i0, %o1 uint32_t i; char lname[5]; Objects_Control *the_object; Objects_Locations location; if ( length == 0 ) 40009764: 80 a6 60 00 cmp %i1, 0 40009768: 12 80 00 04 bne 40009778 <_Objects_Get_name_as_string+0x1c> 4000976c: b0 10 00 1a mov %i2, %i0 _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 40009770: 81 c7 e0 08 ret <== NOT EXECUTED 40009774: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED Objects_Locations location; if ( length == 0 ) return NULL; if ( name == NULL ) 40009778: 80 a6 a0 00 cmp %i2, 0 4000977c: 02 80 00 40 be 4000987c <_Objects_Get_name_as_string+0x120> 40009780: 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 ]; 40009784: 03 10 00 98 sethi %hi(0x40026000), %g1 40009788: 86 08 e0 1c and %g3, 0x1c, %g3 4000978c: 82 10 60 40 or %g1, 0x40, %g1 40009790: c8 00 40 03 ld [ %g1 + %g3 ], %g4 40009794: 85 32 60 1b srl %o1, 0x1b, %g2 40009798: 85 28 a0 02 sll %g2, 2, %g2 4000979c: f4 01 00 02 ld [ %g4 + %g2 ], %i2 return NULL; information = _Objects_Get_information( id ); if ( !information ) 400097a0: 80 a6 a0 00 cmp %i2, 0 400097a4: 22 80 00 36 be,a 4000987c <_Objects_Get_name_as_string+0x120> 400097a8: b0 10 20 00 clr %i0 <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, id, &location ); 400097ac: 90 10 00 1a mov %i2, %o0 400097b0: 40 00 00 3f call 400098ac <_Objects_Get> 400097b4: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 400097b8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400097bc: 80 a0 60 00 cmp %g1, 0 400097c0: 32 80 00 2f bne,a 4000987c <_Objects_Get_name_as_string+0x120> 400097c4: b0 10 20 00 clr %i0 <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 400097c8: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1 400097cc: 80 a0 60 00 cmp %g1, 0 400097d0: 22 80 00 2d be,a 40009884 <_Objects_Get_name_as_string+0x128> 400097d4: c2 02 20 0c ld [ %o0 + 0xc ], %g1 s = the_object->name; 400097d8: 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++ ) { 400097dc: 80 a6 60 01 cmp %i1, 1 400097e0: 02 80 00 1c be 40009850 <_Objects_Get_name_as_string+0xf4> 400097e4: 9a 10 00 18 mov %i0, %o5 400097e8: c8 0a 00 00 ldub [ %o0 ], %g4 400097ec: 85 29 20 18 sll %g4, 0x18, %g2 400097f0: 80 a0 a0 00 cmp %g2, 0 400097f4: 22 80 00 18 be,a 40009854 <_Objects_Get_name_as_string+0xf8> 400097f8: c0 2b 40 00 clrb [ %o5 ] <== NOT EXECUTED 400097fc: b2 06 7f ff add %i1, -1, %i1 40009800: 98 10 20 00 clr %o4 40009804: 10 80 00 07 b 40009820 <_Objects_Get_name_as_string+0xc4> 40009808: 17 10 00 76 sethi %hi(0x4001d800), %o3 4000980c: c8 0a 00 00 ldub [ %o0 ], %g4 40009810: 85 29 20 18 sll %g4, 0x18, %g2 40009814: 80 a0 a0 00 cmp %g2, 0 40009818: 22 80 00 0f be,a 40009854 <_Objects_Get_name_as_string+0xf8> 4000981c: c0 2b 40 00 clrb [ %o5 ] <== NOT EXECUTED *d = (!isprint(*s)) ? '*' : *s; 40009820: c2 02 e3 08 ld [ %o3 + 0x308 ], %g1 40009824: 85 38 a0 18 sra %g2, 0x18, %g2 40009828: c6 48 80 01 ldsb [ %g2 + %g1 ], %g3 4000982c: 80 88 e0 97 btst 0x97, %g3 40009830: 12 80 00 03 bne 4000983c <_Objects_Get_name_as_string+0xe0> 40009834: 90 02 20 01 inc %o0 40009838: 88 10 20 2a mov 0x2a, %g4 <== NOT EXECUTED 4000983c: 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++ ) { 40009840: 98 03 20 01 inc %o4 40009844: 80 a3 00 19 cmp %o4, %i1 40009848: 12 bf ff f1 bne 4000980c <_Objects_Get_name_as_string+0xb0> 4000984c: 9a 03 60 01 inc %o5 *d = (!isprint(*s)) ? '*' : *s; } *d = '\0'; 40009850: 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 ) 40009854: 03 10 00 98 sethi %hi(0x40026000), %g1 40009858: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400260e0 <_Thread_Dispatch_disable_level> 4000985c: 84 00 bf ff add %g2, -1, %g2 40009860: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 40009864: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 40009868: 80 a0 e0 00 cmp %g3, 0 4000986c: 12 80 00 04 bne 4000987c <_Objects_Get_name_as_string+0x120> 40009870: 01 00 00 00 nop _Thread_Dispatch(); 40009874: 40 00 04 fa call 4000ac5c <_Thread_Dispatch> 40009878: 01 00 00 00 nop 4000987c: 81 c7 e0 08 ret 40009880: 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'; 40009884: 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; 40009888: 85 30 60 18 srl %g1, 0x18, %g2 lname[ 1 ] = (u32_name >> 16) & 0xff; 4000988c: 87 30 60 10 srl %g1, 0x10, %g3 lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; 40009890: 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; 40009894: c4 2f bf ef stb %g2, [ %fp + -17 ] lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 40009898: 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; 4000989c: c6 2f bf f0 stb %g3, [ %fp + -16 ] lname[ 2 ] = (u32_name >> 8) & 0xff; 400098a0: c2 2f bf f1 stb %g1, [ %fp + -15 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 400098a4: 10 bf ff ce b 400097dc <_Objects_Get_name_as_string+0x80> 400098a8: 90 07 bf ef add %fp, -17, %o0 400193ec <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 400193ec: 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) 400193f0: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 400193f4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <== NOT EXECUTED 400193f8: 80 8e 40 01 btst %i1, %g1 <== NOT EXECUTED 400193fc: 22 80 00 02 be,a 40019404 <_Objects_Get_next+0x18> <== NOT EXECUTED 40019400: 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) 40019404: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 40019408: a0 10 63 ff or %g1, 0x3ff, %l0 ! ffff <== NOT EXECUTED 4001940c: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED 40019410: 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); 40019414: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40019418: 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) 4001941c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40019420: 18 80 00 0b bgu 4001944c <_Objects_Get_next+0x60> <== NOT EXECUTED 40019424: 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); 40019428: 7f ff d6 bb call 4000ef14 <_Objects_Get> <== NOT EXECUTED 4001942c: b2 06 60 01 inc %i1 <== NOT EXECUTED next_id++; } while (*location_p != OBJECTS_LOCAL); 40019430: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 40019434: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40019438: 32 bf ff f6 bne,a 40019410 <_Objects_Get_next+0x24> <== NOT EXECUTED 4001943c: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED *next_id_p = next_id; 40019440: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 40019444: 81 c7 e0 08 ret <== NOT EXECUTED 40019448: 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; 4001944c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 40019450: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED 40019454: 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; 40019458: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 4001945c: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED return 0; } 40019460: 81 c7 e0 08 ret <== NOT EXECUTED 40019464: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 400154b8 <_Objects_Get_no_protection>: ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 400154b8: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->maximum >= index ) { 400154bc: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 400154c0: 92 22 40 01 sub %o1, %g1, %o1 400154c4: 82 02 60 01 add %o1, 1, %g1 if ( information->maximum >= index ) { 400154c8: 80 a0 40 02 cmp %g1, %g2 400154cc: 18 80 00 09 bgu 400154f0 <_Objects_Get_no_protection+0x38> 400154d0: 83 28 60 02 sll %g1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 400154d4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400154d8: d0 00 80 01 ld [ %g2 + %g1 ], %o0 400154dc: 80 a2 20 00 cmp %o0, 0 400154e0: 02 80 00 08 be 40015500 <_Objects_Get_no_protection+0x48> 400154e4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_LOCAL; 400154e8: 81 c3 e0 08 retl 400154ec: c0 22 80 00 clr [ %o2 ] return the_object; } *location = OBJECTS_ERROR; return NULL; } *location = OBJECTS_ERROR; 400154f0: 82 10 20 02 mov 2, %g1 400154f4: 90 10 20 00 clr %o0 /* * Not supported for multiprocessing */ return NULL; } 400154f8: 81 c3 e0 08 retl 400154fc: 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; 40015500: 81 c3 e0 08 retl <== NOT EXECUTED 40015504: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED 40007f24 <_Objects_Handler_initialization>: uint32_t node, uint32_t maximum_nodes, uint32_t maximum_global_objects ) { if ( node < 1 || node > maximum_nodes ) 40007f24: 80 a2 20 00 cmp %o0, 0 40007f28: 22 80 00 07 be,a 40007f44 <_Objects_Handler_initialization+0x20> 40007f2c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40007f30: 80 a2 00 09 cmp %o0, %o1 40007f34: 18 80 00 04 bgu 40007f44 <_Objects_Handler_initialization+0x20> 40007f38: 90 10 20 00 clr %o0 40007f3c: 81 c3 e0 08 retl 40007f40: 01 00 00 00 nop _Internal_error_Occurred( 40007f44: 92 10 20 01 mov 1, %o1 ! 1 <== NOT EXECUTED 40007f48: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED 40007f4c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40007f50: 7f ff fd de call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 40007f54: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 40007f58: 01 00 00 00 nop 40009258 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 40009258: 9d e3 bf 90 save %sp, -112, %sp 4000925c: 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 ) 40009260: 80 a6 60 00 cmp %i1, 0 40009264: 02 80 00 24 be 400092f4 <_Objects_Id_to_name+0x9c> 40009268: 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); 4000926c: 83 32 60 18 srl %o1, 0x18, %g1 40009270: 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 ) 40009274: 80 a0 60 04 cmp %g1, 4 40009278: 18 80 00 25 bgu 4000930c <_Objects_Id_to_name+0xb4> 4000927c: 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 ]; 40009280: 03 10 00 77 sethi %hi(0x4001dc00), %g1 40009284: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 4001ddb0 <_Objects_Information_table> 40009288: c8 00 40 03 ld [ %g1 + %g3 ], %g4 4000928c: 85 32 60 1b srl %o1, 0x1b, %g2 40009290: 85 28 a0 02 sll %g2, 2, %g2 40009294: d0 01 00 02 ld [ %g4 + %g2 ], %o0 if ( !information ) 40009298: 80 a2 20 00 cmp %o0, 0 4000929c: 02 80 00 1c be 4000930c <_Objects_Id_to_name+0xb4> 400092a0: 01 00 00 00 nop return OBJECTS_INVALID_ID; if ( information->is_string ) 400092a4: c2 02 20 40 ld [ %o0 + 0x40 ], %g1 400092a8: 80 a0 60 00 cmp %g1, 0 400092ac: 12 80 00 18 bne 4000930c <_Objects_Id_to_name+0xb4> 400092b0: 01 00 00 00 nop return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, id, &ignored_location ); 400092b4: 7f ff ff c2 call 400091bc <_Objects_Get> 400092b8: 94 07 bf f4 add %fp, -12, %o2 if ( !the_object ) 400092bc: 80 a2 20 00 cmp %o0, 0 400092c0: 02 80 00 13 be 4000930c <_Objects_Id_to_name+0xb4> 400092c4: 01 00 00 00 nop return OBJECTS_INVALID_ID; *name = the_object->name; 400092c8: c2 02 20 0c ld [ %o0 + 0xc ], %g1 400092cc: 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 ) 400092d0: 07 10 00 77 sethi %hi(0x4001dc00), %g3 400092d4: c2 00 e2 50 ld [ %g3 + 0x250 ], %g1 ! 4001de50 <_Thread_Dispatch_disable_level> 400092d8: b0 10 20 00 clr %i0 400092dc: 82 00 7f ff add %g1, -1, %g1 400092e0: c2 20 e2 50 st %g1, [ %g3 + 0x250 ] 400092e4: c4 00 e2 50 ld [ %g3 + 0x250 ], %g2 400092e8: 80 a0 a0 00 cmp %g2, 0 400092ec: 02 80 00 04 be 400092fc <_Objects_Id_to_name+0xa4> 400092f0: 01 00 00 00 nop _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 400092f4: 81 c7 e0 08 ret <== NOT EXECUTED 400092f8: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 400092fc: 40 00 05 07 call 4000a718 <_Thread_Dispatch> 40009300: 01 00 00 00 nop 40009304: 81 c7 e0 08 ret 40009308: 81 e8 00 00 restore 4000930c: 81 c7 e0 08 ret <== NOT EXECUTED 40009310: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED 40007d5c <_Objects_Initialize_information>: , boolean supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 40007d5c: 9d e3 bf 98 save %sp, -104, %sp /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 40007d60: 03 10 00 66 sethi %hi(0x40019800), %g1 40007d64: 85 2e 60 02 sll %i1, 2, %g2 40007d68: 82 10 62 70 or %g1, 0x270, %g1 40007d6c: c8 00 40 02 ld [ %g1 + %g2 ], %g4 , boolean supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 40007d70: 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; 40007d74: 83 36 e0 1f srl %i3, 0x1f, %g1 maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 40007d78: 05 20 00 00 sethi %hi(0x80000000), %g2 /* * Set the size of the object */ information->size = size; 40007d7c: b9 2f 20 10 sll %i4, 0x10, %i4 40007d80: 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; 40007d84: fa 26 20 40 st %i5, [ %i0 + 0x40 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40007d88: 87 2e 60 18 sll %i1, 0x18, %g3 40007d8c: bb 2e a0 1b sll %i2, 0x1b, %i5 /* * Set the size of the object */ information->size = size; 40007d90: 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; 40007d94: 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; 40007d98: b8 2e c0 02 andn %i3, %g2, %i4 /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 40007d9c: b5 2e a0 02 sll %i2, 2, %i2 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40007da0: 80 a0 00 1c cmp %g0, %i4 /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 40007da4: 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; 40007da8: c2 26 20 14 st %g1, [ %i0 + 0x14 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40007dac: 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; 40007db0: 03 10 00 66 sethi %hi(0x40019800), %g1 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40007db4: 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; 40007db8: 82 10 60 ec or %g1, 0xec, %g1 */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40007dbc: 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; 40007dc0: c2 26 20 20 st %g1, [ %i0 + 0x20 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40007dc4: 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; 40007dc8: f2 26 00 00 st %i1, [ %i0 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40007dcc: 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; 40007dd0: c0 26 20 24 clr [ %i0 + 0x24 ] information->inactive_per_block = 0; 40007dd4: c0 26 20 38 clr [ %i0 + 0x38 ] information->object_blocks = 0; 40007dd8: c0 26 20 3c clr [ %i0 + 0x3c ] information->inactive = 0; 40007ddc: c0 36 20 34 clrh [ %i0 + 0x34 ] /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 40007de0: f8 26 20 18 st %i4, [ %i0 + 0x18 ] */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 40007de4: 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) ) 40007de8: 80 8b e0 03 btst 3, %o7 40007dec: 02 80 00 04 be 40007dfc <_Objects_Initialize_information+0xa0> 40007df0: 82 10 00 0f mov %o7, %g1 name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 40007df4: 82 03 e0 04 add %o7, 4, %g1 <== NOT EXECUTED 40007df8: 82 08 7f fc and %g1, -4, %g1 <== NOT EXECUTED ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 40007dfc: 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); 40007e00: 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); 40007e04: 82 06 20 2c add %i0, 0x2c, %g1 the_chain->permanent_null = NULL; 40007e08: 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); 40007e0c: c2 26 20 28 st %g1, [ %i0 + 0x28 ] /* * Initialize objects .. if there are any */ if ( maximum ) { 40007e10: 80 a7 20 00 cmp %i4, 0 40007e14: 12 80 00 04 bne 40007e24 <_Objects_Initialize_information+0xc8> 40007e18: c4 26 20 30 st %g2, [ %i0 + 0x30 ] 40007e1c: 81 c7 e0 08 ret 40007e20: 81 e8 00 00 restore /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 40007e24: 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 ); 40007e28: 7f ff fe 82 call 40007830 <_Objects_Extend_information> 40007e2c: 81 e8 00 00 restore 40007e30: 01 00 00 00 nop 40007e34 <_Objects_Name_to_id>: Objects_Information *information, Objects_Name name, uint32_t node, Objects_Id *id ) { 40007e34: 9d e3 bf 98 save %sp, -104, %sp 40007e38: 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 ) 40007e3c: 80 a6 e0 00 cmp %i3, 0 40007e40: 02 80 00 2d be 40007ef4 <_Objects_Name_to_id+0xc0> 40007e44: b0 10 20 02 mov 2, %i0 return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 40007e48: 80 a6 60 00 cmp %i1, 0 40007e4c: 02 80 00 28 be 40007eec <_Objects_Name_to_id+0xb8> 40007e50: 01 00 00 00 nop return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40007e54: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 40007e58: 86 90 60 00 orcc %g1, 0, %g3 40007e5c: 02 80 00 24 be 40007eec <_Objects_Name_to_id+0xb8> 40007e60: 80 a6 a0 00 cmp %i2, 0 40007e64: 12 80 00 26 bne 40007efc <_Objects_Name_to_id+0xc8> 40007e68: 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; 40007e6c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 40007e70: 05 10 00 34 sethi %hi(0x4000d000), %g2 40007e74: 80 a0 60 00 cmp %g1, 0 40007e78: a4 10 a0 08 or %g2, 8, %l2 40007e7c: 02 80 00 04 be 40007e8c <_Objects_Name_to_id+0x58> 40007e80: c8 14 60 44 lduh [ %l1 + 0x44 ], %g4 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40007e84: 03 10 00 34 sethi %hi(0x4000d000), %g1 <== NOT EXECUTED 40007e88: a4 10 60 18 or %g1, 0x18, %l2 ! 4000d018 <_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 ) ) { 40007e8c: 83 29 20 10 sll %g4, 0x10, %g1 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40007e90: 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 ) ) { 40007e94: 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 ]; 40007e98: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 40007e9c: 83 2c 20 02 sll %l0, 2, %g1 40007ea0: f4 00 80 01 ld [ %g2 + %g1 ], %i2 if ( !the_object || !the_object->name ) 40007ea4: 80 a6 a0 00 cmp %i2, 0 40007ea8: 02 80 00 0c be 40007ed8 <_Objects_Name_to_id+0xa4> 40007eac: a0 04 20 01 inc %l0 40007eb0: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 40007eb4: 80 a2 60 00 cmp %o1, 0 40007eb8: 02 80 00 08 be 40007ed8 <_Objects_Name_to_id+0xa4> 40007ebc: 90 10 00 19 mov %i1, %o0 continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 40007ec0: 9f c4 80 00 call %l2 40007ec4: 94 10 00 18 mov %i0, %o2 40007ec8: 80 a2 20 00 cmp %o0, 0 40007ecc: 32 80 00 13 bne,a 40007f18 <_Objects_Name_to_id+0xe4> 40007ed0: c2 06 a0 08 ld [ %i2 + 8 ], %g1 40007ed4: 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++ ) { 40007ed8: 83 28 e0 10 sll %g3, 0x10, %g1 40007edc: 83 30 60 10 srl %g1, 0x10, %g1 40007ee0: 80 a0 40 10 cmp %g1, %l0 40007ee4: 3a bf ff ee bcc,a 40007e9c <_Objects_Name_to_id+0x68> 40007ee8: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 40007eec: 81 c7 e0 08 ret 40007ef0: 91 e8 20 01 restore %g0, 1, %o0 return ( _Objects_MP_Global_name_search( information, name, node, id ) ); #else return OBJECTS_INVALID_NAME; #endif } 40007ef4: 81 c7 e0 08 ret <== NOT EXECUTED 40007ef8: 81 e8 00 00 restore <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 40007efc: 82 10 63 ff or %g1, 0x3ff, %g1 40007f00: 80 a6 80 01 cmp %i2, %g1 40007f04: 02 bf ff da be 40007e6c <_Objects_Name_to_id+0x38> 40007f08: 80 a6 a0 01 cmp %i2, 1 40007f0c: 22 bf ff d9 be,a 40007e70 <_Objects_Name_to_id+0x3c> 40007f10: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 40007f14: 30 bf ff f6 b,a 40007eec <_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; 40007f18: c2 26 c0 00 st %g1, [ %i3 ] 40007f1c: 81 c7 e0 08 ret 40007f20: 91 e8 20 00 restore %g0, 0, %o0 40007f5c <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 40007f5c: 9d e3 bf 98 save %sp, -104, %sp 40007f60: 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; 40007f64: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 40007f68: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0 40007f6c: 03 00 00 3f sethi %hi(0xfc00), %g1 40007f70: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40007f74: 92 10 00 10 mov %l0, %o1 40007f78: a2 08 80 01 and %g2, %g1, %l1 40007f7c: 40 00 34 98 call 400151dc <.udiv> 40007f80: 90 22 00 11 sub %o0, %l1, %o0 for ( block = 0; block < block_count; block++ ) { 40007f84: 80 a2 20 00 cmp %o0, 0 40007f88: 02 80 00 15 be 40007fdc <_Objects_Shrink_information+0x80> 40007f8c: 86 10 20 00 clr %g3 if ( information->inactive_per_block[ block ] == information->allocation_size ) { 40007f90: c8 06 20 38 ld [ %i0 + 0x38 ], %g4 40007f94: c2 01 00 00 ld [ %g4 ], %g1 40007f98: 84 10 20 04 mov 4, %g2 40007f9c: 80 a4 00 01 cmp %l0, %g1 40007fa0: a8 10 20 00 clr %l4 40007fa4: 12 80 00 0a bne 40007fcc <_Objects_Shrink_information+0x70> 40007fa8: 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; 40007fac: 10 80 00 10 b 40007fec <_Objects_Shrink_information+0x90> <== NOT EXECUTED 40007fb0: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 <== NOT EXECUTED information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 40007fb4: 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 ) { 40007fb8: 80 a4 00 01 cmp %l0, %g1 information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 40007fbc: 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 ) { 40007fc0: 02 80 00 09 be 40007fe4 <_Objects_Shrink_information+0x88> 40007fc4: 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; 40007fc8: 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++ ) { 40007fcc: 86 00 e0 01 inc %g3 40007fd0: 80 a0 c0 08 cmp %g3, %o0 40007fd4: 32 bf ff f8 bne,a 40007fb4 <_Objects_Shrink_information+0x58> 40007fd8: c2 00 80 04 ld [ %g2 + %g4 ], %g1 40007fdc: 81 c7 e0 08 ret 40007fe0: 81 e8 00 00 restore if ( information->inactive_per_block[ block ] == information->allocation_size ) { 40007fe4: 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; 40007fe8: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 40007fec: 03 00 00 3f sethi %hi(0xfc00), %g1 40007ff0: e0 02 00 00 ld [ %o0 ], %l0 40007ff4: 10 80 00 10 b 40008034 <_Objects_Shrink_information+0xd8> 40007ff8: a6 10 63 ff or %g1, 0x3ff, %l3 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 40007ffc: 82 04 40 01 add %l1, %g1, %g1 40008000: 80 a0 80 01 cmp %g2, %g1 40008004: 3a 80 00 12 bcc,a 4000804c <_Objects_Shrink_information+0xf0> 40008008: 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 ); 4000800c: 40 00 12 e0 call 4000cb8c <_Chain_Extract> 40008010: 01 00 00 00 nop 40008014: 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 ) ); 40008018: 80 a2 20 00 cmp %o0, 0 4000801c: 22 80 00 10 be,a 4000805c <_Objects_Shrink_information+0x100> 40008020: 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); 40008024: e0 02 00 00 ld [ %o0 ], %l0 40008028: 80 a4 20 00 cmp %l0, 0 4000802c: 22 80 00 0c be,a 4000805c <_Objects_Shrink_information+0x100> 40008030: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 40008034: c2 02 20 08 ld [ %o0 + 8 ], %g1 40008038: 84 08 40 13 and %g1, %l3, %g2 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 4000803c: 80 a0 80 11 cmp %g2, %l1 40008040: 3a bf ff ef bcc,a 40007ffc <_Objects_Shrink_information+0xa0> 40008044: 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; 40008048: 90 10 00 10 mov %l0, %o0 } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 4000804c: 80 a2 20 00 cmp %o0, 0 40008050: 32 bf ff f6 bne,a 40008028 <_Objects_Shrink_information+0xcc> 40008054: e0 02 00 00 ld [ %o0 ], %l0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 40008058: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED 4000805c: 11 10 00 66 sethi %hi(0x40019800), %o0 40008060: d2 00 40 14 ld [ %g1 + %l4 ], %o1 40008064: 7f ff fc 99 call 400072c8 <_Heap_Free> 40008068: 90 12 23 5c or %o0, 0x35c, %o0 */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 4000806c: 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; 40008070: c8 06 20 24 ld [ %i0 + 0x24 ], %g4 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 40008074: c0 24 80 02 clr [ %l2 + %g2 ] information->inactive -= information->allocation_size; 40008078: 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; 4000807c: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 40008080: 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; 40008084: c0 25 00 04 clr [ %l4 + %g4 ] information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 40008088: 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; 4000808c: c0 25 00 02 clr [ %l4 + %g2 ] information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 40008090: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 40008094: 81 c7 e0 08 ret 40008098: 81 e8 00 00 restore 4000809c <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 4000809c: 9d e3 bf 98 save %sp, -104, %sp void *p; _RTEMS_Lock_allocator(); 400080a0: 7f ff e7 4e call 40001dd8 400080a4: 01 00 00 00 nop 400080a8: a4 10 00 08 mov %o0, %l2 400080ac: 23 10 00 66 sethi %hi(0x40019800), %l1 400080b0: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> 400080b4: 80 a0 60 00 cmp %g1, 0 400080b8: 02 80 00 0b be 400080e4 <_Protected_heap_Allocate+0x48> 400080bc: 27 10 00 66 sethi %hi(0x40019800), %l3 400080c0: 03 10 00 67 sethi %hi(0x40019c00), %g1 400080c4: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 40019cf0 <_System_state_Current> 400080c8: 80 a0 a0 01 cmp %g2, 1 400080cc: 08 80 00 06 bleu 400080e4 <_Protected_heap_Allocate+0x48> 400080d0: 90 10 20 00 clr %o0 400080d4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400080d8: 7f ff fd 7c call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 400080dc: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400080e0: 27 10 00 66 sethi %hi(0x40019800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400080e4: 09 10 00 66 sethi %hi(0x40019800), %g4 400080e8: e0 04 e3 e4 ld [ %l3 + 0x3e4 ], %l0 400080ec: c4 01 23 ec ld [ %g4 + 0x3ec ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 400080f0: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 400080f4: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 400080f8: 80 a0 60 00 cmp %g1, 0 400080fc: 22 80 00 27 be,a 40008198 <_Protected_heap_Allocate+0xfc> 40008100: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40008104: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40008108: 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; 4000810c: 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; 40008110: 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; 40008114: 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; 40008118: 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 ) || 4000811c: 80 a0 e0 02 cmp %g3, 2 40008120: 12 80 00 2d bne 400081d4 <_Protected_heap_Allocate+0x138> 40008124: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008128: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000812c: 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++; 40008130: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008134: 02 80 00 46 be 4000824c <_Protected_heap_Allocate+0x1b0> 40008138: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 4000813c: 7f ff e7 2b call 40001de8 40008140: 90 10 00 12 mov %l2, %o0 p = _Heap_Allocate( the_heap, size ); 40008144: 90 10 00 18 mov %i0, %o0 40008148: 7f ff fc 2e call 40007200 <_Heap_Allocate> 4000814c: 92 10 00 19 mov %i1, %o1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008150: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 40008154: b0 10 00 08 mov %o0, %i0 40008158: 82 00 60 01 inc %g1 4000815c: c2 24 63 10 st %g1, [ %l1 + 0x310 ] _RTEMS_Unlock_allocator(); 40008160: d0 04 e3 e4 ld [ %l3 + 0x3e4 ], %o0 40008164: 94 10 20 00 clr %o2 40008168: d2 02 20 08 ld [ %o0 + 8 ], %o1 4000816c: 7f ff fb 54 call 40006ebc <_CORE_mutex_Surrender> 40008170: 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 ) 40008174: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 40008178: 82 00 7f ff add %g1, -1, %g1 4000817c: c2 24 63 10 st %g1, [ %l1 + 0x310 ] 40008180: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 40008184: 80 a0 a0 00 cmp %g2, 0 40008188: 02 80 00 2d be 4000823c <_Protected_heap_Allocate+0x1a0> 4000818c: 01 00 00 00 nop return p; } 40008190: 81 c7 e0 08 ret 40008194: 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 ) ) { 40008198: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 4000819c: 12 80 00 16 bne 400081f4 <_Protected_heap_Allocate+0x158> <== NOT EXECUTED 400081a0: c6 04 e3 e4 ld [ %l3 + 0x3e4 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400081a4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400081a8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400081ac: 22 80 00 43 be,a 400082b8 <_Protected_heap_Allocate+0x21c> <== NOT EXECUTED 400081b0: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 400081b4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400081b8: 12 80 00 0f bne 400081f4 <_Protected_heap_Allocate+0x158> <== NOT EXECUTED 400081bc: 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; 400081c0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400081c4: 7f ff e7 09 call 40001de8 <== NOT EXECUTED 400081c8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { void *p; _RTEMS_Lock_allocator(); p = _Heap_Allocate( the_heap, size ); 400081cc: 10 bf ff df b 40008148 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 400081d0: 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 ) || 400081d4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 400081d8: 12 bf ff d9 bne 4000813c <_Protected_heap_Allocate+0xa0> <== NOT EXECUTED 400081dc: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400081e0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400081e4: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400081e8: 02 80 00 19 be 4000824c <_Protected_heap_Allocate+0x1b0> <== NOT EXECUTED 400081ec: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 400081f0: 30 bf ff d3 b,a 4000813c <_Protected_heap_Allocate+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400081f4: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED size_t size ) { void *p; _RTEMS_Lock_allocator(); 400081f8: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 400081fc: c8 01 23 ec ld [ %g4 + 0x3ec ], %g4 <== NOT EXECUTED 40008200: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008204: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40008208: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 4000820c: 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; 40008210: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40008214: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40008218: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 4000821c: 7f ff e6 f3 call 40001de8 <== NOT EXECUTED 40008220: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008224: d0 04 e3 e4 ld [ %l3 + 0x3e4 ], %o0 <== NOT EXECUTED 40008228: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000822c: 7f ff fb 00 call 40006e2c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40008230: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 40008234: 10 bf ff c5 b 40008148 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40008238: 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(); 4000823c: 40 00 03 c9 call 40009160 <_Thread_Dispatch> 40008240: 01 00 00 00 nop 40008244: 81 c7 e0 08 ret 40008248: 81 e8 00 00 restore */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 4000824c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40008250: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40008254: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40008258: 02 80 00 28 be 400082f8 <_Protected_heap_Allocate+0x25c> <== NOT EXECUTED 4000825c: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40008260: 1a 80 00 1c bcc 400082d0 <_Protected_heap_Allocate+0x234> <== NOT EXECUTED 40008264: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008268: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 4000826c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008270: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40008274: 7f ff e6 dd call 40001de8 <== NOT EXECUTED 40008278: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 4000827c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40008280: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40008284: 40 00 02 93 call 40008cd0 <_Thread_Change_priority> <== NOT EXECUTED 40008288: 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 ) 4000828c: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 40008290: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008294: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 40008298: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 <== NOT EXECUTED 4000829c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400082a0: 32 bf ff aa bne,a 40008148 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 400082a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 400082a8: 40 00 03 ae call 40009160 <_Thread_Dispatch> <== NOT EXECUTED 400082ac: 01 00 00 00 nop <== NOT EXECUTED 400082b0: 10 bf ff a6 b 40008148 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 400082b4: 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++; 400082b8: 82 00 60 01 inc %g1 <== NOT EXECUTED 400082bc: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400082c0: 7f ff e6 ca call 40001de8 <== NOT EXECUTED 400082c4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400082c8: 10 bf ff a0 b 40008148 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 400082cc: 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; 400082d0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400082d4: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 400082d8: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 400082dc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400082e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400082e4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400082e8: 7f ff e6 c0 call 40001de8 <== NOT EXECUTED 400082ec: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400082f0: 10 bf ff 96 b 40008148 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 400082f4: 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 ); 400082f8: 7f ff e6 bc call 40001de8 <== NOT EXECUTED 400082fc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008300: 10 bf ff 92 b 40008148 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 40008304: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008308 <_Protected_heap_Extend>: boolean _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 40008308: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 4000830c: 7f ff e6 b3 call 40001dd8 <== NOT EXECUTED 40008310: 01 00 00 00 nop <== NOT EXECUTED 40008314: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 40008318: 23 10 00 66 sethi %hi(0x40019800), %l1 <== NOT EXECUTED 4000831c: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40008320: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008324: 02 80 00 0b be 40008350 <_Protected_heap_Extend+0x48> <== NOT EXECUTED 40008328: 27 10 00 66 sethi %hi(0x40019800), %l3 <== NOT EXECUTED 4000832c: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED 40008330: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 40019cf0 <_System_state_Current> <== NOT EXECUTED 40008334: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40008338: 08 80 00 06 bleu 40008350 <_Protected_heap_Extend+0x48> <== NOT EXECUTED 4000833c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40008340: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008344: 7f ff fc e1 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 40008348: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 4000834c: 27 10 00 66 sethi %hi(0x40019800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40008350: 09 10 00 66 sethi %hi(0x40019800), %g4 <== NOT EXECUTED 40008354: e0 04 e3 e4 ld [ %l3 + 0x3e4 ], %l0 <== NOT EXECUTED 40008358: c4 01 23 ec ld [ %g4 + 0x3ec ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 4000835c: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40008360: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 40008364: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008368: 22 80 00 2d be,a 4000841c <_Protected_heap_Extend+0x114> <== NOT EXECUTED 4000836c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40008370: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40008374: 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; 40008378: 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; 4000837c: 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; 40008380: 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; 40008384: 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 ) || 40008388: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 4000838c: 12 80 00 33 bne 40008458 <_Protected_heap_Extend+0x150> <== NOT EXECUTED 40008390: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008394: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008398: 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++; 4000839c: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400083a0: 02 80 00 48 be 400084c0 <_Protected_heap_Extend+0x1b8> <== NOT EXECUTED 400083a4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400083a8: 7f ff e6 90 call 40001de8 <== NOT EXECUTED 400083ac: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 400083b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400083b4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 400083b8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 400083bc: 40 00 12 2f call 4000cc78 <_Heap_Extend> <== NOT EXECUTED 400083c0: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400083c4: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 400083c8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 400083cc: 82 00 60 01 inc %g1 <== NOT EXECUTED 400083d0: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 400083d4: d0 04 e3 e4 ld [ %l3 + 0x3e4 ], %o0 <== NOT EXECUTED 400083d8: 94 10 20 00 clr %o2 <== NOT EXECUTED 400083dc: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 400083e0: 7f ff fa b7 call 40006ebc <_CORE_mutex_Surrender> <== NOT EXECUTED 400083e4: 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 ) 400083e8: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 400083ec: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400083f0: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 400083f4: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 <== NOT EXECUTED 400083f8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400083fc: 12 80 00 05 bne 40008410 <_Protected_heap_Extend+0x108> <== NOT EXECUTED 40008400: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED _Thread_Dispatch(); 40008404: 40 00 03 57 call 40009160 <_Thread_Dispatch> <== NOT EXECUTED 40008408: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 4000840c: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 40008410: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 40008414: 81 c7 e0 08 ret <== NOT EXECUTED 40008418: 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 ) ) { 4000841c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40008420: 12 80 00 16 bne 40008478 <_Protected_heap_Extend+0x170> <== NOT EXECUTED 40008424: c6 04 e3 e4 ld [ %l3 + 0x3e4 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40008428: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 4000842c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008430: 22 80 00 3f be,a 4000852c <_Protected_heap_Extend+0x224> <== NOT EXECUTED 40008434: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40008438: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000843c: 12 80 00 0f bne 40008478 <_Protected_heap_Extend+0x170> <== NOT EXECUTED 40008440: 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; 40008444: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40008448: 7f ff e6 68 call 40001de8 <== NOT EXECUTED 4000844c: 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); 40008450: 10 bf ff d9 b 400083b4 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 40008454: 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 ) || 40008458: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 4000845c: 12 bf ff d3 bne 400083a8 <_Protected_heap_Extend+0xa0> <== NOT EXECUTED 40008460: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008464: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008468: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000846c: 02 80 00 15 be 400084c0 <_Protected_heap_Extend+0x1b8> <== NOT EXECUTED 40008470: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40008474: 30 bf ff cd b,a 400083a8 <_Protected_heap_Extend+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008478: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED ) { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 4000847c: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40008480: c8 01 23 ec ld [ %g4 + 0x3ec ], %g4 <== NOT EXECUTED 40008484: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008488: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 4000848c: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 40008490: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40008494: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40008498: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 4000849c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 400084a0: 7f ff e6 52 call 40001de8 <== NOT EXECUTED 400084a4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400084a8: d0 04 e3 e4 ld [ %l3 + 0x3e4 ], %o0 <== NOT EXECUTED 400084ac: 92 10 20 00 clr %o1 <== NOT EXECUTED 400084b0: 7f ff fa 5f call 40006e2c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 400084b4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 400084b8: 10 bf ff bf b 400083b4 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 400084bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 400084c0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 400084c4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 400084c8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 400084cc: 02 80 00 28 be 4000856c <_Protected_heap_Extend+0x264> <== NOT EXECUTED 400084d0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 400084d4: 1a 80 00 1c bcc 40008544 <_Protected_heap_Extend+0x23c> <== NOT EXECUTED 400084d8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 400084dc: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 400084e0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400084e4: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 400084e8: 7f ff e6 40 call 40001de8 <== NOT EXECUTED 400084ec: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 400084f0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 400084f4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 400084f8: 40 00 01 f6 call 40008cd0 <_Thread_Change_priority> <== NOT EXECUTED 400084fc: 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 ) 40008500: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 40008504: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008508: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 4000850c: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 <== NOT EXECUTED 40008510: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008514: 32 bf ff a8 bne,a 400083b4 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 40008518: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000851c: 40 00 03 11 call 40009160 <_Thread_Dispatch> <== NOT EXECUTED 40008520: 01 00 00 00 nop <== NOT EXECUTED 40008524: 10 bf ff a4 b 400083b4 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 40008528: 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++; 4000852c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008530: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40008534: 7f ff e6 2d call 40001de8 <== NOT EXECUTED 40008538: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000853c: 10 bf ff 9e b 400083b4 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 40008540: 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; 40008544: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008548: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4000854c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40008550: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008554: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008558: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000855c: 7f ff e6 23 call 40001de8 <== NOT EXECUTED 40008560: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008564: 10 bf ff 94 b 400083b4 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 40008568: 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 ); 4000856c: 7f ff e6 1f call 40001de8 <== NOT EXECUTED 40008570: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008574: 10 bf ff 90 b 400083b4 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 40008578: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000857c <_Protected_heap_Free>: boolean _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 4000857c: 9d e3 bf 98 save %sp, -104, %sp boolean status; _RTEMS_Lock_allocator(); 40008580: 7f ff e6 16 call 40001dd8 40008584: 01 00 00 00 nop 40008588: a4 10 00 08 mov %o0, %l2 4000858c: 23 10 00 66 sethi %hi(0x40019800), %l1 40008590: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> 40008594: 80 a0 60 00 cmp %g1, 0 40008598: 02 80 00 0b be 400085c4 <_Protected_heap_Free+0x48> 4000859c: 27 10 00 66 sethi %hi(0x40019800), %l3 400085a0: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED 400085a4: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 40019cf0 <_System_state_Current> <== NOT EXECUTED 400085a8: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 400085ac: 08 80 00 06 bleu 400085c4 <_Protected_heap_Free+0x48> <== NOT EXECUTED 400085b0: 90 10 20 00 clr %o0 <== NOT EXECUTED 400085b4: 92 10 20 00 clr %o1 <== NOT EXECUTED 400085b8: 7f ff fc 44 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 400085bc: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400085c0: 27 10 00 66 sethi %hi(0x40019800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400085c4: 09 10 00 66 sethi %hi(0x40019800), %g4 400085c8: e0 04 e3 e4 ld [ %l3 + 0x3e4 ], %l0 400085cc: c4 01 23 ec ld [ %g4 + 0x3ec ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 400085d0: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 400085d4: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 400085d8: 80 a0 60 00 cmp %g1, 0 400085dc: 22 80 00 27 be,a 40008678 <_Protected_heap_Free+0xfc> 400085e0: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 400085e4: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400085e8: 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; 400085ec: 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; 400085f0: 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; 400085f4: 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; 400085f8: 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 ) || 400085fc: 80 a0 e0 02 cmp %g3, 2 40008600: 12 80 00 2d bne 400086b4 <_Protected_heap_Free+0x138> 40008604: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008608: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000860c: 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++; 40008610: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008614: 02 80 00 46 be 4000872c <_Protected_heap_Free+0x1b0> 40008618: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 4000861c: 7f ff e5 f3 call 40001de8 40008620: 90 10 00 12 mov %l2, %o0 status = _Heap_Free( the_heap, start_address ); 40008624: 90 10 00 18 mov %i0, %o0 40008628: 7f ff fb 28 call 400072c8 <_Heap_Free> 4000862c: 92 10 00 19 mov %i1, %o1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008630: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 40008634: b0 10 00 08 mov %o0, %i0 40008638: 82 00 60 01 inc %g1 4000863c: c2 24 63 10 st %g1, [ %l1 + 0x310 ] _RTEMS_Unlock_allocator(); 40008640: d0 04 e3 e4 ld [ %l3 + 0x3e4 ], %o0 40008644: 94 10 20 00 clr %o2 40008648: d2 02 20 08 ld [ %o0 + 8 ], %o1 4000864c: 7f ff fa 1c call 40006ebc <_CORE_mutex_Surrender> 40008650: 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 ) 40008654: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 40008658: 82 00 7f ff add %g1, -1, %g1 4000865c: c2 24 63 10 st %g1, [ %l1 + 0x310 ] 40008660: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 40008664: 80 a0 a0 00 cmp %g2, 0 40008668: 02 80 00 2d be 4000871c <_Protected_heap_Free+0x1a0> 4000866c: 01 00 00 00 nop return status; } 40008670: 81 c7 e0 08 ret <== NOT EXECUTED 40008674: 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 ) ) { 40008678: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 4000867c: 12 80 00 16 bne 400086d4 <_Protected_heap_Free+0x158> <== NOT EXECUTED 40008680: c6 04 e3 e4 ld [ %l3 + 0x3e4 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40008684: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40008688: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000868c: 22 80 00 43 be,a 40008798 <_Protected_heap_Free+0x21c> <== NOT EXECUTED 40008690: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40008694: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40008698: 12 80 00 0f bne 400086d4 <_Protected_heap_Free+0x158> <== NOT EXECUTED 4000869c: 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; 400086a0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400086a4: 7f ff e5 d1 call 40001de8 <== NOT EXECUTED 400086a8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { boolean status; _RTEMS_Lock_allocator(); status = _Heap_Free( the_heap, start_address ); 400086ac: 10 bf ff df b 40008628 <_Protected_heap_Free+0xac> <== NOT EXECUTED 400086b0: 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 ) || 400086b4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 400086b8: 12 bf ff d9 bne 4000861c <_Protected_heap_Free+0xa0> <== NOT EXECUTED 400086bc: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400086c0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400086c4: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400086c8: 02 80 00 19 be 4000872c <_Protected_heap_Free+0x1b0> <== NOT EXECUTED 400086cc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 400086d0: 30 bf ff d3 b,a 4000861c <_Protected_heap_Free+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400086d4: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED void *start_address ) { boolean status; _RTEMS_Lock_allocator(); 400086d8: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 400086dc: c8 01 23 ec ld [ %g4 + 0x3ec ], %g4 <== NOT EXECUTED 400086e0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400086e4: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 400086e8: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 400086ec: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 400086f0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 400086f4: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 400086f8: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 400086fc: 7f ff e5 bb call 40001de8 <== NOT EXECUTED 40008700: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008704: d0 04 e3 e4 ld [ %l3 + 0x3e4 ], %o0 <== NOT EXECUTED 40008708: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000870c: 7f ff f9 c8 call 40006e2c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40008710: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 40008714: 10 bf ff c5 b 40008628 <_Protected_heap_Free+0xac> <== NOT EXECUTED 40008718: 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(); 4000871c: 40 00 02 91 call 40009160 <_Thread_Dispatch> 40008720: 01 00 00 00 nop 40008724: 81 c7 e0 08 ret 40008728: 81 e8 00 00 restore */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 4000872c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40008730: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40008734: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40008738: 02 80 00 28 be 400087d8 <_Protected_heap_Free+0x25c> <== NOT EXECUTED 4000873c: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40008740: 1a 80 00 1c bcc 400087b0 <_Protected_heap_Free+0x234> <== NOT EXECUTED 40008744: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008748: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 4000874c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008750: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40008754: 7f ff e5 a5 call 40001de8 <== NOT EXECUTED 40008758: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 4000875c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40008760: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40008764: 40 00 01 5b call 40008cd0 <_Thread_Change_priority> <== NOT EXECUTED 40008768: 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 ) 4000876c: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 40008770: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008774: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 40008778: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 <== NOT EXECUTED 4000877c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008780: 32 bf ff aa bne,a 40008628 <_Protected_heap_Free+0xac> <== NOT EXECUTED 40008784: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40008788: 40 00 02 76 call 40009160 <_Thread_Dispatch> <== NOT EXECUTED 4000878c: 01 00 00 00 nop <== NOT EXECUTED 40008790: 10 bf ff a6 b 40008628 <_Protected_heap_Free+0xac> <== NOT EXECUTED 40008794: 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++; 40008798: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000879c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400087a0: 7f ff e5 92 call 40001de8 <== NOT EXECUTED 400087a4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400087a8: 10 bf ff a0 b 40008628 <_Protected_heap_Free+0xac> <== NOT EXECUTED 400087ac: 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; 400087b0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400087b4: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 400087b8: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 400087bc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400087c0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400087c4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400087c8: 7f ff e5 88 call 40001de8 <== NOT EXECUTED 400087cc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400087d0: 10 bf ff 96 b 40008628 <_Protected_heap_Free+0xac> <== NOT EXECUTED 400087d4: 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 ); 400087d8: 7f ff e5 84 call 40001de8 <== NOT EXECUTED 400087dc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400087e0: 10 bf ff 92 b 40008628 <_Protected_heap_Free+0xac> <== NOT EXECUTED 400087e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400087e8 <_Protected_heap_Get_block_size>: boolean _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 400087e8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED boolean status; _RTEMS_Lock_allocator(); 400087ec: 7f ff e5 7b call 40001dd8 <== NOT EXECUTED 400087f0: 01 00 00 00 nop <== NOT EXECUTED 400087f4: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 400087f8: 23 10 00 66 sethi %hi(0x40019800), %l1 <== NOT EXECUTED 400087fc: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40008800: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008804: 02 80 00 0b be 40008830 <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 40008808: 27 10 00 66 sethi %hi(0x40019800), %l3 <== NOT EXECUTED 4000880c: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED 40008810: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 40019cf0 <_System_state_Current> <== NOT EXECUTED 40008814: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40008818: 08 80 00 06 bleu 40008830 <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 4000881c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40008820: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008824: 7f ff fb a9 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 40008828: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 4000882c: 27 10 00 66 sethi %hi(0x40019800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40008830: 09 10 00 66 sethi %hi(0x40019800), %g4 <== NOT EXECUTED 40008834: e0 04 e3 e4 ld [ %l3 + 0x3e4 ], %l0 <== NOT EXECUTED 40008838: c4 01 23 ec ld [ %g4 + 0x3ec ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 4000883c: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40008840: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 40008844: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008848: 22 80 00 28 be,a 400088e8 <_Protected_heap_Get_block_size+0x100> <== NOT EXECUTED 4000884c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40008850: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40008854: 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; 40008858: 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; 4000885c: 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; 40008860: 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; 40008864: 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 ) || 40008868: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 4000886c: 12 80 00 2e bne 40008924 <_Protected_heap_Get_block_size+0x13c> <== NOT EXECUTED 40008870: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008874: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008878: 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++; 4000887c: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008880: 02 80 00 47 be 4000899c <_Protected_heap_Get_block_size+0x1b4> <== NOT EXECUTED 40008884: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40008888: 7f ff e5 58 call 40001de8 <== NOT EXECUTED 4000888c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 40008890: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008894: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40008898: 40 00 11 b9 call 4000cf7c <_Heap_Size_of_user_area> <== NOT EXECUTED 4000889c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400088a0: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 400088a4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 400088a8: 82 00 60 01 inc %g1 <== NOT EXECUTED 400088ac: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 400088b0: d0 04 e3 e4 ld [ %l3 + 0x3e4 ], %o0 <== NOT EXECUTED 400088b4: 94 10 20 00 clr %o2 <== NOT EXECUTED 400088b8: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 400088bc: 7f ff f9 80 call 40006ebc <_CORE_mutex_Surrender> <== NOT EXECUTED 400088c0: 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 ) 400088c4: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 400088c8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400088cc: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 400088d0: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 <== NOT EXECUTED 400088d4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400088d8: 02 80 00 2d be 4000898c <_Protected_heap_Get_block_size+0x1a4> <== NOT EXECUTED 400088dc: 01 00 00 00 nop <== NOT EXECUTED return status; } 400088e0: 81 c7 e0 08 ret <== NOT EXECUTED 400088e4: 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 ) ) { 400088e8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400088ec: 12 80 00 16 bne 40008944 <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 400088f0: c6 04 e3 e4 ld [ %l3 + 0x3e4 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400088f4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400088f8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400088fc: 22 80 00 43 be,a 40008a08 <_Protected_heap_Get_block_size+0x220> <== NOT EXECUTED 40008900: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40008904: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40008908: 12 80 00 0f bne 40008944 <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 4000890c: 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; 40008910: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40008914: 7f ff e5 35 call 40001de8 <== NOT EXECUTED 40008918: 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 ); 4000891c: 10 bf ff de b 40008894 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008920: 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 ) || 40008924: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40008928: 12 bf ff d8 bne 40008888 <_Protected_heap_Get_block_size+0xa0> <== NOT EXECUTED 4000892c: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008930: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008934: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008938: 02 80 00 19 be 4000899c <_Protected_heap_Get_block_size+0x1b4> <== NOT EXECUTED 4000893c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40008940: 30 bf ff d2 b,a 40008888 <_Protected_heap_Get_block_size+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008944: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED size_t *size ) { boolean status; _RTEMS_Lock_allocator(); 40008948: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 4000894c: c8 01 23 ec ld [ %g4 + 0x3ec ], %g4 <== NOT EXECUTED 40008950: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008954: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40008958: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 4000895c: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40008960: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40008964: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40008968: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 4000896c: 7f ff e5 1f call 40001de8 <== NOT EXECUTED 40008970: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008974: d0 04 e3 e4 ld [ %l3 + 0x3e4 ], %o0 <== NOT EXECUTED 40008978: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000897c: 7f ff f9 2c call 40006e2c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40008980: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 40008984: 10 bf ff c4 b 40008894 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008988: 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(); 4000898c: 40 00 01 f5 call 40009160 <_Thread_Dispatch> <== NOT EXECUTED 40008990: 01 00 00 00 nop <== NOT EXECUTED 40008994: 81 c7 e0 08 ret <== NOT EXECUTED 40008998: 81 e8 00 00 restore <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 4000899c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 400089a0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 400089a4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 400089a8: 02 80 00 28 be 40008a48 <_Protected_heap_Get_block_size+0x260> <== NOT EXECUTED 400089ac: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 400089b0: 1a 80 00 1c bcc 40008a20 <_Protected_heap_Get_block_size+0x238> <== NOT EXECUTED 400089b4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400089b8: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 400089bc: 82 00 60 01 inc %g1 <== NOT EXECUTED 400089c0: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 400089c4: 7f ff e5 09 call 40001de8 <== NOT EXECUTED 400089c8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 400089cc: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 400089d0: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 400089d4: 40 00 00 bf call 40008cd0 <_Thread_Change_priority> <== NOT EXECUTED 400089d8: 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 ) 400089dc: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 400089e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400089e4: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 400089e8: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 <== NOT EXECUTED 400089ec: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400089f0: 32 bf ff a9 bne,a 40008894 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 400089f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 400089f8: 40 00 01 da call 40009160 <_Thread_Dispatch> <== NOT EXECUTED 400089fc: 01 00 00 00 nop <== NOT EXECUTED 40008a00: 10 bf ff a5 b 40008894 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008a04: 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++; 40008a08: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008a0c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40008a10: 7f ff e4 f6 call 40001de8 <== NOT EXECUTED 40008a14: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008a18: 10 bf ff 9f b 40008894 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008a1c: 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; 40008a20: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008a24: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40008a28: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40008a2c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008a30: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008a34: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40008a38: 7f ff e4 ec call 40001de8 <== NOT EXECUTED 40008a3c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008a40: 10 bf ff 95 b 40008894 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008a44: 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 ); 40008a48: 7f ff e4 e8 call 40001de8 <== NOT EXECUTED 40008a4c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008a50: 10 bf ff 91 b 40008894 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 40008a54: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000c234 <_Protected_heap_Get_free_information>: void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 4000c234: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 4000c238: 7f ff de 9b call 40003ca4 <== NOT EXECUTED 4000c23c: 01 00 00 00 nop <== NOT EXECUTED 4000c240: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 4000c244: 23 10 00 f4 sethi %hi(0x4003d000), %l1 <== NOT EXECUTED 4000c248: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 ! 4003d0a0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000c24c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000c250: 02 80 00 0b be 4000c27c <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 4000c254: 27 10 00 f4 sethi %hi(0x4003d000), %l3 <== NOT EXECUTED 4000c258: 03 10 00 f4 sethi %hi(0x4003d000), %g1 <== NOT EXECUTED 4000c25c: c4 00 62 80 ld [ %g1 + 0x280 ], %g2 ! 4003d280 <_System_state_Current> <== NOT EXECUTED 4000c260: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 4000c264: 08 80 00 06 bleu 4000c27c <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 4000c268: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000c26c: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000c270: 7f ff fb 49 call 4000af94 <_Internal_error_Occurred> <== NOT EXECUTED 4000c274: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 4000c278: 27 10 00 f4 sethi %hi(0x4003d000), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 4000c27c: 09 10 00 f4 sethi %hi(0x4003d000), %g4 <== NOT EXECUTED 4000c280: e0 04 e1 74 ld [ %l3 + 0x174 ], %l0 <== NOT EXECUTED 4000c284: c4 01 21 7c ld [ %g4 + 0x17c ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 4000c288: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 4000c28c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 4000c290: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000c294: 22 80 00 26 be,a 4000c32c <_Protected_heap_Get_free_information+0xf8> <== NOT EXECUTED 4000c298: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 4000c29c: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 4000c2a0: 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; 4000c2a4: 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; 4000c2a8: 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; 4000c2ac: 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; 4000c2b0: 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 ) || 4000c2b4: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 4000c2b8: 12 80 00 2c bne 4000c368 <_Protected_heap_Get_free_information+0x134> <== NOT EXECUTED 4000c2bc: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4000c2c0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000c2c4: 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++; 4000c2c8: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000c2cc: 02 80 00 43 be 4000c3d8 <_Protected_heap_Get_free_information+0x1a4> <== NOT EXECUTED 4000c2d0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000c2d4: 7f ff de 78 call 40003cb4 <== NOT EXECUTED 4000c2d8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 4000c2dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000c2e0: 40 00 3a 2e call 4001ab98 <_Heap_Get_free_information> <== NOT EXECUTED 4000c2e4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000c2e8: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 <== NOT EXECUTED 4000c2ec: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c2f0: c2 24 60 a0 st %g1, [ %l1 + 0xa0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 4000c2f4: d0 04 e1 74 ld [ %l3 + 0x174 ], %o0 <== NOT EXECUTED 4000c2f8: 94 10 20 00 clr %o2 <== NOT EXECUTED 4000c2fc: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 4000c300: 7f ff f9 22 call 4000a788 <_CORE_mutex_Surrender> <== NOT EXECUTED 4000c304: 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 ) 4000c308: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 <== NOT EXECUTED 4000c30c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000c310: c2 24 60 a0 st %g1, [ %l1 + 0xa0 ] <== NOT EXECUTED 4000c314: c4 04 60 a0 ld [ %l1 + 0xa0 ], %g2 <== NOT EXECUTED 4000c318: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000c31c: 02 80 00 2d be 4000c3d0 <_Protected_heap_Get_free_information+0x19c> <== NOT EXECUTED 4000c320: 01 00 00 00 nop <== NOT EXECUTED 4000c324: 81 c7 e0 08 ret <== NOT EXECUTED 4000c328: 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 ) ) { 4000c32c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 4000c330: 12 80 00 16 bne 4000c388 <_Protected_heap_Get_free_information+0x154> <== NOT EXECUTED 4000c334: c6 04 e1 74 ld [ %l3 + 0x174 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 4000c338: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 4000c33c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000c340: 22 80 00 41 be,a 4000c444 <_Protected_heap_Get_free_information+0x210> <== NOT EXECUTED 4000c344: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 4000c348: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4000c34c: 12 80 00 0f bne 4000c388 <_Protected_heap_Get_free_information+0x154> <== NOT EXECUTED 4000c350: 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; 4000c354: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 4000c358: 7f ff de 57 call 40003cb4 <== NOT EXECUTED 4000c35c: 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 ); 4000c360: 10 bf ff e0 b 4000c2e0 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c364: 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 ) || 4000c368: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 4000c36c: 12 bf ff da bne 4000c2d4 <_Protected_heap_Get_free_information+0xa0> <== NOT EXECUTED 4000c370: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4000c374: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4000c378: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 4000c37c: 02 80 00 17 be 4000c3d8 <_Protected_heap_Get_free_information+0x1a4> <== NOT EXECUTED 4000c380: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 4000c384: 30 bf ff d4 b,a 4000c2d4 <_Protected_heap_Get_free_information+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000c388: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 <== NOT EXECUTED void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); 4000c38c: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 4000c390: c8 01 21 7c ld [ %g4 + 0x17c ], %g4 <== NOT EXECUTED 4000c394: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c398: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 4000c39c: c2 24 60 a0 st %g1, [ %l1 + 0xa0 ] <== NOT EXECUTED 4000c3a0: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 4000c3a4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4000c3a8: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 4000c3ac: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 4000c3b0: 7f ff de 41 call 40003cb4 <== NOT EXECUTED 4000c3b4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000c3b8: d0 04 e1 74 ld [ %l3 + 0x174 ], %o0 <== NOT EXECUTED 4000c3bc: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000c3c0: 7f ff f8 ce call 4000a6f8 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 4000c3c4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 4000c3c8: 10 bf ff c6 b 4000c2e0 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c3cc: 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(); 4000c3d0: 40 00 01 f3 call 4000cb9c <_Thread_Dispatch> <== NOT EXECUTED 4000c3d4: 81 e8 00 00 restore <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 4000c3d8: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 4000c3dc: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 4000c3e0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4000c3e4: 02 80 00 28 be 4000c484 <_Protected_heap_Get_free_information+0x250> <== NOT EXECUTED 4000c3e8: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 4000c3ec: 1a 80 00 1c bcc 4000c45c <_Protected_heap_Get_free_information+0x228> <== NOT EXECUTED 4000c3f0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000c3f4: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 <== NOT EXECUTED 4000c3f8: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c3fc: c2 24 60 a0 st %g1, [ %l1 + 0xa0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 4000c400: 7f ff de 2d call 40003cb4 <== NOT EXECUTED 4000c404: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 4000c408: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 4000c40c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 4000c410: 40 00 00 bf call 4000c70c <_Thread_Change_priority> <== NOT EXECUTED 4000c414: 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 ) 4000c418: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 <== NOT EXECUTED 4000c41c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000c420: c2 24 60 a0 st %g1, [ %l1 + 0xa0 ] <== NOT EXECUTED 4000c424: c4 04 60 a0 ld [ %l1 + 0xa0 ], %g2 <== NOT EXECUTED 4000c428: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000c42c: 32 bf ff ad bne,a 4000c2e0 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c430: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000c434: 40 00 01 da call 4000cb9c <_Thread_Dispatch> <== NOT EXECUTED 4000c438: 01 00 00 00 nop <== NOT EXECUTED 4000c43c: 10 bf ff a9 b 4000c2e0 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c440: 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++; 4000c444: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000c448: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 4000c44c: 7f ff de 1a call 40003cb4 <== NOT EXECUTED 4000c450: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000c454: 10 bf ff a3 b 4000c2e0 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c458: 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; 4000c45c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 4000c460: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 4000c464: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 4000c468: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 4000c46c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000c470: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 4000c474: 7f ff de 10 call 40003cb4 <== NOT EXECUTED 4000c478: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000c47c: 10 bf ff 99 b 4000c2e0 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c480: 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 ); 4000c484: 7f ff de 0c call 40003cb4 <== NOT EXECUTED 4000c488: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000c48c: 10 bf ff 95 b 4000c2e0 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 4000c490: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008a58 <_Protected_heap_Resize_block>: boolean _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 40008a58: 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(); 40008a5c: 7f ff e4 df call 40001dd8 <== NOT EXECUTED 40008a60: 01 00 00 00 nop <== NOT EXECUTED 40008a64: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 40008a68: 23 10 00 66 sethi %hi(0x40019800), %l1 <== NOT EXECUTED 40008a6c: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40008a70: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008a74: 02 80 00 0b be 40008aa0 <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 40008a78: 27 10 00 66 sethi %hi(0x40019800), %l3 <== NOT EXECUTED 40008a7c: 03 10 00 67 sethi %hi(0x40019c00), %g1 <== NOT EXECUTED 40008a80: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 40019cf0 <_System_state_Current> <== NOT EXECUTED 40008a84: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40008a88: 08 80 00 06 bleu 40008aa0 <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 40008a8c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40008a90: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008a94: 7f ff fb 0d call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 40008a98: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40008a9c: 27 10 00 66 sethi %hi(0x40019800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40008aa0: 09 10 00 66 sethi %hi(0x40019800), %g4 <== NOT EXECUTED 40008aa4: e0 04 e3 e4 ld [ %l3 + 0x3e4 ], %l0 <== NOT EXECUTED 40008aa8: c4 01 23 ec ld [ %g4 + 0x3ec ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40008aac: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40008ab0: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 40008ab4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008ab8: 22 80 00 2e be,a 40008b70 <_Protected_heap_Resize_block+0x118> <== NOT EXECUTED 40008abc: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40008ac0: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40008ac4: 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; 40008ac8: 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; 40008acc: 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; 40008ad0: 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; 40008ad4: 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 ) || 40008ad8: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 40008adc: 12 80 00 34 bne 40008bac <_Protected_heap_Resize_block+0x154> <== NOT EXECUTED 40008ae0: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008ae4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008ae8: 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++; 40008aec: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008af0: 02 80 00 49 be 40008c14 <_Protected_heap_Resize_block+0x1bc> <== NOT EXECUTED 40008af4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40008af8: 7f ff e4 bc call 40001de8 <== NOT EXECUTED 40008afc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 40008b00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40008b04: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40008b08: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40008b0c: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 40008b10: 40 00 10 8d call 4000cd44 <_Heap_Resize_block> <== NOT EXECUTED 40008b14: 98 07 bf f0 add %fp, -16, %o4 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008b18: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 40008b1c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 40008b20: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008b24: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 40008b28: d0 04 e3 e4 ld [ %l3 + 0x3e4 ], %o0 <== NOT EXECUTED 40008b2c: 94 10 20 00 clr %o2 <== NOT EXECUTED 40008b30: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40008b34: 7f ff f8 e2 call 40006ebc <_CORE_mutex_Surrender> <== NOT EXECUTED 40008b38: 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 ) 40008b3c: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 40008b40: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008b44: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 40008b48: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 <== NOT EXECUTED 40008b4c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008b50: 12 80 00 05 bne 40008b64 <_Protected_heap_Resize_block+0x10c> <== NOT EXECUTED 40008b54: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED _Thread_Dispatch(); 40008b58: 40 00 01 82 call 40009160 <_Thread_Dispatch> <== NOT EXECUTED 40008b5c: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 40008b60: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 40008b64: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 40008b68: 81 c7 e0 08 ret <== NOT EXECUTED 40008b6c: 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 ) ) { 40008b70: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40008b74: 12 80 00 16 bne 40008bcc <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 40008b78: c6 04 e3 e4 ld [ %l3 + 0x3e4 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40008b7c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40008b80: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40008b84: 22 80 00 3f be,a 40008c80 <_Protected_heap_Resize_block+0x228> <== NOT EXECUTED 40008b88: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40008b8c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40008b90: 12 80 00 0f bne 40008bcc <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 40008b94: 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; 40008b98: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40008b9c: 7f ff e4 93 call 40001de8 <== NOT EXECUTED 40008ba0: 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( 40008ba4: 10 bf ff d8 b 40008b04 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008ba8: 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 ) || 40008bac: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40008bb0: 12 bf ff d2 bne 40008af8 <_Protected_heap_Resize_block+0xa0> <== NOT EXECUTED 40008bb4: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40008bb8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008bbc: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40008bc0: 02 80 00 15 be 40008c14 <_Protected_heap_Resize_block+0x1bc> <== NOT EXECUTED 40008bc4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 40008bc8: 30 bf ff cc b,a 40008af8 <_Protected_heap_Resize_block+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008bcc: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED { Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 40008bd0: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40008bd4: c8 01 23 ec ld [ %g4 + 0x3ec ], %g4 <== NOT EXECUTED 40008bd8: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008bdc: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40008be0: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 40008be4: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40008be8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40008bec: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40008bf0: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40008bf4: 7f ff e4 7d call 40001de8 <== NOT EXECUTED 40008bf8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008bfc: d0 04 e3 e4 ld [ %l3 + 0x3e4 ], %o0 <== NOT EXECUTED 40008c00: 92 10 20 00 clr %o1 <== NOT EXECUTED 40008c04: 7f ff f8 8a call 40006e2c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40008c08: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 40008c0c: 10 bf ff be b 40008b04 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008c10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40008c14: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40008c18: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40008c1c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40008c20: 02 80 00 28 be 40008cc0 <_Protected_heap_Resize_block+0x268> <== NOT EXECUTED 40008c24: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40008c28: 1a 80 00 1c bcc 40008c98 <_Protected_heap_Resize_block+0x240> <== NOT EXECUTED 40008c2c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 40008c30: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 40008c34: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008c38: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40008c3c: 7f ff e4 6b call 40001de8 <== NOT EXECUTED 40008c40: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40008c44: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40008c48: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40008c4c: 40 00 00 21 call 40008cd0 <_Thread_Change_priority> <== NOT EXECUTED 40008c50: 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 ) 40008c54: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 40008c58: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008c5c: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 40008c60: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 <== NOT EXECUTED 40008c64: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40008c68: 32 bf ff a7 bne,a 40008b04 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008c6c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40008c70: 40 00 01 3c call 40009160 <_Thread_Dispatch> <== NOT EXECUTED 40008c74: 01 00 00 00 nop <== NOT EXECUTED 40008c78: 10 bf ff a3 b 40008b04 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008c7c: 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++; 40008c80: 82 00 60 01 inc %g1 <== NOT EXECUTED 40008c84: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40008c88: 7f ff e4 58 call 40001de8 <== NOT EXECUTED 40008c8c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008c90: 10 bf ff 9d b 40008b04 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008c94: 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; 40008c98: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40008c9c: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40008ca0: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40008ca4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40008ca8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40008cac: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40008cb0: 7f ff e4 4e call 40001de8 <== NOT EXECUTED 40008cb4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008cb8: 10 bf ff 93 b 40008b04 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008cbc: 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 ); 40008cc0: 7f ff e4 4a call 40001de8 <== NOT EXECUTED 40008cc4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40008cc8: 10 bf ff 8f b 40008b04 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 40008ccc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000ca28 <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 4000ca28: 9d e3 bf 98 save %sp, -104, %sp /* * Free per task variable memory */ tvp = deleted->task_variables; 4000ca2c: e0 06 61 7c ld [ %i1 + 0x17c ], %l0 deleted->task_variables = NULL; 4000ca30: c0 26 61 7c clr [ %i1 + 0x17c ] while (tvp) { 4000ca34: 80 a4 20 00 cmp %l0, 0 4000ca38: 02 80 00 25 be 4000cacc <_RTEMS_tasks_Delete_extension+0xa4> 4000ca3c: 29 10 00 66 sethi %hi(0x40019800), %l4 4000ca40: 27 10 00 66 sethi %hi(0x40019800), %l3 <== NOT EXECUTED 4000ca44: 10 80 00 12 b 4000ca8c <_RTEMS_tasks_Delete_extension+0x64> <== NOT EXECUTED 4000ca48: a4 15 23 5c or %l4, 0x35c, %l2 <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { if (tvp->dtor) 4000ca4c: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED 4000ca50: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000ca54: 22 80 00 06 be,a 4000ca6c <_RTEMS_tasks_Delete_extension+0x44> <== NOT EXECUTED 4000ca58: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED (*tvp->dtor)(*tvp->ptr); 4000ca5c: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 4000ca60: 9f c0 80 00 call %g2 <== NOT EXECUTED 4000ca64: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 4000ca68: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED 4000ca6c: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 4000ca70: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4000ca74: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 4000ca78: 7f ff ea 14 call 400072c8 <_Heap_Free> <== NOT EXECUTED 4000ca7c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 4000ca80: a0 94 60 00 orcc %l1, 0, %l0 <== NOT EXECUTED 4000ca84: 22 80 00 13 be,a 4000cad0 <_RTEMS_tasks_Delete_extension+0xa8> <== NOT EXECUTED 4000ca88: d2 06 61 6c ld [ %i1 + 0x16c ], %o1 <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 4000ca8c: c2 04 e3 ec ld [ %l3 + 0x3ec ], %g1 <== NOT EXECUTED 4000ca90: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 4000ca94: 02 bf ff ee be 4000ca4c <_RTEMS_tasks_Delete_extension+0x24> <== NOT EXECUTED 4000ca98: e2 04 00 00 ld [ %l0 ], %l1 <== NOT EXECUTED if (tvp->dtor) (*tvp->dtor)(*tvp->ptr); *tvp->ptr = tvp->gval; } else { if (tvp->dtor) 4000ca9c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 4000caa0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000caa4: 02 bf ff f5 be 4000ca78 <_RTEMS_tasks_Delete_extension+0x50> <== NOT EXECUTED 4000caa8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 4000caac: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000cab0: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED 4000cab4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 4000cab8: 7f ff ea 04 call 400072c8 <_Heap_Free> <== NOT EXECUTED 4000cabc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 4000cac0: a0 94 60 00 orcc %l1, 0, %l0 <== NOT EXECUTED 4000cac4: 12 bf ff f3 bne 4000ca90 <_RTEMS_tasks_Delete_extension+0x68> <== NOT EXECUTED 4000cac8: c2 04 e3 ec ld [ %l3 + 0x3ec ], %g1 <== NOT EXECUTED 4000cacc: d2 06 61 6c ld [ %i1 + 0x16c ], %o1 4000cad0: 7f ff e9 fe call 400072c8 <_Heap_Free> 4000cad4: 90 15 23 5c or %l4, 0x35c, %o0 /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 4000cad8: c0 26 61 6c clr [ %i1 + 0x16c ] } 4000cadc: 81 c7 e0 08 ret 4000cae0: 81 e8 00 00 restore 4000651c <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 4000651c: 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; 40006520: 03 10 00 66 sethi %hi(0x40019800), %g1 40006524: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 40019bd0 <_Configuration_Table> 40006528: 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; 4000652c: d0 00 e0 28 ld [ %g3 + 0x28 ], %o0 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) 40006530: 80 a2 20 00 cmp %o0, 0 40006534: 02 80 00 2f be 400065f0 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 40006538: e4 00 e0 24 ld [ %g3 + 0x24 ], %l2 4000653c: 80 a4 a0 00 cmp %l2, 0 40006540: 02 80 00 2c be 400065f0 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 40006544: a0 10 00 08 mov %o0, %l0 return; for ( index=0 ; index < maximum ; index++ ) { 40006548: a2 10 20 00 clr %l1 4000654c: 10 80 00 0c b 4000657c <_RTEMS_tasks_Initialize_user_tasks_body+0x60> 40006550: 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( 40006554: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 40006558: d0 07 bf f4 ld [ %fp + -12 ], %o0 4000655c: 40 00 00 27 call 400065f8 40006560: a2 04 60 01 inc %l1 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 40006564: 80 a2 20 00 cmp %o0, 0 40006568: 12 80 00 1c bne 400065d8 <_RTEMS_tasks_Initialize_user_tasks_body+0xbc> 4000656c: 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++ ) { 40006570: 80 a4 40 12 cmp %l1, %l2 40006574: 02 80 00 1f be 400065f0 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 40006578: a0 04 20 1c add %l0, 0x1c, %l0 return_value = rtems_task_create( 4000657c: d6 04 20 14 ld [ %l0 + 0x14 ], %o3 40006580: d8 04 20 0c ld [ %l0 + 0xc ], %o4 40006584: d2 04 20 08 ld [ %l0 + 8 ], %o1 40006588: d4 04 20 04 ld [ %l0 + 4 ], %o2 4000658c: d0 04 00 00 ld [ %l0 ], %o0 40006590: 7f ff ff 1a call 400061f8 40006594: 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 ) ) 40006598: 80 a2 20 00 cmp %o0, 0 4000659c: 22 bf ff ee be,a 40006554 <_RTEMS_tasks_Initialize_user_tasks_body+0x38> 400065a0: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 400065a4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 400065a8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400065ac: 40 00 04 47 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 400065b0: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED return_value = rtems_task_start( 400065b4: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED 400065b8: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 <== NOT EXECUTED 400065bc: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED 400065c0: 40 00 00 0e call 400065f8 <== NOT EXECUTED 400065c4: 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 ) ) 400065c8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400065cc: 02 bf ff ea be 40006574 <_RTEMS_tasks_Initialize_user_tasks_body+0x58> <== NOT EXECUTED 400065d0: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 400065d4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 400065d8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400065dc: 40 00 04 3b call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 400065e0: 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++ ) { 400065e4: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED 400065e8: 12 bf ff e5 bne 4000657c <_RTEMS_tasks_Initialize_user_tasks_body+0x60> <== NOT EXECUTED 400065ec: a0 04 20 1c add %l0, 0x1c, %l0 <== NOT EXECUTED 400065f0: 81 c7 e0 08 ret 400065f4: 81 e8 00 00 restore 4000c938 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 4000c938: 9d e3 bf 90 save %sp, -112, %sp * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 4000c93c: 7f ff d5 27 call 40001dd8 4000c940: f0 06 21 6c ld [ %i0 + 0x16c ], %i0 signal_set = asr->signals_posted; 4000c944: e4 06 20 54 ld [ %i0 + 0x54 ], %l2 asr->signals_posted = 0; 4000c948: c0 26 20 54 clr [ %i0 + 0x54 ] _ISR_Enable( level ); 4000c94c: 7f ff d5 27 call 40001de8 4000c950: 01 00 00 00 nop if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 4000c954: 80 a4 a0 00 cmp %l2, 0 4000c958: 32 80 00 04 bne,a 4000c968 <_RTEMS_tasks_Post_switch_extension+0x30> 4000c95c: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 4000c960: 81 c7 e0 08 ret <== NOT EXECUTED 4000c964: 81 e8 00 00 restore <== NOT EXECUTED return; asr->nest_level += 1; rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000c968: d0 06 20 50 ld [ %i0 + 0x50 ], %o0 if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ return; asr->nest_level += 1; 4000c96c: 82 00 60 01 inc %g1 rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000c970: a2 07 bf f4 add %fp, -12, %l1 if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ return; asr->nest_level += 1; 4000c974: c2 26 20 5c st %g1, [ %i0 + 0x5c ] rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000c978: 94 10 00 11 mov %l1, %o2 4000c97c: 21 00 00 3f sethi %hi(0xfc00), %l0 4000c980: 40 00 04 5a call 4000dae8 4000c984: 92 14 23 ff or %l0, 0x3ff, %o1 ! ffff (*asr->handler)( signal_set ); 4000c988: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 4000c98c: 9f c0 40 00 call %g1 4000c990: 90 10 00 12 mov %l2, %o0 asr->nest_level -= 1; 4000c994: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000c998: 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; 4000c99c: 82 00 7f ff add %g1, -1, %g1 rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000c9a0: 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; 4000c9a4: c2 26 20 5c st %g1, [ %i0 + 0x5c ] rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 4000c9a8: 40 00 04 50 call 4000dae8 4000c9ac: 94 10 00 11 mov %l1, %o2 4000c9b0: 81 c7 e0 08 ret 4000c9b4: 81 e8 00 00 restore 400071dc <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 400071dc: 9d e3 bf 90 save %sp, -112, %sp 400071e0: 11 10 00 78 sethi %hi(0x4001e000), %o0 400071e4: 92 10 00 18 mov %i0, %o1 400071e8: 90 12 21 b8 or %o0, 0x1b8, %o0 400071ec: 40 00 09 a7 call 40009888 <_Objects_Get> 400071f0: 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 ) { 400071f4: c2 07 bf f4 ld [ %fp + -12 ], %g1 400071f8: 80 a0 60 00 cmp %g1, 0 400071fc: 12 80 00 11 bne 40007240 <_Rate_monotonic_Timeout+0x64> 40007200: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: /* impossible */ case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; 40007204: d0 02 20 50 ld [ %o0 + 0x50 ], %o0 if ( _States_Is_waiting_for_period( the_thread->current_state ) && 40007208: 03 00 00 10 sethi %hi(0x4000), %g1 4000720c: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 40007210: 80 88 80 01 btst %g2, %g1 40007214: 32 80 00 0d bne,a 40007248 <_Rate_monotonic_Timeout+0x6c> 40007218: 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 ) { 4000721c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 40007220: 80 a0 60 01 cmp %g1, 1 40007224: 02 80 00 17 be 40007280 <_Rate_monotonic_Timeout+0xa4> 40007228: 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; 4000722c: 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; 40007230: 05 10 00 78 sethi %hi(0x4001e000), %g2 40007234: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 ! 4001e350 <_Thread_Dispatch_disable_level> 40007238: 82 00 7f ff add %g1, -1, %g1 4000723c: c2 20 a3 50 st %g1, [ %g2 + 0x350 ] 40007240: 81 c7 e0 08 ret 40007244: 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 ) && 40007248: c2 06 20 08 ld [ %i0 + 8 ], %g1 4000724c: 80 a0 80 01 cmp %g2, %g1 40007250: 32 bf ff f4 bne,a 40007220 <_Rate_monotonic_Timeout+0x44> 40007254: 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 ); 40007258: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000725c: 40 00 0d fe call 4000aa54 <_Thread_Clear_state> 40007260: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40007264: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40007268: 92 06 20 10 add %i0, 0x10, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000726c: c2 26 20 1c st %g1, [ %i0 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40007270: 11 10 00 79 sethi %hi(0x4001e400), %o0 40007274: 40 00 14 33 call 4000c340 <_Watchdog_Insert> 40007278: 90 12 20 4c or %o0, 0x4c, %o0 ! 4001e44c <_Watchdog_Ticks_chain> 4000727c: 30 bf ff ed b,a 40007230 <_Rate_monotonic_Timeout+0x54> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40007280: 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; 40007284: 84 10 20 03 mov 3, %g2 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40007288: 92 06 20 10 add %i0, 0x10, %o1 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 4000728c: c2 26 20 1c st %g1, [ %i0 + 0x1c ] <== NOT EXECUTED 40007290: c4 26 20 38 st %g2, [ %i0 + 0x38 ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40007294: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED 40007298: 40 00 14 2a call 4000c340 <_Watchdog_Insert> <== NOT EXECUTED 4000729c: 90 12 20 4c or %o0, 0x4c, %o0 ! 4001e44c <_Watchdog_Ticks_chain> <== NOT EXECUTED 400072a0: 30 bf ff e4 b,a 40007230 <_Rate_monotonic_Timeout+0x54> <== NOT EXECUTED 4001a5d8 <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 4001a5d8: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001a5dc: 27 10 00 cd sethi %hi(0x40033400), %l3 4001a5e0: c2 04 e0 e0 ld [ %l3 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 4001a5e4: 82 00 60 01 inc %g1 4001a5e8: c2 24 e0 e0 st %g1, [ %l3 + 0xe0 ] 4001a5ec: c2 04 e0 e0 ld [ %l3 + 0xe0 ], %g1 4001a5f0: 82 00 60 01 inc %g1 4001a5f4: c2 24 e0 e0 st %g1, [ %l3 + 0xe0 ] * 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(); 4001a5f8: 03 10 00 cd sethi %hi(0x40033400), %g1 4001a5fc: d0 00 61 b4 ld [ %g1 + 0x1b4 ], %o0 ! 400335b4 <_RTEMS_Allocator_Mutex> 4001a600: 94 10 20 00 clr %o2 4001a604: d2 02 20 08 ld [ %o0 + 8 ], %o1 4001a608: 7f ff e7 b5 call 400144dc <_CORE_mutex_Surrender> 4001a60c: 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 ) 4001a610: c2 04 e0 e0 ld [ %l3 + 0xe0 ], %g1 4001a614: a2 06 20 10 add %i0, 0x10, %l1 4001a618: 82 00 7f ff add %g1, -1, %g1 4001a61c: c2 24 e0 e0 st %g1, [ %l3 + 0xe0 ] 4001a620: c4 04 e0 e0 ld [ %l3 + 0xe0 ], %g2 4001a624: 80 a0 a0 00 cmp %g2, 0 4001a628: 02 80 00 21 be 4001a6ac <_Region_Process_queue+0xd4> 4001a62c: 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 ); 4001a630: 10 80 00 10 b 4001a670 <_Region_Process_queue+0x98> 4001a634: a4 06 20 68 add %i0, 0x68, %l2 the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 4001a638: 7f ff e8 bd call 4001492c <_Heap_Allocate> 4001a63c: d2 04 20 24 ld [ %l0 + 0x24 ], %o1 4001a640: 80 a2 20 00 cmp %o0, 0 4001a644: 02 80 00 11 be 4001a688 <_Region_Process_queue+0xb0> 4001a648: 01 00 00 00 nop break; *(void **)the_thread->Wait.return_argument = the_segment; the_region->number_of_used_blocks += 1; 4001a64c: c2 06 20 64 ld [ %i0 + 0x64 ], %g1 ); if ( the_segment == NULL ) break; *(void **)the_thread->Wait.return_argument = the_segment; 4001a650: c4 04 20 28 ld [ %l0 + 0x28 ], %g2 the_region->number_of_used_blocks += 1; 4001a654: 82 00 60 01 inc %g1 ); if ( the_segment == NULL ) break; *(void **)the_thread->Wait.return_argument = the_segment; 4001a658: d0 20 80 00 st %o0, [ %g2 ] the_region->number_of_used_blocks += 1; 4001a65c: c2 26 20 64 st %g1, [ %i0 + 0x64 ] _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 4001a660: 90 10 00 11 mov %l1, %o0 4001a664: 40 00 02 79 call 4001b048 <_Thread_queue_Extract> 4001a668: 92 10 00 10 mov %l0, %o1 the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 4001a66c: 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 ); 4001a670: 40 00 02 c0 call 4001b170 <_Thread_queue_First> 4001a674: 90 10 00 11 mov %l1, %o0 4001a678: a0 10 00 08 mov %o0, %l0 if ( the_thread == NULL ) 4001a67c: 80 a4 20 00 cmp %l0, 0 4001a680: 12 bf ff ee bne 4001a638 <_Region_Process_queue+0x60> 4001a684: 90 10 00 12 mov %l2, %o0 4001a688: c2 04 e0 e0 ld [ %l3 + 0xe0 ], %g1 4001a68c: 82 00 7f ff add %g1, -1, %g1 4001a690: c2 24 e0 e0 st %g1, [ %l3 + 0xe0 ] 4001a694: c4 04 e0 e0 ld [ %l3 + 0xe0 ], %g2 4001a698: 80 a0 a0 00 cmp %g2, 0 4001a69c: 02 80 00 07 be 4001a6b8 <_Region_Process_queue+0xe0> 4001a6a0: 01 00 00 00 nop 4001a6a4: 81 c7 e0 08 ret <== NOT EXECUTED 4001a6a8: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 4001a6ac: 7f ff f0 bf call 400169a8 <_Thread_Dispatch> <== NOT EXECUTED 4001a6b0: a4 06 20 68 add %i0, 0x68, %l2 <== NOT EXECUTED 4001a6b4: 30 bf ff ef b,a 4001a670 <_Region_Process_queue+0x98> <== NOT EXECUTED 4001a6b8: 7f ff f0 bc call 400169a8 <_Thread_Dispatch> 4001a6bc: 81 e8 00 00 restore 4001a6c0: 01 00 00 00 nop 40008ad0 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 40008ad0: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40008ad4: 23 10 00 98 sethi %hi(0x40026000), %l1 40008ad8: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 ! 400260e0 <_Thread_Dispatch_disable_level> 40008adc: 82 00 60 01 inc %g1 40008ae0: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 40008ae4: 21 10 00 98 sethi %hi(0x40026000), %l0 40008ae8: c2 06 00 00 ld [ %i0 ], %g1 40008aec: d4 04 21 98 ld [ %l0 + 0x198 ], %o2 40008af0: 80 a0 40 0a cmp %g1, %o2 40008af4: 36 80 00 18 bge,a 40008b54 <_TOD_Set+0x84> 40008af8: 94 20 40 0a sub %g1, %o2, %o2 Watchdog_Adjust_directions direction, Watchdog_Interval units ) { _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units ); 40008afc: 11 10 00 98 sethi %hi(0x40026000), %o0 40008b00: 94 22 80 01 sub %o2, %g1, %o2 40008b04: 90 12 21 d0 or %o0, 0x1d0, %o0 40008b08: 40 00 0e ea call 4000c6b0 <_Watchdog_Adjust> 40008b0c: 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; 40008b10: c4 06 00 00 ld [ %i0 ], %g2 40008b14: 86 14 21 98 or %l0, 0x198, %g3 40008b18: c4 24 21 98 st %g2, [ %l0 + 0x198 ] 40008b1c: c2 06 20 04 ld [ %i0 + 4 ], %g1 _TOD_Is_set = TRUE; 40008b20: 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; 40008b24: c2 20 e0 04 st %g1, [ %g3 + 4 ] _TOD_Is_set = TRUE; 40008b28: 03 10 00 98 sethi %hi(0x40026000), %g1 40008b2c: c4 20 61 1c st %g2, [ %g1 + 0x11c ] ! 4002611c <_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 ) 40008b30: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40008b34: 82 00 7f ff add %g1, -1, %g1 40008b38: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] 40008b3c: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 40008b40: 80 a0 a0 00 cmp %g2, 0 40008b44: 02 80 00 0a be 40008b6c <_TOD_Set+0x9c> 40008b48: 01 00 00 00 nop 40008b4c: 81 c7 e0 08 ret 40008b50: 81 e8 00 00 restore 40008b54: 11 10 00 98 sethi %hi(0x40026000), %o0 40008b58: 92 10 20 00 clr %o1 40008b5c: 40 00 0e d5 call 4000c6b0 <_Watchdog_Adjust> 40008b60: 90 12 21 d0 or %o0, 0x1d0, %o0 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 40008b64: 10 bf ff ec b 40008b14 <_TOD_Set+0x44> 40008b68: c4 06 00 00 ld [ %i0 ], %g2 _Thread_Dispatch(); 40008b6c: 40 00 08 3c call 4000ac5c <_Thread_Dispatch> <== NOT EXECUTED 40008b70: 81 e8 00 00 restore <== NOT EXECUTED 40008b74: 01 00 00 00 nop 40009010 <_Thread_Create_idle>: */ const char *_Thread_Idle_name = "IDLE"; void _Thread_Create_idle( void ) { 40009010: 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 ); 40009014: 39 10 00 67 sethi %hi(0x40019c00), %i4 40009018: 7f ff f9 d9 call 4000777c <_Objects_Allocate> 4000901c: 90 17 20 a0 or %i4, 0xa0, %o0 ! 40019ca0 <_Thread_Internal_information> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 40009020: 03 10 00 66 sethi %hi(0x40019800), %g1 40009024: 96 10 63 24 or %g1, 0x324, %o3 ! 40019b24 <_CPU_Table> 40009028: 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(); 4000902c: 37 10 00 67 sethi %hi(0x40019c00), %i3 40009030: d0 26 e0 f8 st %o0, [ %i3 + 0xf8 ] ! 40019cf8 <_Thread_Idle> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 40009034: 03 10 00 24 sethi %hi(0x40009000), %g1 40009038: 92 10 00 08 mov %o0, %o1 4000903c: 80 a0 a0 00 cmp %g2, 0 40009040: 02 80 00 03 be 4000904c <_Thread_Create_idle+0x3c> 40009044: b4 10 62 bc or %g1, 0x2bc, %i2 idle = _CPU_Table.idle_task; 40009048: b4 10 00 02 mov %g2, %i2 <== NOT EXECUTED idle_task_stack_size = _CPU_Table.idle_task_stack_size; 4000904c: d6 02 e0 14 ld [ %o3 + 0x14 ], %o3 if ( idle_task_stack_size < STACK_MINIMUM_SIZE ) 40009050: 80 a2 ef ff cmp %o3, 0xfff 40009054: 28 80 00 02 bleu,a 4000905c <_Thread_Create_idle+0x4c> 40009058: 17 00 00 04 sethi %hi(0x1000), %o3 idle_task_stack_size = STACK_MINIMUM_SIZE; _Thread_Initialize( 4000905c: 03 10 00 64 sethi %hi(0x40019000), %g1 40009060: c4 00 60 68 ld [ %g1 + 0x68 ], %g2 ! 40019068 <_Thread_Idle_name> 40009064: 82 10 20 01 mov 1, %g1 40009068: c4 23 a0 6c st %g2, [ %sp + 0x6c ] 4000906c: 90 17 20 a0 or %i4, 0xa0, %o0 40009070: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 40009074: c0 23 a0 60 clr [ %sp + 0x60 ] 40009078: c0 23 a0 64 clr [ %sp + 0x64 ] 4000907c: c0 23 a0 68 clr [ %sp + 0x68 ] 40009080: 94 10 20 00 clr %o2 40009084: 98 10 20 00 clr %o4 40009088: 40 00 00 8e call 400092c0 <_Thread_Initialize> 4000908c: 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 = 40009090: c6 06 e0 f8 ld [ %i3 + 0xf8 ], %g3 40009094: 03 10 00 66 sethi %hi(0x40019800), %g1 40009098: 05 10 00 66 sethi %hi(0x40019800), %g2 _Thread_Executing = _Thread_Idle; _Thread_Start( 4000909c: 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 = 400090a0: c6 20 63 ec st %g3, [ %g1 + 0x3ec ] 400090a4: c6 20 a3 c4 st %g3, [ %g2 + 0x3c4 ] _Thread_Executing = _Thread_Idle; _Thread_Start( 400090a8: b2 10 20 00 clr %i1 400090ac: b6 10 20 00 clr %i3 400090b0: 40 00 04 07 call 4000a0cc <_Thread_Start> 400090b4: 99 e8 20 00 restore %g0, 0, %o4 400090b8: 01 00 00 00 nop 400090bc <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 400090bc: 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 ) ) { 400090c0: 92 96 20 00 orcc %i0, 0, %o1 400090c4: 12 80 00 11 bne 40009108 <_Thread_Delay_ended+0x4c> 400090c8: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400090cc: 31 10 00 66 sethi %hi(0x40019800), %i0 <== NOT EXECUTED 400090d0: c2 06 23 10 ld [ %i0 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 400090d4: 82 00 60 01 inc %g1 <== NOT EXECUTED 400090d8: c2 26 23 10 st %g1, [ %i0 + 0x310 ] <== NOT EXECUTED Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 400090dc: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 400090e0: d0 00 63 ec ld [ %g1 + 0x3ec ], %o0 ! 40019bec <_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; 400090e4: 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 ); 400090e8: 13 04 00 ff sethi %hi(0x1003fc00), %o1 <== NOT EXECUTED 400090ec: 7f ff ff 68 call 40008e8c <_Thread_Clear_state> 400090f0: 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; 400090f4: c2 06 23 10 ld [ %i0 + 0x310 ], %g1 400090f8: 82 00 7f ff add %g1, -1, %g1 400090fc: c2 26 23 10 st %g1, [ %i0 + 0x310 ] 40009100: 81 c7 e0 08 ret 40009104: 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); 40009108: 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 ) { 4000910c: 80 a0 a0 04 cmp %g2, 4 40009110: 18 bf ff fc bgu 40009100 <_Thread_Delay_ended+0x44> 40009114: 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 :) */ 40009118: 80 a0 60 01 cmp %g1, 1 4000911c: 12 bf ff f9 bne 40009100 <_Thread_Delay_ended+0x44> 40009120: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40009124: 05 10 00 66 sethi %hi(0x40019800), %g2 40009128: 84 10 a2 70 or %g2, 0x270, %g2 ! 40019a70 <_Objects_Information_table> 4000912c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40009130: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40009134: 80 a2 20 00 cmp %o0, 0 40009138: 02 bf ff f2 be 40009100 <_Thread_Delay_ended+0x44> 4000913c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40009140: 7f ff fa e0 call 40007cc0 <_Objects_Get> 40009144: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40009148: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000914c: 80 a0 60 00 cmp %g1, 0 40009150: 12 bf ff ec bne 40009100 <_Thread_Delay_ended+0x44> 40009154: 31 10 00 66 sethi %hi(0x40019800), %i0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 40009158: 10 bf ff e5 b 400090ec <_Thread_Delay_ended+0x30> 4000915c: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000de9c <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 4000de9c: 9d e3 bf 98 save %sp, -104, %sp #endif #if defined(__USE__MAIN__) extern void _main(void); #endif executing = _Thread_Executing; 4000dea0: 03 10 00 66 sethi %hi(0x40019800), %g1 4000dea4: f4 00 63 ec ld [ %g1 + 0x3ec ], %i2 ! 40019bec <_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(); 4000dea8: 3f 10 00 37 sethi %hi(0x4000dc00), %i7 4000deac: be 17 e2 9c or %i7, 0x29c, %i7 ! 4000de9c <_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); 4000deb0: d0 06 a0 c4 ld [ %i2 + 0xc4 ], %o0 4000deb4: 7f ff cf cd call 40001de8 4000deb8: 91 2a 20 08 sll %o0, 8, %o0 #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 4000debc: 05 10 00 66 sethi %hi(0x40019800), %g2 doneConstructors = 1; 4000dec0: 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; 4000dec4: f2 08 a1 2c ldub [ %g2 + 0x12c ], %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 ); 4000dec8: 90 10 00 1a mov %i2, %o0 4000decc: 7f ff f1 3e call 4000a3c4 <_User_extensions_Thread_begin> 4000ded0: c2 28 a1 2c stb %g1, [ %g2 + 0x12c ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 4000ded4: 05 10 00 66 sethi %hi(0x40019800), %g2 4000ded8: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> 4000dedc: 82 00 7f ff add %g1, -1, %g1 4000dee0: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] 4000dee4: c6 00 a3 10 ld [ %g2 + 0x310 ], %g3 4000dee8: 80 a0 e0 00 cmp %g3, 0 4000deec: 02 80 00 36 be 4000dfc4 <_Thread_Handler+0x128> 4000def0: 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) */ 4000def4: 83 2e 60 18 sll %i1, 0x18, %g1 <== NOT EXECUTED 4000def8: 80 a0 60 00 cmp %g1, 0 4000defc: 02 80 00 22 be 4000df84 <_Thread_Handler+0xe8> 4000df00: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 4000df04: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 4000df08: 80 a0 60 01 cmp %g1, 1 4000df0c: 22 80 00 25 be,a 4000dfa0 <_Thread_Handler+0x104> 4000df10: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 4000df14: 80 a0 60 01 cmp %g1, 1 4000df18: 1a 80 00 0c bcc 4000df48 <_Thread_Handler+0xac> 4000df1c: 80 a0 60 02 cmp %g1, 2 case THREAD_START_NUMERIC: executing->Wait.return_argument = 4000df20: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 4000df24: 9f c0 40 00 call %g1 4000df28: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 4000df2c: 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 ); 4000df30: 90 10 00 1a mov %i2, %o0 4000df34: 7f ff f1 4c call 4000a464 <_User_extensions_Thread_exitted> 4000df38: b0 10 20 00 clr %i0 _Internal_error_Occurred( 4000df3c: b2 10 20 01 mov 1, %i1 4000df40: 7f ff e5 e2 call 400076c8 <_Internal_error_Occurred> 4000df44: 95 e8 20 06 restore %g0, 6, %o2 #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 4000df48: 02 80 00 23 be 4000dfd4 <_Thread_Handler+0x138> <== NOT EXECUTED 4000df4c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 4000df50: 12 bf ff f9 bne 4000df34 <_Thread_Handler+0x98> <== NOT EXECUTED 4000df54: 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 = 4000df58: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 4000df5c: d2 06 a0 b0 ld [ %i2 + 0xb0 ], %o1 <== NOT EXECUTED 4000df60: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 <== NOT EXECUTED 4000df64: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000df68: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000df6c: 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 ); 4000df70: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000df74: 7f ff f1 3c call 4000a464 <_User_extensions_Thread_exitted> <== NOT EXECUTED 4000df78: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 4000df7c: 7f ff e5 d3 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 4000df80: 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 (); 4000df84: 40 00 2a d3 call 40018ad0 <_init> 4000df88: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 4000df8c: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 4000df90: 80 a0 60 01 cmp %g1, 1 4000df94: 12 bf ff e1 bne 4000df18 <_Thread_Handler+0x7c> 4000df98: 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 = 4000df9c: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 4000dfa0: d0 06 a0 b0 ld [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED 4000dfa4: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000dfa8: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000dfac: 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 ); 4000dfb0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000dfb4: 7f ff f1 2c call 4000a464 <_User_extensions_Thread_exitted> <== NOT EXECUTED 4000dfb8: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 4000dfbc: 7f ff e5 c3 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 4000dfc0: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED _Thread_Dispatch(); 4000dfc4: 7f ff ec 67 call 40009160 <_Thread_Dispatch> 4000dfc8: 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) */ 4000dfcc: 10 bf ff cb b 4000def8 <_Thread_Handler+0x5c> 4000dfd0: 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 = 4000dfd4: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 4000dfd8: d0 1e a0 b0 ldd [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED 4000dfdc: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000dfe0: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000dfe4: 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 ); 4000dfe8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 4000dfec: 7f ff f1 1e call 4000a464 <_User_extensions_Thread_exitted> <== NOT EXECUTED 4000dff0: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 4000dff4: 7f ff e5 b5 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 4000dff8: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED 4000dffc: 01 00 00 00 nop 4000947c <_Thread_Handler_initialization>: void _Thread_Handler_initialization( uint32_t ticks_per_timeslice, uint32_t maximum_extensions, uint32_t maximum_proxies ) { 4000947c: 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 ) 40009480: 03 10 00 66 sethi %hi(0x40019800), %g1 40009484: 82 10 63 24 or %g1, 0x324, %g1 ! 40019b24 <_CPU_Table> 40009488: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 4000948c: c6 00 60 24 ld [ %g1 + 0x24 ], %g3 40009490: 80 a0 00 02 cmp %g0, %g2 40009494: 88 60 3f ff subx %g0, -1, %g4 40009498: 80 a0 00 03 cmp %g0, %g3 4000949c: 82 60 3f ff subx %g0, -1, %g1 400094a0: 80 a1 00 01 cmp %g4, %g1 400094a4: 12 80 00 2c bne 40009554 <_Thread_Handler_initialization+0xd8> 400094a8: 90 10 20 00 clr %o0 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 400094ac: 03 10 00 66 sethi %hi(0x40019800), %g1 _Thread_Executing = NULL; 400094b0: 05 10 00 66 sethi %hi(0x40019800), %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 400094b4: c0 20 63 fc clr [ %g1 + 0x3fc ] _Thread_Executing = NULL; 400094b8: c0 20 a3 ec clr [ %g2 + 0x3ec ] _Thread_Heir = NULL; 400094bc: 03 10 00 66 sethi %hi(0x40019800), %g1 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; 400094c0: 05 10 00 66 sethi %hi(0x40019800), %g2 INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; _Thread_Executing = NULL; _Thread_Heir = NULL; 400094c4: c0 20 63 c4 clr [ %g1 + 0x3c4 ] #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; 400094c8: c0 20 a3 dc clr [ %g2 + 0x3dc ] _Thread_Maximum_extensions = maximum_extensions; 400094cc: 03 10 00 66 sethi %hi(0x40019800), %g1 _Thread_Ticks_per_timeslice = ticks_per_timeslice; 400094d0: 05 10 00 66 sethi %hi(0x40019800), %g2 _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; _Thread_Maximum_extensions = maximum_extensions; 400094d4: f2 20 63 d8 st %i1, [ %g1 + 0x3d8 ] _Thread_Ticks_per_timeslice = ticks_per_timeslice; 400094d8: f0 20 a2 68 st %i0, [ %g2 + 0x268 ] _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 400094dc: 40 00 05 13 call 4000a928 <_Workspace_Allocate_or_fatal_error> 400094e0: 90 10 2c 00 mov 0xc00, %o0 400094e4: 03 10 00 66 sethi %hi(0x40019800), %g1 400094e8: 84 10 00 08 mov %o0, %g2 400094ec: d0 20 62 64 st %o0, [ %g1 + 0x264 ] 400094f0: 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); 400094f4: 82 00 a0 04 add %g2, 4, %g1 the_chain->permanent_null = NULL; 400094f8: c0 20 a0 04 clr [ %g2 + 4 ] the_chain->last = _Chain_Head(the_chain); 400094fc: 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); 40009500: c2 20 80 00 st %g1, [ %g2 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009504: 84 00 a0 0c add %g2, 0xc, %g2 (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 40009508: 80 a0 80 03 cmp %g2, %g3 4000950c: 12 bf ff fb bne 400094f8 <_Thread_Handler_initialization+0x7c> 40009510: 82 00 a0 04 add %g2, 4, %g1 /* * Initialize this class of objects. */ _Objects_Initialize_information( 40009514: 03 10 00 67 sethi %hi(0x40019c00), %g1 40009518: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 ! 40019c18 <_System_state_Is_multiprocessing> 4000951c: 82 10 20 08 mov 8, %g1 40009520: 80 a0 00 02 cmp %g0, %g2 40009524: 96 10 20 02 mov 2, %o3 40009528: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 4000952c: 96 42 ff ff addx %o3, -1, %o3 40009530: 11 10 00 67 sethi %hi(0x40019c00), %o0 40009534: 92 10 20 01 mov 1, %o1 40009538: 90 12 20 a0 or %o0, 0xa0, %o0 4000953c: 94 10 20 01 mov 1, %o2 40009540: 98 10 21 80 mov 0x180, %o4 40009544: 7f ff fa 06 call 40007d5c <_Objects_Initialize_information> 40009548: 9a 10 20 01 mov 1, %o5 FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 4000954c: 81 c7 e0 08 ret 40009550: 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( 40009554: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 40009558: 7f ff f8 5c call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 4000955c: 94 10 20 0f mov 0xf, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 40009560: 10 bf ff d4 b 400094b0 <_Thread_Handler_initialization+0x34> <== NOT EXECUTED 40009564: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 400092c0 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 400092c0: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the Ada self pointer */ the_thread->rtems_ada_self = NULL; 400092c4: c0 26 60 80 clr [ %i1 + 0x80 ] /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 400092c8: 80 a6 a0 00 cmp %i2, 0 400092cc: 02 80 00 59 be 40009430 <_Thread_Initialize+0x170> 400092d0: 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; 400092d4: c0 26 60 cc clr [ %i1 + 0xcc ] <== NOT EXECUTED 400092d8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 400092dc: 21 10 00 66 sethi %hi(0x40019800), %l0 400092e0: d2 04 23 d8 ld [ %l0 + 0x3d8 ], %o1 ! 40019bd8 <_Thread_Maximum_extensions> Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 400092e4: f4 26 60 d4 st %i2, [ %i1 + 0xd4 ] the_stack->size = size; 400092e8: d0 26 60 d0 st %o0, [ %i1 + 0xd0 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 400092ec: c0 26 60 50 clr [ %i1 + 0x50 ] the_watchdog->routine = routine; 400092f0: c0 26 60 64 clr [ %i1 + 0x64 ] the_watchdog->id = id; 400092f4: c0 26 60 68 clr [ %i1 + 0x68 ] the_watchdog->user_data = user_data; 400092f8: c0 26 60 6c clr [ %i1 + 0x6c ] 400092fc: 80 a2 60 00 cmp %o1, 0 40009300: 12 80 00 38 bne 400093e0 <_Thread_Initialize+0x120> 40009304: c0 26 61 68 clr [ %i1 + 0x168 ] return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 40009308: c0 26 61 78 clr [ %i1 + 0x178 ] 4000930c: b6 10 20 00 clr %i3 /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 40009310: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 the_thread->Start.budget_algorithm = budget_algorithm; 40009314: e2 26 60 bc st %l1, [ %i1 + 0xbc ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 40009318: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 4000931c: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 switch ( budget_algorithm ) { 40009320: 80 a4 60 02 cmp %l1, 2 40009324: 12 80 00 05 bne 40009338 <_Thread_Initialize+0x78> 40009328: 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; 4000932c: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 40009330: c4 00 62 68 ld [ %g1 + 0x268 ], %g2 ! 40019a68 <_Thread_Ticks_per_timeslice> <== NOT EXECUTED 40009334: 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; 40009338: c2 07 a0 68 ld [ %fp + 0x68 ], %g1 the_thread->current_state = STATES_DORMANT; the_thread->Wait.queue = NULL; 4000933c: c0 26 60 44 clr [ %i1 + 0x44 ] break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 40009340: c2 26 60 c4 st %g1, [ %i1 + 0xc4 ] the_thread->current_state = STATES_DORMANT; 40009344: 82 10 20 01 mov 1, %g1 the_thread->Wait.queue = NULL; the_thread->resource_count = 0; 40009348: c0 26 60 1c clr [ %i1 + 0x1c ] break; } the_thread->Start.isr_level = isr_level; the_thread->current_state = STATES_DORMANT; 4000934c: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_thread->Wait.queue = NULL; the_thread->resource_count = 0; the_thread->suspend_count = 0; 40009350: c0 26 60 70 clr [ %i1 + 0x70 ] the_thread->real_priority = priority; 40009354: fa 26 60 18 st %i5, [ %i1 + 0x18 ] the_thread->Start.initial_priority = priority; 40009358: fa 26 60 c8 st %i5, [ %i1 + 0xc8 ] _Thread_Set_priority( the_thread, priority ); 4000935c: 92 10 00 1d mov %i5, %o1 40009360: 40 00 02 76 call 40009d38 <_Thread_Set_priority> 40009364: 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 ); 40009368: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000936c: 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; 40009370: c0 26 60 90 clr [ %i1 + 0x90 ] 40009374: 03 00 00 3f sethi %hi(0xfc00), %g1 40009378: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000937c: 82 08 80 01 and %g2, %g1, %g1 40009380: 80 a0 40 03 cmp %g1, %g3 40009384: 08 80 00 13 bleu 400093d0 <_Thread_Initialize+0x110> 40009388: 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; 4000938c: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 /* * Invoke create extensions */ if ( !_User_extensions_Thread_create( the_thread ) ) { 40009390: 90 10 00 19 mov %i1, %o0 40009394: c2 26 60 0c st %g1, [ %i1 + 0xc ] 40009398: 40 00 04 46 call 4000a4b0 <_User_extensions_Thread_create> 4000939c: b0 10 20 01 mov 1, %i0 400093a0: 80 a2 20 00 cmp %o0, 0 400093a4: 12 80 00 34 bne 40009474 <_Thread_Initialize+0x1b4> 400093a8: 80 a6 e0 00 cmp %i3, 0 if ( extensions_area ) 400093ac: 02 80 00 05 be 400093c0 <_Thread_Initialize+0x100> 400093b0: 11 10 00 66 sethi %hi(0x40019800), %o0 400093b4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 400093b8: 7f ff f7 c4 call 400072c8 <_Heap_Free> <== NOT EXECUTED 400093bc: 90 12 23 5c or %o0, 0x35c, %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 ); 400093c0: 40 00 03 22 call 4000a048 <_Thread_Stack_Free> 400093c4: 90 10 00 19 mov %i1, %o0 400093c8: 81 c7 e0 08 ret 400093cc: 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; 400093d0: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 400093d4: 83 28 60 02 sll %g1, 2, %g1 400093d8: 10 bf ff ed b 4000938c <_Thread_Initialize+0xcc> 400093dc: f2 20 80 01 st %i1, [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 400093e0: 92 02 60 01 inc %o1 400093e4: 11 10 00 66 sethi %hi(0x40019800), %o0 400093e8: 93 2a 60 02 sll %o1, 2, %o1 400093ec: 7f ff f7 85 call 40007200 <_Heap_Allocate> 400093f0: 90 12 23 5c or %o0, 0x35c, %o0 if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 400093f4: b6 92 20 00 orcc %o0, 0, %i3 400093f8: 02 80 00 1c be 40009468 <_Thread_Initialize+0x1a8> 400093fc: c2 04 23 d8 ld [ %l0 + 0x3d8 ], %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 40009400: 80 a0 7f ff cmp %g1, -1 40009404: 02 bf ff c3 be 40009310 <_Thread_Initialize+0x50> 40009408: f6 26 61 78 st %i3, [ %i1 + 0x178 ] 4000940c: 86 00 60 01 add %g1, 1, %g3 40009410: 84 10 20 00 clr %g2 the_thread->extensions[i] = NULL; 40009414: 83 28 a0 02 sll %g2, 2, %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 40009418: 84 00 a0 01 inc %g2 4000941c: 80 a0 80 03 cmp %g2, %g3 40009420: 12 bf ff fd bne 40009414 <_Thread_Initialize+0x154> 40009424: c0 26 c0 01 clr [ %i3 + %g1 ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 40009428: 10 bf ff bb b 40009314 <_Thread_Initialize+0x54> 4000942c: 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 ) ) 40009430: 80 a6 ef ff cmp %i3, 0xfff 40009434: 08 80 00 03 bleu 40009440 <_Thread_Initialize+0x180> 40009438: 13 00 00 04 sethi %hi(0x1000), %o1 4000943c: 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 ); 40009440: 40 00 02 e7 call 40009fdc <_Thread_Stack_Allocate> 40009444: 90 10 00 19 mov %i1, %o0 if ( !actual_stack_size || actual_stack_size < stack_size ) 40009448: 80 a2 20 00 cmp %o0, 0 4000944c: 02 bf ff df be 400093c8 <_Thread_Initialize+0x108> 40009450: 80 a6 c0 08 cmp %i3, %o0 40009454: 18 bf ff dd bgu 400093c8 <_Thread_Initialize+0x108> 40009458: 82 10 20 01 mov 1, %g1 return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 4000945c: f4 06 60 d8 ld [ %i1 + 0xd8 ], %i2 the_thread->Start.core_allocated_stack = TRUE; 40009460: 10 bf ff 9f b 400092dc <_Thread_Initialize+0x1c> 40009464: 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 ); 40009468: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4000946c: 40 00 02 f7 call 4000a048 <_Thread_Stack_Free> <== NOT EXECUTED 40009470: b0 10 20 00 clr %i0 <== NOT EXECUTED 40009474: 81 c7 e0 08 ret 40009478: 81 e8 00 00 restore 4000e29c <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { 4000e29c: 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; 4000e2a0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000e2a4: c4 06 20 bc ld [ %i0 + 0xbc ], %g2 the_thread->budget_callout = the_thread->Start.budget_callout; 4000e2a8: 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; 4000e2ac: 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; 4000e2b0: c4 3e 20 88 std %g2, [ %i0 + 0x88 ] the_thread->Start.pointer_argument = pointer_argument; 4000e2b4: f2 26 20 b0 st %i1, [ %i0 + 0xb0 ] the_thread->Start.numeric_argument = numeric_argument; 4000e2b8: f4 26 20 b4 st %i2, [ %i0 + 0xb4 ] Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { the_thread->resource_count = 0; 4000e2bc: c0 26 20 1c clr [ %i0 + 0x1c ] the_thread->suspend_count = 0; 4000e2c0: 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 ) ) { 4000e2c4: 7f ff f1 24 call 4000a754 <_Thread_queue_Extract_with_proxy> 4000e2c8: 90 10 00 18 mov %i0, %o0 4000e2cc: 80 a2 20 00 cmp %o0, 0 4000e2d0: 32 80 00 07 bne,a 4000e2ec <_Thread_Reset+0x50> 4000e2d4: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 if ( _Watchdog_Is_active( &the_thread->Timer ) ) 4000e2d8: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000e2dc: 80 a0 60 02 cmp %g1, 2 4000e2e0: 02 80 00 0c be 4000e310 <_Thread_Reset+0x74> 4000e2e4: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 4000e2e8: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 4000e2ec: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4000e2f0: 80 a0 40 19 cmp %g1, %i1 4000e2f4: 02 80 00 05 be 4000e308 <_Thread_Reset+0x6c> 4000e2f8: 01 00 00 00 nop the_thread->real_priority = the_thread->Start.initial_priority; 4000e2fc: f2 26 20 18 st %i1, [ %i0 + 0x18 ] _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 4000e300: 7f ff f1 d6 call 4000aa58 <_Thread_Set_priority> 4000e304: 81 e8 00 00 restore 4000e308: 81 c7 e0 08 ret 4000e30c: 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 ); 4000e310: 7f ff f4 81 call 4000b514 <_Watchdog_Remove> <== NOT EXECUTED 4000e314: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 4000e318: 10 bf ff f5 b 4000e2ec <_Thread_Reset+0x50> <== NOT EXECUTED 4000e31c: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 <== NOT EXECUTED 4000d4a4 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 4000d4a4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 4000d4a8: 03 10 00 66 sethi %hi(0x40019800), %g1 4000d4ac: e0 00 63 ec ld [ %g1 + 0x3ec ], %l0 ! 40019bec <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 4000d4b0: 7f ff d2 4a call 40001dd8 4000d4b4: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 4000d4b8: b0 10 00 08 mov %o0, %i0 if ( _Chain_Has_only_one_node( ready ) ) { 4000d4bc: c4 04 40 00 ld [ %l1 ], %g2 4000d4c0: c2 04 60 08 ld [ %l1 + 8 ], %g1 4000d4c4: 80 a0 80 01 cmp %g2, %g1 4000d4c8: 32 80 00 04 bne,a 4000d4d8 <_Thread_Reset_timeslice+0x34> 4000d4cc: c6 04 00 00 ld [ %l0 ], %g3 _ISR_Enable( level ); 4000d4d0: 7f ff d2 46 call 40001de8 4000d4d4: 81 e8 00 00 restore { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 4000d4d8: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000d4dc: 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; 4000d4e0: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000d4e4: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000d4e8: 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; 4000d4ec: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 4000d4f0: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000d4f4: 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; 4000d4f8: e0 20 40 00 st %l0, [ %g1 ] return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 4000d4fc: 7f ff d2 3b call 40001de8 4000d500: 01 00 00 00 nop 4000d504: 7f ff d2 35 call 40001dd8 4000d508: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 4000d50c: 05 10 00 66 sethi %hi(0x40019800), %g2 4000d510: c2 00 a3 c4 ld [ %g2 + 0x3c4 ], %g1 ! 40019bc4 <_Thread_Heir> 4000d514: 80 a4 00 01 cmp %l0, %g1 4000d518: 32 80 00 05 bne,a 4000d52c <_Thread_Reset_timeslice+0x88> 4000d51c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 4000d520: c2 04 40 00 ld [ %l1 ], %g1 4000d524: c2 20 a3 c4 st %g1, [ %g2 + 0x3c4 ] _Context_Switch_necessary = TRUE; 4000d528: 84 10 20 01 mov 1, %g2 4000d52c: 03 10 00 66 sethi %hi(0x40019800), %g1 4000d530: c4 20 63 fc st %g2, [ %g1 + 0x3fc ] ! 40019bfc <_Context_Switch_necessary> _ISR_Enable( level ); 4000d534: 7f ff d2 2d call 40001de8 4000d538: 81 e8 00 00 restore 4000d53c: 01 00 00 00 nop 4000b88c <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, boolean force ) { 4000b88c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; States_Control current_state; _ISR_Disable( level ); 4000b890: 7f ff dc 9a call 40002af8 4000b894: 01 00 00 00 nop 4000b898: a0 10 00 08 mov %o0, %l0 if ( force == TRUE ) 4000b89c: 80 a6 60 01 cmp %i1, 1 4000b8a0: 22 80 00 13 be,a 4000b8ec <_Thread_Resume+0x60> 4000b8a4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 the_thread->suspend_count = 0; else the_thread->suspend_count--; 4000b8a8: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED 4000b8ac: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 4000b8b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000b8b4: 12 80 00 0c bne 4000b8e4 <_Thread_Resume+0x58> <== NOT EXECUTED 4000b8b8: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED _ISR_Enable( level ); return; } current_state = the_thread->current_state; 4000b8bc: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 4000b8c0: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 4000b8c4: 02 80 00 06 be 4000b8dc <_Thread_Resume+0x50> <== NOT EXECUTED 4000b8c8: 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); 4000b8cc: 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 ) ) { 4000b8d0: 80 a0 60 00 cmp %g1, 0 4000b8d4: 02 80 00 0b be 4000b900 <_Thread_Resume+0x74> 4000b8d8: c2 26 20 10 st %g1, [ %i0 + 0x10 ] _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 4000b8dc: 7f ff dc 8b call 40002b08 4000b8e0: 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 ); 4000b8e4: 7f ff dc 89 call 40002b08 <== NOT EXECUTED 4000b8e8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { 4000b8ec: 80 88 60 02 btst 2, %g1 4000b8f0: 02 bf ff fb be 4000b8dc <_Thread_Resume+0x50> 4000b8f4: c0 26 20 70 clr [ %i0 + 0x70 ] 4000b8f8: 10 bf ff f6 b 4000b8d0 <_Thread_Resume+0x44> 4000b8fc: 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; 4000b900: c8 06 20 9c ld [ %i0 + 0x9c ], %g4 4000b904: c4 16 20 a2 lduh [ %i0 + 0xa2 ], %g2 4000b908: 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); 4000b90c: c6 06 20 98 ld [ %i0 + 0x98 ], %g3 4000b910: 82 10 40 02 or %g1, %g2, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 4000b914: 1b 10 00 98 sethi %hi(0x40026000), %o5 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 4000b918: c2 31 00 00 sth %g1, [ %g4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000b91c: 82 00 e0 04 add %g3, 4, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 4000b920: d8 16 20 a0 lduh [ %i0 + 0xa0 ], %o4 4000b924: c2 26 00 00 st %g1, [ %i0 ] 4000b928: c4 13 61 b0 lduh [ %o5 + 0x1b0 ], %g2 old_last_node = the_chain->last; 4000b92c: c8 00 e0 08 ld [ %g3 + 8 ], %g4 the_chain->last = the_node; 4000b930: f0 20 e0 08 st %i0, [ %g3 + 8 ] 4000b934: 84 10 80 0c or %g2, %o4, %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 4000b938: c8 26 20 04 st %g4, [ %i0 + 4 ] 4000b93c: c4 33 61 b0 sth %g2, [ %o5 + 0x1b0 ] 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; 4000b940: f0 21 00 00 st %i0, [ %g4 ] _ISR_Flash( level ); 4000b944: 7f ff dc 71 call 40002b08 4000b948: 90 10 00 10 mov %l0, %o0 4000b94c: 7f ff dc 6b call 40002af8 4000b950: 01 00 00 00 nop if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 4000b954: 09 10 00 98 sethi %hi(0x40026000), %g4 4000b958: c4 01 21 94 ld [ %g4 + 0x194 ], %g2 ! 40026194 <_Thread_Heir> 4000b95c: c6 06 20 14 ld [ %i0 + 0x14 ], %g3 4000b960: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 4000b964: 80 a0 c0 01 cmp %g3, %g1 4000b968: 1a bf ff dd bcc 4000b8dc <_Thread_Resume+0x50> 4000b96c: 01 00 00 00 nop _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 4000b970: 03 10 00 98 sethi %hi(0x40026000), %g1 4000b974: c4 00 61 bc ld [ %g1 + 0x1bc ], %g2 ! 400261bc <_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; 4000b978: f0 21 21 94 st %i0, [ %g4 + 0x194 ] if ( _Thread_Executing->is_preemptible || 4000b97c: c2 00 a0 7c ld [ %g2 + 0x7c ], %g1 4000b980: 80 a0 60 00 cmp %g1, 0 4000b984: 02 80 00 06 be 4000b99c <_Thread_Resume+0x110> 4000b988: 80 a0 e0 00 cmp %g3, 0 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 4000b98c: 84 10 20 01 mov 1, %g2 4000b990: 03 10 00 98 sethi %hi(0x40026000), %g1 4000b994: c4 20 61 cc st %g2, [ %g1 + 0x1cc ] ! 400261cc <_Context_Switch_necessary> 4000b998: 30 bf ff d1 b,a 4000b8dc <_Thread_Resume+0x50> _ISR_Flash( level ); if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 4000b99c: 12 bf ff d0 bne 4000b8dc <_Thread_Resume+0x50> 4000b9a0: 84 10 20 01 mov 1, %g2 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 4000b9a4: 10 bf ff fc b 4000b994 <_Thread_Resume+0x108> <== NOT EXECUTED 4000b9a8: 03 10 00 98 sethi %hi(0x40026000), %g1 <== NOT EXECUTED 40009fdc <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 40009fdc: 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 ) ) 40009fe0: 80 a6 6f ff cmp %i1, 0xfff 40009fe4: 28 80 00 02 bleu,a 40009fec <_Thread_Stack_Allocate+0x10> 40009fe8: 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 ) { 40009fec: 03 10 00 66 sethi %hi(0x40019800), %g1 40009ff0: c2 00 63 44 ld [ %g1 + 0x344 ], %g1 ! 40019b44 <_CPU_Table+0x20> 40009ff4: 80 a0 60 00 cmp %g1, 0 40009ff8: 02 80 00 0a be 4000a020 <_Thread_Stack_Allocate+0x44> 40009ffc: 92 06 60 10 add %i1, 0x10, %o1 stack_addr = (*_CPU_Table.stack_allocate_hook)( the_stack_size ); 4000a000: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a004: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 4000a008: 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 ) 4000a00c: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 4000a010: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 4000a014: b0 0e 40 18 and %i1, %i0, %i0 <== NOT EXECUTED 4000a018: 81 c7 e0 08 ret <== NOT EXECUTED 4000a01c: 81 e8 00 00 restore <== NOT EXECUTED 4000a020: 11 10 00 66 sethi %hi(0x40019800), %o0 4000a024: b2 10 00 09 mov %o1, %i1 4000a028: 7f ff f4 76 call 40007200 <_Heap_Allocate> 4000a02c: 90 12 23 5c or %o0, 0x35c, %o0 } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 4000a030: 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 ) 4000a034: 80 a0 00 08 cmp %g0, %o0 4000a038: b0 60 20 00 subx %g0, 0, %i0 the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 4000a03c: b0 0e 40 18 and %i1, %i0, %i0 4000a040: 81 c7 e0 08 ret 4000a044: 81 e8 00 00 restore 4000a048 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 4000a048: 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 ) 4000a04c: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 4000a050: 80 a0 60 00 cmp %g1, 0 4000a054: 02 80 00 08 be 4000a074 <_Thread_Stack_Free+0x2c> 4000a058: 03 10 00 66 sethi %hi(0x40019800), %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 ) 4000a05c: c2 00 63 48 ld [ %g1 + 0x348 ], %g1 ! 40019b48 <_CPU_Table+0x24> 4000a060: 80 a0 60 00 cmp %g1, 0 4000a064: 22 80 00 06 be,a 4000a07c <_Thread_Stack_Free+0x34> 4000a068: f2 06 20 d4 ld [ %i0 + 0xd4 ], %i1 (*_CPU_Table.stack_free_hook)( the_thread->Start.Initial_stack.area ); 4000a06c: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a070: d0 06 20 d4 ld [ %i0 + 0xd4 ], %o0 <== NOT EXECUTED 4000a074: 81 c7 e0 08 ret <== NOT EXECUTED 4000a078: 81 e8 00 00 restore <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4000a07c: 31 10 00 66 sethi %hi(0x40019800), %i0 4000a080: 7f ff f4 92 call 400072c8 <_Heap_Free> 4000a084: 91 ee 23 5c restore %i0, 0x35c, %o0 4000a088: 01 00 00 00 nop 4000a114 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 4000a114: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; 4000a118: 03 10 00 66 sethi %hi(0x40019800), %g1 4000a11c: e0 00 63 ec ld [ %g1 + 0x3ec ], %l0 ! 40019bec <_Thread_Executing> /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 4000a120: c4 04 20 7c ld [ %l0 + 0x7c ], %g2 4000a124: 80 a0 a0 00 cmp %g2, 0 4000a128: 02 80 00 24 be 4000a1b8 <_Thread_Tickle_timeslice+0xa4> 4000a12c: 01 00 00 00 nop return; if ( !_States_Is_ready( executing->current_state ) ) 4000a130: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 4000a134: 80 a0 60 00 cmp %g1, 0 4000a138: 12 80 00 20 bne 4000a1b8 <_Thread_Tickle_timeslice+0xa4> 4000a13c: 01 00 00 00 nop /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 4000a140: c2 04 20 88 ld [ %l0 + 0x88 ], %g1 4000a144: 80 a0 60 01 cmp %g1, 1 4000a148: 0a 80 00 09 bcs 4000a16c <_Thread_Tickle_timeslice+0x58> 4000a14c: 80 a0 60 02 cmp %g1, 2 4000a150: 18 80 00 09 bgu 4000a174 <_Thread_Tickle_timeslice+0x60> 4000a154: 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 ) { 4000a158: c2 04 20 84 ld [ %l0 + 0x84 ], %g1 4000a15c: 82 00 7f ff add %g1, -1, %g1 4000a160: 80 a0 60 00 cmp %g1, 0 4000a164: 04 80 00 10 ble 4000a1a4 <_Thread_Tickle_timeslice+0x90> 4000a168: c2 24 20 84 st %g1, [ %l0 + 0x84 ] 4000a16c: 81 c7 e0 08 ret 4000a170: 81 e8 00 00 restore /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 4000a174: 12 80 00 11 bne 4000a1b8 <_Thread_Tickle_timeslice+0xa4> <== NOT EXECUTED 4000a178: 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 ) 4000a17c: c2 04 20 84 ld [ %l0 + 0x84 ], %g1 <== NOT EXECUTED 4000a180: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000a184: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000a188: 12 bf ff f9 bne 4000a16c <_Thread_Tickle_timeslice+0x58> <== NOT EXECUTED 4000a18c: c2 24 20 84 st %g1, [ %l0 + 0x84 ] <== NOT EXECUTED (*executing->budget_callout)( executing ); 4000a190: c2 04 20 8c ld [ %l0 + 0x8c ], %g1 <== NOT EXECUTED 4000a194: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a198: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 4000a19c: 81 c7 e0 08 ret <== NOT EXECUTED 4000a1a0: 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(); 4000a1a4: 40 00 0c c0 call 4000d4a4 <_Thread_Reset_timeslice> 4000a1a8: 01 00 00 00 nop executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 4000a1ac: 03 10 00 66 sethi %hi(0x40019800), %g1 4000a1b0: c4 00 62 68 ld [ %g1 + 0x268 ], %g2 ! 40019a68 <_Thread_Ticks_per_timeslice> 4000a1b4: c4 24 20 84 st %g2, [ %l0 + 0x84 ] 4000a1b8: 81 c7 e0 08 ret 4000a1bc: 81 e8 00 00 restore 4000a1c0 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 4000a1c0: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 4000a1c4: 03 10 00 66 sethi %hi(0x40019800), %g1 4000a1c8: e0 00 63 ec ld [ %g1 + 0x3ec ], %l0 ! 40019bec <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 4000a1cc: 7f ff df 03 call 40001dd8 4000a1d0: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 4000a1d4: b0 10 00 08 mov %o0, %i0 if ( !_Chain_Has_only_one_node( ready ) ) { 4000a1d8: c4 04 40 00 ld [ %l1 ], %g2 4000a1dc: c2 04 60 08 ld [ %l1 + 8 ], %g1 4000a1e0: 80 a0 80 01 cmp %g2, %g1 4000a1e4: 12 80 00 0b bne 4000a210 <_Thread_Yield_processor+0x50> 4000a1e8: 03 10 00 66 sethi %hi(0x40019800), %g1 if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 4000a1ec: c4 00 63 c4 ld [ %g1 + 0x3c4 ], %g2 ! 40019bc4 <_Thread_Heir> 4000a1f0: 80 a4 00 02 cmp %l0, %g2 4000a1f4: 02 80 00 05 be 4000a208 <_Thread_Yield_processor+0x48> 4000a1f8: 01 00 00 00 nop _Context_Switch_necessary = TRUE; 4000a1fc: 84 10 20 01 mov 1, %g2 ! 1 4000a200: 03 10 00 66 sethi %hi(0x40019800), %g1 4000a204: c4 20 63 fc st %g2, [ %g1 + 0x3fc ] ! 40019bfc <_Context_Switch_necessary> _ISR_Enable( level ); 4000a208: 7f ff de f8 call 40001de8 4000a20c: 81 e8 00 00 restore ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 4000a210: c6 04 00 00 ld [ %l0 ], %g3 previous = the_node->previous; 4000a214: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000a218: 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; 4000a21c: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000a220: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000a224: 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; 4000a228: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 4000a22c: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000a230: 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; 4000a234: 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 ); 4000a238: 7f ff de ec call 40001de8 4000a23c: 01 00 00 00 nop 4000a240: 7f ff de e6 call 40001dd8 4000a244: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 4000a248: 05 10 00 66 sethi %hi(0x40019800), %g2 4000a24c: c2 00 a3 c4 ld [ %g2 + 0x3c4 ], %g1 ! 40019bc4 <_Thread_Heir> 4000a250: 80 a4 00 01 cmp %l0, %g1 4000a254: 32 bf ff eb bne,a 4000a200 <_Thread_Yield_processor+0x40> 4000a258: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 4000a25c: c2 04 40 00 ld [ %l1 ], %g1 4000a260: 10 bf ff e7 b 4000a1fc <_Thread_Yield_processor+0x3c> 4000a264: c2 20 a3 c4 st %g1, [ %g2 + 0x3c4 ] 40009568 <_Thread_queue_Dequeue>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 40009568: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4000956c: 80 a0 60 00 cmp %g1, 0 40009570: 12 80 00 05 bne 40009584 <_Thread_queue_Dequeue+0x1c> 40009574: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); 40009578: 82 13 c0 00 mov %o7, %g1 4000957c: 40 00 0e c2 call 4000d084 <_Thread_queue_Dequeue_fifo> 40009580: 9e 10 40 00 mov %g1, %o7 Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 40009584: 02 80 00 04 be 40009594 <_Thread_queue_Dequeue+0x2c> 40009588: 01 00 00 00 nop the_thread = NULL; break; } return( the_thread ); } 4000958c: 81 c3 e0 08 retl <== NOT EXECUTED 40009590: 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 ); 40009594: 82 13 c0 00 mov %o7, %g1 40009598: 40 00 00 03 call 400095a4 <_Thread_queue_Dequeue_priority> 4000959c: 9e 10 40 00 mov %g1, %o7 400095a0: 01 00 00 00 nop 4000d084 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 4000d084: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 4000d088: 7f ff d3 54 call 40001dd8 4000d08c: a0 10 00 18 mov %i0, %l0 4000d090: 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)); 4000d094: f0 06 00 00 ld [ %i0 ], %i0 if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 4000d098: 82 04 20 04 add %l0, 4, %g1 4000d09c: 80 a6 00 01 cmp %i0, %g1 4000d0a0: 22 80 00 1d be,a 4000d114 <_Thread_queue_Dequeue_fifo+0x90> 4000d0a4: 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; 4000d0a8: c2 06 00 00 ld [ %i0 ], %g1 the_chain->first = new_first; 4000d0ac: 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 ) ) { 4000d0b0: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 new_first->previous = _Chain_Head(the_chain); 4000d0b4: e0 20 60 04 st %l0, [ %g1 + 4 ] 4000d0b8: 80 a0 a0 02 cmp %g2, 2 4000d0bc: 02 80 00 0a be 4000d0e4 <_Thread_queue_Dequeue_fifo+0x60> 4000d0c0: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 4000d0c4: 7f ff d3 49 call 40001de8 4000d0c8: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 4000d0cc: 90 10 00 18 mov %i0, %o0 4000d0d0: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000d0d4: 7f ff ef 6e call 40008e8c <_Thread_Clear_state> 4000d0d8: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 4000d0dc: 81 c7 e0 08 ret 4000d0e0: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 4000d0e4: 82 10 20 03 mov 3, %g1 4000d0e8: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000d0ec: 7f ff d3 3f call 40001de8 4000d0f0: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 4000d0f4: 7f ff f5 ac call 4000a7a4 <_Watchdog_Remove> 4000d0f8: 90 06 20 48 add %i0, 0x48, %o0 4000d0fc: 90 10 00 18 mov %i0, %o0 4000d100: 13 04 00 ff sethi %hi(0x1003fc00), %o1 4000d104: 7f ff ef 62 call 40008e8c <_Thread_Clear_state> 4000d108: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 4000d10c: 81 c7 e0 08 ret 4000d110: 81 e8 00 00 restore #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 4000d114: 80 a0 60 02 cmp %g1, 2 4000d118: 18 80 00 0c bgu 4000d148 <_Thread_queue_Dequeue_fifo+0xc4> 4000d11c: 80 a0 60 03 cmp %g1, 3 4000d120: 80 a0 60 01 cmp %g1, 1 4000d124: 0a 80 00 0b bcs 4000d150 <_Thread_queue_Dequeue_fifo+0xcc> 4000d128: 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; 4000d12c: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 4000d130: 7f ff d3 2e call 40001de8 <== NOT EXECUTED 4000d134: 01 00 00 00 nop <== NOT EXECUTED return _Thread_Executing; 4000d138: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 4000d13c: f0 00 63 ec ld [ %g1 + 0x3ec ], %i0 ! 40019bec <_Thread_Executing> <== NOT EXECUTED } return NULL; /* this is only to prevent warnings */ } 4000d140: 81 c7 e0 08 ret <== NOT EXECUTED 4000d144: 81 e8 00 00 restore <== NOT EXECUTED #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 4000d148: 12 bf ff e5 bne 4000d0dc <_Thread_queue_Dequeue_fifo+0x58> <== NOT EXECUTED 4000d14c: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 4000d150: b0 10 20 00 clr %i0 4000d154: 7f ff d3 25 call 40001de8 4000d158: 90 10 00 02 mov %g2, %o0 4000d15c: 81 c7 e0 08 ret 4000d160: 81 e8 00 00 restore 400095a4 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 400095a4: 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 ); 400095a8: 7f ff e2 0c call 40001dd8 400095ac: 01 00 00 00 nop 400095b0: 9a 10 00 08 mov %o0, %o5 400095b4: 86 10 20 00 clr %g3 400095b8: 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)); 400095bc: 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 ] ) ) { 400095c0: 85 28 e0 02 sll %g3, 2, %g2 400095c4: 83 28 e0 04 sll %g3, 4, %g1 400095c8: 82 20 40 02 sub %g1, %g2, %g1 400095cc: 82 06 00 01 add %i0, %g1, %g1 400095d0: 82 00 60 04 add %g1, 4, %g1 400095d4: 80 a2 00 01 cmp %o0, %g1 400095d8: 12 80 00 50 bne 40009718 <_Thread_queue_Dequeue_priority+0x174> 400095dc: 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++ ) { 400095e0: 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 ; 400095e4: 80 a0 e0 04 cmp %g3, 4 400095e8: 32 bf ff f6 bne,a 400095c0 <_Thread_queue_Dequeue_priority+0x1c> 400095ec: d0 01 00 18 ld [ %g4 + %i0 ], %o0 the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 400095f0: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 400095f4: 80 a0 60 02 cmp %g1, 2 400095f8: 08 80 00 23 bleu 40009684 <_Thread_queue_Dequeue_priority+0xe0> 400095fc: 80 a0 60 01 cmp %g1, 1 40009600: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 40009604: 02 80 00 29 be 400096a8 <_Thread_queue_Dequeue_priority+0x104> <== NOT EXECUTED 40009608: 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; 4000960c: 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 ) ) { 40009610: 82 06 20 3c add %i0, 0x3c, %g1 _ISR_Enable( level ); return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; 40009614: 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 ) ) { 40009618: 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; 4000961c: c4 06 00 00 ld [ %i0 ], %g2 previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 40009620: 02 80 00 27 be 400096bc <_Thread_queue_Dequeue_priority+0x118> 40009624: c2 06 20 04 ld [ %i0 + 4 ], %g1 last_node = the_thread->Wait.Block2n.last; 40009628: d8 06 20 40 ld [ %i0 + 0x40 ], %o4 new_second_node = new_first_node->next; 4000962c: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 40009630: 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; 40009634: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 40009638: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 4000963c: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 40009640: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 40009644: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 40009648: 80 a0 80 01 cmp %g2, %g1 4000964c: 12 80 00 2d bne 40009700 <_Thread_queue_Dequeue_priority+0x15c> 40009650: 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 ) ) { 40009654: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 40009658: 80 a0 60 02 cmp %g1, 2 4000965c: 02 80 00 1e be 400096d4 <_Thread_queue_Dequeue_priority+0x130> 40009660: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 40009664: 7f ff e1 e1 call 40001de8 40009668: 90 10 00 0d mov %o5, %o0 4000966c: 90 10 00 18 mov %i0, %o0 40009670: 13 04 00 ff sethi %hi(0x1003fc00), %o1 40009674: 7f ff fe 06 call 40008e8c <_Thread_Clear_state> 40009678: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 4000967c: 81 c7 e0 08 ret 40009680: 81 e8 00 00 restore the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 40009684: 0a 80 00 09 bcs 400096a8 <_Thread_queue_Dequeue_priority+0x104> 40009688: 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; 4000968c: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 40009690: 7f ff e1 d6 call 40001de8 <== NOT EXECUTED 40009694: 90 10 00 0d mov %o5, %o0 <== NOT EXECUTED return _Thread_Executing; 40009698: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 4000969c: f0 00 63 ec ld [ %g1 + 0x3ec ], %i0 ! 40019bec <_Thread_Executing> <== NOT EXECUTED 400096a0: 81 c7 e0 08 ret <== NOT EXECUTED 400096a4: 81 e8 00 00 restore <== NOT EXECUTED } switch ( the_thread_queue->sync_state ) { case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 400096a8: b0 10 20 00 clr %i0 400096ac: 7f ff e1 cf call 40001de8 400096b0: 90 10 00 0d mov %o5, %o0 400096b4: 81 c7 e0 08 ret 400096b8: 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; 400096bc: 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; 400096c0: c4 20 40 00 st %g2, [ %g1 ] next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 400096c4: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 400096c8: 80 a0 60 02 cmp %g1, 2 400096cc: 12 bf ff e6 bne 40009664 <_Thread_queue_Dequeue_priority+0xc0> 400096d0: 82 10 20 03 mov 3, %g1 RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 400096d4: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 400096d8: 7f ff e1 c4 call 40001de8 400096dc: 90 10 00 0d mov %o5, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 400096e0: 40 00 04 31 call 4000a7a4 <_Watchdog_Remove> 400096e4: 90 06 20 48 add %i0, 0x48, %o0 400096e8: 90 10 00 18 mov %i0, %o0 400096ec: 13 04 00 ff sethi %hi(0x1003fc00), %o1 400096f0: 7f ff fd e7 call 40008e8c <_Thread_Clear_state> 400096f4: 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 ); } 400096f8: 81 c7 e0 08 ret 400096fc: 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 = 40009700: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 40009704: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] new_first_thread->Wait.Block2n.last = last_node; 40009708: d8 20 e0 40 st %o4, [ %g3 + 0x40 ] last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 4000970c: 82 00 e0 3c add %g3, 0x3c, %g1 40009710: 10 bf ff d1 b 40009654 <_Thread_queue_Dequeue_priority+0xb0> 40009714: 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 *) 40009718: 10 bf ff bd b 4000960c <_Thread_queue_Dequeue_priority+0x68> 4000971c: b0 10 00 08 mov %o0, %i0 4000d164 <_Thread_queue_Enqueue_fifo>: void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000d164: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); 4000d168: 7f ff d3 1c call 40001dd8 4000d16c: 01 00 00 00 nop sync_state = the_thread_queue->sync_state; 4000d170: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 4000d174: 80 a0 a0 02 cmp %g2, 2 4000d178: 02 80 00 22 be 4000d200 <_Thread_queue_Enqueue_fifo+0x9c> 4000d17c: c0 26 20 30 clr [ %i0 + 0x30 ] 4000d180: 80 a0 a0 03 cmp %g2, 3 4000d184: 02 80 00 11 be 4000d1c8 <_Thread_queue_Enqueue_fifo+0x64> 4000d188: 80 a0 a0 01 cmp %g2, 1 4000d18c: 02 80 00 07 be 4000d1a8 <_Thread_queue_Enqueue_fifo+0x44> 4000d190: 82 06 20 04 add %i0, 4, %g1 4000d194: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000d198: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000d19c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000d1a0: 7f ff ef 3b call 40008e8c <_Thread_Clear_state> <== NOT EXECUTED 4000d1a4: 81 e8 00 00 restore <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 4000d1a8: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 4000d1ac: c4 06 20 08 ld [ %i0 + 8 ], %g2 the_chain->last = the_node; 4000d1b0: 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; 4000d1b4: f0 26 60 44 st %i0, [ %i1 + 0x44 ] old_last_node->next = the_node; the_node->previous = old_last_node; 4000d1b8: 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; 4000d1bc: f2 20 80 00 st %i1, [ %g2 ] _ISR_Enable( level ); 4000d1c0: 7f ff d3 0a call 40001de8 4000d1c4: 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 ) ) { 4000d1c8: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 4000d1cc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000d1d0: 12 80 00 16 bne 4000d228 <_Thread_queue_Enqueue_fifo+0xc4> <== NOT EXECUTED 4000d1d4: 01 00 00 00 nop <== NOT EXECUTED 4000d1d8: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 4000d1dc: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 4000d1e0: 7f ff d3 02 call 40001de8 <== NOT EXECUTED 4000d1e4: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 4000d1e8: 7f ff f5 6f call 4000a7a4 <_Watchdog_Remove> <== NOT EXECUTED 4000d1ec: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 4000d1f0: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000d1f4: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000d1f8: 7f ff ef 25 call 40008e8c <_Thread_Clear_state> <== NOT EXECUTED 4000d1fc: 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; 4000d200: c4 06 60 44 ld [ %i1 + 0x44 ], %g2 <== NOT EXECUTED the_thread->Wait.queue = NULL; 4000d204: 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; 4000d208: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED 4000d20c: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 4000d210: 7f ff d2 f6 call 40001de8 <== NOT EXECUTED 4000d214: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000d218: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000d21c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000d220: 7f ff ef 1b call 40008e8c <_Thread_Clear_state> <== NOT EXECUTED 4000d224: 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 ); 4000d228: 7f ff d2 f0 call 40001de8 <== NOT EXECUTED 4000d22c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 4000d230: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 4000d234: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 4000d238: 7f ff ef 15 call 40008e8c <_Thread_Clear_state> <== NOT EXECUTED 4000d23c: 81 e8 00 00 restore <== NOT EXECUTED 4000d240: 01 00 00 00 nop 400097a4 <_Thread_queue_Enqueue_priority>: void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 400097a4: 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; 400097a8: 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); 400097ac: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 400097b0: 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); 400097b4: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; 400097b8: c0 26 60 3c clr [ %i1 + 0x3c ] the_chain->last = _Chain_Head(the_chain); 400097bc: c4 26 60 40 st %g2, [ %i1 + 0x40 ] void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 400097c0: 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 ) ) 400097c4: 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); 400097c8: 83 34 a0 06 srl %l2, 6, %g1 400097cc: 12 80 00 40 bne 400098cc <_Thread_queue_Enqueue_priority+0x128> 400097d0: e8 06 20 38 ld [ %i0 + 0x38 ], %l4 400097d4: 85 28 60 04 sll %g1, 4, %g2 400097d8: 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; 400097dc: 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; 400097e0: 82 06 00 16 add %i0, %l6, %g1 400097e4: 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 ); 400097e8: 7f ff e1 7c call 40001dd8 400097ec: 01 00 00 00 nop 400097f0: b0 10 00 08 mov %o0, %i0 search_thread = (Thread_Control *) header->first; 400097f4: e0 05 40 16 ld [ %l5 + %l6 ], %l0 while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 400097f8: 80 a4 00 13 cmp %l0, %l3 400097fc: 02 80 00 24 be 4000988c <_Thread_queue_Enqueue_priority+0xe8> 40009800: a2 10 3f ff mov -1, %l1 search_priority = search_thread->current_priority; 40009804: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 40009808: 80 a4 80 11 cmp %l2, %l1 4000980c: 28 80 00 21 bleu,a 40009890 <_Thread_queue_Enqueue_priority+0xec> 40009810: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 40009814: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 40009818: 80 a4 c0 10 cmp %l3, %l0 4000981c: 32 80 00 19 bne,a 40009880 <_Thread_queue_Enqueue_priority+0xdc> 40009820: 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 ) 40009824: 10 80 00 1b b 40009890 <_Thread_queue_Enqueue_priority+0xec> 40009828: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 4000982c: 7f ff e1 6f call 40001de8 40009830: 90 10 00 18 mov %i0, %o0 40009834: 7f ff e1 69 call 40001dd8 40009838: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 4000983c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 40009840: 80 8d 00 01 btst %l4, %g1 40009844: 02 80 00 91 be 40009a88 <_Thread_queue_Enqueue_priority+0x2e4> 40009848: 01 00 00 00 nop _ISR_Enable( level ); goto restart_forward_search; } search_thread = 4000984c: 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 ) ) { 40009850: 80 a4 00 13 cmp %l0, %l3 40009854: 22 80 00 0f be,a 40009890 <_Thread_queue_Enqueue_priority+0xec> 40009858: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 search_priority = search_thread->current_priority; 4000985c: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 40009860: 80 a4 80 11 cmp %l2, %l1 40009864: 28 80 00 0b bleu,a 40009890 <_Thread_queue_Enqueue_priority+0xec> 40009868: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 4000986c: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 40009870: 80 a4 00 13 cmp %l0, %l3 40009874: 22 80 00 07 be,a 40009890 <_Thread_queue_Enqueue_priority+0xec> 40009878: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 4000987c: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 40009880: 80 a4 80 11 cmp %l2, %l1 40009884: 18 bf ff ea bgu 4000982c <_Thread_queue_Enqueue_priority+0x88> 40009888: 01 00 00 00 nop } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 4000988c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 40009890: 80 a0 60 01 cmp %g1, 1 40009894: 02 80 00 63 be 40009a20 <_Thread_queue_Enqueue_priority+0x27c> 40009898: 80 a4 80 11 cmp %l2, %l1 return; synchronize: sync_state = the_thread_queue->sync_state; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; 4000989c: c0 25 60 30 clr [ %l5 + 0x30 ] <== NOT EXECUTED switch ( sync_state ) { 400098a0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 400098a4: 02 80 00 54 be 400099f4 <_Thread_queue_Enqueue_priority+0x250> <== NOT EXECUTED 400098a8: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED 400098ac: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 400098b0: 22 80 00 43 be,a 400099bc <_Thread_queue_Enqueue_priority+0x218> <== NOT EXECUTED 400098b4: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 400098b8: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 400098bc: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 400098c0: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 400098c4: 7f ff fd 72 call 40008e8c <_Thread_Clear_state> <== NOT EXECUTED 400098c8: 81 e8 00 00 restore <== NOT EXECUTED 400098cc: 85 28 60 04 sll %g1, 4, %g2 400098d0: 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; 400098d4: 82 20 80 01 sub %g2, %g1, %g1 400098d8: a6 00 40 18 add %g1, %i0, %l3 return; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); 400098dc: 7f ff e1 3f call 40001dd8 400098e0: 01 00 00 00 nop 400098e4: b0 10 00 08 mov %o0, %i0 search_thread = (Thread_Control *) header->last; 400098e8: e0 04 e0 08 ld [ %l3 + 8 ], %l0 while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 400098ec: 80 a4 00 13 cmp %l0, %l3 400098f0: 02 80 00 24 be 40009980 <_Thread_queue_Enqueue_priority+0x1dc> 400098f4: a2 10 21 00 mov 0x100, %l1 search_priority = search_thread->current_priority; 400098f8: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority >= search_priority ) 400098fc: 80 a4 80 11 cmp %l2, %l1 40009900: 3a 80 00 21 bcc,a 40009984 <_Thread_queue_Enqueue_priority+0x1e0> 40009904: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 40009908: e0 04 20 04 ld [ %l0 + 4 ], %l0 if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 4000990c: 80 a4 c0 10 cmp %l3, %l0 40009910: 32 80 00 19 bne,a 40009974 <_Thread_queue_Enqueue_priority+0x1d0> 40009914: 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 ) 40009918: 10 80 00 1b b 40009984 <_Thread_queue_Enqueue_priority+0x1e0> 4000991c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 40009920: 7f ff e1 32 call 40001de8 40009924: 90 10 00 18 mov %i0, %o0 40009928: 7f ff e1 2c call 40001dd8 4000992c: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 40009930: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 40009934: 80 8d 00 01 btst %l4, %g1 40009938: 02 80 00 57 be 40009a94 <_Thread_queue_Enqueue_priority+0x2f0> 4000993c: 01 00 00 00 nop _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 40009940: 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 ) ) { 40009944: 80 a4 00 13 cmp %l0, %l3 40009948: 22 80 00 0f be,a 40009984 <_Thread_queue_Enqueue_priority+0x1e0> 4000994c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 search_priority = search_thread->current_priority; 40009950: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED if ( priority >= search_priority ) 40009954: 80 a4 80 11 cmp %l2, %l1 <== NOT EXECUTED 40009958: 3a 80 00 0b bcc,a 40009984 <_Thread_queue_Enqueue_priority+0x1e0> <== NOT EXECUTED 4000995c: 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; 40009960: e0 04 20 04 ld [ %l0 + 4 ], %l0 <== NOT EXECUTED if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 40009964: 80 a4 00 13 cmp %l0, %l3 <== NOT EXECUTED 40009968: 22 80 00 07 be,a 40009984 <_Thread_queue_Enqueue_priority+0x1e0> <== NOT EXECUTED 4000996c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 <== NOT EXECUTED break; search_priority = search_thread->current_priority; 40009970: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED if ( priority >= search_priority ) 40009974: 80 a4 80 11 cmp %l2, %l1 40009978: 0a bf ff ea bcs 40009920 <_Thread_queue_Enqueue_priority+0x17c> 4000997c: 01 00 00 00 nop } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 40009980: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 40009984: 80 a0 60 01 cmp %g1, 1 40009988: 12 bf ff c6 bne 400098a0 <_Thread_queue_Enqueue_priority+0xfc> 4000998c: c0 25 60 30 clr [ %l5 + 0x30 ] goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 40009990: 80 a4 80 11 cmp %l2, %l1 40009994: 22 80 00 35 be,a 40009a68 <_Thread_queue_Enqueue_priority+0x2c4> 40009998: 82 04 20 3c add %l0, 0x3c, %g1 goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 4000999c: c2 04 00 00 ld [ %l0 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 400099a0: 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; 400099a4: 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; 400099a8: 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; 400099ac: f2 24 00 00 st %i1, [ %l0 ] next_node->previous = the_node; 400099b0: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 400099b4: 7f ff e1 0d call 40001de8 400099b8: 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 ) ) { 400099bc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 400099c0: 12 80 00 22 bne 40009a48 <_Thread_queue_Enqueue_priority+0x2a4> <== NOT EXECUTED 400099c4: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 400099c8: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 400099cc: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 400099d0: 7f ff e1 06 call 40001de8 <== NOT EXECUTED 400099d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 400099d8: 40 00 03 73 call 4000a7a4 <_Watchdog_Remove> <== NOT EXECUTED 400099dc: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 400099e0: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 400099e4: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 400099e8: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 400099ec: 7f ff fd 28 call 40008e8c <_Thread_Clear_state> <== NOT EXECUTED 400099f0: 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; 400099f4: c4 06 60 44 ld [ %i1 + 0x44 ], %g2 <== NOT EXECUTED the_thread->Wait.queue = NULL; 400099f8: 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; 400099fc: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED 40009a00: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 40009a04: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009a08: 7f ff e0 f8 call 40001de8 <== NOT EXECUTED 40009a0c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 40009a10: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 40009a14: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 40009a18: 7f ff fd 1d call 40008e8c <_Thread_Clear_state> <== NOT EXECUTED 40009a1c: 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 ) 40009a20: 02 80 00 11 be 40009a64 <_Thread_queue_Enqueue_priority+0x2c0> 40009a24: c0 25 60 30 clr [ %l5 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 40009a28: c2 04 20 04 ld [ %l0 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 40009a2c: e0 26 40 00 st %l0, [ %i1 ] the_node->previous = previous_node; 40009a30: 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; 40009a34: 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; 40009a38: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 40009a3c: f2 24 20 04 st %i1, [ %l0 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 40009a40: 7f ff e0 ea call 40001de8 40009a44: 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 ); 40009a48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009a4c: 7f ff e0 e7 call 40001de8 <== NOT EXECUTED 40009a50: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 40009a54: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 40009a58: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 40009a5c: 7f ff fd 0c call 40008e8c <_Thread_Clear_state> <== NOT EXECUTED 40009a60: 81 e8 00 00 restore <== NOT EXECUTED 40009a64: 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; 40009a68: c4 00 60 04 ld [ %g1 + 4 ], %g2 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 40009a6c: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = previous_node; 40009a70: 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; 40009a74: 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; 40009a78: f2 20 80 00 st %i1, [ %g2 ] search_node->previous = the_node; 40009a7c: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 40009a80: 7f ff e0 da call 40001de8 40009a84: 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 ); 40009a88: 7f ff e0 d8 call 40001de8 <== NOT EXECUTED 40009a8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009a90: 30 bf ff 56 b,a 400097e8 <_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 ); 40009a94: 7f ff e0 d5 call 40001de8 <== NOT EXECUTED 40009a98: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40009a9c: 30 bf ff 90 b,a 400098dc <_Thread_queue_Enqueue_priority+0x138> <== NOT EXECUTED 40009720 <_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 ) { 40009720: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; the_thread = _Thread_Executing; 40009724: 03 10 00 66 sethi %hi(0x40019800), %g1 else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 40009728: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 Thread_queue_Timeout_callout handler ) { Thread_Control *the_thread; the_thread = _Thread_Executing; 4000972c: e0 00 63 ec ld [ %g1 + 0x3ec ], %l0 void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 40009730: 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 ); 40009734: 40 00 01 9b call 40009da0 <_Thread_Set_state> 40009738: 90 10 00 10 mov %l0, %o0 /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 4000973c: 80 a6 60 00 cmp %i1, 0 40009740: 32 80 00 0e bne,a 40009778 <_Thread_queue_Enqueue_with_handler+0x58> 40009744: c2 04 20 08 ld [ %l0 + 8 ], %g1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 40009748: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 4000974c: 80 a0 60 00 cmp %g1, 0 40009750: 12 80 00 04 bne 40009760 <_Thread_queue_Enqueue_with_handler+0x40> 40009754: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); 40009758: 40 00 0e 83 call 4000d164 <_Thread_queue_Enqueue_fifo> 4000975c: 93 e8 00 10 restore %g0, %l0, %o1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 40009760: 02 80 00 04 be 40009770 <_Thread_queue_Enqueue_with_handler+0x50> 40009764: 01 00 00 00 nop 40009768: 81 c7 e0 08 ret <== NOT EXECUTED 4000976c: 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 ); 40009770: 40 00 00 0d call 400097a4 <_Thread_queue_Enqueue_priority> 40009774: 93 e8 00 10 restore %g0, %l0, %o1 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40009778: f4 24 20 64 st %i2, [ %l0 + 0x64 ] the_watchdog->id = id; 4000977c: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40009780: f2 24 20 54 st %i1, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40009784: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 40009788: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4000978c: 11 10 00 67 sethi %hi(0x40019c00), %o0 40009790: 92 04 20 48 add %l0, 0x48, %o1 40009794: 40 00 03 9a call 4000a5fc <_Watchdog_Insert> 40009798: 90 12 20 0c or %o0, 0xc, %o0 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 4000979c: 10 bf ff ec b 4000974c <_Thread_queue_Enqueue_with_handler+0x2c> 400097a0: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 4000d244 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 4000d244: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4000d248: 80 a0 60 00 cmp %g1, 0 4000d24c: 12 80 00 05 bne 4000d260 <_Thread_queue_Extract+0x1c> 4000d250: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 4000d254: 82 13 c0 00 mov %o7, %g1 4000d258: 40 00 03 6a call 4000e000 <_Thread_queue_Extract_fifo> 4000d25c: 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 ) { 4000d260: 02 80 00 04 be 4000d270 <_Thread_queue_Extract+0x2c> 4000d264: 94 10 20 00 clr %o2 4000d268: 81 c3 e0 08 retl <== NOT EXECUTED 4000d26c: 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 ); 4000d270: 82 13 c0 00 mov %o7, %g1 4000d274: 40 00 00 03 call 4000d280 <_Thread_queue_Extract_priority_helper> 4000d278: 9e 10 40 00 mov %g1, %o7 4000d27c: 01 00 00 00 nop 4000e000 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 4000e000: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 4000e004: 7f ff cf 75 call 40001dd8 4000e008: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 4000e00c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 4000e010: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000e014: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000e018: 80 88 80 01 btst %g2, %g1 4000e01c: 02 80 00 19 be 4000e080 <_Thread_queue_Extract_fifo+0x80> 4000e020: 01 00 00 00 nop ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 4000e024: c2 06 40 00 ld [ %i1 ], %g1 previous = the_node->previous; 4000e028: 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 ) ) { 4000e02c: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 next->previous = previous; previous->next = next; 4000e030: c2 20 80 00 st %g1, [ %g2 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000e034: c4 20 60 04 st %g2, [ %g1 + 4 ] 4000e038: 80 a0 e0 02 cmp %g3, 2 4000e03c: 12 80 00 0c bne 4000e06c <_Thread_queue_Extract_fifo+0x6c> 4000e040: c0 26 60 44 clr [ %i1 + 0x44 ] 4000e044: 82 10 20 03 mov 3, %g1 4000e048: c2 26 60 50 st %g1, [ %i1 + 0x50 ] _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 4000e04c: 7f ff cf 67 call 40001de8 4000e050: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 4000e054: 7f ff f1 d4 call 4000a7a4 <_Watchdog_Remove> 4000e058: 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 ); 4000e05c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 4000e060: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000e064: 7f ff eb 8a call 40008e8c <_Thread_Clear_state> 4000e068: 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 ); 4000e06c: 7f ff cf 5f call 40001de8 4000e070: 33 04 00 ff sethi %hi(0x1003fc00), %i1 4000e074: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000e078: 7f ff eb 85 call 40008e8c <_Thread_Clear_state> 4000e07c: 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 ); 4000e080: 7f ff cf 5a call 40001de8 <== NOT EXECUTED 4000e084: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 4000e088: 01 00 00 00 nop 4000d280 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, boolean requeuing ) { 4000d280: 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 ); 4000d284: 7f ff d2 d5 call 40001dd8 4000d288: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 4000d28c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 4000d290: 03 00 00 ef sethi %hi(0x3bc00), %g1 4000d294: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 4000d298: 80 88 80 01 btst %g2, %g1 4000d29c: 02 80 00 29 be 4000d340 <_Thread_queue_Extract_priority_helper+0xc0> 4000d2a0: 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)); 4000d2a4: 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; 4000d2a8: c4 06 40 00 ld [ %i1 ], %g2 previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 4000d2ac: 80 a0 c0 01 cmp %g3, %g1 4000d2b0: 12 80 00 10 bne 4000d2f0 <_Thread_queue_Extract_priority_helper+0x70> 4000d2b4: 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; 4000d2b8: 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; 4000d2bc: c4 20 40 00 st %g2, [ %g1 ] /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 4000d2c0: 80 a6 a0 00 cmp %i2, 0 4000d2c4: 12 80 00 1d bne 4000d338 <_Thread_queue_Extract_priority_helper+0xb8> 4000d2c8: 01 00 00 00 nop _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 4000d2cc: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 4000d2d0: 80 a0 60 02 cmp %g1, 2 4000d2d4: 02 80 00 1d be 4000d348 <_Thread_queue_Extract_priority_helper+0xc8> 4000d2d8: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 4000d2dc: 7f ff d2 c3 call 40001de8 4000d2e0: 33 04 00 ff sethi %hi(0x1003fc00), %i1 4000d2e4: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 4000d2e8: 7f ff ee e9 call 40008e8c <_Thread_Clear_state> 4000d2ec: 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; 4000d2f0: da 06 60 40 ld [ %i1 + 0x40 ], %o5 new_second_node = new_first_node->next; 4000d2f4: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 4000d2f8: 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; 4000d2fc: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 4000d300: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 4000d304: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 4000d308: c4 06 60 38 ld [ %i1 + 0x38 ], %g2 4000d30c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 4000d310: 80 a0 80 01 cmp %g2, %g1 4000d314: 02 bf ff ec be 4000d2c4 <_Thread_queue_Extract_priority_helper+0x44> 4000d318: 80 a6 a0 00 cmp %i2, 0 /* > two threads on 2-n */ new_second_node->previous = 4000d31c: 82 00 e0 38 add %g3, 0x38, %g1 <== NOT EXECUTED 4000d320: 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; 4000d324: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 4000d328: da 20 e0 40 st %o5, [ %g3 + 0x40 ] <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 4000d32c: 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 ) { 4000d330: 02 bf ff e7 be 4000d2cc <_Thread_queue_Extract_priority_helper+0x4c> <== NOT EXECUTED 4000d334: c2 23 40 00 st %g1, [ %o5 ] <== NOT EXECUTED _ISR_Enable( level ); 4000d338: 7f ff d2 ac call 40001de8 4000d33c: 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 ); 4000d340: 7f ff d2 aa call 40001de8 <== NOT EXECUTED 4000d344: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 4000d348: 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 ); 4000d34c: 7f ff d2 a7 call 40001de8 <== NOT EXECUTED 4000d350: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 4000d354: 7f ff f5 14 call 4000a7a4 <_Watchdog_Remove> <== NOT EXECUTED 4000d358: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED 4000d35c: b2 16 63 f8 or %i1, 0x3f8, %i1 <== NOT EXECUTED 4000d360: 7f ff ee cb call 40008e8c <_Thread_Clear_state> <== NOT EXECUTED 4000d364: 81 e8 00 00 restore <== NOT EXECUTED 4000d368: 01 00 00 00 nop 40009aa0 <_Thread_queue_Extract_with_proxy>: */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 40009aa0: 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; 40009aa4: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 40009aa8: 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 ) ) { 40009aac: 03 00 00 ef sethi %hi(0x3bc00), %g1 40009ab0: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 40009ab4: 80 88 80 01 btst %g2, %g1 40009ab8: 02 80 00 1e be 40009b30 <_Thread_queue_Extract_with_proxy+0x90> 40009abc: b0 10 20 00 clr %i0 if ( _States_Is_waiting_for_rpc_reply( state ) && 40009ac0: 03 00 00 08 sethi %hi(0x2000), %g1 40009ac4: 80 88 80 01 btst %g2, %g1 40009ac8: 22 80 00 17 be,a 40009b24 <_Thread_queue_Extract_with_proxy+0x84> 40009acc: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 40009ad0: 03 00 00 e7 sethi %hi(0x39c00), %g1 <== NOT EXECUTED 40009ad4: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 39ee0 <== NOT EXECUTED 40009ad8: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 40009adc: 22 80 00 12 be,a 40009b24 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 40009ae0: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED _States_Is_locally_blocked( state ) ) { the_information = _Objects_Get_information( the_thread->Wait.id ); 40009ae4: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED proxy_extract_callout = 40009ae8: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 40009aec: 85 30 e0 16 srl %g3, 0x16, %g2 <== NOT EXECUTED 40009af0: 82 10 62 70 or %g1, 0x270, %g1 <== NOT EXECUTED 40009af4: 84 08 a0 1c and %g2, 0x1c, %g2 <== NOT EXECUTED 40009af8: c8 00 40 02 ld [ %g1 + %g2 ], %g4 <== NOT EXECUTED 40009afc: 87 30 e0 1b srl %g3, 0x1b, %g3 <== NOT EXECUTED 40009b00: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED 40009b04: c2 01 00 03 ld [ %g4 + %g3 ], %g1 <== NOT EXECUTED 40009b08: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 <== NOT EXECUTED (Objects_Thread_queue_Extract_callout) the_information->extract; if ( proxy_extract_callout ) 40009b0c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40009b10: 22 80 00 05 be,a 40009b24 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 40009b14: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED (*proxy_extract_callout)( the_thread ); 40009b18: 9f c0 40 00 call %g1 <== NOT EXECUTED 40009b1c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 40009b20: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED 40009b24: 92 10 00 10 mov %l0, %o1 40009b28: 40 00 0d c7 call 4000d244 <_Thread_queue_Extract> 40009b2c: b0 10 20 01 mov 1, %i0 return TRUE; } return FALSE; } 40009b30: 81 c7 e0 08 ret 40009b34: 81 e8 00 00 restore 4001b170 <_Thread_queue_First>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 4001b170: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 4001b174: 80 a0 60 00 cmp %g1, 0 4001b178: 12 80 00 05 bne 4001b18c <_Thread_queue_First+0x1c> 4001b17c: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); 4001b180: 82 13 c0 00 mov %o7, %g1 4001b184: 40 00 03 1b call 4001bdf0 <_Thread_queue_First_fifo> 4001b188: 9e 10 40 00 mov %g1, %o7 Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 4001b18c: 02 80 00 04 be 4001b19c <_Thread_queue_First+0x2c> 4001b190: 01 00 00 00 nop the_thread = NULL; break; } return the_thread; } 4001b194: 81 c3 e0 08 retl <== NOT EXECUTED 4001b198: 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 ); 4001b19c: 82 13 c0 00 mov %o7, %g1 4001b1a0: 40 00 00 03 call 4001b1ac <_Thread_queue_First_priority> 4001b1a4: 9e 10 40 00 mov %g1, %o7 4001b1a8: 01 00 00 00 nop 40009b58 <_Thread_queue_Initialize>: uint32_t timeout_status ) { uint32_t index; the_thread_queue->state = state; 40009b58: d4 22 20 38 st %o2, [ %o0 + 0x38 ] the_thread_queue->discipline = the_discipline; the_thread_queue->timeout_status = timeout_status; 40009b5c: d6 22 20 3c st %o3, [ %o0 + 0x3c ] the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; 40009b60: c0 22 20 30 clr [ %o0 + 0x30 ] switch ( the_discipline ) { 40009b64: 80 a2 60 00 cmp %o1, 0 40009b68: 12 80 00 07 bne 40009b84 <_Thread_queue_Initialize+0x2c> 40009b6c: 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); 40009b70: 82 02 20 04 add %o0, 4, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009b74: 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; 40009b78: 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); 40009b7c: 81 c3 e0 08 retl 40009b80: c2 22 00 00 st %g1, [ %o0 ] 40009b84: 80 a2 60 01 cmp %o1, 1 40009b88: 02 80 00 04 be 40009b98 <_Thread_queue_Initialize+0x40> 40009b8c: 82 02 20 04 add %o0, 4, %g1 40009b90: 81 c3 e0 08 retl <== NOT EXECUTED 40009b94: 01 00 00 00 nop <== NOT EXECUTED 40009b98: 84 02 20 10 add %o0, 0x10, %g2 40009b9c: c2 22 00 00 st %g1, [ %o0 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009ba0: 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); 40009ba4: c4 22 20 0c st %g2, [ %o0 + 0xc ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009ba8: 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); 40009bac: 84 02 20 1c add %o0, 0x1c, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009bb0: 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); 40009bb4: c4 22 20 18 st %g2, [ %o0 + 0x18 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009bb8: 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); 40009bbc: 84 02 20 28 add %o0, 0x28, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009bc0: 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; 40009bc4: c0 22 20 04 clr [ %o0 + 4 ] the_chain->last = _Chain_Head(the_chain); 40009bc8: 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; 40009bcc: c0 22 20 10 clr [ %o0 + 0x10 ] 40009bd0: c0 22 20 1c clr [ %o0 + 0x1c ] 40009bd4: 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); 40009bd8: c4 22 20 24 st %g2, [ %o0 + 0x24 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40009bdc: 81 c3 e0 08 retl 40009be0: c2 22 20 2c st %g1, [ %o0 + 0x2c ] 40009be4 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 40009be4: 9d e3 bf 98 save %sp, -104, %sp /* just in case the thread really wasn't blocked here */ if ( !the_thread_queue ) { 40009be8: 80 a6 20 00 cmp %i0, 0 40009bec: 02 80 00 06 be 40009c04 <_Thread_queue_Requeue+0x20> 40009bf0: 01 00 00 00 nop return; } switch ( the_thread_queue->discipline ) { 40009bf4: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 40009bf8: 80 a4 20 01 cmp %l0, 1 40009bfc: 02 80 00 04 be 40009c0c <_Thread_queue_Requeue+0x28> 40009c00: 01 00 00 00 nop 40009c04: 81 c7 e0 08 ret <== NOT EXECUTED 40009c08: 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 ); 40009c0c: 7f ff e0 73 call 40001dd8 40009c10: 01 00 00 00 nop 40009c14: a2 10 00 08 mov %o0, %l1 if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 40009c18: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 40009c1c: 03 00 00 ef sethi %hi(0x3bc00), %g1 40009c20: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 40009c24: 80 88 80 01 btst %g2, %g1 40009c28: 12 80 00 04 bne 40009c38 <_Thread_queue_Requeue+0x54> 40009c2c: 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 ); 40009c30: 7f ff e0 6e call 40001de8 <== NOT EXECUTED 40009c34: 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 ); 40009c38: 90 10 00 18 mov %i0, %o0 40009c3c: 92 10 00 19 mov %i1, %o1 40009c40: 40 00 0d 90 call 4000d280 <_Thread_queue_Extract_priority_helper> 40009c44: e0 26 20 30 st %l0, [ %i0 + 0x30 ] _Thread_queue_Enqueue_priority( tq, the_thread ); 40009c48: 90 10 00 18 mov %i0, %o0 40009c4c: 7f ff fe d6 call 400097a4 <_Thread_queue_Enqueue_priority> 40009c50: 92 10 00 19 mov %i1, %o1 } _ISR_Enable( level ); 40009c54: 7f ff e0 65 call 40001de8 40009c58: 91 e8 00 11 restore %g0, %l1, %o0 40009c5c: 01 00 00 00 nop 40009c60 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 40009c60: 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 ) ) { 40009c64: 92 96 20 00 orcc %i0, 0, %o1 40009c68: 12 80 00 1a bne 40009cd0 <_Thread_queue_Timeout+0x70> 40009c6c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40009c70: 31 10 00 66 sethi %hi(0x40019800), %i0 <== NOT EXECUTED 40009c74: c2 06 23 10 ld [ %i0 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40009c78: 82 00 60 01 inc %g1 <== NOT EXECUTED 40009c7c: c2 26 23 10 st %g1, [ %i0 + 0x310 ] <== NOT EXECUTED Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 40009c80: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 40009c84: d2 00 63 ec ld [ %g1 + 0x3ec ], %o1 ! 40019bec <_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; 40009c88: 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; 40009c8c: 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 && 40009c90: c6 02 20 30 ld [ %o0 + 0x30 ], %g3 40009c94: 80 a0 e0 00 cmp %g3, 0 40009c98: 02 80 00 06 be 40009cb0 <_Thread_queue_Timeout+0x50> 40009c9c: 03 10 00 66 sethi %hi(0x40019800), %g1 40009ca0: c4 00 63 ec ld [ %g1 + 0x3ec ], %g2 ! 40019bec <_Thread_Executing> <== NOT EXECUTED 40009ca4: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED 40009ca8: 02 80 00 20 be 40009d28 <_Thread_queue_Timeout+0xc8> <== NOT EXECUTED 40009cac: 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; 40009cb0: c2 02 20 3c ld [ %o0 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 40009cb4: 40 00 0d 64 call 4000d244 <_Thread_queue_Extract> 40009cb8: 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; 40009cbc: c2 06 23 10 ld [ %i0 + 0x310 ], %g1 40009cc0: 82 00 7f ff add %g1, -1, %g1 40009cc4: c2 26 23 10 st %g1, [ %i0 + 0x310 ] 40009cc8: 81 c7 e0 08 ret 40009ccc: 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); 40009cd0: 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 ) { 40009cd4: 80 a0 a0 04 cmp %g2, 4 40009cd8: 18 bf ff fc bgu 40009cc8 <_Thread_queue_Timeout+0x68> 40009cdc: 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 :) */ 40009ce0: 80 a0 60 01 cmp %g1, 1 40009ce4: 12 bf ff f9 bne 40009cc8 <_Thread_queue_Timeout+0x68> 40009ce8: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40009cec: 05 10 00 66 sethi %hi(0x40019800), %g2 40009cf0: 84 10 a2 70 or %g2, 0x270, %g2 ! 40019a70 <_Objects_Information_table> 40009cf4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40009cf8: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40009cfc: 80 a2 20 00 cmp %o0, 0 40009d00: 02 bf ff f2 be 40009cc8 <_Thread_queue_Timeout+0x68> 40009d04: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40009d08: 7f ff f7 ee call 40007cc0 <_Objects_Get> 40009d0c: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40009d10: c2 07 bf f4 ld [ %fp + -12 ], %g1 40009d14: 80 a0 60 00 cmp %g1, 0 40009d18: 12 bf ff ec bne 40009cc8 <_Thread_queue_Timeout+0x68> 40009d1c: 92 10 00 08 mov %o0, %o1 40009d20: 10 bf ff db b 40009c8c <_Thread_queue_Timeout+0x2c> 40009d24: 31 10 00 66 sethi %hi(0x40019800), %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 ) 40009d28: 02 bf ff e5 be 40009cbc <_Thread_queue_Timeout+0x5c> <== NOT EXECUTED 40009d2c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 40009d30: 10 bf ff e3 b 40009cbc <_Thread_queue_Timeout+0x5c> <== NOT EXECUTED 40009d34: c2 22 20 30 st %g1, [ %o0 + 0x30 ] <== NOT EXECUTED 400133c0 <_Timer_Server_body>: */ Thread _Timer_Server_body( uint32_t ignored ) { 400133c0: 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; 400133c4: 03 10 00 cd sethi %hi(0x40033400), %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400133c8: 21 10 00 cd sethi %hi(0x40033400), %l0 400133cc: c6 00 62 64 ld [ %g1 + 0x264 ], %g3 _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 400133d0: 05 10 00 cd sethi %hi(0x40033400), %g2 400133d4: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 400133d8: c8 00 a1 98 ld [ %g2 + 0x198 ], %g4 /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 400133dc: 05 10 00 cc sethi %hi(0x40033000), %g2 400133e0: 82 00 60 01 inc %g1 400133e4: c6 20 a3 ec st %g3, [ %g2 + 0x3ec ] 400133e8: c2 24 20 e0 st %g1, [ %l0 + 0xe0 ] _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 400133ec: 05 10 00 cc sethi %hi(0x40033000), %g2 400133f0: c8 20 a3 e8 st %g4, [ %g2 + 0x3e8 ] ! 400333e8 <_Timer_Server_seconds_last_time> RTEMS_COMPILER_MEMORY_BARRIER(); 400133f4: 03 10 00 cc sethi %hi(0x40033000), %g1 400133f8: 05 10 00 cd sethi %hi(0x40033400), %g2 400133fc: ba 10 63 e0 or %g1, 0x3e0, %i5 40013400: 03 10 00 cc sethi %hi(0x40033000), %g1 40013404: 39 10 00 ce sethi %hi(0x40033800), %i4 /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 40013408: b4 10 a1 dc or %g2, 0x1dc, %i2 4001340c: ae 10 63 f4 or %g1, 0x3f4, %l7 40013410: 05 10 00 cc sethi %hi(0x40033000), %g2 40013414: 03 10 00 cd sethi %hi(0x40033400), %g1 40013418: a6 10 a3 fc or %g2, 0x3fc, %l3 4001341c: b6 10 61 d0 or %g1, 0x1d0, %i3 40013420: 2d 10 00 cc sethi %hi(0x40033000), %l6 40013424: 2b 10 00 cc sethi %hi(0x40033000), %l5 40013428: 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 ) 4001342c: a2 10 00 10 mov %l0, %l1 40013430: 10 80 00 18 b 40013490 <_Timer_Server_body+0xd0> 40013434: a8 10 00 13 mov %l3, %l4 _Timer_Server_reset_ticks_timer(); _Timer_Server_reset_seconds_timer(); 40013438: 80 a0 40 17 cmp %g1, %l7 4001343c: 32 80 00 27 bne,a 400134d8 <_Timer_Server_body+0x118> 40013440: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED 40013444: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 40013448: 82 00 7f ff add %g1, -1, %g1 4001344c: c2 24 20 e0 st %g1, [ %l0 + 0xe0 ] 40013450: c4 04 20 e0 ld [ %l0 + 0xe0 ], %g2 40013454: 80 a0 a0 00 cmp %g2, 0 40013458: 02 80 00 2b be 40013504 <_Timer_Server_body+0x144> 4001345c: 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(); 40013460: d0 04 a0 98 ld [ %l2 + 0x98 ], %o0 <== NOT EXECUTED 40013464: 40 00 14 19 call 400184c8 <_Watchdog_Remove> 40013468: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_stop_seconds_timer(); 4001346c: 40 00 14 17 call 400184c8 <_Watchdog_Remove> 40013470: 90 10 00 14 mov %l4, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40013474: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40013478: 82 00 60 01 inc %g1 4001347c: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] * 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(); 40013480: 7f ff ff bf call 4001337c <_Timer_Server_process_ticks_chain> 40013484: 01 00 00 00 nop _Timer_Server_process_seconds_chain(); 40013488: 7f ff ff a2 call 40013310 <_Timer_Server_process_seconds_chain> 4001348c: 01 00 00 00 nop /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 40013490: d0 07 20 98 ld [ %i4 + 0x98 ], %o0 40013494: 40 00 10 b8 call 40017774 <_Thread_Set_state> 40013498: 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)); 4001349c: c2 05 a3 dc ld [ %l6 + 0x3dc ], %g1 _Timer_Server_reset_ticks_timer(); 400134a0: 80 a0 40 1d cmp %g1, %i5 400134a4: 22 bf ff e5 be,a 40013438 <_Timer_Server_body+0x78> 400134a8: c2 05 63 f0 ld [ %l5 + 0x3f0 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400134ac: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 400134b0: d2 04 a0 98 ld [ %l2 + 0x98 ], %o1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400134b4: 90 10 00 1a mov %i2, %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400134b8: c2 22 60 54 st %g1, [ %o1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 400134bc: 40 00 13 99 call 40018320 <_Watchdog_Insert> 400134c0: 92 02 60 48 add %o1, 0x48, %o1 400134c4: c2 05 63 f0 ld [ %l5 + 0x3f0 ], %g1 _Timer_Server_reset_seconds_timer(); 400134c8: 80 a0 40 17 cmp %g1, %l7 400134cc: 02 bf ff de be 40013444 <_Timer_Server_body+0x84> 400134d0: 01 00 00 00 nop Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400134d4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 400134d8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 400134dc: c2 24 e0 0c st %g1, [ %l3 + 0xc ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 400134e0: 40 00 13 90 call 40018320 <_Watchdog_Insert> <== NOT EXECUTED 400134e4: 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 ) 400134e8: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 <== NOT EXECUTED 400134ec: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400134f0: c2 24 20 e0 st %g1, [ %l0 + 0xe0 ] <== NOT EXECUTED 400134f4: c4 04 20 e0 ld [ %l0 + 0xe0 ], %g2 <== NOT EXECUTED 400134f8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400134fc: 32 bf ff da bne,a 40013464 <_Timer_Server_body+0xa4> <== NOT EXECUTED 40013500: d0 04 a0 98 ld [ %l2 + 0x98 ], %o0 <== NOT EXECUTED _Thread_Dispatch(); 40013504: 40 00 0d 29 call 400169a8 <_Thread_Dispatch> 40013508: 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(); 4001350c: 10 bf ff d6 b 40013464 <_Timer_Server_body+0xa4> 40013510: d0 04 a0 98 ld [ %l2 + 0x98 ], %o0 4001337c <_Timer_Server_process_ticks_chain>: void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 4001337c: 03 10 00 cd sethi %hi(0x40033400), %g1 if ( snapshot >= _Timer_Server_ticks_last_time ) 40013380: 07 10 00 cc sethi %hi(0x40033000), %g3 void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 40013384: c4 00 62 64 ld [ %g1 + 0x264 ], %g2 if ( snapshot >= _Timer_Server_ticks_last_time ) 40013388: c2 00 e3 ec ld [ %g3 + 0x3ec ], %g1 4001338c: 80 a0 80 01 cmp %g2, %g1 40013390: 1a 80 00 04 bcc 400133a0 <_Timer_Server_process_ticks_chain+0x24> 40013394: 94 20 80 01 sub %g2, %g1, %o2 ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 40013398: 82 38 00 01 xnor %g0, %g1, %g1 <== NOT EXECUTED 4001339c: 94 00 40 02 add %g1, %g2, %o2 <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 400133a0: 11 10 00 cc sethi %hi(0x40033000), %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; 400133a4: c4 20 e3 ec st %g2, [ %g3 + 0x3ec ] _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 400133a8: 90 12 23 dc or %o0, 0x3dc, %o0 400133ac: 92 10 20 00 clr %o1 400133b0: 82 13 c0 00 mov %o7, %g1 400133b4: 40 00 13 aa call 4001825c <_Watchdog_Adjust> 400133b8: 9e 10 40 00 mov %g1, %o7 400133bc: 01 00 00 00 nop 4000c0f8 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 4000c0f8: 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; 4000c0fc: 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; 4000c100: de 06 20 04 ld [ %i0 + 4 ], %o7 right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 4000c104: 96 10 00 01 mov %g1, %o3 4000c108: 95 38 60 1f sra %g1, 0x1f, %o2 4000c10c: 83 30 60 1d srl %g1, 0x1d, %g1 4000c110: 9b 2a e0 03 sll %o3, 3, %o5 4000c114: 99 2a a0 03 sll %o2, 3, %o4 4000c118: 98 10 40 0c or %g1, %o4, %o4 4000c11c: 83 33 60 1b srl %o5, 0x1b, %g1 4000c120: 85 2b 20 05 sll %o4, 5, %g2 4000c124: 87 2b 60 05 sll %o5, 5, %g3 4000c128: 84 10 40 02 or %g1, %g2, %g2 4000c12c: 86 a0 c0 0d subcc %g3, %o5, %g3 4000c130: 83 30 e0 1a srl %g3, 0x1a, %g1 4000c134: 84 60 80 0c subx %g2, %o4, %g2 4000c138: 9b 28 e0 06 sll %g3, 6, %o5 4000c13c: 99 28 a0 06 sll %g2, 6, %o4 4000c140: 9a a3 40 03 subcc %o5, %g3, %o5 4000c144: 98 10 40 0c or %g1, %o4, %o4 4000c148: 98 63 00 02 subx %o4, %g2, %o4 4000c14c: 9a 83 40 0b addcc %o5, %o3, %o5 4000c150: 83 33 60 1e srl %o5, 0x1e, %g1 4000c154: 98 43 00 0a addx %o4, %o2, %o4 4000c158: 87 2b 60 02 sll %o5, 2, %g3 4000c15c: 85 2b 20 02 sll %o4, 2, %g2 4000c160: 9a 83 40 03 addcc %o5, %g3, %o5 4000c164: 84 10 40 02 or %g1, %g2, %g2 4000c168: 83 33 60 1e srl %o5, 0x1e, %g1 4000c16c: 98 43 00 02 addx %o4, %g2, %o4 4000c170: 87 2b 60 02 sll %o5, 2, %g3 4000c174: 85 2b 20 02 sll %o4, 2, %g2 4000c178: 9a 83 40 03 addcc %o5, %g3, %o5 4000c17c: 84 10 40 02 or %g1, %g2, %g2 4000c180: 83 33 60 1e srl %o5, 0x1e, %g1 4000c184: 98 43 00 02 addx %o4, %g2, %o4 4000c188: 85 2b 20 02 sll %o4, 2, %g2 4000c18c: 84 10 40 02 or %g1, %g2, %g2 right += rhs->tv_nsec; 4000c190: 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; 4000c194: 87 2b 60 02 sll %o5, 2, %g3 4000c198: 9a 83 40 03 addcc %o5, %g3, %o5 right += rhs->tv_nsec; 4000c19c: 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; 4000c1a0: 98 43 00 02 addx %o4, %g2, %o4 4000c1a4: 89 33 60 17 srl %o5, 0x17, %g4 4000c1a8: 85 2b 20 09 sll %o4, 9, %g2 4000c1ac: 87 2b 60 09 sll %o5, 9, %g3 4000c1b0: 84 11 00 02 or %g4, %g2, %g2 right += rhs->tv_nsec; 4000c1b4: 96 80 c0 01 addcc %g3, %g1, %o3 4000c1b8: 94 40 80 0a addx %g2, %o2, %o2 if ( right == 0 ) { 4000c1bc: 80 92 80 0b orcc %o2, %o3, %g0 4000c1c0: 12 80 00 06 bne 4000c1d8 <_Timespec_Divide+0xe0> 4000c1c4: f0 06 00 00 ld [ %i0 ], %i0 *ival_percentage = 0; 4000c1c8: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED *fval_percentage = 0; 4000c1cc: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 4000c1d0: 81 c7 e0 08 ret <== NOT EXECUTED 4000c1d4: 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; 4000c1d8: 83 36 20 1d srl %i0, 0x1d, %g1 4000c1dc: 9b 2e 20 03 sll %i0, 3, %o5 4000c1e0: 91 3e 20 1f sra %i0, 0x1f, %o0 4000c1e4: 99 2a 20 03 sll %o0, 3, %o4 4000c1e8: 98 10 40 0c or %g1, %o4, %o4 4000c1ec: 83 33 60 1b srl %o5, 0x1b, %g1 4000c1f0: 85 2b 20 05 sll %o4, 5, %g2 4000c1f4: 87 2b 60 05 sll %o5, 5, %g3 4000c1f8: 84 10 40 02 or %g1, %g2, %g2 4000c1fc: 86 a0 c0 0d subcc %g3, %o5, %g3 4000c200: 83 30 e0 1a srl %g3, 0x1a, %g1 4000c204: 84 60 80 0c subx %g2, %o4, %g2 4000c208: 9b 28 e0 06 sll %g3, 6, %o5 4000c20c: 99 28 a0 06 sll %g2, 6, %o4 4000c210: 9a a3 40 03 subcc %o5, %g3, %o5 4000c214: 98 10 40 0c or %g1, %o4, %o4 4000c218: 98 63 00 02 subx %o4, %g2, %o4 4000c21c: 9a 83 40 18 addcc %o5, %i0, %o5 4000c220: 83 33 60 1e srl %o5, 0x1e, %g1 4000c224: 98 43 00 08 addx %o4, %o0, %o4 4000c228: 87 2b 60 02 sll %o5, 2, %g3 4000c22c: 85 2b 20 02 sll %o4, 2, %g2 4000c230: 9a 83 40 03 addcc %o5, %g3, %o5 4000c234: 84 10 40 02 or %g1, %g2, %g2 4000c238: 83 33 60 1e srl %o5, 0x1e, %g1 4000c23c: 98 43 00 02 addx %o4, %g2, %o4 4000c240: 87 2b 60 02 sll %o5, 2, %g3 4000c244: 85 2b 20 02 sll %o4, 2, %g2 4000c248: 9a 83 40 03 addcc %o5, %g3, %o5 4000c24c: 84 10 40 02 or %g1, %g2, %g2 4000c250: 83 33 60 1e srl %o5, 0x1e, %g1 4000c254: 98 43 00 02 addx %o4, %g2, %o4 4000c258: 87 2b 60 02 sll %o5, 2, %g3 4000c25c: 85 2b 20 02 sll %o4, 2, %g2 4000c260: 9a 83 40 03 addcc %o5, %g3, %o5 4000c264: 84 10 40 02 or %g1, %g2, %g2 4000c268: 83 33 60 17 srl %o5, 0x17, %g1 4000c26c: 98 43 00 02 addx %o4, %g2, %o4 4000c270: 93 2b 60 09 sll %o5, 9, %o1 4000c274: 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; 4000c278: 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; 4000c27c: 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; 4000c280: 83 32 60 1e srl %o1, 0x1e, %g1 4000c284: a1 3b e0 1f sra %o7, 0x1f, %l0 4000c288: 87 2a 60 02 sll %o1, 2, %g3 4000c28c: 90 42 00 10 addx %o0, %l0, %o0 4000c290: 85 2a 20 02 sll %o0, 2, %g2 4000c294: 84 10 40 02 or %g1, %g2, %g2 4000c298: 83 30 e0 1b srl %g3, 0x1b, %g1 4000c29c: 99 28 a0 05 sll %g2, 5, %o4 4000c2a0: 9b 28 e0 05 sll %g3, 5, %o5 4000c2a4: 98 10 40 0c or %g1, %o4, %o4 4000c2a8: 9a a3 40 03 subcc %o5, %g3, %o5 4000c2ac: 98 63 00 02 subx %o4, %g2, %o4 4000c2b0: 9a 83 40 09 addcc %o5, %o1, %o5 4000c2b4: 83 33 60 1e srl %o5, 0x1e, %g1 4000c2b8: 98 43 00 08 addx %o4, %o0, %o4 4000c2bc: 87 2b 60 02 sll %o5, 2, %g3 4000c2c0: 85 2b 20 02 sll %o4, 2, %g2 4000c2c4: 9a 83 40 03 addcc %o5, %g3, %o5 4000c2c8: 84 10 40 02 or %g1, %g2, %g2 4000c2cc: 83 33 60 1e srl %o5, 0x1e, %g1 4000c2d0: 87 2b 60 02 sll %o5, 2, %g3 4000c2d4: 98 43 00 02 addx %o4, %g2, %o4 4000c2d8: 9a 83 40 03 addcc %o5, %g3, %o5 4000c2dc: 85 2b 20 02 sll %o4, 2, %g2 4000c2e0: 84 10 40 02 or %g1, %g2, %g2 4000c2e4: 83 33 60 1b srl %o5, 0x1b, %g1 4000c2e8: 98 43 00 02 addx %o4, %g2, %o4 4000c2ec: 93 2b 60 05 sll %o5, 5, %o1 4000c2f0: 91 2b 20 05 sll %o4, 5, %o0 4000c2f4: 40 00 33 56 call 4001904c <__udivdi3> 4000c2f8: 90 10 40 08 or %g1, %o0, %o0 *ival_percentage = answer / 1000; 4000c2fc: 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; 4000c300: a0 10 00 08 mov %o0, %l0 4000c304: a2 10 00 09 mov %o1, %l1 *ival_percentage = answer / 1000; 4000c308: 96 10 23 e8 mov 0x3e8, %o3 4000c30c: 40 00 33 50 call 4001904c <__udivdi3> 4000c310: 90 10 00 10 mov %l0, %o0 *fval_percentage = answer % 1000; 4000c314: 90 10 00 10 mov %l0, %o0 * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 4000c318: d2 26 80 00 st %o1, [ %i2 ] *fval_percentage = answer % 1000; 4000c31c: 94 10 20 00 clr %o2 4000c320: 92 10 00 11 mov %l1, %o1 4000c324: 40 00 34 29 call 400193c8 <__umoddi3> 4000c328: 96 10 23 e8 mov 0x3e8, %o3 4000c32c: d2 26 c0 00 st %o1, [ %i3 ] 4000c330: 81 c7 e0 08 ret 4000c334: 81 e8 00 00 restore 40016e18 <_Timespec_From_ticks>: void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 40016e18: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 40016e1c: 03 10 00 ac sethi %hi(0x4002b000), %g1 <== NOT EXECUTED 40016e20: d2 00 63 6c ld [ %g1 + 0x36c ], %o1 ! 4002b36c <_TOD_Microseconds_per_tick> <== NOT EXECUTED 40016e24: 40 00 2f c0 call 40022d24 <.umul> <== NOT EXECUTED 40016e28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 40016e2c: 21 00 03 d0 sethi %hi(0xf4000), %l0 <== NOT EXECUTED struct timespec *time ) { uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 40016e30: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 40016e34: 7f ff aa 70 call 400017f4 <.udiv> <== NOT EXECUTED 40016e38: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 40016e3c: 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; 40016e40: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 40016e44: 40 00 2f f2 call 40022e0c <.urem> <== NOT EXECUTED 40016e48: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40016e4c: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED 40016e50: 83 2a 20 07 sll %o0, 7, %g1 <== NOT EXECUTED 40016e54: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 40016e58: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 40016e5c: 83 28 60 03 sll %g1, 3, %g1 <== NOT EXECUTED 40016e60: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 40016e64: 81 c7 e0 08 ret <== NOT EXECUTED 40016e68: 81 e8 00 00 restore <== NOT EXECUTED 40016e6c <_Timespec_Is_valid>: boolean _Timespec_Is_valid( const struct timespec *time ) { if ( !time ) 40016e6c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40016e70: 02 80 00 0e be 40016ea8 <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 40016e74: 01 00 00 00 nop <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) 40016e78: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 40016e7c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40016e80: 06 80 00 0a bl 40016ea8 <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 40016e84: 01 00 00 00 nop <== NOT EXECUTED return FALSE; if ( time->tv_nsec < 0 ) 40016e88: d0 02 20 04 ld [ %o0 + 4 ], %o0 <== NOT EXECUTED 40016e8c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40016e90: 06 80 00 06 bl 40016ea8 <_Timespec_Is_valid+0x3c> <== NOT EXECUTED 40016e94: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 <== NOT EXECUTED 40016e98: 82 10 61 ff or %g1, 0x1ff, %g1 ! 3b9ac9ff <== NOT EXECUTED 40016e9c: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED 40016ea0: 81 c3 e0 08 retl <== NOT EXECUTED 40016ea4: 90 60 3f ff subx %g0, -1, %o0 <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 40016ea8: 81 c3 e0 08 retl <== NOT EXECUTED 40016eac: 90 10 20 00 clr %o0 <== NOT EXECUTED 40016eb0 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 40016eb0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 40016eb4: e0 06 00 00 ld [ %i0 ], %l0 <== NOT EXECUTED 40016eb8: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 40016ebc: 02 80 00 15 be 40016f10 <_Timespec_To_ticks+0x60> <== NOT EXECUTED 40016ec0: e4 06 20 04 ld [ %i0 + 4 ], %l2 <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 40016ec4: 03 10 00 ac sethi %hi(0x4002b000), %g1 <== NOT EXECUTED 40016ec8: e2 00 63 6c ld [ %g1 + 0x36c ], %l1 ! 4002b36c <_TOD_Microseconds_per_tick> <== NOT EXECUTED 40016ecc: 11 00 03 d0 sethi %hi(0xf4000), %o0 <== NOT EXECUTED 40016ed0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 40016ed4: 7f ff aa 48 call 400017f4 <.udiv> <== NOT EXECUTED 40016ed8: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED 40016edc: 40 00 2f 92 call 40022d24 <.umul> <== NOT EXECUTED 40016ee0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 40016ee4: 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; 40016ee8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 40016eec: 7f ff aa 42 call 400017f4 <.udiv> <== NOT EXECUTED 40016ef0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40016ef4: 7f ff aa 40 call 400017f4 <.udiv> <== NOT EXECUTED 40016ef8: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED _TOD_Microseconds_per_tick; if (ticks) 40016efc: b0 82 00 10 addcc %o0, %l0, %i0 <== NOT EXECUTED 40016f00: 02 80 00 08 be 40016f20 <_Timespec_To_ticks+0x70> <== NOT EXECUTED 40016f04: 01 00 00 00 nop <== NOT EXECUTED return ticks; return 1; } 40016f08: 81 c7 e0 08 ret <== NOT EXECUTED 40016f0c: 81 e8 00 00 restore <== NOT EXECUTED const struct timespec *time ) { uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 40016f10: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 40016f14: 12 bf ff ec bne 40016ec4 <_Timespec_To_ticks+0x14> <== NOT EXECUTED 40016f18: b0 10 20 00 clr %i0 <== NOT EXECUTED 40016f1c: 30 bf ff fb b,a 40016f08 <_Timespec_To_ticks+0x58> <== NOT EXECUTED if (ticks) return ticks; return 1; } 40016f20: 81 c7 e0 08 ret <== NOT EXECUTED 40016f24: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED 4000d540 <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 4000d540: 9d e3 bf 98 save %sp, -104, %sp _Chain_Append( &_User_extensions_List, &the_extension->Node ); 4000d544: 11 10 00 67 sethi %hi(0x40019c00), %o0 4000d548: 92 10 00 18 mov %i0, %o1 4000d54c: 7f ff e5 dc call 40006cbc <_Chain_Append> 4000d550: 90 12 21 94 or %o0, 0x194, %o0 /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 4000d554: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 4000d558: 80 a0 60 00 cmp %g1, 0 4000d55c: 02 80 00 06 be 4000d574 <_User_extensions_Add_API_set+0x34> 4000d560: b2 06 20 08 add %i0, 8, %i1 the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 4000d564: c2 26 20 10 st %g1, [ %i0 + 0x10 ] _Chain_Append( 4000d568: 31 10 00 66 sethi %hi(0x40019800), %i0 4000d56c: 7f ff e5 d4 call 40006cbc <_Chain_Append> 4000d570: 91 ee 23 14 restore %i0, 0x314, %o0 4000d574: 81 c7 e0 08 ret <== NOT EXECUTED 4000d578: 81 e8 00 00 restore <== NOT EXECUTED 4000a414 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, boolean is_internal, uint32_t the_error ) { 4000a414: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 4000a418: 03 10 00 67 sethi %hi(0x40019c00), %g1 4000a41c: 82 10 61 94 or %g1, 0x194, %g1 ! 40019d94 <_User_extensions_List> 4000a420: e0 00 60 08 ld [ %g1 + 8 ], %l0 !_Chain_Is_head( &_User_extensions_List, the_node ) ; 4000a424: 80 a4 00 01 cmp %l0, %g1 4000a428: 02 80 00 0d be 4000a45c <_User_extensions_Fatal+0x48> 4000a42c: 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 ) 4000a430: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 4000a434: 80 a0 60 00 cmp %g1, 0 4000a438: 02 80 00 05 be 4000a44c <_User_extensions_Fatal+0x38> 4000a43c: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 4000a440: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000a444: 9f c0 40 00 call %g1 <== NOT EXECUTED 4000a448: 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 ) { 4000a44c: 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 ) ; 4000a450: 80 a4 00 11 cmp %l0, %l1 4000a454: 32 bf ff f8 bne,a 4000a434 <_User_extensions_Fatal+0x20> 4000a458: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 <== NOT EXECUTED 4000a45c: 81 c7 e0 08 ret 4000a460: 81 e8 00 00 restore 400116bc <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 400116bc: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 400116c0: 40 00 12 b2 call 40016188 <_Chain_Extract> <== NOT EXECUTED 400116c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 400116c8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED 400116cc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400116d0: 02 80 00 04 be 400116e0 <_User_extensions_Remove_set+0x24> <== NOT EXECUTED 400116d4: 01 00 00 00 nop <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 400116d8: 40 00 12 ac call 40016188 <_Chain_Extract> <== NOT EXECUTED 400116dc: 91 ee 20 08 restore %i0, 8, %o0 <== NOT EXECUTED 400116e0: 81 c7 e0 08 ret <== NOT EXECUTED 400116e4: 81 e8 00 00 restore <== NOT EXECUTED 4000a464 <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 4000a464: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 4000a468: 03 10 00 67 sethi %hi(0x40019c00), %g1 4000a46c: 82 10 61 94 or %g1, 0x194, %g1 ! 40019d94 <_User_extensions_List> 4000a470: e0 00 60 08 ld [ %g1 + 8 ], %l0 !_Chain_Is_head( &_User_extensions_List, the_node ) ; 4000a474: 80 a4 00 01 cmp %l0, %g1 4000a478: 02 80 00 0c be 4000a4a8 <_User_extensions_Thread_exitted+0x44> 4000a47c: 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 ) 4000a480: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 4000a484: 80 a0 60 00 cmp %g1, 0 4000a488: 02 80 00 04 be 4000a498 <_User_extensions_Thread_exitted+0x34> 4000a48c: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.thread_exitted)( executing ); 4000a490: 9f c0 40 00 call %g1 4000a494: 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 ) { 4000a498: 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 ) ; 4000a49c: 80 a4 00 11 cmp %l0, %l1 4000a4a0: 32 bf ff f9 bne,a 4000a484 <_User_extensions_Thread_exitted+0x20> 4000a4a4: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 <== NOT EXECUTED 4000a4a8: 81 c7 e0 08 ret 4000a4ac: 81 e8 00 00 restore 4000a5fc <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 4000a5fc: 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; 4000a600: 03 10 00 66 sethi %hi(0x40019800), %g1 void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 4000a604: 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; 4000a608: e6 00 63 d4 ld [ %g1 + 0x3d4 ], %l3 _ISR_Disable( level ); 4000a60c: 7f ff dd f3 call 40001dd8 4000a610: 01 00 00 00 nop 4000a614: 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 ) { 4000a618: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000a61c: 80 a0 60 00 cmp %g1, 0 4000a620: 12 80 00 49 bne 4000a744 <_Watchdog_Insert+0x148> 4000a624: 01 00 00 00 nop _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 4000a628: 2b 10 00 67 sethi %hi(0x40019c00), %l5 4000a62c: c2 05 60 90 ld [ %l5 + 0x90 ], %g1 ! 40019c90 <_Watchdog_Sync_count> if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 4000a630: 84 10 20 01 mov 1, %g2 _Watchdog_Sync_count++; 4000a634: 82 00 60 01 inc %g1 4000a638: 29 10 00 66 sethi %hi(0x40019800), %l4 if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 4000a63c: c4 26 60 08 st %g2, [ %i1 + 8 ] _Watchdog_Sync_count++; 4000a640: c2 25 60 90 st %g1, [ %l5 + 0x90 ] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 4000a644: ae 10 00 14 mov %l4, %l7 the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 4000a648: 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 ; 4000a64c: e2 05 80 00 ld [ %l6 ], %l1 ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 4000a650: 80 a4 a0 00 cmp %l2, 0 4000a654: 02 80 00 2b be 4000a700 <_Watchdog_Insert+0x104> 4000a658: 03 10 00 67 sethi %hi(0x40019c00), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 4000a65c: c2 04 40 00 ld [ %l1 ], %g1 4000a660: 80 a0 60 00 cmp %g1, 0 4000a664: 02 80 00 27 be 4000a700 <_Watchdog_Insert+0x104> 4000a668: 03 10 00 67 sethi %hi(0x40019c00), %g1 break; if ( delta_interval < after->delta_interval ) { 4000a66c: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 4000a670: 80 a4 80 10 cmp %l2, %l0 4000a674: 1a 80 00 13 bcc 4000a6c0 <_Watchdog_Insert+0xc4> 4000a678: 01 00 00 00 nop after->delta_interval -= delta_interval; 4000a67c: 10 80 00 1f b 4000a6f8 <_Watchdog_Insert+0xfc> 4000a680: 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 ) { 4000a684: c2 05 23 e8 ld [ %l4 + 0x3e8 ], %g1 4000a688: 80 a4 c0 01 cmp %l3, %g1 4000a68c: 0a 80 00 30 bcs 4000a74c <_Watchdog_Insert+0x150> 4000a690: 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 ) ) 4000a694: a4 a4 80 10 subcc %l2, %l0, %l2 4000a698: 02 80 00 19 be 4000a6fc <_Watchdog_Insert+0x100> 4000a69c: e2 04 40 00 ld [ %l1 ], %l1 4000a6a0: c2 04 40 00 ld [ %l1 ], %g1 4000a6a4: 80 a0 60 00 cmp %g1, 0 4000a6a8: 02 80 00 16 be 4000a700 <_Watchdog_Insert+0x104> 4000a6ac: 03 10 00 67 sethi %hi(0x40019c00), %g1 break; if ( delta_interval < after->delta_interval ) { 4000a6b0: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 4000a6b4: 80 a4 00 12 cmp %l0, %l2 4000a6b8: 38 80 00 10 bgu,a 4000a6f8 <_Watchdog_Insert+0xfc> 4000a6bc: 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 ); 4000a6c0: 7f ff dd ca call 40001de8 4000a6c4: 90 10 00 18 mov %i0, %o0 4000a6c8: 7f ff dd c4 call 40001dd8 4000a6cc: 01 00 00 00 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 4000a6d0: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000a6d4: 80 a0 60 01 cmp %g1, 1 4000a6d8: 02 bf ff eb be 4000a684 <_Watchdog_Insert+0x88> 4000a6dc: 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; 4000a6e0: e6 25 23 e8 st %l3, [ %l4 + 0x3e8 ] <== NOT EXECUTED _Watchdog_Sync_count--; 4000a6e4: c2 05 60 90 ld [ %l5 + 0x90 ], %g1 <== NOT EXECUTED 4000a6e8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000a6ec: c2 25 60 90 st %g1, [ %l5 + 0x90 ] <== NOT EXECUTED _ISR_Enable( level ); 4000a6f0: 7f ff dd be call 40001de8 <== NOT EXECUTED 4000a6f4: 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; 4000a6f8: 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; 4000a6fc: 03 10 00 67 sethi %hi(0x40019c00), %g1 4000a700: c6 00 60 94 ld [ %g1 + 0x94 ], %g3 ! 40019c94 <_Watchdog_Ticks_since_boot> _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 4000a704: c4 04 60 04 ld [ %l1 + 4 ], %g2 the_watchdog->start_time = _Watchdog_Ticks_since_boot; 4000a708: c6 26 60 14 st %g3, [ %i1 + 0x14 ] } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 4000a70c: e4 26 60 10 st %l2, [ %i1 + 0x10 ] RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 4000a710: 82 10 20 02 mov 2, %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 4000a714: 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; 4000a718: e6 25 23 e8 st %l3, [ %l4 + 0x3e8 ] 4000a71c: c2 26 60 08 st %g1, [ %i1 + 8 ] _Watchdog_Sync_count--; 4000a720: c2 05 60 90 ld [ %l5 + 0x90 ], %g1 after_node->next = the_node; 4000a724: f2 20 80 00 st %i1, [ %g2 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 4000a728: c4 26 60 04 st %g2, [ %i1 + 4 ] 4000a72c: 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; 4000a730: 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; 4000a734: c8 26 40 00 st %g4, [ %i1 ] 4000a738: c2 25 60 90 st %g1, [ %l5 + 0x90 ] _ISR_Enable( level ); 4000a73c: 7f ff dd ab call 40001de8 4000a740: 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 ); 4000a744: 7f ff dd a9 call 40001de8 <== NOT EXECUTED 4000a748: 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; 4000a74c: e6 25 e3 e8 st %l3, [ %l7 + 0x3e8 ] the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 4000a750: 10 bf ff bf b 4000a64c <_Watchdog_Insert+0x50> 4000a754: e4 06 60 0c ld [ %i1 + 0xc ], %l2 4000a7a4 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 4000a7a4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 4000a7a8: 7f ff dd 8c call 40001dd8 4000a7ac: a0 10 00 18 mov %i0, %l0 previous_state = the_watchdog->state; 4000a7b0: f0 06 20 08 ld [ %i0 + 8 ], %i0 switch ( previous_state ) { 4000a7b4: 80 a6 20 01 cmp %i0, 1 4000a7b8: 02 80 00 2a be 4000a860 <_Watchdog_Remove+0xbc> 4000a7bc: 03 10 00 67 sethi %hi(0x40019c00), %g1 4000a7c0: 1a 80 00 09 bcc 4000a7e4 <_Watchdog_Remove+0x40> 4000a7c4: 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; 4000a7c8: 03 10 00 67 sethi %hi(0x40019c00), %g1 4000a7cc: c4 00 60 94 ld [ %g1 + 0x94 ], %g2 ! 40019c94 <_Watchdog_Ticks_since_boot> 4000a7d0: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 4000a7d4: 7f ff dd 85 call 40001de8 4000a7d8: 01 00 00 00 nop return( previous_state ); } 4000a7dc: 81 c7 e0 08 ret 4000a7e0: 81 e8 00 00 restore Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 4000a7e4: 18 bf ff fa bgu 4000a7cc <_Watchdog_Remove+0x28> 4000a7e8: 03 10 00 67 sethi %hi(0x40019c00), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 4000a7ec: c8 04 00 00 ld [ %l0 ], %g4 break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 4000a7f0: c0 24 20 08 clr [ %l0 + 8 ] next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 4000a7f4: c2 01 00 00 ld [ %g4 ], %g1 4000a7f8: 80 a0 60 00 cmp %g1, 0 4000a7fc: 02 80 00 07 be 4000a818 <_Watchdog_Remove+0x74> 4000a800: 03 10 00 67 sethi %hi(0x40019c00), %g1 next_watchdog->delta_interval += the_watchdog->delta_interval; 4000a804: c2 01 20 10 ld [ %g4 + 0x10 ], %g1 4000a808: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 4000a80c: 82 00 40 02 add %g1, %g2, %g1 4000a810: c2 21 20 10 st %g1, [ %g4 + 0x10 ] if ( _Watchdog_Sync_count ) 4000a814: 03 10 00 67 sethi %hi(0x40019c00), %g1 4000a818: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 40019c90 <_Watchdog_Sync_count> 4000a81c: 80 a0 a0 00 cmp %g2, 0 4000a820: 22 80 00 07 be,a 4000a83c <_Watchdog_Remove+0x98> 4000a824: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Watchdog_Sync_level = _ISR_Nest_level; 4000a828: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 4000a82c: c6 00 63 d4 ld [ %g1 + 0x3d4 ], %g3 ! 40019bd4 <_ISR_Nest_level> <== NOT EXECUTED 4000a830: 05 10 00 66 sethi %hi(0x40019800), %g2 <== NOT EXECUTED 4000a834: c6 20 a3 e8 st %g3, [ %g2 + 0x3e8 ] ! 40019be8 <_Watchdog_Sync_level> <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 4000a838: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 4000a83c: c8 20 40 00 st %g4, [ %g1 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 4000a840: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 4000a844: 03 10 00 67 sethi %hi(0x40019c00), %g1 4000a848: c4 00 60 94 ld [ %g1 + 0x94 ], %g2 ! 40019c94 <_Watchdog_Ticks_since_boot> 4000a84c: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 4000a850: 7f ff dd 66 call 40001de8 4000a854: 01 00 00 00 nop return( previous_state ); } 4000a858: 81 c7 e0 08 ret 4000a85c: 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; 4000a860: c4 00 60 94 ld [ %g1 + 0x94 ], %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; 4000a864: 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; 4000a868: c4 24 20 18 st %g2, [ %l0 + 0x18 ] <== NOT EXECUTED _ISR_Enable( level ); 4000a86c: 7f ff dd 5f call 40001de8 <== NOT EXECUTED 4000a870: 01 00 00 00 nop <== NOT EXECUTED return( previous_state ); } 4000a874: 81 c7 e0 08 ret <== NOT EXECUTED 4000a878: 81 e8 00 00 restore <== NOT EXECUTED 4000a928 <_Workspace_Allocate_or_fatal_error>: */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 4000a928: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 4000a92c: 11 10 00 66 sethi %hi(0x40019800), %o0 4000a930: 92 10 00 18 mov %i0, %o1 4000a934: 7f ff f2 33 call 40007200 <_Heap_Allocate> 4000a938: 90 12 23 5c or %o0, 0x35c, %o0 void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 4000a93c: b0 92 20 00 orcc %o0, 0, %i0 4000a940: 12 80 00 04 bne 4000a950 <_Workspace_Allocate_or_fatal_error+0x28> 4000a944: 92 10 20 01 mov 1, %o1 _Internal_error_Occurred( 4000a948: 7f ff f3 60 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 4000a94c: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 4000a950: 81 c7 e0 08 ret 4000a954: 81 e8 00 00 restore 4000a958 <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 4000a958: 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 ) ) 4000a95c: 80 a6 20 00 cmp %i0, 0 4000a960: 02 80 00 1d be 4000a9d4 <_Workspace_Handler_initialization+0x7c> 4000a964: 80 8e 20 07 btst 7, %i0 4000a968: 12 80 00 1c bne 4000a9d8 <_Workspace_Handler_initialization+0x80> 4000a96c: 90 10 20 00 clr %o0 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { 4000a970: 03 10 00 66 sethi %hi(0x40019800), %g1 4000a974: c4 00 63 34 ld [ %g1 + 0x334 ], %g2 ! 40019b34 <_CPU_Table+0x10> 4000a978: 80 a0 a0 00 cmp %g2, 0 4000a97c: 02 80 00 0c be 4000a9ac <_Workspace_Handler_initialization+0x54> 4000a980: 92 10 00 18 mov %i0, %o1 for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; 4000a984: 87 36 60 02 srl %i1, 2, %g3 <== NOT EXECUTED 4000a988: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000a98c: 02 80 00 08 be 4000a9ac <_Workspace_Handler_initialization+0x54> <== NOT EXECUTED 4000a990: 84 10 20 00 clr %g2 <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; 4000a994: 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++ ) 4000a998: 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 ) ; 4000a99c: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED 4000a9a0: 12 bf ff fd bne 4000a994 <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED 4000a9a4: c0 20 40 18 clr [ %g1 + %i0 ] <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 4000a9a8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000a9ac: 94 10 00 19 mov %i1, %o2 4000a9b0: 11 10 00 66 sethi %hi(0x40019800), %o0 4000a9b4: 96 10 20 08 mov 8, %o3 4000a9b8: 7f ff f2 f7 call 40007594 <_Heap_Initialize> 4000a9bc: 90 12 23 5c or %o0, 0x35c, %o0 starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 4000a9c0: 80 a2 20 00 cmp %o0, 0 4000a9c4: 02 80 00 0a be 4000a9ec <_Workspace_Handler_initialization+0x94> 4000a9c8: b0 10 20 00 clr %i0 4000a9cc: 81 c7 e0 08 ret 4000a9d0: 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( 4000a9d4: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000a9d8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 4000a9dc: 7f ff f3 3b call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 4000a9e0: 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 ) { 4000a9e4: 10 bf ff e4 b 4000a974 <_Workspace_Handler_initialization+0x1c> <== NOT EXECUTED 4000a9e8: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 4000a9ec: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED 4000a9f0: 7f ff f3 36 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 4000a9f4: 95 e8 20 03 restore %g0, 3, %o2 <== NOT EXECUTED 4000a9f8: 01 00 00 00 nop 40006230 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 40006230: 9d e3 bf 90 save %sp, -112, %sp Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 40006234: a4 96 20 00 orcc %i0, 0, %l2 40006238: 02 80 00 20 be 400062b8 4000623c: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 40006240: 80 a6 e0 00 cmp %i3, 0 40006244: 02 80 00 1d be 400062b8 40006248: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 4000624c: 80 8e 60 10 btst 0x10, %i1 40006250: 02 80 00 39 be 40006334 40006254: 80 a6 a0 00 cmp %i2, 0 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 40006258: 02 80 00 18 be 400062b8 4000625c: 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; 40006260: c0 27 bf f0 clr [ %fp + -16 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006264: 21 10 00 76 sethi %hi(0x4001d800), %l0 40006268: c2 04 23 70 ld [ %l0 + 0x370 ], %g1 ! 4001db70 <_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; 4000626c: f4 27 bf f4 st %i2, [ %fp + -12 ] 40006270: 82 00 60 01 inc %g1 40006274: c2 24 23 70 st %g1, [ %l0 + 0x370 ] * 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 ); 40006278: 23 10 00 76 sethi %hi(0x4001d800), %l1 4000627c: 40 00 0a 45 call 40008b90 <_Objects_Allocate> 40006280: 90 14 61 d4 or %l1, 0x1d4, %o0 ! 4001d9d4 <_Barrier_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 40006284: b4 92 20 00 orcc %o0, 0, %i2 40006288: 12 80 00 0e bne 400062c0 4000628c: 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 ) 40006290: c2 04 23 70 ld [ %l0 + 0x370 ], %g1 40006294: b0 10 20 05 mov 5, %i0 40006298: 82 00 7f ff add %g1, -1, %g1 4000629c: c2 24 23 70 st %g1, [ %l0 + 0x370 ] 400062a0: c4 04 23 70 ld [ %l0 + 0x370 ], %g2 400062a4: 80 a0 a0 00 cmp %g2, 0 400062a8: 12 80 00 21 bne 4000632c 400062ac: 01 00 00 00 nop _Thread_Dispatch(); 400062b0: 40 00 10 b1 call 4000a574 <_Thread_Dispatch> 400062b4: 01 00 00 00 nop 400062b8: 81 c7 e0 08 ret 400062bc: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 400062c0: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 400062c4: 40 00 07 67 call 40008060 <_CORE_barrier_Initialize> 400062c8: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400062cc: 90 14 61 d4 or %l1, 0x1d4, %o0 Objects_Name name ) { uint32_t index; index = _Objects_Get_index( the_object->id ); 400062d0: c6 06 a0 08 ld [ %i2 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400062d4: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 400062d8: 03 00 00 3f sethi %hi(0xfc00), %g1 400062dc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400062e0: 82 08 c0 01 and %g3, %g1, %g1 400062e4: 80 a0 40 02 cmp %g1, %g2 400062e8: 38 80 00 06 bgu,a 40006300 400062ec: e4 26 a0 0c st %l2, [ %i2 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 400062f0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400062f4: 83 28 60 02 sll %g1, 2, %g1 400062f8: 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; 400062fc: e4 26 a0 0c st %l2, [ %i2 + 0xc ] &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 40006300: 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 ) 40006304: c2 04 23 70 ld [ %l0 + 0x370 ], %g1 40006308: b0 10 20 00 clr %i0 4000630c: 82 00 7f ff add %g1, -1, %g1 40006310: c2 24 23 70 st %g1, [ %l0 + 0x370 ] 40006314: c4 04 23 70 ld [ %l0 + 0x370 ], %g2 40006318: 80 a0 a0 00 cmp %g2, 0 4000631c: 12 80 00 04 bne 4000632c 40006320: 01 00 00 00 nop _Thread_Dispatch(); 40006324: 40 00 10 94 call 4000a574 <_Thread_Dispatch> 40006328: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 4000632c: 81 c7 e0 08 ret 40006330: 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; 40006334: 82 10 20 01 mov 1, %g1 40006338: 10 bf ff cb b 40006264 4000633c: c2 27 bf f0 st %g1, [ %fp + -16 ] 40006340 : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 40006340: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 40006344: 21 10 00 76 sethi %hi(0x4001d800), %l0 40006348: 92 10 00 18 mov %i0, %o1 4000634c: 94 07 bf f4 add %fp, -12, %o2 40006350: 40 00 0b 61 call 400090d4 <_Objects_Get> 40006354: 90 14 21 d4 or %l0, 0x1d4, %o0 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 40006358: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000635c: 80 a0 60 00 cmp %g1, 0 40006360: 12 80 00 20 bne 400063e0 40006364: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Flush( 40006368: 90 02 20 14 add %o0, 0x14, %o0 4000636c: 92 10 20 00 clr %o1 40006370: 40 00 12 f7 call 4000af4c <_Thread_queue_Flush> 40006374: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006378: 90 14 21 d4 or %l0, 0x1d4, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000637c: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40006380: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40006384: 05 00 00 3f sethi %hi(0xfc00), %g2 40006388: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000638c: 82 08 40 02 and %g1, %g2, %g1 40006390: 80 a0 40 03 cmp %g1, %g3 40006394: 38 80 00 06 bgu,a 400063ac 40006398: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000639c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400063a0: 83 28 60 02 sll %g1, 2, %g1 400063a4: 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; 400063a8: c0 26 20 0c clr [ %i0 + 0xc ] */ RTEMS_INLINE_ROUTINE void _Barrier_Free ( Barrier_Control *the_barrier ) { _Objects_Free( &_Barrier_Information, &the_barrier->Object ); 400063ac: 40 00 0b 07 call 40008fc8 <_Objects_Free> 400063b0: 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 ) 400063b4: 03 10 00 76 sethi %hi(0x4001d800), %g1 400063b8: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 4001db70 <_Thread_Dispatch_disable_level> 400063bc: b0 10 20 00 clr %i0 400063c0: 84 00 bf ff add %g2, -1, %g2 400063c4: c4 20 63 70 st %g2, [ %g1 + 0x370 ] 400063c8: c6 00 63 70 ld [ %g1 + 0x370 ], %g3 400063cc: 80 a0 e0 00 cmp %g3, 0 400063d0: 02 80 00 09 be 400063f4 400063d4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400063d8: 81 c7 e0 08 ret 400063dc: 81 e8 00 00 restore { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 400063e0: 80 a0 60 02 cmp %g1, 2 400063e4: 08 bf ff fd bleu 400063d8 400063e8: b0 10 20 04 mov 4, %i0 400063ec: 81 c7 e0 08 ret <== NOT EXECUTED 400063f0: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 400063f4: 40 00 10 60 call 4000a574 <_Thread_Dispatch> 400063f8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400063fc: 81 c7 e0 08 ret 40006400: 81 e8 00 00 restore 4000643c : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 4000643c: 9d e3 bf 90 save %sp, -112, %sp 40006440: a0 10 00 18 mov %i0, %l0 Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 40006444: 80 a6 60 00 cmp %i1, 0 40006448: 02 80 00 1f be 400064c4 4000644c: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 40006450: 11 10 00 76 sethi %hi(0x4001d800), %o0 40006454: 92 10 00 10 mov %l0, %o1 40006458: 90 12 21 d4 or %o0, 0x1d4, %o0 4000645c: 40 00 0b 1e call 400090d4 <_Objects_Get> 40006460: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 40006464: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006468: 80 a0 60 00 cmp %g1, 0 4000646c: 02 80 00 07 be 40006488 40006470: 92 10 00 10 mov %l0, %o1 40006474: 80 a0 60 02 cmp %g1, 2 40006478: 08 80 00 13 bleu 400064c4 4000647c: b0 10 20 04 mov 4, %i0 40006480: 81 c7 e0 08 ret <== NOT EXECUTED 40006484: 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 ); 40006488: 94 10 20 00 clr %o2 4000648c: 40 00 07 01 call 40008090 <_CORE_barrier_Release> 40006490: 90 02 20 14 add %o0, 0x14, %o0 40006494: 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 ) 40006498: 03 10 00 76 sethi %hi(0x4001d800), %g1 4000649c: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 4001db70 <_Thread_Dispatch_disable_level> 400064a0: b0 10 20 00 clr %i0 400064a4: 84 00 bf ff add %g2, -1, %g2 400064a8: c4 20 63 70 st %g2, [ %g1 + 0x370 ] 400064ac: c6 00 63 70 ld [ %g1 + 0x370 ], %g3 400064b0: 80 a0 e0 00 cmp %g3, 0 400064b4: 12 80 00 04 bne 400064c4 400064b8: 01 00 00 00 nop _Thread_Dispatch(); 400064bc: 40 00 10 2e call 4000a574 <_Thread_Dispatch> 400064c0: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400064c4: 81 c7 e0 08 ret 400064c8: 81 e8 00 00 restore 400064cc : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 400064cc: 9d e3 bf 90 save %sp, -112, %sp 400064d0: 11 10 00 76 sethi %hi(0x4001d800), %o0 400064d4: 92 10 00 18 mov %i0, %o1 400064d8: 90 12 21 d4 or %o0, 0x1d4, %o0 400064dc: 40 00 0a fe call 400090d4 <_Objects_Get> 400064e0: 94 07 bf f4 add %fp, -12, %o2 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 400064e4: c2 07 bf f4 ld [ %fp + -12 ], %g1 400064e8: 80 a0 60 00 cmp %g1, 0 400064ec: 12 80 00 14 bne 4000653c 400064f0: 96 10 00 19 mov %i1, %o3 case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Wait( 400064f4: 90 02 20 14 add %o0, 0x14, %o0 400064f8: 92 10 00 18 mov %i0, %o1 400064fc: 94 10 20 01 mov 1, %o2 40006500: 40 00 06 ef call 400080bc <_CORE_barrier_Wait> 40006504: 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 ) 40006508: 03 10 00 76 sethi %hi(0x4001d800), %g1 4000650c: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 4001db70 <_Thread_Dispatch_disable_level> 40006510: 84 00 bf ff add %g2, -1, %g2 40006514: c4 20 63 70 st %g2, [ %g1 + 0x370 ] 40006518: c6 00 63 70 ld [ %g1 + 0x370 ], %g3 4000651c: 80 a0 e0 00 cmp %g3, 0 40006520: 02 80 00 0d be 40006554 40006524: 03 10 00 77 sethi %hi(0x4001dc00), %g1 TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 40006528: c4 00 60 4c ld [ %g1 + 0x4c ], %g2 ! 4001dc4c <_Thread_Executing> <== NOT EXECUTED 4000652c: 40 00 1d 9a call 4000db94 <_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 40006530: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 <== NOT EXECUTED _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006534: 81 c7 e0 08 ret 40006538: 91 e8 00 08 restore %g0, %o0, %o0 { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 4000653c: 80 a0 60 02 cmp %g1, 2 40006540: 08 bf ff fd bleu 40006534 40006544: 90 10 20 04 mov 4, %o0 40006548: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000654c: 81 c7 e0 08 ret <== NOT EXECUTED 40006550: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40006554: 40 00 10 08 call 4000a574 <_Thread_Dispatch> 40006558: 01 00 00 00 nop TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 4000655c: 03 10 00 77 sethi %hi(0x4001dc00), %g1 40006560: c4 00 60 4c ld [ %g1 + 0x4c ], %g2 ! 4001dc4c <_Thread_Executing> 40006564: 40 00 1d 8c call 4000db94 <_Barrier_Translate_core_barrier_return_code> 40006568: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 4000656c: 30 bf ff f2 b,a 40006534 40005244 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 40005244: 9d e3 bf 60 save %sp, -160, %sp 40005248: 82 10 00 18 mov %i0, %g1 if ( !time_buffer ) 4000524c: 80 a6 60 00 cmp %i1, 0 40005250: 02 80 00 19 be 400052b4 40005254: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; switch ( option ) { 40005258: 80 a0 60 04 cmp %g1, 4 4000525c: 18 80 00 16 bgu 400052b4 40005260: b0 10 20 19 mov 0x19, %i0 40005264: 83 28 60 02 sll %g1, 2, %g1 40005268: 05 10 00 14 sethi %hi(0x40005000), %g2 4000526c: 84 10 a2 30 or %g2, 0x230, %g2 ! 40005230 40005270: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40005274: 81 c0 c0 00 jmp %g3 40005278: 01 00 00 00 nop } case RTEMS_CLOCK_GET_TIME_VALUE: { struct timeval *time = (struct timeval *)time_buffer; if ( !_TOD_Is_set ) 4000527c: 03 10 00 66 sethi %hi(0x40019800), %g1 <== NOT EXECUTED 40005280: c4 00 63 4c ld [ %g1 + 0x34c ], %g2 ! 40019b4c <_TOD_Is_set> <== NOT EXECUTED 40005284: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40005288: 12 80 00 46 bne 400053a0 <== NOT EXECUTED 4000528c: 01 00 00 00 nop <== NOT EXECUTED } } return RTEMS_INTERNAL_ERROR; /* should never get here */ } 40005290: 81 c7 e0 08 ret 40005294: 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; 40005298: 03 10 00 67 sethi %hi(0x40019c00), %g1 4000529c: d2 00 60 ec ld [ %g1 + 0xec ], %o1 ! 40019cec <_TOD_Microseconds_per_tick> 400052a0: 11 00 03 d0 sethi %hi(0xf4000), %o0 400052a4: b0 10 20 00 clr %i0 400052a8: 40 00 3f cd call 400151dc <.udiv> 400052ac: 90 12 22 40 or %o0, 0x240, %o0 400052b0: d0 26 40 00 st %o0, [ %i1 ] 400052b4: 81 c7 e0 08 ret 400052b8: 81 e8 00 00 restore } case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = _Watchdog_Ticks_since_boot; 400052bc: 03 10 00 67 sethi %hi(0x40019c00), %g1 400052c0: c4 00 60 94 ld [ %g1 + 0x94 ], %g2 ! 40019c94 <_Watchdog_Ticks_since_boot> 400052c4: c4 26 40 00 st %g2, [ %i1 ] 400052c8: 81 c7 e0 08 ret 400052cc: 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 ) 400052d0: 03 10 00 66 sethi %hi(0x40019800), %g1 400052d4: c4 00 63 4c ld [ %g1 + 0x34c ], %g2 ! 40019b4c <_TOD_Is_set> 400052d8: 80 a0 a0 00 cmp %g2, 0 400052dc: 02 bf ff ed be 40005290 400052e0: 03 10 00 66 sethi %hi(0x40019800), %g1 return RTEMS_NOT_DEFINED; *interval = _TOD_Seconds_since_epoch; 400052e4: c4 00 63 c8 ld [ %g1 + 0x3c8 ], %g2 ! 40019bc8 <_TOD_Now> 400052e8: c4 26 40 00 st %g2, [ %i1 ] 400052ec: 81 c7 e0 08 ret 400052f0: 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 ) 400052f4: 03 10 00 66 sethi %hi(0x40019800), %g1 400052f8: c4 00 63 4c ld [ %g1 + 0x34c ], %g2 ! 40019b4c <_TOD_Is_set> 400052fc: 80 a0 a0 00 cmp %g2, 0 40005300: 02 bf ff e4 be 40005290 40005304: 01 00 00 00 nop ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 40005308: 7f ff f2 b4 call 40001dd8 4000530c: 01 00 00 00 nop 40005310: a0 10 00 08 mov %o0, %l0 _TOD_Get( &now ); 40005314: 40 00 07 71 call 400070d8 <_TOD_Get> 40005318: 90 07 bf e8 add %fp, -24, %o0 _ISR_Enable(level); 4000531c: 7f ff f2 b3 call 40001de8 40005320: 90 10 00 10 mov %l0, %o0 time->tv_sec = now.tv_sec; 40005324: c2 07 bf e8 ld [ %fp + -24 ], %g1 time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 40005328: d0 07 bf ec ld [ %fp + -20 ], %o0 _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 4000532c: c2 27 bf f0 st %g1, [ %fp + -16 ] time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 40005330: 40 00 3f ab call 400151dc <.udiv> 40005334: 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 ); 40005338: 92 07 bf c4 add %fp, -60, %o1 4000533c: d0 27 bf f4 st %o0, [ %fp + -12 ] 40005340: 40 00 25 4e call 4000e878 40005344: 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; 40005348: 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; 4000534c: 03 10 00 67 sethi %hi(0x40019c00), %g1 40005350: d2 00 60 ec ld [ %g1 + 0xec ], %o1 ! 40019cec <_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; 40005354: c4 26 60 08 st %g2, [ %i1 + 8 ] tmbuf->hour = time.tm_hour; 40005358: c2 07 bf cc ld [ %fp + -52 ], %g1 tmbuf->minute = time.tm_min; 4000535c: 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; 40005360: c2 26 60 0c st %g1, [ %i1 + 0xc ] tmbuf->minute = time.tm_min; 40005364: 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; 40005368: c2 07 bf d8 ld [ %fp + -40 ], %g1 tmbuf->month = time.tm_mon + 1; 4000536c: 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; 40005370: c6 07 bf c4 ld [ %fp + -60 ], %g3 tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 40005374: 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; 40005378: 82 00 67 6c add %g1, 0x76c, %g1 tmbuf->month = time.tm_mon + 1; 4000537c: 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; 40005380: 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; 40005384: c2 26 40 00 st %g1, [ %i1 ] tmbuf->month = time.tm_mon + 1; 40005388: 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; 4000538c: 40 00 3f 94 call 400151dc <.udiv> 40005390: b0 10 20 00 clr %i0 40005394: d0 26 60 18 st %o0, [ %i1 + 0x18 ] 40005398: 81 c7 e0 08 ret 4000539c: 81 e8 00 00 restore ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 400053a0: 7f ff f2 8e call 40001dd8 <== NOT EXECUTED 400053a4: 01 00 00 00 nop <== NOT EXECUTED 400053a8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED _TOD_Get( &now ); 400053ac: 40 00 07 4b call 400070d8 <_TOD_Get> <== NOT EXECUTED 400053b0: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED _ISR_Enable(level); 400053b4: 7f ff f2 8d call 40001de8 <== NOT EXECUTED 400053b8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED time->tv_sec = now.tv_sec; 400053bc: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 400053c0: d0 07 bf ec ld [ %fp + -20 ], %o0 <== NOT EXECUTED 400053c4: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 400053c8: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 400053cc: 40 00 3f 84 call 400151dc <.udiv> <== NOT EXECUTED 400053d0: b0 10 20 00 clr %i0 <== NOT EXECUTED 400053d4: d0 26 60 04 st %o0, [ %i1 + 4 ] <== NOT EXECUTED 400053d8: 81 c7 e0 08 ret <== NOT EXECUTED 400053dc: 81 e8 00 00 restore <== NOT EXECUTED 40005400 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 40005400: 9d e3 bf 98 save %sp, -104, %sp _TOD_Tickle_ticks(); 40005404: 40 00 07 5d call 40007178 <_TOD_Tickle_ticks> 40005408: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 4000540c: 11 10 00 67 sethi %hi(0x40019c00), %o0 40005410: 40 00 15 1b call 4000a87c <_Watchdog_Tickle> 40005414: 90 12 20 0c or %o0, 0xc, %o0 ! 40019c0c <_Watchdog_Ticks_chain> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 40005418: 40 00 13 3f call 4000a114 <_Thread_Tickle_timeslice> 4000541c: 01 00 00 00 nop * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_context_switch_necessary( void ) { return ( _Context_Switch_necessary ); 40005420: 03 10 00 66 sethi %hi(0x40019800), %g1 40005424: c4 00 63 fc ld [ %g1 + 0x3fc ], %g2 ! 40019bfc <_Context_Switch_necessary> if ( _Thread_Is_context_switch_necessary() && 40005428: 80 a0 a0 00 cmp %g2, 0 4000542c: 02 80 00 06 be 40005444 40005430: 03 10 00 66 sethi %hi(0x40019800), %g1 * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 40005434: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 40019b10 <_Thread_Dispatch_disable_level> 40005438: 80 a0 a0 00 cmp %g2, 0 4000543c: 02 80 00 04 be 4000544c 40005440: 01 00 00 00 nop _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 40005444: 81 c7 e0 08 ret 40005448: 91 e8 20 00 restore %g0, 0, %o0 _Thread_Tickle_timeslice(); if ( _Thread_Is_context_switch_necessary() && _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 4000544c: 40 00 0f 45 call 40009160 <_Thread_Dispatch> <== NOT EXECUTED 40005450: b0 10 20 00 clr %i0 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 40005454: 81 c7 e0 08 ret <== NOT EXECUTED 40005458: 81 e8 00 00 restore <== NOT EXECUTED 40005694 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 40005694: 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 ) ) { 40005698: 92 96 20 00 orcc %i0, 0, %o1 4000569c: 12 80 00 1c bne 4000570c 400056a0: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400056a4: 23 10 00 66 sethi %hi(0x40019800), %l1 400056a8: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> 400056ac: 82 00 60 01 inc %g1 400056b0: c2 24 63 10 st %g1, [ %l1 + 0x310 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 400056b4: 03 10 00 66 sethi %hi(0x40019800), %g1 400056b8: f0 00 63 ec ld [ %g1 + 0x3ec ], %i0 ! 40019bec <_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; 400056bc: c0 27 bf f4 clr [ %fp + -12 ] rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 400056c0: 7f ff f1 c6 call 40001dd8 400056c4: e0 06 21 6c ld [ %i0 + 0x16c ], %l0 *the_event_set |= the_new_events; 400056c8: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 400056cc: 82 10 40 19 or %g1, %i1, %g1 400056d0: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _ISR_Enable( level ); 400056d4: 7f ff f1 c5 call 40001de8 400056d8: 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 ); 400056dc: 40 00 00 2d call 40005790 <_Event_Surrender> 400056e0: 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 ) 400056e4: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 400056e8: b0 10 20 00 clr %i0 400056ec: 82 00 7f ff add %g1, -1, %g1 400056f0: c2 24 63 10 st %g1, [ %l1 + 0x310 ] 400056f4: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 400056f8: 80 a0 a0 00 cmp %g2, 0 400056fc: 02 80 00 0a be 40005724 40005700: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40005704: 81 c7 e0 08 ret 40005708: 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); 4000570c: 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 ) { 40005710: 80 a0 a0 04 cmp %g2, 4 40005714: 08 80 00 08 bleu 40005734 40005718: 83 32 60 1b srl %o1, 0x1b, %g1 4000571c: 81 c7 e0 08 ret <== NOT EXECUTED 40005720: 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(); 40005724: 40 00 0e 8f call 40009160 <_Thread_Dispatch> 40005728: 01 00 00 00 nop 4000572c: 81 c7 e0 08 ret 40005730: 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 :) */ 40005734: 80 a0 60 01 cmp %g1, 1 40005738: 12 bf ff f3 bne 40005704 4000573c: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40005740: 83 28 a0 02 sll %g2, 2, %g1 40005744: 05 10 00 66 sethi %hi(0x40019800), %g2 40005748: 84 10 a2 70 or %g2, 0x270, %g2 ! 40019a70 <_Objects_Information_table> 4000574c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40005750: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40005754: 80 a2 20 00 cmp %o0, 0 40005758: 02 bf ff f5 be 4000572c 4000575c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40005760: 40 00 09 58 call 40007cc0 <_Objects_Get> 40005764: 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 ) { 40005768: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000576c: b0 10 00 08 mov %o0, %i0 40005770: 80 a0 60 00 cmp %g1, 0 40005774: 02 bf ff d3 be 400056c0 40005778: 23 10 00 66 sethi %hi(0x40019800), %l1 4000577c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40005780: 18 bf ff e1 bgu 40005704 <== NOT EXECUTED 40005784: 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(); 40005788: 81 c7 e0 08 ret <== NOT EXECUTED 4000578c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 4000da80 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 4000da80: 9d e3 bf 98 save %sp, -104, %sp Extension_Control *the_extension; if ( !rtems_is_name_valid( name ) ) 4000da84: a6 96 20 00 orcc %i0, 0, %l3 4000da88: 02 80 00 16 be 4000dae0 4000da8c: b0 10 20 03 mov 3, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000da90: 23 10 00 ac sethi %hi(0x4002b000), %l1 4000da94: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 ! 4002b190 <_Thread_Dispatch_disable_level> 4000da98: 82 00 60 01 inc %g1 4000da9c: c2 24 61 90 st %g1, [ %l1 + 0x190 ] * the inactive chain of free extension control blocks. */ RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void ) { return (Extension_Control *) _Objects_Allocate( &_Extension_Information ); 4000daa0: 25 10 00 ad sethi %hi(0x4002b400), %l2 4000daa4: 40 00 03 cb call 4000e9d0 <_Objects_Allocate> 4000daa8: 90 14 a0 2c or %l2, 0x2c, %o0 ! 4002b42c <_Extension_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 4000daac: a0 92 20 00 orcc %o0, 0, %l0 4000dab0: 12 80 00 0e bne 4000dae8 4000dab4: 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 ) 4000dab8: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 <== NOT EXECUTED 4000dabc: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 4000dac0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4000dac4: c2 24 61 90 st %g1, [ %l1 + 0x190 ] <== NOT EXECUTED 4000dac8: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 <== NOT EXECUTED 4000dacc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4000dad0: 12 80 00 20 bne 4000db50 <== NOT EXECUTED 4000dad4: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4000dad8: 40 00 0a 37 call 400103b4 <_Thread_Dispatch> <== NOT EXECUTED 4000dadc: 01 00 00 00 nop <== NOT EXECUTED 4000dae0: 81 c7 e0 08 ret <== NOT EXECUTED 4000dae4: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 4000dae8: 40 00 0e bb call 400115d4 <_User_extensions_Add_set> 4000daec: 92 10 00 19 mov %i1, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000daf0: 90 14 a0 2c or %l2, 0x2c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000daf4: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000daf8: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 4000dafc: 03 00 00 3f sethi %hi(0xfc00), %g1 4000db00: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000db04: 82 08 c0 01 and %g3, %g1, %g1 4000db08: 80 a0 40 02 cmp %g1, %g2 4000db0c: 38 80 00 06 bgu,a 4000db24 4000db10: e6 24 20 0c st %l3, [ %l0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000db14: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000db18: 83 28 60 02 sll %g1, 2, %g1 4000db1c: 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; 4000db20: e6 24 20 0c st %l3, [ %l0 + 0xc ] &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 4000db24: 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 ) 4000db28: c2 04 61 90 ld [ %l1 + 0x190 ], %g1 4000db2c: b0 10 20 00 clr %i0 4000db30: 82 00 7f ff add %g1, -1, %g1 4000db34: c2 24 61 90 st %g1, [ %l1 + 0x190 ] 4000db38: c4 04 61 90 ld [ %l1 + 0x190 ], %g2 4000db3c: 80 a0 a0 00 cmp %g2, 0 4000db40: 12 80 00 04 bne 4000db50 4000db44: 01 00 00 00 nop _Thread_Dispatch(); 4000db48: 40 00 0a 1b call 400103b4 <_Thread_Dispatch> 4000db4c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 4000db50: 81 c7 e0 08 ret 4000db54: 81 e8 00 00 restore 4000db58 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 4000db58: 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 *) 4000db5c: 21 10 00 ad sethi %hi(0x4002b400), %l0 <== NOT EXECUTED 4000db60: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000db64: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 4000db68: 40 00 04 eb call 4000ef14 <_Objects_Get> <== NOT EXECUTED 4000db6c: 90 14 20 2c or %l0, 0x2c, %o0 <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 4000db70: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4000db74: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000db78: 12 80 00 1e bne 4000dbf0 <== NOT EXECUTED 4000db7c: 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 ); 4000db80: 40 00 0e cf call 400116bc <_User_extensions_Remove_set> <== NOT EXECUTED 4000db84: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000db88: 90 14 20 2c or %l0, 0x2c, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000db8c: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000db90: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 <== NOT EXECUTED 4000db94: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED 4000db98: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <== NOT EXECUTED 4000db9c: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 4000dba0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4000dba4: 38 80 00 06 bgu,a 4000dbbc <== NOT EXECUTED 4000dba8: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000dbac: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 <== NOT EXECUTED 4000dbb0: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4000dbb4: 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; 4000dbb8: 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 ); 4000dbbc: 40 00 04 93 call 4000ee08 <_Objects_Free> <== NOT EXECUTED 4000dbc0: 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 ) 4000dbc4: 03 10 00 ac sethi %hi(0x4002b000), %g1 <== NOT EXECUTED 4000dbc8: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 4002b190 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4000dbcc: b0 10 20 00 clr %i0 <== NOT EXECUTED 4000dbd0: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 4000dbd4: c4 20 61 90 st %g2, [ %g1 + 0x190 ] <== NOT EXECUTED 4000dbd8: c6 00 61 90 ld [ %g1 + 0x190 ], %g3 <== NOT EXECUTED 4000dbdc: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4000dbe0: 02 80 00 09 be 4000dc04 <== NOT EXECUTED 4000dbe4: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000dbe8: 81 c7 e0 08 ret <== NOT EXECUTED 4000dbec: 81 e8 00 00 restore <== NOT EXECUTED { Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 4000dbf0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000dbf4: 08 bf ff fd bleu 4000dbe8 <== NOT EXECUTED 4000dbf8: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 4000dbfc: 81 c7 e0 08 ret <== NOT EXECUTED 4000dc00: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000dc04: 40 00 09 ec call 400103b4 <_Thread_Dispatch> <== NOT EXECUTED 4000dc08: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000dc0c: 81 c7 e0 08 ret <== NOT EXECUTED 4000dc10: 81 e8 00 00 restore <== NOT EXECUTED 400069f4 : */ void rtems_fatal_error_occurred( uint32_t the_error ) { 400069f4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error ); 400069f8: 92 10 20 00 clr %o1 <== NOT EXECUTED 400069fc: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 40006a00: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 40006a04: 40 00 03 31 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 40006a08: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 40006a0c: 01 00 00 00 nop 40006a10 : #include const char *rtems_get_version_string(void) { return _RTEMS_version; } 40006a10: 11 10 00 62 sethi %hi(0x40018800), %o0 <== NOT EXECUTED 40006a14: 81 c3 e0 08 retl <== NOT EXECUTED 40006a18: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 40018aa8 <_RTEMS_version> <== NOT EXECUTED 400067bc : rtems_interrupt_level rtems_initialize_executive_early( rtems_configuration_table *configuration_table, rtems_cpu_table *cpu_table ) { 400067bc: 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 ); 400067c0: 7f ff ed 86 call 40001dd8 400067c4: 01 00 00 00 nop 400067c8: a6 10 00 08 mov %o0, %l3 if ( configuration_table == NULL ) 400067cc: 80 a6 20 00 cmp %i0, 0 400067d0: 22 80 00 77 be,a 400069ac 400067d4: 90 10 20 00 clr %o0 <== NOT EXECUTED /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 400067d8: 05 10 00 66 sethi %hi(0x40019800), %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; 400067dc: 03 10 00 67 sethi %hi(0x40019c00), %g1 400067e0: a4 10 a3 24 or %g2, 0x324, %l2 400067e4: 94 10 20 28 mov 0x28, %o2 400067e8: 92 10 00 19 mov %i1, %o1 400067ec: c0 20 60 18 clr [ %g1 + 0x18 ] RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; 400067f0: 29 10 00 67 sethi %hi(0x40019c00), %l4 400067f4: 90 10 00 12 mov %l2, %o0 400067f8: 40 00 20 25 call 4000e88c 400067fc: c0 25 20 f0 clr [ %l4 + 0xf0 ] /* * Provided just for user convenience. */ _Configuration_Table = configuration_table; 40006800: 03 10 00 66 sethi %hi(0x40019800), %g1 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_NO_CPU_TABLE ); _CPU_Initialize( cpu_table, _Thread_Dispatch ); 40006804: 90 10 00 19 mov %i1, %o0 40006808: 13 10 00 24 sethi %hi(0x40009000), %o1 4000680c: 92 12 61 60 or %o1, 0x160, %o1 ! 40009160 <_Thread_Dispatch> 40006810: 40 00 11 80 call 4000ae10 <_CPU_Initialize> 40006814: f0 20 63 d0 st %i0, [ %g1 + 0x3d0 ] /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 40006818: 40 00 18 bd call 4000cb0c <_Debug_Manager_initialization> 4000681c: a2 10 20 01 mov 1, %l1 _API_extensions_Initialization(); 40006820: 40 00 00 dd call 40006b94 <_API_extensions_Initialization> 40006824: 01 00 00 00 nop _Thread_Dispatch_initialization(); _Workspace_Handler_initialization( 40006828: d2 06 20 04 ld [ %i0 + 4 ], %o1 4000682c: 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; 40006830: 03 10 00 66 sethi %hi(0x40019800), %g1 40006834: e2 20 63 10 st %l1, [ %g1 + 0x310 ] ! 40019b10 <_Thread_Dispatch_disable_level> 40006838: 40 00 10 48 call 4000a958 <_Workspace_Handler_initialization> 4000683c: 21 10 00 67 sethi %hi(0x40019c00), %l0 (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 40006840: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 40006844: 40 00 0e b9 call 4000a328 <_User_extensions_Handler_initialization> 40006848: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 4000684c: 40 00 03 af call 40007708 <_ISR_Handler_initialization> 40006850: 01 00 00 00 nop _Objects_Handler_initialization( 40006854: 90 10 20 01 mov 1, %o0 ! 1 40006858: 92 10 20 01 mov 1, %o1 4000685c: 40 00 05 b2 call 40007f24 <_Objects_Handler_initialization> 40006860: 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; 40006864: 05 10 00 66 sethi %hi(0x40019800), %g2 /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 40006868: 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; 4000686c: 03 10 00 66 sethi %hi(0x40019800), %g1 40006870: 82 10 63 50 or %g1, 0x350, %g1 ! 40019b50 <_Internal_Objects> /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 40006874: 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; 40006878: c2 20 a2 74 st %g1, [ %g2 + 0x274 ] /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 4000687c: 94 10 20 02 mov 2, %o2 40006880: 96 10 20 01 mov 1, %o3 40006884: 98 10 20 74 mov 0x74, %o4 40006888: 9a 10 20 00 clr %o5 4000688c: 40 00 05 34 call 40007d5c <_Objects_Initialize_information> 40006890: 90 14 20 1c or %l0, 0x1c, %o0 _API_Mutex_Allocate( _RTEMS_Allocator_Mutex ); 40006894: 82 10 20 02 mov 2, %g1 40006898: e2 27 bf e8 st %l1, [ %fp + -24 ] 4000689c: c2 27 bf f0 st %g1, [ %fp + -16 ] 400068a0: c0 27 bf ec clr [ %fp + -20 ] 400068a4: c0 27 bf f4 clr [ %fp + -12 ] 400068a8: 40 00 03 b5 call 4000777c <_Objects_Allocate> 400068ac: 90 14 20 1c or %l0, 0x1c, %o0 400068b0: 03 10 00 66 sethi %hi(0x40019800), %g1 400068b4: 84 10 00 08 mov %o0, %g2 400068b8: 92 07 bf e8 add %fp, -24, %o1 400068bc: c4 20 63 e4 st %g2, [ %g1 + 0x3e4 ] 400068c0: 90 02 20 10 add %o0, 0x10, %o0 400068c4: 40 00 01 21 call 40006d48 <_CORE_mutex_Initialize> 400068c8: 94 10 20 01 mov 1, %o2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 400068cc: 03 10 00 66 sethi %hi(0x40019800), %g1 for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 400068d0: 05 10 00 67 sethi %hi(0x40019c00), %g2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 400068d4: c0 30 63 e0 clrh [ %g1 + 0x3e0 ] for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 400068d8: c0 30 a0 70 clrh [ %g2 + 0x70 ] 400068dc: 82 10 20 02 mov 2, %g1 400068e0: 84 10 a0 70 or %g2, 0x70, %g2 400068e4: c0 30 40 02 clrh [ %g1 + %g2 ] 400068e8: 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++ ) 400068ec: 80 a0 60 20 cmp %g1, 0x20 400068f0: 32 bf ff fe bne,a 400068e8 400068f4: c0 30 40 02 clrh [ %g1 + %g2 ] _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 400068f8: 40 00 0f 98 call 4000a758 <_Watchdog_Handler_initialization> 400068fc: 01 00 00 00 nop _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 40006900: 40 00 02 0f call 4000713c <_TOD_Handler_initialization> 40006904: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _Thread_Handler_initialization( 40006908: d2 06 20 08 ld [ %i0 + 8 ], %o1 4000690c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 40006910: 40 00 0a db call 4000947c <_Thread_Handler_initialization> 40006914: 94 10 20 00 clr %o2 ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 40006918: 40 00 00 80 call 40006b18 <_RTEMS_API_Initialize> 4000691c: 90 10 00 18 mov %i0, %o0 _Extension_Manager_initialization( configuration_table->maximum_extensions ); 40006920: 40 00 00 28 call 400069c0 <_Extension_Manager_initialization> 40006924: d0 06 20 08 ld [ %i0 + 8 ], %o0 _IO_Manager_initialization( 40006928: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 4000692c: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 40006930: 40 00 00 4c call 40006a60 <_IO_Manager_initialization> 40006934: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 40006938: 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(); 4000693c: 40 00 09 b5 call 40009010 <_Thread_Create_idle> 40006940: c2 25 20 f0 st %g1, [ %l4 + 0xf0 ] /* * Scheduling can properly occur now as long as we avoid dispatching. */ if ( cpu_table->pretasking_hook ) 40006944: d0 06 40 00 ld [ %i1 ], %o0 40006948: 80 a2 20 00 cmp %o0, 0 4000694c: 02 80 00 04 be 4000695c 40006950: 01 00 00 00 nop (*cpu_table->pretasking_hook)(); 40006954: 9f c2 00 00 call %o0 40006958: 01 00 00 00 nop /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 4000695c: 40 00 00 b0 call 40006c1c <_API_extensions_Run_predriver> 40006960: 01 00 00 00 nop if ( _CPU_Table.predriver_hook ) 40006964: c2 04 a0 04 ld [ %l2 + 4 ], %g1 40006968: 80 a0 60 00 cmp %g1, 0 4000696c: 02 80 00 04 be 4000697c 40006970: 01 00 00 00 nop (*_CPU_Table.predriver_hook)(); 40006974: 9f c0 40 00 call %g1 <== NOT EXECUTED 40006978: 01 00 00 00 nop <== NOT EXECUTED * Initialize all the device drivers and initialize the MPCI layer. * * NOTE: The MPCI may be build upon a device driver. */ _IO_Initialize_all_drivers(); 4000697c: 40 00 00 28 call 40006a1c <_IO_Initialize_all_drivers> 40006980: 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(); 40006984: 40 00 00 8b call 40006bb0 <_API_extensions_Run_postdriver> 40006988: 01 00 00 00 nop if ( _CPU_Table.postdriver_hook ) 4000698c: c4 04 a0 08 ld [ %l2 + 8 ], %g2 40006990: 80 a0 a0 00 cmp %g2, 0 40006994: 02 80 00 04 be 400069a4 40006998: 01 00 00 00 nop (*_CPU_Table.postdriver_hook)(); 4000699c: 9f c0 80 00 call %g2 400069a0: 01 00 00 00 nop return bsp_level; } 400069a4: 81 c7 e0 08 ret 400069a8: 91 e8 00 13 restore %g0, %l3, %o0 */ _ISR_Disable( bsp_level ); if ( configuration_table == NULL ) _Internal_error_Occurred( 400069ac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 400069b0: 40 00 03 46 call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 400069b4: 94 10 20 00 clr %o2 <== NOT EXECUTED /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 400069b8: 10 bf ff 89 b 400067dc <== NOT EXECUTED 400069bc: 05 10 00 66 sethi %hi(0x40019800), %g2 <== NOT EXECUTED 40007b24 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 40007b24: 9d e3 bf 98 save %sp, -104, %sp /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 40007b28: 80 a6 60 00 cmp %i1, 0 40007b2c: 02 80 00 3e be 40007c24 40007b30: 90 10 00 18 mov %i0, %o0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 40007b34: 80 a6 a0 00 cmp %i2, 0 40007b38: 02 80 00 3b be 40007c24 40007b3c: 01 00 00 00 nop return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 40007b40: c2 06 40 00 ld [ %i1 ], %g1 40007b44: 80 a0 60 00 cmp %g1, 0 40007b48: 22 80 00 34 be,a 40007c18 40007b4c: c2 06 60 04 ld [ %i1 + 4 ], %g1 return RTEMS_INVALID_ADDRESS; *registered_major = 0; 40007b50: c0 26 80 00 clr [ %i2 ] /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 40007b54: 03 10 00 76 sethi %hi(0x4001d800), %g1 40007b58: c6 00 61 dc ld [ %g1 + 0x1dc ], %g3 ! 4001d9dc <_IO_Number_of_drivers> 40007b5c: 80 a0 c0 08 cmp %g3, %o0 40007b60: 08 80 00 43 bleu 40007c6c 40007b64: b0 10 20 0a mov 0xa, %i0 /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 40007b68: 80 a2 20 00 cmp %o0, 0 40007b6c: 12 80 00 1f bne 40007be8 40007b70: 03 10 00 76 sethi %hi(0x4001d800), %g1 boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 40007b74: 90 80 ff ff addcc %g3, -1, %o0 40007b78: 02 80 00 26 be 40007c10 40007b7c: c8 00 61 e0 ld [ %g1 + 0x1e0 ], %g4 if ( !_IO_Driver_address_table[major].initialization_entry && 40007b80: 85 28 e0 05 sll %g3, 5, %g2 40007b84: 83 28 e0 03 sll %g3, 3, %g1 40007b88: 84 20 80 01 sub %g2, %g1, %g2 40007b8c: 84 00 bf e8 add %g2, -24, %g2 40007b90: 10 80 00 04 b 40007ba0 40007b94: 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-- ) { 40007b98: 02 80 00 1e be 40007c10 40007b9c: 84 00 bf e8 add %g2, -24, %g2 if ( !_IO_Driver_address_table[major].initialization_entry && 40007ba0: c2 00 80 00 ld [ %g2 ], %g1 40007ba4: 80 a0 60 00 cmp %g1, 0 40007ba8: 32 bf ff fc bne,a 40007b98 40007bac: 90 82 3f ff addcc %o0, -1, %o0 40007bb0: c2 00 a0 04 ld [ %g2 + 4 ], %g1 40007bb4: 80 a0 60 00 cmp %g1, 0 40007bb8: 32 bf ff f8 bne,a 40007b98 40007bbc: 90 82 3f ff addcc %o0, -1, %o0 <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 40007bc0: 85 2a 20 03 sll %o0, 3, %g2 40007bc4: 83 2a 20 05 sll %o0, 5, %g1 40007bc8: 82 20 40 02 sub %g1, %g2, %g1 40007bcc: 88 01 00 01 add %g4, %g1, %g4 40007bd0: c2 01 20 04 ld [ %g4 + 4 ], %g1 40007bd4: 80 a0 60 00 cmp %g1, 0 40007bd8: 22 80 00 15 be,a 40007c2c 40007bdc: 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; 40007be0: 81 c7 e0 08 ret <== NOT EXECUTED 40007be4: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 40007be8: c8 00 61 e0 ld [ %g1 + 0x1e0 ], %g4 40007bec: 85 2a 20 03 sll %o0, 3, %g2 40007bf0: 83 2a 20 05 sll %o0, 5, %g1 40007bf4: 82 20 40 02 sub %g1, %g2, %g1 40007bf8: c6 00 40 04 ld [ %g1 + %g4 ], %g3 40007bfc: 80 a0 e0 00 cmp %g3, 0 40007c00: 02 bf ff f4 be 40007bd0 40007c04: 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; 40007c08: 81 c7 e0 08 ret 40007c0c: 91 e8 20 0c restore %g0, 0xc, %o0 40007c10: 81 c7 e0 08 ret 40007c14: 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 ) 40007c18: 80 a0 60 00 cmp %g1, 0 40007c1c: 32 bf ff ce bne,a 40007b54 40007c20: 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; 40007c24: 81 c7 e0 08 ret 40007c28: 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; 40007c2c: 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; 40007c30: c2 21 00 00 st %g1, [ %g4 ] 40007c34: c4 06 60 04 ld [ %i1 + 4 ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40007c38: 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; 40007c3c: c4 21 20 04 st %g2, [ %g4 + 4 ] 40007c40: c2 06 60 08 ld [ %i1 + 8 ], %g1 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40007c44: 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; 40007c48: c2 21 20 08 st %g1, [ %g4 + 8 ] 40007c4c: c4 06 60 0c ld [ %i1 + 0xc ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40007c50: 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; 40007c54: c4 21 20 0c st %g2, [ %g4 + 0xc ] 40007c58: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 40007c5c: c2 21 20 10 st %g1, [ %g4 + 0x10 ] 40007c60: c4 06 60 14 ld [ %i1 + 0x14 ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 40007c64: 7f ff ff 30 call 40007924 40007c68: c4 21 20 14 st %g2, [ %g4 + 0x14 ] 40007c6c: 81 c7 e0 08 ret 40007c70: 81 e8 00 00 restore 4000917c : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 4000917c: 9d e3 bf 98 save %sp, -104, %sp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 40009180: 80 a6 20 00 cmp %i0, 0 40009184: 02 80 00 23 be 40009210 40009188: 03 10 00 98 sethi %hi(0x40026000), %g1 return; 4000918c: a4 10 60 44 or %g1, 0x44, %l2 ! 40026044 <_Objects_Information_table+0x4> 40009190: 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 ] ) 40009194: c2 04 80 00 ld [ %l2 ], %g1 40009198: 80 a0 60 00 cmp %g1, 0 4000919c: 22 80 00 1a be,a 40009204 400091a0: a4 04 a0 04 add %l2, 4, %l2 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 400091a4: e2 00 60 04 ld [ %g1 + 4 ], %l1 if ( information ) { 400091a8: 80 a4 60 00 cmp %l1, 0 400091ac: 22 80 00 16 be,a 40009204 400091b0: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 400091b4: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 400091b8: 86 90 60 00 orcc %g1, 0, %g3 400091bc: 22 80 00 12 be,a 40009204 400091c0: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED 400091c4: a0 10 20 01 mov 1, %l0 the_thread = (Thread_Control *)information->local_table[ i ]; 400091c8: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 400091cc: 83 2c 20 02 sll %l0, 2, %g1 400091d0: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( !the_thread ) 400091d4: 80 a2 20 00 cmp %o0, 0 400091d8: 02 80 00 05 be 400091ec 400091dc: a0 04 20 01 inc %l0 continue; (*routine)(the_thread); 400091e0: 9f c6 00 00 call %i0 400091e4: 01 00 00 00 nop 400091e8: 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++ ) { 400091ec: 83 28 e0 10 sll %g3, 0x10, %g1 400091f0: 83 30 60 10 srl %g1, 0x10, %g1 400091f4: 80 a0 40 10 cmp %g1, %l0 400091f8: 3a bf ff f5 bcc,a 400091cc 400091fc: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 40009200: a4 04 a0 04 add %l2, 4, %l2 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 40009204: 80 a4 80 13 cmp %l2, %l3 40009208: 32 bf ff e4 bne,a 40009198 4000920c: c2 04 80 00 ld [ %l2 ], %g1 40009210: 81 c7 e0 08 ret 40009214: 81 e8 00 00 restore 4000ef70 : Objects_Id id, void *buffer, size_t size, uint32_t *count ) { 4000ef70: 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 ) 4000ef74: 80 a6 60 00 cmp %i1, 0 4000ef78: 02 80 00 28 be 4000f018 4000ef7c: 80 a6 e0 00 cmp %i3, 0 return RTEMS_INVALID_ADDRESS; if ( !count ) 4000ef80: 02 80 00 26 be 4000f018 4000ef84: 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 *) 4000ef88: 11 10 00 ce sethi %hi(0x40033800), %o0 4000ef8c: 90 12 20 00 mov %o0, %o0 ! 40033800 <_Message_queue_Information> 4000ef90: 40 00 19 5e call 40015508 <_Objects_Get> 4000ef94: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 4000ef98: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000ef9c: 80 a0 60 00 cmp %g1, 0 4000efa0: 02 80 00 08 be 4000efc0 4000efa4: 9a 10 00 1b mov %i3, %o5 4000efa8: 80 a0 60 02 cmp %g1, 2 4000efac: 08 80 00 03 bleu 4000efb8 4000efb0: 90 10 20 04 mov 4, %o0 4000efb4: 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 */ } 4000efb8: 81 c7 e0 08 ret 4000efbc: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 4000efc0: 92 10 00 19 mov %i1, %o1 4000efc4: 94 10 00 1a mov %i2, %o2 4000efc8: 96 10 00 18 mov %i0, %o3 4000efcc: 98 10 20 00 clr %o4 4000efd0: 40 00 13 d2 call 40013f18 <_CORE_message_queue_Broadcast> 4000efd4: 90 02 20 14 add %o0, 0x14, %o0 4000efd8: 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 ) 4000efdc: 03 10 00 cd sethi %hi(0x40033400), %g1 4000efe0: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 4000efe4: 84 00 bf ff add %g2, -1, %g2 4000efe8: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 4000efec: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 4000eff0: 80 a0 e0 00 cmp %g3, 0 4000eff4: 02 80 00 06 be 4000f00c 4000eff8: 01 00 00 00 nop #endif count ); _Thread_Enable_dispatch(); return 4000effc: 40 00 01 35 call 4000f4d0 <_Message_queue_Translate_core_message_queue_return_code> 4000f000: 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 */ } 4000f004: 81 c7 e0 08 ret 4000f008: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 4000f00c: 40 00 1e 67 call 400169a8 <_Thread_Dispatch> 4000f010: 01 00 00 00 nop 4000f014: 30 bf ff fa b,a 4000effc #endif count ); _Thread_Enable_dispatch(); return 4000f018: 10 bf ff e8 b 4000efb8 <== NOT EXECUTED 4000f01c: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED 4000f020 : uint32_t count, uint32_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 4000f020: 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 ) ) 4000f024: a4 96 20 00 orcc %i0, 0, %l2 4000f028: 02 80 00 1f be 4000f0a4 4000f02c: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 4000f030: 80 a7 20 00 cmp %i4, 0 4000f034: 02 80 00 1c be 4000f0a4 4000f038: 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 ) 4000f03c: 80 a6 60 00 cmp %i1, 0 4000f040: 02 80 00 19 be 4000f0a4 4000f044: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 4000f048: 80 a6 a0 00 cmp %i2, 0 4000f04c: 02 80 00 16 be 4000f0a4 4000f050: b0 10 20 08 mov 8, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000f054: 23 10 00 cd sethi %hi(0x40033400), %l1 4000f058: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 4000f05c: 82 00 60 01 inc %g1 4000f060: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate( count, max_message_size ); 4000f064: 90 10 00 19 mov %i1, %o0 4000f068: 40 00 2d 2f call 4001a524 <_Message_queue_Allocate> 4000f06c: 92 10 00 1a mov %i2, %o1 if ( !the_message_queue ) { 4000f070: a0 92 20 00 orcc %o0, 0, %l0 4000f074: 12 80 00 0e bne 4000f0ac 4000f078: 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 ) 4000f07c: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 4000f080: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 4000f084: 82 00 7f ff add %g1, -1, %g1 4000f088: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] 4000f08c: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 4000f090: 80 a0 a0 00 cmp %g2, 0 4000f094: 12 80 00 33 bne 4000f160 4000f098: 01 00 00 00 nop 4000f09c: 40 00 1e 43 call 400169a8 <_Thread_Dispatch> 4000f0a0: 01 00 00 00 nop 4000f0a4: 81 c7 e0 08 ret 4000f0a8: 81 e8 00 00 restore } #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) 4000f0ac: 12 80 00 11 bne 4000f0f0 4000f0b0: 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; 4000f0b4: c0 27 bf f4 clr [ %fp + -12 ] if ( ! _CORE_message_queue_Initialize( 4000f0b8: 94 10 00 19 mov %i1, %o2 4000f0bc: 96 10 00 1a mov %i2, %o3 4000f0c0: 90 04 20 14 add %l0, 0x14, %o0 4000f0c4: 40 00 13 e2 call 4001404c <_CORE_message_queue_Initialize> 4000f0c8: 92 07 bf f4 add %fp, -12, %o1 4000f0cc: 80 a2 20 00 cmp %o0, 0 4000f0d0: 12 80 00 0b bne 4000f0fc 4000f0d4: 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 ); 4000f0d8: 11 10 00 ce sethi %hi(0x40033800), %o0 <== NOT EXECUTED 4000f0dc: 40 00 18 b4 call 400153ac <_Objects_Free> <== NOT EXECUTED 4000f0e0: 90 12 20 00 mov %o0, %o0 ! 40033800 <_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 ) 4000f0e4: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 4000f0e8: 10 bf ff e7 b 4000f084 <== NOT EXECUTED 4000f0ec: 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; 4000f0f0: 82 10 20 01 mov 1, %g1 4000f0f4: 10 bf ff f1 b 4000f0b8 4000f0f8: c2 27 bf f4 st %g1, [ %fp + -12 ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f0fc: 03 10 00 ce sethi %hi(0x40033800), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000f100: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f104: 88 10 60 00 mov %g1, %g4 4000f108: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 4000f10c: 03 00 00 3f sethi %hi(0xfc00), %g1 4000f110: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000f114: 82 08 c0 01 and %g3, %g1, %g1 4000f118: 80 a0 40 02 cmp %g1, %g2 4000f11c: 38 80 00 06 bgu,a 4000f134 4000f120: e4 24 20 0c st %l2, [ %l0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000f124: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 4000f128: 83 28 60 02 sll %g1, 2, %g1 4000f12c: 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; 4000f130: e4 24 20 0c st %l2, [ %l0 + 0xc ] &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 4000f134: c6 27 00 00 st %g3, [ %i4 ] 4000f138: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 4000f13c: b0 10 20 00 clr %i0 4000f140: 82 00 7f ff add %g1, -1, %g1 4000f144: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] 4000f148: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 4000f14c: 80 a0 a0 00 cmp %g2, 0 4000f150: 12 80 00 04 bne 4000f160 4000f154: 01 00 00 00 nop _Thread_Dispatch(); 4000f158: 40 00 1e 14 call 400169a8 <_Thread_Dispatch> 4000f15c: 01 00 00 00 nop ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 4000f160: 81 c7 e0 08 ret 4000f164: 81 e8 00 00 restore 40015ab0 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 40015ab0: 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 *) 40015ab4: 21 10 00 ad sethi %hi(0x4002b400), %l0 40015ab8: 92 10 00 18 mov %i0, %o1 40015abc: 94 07 bf f4 add %fp, -12, %o2 40015ac0: 7f ff e5 15 call 4000ef14 <_Objects_Get> 40015ac4: 90 14 21 2c or %l0, 0x12c, %o0 register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 40015ac8: c2 07 bf f4 ld [ %fp + -12 ], %g1 40015acc: 80 a0 60 00 cmp %g1, 0 40015ad0: 12 80 00 20 bne 40015b50 40015ad4: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40015ad8: 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 ); 40015adc: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40015ae0: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 40015ae4: 05 00 00 3f sethi %hi(0xfc00), %g2 40015ae8: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40015aec: 82 08 40 02 and %g1, %g2, %g1 40015af0: 80 a0 40 03 cmp %g1, %g3 40015af4: 18 80 00 05 bgu 40015b08 40015af8: 94 10 20 05 mov 5, %o2 information->local_table[ index ] = the_object; 40015afc: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 40015b00: 83 28 60 02 sll %g1, 2, %g1 40015b04: c0 20 80 01 clr [ %g2 + %g1 ] case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, &the_message_queue->Object ); _CORE_message_queue_Close( 40015b08: 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; 40015b0c: c0 26 20 0c clr [ %i0 + 0xc ] 40015b10: 40 00 01 c0 call 40016210 <_CORE_message_queue_Close> 40015b14: 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 ); 40015b18: 90 10 00 10 mov %l0, %o0 40015b1c: 7f ff e4 bb call 4000ee08 <_Objects_Free> 40015b20: 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 ) 40015b24: 03 10 00 ac sethi %hi(0x4002b000), %g1 40015b28: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 4002b190 <_Thread_Dispatch_disable_level> 40015b2c: b0 10 20 00 clr %i0 40015b30: 84 00 bf ff add %g2, -1, %g2 40015b34: c4 20 61 90 st %g2, [ %g1 + 0x190 ] 40015b38: c6 00 61 90 ld [ %g1 + 0x190 ], %g3 40015b3c: 80 a0 e0 00 cmp %g3, 0 40015b40: 02 80 00 09 be 40015b64 40015b44: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40015b48: 81 c7 e0 08 ret 40015b4c: 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 ) { 40015b50: 80 a0 60 02 cmp %g1, 2 40015b54: 08 bf ff fd bleu 40015b48 40015b58: b0 10 20 04 mov 4, %i0 40015b5c: 81 c7 e0 08 ret <== NOT EXECUTED 40015b60: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40015b64: 7f ff ea 14 call 400103b4 <_Thread_Dispatch> 40015b68: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40015b6c: 81 c7 e0 08 ret 40015b70: 81 e8 00 00 restore 4000f22c : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 4000f22c: 9d e3 bf 90 save %sp, -112, %sp 4000f230: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 4000f234: 80 a6 60 00 cmp %i1, 0 4000f238: 02 80 00 1c be 4000f2a8 4000f23c: 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 *) 4000f240: 11 10 00 ce sethi %hi(0x40033800), %o0 4000f244: 94 07 bf f4 add %fp, -12, %o2 4000f248: 40 00 18 b0 call 40015508 <_Objects_Get> 4000f24c: 90 12 20 00 mov %o0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 4000f250: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f254: 80 a0 60 00 cmp %g1, 0 4000f258: 02 80 00 06 be 4000f270 4000f25c: 80 a0 60 02 cmp %g1, 2 4000f260: 08 80 00 12 bleu 4000f2a8 4000f264: b0 10 20 04 mov 4, %i0 4000f268: 81 c7 e0 08 ret <== NOT EXECUTED 4000f26c: 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 ); 4000f270: 40 00 13 57 call 40013fcc <_CORE_message_queue_Flush> 4000f274: 90 02 20 14 add %o0, 0x14, %o0 4000f278: 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 ) 4000f27c: 03 10 00 cd sethi %hi(0x40033400), %g1 4000f280: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 4000f284: b0 10 20 00 clr %i0 4000f288: 84 00 bf ff add %g2, -1, %g2 4000f28c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 4000f290: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 4000f294: 80 a0 e0 00 cmp %g3, 0 4000f298: 12 80 00 04 bne 4000f2a8 4000f29c: 01 00 00 00 nop _Thread_Dispatch(); 4000f2a0: 40 00 1d c2 call 400169a8 <_Thread_Dispatch> 4000f2a4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f2a8: 81 c7 e0 08 ret 4000f2ac: 81 e8 00 00 restore 4000f2b0 : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 4000f2b0: 9d e3 bf 90 save %sp, -112, %sp 4000f2b4: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 4000f2b8: 80 a6 60 00 cmp %i1, 0 4000f2bc: 02 80 00 1b be 4000f328 4000f2c0: b0 10 20 09 mov 9, %i0 4000f2c4: 11 10 00 ce sethi %hi(0x40033800), %o0 4000f2c8: 94 07 bf f4 add %fp, -12, %o2 4000f2cc: 40 00 18 8f call 40015508 <_Objects_Get> 4000f2d0: 90 12 20 00 mov %o0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 4000f2d4: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f2d8: 80 a0 60 00 cmp %g1, 0 4000f2dc: 22 80 00 07 be,a 4000f2f8 4000f2e0: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 4000f2e4: 80 a0 60 02 cmp %g1, 2 4000f2e8: 08 80 00 10 bleu 4000f328 4000f2ec: b0 10 20 04 mov 4, %i0 4000f2f0: 81 c7 e0 08 ret <== NOT EXECUTED 4000f2f4: 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; 4000f2f8: 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 ) 4000f2fc: 07 10 00 cd sethi %hi(0x40033400), %g3 4000f300: c2 00 e0 e0 ld [ %g3 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 4000f304: b0 10 20 00 clr %i0 4000f308: 82 00 7f ff add %g1, -1, %g1 4000f30c: c2 20 e0 e0 st %g1, [ %g3 + 0xe0 ] 4000f310: c4 00 e0 e0 ld [ %g3 + 0xe0 ], %g2 4000f314: 80 a0 a0 00 cmp %g2, 0 4000f318: 12 80 00 04 bne 4000f328 4000f31c: 01 00 00 00 nop _Thread_Dispatch(); 4000f320: 40 00 1d a2 call 400169a8 <_Thread_Dispatch> 4000f324: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f328: 81 c7 e0 08 ret 4000f32c: 81 e8 00 00 restore 40015ba8 : void *buffer, size_t *size, uint32_t option_set, rtems_interval timeout ) { 40015ba8: 9d e3 bf 90 save %sp, -112, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; boolean wait; if ( !buffer ) 40015bac: 80 a6 60 00 cmp %i1, 0 40015bb0: 02 80 00 2b be 40015c5c 40015bb4: 92 10 00 18 mov %i0, %o1 return RTEMS_INVALID_ADDRESS; if ( !size ) 40015bb8: 80 a6 a0 00 cmp %i2, 0 40015bbc: 02 80 00 28 be 40015c5c 40015bc0: 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 *) 40015bc4: 11 10 00 ad sethi %hi(0x4002b400), %o0 40015bc8: 7f ff e4 d3 call 4000ef14 <_Objects_Get> 40015bcc: 90 12 21 2c or %o0, 0x12c, %o0 ! 4002b52c <_Message_queue_Information> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 40015bd0: c2 07 bf f4 ld [ %fp + -12 ], %g1 40015bd4: 80 a0 60 00 cmp %g1, 0 40015bd8: 22 80 00 08 be,a 40015bf8 40015bdc: d2 02 20 08 ld [ %o0 + 8 ], %o1 40015be0: 80 a0 60 02 cmp %g1, 2 40015be4: 08 80 00 03 bleu 40015bf0 40015be8: 90 10 20 04 mov 4, %o0 40015bec: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40015bf0: 81 c7 e0 08 ret 40015bf4: 91 e8 00 08 restore %g0, %o0, %o0 40015bf8: 98 0e e0 01 and %i3, 1, %o4 if ( _Options_Is_no_wait( option_set ) ) wait = FALSE; else wait = TRUE; _CORE_message_queue_Seize( 40015bfc: 94 10 00 19 mov %i1, %o2 40015c00: 96 10 00 1a mov %i2, %o3 40015c04: 98 1b 20 01 xor %o4, 1, %o4 40015c08: 9a 10 00 1c mov %i4, %o5 40015c0c: 40 00 01 a7 call 400162a8 <_CORE_message_queue_Seize> 40015c10: 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 ) 40015c14: 05 10 00 ac sethi %hi(0x4002b000), %g2 40015c18: c2 00 a1 90 ld [ %g2 + 0x190 ], %g1 ! 4002b190 <_Thread_Dispatch_disable_level> 40015c1c: 82 00 7f ff add %g1, -1, %g1 40015c20: c2 20 a1 90 st %g1, [ %g2 + 0x190 ] 40015c24: c6 00 a1 90 ld [ %g2 + 0x190 ], %g3 40015c28: 80 a0 e0 00 cmp %g3, 0 40015c2c: 02 80 00 08 be 40015c4c 40015c30: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 40015c34: 03 10 00 ac sethi %hi(0x4002b000), %g1 <== NOT EXECUTED 40015c38: c4 00 62 6c ld [ %g1 + 0x26c ], %g2 ! 4002b26c <_Thread_Executing> 40015c3c: 40 00 00 36 call 40015d14 <_Message_queue_Translate_core_message_queue_return_code> 40015c40: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40015c44: 81 c7 e0 08 ret 40015c48: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40015c4c: 7f ff e9 da call 400103b4 <_Thread_Dispatch> 40015c50: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 40015c54: 10 bf ff f9 b 40015c38 40015c58: 03 10 00 ac sethi %hi(0x4002b000), %g1 40015c5c: 10 bf ff e5 b 40015bf0 <== NOT EXECUTED 40015c60: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED 40015c64 : rtems_status_code rtems_message_queue_send( Objects_Id id, void *buffer, size_t size ) { 40015c64: 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 ) 40015c68: 80 a6 60 00 cmp %i1, 0 40015c6c: 02 80 00 20 be 40015cec 40015c70: 90 10 20 09 mov 9, %o0 40015c74: 11 10 00 ad sethi %hi(0x4002b400), %o0 40015c78: 92 10 00 18 mov %i0, %o1 40015c7c: 90 12 21 2c or %o0, 0x12c, %o0 40015c80: 7f ff e4 a5 call 4000ef14 <_Objects_Get> 40015c84: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 40015c88: c2 07 bf f4 ld [ %fp + -12 ], %g1 40015c8c: 80 a0 60 00 cmp %g1, 0 40015c90: 12 80 00 19 bne 40015cf4 40015c94: 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( 40015c98: 94 10 00 1a mov %i2, %o2 40015c9c: c0 23 a0 5c clr [ %sp + 0x5c ] 40015ca0: c0 23 a0 60 clr [ %sp + 0x60 ] 40015ca4: 92 10 00 19 mov %i1, %o1 40015ca8: 96 10 00 18 mov %i0, %o3 40015cac: 98 10 20 00 clr %o4 40015cb0: 90 02 20 14 add %o0, 0x14, %o0 40015cb4: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5 40015cb8: 40 00 01 c3 call 400163c4 <_CORE_message_queue_Submit> 40015cbc: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff 40015cc0: 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 ) 40015cc4: 05 10 00 ac sethi %hi(0x4002b000), %g2 40015cc8: c2 00 a1 90 ld [ %g2 + 0x190 ], %g1 ! 4002b190 <_Thread_Dispatch_disable_level> 40015ccc: 82 00 7f ff add %g1, -1, %g1 40015cd0: c2 20 a1 90 st %g1, [ %g2 + 0x190 ] 40015cd4: c6 00 a1 90 ld [ %g2 + 0x190 ], %g3 40015cd8: 80 a0 e0 00 cmp %g3, 0 40015cdc: 02 80 00 0b be 40015d08 40015ce0: 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); 40015ce4: 40 00 00 0c call 40015d14 <_Message_queue_Translate_core_message_queue_return_code> 40015ce8: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40015cec: 81 c7 e0 08 ret 40015cf0: 91 e8 00 08 restore %g0, %o0, %o0 if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 40015cf4: 08 bf ff fe bleu 40015cec 40015cf8: 90 10 20 04 mov 4, %o0 40015cfc: 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 */ } 40015d00: 81 c7 e0 08 ret <== NOT EXECUTED 40015d04: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40015d08: 7f ff e9 ab call 400103b4 <_Thread_Dispatch> 40015d0c: 01 00 00 00 nop 40015d10: 30 bf ff f5 b,a 40015ce4 40008870 : rtems_status_code rtems_message_queue_urgent( Objects_Id id, void *buffer, size_t size ) { 40008870: 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 ) 40008874: 80 a6 60 00 cmp %i1, 0 40008878: 02 80 00 1f be 400088f4 4000887c: 90 10 20 09 mov 9, %o0 40008880: 11 10 00 85 sethi %hi(0x40021400), %o0 40008884: 92 10 00 18 mov %i0, %o1 40008888: 90 12 23 38 or %o0, 0x338, %o0 4000888c: 40 00 0a 21 call 4000b110 <_Objects_Get> 40008890: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 40008894: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008898: 80 a0 60 00 cmp %g1, 0 4000889c: 12 80 00 18 bne 400088fc 400088a0: 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( 400088a4: 94 10 00 1a mov %i2, %o2 400088a8: c0 23 a0 5c clr [ %sp + 0x5c ] 400088ac: c0 23 a0 60 clr [ %sp + 0x60 ] 400088b0: 92 10 00 19 mov %i1, %o1 400088b4: 96 10 00 18 mov %i0, %o3 400088b8: 98 10 20 00 clr %o4 400088bc: 1b 20 00 00 sethi %hi(0x80000000), %o5 400088c0: 40 00 05 e8 call 4000a060 <_CORE_message_queue_Submit> 400088c4: 90 02 20 14 add %o0, 0x14, %o0 400088c8: 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 ) 400088cc: 03 10 00 85 sethi %hi(0x40021400), %g1 400088d0: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 ! 40021420 <_Thread_Dispatch_disable_level> 400088d4: 84 00 bf ff add %g2, -1, %g2 400088d8: c4 20 60 20 st %g2, [ %g1 + 0x20 ] 400088dc: c6 00 60 20 ld [ %g1 + 0x20 ], %g3 400088e0: 80 a0 e0 00 cmp %g3, 0 400088e4: 02 80 00 0b be 40008910 400088e8: 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); 400088ec: 7f ff ff d7 call 40008848 <_Message_queue_Translate_core_message_queue_return_code> 400088f0: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400088f4: 81 c7 e0 08 ret 400088f8: 91 e8 00 08 restore %g0, %o0, %o0 if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 400088fc: 08 bf ff fe bleu 400088f4 <== NOT EXECUTED 40008900: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED 40008904: 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 */ } 40008908: 81 c7 e0 08 ret <== NOT EXECUTED 4000890c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 40008910: 40 00 0f 28 call 4000c5b0 <_Thread_Dispatch> 40008914: 01 00 00 00 nop 40008918: 30 bf ff f5 b,a 400088ec 4000f4f8 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 4000f4f8: 9d e3 bf 98 save %sp, -104, %sp register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 4000f4fc: a8 96 20 00 orcc %i0, 0, %l4 4000f500: 02 80 00 29 be 4000f5a4 4000f504: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 4000f508: 80 a6 60 00 cmp %i1, 0 4000f50c: 02 80 00 11 be 4000f550 4000f510: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 4000f514: 02 80 00 0f be 4000f550 4000f518: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 4000f51c: 12 80 00 04 bne 4000f52c 4000f520: 80 a6 e0 00 cmp %i3, 0 ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 4000f524: 81 c7 e0 08 ret 4000f528: 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 || 4000f52c: 02 80 00 1e be 4000f5a4 4000f530: b0 10 20 08 mov 8, %i0 4000f534: 80 a6 80 1b cmp %i2, %i3 4000f538: 0a 80 00 1b bcs 4000f5a4 4000f53c: 80 8e e0 07 btst 7, %i3 4000f540: 12 80 00 19 bne 4000f5a4 4000f544: 80 8e 60 07 btst 7, %i1 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 4000f548: 02 80 00 04 be 4000f558 4000f54c: 25 10 00 cd sethi %hi(0x40033400), %l2 4000f550: 81 c7 e0 08 ret 4000f554: 91 e8 20 09 restore %g0, 9, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000f558: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 4000f55c: 82 00 60 01 inc %g1 4000f560: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 4000f564: 27 10 00 cc sethi %hi(0x40033000), %l3 4000f568: 40 00 16 83 call 40014f74 <_Objects_Allocate> 4000f56c: 90 14 e2 60 or %l3, 0x260, %o0 ! 40033260 <_Partition_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 4000f570: a2 92 20 00 orcc %o0, 0, %l1 4000f574: 12 80 00 0e bne 4000f5ac 4000f578: 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 ) 4000f57c: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 4000f580: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 4000f584: 82 00 7f ff add %g1, -1, %g1 4000f588: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] 4000f58c: c4 04 a0 e0 ld [ %l2 + 0xe0 ], %g2 4000f590: 80 a0 a0 00 cmp %g2, 0 4000f594: 12 80 00 04 bne 4000f5a4 4000f598: 01 00 00 00 nop 4000f59c: 40 00 1d 03 call 400169a8 <_Thread_Dispatch> 4000f5a0: 01 00 00 00 nop 4000f5a4: 81 c7 e0 08 ret 4000f5a8: 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; 4000f5ac: f8 24 60 1c st %i4, [ %l1 + 0x1c ] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 4000f5b0: f2 24 60 10 st %i1, [ %l1 + 0x10 ] the_partition->length = length; 4000f5b4: f4 24 60 14 st %i2, [ %l1 + 0x14 ] the_partition->buffer_size = buffer_size; 4000f5b8: f6 24 60 18 st %i3, [ %l1 + 0x18 ] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 4000f5bc: c0 24 60 20 clr [ %l1 + 0x20 ] _Chain_Initialize( &the_partition->Memory, starting_address, 4000f5c0: 40 00 55 1e call 40024a38 <.udiv> 4000f5c4: 90 10 00 1a mov %i2, %o0 4000f5c8: a0 04 60 24 add %l1, 0x24, %l0 4000f5cc: 94 10 00 08 mov %o0, %o2 4000f5d0: 92 10 00 19 mov %i1, %o1 4000f5d4: 90 10 00 10 mov %l0, %o0 4000f5d8: 40 00 12 38 call 40013eb8 <_Chain_Initialize> 4000f5dc: 96 10 00 1b mov %i3, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f5e0: 90 14 e2 60 or %l3, 0x260, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 4000f5e4: c6 04 60 08 ld [ %l1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f5e8: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 4000f5ec: 03 00 00 3f sethi %hi(0xfc00), %g1 4000f5f0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 4000f5f4: 82 08 c0 01 and %g3, %g1, %g1 4000f5f8: 80 a0 40 02 cmp %g1, %g2 4000f5fc: 38 80 00 06 bgu,a 4000f614 4000f600: e8 24 60 0c st %l4, [ %l1 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000f604: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000f608: 83 28 60 02 sll %g1, 2, %g1 4000f60c: 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; 4000f610: e8 24 60 0c st %l4, [ %l1 + 0xc ] &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 4000f614: 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 ) 4000f618: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 4000f61c: 10 bf ff da b 4000f584 4000f620: b0 10 20 00 clr %i0 4000f624 : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 4000f624: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 4000f628: 92 10 00 18 mov %i0, %o1 4000f62c: 94 07 bf f4 add %fp, -12, %o2 4000f630: 31 10 00 cc sethi %hi(0x40033000), %i0 4000f634: 40 00 17 b5 call 40015508 <_Objects_Get> 4000f638: 90 16 22 60 or %i0, 0x260, %o0 ! 40033260 <_Partition_Information> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000f63c: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f640: 80 a0 60 00 cmp %g1, 0 4000f644: 12 80 00 13 bne 4000f690 4000f648: 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 ) { 4000f64c: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 4000f650: 80 a0 60 00 cmp %g1, 0 4000f654: 02 80 00 14 be 4000f6a4 4000f658: 90 16 22 60 or %i0, 0x260, %o0 4000f65c: 03 10 00 cd sethi %hi(0x40033400), %g1 4000f660: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 4000f664: b0 10 20 0c mov 0xc, %i0 4000f668: 84 00 bf ff add %g2, -1, %g2 4000f66c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 4000f670: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 4000f674: 80 a0 e0 00 cmp %g3, 0 4000f678: 12 80 00 22 bne 4000f700 4000f67c: 01 00 00 00 nop _Thread_Dispatch(); 4000f680: 40 00 1c ca call 400169a8 <_Thread_Dispatch> 4000f684: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f688: 81 c7 e0 08 ret 4000f68c: 81 e8 00 00 restore { register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000f690: 80 a0 60 02 cmp %g1, 2 4000f694: 08 bf ff fd bleu 4000f688 4000f698: b0 10 20 04 mov 4, %i0 4000f69c: 81 c7 e0 08 ret <== NOT EXECUTED 4000f6a0: 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 ); 4000f6a4: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000f6a8: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4000f6ac: 05 00 00 3f sethi %hi(0xfc00), %g2 4000f6b0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000f6b4: 82 08 40 02 and %g1, %g2, %g1 4000f6b8: 80 a0 40 03 cmp %g1, %g3 4000f6bc: 18 80 00 04 bgu 4000f6cc 4000f6c0: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 4000f6c4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000f6c8: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Partition_Free ( Partition_Control *the_partition ) { _Objects_Free( &_Partition_Information, &the_partition->Object ); 4000f6cc: 40 00 17 38 call 400153ac <_Objects_Free> 4000f6d0: 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 ) 4000f6d4: 03 10 00 cd sethi %hi(0x40033400), %g1 4000f6d8: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 4000f6dc: b0 10 20 00 clr %i0 4000f6e0: 84 00 bf ff add %g2, -1, %g2 4000f6e4: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 4000f6e8: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 4000f6ec: 80 a0 e0 00 cmp %g3, 0 4000f6f0: 12 80 00 04 bne 4000f700 4000f6f4: 01 00 00 00 nop _Thread_Dispatch(); 4000f6f8: 40 00 1c ac call 400169a8 <_Thread_Dispatch> 4000f6fc: 01 00 00 00 nop 4000f700: 81 c7 e0 08 ret 4000f704: 81 e8 00 00 restore 4000f708 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 4000f708: 9d e3 bf 90 save %sp, -112, %sp 4000f70c: 92 10 00 18 mov %i0, %o1 register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 4000f710: 80 a6 60 00 cmp %i1, 0 4000f714: 02 80 00 1a be 4000f77c 4000f718: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 4000f71c: 11 10 00 cc sethi %hi(0x40033000), %o0 4000f720: 94 07 bf f4 add %fp, -12, %o2 4000f724: 40 00 17 79 call 40015508 <_Objects_Get> 4000f728: 90 12 22 60 or %o0, 0x260, %o0 return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000f72c: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f730: 80 a0 60 00 cmp %g1, 0 4000f734: 12 80 00 14 bne 4000f784 4000f738: b0 10 00 08 mov %o0, %i0 RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 4000f73c: 40 00 11 cc call 40013e6c <_Chain_Get> 4000f740: 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 ) { 4000f744: a0 92 20 00 orcc %o0, 0, %l0 4000f748: 32 80 00 14 bne,a 4000f798 4000f74c: 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 ) 4000f750: 03 10 00 cd sethi %hi(0x40033400), %g1 4000f754: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 4000f758: b0 10 20 0d mov 0xd, %i0 4000f75c: 84 00 bf ff add %g2, -1, %g2 4000f760: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 4000f764: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 4000f768: 80 a0 e0 00 cmp %g3, 0 4000f76c: 12 80 00 04 bne 4000f77c 4000f770: 01 00 00 00 nop _Thread_Dispatch(); 4000f774: 40 00 1c 8d call 400169a8 <_Thread_Dispatch> 4000f778: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_UNSATISFIED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f77c: 81 c7 e0 08 ret 4000f780: 81 e8 00 00 restore if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000f784: 80 a0 60 02 cmp %g1, 2 4000f788: 08 bf ff fd bleu 4000f77c 4000f78c: b0 10 20 04 mov 4, %i0 4000f790: 81 c7 e0 08 ret <== NOT EXECUTED 4000f794: 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; 4000f798: 82 00 60 01 inc %g1 4000f79c: 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 ) 4000f7a0: 05 10 00 cd sethi %hi(0x40033400), %g2 4000f7a4: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 4000f7a8: 82 00 7f ff add %g1, -1, %g1 4000f7ac: c2 20 a0 e0 st %g1, [ %g2 + 0xe0 ] 4000f7b0: c6 00 a0 e0 ld [ %g2 + 0xe0 ], %g3 4000f7b4: 80 a0 e0 00 cmp %g3, 0 4000f7b8: 02 80 00 05 be 4000f7cc 4000f7bc: 01 00 00 00 nop _Thread_Enable_dispatch(); *buffer = the_buffer; 4000f7c0: e0 26 40 00 st %l0, [ %i1 ] <== NOT EXECUTED 4000f7c4: 81 c7 e0 08 ret 4000f7c8: 91 e8 20 00 restore %g0, 0, %o0 _Thread_Dispatch(); 4000f7cc: 40 00 1c 77 call 400169a8 <_Thread_Dispatch> 4000f7d0: 01 00 00 00 nop 4000f7d4: 10 bf ff fc b 4000f7c4 4000f7d8: e0 26 40 00 st %l0, [ %i1 ] 4000f810 : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 4000f810: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 4000f814: 11 10 00 cc sethi %hi(0x40033000), %o0 4000f818: 92 10 00 18 mov %i0, %o1 4000f81c: 90 12 22 60 or %o0, 0x260, %o0 4000f820: 40 00 17 3a call 40015508 <_Objects_Get> 4000f824: 94 07 bf f4 add %fp, -12, %o2 register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 4000f828: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000f82c: 80 a0 60 00 cmp %g1, 0 4000f830: 12 80 00 12 bne 4000f878 4000f834: b0 10 00 08 mov %o0, %i0 ) { void *starting; void *ending; starting = the_partition->starting_address; 4000f838: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( 4000f83c: 80 a0 80 19 cmp %g2, %i1 4000f840: 28 80 00 13 bleu,a 4000f88c 4000f844: 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 ) 4000f848: 03 10 00 cd sethi %hi(0x40033400), %g1 4000f84c: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 4000f850: 84 00 bf ff add %g2, -1, %g2 4000f854: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 4000f858: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 4000f85c: 80 a0 e0 00 cmp %g3, 0 4000f860: 12 80 00 27 bne 4000f8fc 4000f864: 01 00 00 00 nop _Thread_Dispatch(); 4000f868: 40 00 1c 50 call 400169a8 <_Thread_Dispatch> 4000f86c: b0 10 20 09 mov 9, %i0 ! 9 4000f870: 81 c7 e0 08 ret 4000f874: 81 e8 00 00 restore 4000f878: 80 a0 60 02 cmp %g1, 2 4000f87c: 08 bf ff fd bleu 4000f870 4000f880: b0 10 20 04 mov 4, %i0 4000f884: 81 c7 e0 08 ret <== NOT EXECUTED 4000f888: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 4000f88c: 82 00 80 01 add %g2, %g1, %g1 4000f890: 80 a0 40 19 cmp %g1, %i1 4000f894: 0a bf ff ed bcs 4000f848 4000f898: 01 00 00 00 nop 4000f89c: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 4000f8a0: 40 00 55 12 call 40024ce8 <.urem> 4000f8a4: 90 26 40 02 sub %i1, %g2, %o0 4000f8a8: 80 a2 20 00 cmp %o0, 0 4000f8ac: 12 bf ff e7 bne 4000f848 4000f8b0: 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 ); 4000f8b4: 40 00 11 62 call 40013e3c <_Chain_Append> 4000f8b8: 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; 4000f8bc: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 4000f8c0: 82 00 7f ff add %g1, -1, %g1 4000f8c4: 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 ) 4000f8c8: 07 10 00 cd sethi %hi(0x40033400), %g3 4000f8cc: c2 00 e0 e0 ld [ %g3 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 4000f8d0: b0 10 20 00 clr %i0 4000f8d4: 82 00 7f ff add %g1, -1, %g1 4000f8d8: c2 20 e0 e0 st %g1, [ %g3 + 0xe0 ] 4000f8dc: c4 00 e0 e0 ld [ %g3 + 0xe0 ], %g2 4000f8e0: 80 a0 a0 00 cmp %g2, 0 4000f8e4: 12 80 00 04 bne 4000f8f4 4000f8e8: 01 00 00 00 nop _Thread_Dispatch(); 4000f8ec: 40 00 1c 2f call 400169a8 <_Thread_Dispatch> 4000f8f0: 01 00 00 00 nop 4000f8f4: 81 c7 e0 08 ret 4000f8f8: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000f8fc: 81 c7 e0 08 ret <== NOT EXECUTED 4000f900: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED 4000e77c : */ rtems_status_code rtems_port_delete( Objects_Id id ) { 4000e77c: 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 *) 4000e780: 92 10 00 18 mov %i0, %o1 4000e784: 94 07 bf f4 add %fp, -12, %o2 4000e788: 31 10 00 cc sethi %hi(0x40033000), %i0 4000e78c: 40 00 1b 5f call 40015508 <_Objects_Get> 4000e790: 90 16 22 14 or %i0, 0x214, %o0 ! 40033214 <_Dual_ported_memory_Information> register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 4000e794: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000e798: 80 a0 60 00 cmp %g1, 0 4000e79c: 12 80 00 1a bne 4000e804 4000e7a0: 92 10 00 08 mov %o0, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000e7a4: 90 16 22 14 or %i0, 0x214, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000e7a8: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000e7ac: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 4000e7b0: 05 00 00 3f sethi %hi(0xfc00), %g2 4000e7b4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000e7b8: 82 08 40 02 and %g1, %g2, %g1 4000e7bc: 80 a0 40 03 cmp %g1, %g3 4000e7c0: 18 80 00 04 bgu 4000e7d0 4000e7c4: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 4000e7c8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 4000e7cc: 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 ); 4000e7d0: 40 00 1a f7 call 400153ac <_Objects_Free> 4000e7d4: c0 22 60 0c clr [ %o1 + 0xc ] 4000e7d8: 03 10 00 cd sethi %hi(0x40033400), %g1 4000e7dc: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 4000e7e0: b0 10 20 00 clr %i0 4000e7e4: 84 00 bf ff add %g2, -1, %g2 4000e7e8: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 4000e7ec: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 4000e7f0: 80 a0 e0 00 cmp %g3, 0 4000e7f4: 02 80 00 0a be 4000e81c 4000e7f8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000e7fc: 81 c7 e0 08 ret <== NOT EXECUTED 4000e800: 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 ) { 4000e804: 82 18 60 02 xor %g1, 2, %g1 4000e808: 80 a0 00 01 cmp %g0, %g1 4000e80c: 84 60 20 00 subx %g0, 0, %g2 4000e810: b0 08 a0 15 and %g2, 0x15, %i0 4000e814: 81 c7 e0 08 ret 4000e818: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 4000e81c: 40 00 20 63 call 400169a8 <_Thread_Dispatch> 4000e820: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000e824: 81 c7 e0 08 ret 4000e828: 81 e8 00 00 restore 4000fb18 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 4000fb18: 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 *) 4000fb1c: 21 10 00 cc sethi %hi(0x40033000), %l0 4000fb20: 92 10 00 18 mov %i0, %o1 4000fb24: 94 07 bf f4 add %fp, -12, %o2 4000fb28: 40 00 16 78 call 40015508 <_Objects_Get> 4000fb2c: 90 14 22 ac or %l0, 0x2ac, %o0 Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000fb30: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000fb34: 80 a0 60 00 cmp %g1, 0 4000fb38: 12 80 00 20 bne 4000fbb8 4000fb3c: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000fb40: a0 14 22 ac or %l0, 0x2ac, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 4000fb44: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 4000fb48: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 4000fb4c: 05 00 00 3f sethi %hi(0xfc00), %g2 4000fb50: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 4000fb54: 82 08 40 02 and %g1, %g2, %g1 4000fb58: 80 a0 40 03 cmp %g1, %g3 4000fb5c: 38 80 00 06 bgu,a 4000fb74 4000fb60: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 4000fb64: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 4000fb68: 83 28 60 02 sll %g1, 2, %g1 4000fb6c: 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; 4000fb70: 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 ); 4000fb74: 40 00 22 55 call 400184c8 <_Watchdog_Remove> 4000fb78: 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 ); 4000fb7c: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_INACTIVE; 4000fb80: c0 26 20 38 clr [ %i0 + 0x38 ] 4000fb84: 40 00 16 0a call 400153ac <_Objects_Free> 4000fb88: 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 ) 4000fb8c: 03 10 00 cd sethi %hi(0x40033400), %g1 4000fb90: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 4000fb94: b0 10 20 00 clr %i0 4000fb98: 84 00 bf ff add %g2, -1, %g2 4000fb9c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 4000fba0: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 4000fba4: 80 a0 e0 00 cmp %g3, 0 4000fba8: 02 80 00 0a be 4000fbd0 4000fbac: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000fbb0: 81 c7 e0 08 ret <== NOT EXECUTED 4000fbb4: 81 e8 00 00 restore <== NOT EXECUTED { Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000fbb8: 82 18 60 02 xor %g1, 2, %g1 4000fbbc: 80 a0 00 01 cmp %g0, %g1 4000fbc0: 84 60 20 00 subx %g0, 0, %g2 4000fbc4: b0 08 a0 15 and %g2, 0x15, %i0 4000fbc8: 81 c7 e0 08 ret 4000fbcc: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 4000fbd0: 40 00 1b 76 call 400169a8 <_Thread_Dispatch> 4000fbd4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000fbd8: 81 c7 e0 08 ret 4000fbdc: 81 e8 00 00 restore 4000e5a8 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 4000e5a8: 9d e3 bf 90 save %sp, -112, %sp 4000e5ac: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 4000e5b0: 80 a6 60 00 cmp %i1, 0 4000e5b4: 02 80 00 17 be 4000e610 4000e5b8: b0 10 20 09 mov 9, %i0 4000e5bc: 11 10 00 78 sethi %hi(0x4001e000), %o0 4000e5c0: 94 07 bf f4 add %fp, -12, %o2 4000e5c4: 7f ff ec b1 call 40009888 <_Objects_Get> 4000e5c8: 90 12 21 b8 or %o0, 0x1b8, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000e5cc: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000e5d0: 80 a0 60 00 cmp %g1, 0 4000e5d4: 12 80 00 11 bne 4000e618 4000e5d8: 92 10 00 08 mov %o0, %o1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: *statistics = the_period->Statistics; 4000e5dc: 90 10 00 19 mov %i1, %o0 4000e5e0: 92 02 60 54 add %o1, 0x54, %o1 4000e5e4: 40 00 08 00 call 400105e4 4000e5e8: 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 ) 4000e5ec: 03 10 00 78 sethi %hi(0x4001e000), %g1 4000e5f0: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 4001e350 <_Thread_Dispatch_disable_level> 4000e5f4: b0 10 20 00 clr %i0 4000e5f8: 84 00 bf ff add %g2, -1, %g2 4000e5fc: c4 20 63 50 st %g2, [ %g1 + 0x350 ] 4000e600: c6 00 63 50 ld [ %g1 + 0x350 ], %g3 4000e604: 80 a0 e0 00 cmp %g3, 0 4000e608: 02 80 00 0a be 4000e630 4000e60c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000e610: 81 c7 e0 08 ret <== NOT EXECUTED 4000e614: 81 e8 00 00 restore <== NOT EXECUTED if ( !statistics ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000e618: 82 18 60 02 xor %g1, 2, %g1 4000e61c: 80 a0 00 01 cmp %g0, %g1 4000e620: 84 60 20 00 subx %g0, 0, %g2 4000e624: b0 08 a0 15 and %g2, 0x15, %i0 4000e628: 81 c7 e0 08 ret 4000e62c: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 4000e630: 7f ff f1 be call 4000ad28 <_Thread_Dispatch> 4000e634: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000e638: 81 c7 e0 08 ret 4000e63c: 81 e8 00 00 restore 4000e640 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 4000e640: 9d e3 bf 88 save %sp, -120, %sp 4000e644: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 4000e648: 80 a6 60 00 cmp %i1, 0 4000e64c: 02 80 00 21 be 4000e6d0 4000e650: b0 10 20 09 mov 9, %i0 4000e654: 11 10 00 78 sethi %hi(0x4001e000), %o0 4000e658: 94 07 bf f4 add %fp, -12, %o2 4000e65c: 7f ff ec 8b call 40009888 <_Objects_Get> 4000e660: 90 12 21 b8 or %o0, 0x1b8, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000e664: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000e668: 80 a0 60 00 cmp %g1, 0 4000e66c: 12 80 00 1b bne 4000e6d8 4000e670: 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); 4000e674: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 4000e678: 80 a0 60 00 cmp %g1, 0 4000e67c: 02 80 00 03 be 4000e688 4000e680: 84 10 20 00 clr %g2 4000e684: c4 00 60 08 ld [ %g1 + 8 ], %g2 status->state = the_period->state; 4000e688: 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); 4000e68c: c4 26 40 00 st %g2, [ %i1 ] status->state = the_period->state; if ( status->state == RATE_MONOTONIC_INACTIVE ) { 4000e690: 80 a0 60 00 cmp %g1, 0 4000e694: 12 80 00 1b bne 4000e700 4000e698: 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; 4000e69c: 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; 4000e6a0: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 4000e6a4: 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; 4000e6a8: 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 ) 4000e6ac: 03 10 00 78 sethi %hi(0x4001e000), %g1 4000e6b0: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 4001e350 <_Thread_Dispatch_disable_level> 4000e6b4: b0 10 20 00 clr %i0 4000e6b8: 84 00 bf ff add %g2, -1, %g2 4000e6bc: c4 20 63 50 st %g2, [ %g1 + 0x350 ] 4000e6c0: c6 00 63 50 ld [ %g1 + 0x350 ], %g3 4000e6c4: 80 a0 e0 00 cmp %g3, 0 4000e6c8: 02 80 00 0a be 4000e6f0 4000e6cc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000e6d0: 81 c7 e0 08 ret <== NOT EXECUTED 4000e6d4: 81 e8 00 00 restore <== NOT EXECUTED if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 4000e6d8: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 4000e6dc: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 4000e6e0: 84 60 20 00 subx %g0, 0, %g2 <== NOT EXECUTED 4000e6e4: b0 08 a0 15 and %g2, 0x15, %i0 <== NOT EXECUTED 4000e6e8: 81 c7 e0 08 ret <== NOT EXECUTED 4000e6ec: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000e6f0: 7f ff f1 8e call 4000ad28 <_Thread_Dispatch> 4000e6f4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000e6f8: 81 c7 e0 08 ret 4000e6fc: 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 ); 4000e700: a0 07 bf ec add %fp, -20, %l0 4000e704: 7f ff e9 13 call 40008b50 <_TOD_Get_uptime> 4000e708: 90 10 00 10 mov %l0, %o0 #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 4000e70c: 90 06 20 44 add %i0, 0x44, %o0 4000e710: 92 10 00 10 mov %l0, %o1 4000e714: 7f ff f6 40 call 4000c014 <_Timespec_Subtract> 4000e718: 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( 4000e71c: 92 10 00 10 mov %l0, %o1 4000e720: 94 06 60 10 add %i1, 0x10, %o2 4000e724: 11 10 00 79 sethi %hi(0x4001e400), %o0 4000e728: 7f ff f6 3b call 4000c014 <_Timespec_Subtract> 4000e72c: 90 12 20 34 or %o0, 0x34, %o0 ! 4001e434 <_Thread_Time_of_last_context_switch> 4000e730: 30 bf ff df b,a 4000e6ac 40006bb4 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 40006bb4: 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 *) 40006bb8: 11 10 00 78 sethi %hi(0x4001e000), %o0 40006bbc: 92 10 00 18 mov %i0, %o1 40006bc0: 90 12 21 b8 or %o0, 0x1b8, %o0 40006bc4: 40 00 0b 31 call 40009888 <_Objects_Get> 40006bc8: 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 ) { 40006bcc: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006bd0: 80 a0 60 00 cmp %g1, 0 40006bd4: 12 80 00 15 bne 40006c28 40006bd8: a2 10 00 08 mov %o0, %l1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 40006bdc: 25 10 00 79 sethi %hi(0x4001e400), %l2 40006be0: c4 02 20 50 ld [ %o0 + 0x50 ], %g2 40006be4: c2 04 a0 2c ld [ %l2 + 0x2c ], %g1 40006be8: 80 a0 80 01 cmp %g2, %g1 40006bec: 02 80 00 14 be 40006c3c 40006bf0: 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 ) 40006bf4: 03 10 00 78 sethi %hi(0x4001e000), %g1 40006bf8: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 4001e350 <_Thread_Dispatch_disable_level> 40006bfc: b0 10 20 17 mov 0x17, %i0 _Thread_Dispatch(); 40006c00: 84 00 bf ff add %g2, -1, %g2 40006c04: c4 20 63 50 st %g2, [ %g1 + 0x350 ] 40006c08: c6 00 63 50 ld [ %g1 + 0x350 ], %g3 40006c0c: 80 a0 e0 00 cmp %g3, 0 40006c10: 12 80 00 66 bne 40006da8 40006c14: 01 00 00 00 nop 40006c18: 40 00 10 44 call 4000ad28 <_Thread_Dispatch> 40006c1c: 01 00 00 00 nop 40006c20: 81 c7 e0 08 ret 40006c24: 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 ) { 40006c28: 80 a0 60 02 cmp %g1, 2 40006c2c: 02 bf ff fd be 40006c20 40006c30: b0 10 20 04 mov 4, %i0 break; } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006c34: 81 c7 e0 08 ret <== NOT EXECUTED 40006c38: 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 ) { 40006c3c: 22 80 00 73 be,a 40006e08 40006c40: d0 02 20 38 ld [ %o0 + 0x38 ], %o0 } _Thread_Enable_dispatch(); return( return_value ); } _ISR_Disable( level ); 40006c44: 7f ff ef 57 call 400029a0 40006c48: 01 00 00 00 nop 40006c4c: a0 10 00 08 mov %o0, %l0 switch ( the_period->state ) { 40006c50: e6 04 60 38 ld [ %l1 + 0x38 ], %l3 40006c54: 80 a4 e0 02 cmp %l3, 2 40006c58: 02 80 00 34 be 40006d28 40006c5c: 80 a4 e0 04 cmp %l3, 4 40006c60: 02 80 00 54 be 40006db0 40006c64: 80 a4 e0 00 cmp %l3, 0 40006c68: 32 bf ff ee bne,a 40006c20 40006c6c: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED /* * No need to update statistics -- there are not a period active */ _ISR_Enable( level ); 40006c70: 7f ff ef 50 call 400029b0 40006c74: 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 ); 40006c78: 40 00 07 b6 call 40008b50 <_TOD_Get_uptime> 40006c7c: 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; 40006c80: c2 07 bf ec ld [ %fp + -20 ], %g1 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40006c84: c6 04 a0 2c ld [ %l2 + 0x2c ], %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; 40006c88: c2 24 60 44 st %g1, [ %l1 + 0x44 ] 40006c8c: 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( 40006c90: 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; 40006c94: c2 24 60 48 st %g1, [ %l1 + 0x48 ] #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40006c98: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40006c9c: a0 07 bf e4 add %fp, -28, %l0 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40006ca0: c4 24 60 3c st %g2, [ %l1 + 0x3c ] 40006ca4: c2 00 e0 94 ld [ %g3 + 0x94 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40006ca8: 94 10 00 10 mov %l0, %o2 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 40006cac: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 40006cb0: 11 10 00 79 sethi %hi(0x4001e400), %o0 40006cb4: 40 00 14 d8 call 4000c014 <_Timespec_Subtract> 40006cb8: 90 12 20 34 or %o0, 0x34, %o0 ! 4001e434 <_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 ); 40006cbc: 92 10 00 10 mov %l0, %o1 40006cc0: 40 00 14 72 call 4000be88 <_Timespec_Add_to> 40006cc4: 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; 40006cc8: 84 10 20 02 mov 2, %g2 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40006ccc: 03 10 00 1c sethi %hi(0x40007000), %g1 40006cd0: 82 10 61 dc or %g1, 0x1dc, %g1 ! 400071dc <_Rate_monotonic_Timeout> the_watchdog->id = id; 40006cd4: f0 24 60 30 st %i0, [ %l1 + 0x30 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40006cd8: f2 24 60 1c st %i1, [ %l1 + 0x1c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40006cdc: c0 24 60 18 clr [ %l1 + 0x18 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 40006ce0: c0 24 60 34 clr [ %l1 + 0x34 ] _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 40006ce4: f2 24 60 4c st %i1, [ %l1 + 0x4c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40006ce8: 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; 40006cec: c4 24 60 38 st %g2, [ %l1 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40006cf0: c2 24 60 2c st %g1, [ %l1 + 0x2c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40006cf4: 11 10 00 79 sethi %hi(0x4001e400), %o0 40006cf8: 40 00 15 92 call 4000c340 <_Watchdog_Insert> 40006cfc: 90 12 20 4c or %o0, 0x4c, %o0 ! 4001e44c <_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 ) 40006d00: 05 10 00 78 sethi %hi(0x4001e000), %g2 40006d04: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 ! 4001e350 <_Thread_Dispatch_disable_level> 40006d08: 82 00 7f ff add %g1, -1, %g1 40006d0c: c2 20 a3 50 st %g1, [ %g2 + 0x350 ] 40006d10: c6 00 a3 50 ld [ %g2 + 0x350 ], %g3 40006d14: 80 a0 e0 00 cmp %g3, 0 40006d18: 02 80 00 22 be 40006da0 40006d1c: 01 00 00 00 nop _Thread_Dispatch(); 40006d20: 81 c7 e0 08 ret <== NOT EXECUTED 40006d24: 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 ); 40006d28: 7f ff ff 43 call 40006a34 <_Rate_monotonic_Update_statistics> 40006d2c: 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; 40006d30: 82 10 20 01 mov 1, %g1 the_period->next_length = length; 40006d34: 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; 40006d38: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; _ISR_Enable( level ); 40006d3c: 7f ff ef 1d call 400029b0 40006d40: 90 10 00 10 mov %l0, %o0 _Thread_Executing->Wait.id = the_period->Object.id; 40006d44: c2 04 a0 2c ld [ %l2 + 0x2c ], %g1 40006d48: c4 04 60 08 ld [ %l1 + 8 ], %g2 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 40006d4c: 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; 40006d50: c4 20 60 20 st %g2, [ %g1 + 0x20 ] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 40006d54: 40 00 13 1b call 4000b9c0 <_Thread_Set_state> 40006d58: 13 00 00 10 sethi %hi(0x4000), %o1 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 40006d5c: 7f ff ef 11 call 400029a0 40006d60: 01 00 00 00 nop local_state = the_period->state; 40006d64: e0 04 60 38 ld [ %l1 + 0x38 ], %l0 the_period->state = RATE_MONOTONIC_ACTIVE; 40006d68: e6 24 60 38 st %l3, [ %l1 + 0x38 ] _ISR_Enable( level ); 40006d6c: 7f ff ef 11 call 400029b0 40006d70: 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 ) 40006d74: 80 a4 20 03 cmp %l0, 3 40006d78: 02 80 00 32 be 40006e40 40006d7c: d0 04 a0 2c ld [ %l2 + 0x2c ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40006d80: 03 10 00 78 sethi %hi(0x4001e000), %g1 40006d84: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 4001e350 <_Thread_Dispatch_disable_level> 40006d88: 84 00 bf ff add %g2, -1, %g2 40006d8c: c4 20 63 50 st %g2, [ %g1 + 0x350 ] 40006d90: c6 00 63 50 ld [ %g1 + 0x350 ], %g3 40006d94: 80 a0 e0 00 cmp %g3, 0 40006d98: 12 bf ff e2 bne 40006d20 40006d9c: 01 00 00 00 nop _Thread_Dispatch(); 40006da0: 40 00 0f e2 call 4000ad28 <_Thread_Dispatch> 40006da4: b0 10 20 00 clr %i0 ! 0 40006da8: 81 c7 e0 08 ret 40006dac: 81 e8 00 00 restore case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 40006db0: 7f ff ff 21 call 40006a34 <_Rate_monotonic_Update_statistics> 40006db4: 90 10 00 11 mov %l1, %o0 _ISR_Enable( level ); 40006db8: 7f ff ee fe call 400029b0 40006dbc: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 40006dc0: 82 10 20 02 mov 2, %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40006dc4: f2 24 60 1c st %i1, [ %l1 + 0x1c ] the_period->next_length = length; 40006dc8: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40006dcc: 92 04 60 10 add %l1, 0x10, %o1 */ _Rate_monotonic_Update_statistics( the_period ); _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 40006dd0: c2 24 60 38 st %g1, [ %l1 + 0x38 ] 40006dd4: 11 10 00 79 sethi %hi(0x4001e400), %o0 40006dd8: 40 00 15 5a call 4000c340 <_Watchdog_Insert> 40006ddc: 90 12 20 4c or %o0, 0x4c, %o0 ! 4001e44c <_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 ) 40006de0: 07 10 00 78 sethi %hi(0x4001e000), %g3 40006de4: c2 00 e3 50 ld [ %g3 + 0x350 ], %g1 ! 4001e350 <_Thread_Dispatch_disable_level> 40006de8: b0 10 20 06 mov 6, %i0 40006dec: 82 00 7f ff add %g1, -1, %g1 40006df0: c2 20 e3 50 st %g1, [ %g3 + 0x350 ] 40006df4: c4 00 e3 50 ld [ %g3 + 0x350 ], %g2 40006df8: 80 a0 a0 00 cmp %g2, 0 40006dfc: 02 bf ff 87 be 40006c18 40006e00: 01 00 00 00 nop 40006e04: 30 bf ff e9 b,a 40006da8 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 40006e08: 80 a2 20 02 cmp %o0, 2 40006e0c: 02 80 00 09 be 40006e30 40006e10: b0 10 20 00 clr %i0 40006e14: 80 a2 20 04 cmp %o0, 4 40006e18: 02 80 00 06 be 40006e30 40006e1c: b0 10 20 06 mov 6, %i0 40006e20: 80 a2 20 00 cmp %o0, 0 40006e24: 02 80 00 03 be 40006e30 40006e28: b0 10 20 0b mov 0xb, %i0 40006e2c: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 40006e30: 03 10 00 78 sethi %hi(0x4001e000), %g1 40006e34: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 4001e350 <_Thread_Dispatch_disable_level> 40006e38: 10 bf ff 73 b 40006c04 40006e3c: 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 ); 40006e40: 40 00 0f 05 call 4000aa54 <_Thread_Clear_state> <== NOT EXECUTED 40006e44: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED 40006e48: 30 bf ff ce b,a 40006d80 <== NOT EXECUTED 40006e4c : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 40006e4c: 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 ) 40006e50: 80 a6 60 00 cmp %i1, 0 40006e54: 02 80 00 4e be 40006f8c 40006e58: 90 10 00 18 mov %i0, %o0 return; (*print)( context, "Period information by period\n" ); 40006e5c: 13 10 00 6f sethi %hi(0x4001bc00), %o1 40006e60: 9f c6 40 00 call %i1 40006e64: 92 12 60 e8 or %o1, 0xe8, %o1 ! 4001bce8 #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 40006e68: 90 10 00 18 mov %i0, %o0 40006e6c: 13 10 00 6f sethi %hi(0x4001bc00), %o1 40006e70: 9f c6 40 00 call %i1 40006e74: 92 12 61 08 or %o1, 0x108, %o1 ! 4001bd08 #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 40006e78: 90 10 00 18 mov %i0, %o0 40006e7c: 13 10 00 6f sethi %hi(0x4001bc00), %o1 40006e80: 9f c6 40 00 call %i1 40006e84: 92 12 61 30 or %o1, 0x130, %o1 ! 4001bd30 Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 40006e88: 90 10 00 18 mov %i0, %o0 40006e8c: 13 10 00 6f sethi %hi(0x4001bc00), %o1 40006e90: 9f c6 40 00 call %i1 40006e94: 92 12 61 58 or %o1, 0x158, %o1 ! 4001bd58 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 40006e98: 90 10 00 18 mov %i0, %o0 40006e9c: 13 10 00 6f sethi %hi(0x4001bc00), %o1 40006ea0: 9f c6 40 00 call %i1 40006ea4: 92 12 61 a8 or %o1, 0x1a8, %o1 ! 4001bda8 /* * 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 ; 40006ea8: 03 10 00 78 sethi %hi(0x4001e000), %g1 40006eac: a6 10 61 b8 or %g1, 0x1b8, %l3 ! 4001e1b8 <_Rate_monotonic_Information> 40006eb0: e4 04 e0 08 ld [ %l3 + 8 ], %l2 id <= _Rate_monotonic_Information.maximum_id ; 40006eb4: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 40006eb8: 80 a4 80 01 cmp %l2, %g1 40006ebc: 18 80 00 34 bgu 40006f8c 40006ec0: 03 10 00 6f sethi %hi(0x4001bc00), %g1 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 40006ec4: 05 10 00 6f sethi %hi(0x4001bc00), %g2 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 40006ec8: b6 10 61 f8 or %g1, 0x1f8, %i3 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 40006ecc: b8 10 a1 28 or %g2, 0x128, %i4 40006ed0: 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 ); 40006ed4: aa 07 bf d0 add %fp, -48, %l5 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 40006ed8: ba 07 bf b0 add %fp, -80, %i5 40006edc: 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( 40006ee0: b4 07 bf c8 add %fp, -56, %i2 40006ee4: 10 80 00 06 b 40006efc 40006ee8: 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++ ) { 40006eec: 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 ; 40006ef0: 80 a0 40 12 cmp %g1, %l2 40006ef4: 0a 80 00 26 bcs 40006f8c 40006ef8: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 40006efc: 90 10 00 12 mov %l2, %o0 40006f00: 40 00 1d aa call 4000e5a8 40006f04: 92 10 00 14 mov %l4, %o1 if ( status != RTEMS_SUCCESSFUL ) 40006f08: 80 a2 20 00 cmp %o0, 0 40006f0c: 32 bf ff f8 bne,a 40006eec 40006f10: 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 ); 40006f14: 92 10 00 15 mov %l5, %o1 40006f18: 40 00 1d ca call 4000e640 40006f1c: 90 10 00 12 mov %l2, %o0 if ( status != RTEMS_SUCCESSFUL ) 40006f20: 80 a2 20 00 cmp %o0, 0 40006f24: 32 bf ff f2 bne,a 40006eec 40006f28: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 <== NOT EXECUTED continue; name[ 0 ] = '\0'; if ( the_status.owner ) { 40006f2c: 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'; 40006f30: c0 2f bf f3 clrb [ %fp + -13 ] if ( the_status.owner ) { 40006f34: 80 a2 20 00 cmp %o0, 0 40006f38: 12 80 00 4b bne 40007064 40006f3c: a0 10 00 17 mov %l7, %l0 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 40006f40: d8 1f bf 98 ldd [ %fp + -104 ], %o4 <== NOT EXECUTED 40006f44: 94 10 00 12 mov %l2, %o2 40006f48: 92 10 00 1b mov %i3, %o1 40006f4c: 96 10 00 10 mov %l0, %o3 40006f50: 9f c6 40 00 call %i1 40006f54: 90 10 00 18 mov %i0, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 40006f58: c2 07 bf 98 ld [ %fp + -104 ], %g1 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 40006f5c: 94 10 00 16 mov %l6, %o2 40006f60: 90 10 00 1d mov %i5, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 40006f64: 80 a0 60 00 cmp %g1, 0 40006f68: 12 80 00 0b bne 40006f94 40006f6c: 92 10 00 1c mov %i4, %o1 (*print)( context, "\n" ); 40006f70: 9f c6 40 00 call %i1 40006f74: 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 ; 40006f78: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 id++ ) { 40006f7c: 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 ; 40006f80: 80 a0 40 12 cmp %g1, %l2 40006f84: 1a bf ff df bcc 40006f00 40006f88: 90 10 00 12 mov %l2, %o0 40006f8c: 81 c7 e0 08 ret 40006f90: 81 e8 00 00 restore */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 40006f94: 40 00 13 d7 call 4000bef0 <_Timespec_Divide_by_integer> 40006f98: 92 10 00 01 mov %g1, %o1 &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 40006f9c: d0 07 bf a4 ld [ %fp + -92 ], %o0 40006fa0: 40 00 46 a2 call 40018a28 <.div> 40006fa4: 92 10 23 e8 mov 0x3e8, %o1 40006fa8: a2 10 00 08 mov %o0, %l1 40006fac: d0 07 bf ac ld [ %fp + -84 ], %o0 40006fb0: 40 00 46 9e call 40018a28 <.div> 40006fb4: 92 10 23 e8 mov 0x3e8, %o1 40006fb8: c2 07 bf e8 ld [ %fp + -24 ], %g1 40006fbc: a0 10 00 08 mov %o0, %l0 40006fc0: d0 07 bf ec ld [ %fp + -20 ], %o0 40006fc4: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 40006fc8: 40 00 46 98 call 40018a28 <.div> 40006fcc: 92 10 23 e8 mov 0x3e8, %o1 40006fd0: d8 07 bf a8 ld [ %fp + -88 ], %o4 40006fd4: d4 07 bf a0 ld [ %fp + -96 ], %o2 40006fd8: 96 10 00 11 mov %l1, %o3 40006fdc: 9a 10 00 10 mov %l0, %o5 40006fe0: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 40006fe4: 13 10 00 6f sethi %hi(0x4001bc00), %o1 40006fe8: 90 10 00 18 mov %i0, %o0 40006fec: 9f c6 40 00 call %i1 40006ff0: 92 12 62 10 or %o1, 0x210, %o1 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 40006ff4: d2 07 bf 98 ld [ %fp + -104 ], %o1 40006ff8: 94 10 00 16 mov %l6, %o2 40006ffc: 40 00 13 bd call 4000bef0 <_Timespec_Divide_by_integer> 40007000: 90 10 00 1a mov %i2, %o0 &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 40007004: d0 07 bf bc ld [ %fp + -68 ], %o0 40007008: 40 00 46 88 call 40018a28 <.div> 4000700c: 92 10 23 e8 mov 0x3e8, %o1 40007010: a2 10 00 08 mov %o0, %l1 40007014: d0 07 bf c4 ld [ %fp + -60 ], %o0 40007018: 40 00 46 84 call 40018a28 <.div> 4000701c: 92 10 23 e8 mov 0x3e8, %o1 40007020: c2 07 bf e8 ld [ %fp + -24 ], %g1 40007024: a0 10 00 08 mov %o0, %l0 40007028: d0 07 bf ec ld [ %fp + -20 ], %o0 4000702c: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 40007030: 40 00 46 7e call 40018a28 <.div> 40007034: 92 10 23 e8 mov 0x3e8, %o1 40007038: d4 07 bf b8 ld [ %fp + -72 ], %o2 4000703c: d8 07 bf c0 ld [ %fp + -64 ], %o4 40007040: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 40007044: 96 10 00 11 mov %l1, %o3 40007048: 9a 10 00 10 mov %l0, %o5 4000704c: 90 10 00 18 mov %i0, %o0 40007050: 13 10 00 6f sethi %hi(0x4001bc00), %o1 40007054: 9f c6 40 00 call %i1 40007058: 92 12 62 30 or %o1, 0x230, %o1 ! 4001be30 /* * 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 ; 4000705c: 10 bf ff a4 b 40006eec 40007060: 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 ); 40007064: 92 10 20 05 mov 5, %o1 40007068: 40 00 00 8f call 400072a4 4000706c: 94 10 00 17 mov %l7, %o2 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 40007070: 10 bf ff b5 b 40006f44 40007074: d8 1f bf 98 ldd [ %fp + -104 ], %o4 40007094 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 40007094: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007098: 25 10 00 78 sethi %hi(0x4001e000), %l2 4000709c: c2 04 a3 50 ld [ %l2 + 0x350 ], %g1 ! 4001e350 <_Thread_Dispatch_disable_level> 400070a0: 82 00 60 01 inc %g1 400070a4: c2 24 a3 50 st %g1, [ %l2 + 0x350 ] /* * 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 ; 400070a8: 03 10 00 78 sethi %hi(0x4001e000), %g1 400070ac: a2 10 61 b8 or %g1, 0x1b8, %l1 ! 4001e1b8 <_Rate_monotonic_Information> 400070b0: e0 04 60 08 ld [ %l1 + 8 ], %l0 id <= _Rate_monotonic_Information.maximum_id ; 400070b4: c2 04 60 0c ld [ %l1 + 0xc ], %g1 400070b8: 80 a4 00 01 cmp %l0, %g1 400070bc: 18 80 00 09 bgu 400070e0 400070c0: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 400070c4: 40 00 00 13 call 40007110 400070c8: 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 ; 400070cc: c2 04 60 0c ld [ %l1 + 0xc ], %g1 id++ ) { 400070d0: 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 ; 400070d4: 80 a0 40 10 cmp %g1, %l0 400070d8: 1a bf ff fb bcc 400070c4 400070dc: 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 ) 400070e0: c2 04 a3 50 ld [ %l2 + 0x350 ], %g1 400070e4: 82 00 7f ff add %g1, -1, %g1 400070e8: c2 24 a3 50 st %g1, [ %l2 + 0x350 ] 400070ec: c4 04 a3 50 ld [ %l2 + 0x350 ], %g2 400070f0: 80 a0 a0 00 cmp %g2, 0 400070f4: 02 80 00 04 be 40007104 400070f8: 01 00 00 00 nop 400070fc: 81 c7 e0 08 ret <== NOT EXECUTED 40007100: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40007104: 40 00 0f 09 call 4000ad28 <_Thread_Dispatch> 40007108: 81 e8 00 00 restore 4000710c: 01 00 00 00 nop 400100f8 : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 400100f8: 9d e3 bf 98 save %sp, -104, %sp Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 400100fc: a8 96 20 00 orcc %i0, 0, %l4 40010100: 02 80 00 58 be 40010260 40010104: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 40010108: 80 a6 60 00 cmp %i1, 0 4001010c: 02 80 00 06 be 40010124 40010110: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 40010114: 02 80 00 04 be 40010124 40010118: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 4001011c: 02 80 00 04 be 4001012c 40010120: 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(); 40010124: 81 c7 e0 08 ret 40010128: 91 e8 20 09 restore %g0, 9, %o0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 4001012c: 7f ff ea 73 call 4000aaf8 40010130: 01 00 00 00 nop 40010134: a2 10 00 08 mov %o0, %l1 40010138: 25 10 00 cd sethi %hi(0x40033400), %l2 4001013c: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 40010140: 80 a0 60 00 cmp %g1, 0 40010144: 02 80 00 0b be 40010170 40010148: 03 10 00 cd sethi %hi(0x40033400), %g1 4001014c: 03 10 00 cd sethi %hi(0x40033400), %g1 <== NOT EXECUTED 40010150: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 400336c0 <_System_state_Current> <== NOT EXECUTED 40010154: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40010158: 08 80 00 05 bleu 4001016c <== NOT EXECUTED 4001015c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40010160: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010164: 40 00 13 57 call 40014ec0 <_Internal_error_Occurred> <== NOT EXECUTED 40010168: 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; 4001016c: 03 10 00 cd sethi %hi(0x40033400), %g1 <== NOT EXECUTED 40010170: 27 10 00 cd sethi %hi(0x40033400), %l3 40010174: c6 00 61 bc ld [ %g1 + 0x1bc ], %g3 40010178: e0 04 e1 b4 ld [ %l3 + 0x1b4 ], %l0 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 4001017c: c0 20 e0 34 clr [ %g3 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40010180: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40010184: 80 a0 60 00 cmp %g1, 0 40010188: 22 80 00 12 be,a 400101d0 4001018c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40010190: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40010194: 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; 40010198: 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; 4001019c: 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; 400101a0: 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; 400101a4: 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 ) || 400101a8: 80 a0 a0 02 cmp %g2, 2 400101ac: 12 80 00 2f bne 40010268 400101b0: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400101b4: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 400101b8: 82 00 60 01 inc %g1 400101bc: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 400101c0: 7f ff ea 52 call 4000ab08 400101c4: 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 ); 400101c8: 10 80 00 0f b 40010204 400101cc: 23 10 00 cc sethi %hi(0x40033000), %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 ) ) { 400101d0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 400101d4: 32 80 00 48 bne,a 400102f4 <== NOT EXECUTED 400101d8: c4 04 20 08 ld [ %l0 + 8 ], %g2 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400101dc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400101e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400101e4: 12 80 00 41 bne 400102e8 <== NOT EXECUTED 400101e8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 400101ec: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 400101f0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400101f4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400101f8: 7f ff ea 44 call 4000ab08 <== NOT EXECUTED 400101fc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40010200: 23 10 00 cc sethi %hi(0x40033000), %l1 <== NOT EXECUTED 40010204: 40 00 13 5c call 40014f74 <_Objects_Allocate> 40010208: 90 14 62 f8 or %l1, 0x2f8, %o0 ! 400332f8 <_Region_Information> the_region = _Region_Allocate(); if ( !the_region ) { 4001020c: a0 92 20 00 orcc %o0, 0, %l0 40010210: 32 80 00 4e bne,a 40010348 40010214: 90 04 20 68 add %l0, 0x68, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010218: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 4001021c: 82 00 60 01 inc %g1 40010220: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] _RTEMS_Unlock_allocator(); 40010224: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 40010228: 94 10 20 00 clr %o2 4001022c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010230: 40 00 10 ab call 400144dc <_CORE_mutex_Surrender> 40010234: 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 ) 40010238: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 4001023c: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 40010240: 82 00 7f ff add %g1, -1, %g1 40010244: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] 40010248: c4 04 a0 e0 ld [ %l2 + 0xe0 ], %g2 4001024c: 80 a0 a0 00 cmp %g2, 0 40010250: 12 80 00 04 bne 40010260 40010254: 01 00 00 00 nop 40010258: 40 00 19 d4 call 400169a8 <_Thread_Dispatch> 4001025c: 01 00 00 00 nop 40010260: 81 c7 e0 08 ret 40010264: 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 ) || 40010268: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 4001026c: 12 bf ff d5 bne 400101c0 <== NOT EXECUTED 40010270: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40010274: 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; 40010278: 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++; 4001027c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010280: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40010284: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED current = executing->current_priority; if ( current == ceiling ) { 40010288: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4001028c: 02 80 00 4e be 400103c4 <== NOT EXECUTED 40010290: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40010294: 1a 80 00 42 bcc 4001039c <== NOT EXECUTED 40010298: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001029c: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 <== NOT EXECUTED 400102a0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400102a4: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 400102a8: 7f ff ea 18 call 4000ab08 <== NOT EXECUTED 400102ac: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 400102b0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 400102b4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 400102b8: 40 00 18 98 call 40016518 <_Thread_Change_priority> <== NOT EXECUTED 400102bc: 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 ) 400102c0: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 <== NOT EXECUTED 400102c4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400102c8: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] <== NOT EXECUTED 400102cc: c4 04 a0 e0 ld [ %l2 + 0xe0 ], %g2 <== NOT EXECUTED 400102d0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400102d4: 12 bf ff cc bne 40010204 <== NOT EXECUTED 400102d8: 23 10 00 cc sethi %hi(0x40033000), %l1 <== NOT EXECUTED _Thread_Dispatch(); 400102dc: 40 00 19 b3 call 400169a8 <_Thread_Dispatch> <== NOT EXECUTED 400102e0: 01 00 00 00 nop <== NOT EXECUTED 400102e4: 30 bf ff c8 b,a 40010204 <== 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 ) { 400102e8: 02 80 00 13 be 40010334 <== NOT EXECUTED 400102ec: 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 */ 400102f0: c4 04 20 08 ld [ %l0 + 8 ], %g2 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400102f4: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 <== NOT EXECUTED 400102f8: c4 20 e0 20 st %g2, [ %g3 + 0x20 ] <== NOT EXECUTED 400102fc: 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; 40010300: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 40010304: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] <== NOT EXECUTED 40010308: c4 24 20 40 st %g2, [ %l0 + 0x40 ] <== NOT EXECUTED 4001030c: 82 04 20 10 add %l0, 0x10, %g1 <== NOT EXECUTED 40010310: c2 20 e0 44 st %g1, [ %g3 + 0x44 ] <== NOT EXECUTED 40010314: 7f ff e9 fd call 4000ab08 <== NOT EXECUTED 40010318: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 4001031c: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 <== NOT EXECUTED 40010320: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010324: 40 00 10 4a call 4001444c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40010328: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 4001032c: 10 bf ff b6 b 40010204 <== NOT EXECUTED 40010330: 23 10 00 cc sethi %hi(0x40033000), %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; 40010334: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40010338: 7f ff e9 f4 call 4000ab08 <== NOT EXECUTED 4001033c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40010340: 10 bf ff b1 b 40010204 <== NOT EXECUTED 40010344: 23 10 00 cc sethi %hi(0x40033000), %l1 <== NOT EXECUTED if ( !the_region ) { _RTEMS_Unlock_allocator(); return RTEMS_TOO_MANY; } the_region->maximum_segment_size = 40010348: 92 10 00 19 mov %i1, %o1 4001034c: 94 10 00 1a mov %i2, %o2 40010350: 40 00 12 8f call 40014d8c <_Heap_Initialize> 40010354: 96 10 00 1b mov %i3, %o3 _Heap_Initialize(&the_region->Memory, starting_address, length, page_size); if ( !the_region->maximum_segment_size ) { 40010358: 80 a2 20 00 cmp %o0, 0 4001035c: 12 80 00 1e bne 400103d4 40010360: 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 ); 40010364: 90 14 62 f8 or %l1, 0x2f8, %o0 40010368: 40 00 14 11 call 400153ac <_Objects_Free> 4001036c: 92 10 00 10 mov %l0, %o1 40010370: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 40010374: 82 00 60 01 inc %g1 40010378: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 4001037c: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 40010380: 94 10 20 00 clr %o2 40010384: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010388: 40 00 10 55 call 400144dc <_CORE_mutex_Surrender> 4001038c: 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 ) 40010390: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 40010394: 10 bf ff ab b 40010240 40010398: b0 10 20 08 mov 8, %i0 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 4001039c: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400103a0: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 400103a4: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 400103a8: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 400103ac: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400103b0: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400103b4: 7f ff e9 d5 call 4000ab08 <== NOT EXECUTED 400103b8: 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 ); 400103bc: 10 bf ff 92 b 40010204 <== NOT EXECUTED 400103c0: 23 10 00 cc sethi %hi(0x40033000), %l1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 400103c4: 7f ff e9 d1 call 4000ab08 <== NOT EXECUTED 400103c8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400103cc: 10 bf ff 8e b 40010204 <== NOT EXECUTED 400103d0: 23 10 00 cc sethi %hi(0x40033000), %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( 400103d4: 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; 400103d8: f2 24 20 50 st %i1, [ %l0 + 0x50 ] the_region->length = length; 400103dc: f4 24 20 54 st %i2, [ %l0 + 0x54 ] the_region->page_size = page_size; 400103e0: f6 24 20 58 st %i3, [ %l0 + 0x58 ] the_region->attribute_set = attribute_set; 400103e4: f8 24 20 60 st %i4, [ %l0 + 0x60 ] the_region->number_of_used_blocks = 0; 400103e8: c0 24 20 64 clr [ %l0 + 0x64 ] _Thread_queue_Initialize( 400103ec: 93 37 20 02 srl %i4, 2, %o1 400103f0: 94 10 20 40 mov 0x40, %o2 400103f4: 92 0a 60 01 and %o1, 1, %o1 400103f8: 40 00 1b ea call 400173a0 <_Thread_queue_Initialize> 400103fc: 96 10 20 06 mov 6, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40010400: 90 14 62 f8 or %l1, 0x2f8, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40010404: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40010408: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 4001040c: 03 00 00 3f sethi %hi(0xfc00), %g1 40010410: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40010414: 82 08 c0 01 and %g3, %g1, %g1 40010418: 80 a0 40 02 cmp %g1, %g2 4001041c: 38 80 00 06 bgu,a 40010434 40010420: c6 27 40 00 st %g3, [ %i5 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40010424: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40010428: 83 28 60 02 sll %g1, 2, %g1 4001042c: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 40010430: c6 27 40 00 st %g3, [ %i5 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010434: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %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; 40010438: e8 24 20 0c st %l4, [ %l0 + 0xc ] 4001043c: 82 00 60 01 inc %g1 40010440: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] _RTEMS_Unlock_allocator(); 40010444: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 40010448: 94 10 20 00 clr %o2 4001044c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010450: 40 00 10 23 call 400144dc <_CORE_mutex_Surrender> 40010454: 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 ) 40010458: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 4001045c: 10 bf ff 79 b 40010240 40010460: b0 10 20 00 clr %i0 40010464 : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 40010464: 9d e3 bf 90 save %sp, -112, %sp register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 40010468: 7f ff e9 a4 call 4000aaf8 4001046c: 01 00 00 00 nop 40010470: a2 10 00 08 mov %o0, %l1 40010474: 25 10 00 cd sethi %hi(0x40033400), %l2 40010478: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 4001047c: 80 a0 60 00 cmp %g1, 0 40010480: 02 80 00 0b be 400104ac 40010484: 27 10 00 cd sethi %hi(0x40033400), %l3 40010488: 03 10 00 cd sethi %hi(0x40033400), %g1 <== NOT EXECUTED 4001048c: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 400336c0 <_System_state_Current> <== NOT EXECUTED 40010490: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40010494: 08 80 00 06 bleu 400104ac <== NOT EXECUTED 40010498: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001049c: 92 10 20 00 clr %o1 <== NOT EXECUTED 400104a0: 40 00 12 88 call 40014ec0 <_Internal_error_Occurred> <== NOT EXECUTED 400104a4: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400104a8: 27 10 00 cd sethi %hi(0x40033400), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400104ac: 09 10 00 cd sethi %hi(0x40033400), %g4 400104b0: e0 04 e1 b4 ld [ %l3 + 0x1b4 ], %l0 400104b4: c4 01 21 bc ld [ %g4 + 0x1bc ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 400104b8: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 400104bc: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 400104c0: 80 a0 60 00 cmp %g1, 0 400104c4: 22 80 00 36 be,a 4001059c 400104c8: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 400104cc: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 400104d0: 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; 400104d4: 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; 400104d8: 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; 400104dc: 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; 400104e0: 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 ) || 400104e4: 80 a0 e0 02 cmp %g3, 2 400104e8: 12 80 00 56 bne 40010640 400104ec: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400104f0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400104f4: 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++; 400104f8: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400104fc: 02 80 00 7c be 400106ec 40010500: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 40010504: 7f ff e9 81 call 4000ab08 40010508: 90 10 00 11 mov %l1, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 4001050c: 92 10 00 18 mov %i0, %o1 40010510: 21 10 00 cc sethi %hi(0x40033000), %l0 40010514: 94 07 bf f4 add %fp, -12, %o2 40010518: 40 00 13 e8 call 400154b8 <_Objects_Get_no_protection> 4001051c: 90 14 22 f8 or %l0, 0x2f8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 40010520: c2 07 bf f4 ld [ %fp + -12 ], %g1 40010524: 80 a0 60 01 cmp %g1, 1 40010528: 02 80 00 33 be 400105f4 4001052c: 92 10 00 08 mov %o0, %o1 40010530: 80 a0 60 01 cmp %g1, 1 40010534: 1a 80 00 5f bcc 400106b0 40010538: 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 ) { 4001053c: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 40010540: 80 a0 60 00 cmp %g1, 0 40010544: 22 80 00 99 be,a 400107a8 40010548: 90 14 22 f8 or %l0, 0x2f8, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001054c: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 40010550: 82 00 60 01 inc %g1 40010554: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } _RTEMS_Unlock_allocator(); 40010558: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 4001055c: 94 10 20 00 clr %o2 40010560: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010564: 40 00 0f de call 400144dc <_CORE_mutex_Surrender> 40010568: 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 ) 4001056c: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 40010570: b0 10 20 0c mov 0xc, %i0 40010574: 82 00 7f ff add %g1, -1, %g1 40010578: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] 4001057c: c4 04 a0 e0 ld [ %l2 + 0xe0 ], %g2 40010580: 80 a0 a0 00 cmp %g2, 0 40010584: 12 80 00 49 bne 400106a8 40010588: 01 00 00 00 nop _Thread_Dispatch(); 4001058c: 40 00 19 07 call 400169a8 <_Thread_Dispatch> 40010590: 01 00 00 00 nop 40010594: 81 c7 e0 08 ret 40010598: 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 ) ) { 4001059c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400105a0: 12 80 00 30 bne 40010660 <== NOT EXECUTED 400105a4: c6 04 e1 b4 ld [ %l3 + 0x1b4 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400105a8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 400105ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400105b0: 22 80 00 6a be,a 40010758 <== NOT EXECUTED 400105b4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 400105b8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400105bc: 12 80 00 29 bne 40010660 <== NOT EXECUTED 400105c0: 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; 400105c4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 400105c8: 7f ff e9 50 call 4000ab08 <== NOT EXECUTED 400105cc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400105d0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 400105d4: 21 10 00 cc sethi %hi(0x40033000), %l0 <== NOT EXECUTED 400105d8: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 400105dc: 40 00 13 b7 call 400154b8 <_Objects_Get_no_protection> <== NOT EXECUTED 400105e0: 90 14 22 f8 or %l0, 0x2f8, %o0 <== NOT EXECUTED register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 400105e4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 400105e8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400105ec: 12 bf ff d2 bne 40010534 <== NOT EXECUTED 400105f0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400105f4: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 <== NOT EXECUTED 400105f8: 82 00 60 01 inc %g1 <== NOT EXECUTED 400105fc: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 40010600: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 <== NOT EXECUTED 40010604: 94 10 20 00 clr %o2 <== NOT EXECUTED 40010608: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 4001060c: 40 00 0f b4 call 400144dc <_CORE_mutex_Surrender> <== NOT EXECUTED 40010610: 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 ) 40010614: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 <== NOT EXECUTED 40010618: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001061c: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] <== NOT EXECUTED 40010620: c4 04 a0 e0 ld [ %l2 + 0xe0 ], %g2 <== NOT EXECUTED 40010624: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40010628: 12 80 00 24 bne 400106b8 <== NOT EXECUTED 4001062c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 40010630: 40 00 18 de call 400169a8 <_Thread_Dispatch> <== NOT EXECUTED 40010634: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 40010638: 81 c7 e0 08 ret <== NOT EXECUTED 4001063c: 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 ) || 40010640: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40010644: 12 bf ff b0 bne 40010504 <== NOT EXECUTED 40010648: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4001064c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40010650: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010654: 02 80 00 26 be 400106ec <== NOT EXECUTED 40010658: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 4001065c: 30 bf ff aa b,a 40010504 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010660: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 <== NOT EXECUTED ) { register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 40010664: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40010668: c8 01 21 bc ld [ %g4 + 0x1bc ], %g4 <== NOT EXECUTED 4001066c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010670: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40010674: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] <== NOT EXECUTED 40010678: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 4001067c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40010680: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40010684: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40010688: 7f ff e9 20 call 4000ab08 <== NOT EXECUTED 4001068c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40010690: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 <== NOT EXECUTED 40010694: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010698: 40 00 0f 6d call 4001444c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 4001069c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 400106a0: 10 bf ff 9c b 40010510 <== NOT EXECUTED 400106a4: 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 */ } 400106a8: 81 c7 e0 08 ret <== NOT EXECUTED 400106ac: 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 ) { 400106b0: 02 80 00 04 be 400106c0 400106b4: 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(); 400106b8: 81 c7 e0 08 ret <== NOT EXECUTED 400106bc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400106c0: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 400106c4: 82 00 60 01 inc %g1 400106c8: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 400106cc: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 400106d0: 94 10 20 00 clr %o2 400106d4: d2 02 20 08 ld [ %o0 + 8 ], %o1 400106d8: 40 00 0f 81 call 400144dc <_CORE_mutex_Surrender> 400106dc: 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 ) 400106e0: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 400106e4: 10 bf ff a4 b 40010574 400106e8: b0 10 20 04 mov 4, %i0 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 400106ec: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 400106f0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 400106f4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 400106f8: 02 80 00 28 be 40010798 <== NOT EXECUTED 400106fc: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40010700: 1a 80 00 1c bcc 40010770 <== NOT EXECUTED 40010704: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010708: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 <== NOT EXECUTED 4001070c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010710: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40010714: 7f ff e8 fd call 4000ab08 <== NOT EXECUTED 40010718: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 4001071c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40010720: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40010724: 40 00 17 7d call 40016518 <_Thread_Change_priority> <== NOT EXECUTED 40010728: 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 ) 4001072c: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 <== NOT EXECUTED 40010730: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010734: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] <== NOT EXECUTED 40010738: c4 04 a0 e0 ld [ %l2 + 0xe0 ], %g2 <== NOT EXECUTED 4001073c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40010740: 32 bf ff 74 bne,a 40010510 <== NOT EXECUTED 40010744: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _Thread_Dispatch(); 40010748: 40 00 18 98 call 400169a8 <_Thread_Dispatch> <== NOT EXECUTED 4001074c: 01 00 00 00 nop <== NOT EXECUTED 40010750: 10 bf ff 70 b 40010510 <== NOT EXECUTED 40010754: 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++; 40010758: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001075c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40010760: 7f ff e8 ea call 4000ab08 <== NOT EXECUTED 40010764: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40010768: 10 bf ff 6a b 40010510 <== NOT EXECUTED 4001076c: 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; 40010770: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40010774: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40010778: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 4001077c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40010780: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010784: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40010788: 7f ff e8 e0 call 4000ab08 <== NOT EXECUTED 4001078c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 40010790: 10 bf ff 60 b 40010510 <== NOT EXECUTED 40010794: 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 ); 40010798: 7f ff e8 dc call 4000ab08 <== NOT EXECUTED 4001079c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 400107a0: 10 bf ff 5c b 40010510 <== NOT EXECUTED 400107a4: 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 ); 400107a8: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 400107ac: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 400107b0: 05 00 00 3f sethi %hi(0xfc00), %g2 400107b4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 400107b8: 82 08 40 02 and %g1, %g2, %g1 400107bc: 80 a0 40 03 cmp %g1, %g3 400107c0: 18 80 00 05 bgu 400107d4 400107c4: 01 00 00 00 nop information->local_table[ index ] = the_object; 400107c8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 400107cc: 83 28 60 02 sll %g1, 2, %g1 400107d0: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 400107d4: 40 00 12 f6 call 400153ac <_Objects_Free> 400107d8: c0 22 60 0c clr [ %o1 + 0xc ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400107dc: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 400107e0: 82 00 60 01 inc %g1 400107e4: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] 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(); 400107e8: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 400107ec: 94 10 20 00 clr %o2 400107f0: d2 02 20 08 ld [ %o0 + 8 ], %o1 400107f4: 40 00 0f 3a call 400144dc <_CORE_mutex_Surrender> 400107f8: 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 ) 400107fc: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 40010800: 10 bf ff 5d b 40010574 40010804: b0 10 20 00 clr %i0 40010808 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 40010808: 9d e3 bf 90 save %sp, -112, %sp 4001080c: 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 ) 40010810: 80 a6 60 00 cmp %i1, 0 40010814: 02 80 00 59 be 40010978 40010818: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 4001081c: 7f ff e8 b7 call 4000aaf8 40010820: 01 00 00 00 nop 40010824: a4 10 00 08 mov %o0, %l2 40010828: 23 10 00 cd sethi %hi(0x40033400), %l1 4001082c: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 40010830: 80 a0 60 00 cmp %g1, 0 40010834: 02 80 00 0b be 40010860 40010838: 27 10 00 cd sethi %hi(0x40033400), %l3 4001083c: 03 10 00 cd sethi %hi(0x40033400), %g1 <== NOT EXECUTED 40010840: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 400336c0 <_System_state_Current> <== NOT EXECUTED 40010844: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40010848: 08 80 00 06 bleu 40010860 <== NOT EXECUTED 4001084c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40010850: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010854: 40 00 11 9b call 40014ec0 <_Internal_error_Occurred> <== NOT EXECUTED 40010858: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 4001085c: 27 10 00 cd sethi %hi(0x40033400), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40010860: 09 10 00 cd sethi %hi(0x40033400), %g4 40010864: e0 04 e1 b4 ld [ %l3 + 0x1b4 ], %l0 40010868: c4 01 21 bc ld [ %g4 + 0x1bc ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 4001086c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40010870: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40010874: 80 a0 60 00 cmp %g1, 0 40010878: 22 80 00 42 be,a 40010980 4001087c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40010880: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40010884: 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; 40010888: 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; 4001088c: 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; 40010890: 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; 40010894: 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 ) || 40010898: 80 a0 e0 02 cmp %g3, 2 4001089c: 02 80 00 61 be 40010a20 400108a0: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 400108a4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 400108a8: 22 80 00 60 be,a 40010a28 <== NOT EXECUTED 400108ac: 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 ); 400108b0: 7f ff e8 96 call 4000ab08 400108b4: 90 10 00 12 mov %l2, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 400108b8: 92 10 00 14 mov %l4, %o1 400108bc: 11 10 00 cc sethi %hi(0x40033000), %o0 400108c0: 94 07 bf f4 add %fp, -12, %o2 400108c4: 40 00 12 fd call 400154b8 <_Objects_Get_no_protection> 400108c8: 90 12 22 f8 or %o0, 0x2f8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 400108cc: c2 07 bf f4 ld [ %fp + -12 ], %g1 400108d0: 80 a0 60 01 cmp %g1, 1 400108d4: 02 80 00 40 be 400109d4 400108d8: a0 10 00 08 mov %o0, %l0 400108dc: 80 a0 60 01 cmp %g1, 1 400108e0: 1a 80 00 70 bcc 40010aa0 400108e4: 80 a0 60 02 cmp %g1, 2 _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: heap_status = _Heap_Extend( 400108e8: 92 10 00 19 mov %i1, %o1 400108ec: 94 10 00 1a mov %i2, %o2 400108f0: 90 02 20 68 add %o0, 0x68, %o0 400108f4: 96 07 bf f0 add %fp, -16, %o3 400108f8: 40 00 10 3f call 400149f4 <_Heap_Extend> 400108fc: b0 10 20 09 mov 9, %i0 starting_address, length, &amount_extended ); switch ( heap_status ) { 40010900: 80 a2 20 01 cmp %o0, 1 40010904: 02 80 00 0c be 40010934 40010908: 01 00 00 00 nop 4001090c: 1a 80 00 8e bcc 40010b44 40010910: 82 1a 20 02 xor %o0, 2, %g1 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 40010914: c6 07 bf f0 ld [ %fp + -16 ], %g3 40010918: c4 04 20 54 ld [ %l0 + 0x54 ], %g2 the_region->maximum_segment_size += amount_extended; 4001091c: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 40010920: 84 00 80 03 add %g2, %g3, %g2 the_region->maximum_segment_size += amount_extended; 40010924: 82 00 40 03 add %g1, %g3, %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 40010928: c4 24 20 54 st %g2, [ %l0 + 0x54 ] the_region->maximum_segment_size += amount_extended; 4001092c: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 40010930: b0 10 20 00 clr %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010934: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010938: 82 00 60 01 inc %g1 4001093c: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] break; case HEAP_EXTEND_NOT_IMPLEMENTED: status = RTEMS_NOT_IMPLEMENTED; break; } _RTEMS_Unlock_allocator(); 40010940: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 40010944: 94 10 20 00 clr %o2 40010948: d2 02 20 08 ld [ %o0 + 8 ], %o1 4001094c: 40 00 0e e4 call 400144dc <_CORE_mutex_Surrender> 40010950: 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 ) 40010954: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010958: 82 00 7f ff add %g1, -1, %g1 4001095c: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] 40010960: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 40010964: 80 a0 a0 00 cmp %g2, 0 40010968: 12 80 00 2c bne 40010a18 4001096c: 01 00 00 00 nop _Thread_Dispatch(); 40010970: 40 00 18 0e call 400169a8 <_Thread_Dispatch> 40010974: 01 00 00 00 nop 40010978: 81 c7 e0 08 ret 4001097c: 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 ) ) { 40010980: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40010984: 12 80 00 4d bne 40010ab8 <== NOT EXECUTED 40010988: c6 04 e1 b4 ld [ %l3 + 0x1b4 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 4001098c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40010990: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40010994: 12 80 00 47 bne 40010ab0 <== NOT EXECUTED 40010998: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 4001099c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 400109a0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400109a4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400109a8: 7f ff e8 58 call 4000ab08 <== NOT EXECUTED 400109ac: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400109b0: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 400109b4: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 400109b8: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 400109bc: 40 00 12 bf call 400154b8 <_Objects_Get_no_protection> <== NOT EXECUTED 400109c0: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 400109c4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 400109c8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 400109cc: 12 bf ff c5 bne 400108e0 <== NOT EXECUTED 400109d0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400109d4: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 400109d8: 82 00 60 01 inc %g1 <== NOT EXECUTED 400109dc: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 400109e0: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 <== NOT EXECUTED 400109e4: 94 10 20 00 clr %o2 <== NOT EXECUTED 400109e8: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 400109ec: 40 00 0e bc call 400144dc <_CORE_mutex_Surrender> <== NOT EXECUTED 400109f0: 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 ) 400109f4: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 400109f8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400109fc: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED 40010a00: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 <== NOT EXECUTED 40010a04: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40010a08: 12 80 00 28 bne 40010aa8 <== NOT EXECUTED 40010a0c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 40010a10: 40 00 17 e6 call 400169a8 <_Thread_Dispatch> <== NOT EXECUTED 40010a14: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 40010a18: 81 c7 e0 08 ret <== NOT EXECUTED 40010a1c: 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++; 40010a20: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010a24: 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++; 40010a28: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010a2c: 12 bf ff a1 bne 400108b0 40010a30: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40010a34: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40010a38: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40010a3c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40010a40: 02 80 00 50 be 40010b80 <== NOT EXECUTED 40010a44: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40010a48: 1a 80 00 44 bcc 40010b58 <== NOT EXECUTED 40010a4c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010a50: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 40010a54: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010a58: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40010a5c: 7f ff e8 2b call 4000ab08 <== NOT EXECUTED 40010a60: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40010a64: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40010a68: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40010a6c: 40 00 16 ab call 40016518 <_Thread_Change_priority> <== NOT EXECUTED 40010a70: 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 ) 40010a74: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 40010a78: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010a7c: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED 40010a80: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 <== NOT EXECUTED 40010a84: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40010a88: 32 bf ff 8d bne,a 400108bc <== NOT EXECUTED 40010a8c: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED _Thread_Dispatch(); 40010a90: 40 00 17 c6 call 400169a8 <_Thread_Dispatch> <== NOT EXECUTED 40010a94: 01 00 00 00 nop <== NOT EXECUTED 40010a98: 10 bf ff 89 b 400108bc <== NOT EXECUTED 40010a9c: 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 ) { 40010aa0: 02 80 00 18 be 40010b00 40010aa4: 01 00 00 00 nop 40010aa8: 81 c7 e0 08 ret <== NOT EXECUTED 40010aac: 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 ) { 40010ab0: 02 80 00 1f be 40010b2c <== NOT EXECUTED 40010ab4: c6 04 e1 b4 ld [ %l3 + 0x1b4 ], %g3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010ab8: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED if ( !starting_address ) return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 40010abc: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40010ac0: c8 01 21 bc ld [ %g4 + 0x1bc ], %g4 <== NOT EXECUTED 40010ac4: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010ac8: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40010acc: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED 40010ad0: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40010ad4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40010ad8: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40010adc: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40010ae0: 7f ff e8 0a call 4000ab08 <== NOT EXECUTED 40010ae4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010ae8: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 <== NOT EXECUTED 40010aec: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010af0: 40 00 0e 57 call 4001444c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40010af4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 40010af8: 10 bf ff 71 b 400108bc <== NOT EXECUTED 40010afc: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 40010b00: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010b04: 82 00 60 01 inc %g1 40010b08: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40010b0c: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 40010b10: 94 10 20 00 clr %o2 40010b14: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010b18: 40 00 0e 71 call 400144dc <_CORE_mutex_Surrender> 40010b1c: 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 ) 40010b20: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010b24: 10 bf ff 8d b 40010958 40010b28: 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; 40010b2c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40010b30: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40010b34: 7f ff e7 f5 call 4000ab08 <== NOT EXECUTED 40010b38: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010b3c: 10 bf ff 60 b 400108bc <== NOT EXECUTED 40010b40: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 40010b44: 80 a0 00 01 cmp %g0, %g1 40010b48: 84 60 20 00 subx %g0, 0, %g2 40010b4c: b0 08 bf e8 and %g2, -24, %i0 40010b50: 10 bf ff 79 b 40010934 40010b54: 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; 40010b58: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40010b5c: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40010b60: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40010b64: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40010b68: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010b6c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40010b70: 7f ff e7 e6 call 4000ab08 <== NOT EXECUTED 40010b74: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010b78: 10 bf ff 51 b 400108bc <== NOT EXECUTED 40010b7c: 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 ); 40010b80: 7f ff e7 e2 call 4000ab08 <== NOT EXECUTED 40010b84: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010b88: 10 bf ff 4d b 400108bc <== NOT EXECUTED 40010b8c: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 40010b90 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 40010b90: 9d e3 bf 90 save %sp, -112, %sp 40010b94: aa 10 00 18 mov %i0, %l5 register Region_Control *the_region; Objects_Locations location; Thread_Control *executing; void *the_segment; if ( !segment ) 40010b98: 80 a7 20 00 cmp %i4, 0 40010b9c: 02 80 00 4e be 40010cd4 40010ba0: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; *segment = NULL; if ( size == 0 ) 40010ba4: 80 a6 60 00 cmp %i1, 0 40010ba8: 02 80 00 c8 be 40010ec8 40010bac: c0 27 00 00 clr [ %i4 ] return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 40010bb0: 7f ff e7 d2 call 4000aaf8 40010bb4: 01 00 00 00 nop 40010bb8: a4 10 00 08 mov %o0, %l2 40010bbc: 23 10 00 cd sethi %hi(0x40033400), %l1 40010bc0: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 40010bc4: 80 a0 60 00 cmp %g1, 0 40010bc8: 02 80 00 0b be 40010bf4 40010bcc: 29 10 00 cd sethi %hi(0x40033400), %l4 40010bd0: 03 10 00 cd sethi %hi(0x40033400), %g1 <== NOT EXECUTED 40010bd4: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 400336c0 <_System_state_Current> <== NOT EXECUTED 40010bd8: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 40010bdc: 08 80 00 06 bleu 40010bf4 <== NOT EXECUTED 40010be0: 90 10 20 00 clr %o0 <== NOT EXECUTED 40010be4: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010be8: 40 00 10 b6 call 40014ec0 <_Internal_error_Occurred> <== NOT EXECUTED 40010bec: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 40010bf0: 29 10 00 cd sethi %hi(0x40033400), %l4 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40010bf4: 27 10 00 cd sethi %hi(0x40033400), %l3 40010bf8: e0 05 21 b4 ld [ %l4 + 0x1b4 ], %l0 40010bfc: c4 04 e1 bc ld [ %l3 + 0x1bc ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40010c00: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40010c04: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40010c08: 80 a0 60 00 cmp %g1, 0 40010c0c: 22 80 00 34 be,a 40010cdc 40010c10: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40010c14: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 40010c18: 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; 40010c1c: 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; 40010c20: 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; 40010c24: 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; 40010c28: 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 ) || 40010c2c: 80 a0 e0 02 cmp %g3, 2 40010c30: 02 80 00 54 be 40010d80 40010c34: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 40010c38: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40010c3c: 22 80 00 53 be,a 40010d88 <== NOT EXECUTED 40010c40: 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 ); 40010c44: 7f ff e7 b1 call 4000ab08 40010c48: 90 10 00 12 mov %l2, %o0 executing = _Thread_Executing; 40010c4c: f0 04 e1 bc ld [ %l3 + 0x1bc ], %i0 40010c50: 11 10 00 cc sethi %hi(0x40033000), %o0 40010c54: 92 10 00 15 mov %l5, %o1 40010c58: 90 12 22 f8 or %o0, 0x2f8, %o0 40010c5c: 40 00 12 17 call 400154b8 <_Objects_Get_no_protection> 40010c60: 94 07 bf f4 add %fp, -12, %o2 the_region = _Region_Get( id, &location ); switch ( location ) { 40010c64: c2 07 bf f4 ld [ %fp + -12 ], %g1 40010c68: 80 a0 60 01 cmp %g1, 1 40010c6c: 02 80 00 32 be 40010d34 40010c70: a0 10 00 08 mov %o0, %l0 40010c74: 80 a0 60 01 cmp %g1, 1 40010c78: 1a 80 00 62 bcc 40010e00 40010c7c: 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 ) { 40010c80: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 40010c84: 80 a6 40 01 cmp %i1, %g1 40010c88: 28 80 00 a0 bleu,a 40010f08 40010c8c: 90 02 20 68 add %o0, 0x68, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010c90: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010c94: 82 00 60 01 inc %g1 40010c98: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] _RTEMS_Unlock_allocator(); 40010c9c: d0 05 21 b4 ld [ %l4 + 0x1b4 ], %o0 40010ca0: 94 10 20 00 clr %o2 40010ca4: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010ca8: 40 00 0e 0d call 400144dc <_CORE_mutex_Surrender> 40010cac: 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 ) 40010cb0: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010cb4: 82 00 7f ff add %g1, -1, %g1 40010cb8: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] 40010cbc: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 40010cc0: 80 a0 a0 00 cmp %g2, 0 40010cc4: 12 80 00 81 bne 40010ec8 40010cc8: 01 00 00 00 nop _Thread_Dispatch(); 40010ccc: 40 00 17 37 call 400169a8 <_Thread_Dispatch> 40010cd0: b0 10 20 08 mov 8, %i0 ! 8 40010cd4: 81 c7 e0 08 ret 40010cd8: 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 ) ) { 40010cdc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40010ce0: 12 80 00 4e bne 40010e18 <== NOT EXECUTED 40010ce4: c6 05 21 b4 ld [ %l4 + 0x1b4 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40010ce8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40010cec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40010cf0: 12 80 00 48 bne 40010e10 <== NOT EXECUTED 40010cf4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40010cf8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 40010cfc: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010d00: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 40010d04: 7f ff e7 81 call 4000ab08 <== NOT EXECUTED 40010d08: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010d0c: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40010d10: f0 04 e1 bc ld [ %l3 + 0x1bc ], %i0 <== NOT EXECUTED 40010d14: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED 40010d18: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED 40010d1c: 40 00 11 e7 call 400154b8 <_Objects_Get_no_protection> <== NOT EXECUTED 40010d20: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 40010d24: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 40010d28: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40010d2c: 12 bf ff d3 bne 40010c78 <== NOT EXECUTED 40010d30: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010d34: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 40010d38: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010d3c: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 40010d40: d0 05 21 b4 ld [ %l4 + 0x1b4 ], %o0 <== NOT EXECUTED 40010d44: 94 10 20 00 clr %o2 <== NOT EXECUTED 40010d48: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40010d4c: 40 00 0d e4 call 400144dc <_CORE_mutex_Surrender> <== NOT EXECUTED 40010d50: 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 ) 40010d54: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 40010d58: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010d5c: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED 40010d60: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 <== NOT EXECUTED 40010d64: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40010d68: 12 80 00 28 bne 40010e08 <== NOT EXECUTED 40010d6c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 40010d70: 40 00 17 0e call 400169a8 <_Thread_Dispatch> <== NOT EXECUTED 40010d74: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 40010d78: 81 c7 e0 08 ret <== NOT EXECUTED 40010d7c: 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++; 40010d80: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010d84: 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++; 40010d88: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40010d8c: 12 bf ff ae bne 40010c44 40010d90: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40010d94: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 40010d98: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40010d9c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40010da0: 02 80 00 56 be 40010ef8 <== NOT EXECUTED 40010da4: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40010da8: 1a 80 00 4a bcc 40010ed0 <== NOT EXECUTED 40010dac: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010db0: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 40010db4: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010db8: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40010dbc: 7f ff e7 53 call 4000ab08 <== NOT EXECUTED 40010dc0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40010dc4: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 40010dc8: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40010dcc: 40 00 15 d3 call 40016518 <_Thread_Change_priority> <== NOT EXECUTED 40010dd0: 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 ) 40010dd4: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 40010dd8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010ddc: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED 40010de0: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 <== NOT EXECUTED 40010de4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40010de8: 32 bf ff 9a bne,a 40010c50 <== NOT EXECUTED 40010dec: f0 04 e1 bc ld [ %l3 + 0x1bc ], %i0 <== NOT EXECUTED _Thread_Dispatch(); 40010df0: 40 00 16 ee call 400169a8 <_Thread_Dispatch> <== NOT EXECUTED 40010df4: 01 00 00 00 nop <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40010df8: 10 bf ff 96 b 40010c50 <== NOT EXECUTED 40010dfc: f0 04 e1 bc ld [ %l3 + 0x1bc ], %i0 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 40010e00: 02 80 00 18 be 40010e60 40010e04: 01 00 00 00 nop _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 40010e08: 81 c7 e0 08 ret <== NOT EXECUTED 40010e0c: 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 ) { 40010e10: 02 80 00 28 be 40010eb0 <== NOT EXECUTED 40010e14: c6 05 21 b4 ld [ %l4 + 0x1b4 ], %g3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010e18: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 40010e1c: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 40010e20: c8 04 e1 bc ld [ %l3 + 0x1bc ], %g4 <== NOT EXECUTED 40010e24: 82 00 60 01 inc %g1 <== NOT EXECUTED 40010e28: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 40010e2c: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED 40010e30: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 40010e34: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40010e38: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 40010e3c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 40010e40: 7f ff e7 32 call 4000ab08 <== NOT EXECUTED 40010e44: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010e48: d0 05 21 b4 ld [ %l4 + 0x1b4 ], %o0 <== NOT EXECUTED 40010e4c: 92 10 20 00 clr %o1 <== NOT EXECUTED 40010e50: 40 00 0d 7f call 4001444c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 40010e54: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED executing = _Thread_Executing; 40010e58: 10 bf ff 7e b 40010c50 <== NOT EXECUTED 40010e5c: f0 04 e1 bc ld [ %l3 + 0x1bc ], %i0 <== NOT EXECUTED 40010e60: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010e64: 82 00 60 01 inc %g1 40010e68: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40010e6c: d0 05 21 b4 ld [ %l4 + 0x1b4 ], %o0 40010e70: 94 10 20 00 clr %o2 40010e74: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010e78: 40 00 0d 99 call 400144dc <_CORE_mutex_Surrender> 40010e7c: 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 ) 40010e80: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010e84: b0 10 20 04 mov 4, %i0 _Thread_Dispatch(); 40010e88: 82 00 7f ff add %g1, -1, %g1 40010e8c: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] 40010e90: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 40010e94: 80 a0 a0 00 cmp %g2, 0 40010e98: 12 80 00 6d bne 4001104c 40010e9c: 01 00 00 00 nop 40010ea0: 40 00 16 c2 call 400169a8 <_Thread_Dispatch> 40010ea4: 01 00 00 00 nop 40010ea8: 81 c7 e0 08 ret 40010eac: 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; 40010eb0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40010eb4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 40010eb8: 7f ff e7 14 call 4000ab08 <== NOT EXECUTED 40010ebc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40010ec0: 10 bf ff 64 b 40010c50 <== NOT EXECUTED 40010ec4: f0 04 e1 bc ld [ %l3 + 0x1bc ], %i0 <== NOT EXECUTED _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 40010ec8: 81 c7 e0 08 ret <== NOT EXECUTED 40010ecc: 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; 40010ed0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40010ed4: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40010ed8: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40010edc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 40010ee0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40010ee4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 40010ee8: 7f ff e7 08 call 4000ab08 <== NOT EXECUTED 40010eec: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 40010ef0: 10 bf ff 58 b 40010c50 <== NOT EXECUTED 40010ef4: f0 04 e1 bc ld [ %l3 + 0x1bc ], %i0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 40010ef8: 7f ff e7 04 call 4000ab08 <== NOT EXECUTED 40010efc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 40010f00: 10 bf ff 54 b 40010c50 <== NOT EXECUTED 40010f04: f0 04 e1 bc ld [ %l3 + 0x1bc ], %i0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 40010f08: 40 00 0e 89 call 4001492c <_Heap_Allocate> 40010f0c: 92 10 00 19 mov %i1, %o1 the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 40010f10: a4 92 20 00 orcc %o0, 0, %l2 40010f14: 02 80 00 17 be 40010f70 40010f18: 80 8e a0 01 btst 1, %i2 the_region->number_of_used_blocks += 1; 40010f1c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010f20: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 40010f24: 82 00 60 01 inc %g1 40010f28: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 40010f2c: 84 00 a0 01 inc %g2 40010f30: c4 24 60 e0 st %g2, [ %l1 + 0xe0 ] _RTEMS_Unlock_allocator(); 40010f34: d0 05 21 b4 ld [ %l4 + 0x1b4 ], %o0 40010f38: 94 10 20 00 clr %o2 40010f3c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010f40: 40 00 0d 67 call 400144dc <_CORE_mutex_Surrender> 40010f44: 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 ) 40010f48: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010f4c: 82 00 7f ff add %g1, -1, %g1 40010f50: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] 40010f54: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 40010f58: 80 a0 a0 00 cmp %g2, 0 40010f5c: 02 80 00 12 be 40010fa4 40010f60: 01 00 00 00 nop *segment = the_segment; 40010f64: e4 27 00 00 st %l2, [ %i4 ] <== NOT EXECUTED 40010f68: 81 c7 e0 08 ret 40010f6c: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; } if ( _Options_Is_no_wait( option_set ) ) { 40010f70: 02 80 00 11 be 40010fb4 40010f74: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010f78: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010f7c: 82 00 60 01 inc %g1 40010f80: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] _RTEMS_Unlock_allocator(); 40010f84: d0 05 21 b4 ld [ %l4 + 0x1b4 ], %o0 40010f88: 94 10 20 00 clr %o2 40010f8c: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010f90: 40 00 0d 53 call 400144dc <_CORE_mutex_Surrender> 40010f94: 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 ) 40010f98: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010f9c: 10 bf ff bb b 40010e88 40010fa0: b0 10 20 0d mov 0xd, %i0 _Thread_Dispatch(); 40010fa4: 40 00 16 81 call 400169a8 <_Thread_Dispatch> 40010fa8: 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; 40010fac: 10 bf ff ef b 40010f68 40010fb0: e4 27 00 00 st %l2, [ %i4 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40010fb4: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010fb8: 25 10 00 cd sethi %hi(0x40033400), %l2 40010fbc: 82 00 60 01 inc %g1 40010fc0: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] 40010fc4: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010fc8: 82 00 60 01 inc %g1 40010fcc: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] * 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(); 40010fd0: d0 05 21 b4 ld [ %l4 + 0x1b4 ], %o0 40010fd4: 94 10 20 00 clr %o2 40010fd8: d2 02 20 08 ld [ %o0 + 8 ], %o1 40010fdc: 40 00 0d 40 call 400144dc <_CORE_mutex_Surrender> 40010fe0: 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 ) 40010fe4: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40010fe8: 82 00 7f ff add %g1, -1, %g1 40010fec: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] 40010ff0: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 40010ff4: 80 a0 a0 00 cmp %g2, 0 40010ff8: 02 80 00 17 be 40011054 40010ffc: 01 00 00 00 nop 40011000: 82 10 20 01 mov 1, %g1 ! 1 executing->Wait.queue = &the_region->Wait_queue; 40011004: 90 04 20 10 add %l0, 0x10, %o0 executing->Wait.id = id; 40011008: ea 26 20 20 st %l5, [ %i0 + 0x20 ] executing->Wait.count = size; 4001100c: f2 26 20 24 st %i1, [ %i0 + 0x24 ] executing->Wait.return_argument = segment; 40011010: 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 ); 40011014: 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; 40011018: d0 26 20 44 st %o0, [ %i0 + 0x44 ] 4001101c: 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 ); 40011020: 15 10 00 5d sethi %hi(0x40017400), %o2 40011024: 40 00 17 d1 call 40016f68 <_Thread_queue_Enqueue_with_handler> 40011028: 94 12 a0 a8 or %o2, 0xa8, %o2 ! 400174a8 <_Thread_queue_Timeout> 4001102c: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 40011030: 82 00 7f ff add %g1, -1, %g1 40011034: c2 24 a0 e0 st %g1, [ %l2 + 0xe0 ] 40011038: c4 04 a0 e0 ld [ %l2 + 0xe0 ], %g2 4001103c: 80 a0 a0 00 cmp %g2, 0 40011040: 02 80 00 09 be 40011064 40011044: 01 00 00 00 nop _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 40011048: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 <== NOT EXECUTED 4001104c: 81 c7 e0 08 ret <== NOT EXECUTED 40011050: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40011054: 40 00 16 55 call 400169a8 <_Thread_Dispatch> <== NOT EXECUTED 40011058: 01 00 00 00 nop <== NOT EXECUTED 4001105c: 10 bf ff ea b 40011004 <== NOT EXECUTED 40011060: 82 10 20 01 mov 1, %g1 ! 1 <== NOT EXECUTED 40011064: 40 00 16 51 call 400169a8 <_Thread_Dispatch> 40011068: 01 00 00 00 nop 4001106c: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 40011070: 81 c7 e0 08 ret 40011074: 81 e8 00 00 restore 400110b0 : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 400110b0: 9d e3 bf 90 save %sp, -112, %sp #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 400110b4: 7f ff e6 91 call 4000aaf8 400110b8: 01 00 00 00 nop 400110bc: a4 10 00 08 mov %o0, %l2 400110c0: 23 10 00 cd sethi %hi(0x40033400), %l1 400110c4: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 400110c8: 80 a0 60 00 cmp %g1, 0 400110cc: 02 80 00 0b be 400110f8 400110d0: 27 10 00 cd sethi %hi(0x40033400), %l3 400110d4: 03 10 00 cd sethi %hi(0x40033400), %g1 <== NOT EXECUTED 400110d8: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 400336c0 <_System_state_Current> <== NOT EXECUTED 400110dc: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 400110e0: 08 80 00 06 bleu 400110f8 <== NOT EXECUTED 400110e4: 90 10 20 00 clr %o0 <== NOT EXECUTED 400110e8: 92 10 20 00 clr %o1 <== NOT EXECUTED 400110ec: 40 00 0f 75 call 40014ec0 <_Internal_error_Occurred> <== NOT EXECUTED 400110f0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 400110f4: 27 10 00 cd sethi %hi(0x40033400), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 400110f8: 09 10 00 cd sethi %hi(0x40033400), %g4 400110fc: e0 04 e1 b4 ld [ %l3 + 0x1b4 ], %l0 40011100: c4 01 21 bc ld [ %g4 + 0x1bc ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40011104: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40011108: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 4001110c: 80 a0 60 00 cmp %g1, 0 40011110: 22 80 00 38 be,a 400111f0 40011114: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 40011118: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 4001111c: 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; 40011120: 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; 40011124: 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; 40011128: 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; 4001112c: 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 ) || 40011130: 80 a0 e0 02 cmp %g3, 2 40011134: 12 80 00 58 bne 40011294 40011138: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 4001113c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40011140: 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++; 40011144: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40011148: 02 80 00 7c be 40011338 4001114c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 40011150: 7f ff e6 6e call 4000ab08 40011154: 90 10 00 12 mov %l2, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 40011158: 92 10 00 18 mov %i0, %o1 4001115c: 11 10 00 cc sethi %hi(0x40033000), %o0 40011160: 94 07 bf f4 add %fp, -12, %o2 40011164: 40 00 10 d5 call 400154b8 <_Objects_Get_no_protection> 40011168: 90 12 22 f8 or %o0, 0x2f8, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 4001116c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40011170: 80 a0 60 01 cmp %g1, 1 40011174: 02 80 00 35 be 40011248 40011178: a0 10 00 08 mov %o0, %l0 4001117c: 80 a0 60 01 cmp %g1, 1 40011180: 1a 80 00 5f bcc 400112fc 40011184: 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 ); 40011188: 92 10 00 19 mov %i1, %o1 4001118c: 40 00 0e 4d call 40014ac0 <_Heap_Free> 40011190: 90 02 20 68 add %o0, 0x68, %o0 status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) { 40011194: 80 a2 20 00 cmp %o0, 0 40011198: 32 80 00 97 bne,a 400113f4 4001119c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400111a0: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 400111a4: 82 00 60 01 inc %g1 400111a8: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] _RTEMS_Unlock_allocator(); 400111ac: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 400111b0: 94 10 20 00 clr %o2 400111b4: d2 02 20 08 ld [ %o0 + 8 ], %o1 400111b8: 40 00 0c c9 call 400144dc <_CORE_mutex_Surrender> 400111bc: 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 ) 400111c0: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 400111c4: b0 10 20 09 mov 9, %i0 400111c8: 82 00 7f ff add %g1, -1, %g1 400111cc: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] 400111d0: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 400111d4: 80 a0 a0 00 cmp %g2, 0 400111d8: 12 80 00 8c bne 40011408 400111dc: 01 00 00 00 nop _Thread_Dispatch(); 400111e0: 40 00 15 f2 call 400169a8 <_Thread_Dispatch> 400111e4: 01 00 00 00 nop 400111e8: 81 c7 e0 08 ret 400111ec: 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 ) ) { 400111f0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 400111f4: 12 80 00 30 bne 400112b4 <== NOT EXECUTED 400111f8: c6 04 e1 b4 ld [ %l3 + 0x1b4 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 400111fc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 40011200: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40011204: 22 80 00 68 be,a 400113a4 <== NOT EXECUTED 40011208: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 4001120c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40011210: 12 80 00 29 bne 400112b4 <== NOT EXECUTED 40011214: 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; 40011218: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 4001121c: 7f ff e6 3b call 4000ab08 <== NOT EXECUTED 40011220: 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 *) 40011224: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 40011228: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001122c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 40011230: 40 00 10 a2 call 400154b8 <_Objects_Get_no_protection> <== NOT EXECUTED 40011234: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED #endif int status; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 40011238: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4001123c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 40011240: 12 bf ff d0 bne 40011180 <== NOT EXECUTED 40011244: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011248: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 4001124c: 82 00 60 01 inc %g1 <== NOT EXECUTED 40011250: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 40011254: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 <== NOT EXECUTED 40011258: 94 10 20 00 clr %o2 <== NOT EXECUTED 4001125c: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 40011260: 40 00 0c 9f call 400144dc <_CORE_mutex_Surrender> <== NOT EXECUTED 40011264: 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 ) 40011268: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 4001126c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40011270: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED 40011274: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 <== NOT EXECUTED 40011278: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001127c: 12 80 00 22 bne 40011304 <== NOT EXECUTED 40011280: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 40011284: 40 00 15 c9 call 400169a8 <_Thread_Dispatch> <== NOT EXECUTED 40011288: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 4001128c: 81 c7 e0 08 ret <== NOT EXECUTED 40011290: 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 ) || 40011294: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 40011298: 12 bf ff ae bne 40011150 <== NOT EXECUTED 4001129c: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 400112a0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400112a4: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 400112a8: 02 80 00 24 be 40011338 <== NOT EXECUTED 400112ac: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 400112b0: 30 bf ff a8 b,a 40011150 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 400112b4: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 400112b8: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 400112bc: c8 01 21 bc ld [ %g4 + 0x1bc ], %g4 <== NOT EXECUTED 400112c0: 82 00 60 01 inc %g1 <== NOT EXECUTED 400112c4: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 400112c8: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED 400112cc: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 400112d0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 400112d4: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 400112d8: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 400112dc: 7f ff e6 0b call 4000ab08 <== NOT EXECUTED 400112e0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400112e4: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 <== NOT EXECUTED 400112e8: 92 10 20 00 clr %o1 <== NOT EXECUTED 400112ec: 40 00 0c 58 call 4001444c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 400112f0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 400112f4: 10 bf ff 9a b 4001115c <== NOT EXECUTED 400112f8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 400112fc: 02 80 00 04 be 4001130c 40011300: 01 00 00 00 nop the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator internally */ return RTEMS_SUCCESSFUL; 40011304: 81 c7 e0 08 ret <== NOT EXECUTED 40011308: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 4001130c: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40011310: 82 00 60 01 inc %g1 40011314: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 40011318: d0 04 e1 b4 ld [ %l3 + 0x1b4 ], %o0 4001131c: 94 10 20 00 clr %o2 40011320: d2 02 20 08 ld [ %o0 + 8 ], %o1 40011324: 40 00 0c 6e call 400144dc <_CORE_mutex_Surrender> 40011328: 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 ) 4001132c: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40011330: 10 bf ff a6 b 400111c8 40011334: b0 10 20 04 mov 4, %i0 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40011338: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 4001133c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40011340: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 40011344: 02 80 00 28 be 400113e4 <== NOT EXECUTED 40011348: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 4001134c: 1a 80 00 1c bcc 400113bc <== NOT EXECUTED 40011350: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011354: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 40011358: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001135c: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40011360: 7f ff e5 ea call 4000ab08 <== NOT EXECUTED 40011364: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 40011368: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 4001136c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 40011370: 40 00 14 6a call 40016518 <_Thread_Change_priority> <== NOT EXECUTED 40011374: 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 ) 40011378: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 4001137c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40011380: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED 40011384: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 <== NOT EXECUTED 40011388: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001138c: 32 bf ff 74 bne,a 4001115c <== NOT EXECUTED 40011390: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _Thread_Dispatch(); 40011394: 40 00 15 85 call 400169a8 <_Thread_Dispatch> <== NOT EXECUTED 40011398: 01 00 00 00 nop <== NOT EXECUTED 4001139c: 10 bf ff 70 b 4001115c <== NOT EXECUTED 400113a0: 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++; 400113a4: 82 00 60 01 inc %g1 <== NOT EXECUTED 400113a8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 400113ac: 7f ff e5 d7 call 4000ab08 <== NOT EXECUTED 400113b0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400113b4: 10 bf ff 6a b 4001115c <== NOT EXECUTED 400113b8: 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; 400113bc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 400113c0: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 400113c4: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 400113c8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 400113cc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400113d0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400113d4: 7f ff e5 cd call 4000ab08 <== NOT EXECUTED 400113d8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400113dc: 10 bf ff 60 b 4001115c <== NOT EXECUTED 400113e0: 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 ); 400113e4: 7f ff e5 c9 call 4000ab08 <== NOT EXECUTED 400113e8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 400113ec: 10 bf ff 5c b 4001115c <== NOT EXECUTED 400113f0: 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 */ 400113f4: 90 10 00 10 mov %l0, %o0 if ( !status ) { _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 400113f8: 82 00 7f ff add %g1, -1, %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 400113fc: b0 10 20 00 clr %i0 40011400: 40 00 24 76 call 4001a5d8 <_Region_Process_queue> 40011404: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 40011408: 81 c7 e0 08 ret 4001140c: 81 e8 00 00 restore 40005a2c : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 40005a2c: 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 ) ) 40005a30: aa 96 20 00 orcc %i0, 0, %l5 40005a34: 02 80 00 12 be 40005a7c 40005a38: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 40005a3c: 80 a7 20 00 cmp %i4, 0 40005a40: 02 80 00 0f be 40005a7c 40005a44: b0 10 20 09 mov 9, %i0 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 40005a48: a4 8e a0 40 andcc %i2, 0x40, %l2 40005a4c: 12 80 00 0e bne 40005a84 40005a50: a0 0e a0 30 and %i2, 0x30, %l0 40005a54: 80 8e a0 80 btst 0x80, %i2 40005a58: 12 80 00 0c bne 40005a88 40005a5c: 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); 40005a60: 80 a0 00 10 cmp %g0, %l0 40005a64: 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 ) ) 40005a68: 80 a4 60 00 cmp %l1, 0 40005a6c: 12 80 00 17 bne 40005ac8 40005a70: 80 a6 60 01 cmp %i1, 1 40005a74: 08 80 00 15 bleu 40005ac8 40005a78: b0 10 20 0a mov 0xa, %i0 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 40005a7c: 81 c7 e0 08 ret 40005a80: 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 ) || 40005a84: 80 a4 20 10 cmp %l0, 0x10 40005a88: 12 80 00 0b bne 40005ab4 40005a8c: 80 a4 20 20 cmp %l0, 0x20 40005a90: 80 8e a0 04 btst 4, %i2 40005a94: 02 80 00 06 be 40005aac 40005a98: 80 a4 a0 00 cmp %l2, 0 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 40005a9c: 02 bf ff f1 be 40005a60 40005aa0: 80 8e a0 80 btst 0x80, %i2 40005aa4: 02 bf ff f0 be 40005a64 40005aa8: 80 a0 00 10 cmp %g0, %l0 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 40005aac: 81 c7 e0 08 ret 40005ab0: 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 ) || 40005ab4: 12 bf ff fe bne 40005aac 40005ab8: 80 8e a0 04 btst 4, %i2 40005abc: 12 bf ff f8 bne 40005a9c 40005ac0: 80 a4 a0 00 cmp %l2, 0 40005ac4: 30 bf ff fa b,a 40005aac <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40005ac8: 29 10 00 66 sethi %hi(0x40019800), %l4 40005acc: c2 05 23 10 ld [ %l4 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> 40005ad0: 82 00 60 01 inc %g1 40005ad4: c2 25 23 10 st %g1, [ %l4 + 0x310 ] * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 40005ad8: 31 10 00 66 sethi %hi(0x40019800), %i0 40005adc: 40 00 07 28 call 4000777c <_Objects_Allocate> 40005ae0: 90 16 21 c4 or %i0, 0x1c4, %o0 ! 400199c4 <_Semaphore_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 40005ae4: a6 92 20 00 orcc %o0, 0, %l3 40005ae8: 12 80 00 0e bne 40005b20 40005aec: 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 ) 40005af0: c2 05 23 10 ld [ %l4 + 0x310 ], %g1 40005af4: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 40005af8: 82 00 7f ff add %g1, -1, %g1 40005afc: c2 25 23 10 st %g1, [ %l4 + 0x310 ] 40005b00: c4 05 23 10 ld [ %l4 + 0x310 ], %g2 40005b04: 80 a0 a0 00 cmp %g2, 0 40005b08: 12 80 00 04 bne 40005b18 40005b0c: 01 00 00 00 nop 40005b10: 40 00 0d 94 call 40009160 <_Thread_Dispatch> 40005b14: 01 00 00 00 nop 40005b18: 81 c7 e0 08 ret 40005b1c: 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 ) ) { 40005b20: 12 80 00 1e bne 40005b98 40005b24: f4 24 e0 10 st %i2, [ %l3 + 0x10 ] CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 40005b28: 80 a4 a0 00 cmp %l2, 0 40005b2c: 02 80 00 39 be 40005c10 40005b30: 80 8e a0 80 btst 0x80, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 40005b34: 82 10 20 02 mov 2, %g1 40005b38: 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 ) ) { 40005b3c: 80 a4 20 10 cmp %l0, 0x10 40005b40: 12 80 00 39 bne 40005c24 40005b44: 82 10 20 02 mov 2, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 40005b48: c2 07 bf e8 ld [ %fp + -24 ], %g1 40005b4c: 80 a0 60 01 cmp %g1, 1 40005b50: 18 80 00 3d bgu 40005c44 40005b54: c0 27 bf e0 clr [ %fp + -32 ] case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; 40005b58: 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( 40005b5c: 82 1e 60 01 xor %i1, 1, %g1 40005b60: 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; 40005b64: f6 27 bf ec st %i3, [ %fp + -20 ] mutex_status = _CORE_mutex_Initialize( 40005b68: 94 60 3f ff subx %g0, -1, %o2 40005b6c: 90 04 e0 14 add %l3, 0x14, %o0 40005b70: 40 00 04 76 call 40006d48 <_CORE_mutex_Initialize> 40005b74: 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 ) { 40005b78: 80 a2 20 06 cmp %o0, 6 40005b7c: 12 80 00 14 bne 40005bcc 40005b80: 90 16 21 c4 or %i0, 0x1c4, %o0 RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 40005b84: 40 00 08 0c call 40007bb4 <_Objects_Free> <== NOT EXECUTED 40005b88: 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 ) 40005b8c: c2 05 23 10 ld [ %l4 + 0x310 ], %g1 <== NOT EXECUTED 40005b90: 10 bf ff da b 40005af8 <== NOT EXECUTED 40005b94: 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 ) ) 40005b98: 80 8e a0 04 btst 4, %i2 40005b9c: 22 80 00 04 be,a 40005bac 40005ba0: c0 27 bf f4 clr [ %fp + -12 ] the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 40005ba4: 82 10 20 01 mov 1, %g1 40005ba8: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 40005bac: 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; 40005bb0: c0 27 bf e0 clr [ %fp + -32 ] the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 40005bb4: c0 27 bf ec clr [ %fp + -20 ] _CORE_semaphore_Initialize( 40005bb8: 94 10 00 19 mov %i1, %o2 /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 40005bbc: 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( 40005bc0: 90 04 e0 14 add %l3, 0x14, %o0 40005bc4: 40 00 05 1e call 4000703c <_CORE_semaphore_Initialize> 40005bc8: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005bcc: 90 16 21 c4 or %i0, 0x1c4, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 40005bd0: c6 04 e0 08 ld [ %l3 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005bd4: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 40005bd8: 03 00 00 3f sethi %hi(0xfc00), %g1 40005bdc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 40005be0: 82 08 c0 01 and %g3, %g1, %g1 40005be4: 80 a0 40 02 cmp %g1, %g2 40005be8: 38 80 00 06 bgu,a 40005c00 40005bec: ea 24 e0 0c st %l5, [ %l3 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40005bf0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40005bf4: 83 28 60 02 sll %g1, 2, %g1 40005bf8: 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; 40005bfc: ea 24 e0 0c st %l5, [ %l3 + 0xc ] &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 40005c00: c6 27 00 00 st %g3, [ %i4 ] 40005c04: c2 05 23 10 ld [ %l4 + 0x310 ], %g1 40005c08: 10 bf ff bc b 40005af8 40005c0c: 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 ) ) 40005c10: 02 80 00 08 be 40005c30 40005c14: 80 8e a0 04 btst 4, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 40005c18: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 40005c1c: 10 bf ff c8 b 40005b3c <== NOT EXECUTED 40005c20: 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; 40005c24: 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; 40005c28: 10 bf ff cd b 40005b5c 40005c2c: 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 ) ) 40005c30: 22 bf ff c3 be,a 40005b3c 40005c34: c0 27 bf e8 clr [ %fp + -24 ] the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 40005c38: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 40005c3c: 10 bf ff c0 b 40005b3c <== NOT EXECUTED 40005c40: 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 ) { 40005c44: 80 a0 60 03 cmp %g1, 3 40005c48: 18 bf ff c6 bgu 40005b60 40005c4c: 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; 40005c50: 82 10 20 01 mov 1, %g1 40005c54: 10 bf ff c2 b 40005b5c 40005c58: c2 27 bf e4 st %g1, [ %fp + -28 ] 40005c5c : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 40005c5c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 40005c60: 21 10 00 66 sethi %hi(0x40019800), %l0 40005c64: 92 10 00 18 mov %i0, %o1 40005c68: 94 07 bf f4 add %fp, -12, %o2 40005c6c: 40 00 08 15 call 40007cc0 <_Objects_Get> 40005c70: 90 14 21 c4 or %l0, 0x1c4, %o0 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 40005c74: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005c78: 80 a0 60 00 cmp %g1, 0 40005c7c: 12 80 00 19 bne 40005ce0 40005c80: b0 10 00 08 mov %o0, %i0 40005c84: 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) ) { 40005c88: 84 88 60 30 andcc %g1, 0x30, %g2 40005c8c: 22 80 00 1a be,a 40005cf4 40005c90: 90 02 20 14 add %o0, 0x14, %o0 if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 40005c94: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 40005c98: 80 a0 60 00 cmp %g1, 0 40005c9c: 12 80 00 35 bne 40005d70 40005ca0: 80 a0 a0 20 cmp %g2, 0x20 40005ca4: 02 80 00 34 be 40005d74 40005ca8: 90 06 20 14 add %i0, 0x14, %o0 40005cac: 03 10 00 66 sethi %hi(0x40019800), %g1 40005cb0: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 40019b10 <_Thread_Dispatch_disable_level> 40005cb4: b0 10 20 0c mov 0xc, %i0 40005cb8: 84 00 bf ff add %g2, -1, %g2 40005cbc: c4 20 63 10 st %g2, [ %g1 + 0x310 ] 40005cc0: c6 00 63 10 ld [ %g1 + 0x310 ], %g3 40005cc4: 80 a0 e0 00 cmp %g3, 0 40005cc8: 12 80 00 28 bne 40005d68 40005ccc: 01 00 00 00 nop _Thread_Dispatch(); 40005cd0: 40 00 0d 24 call 40009160 <_Thread_Dispatch> 40005cd4: 01 00 00 00 nop 40005cd8: 81 c7 e0 08 ret 40005cdc: 81 e8 00 00 restore { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 40005ce0: 80 a0 60 02 cmp %g1, 2 40005ce4: 08 bf ff fd bleu 40005cd8 40005ce8: b0 10 20 04 mov 4, %i0 40005cec: 81 c7 e0 08 ret <== NOT EXECUTED 40005cf0: 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( 40005cf4: 92 10 20 00 clr %o1 40005cf8: 40 00 04 cd call 4000702c <_CORE_semaphore_Flush> 40005cfc: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005d00: 90 14 21 c4 or %l0, 0x1c4, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40005d04: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005d08: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 40005d0c: 05 00 00 3f sethi %hi(0xfc00), %g2 40005d10: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40005d14: 82 08 40 02 and %g1, %g2, %g1 40005d18: 80 a0 40 03 cmp %g1, %g3 40005d1c: 38 80 00 06 bgu,a 40005d34 40005d20: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40005d24: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 40005d28: 83 28 60 02 sll %g1, 2, %g1 40005d2c: 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; 40005d30: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 40005d34: 40 00 07 a0 call 40007bb4 <_Objects_Free> 40005d38: 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 ) 40005d3c: 03 10 00 66 sethi %hi(0x40019800), %g1 40005d40: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 40019b10 <_Thread_Dispatch_disable_level> 40005d44: b0 10 20 00 clr %i0 40005d48: 84 00 bf ff add %g2, -1, %g2 40005d4c: c4 20 63 10 st %g2, [ %g1 + 0x310 ] 40005d50: c6 00 63 10 ld [ %g1 + 0x310 ], %g3 40005d54: 80 a0 e0 00 cmp %g3, 0 40005d58: 12 80 00 04 bne 40005d68 40005d5c: 01 00 00 00 nop _Thread_Dispatch(); 40005d60: 40 00 0d 00 call 40009160 <_Thread_Dispatch> 40005d64: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40005d68: 81 c7 e0 08 ret 40005d6c: 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( 40005d70: 90 06 20 14 add %i0, 0x14, %o0 40005d74: 92 10 20 00 clr %o1 40005d78: 40 00 03 f0 call 40006d38 <_CORE_mutex_Flush> 40005d7c: 94 10 20 04 mov 4, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40005d80: 10 bf ff e1 b 40005d04 40005d84: 90 14 21 c4 or %l0, 0x1c4, %o0 40006228 : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 40006228: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 4000622c: 11 10 00 6d sethi %hi(0x4001b400), %o0 40006230: 92 10 00 18 mov %i0, %o1 40006234: 90 12 20 dc or %o0, 0xdc, %o0 40006238: 40 00 08 75 call 4000840c <_Objects_Get> 4000623c: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 40006240: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006244: 80 a0 60 00 cmp %g1, 0 40006248: 12 80 00 16 bne 400062a0 4000624c: 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) ) { 40006250: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40006254: 80 88 60 30 btst 0x30, %g1 40006258: 12 80 00 16 bne 400062b0 4000625c: 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( 40006260: 92 10 20 00 clr %o1 <== NOT EXECUTED 40006264: 40 00 05 45 call 40007778 <_CORE_semaphore_Flush> <== NOT EXECUTED 40006268: 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 ) 4000626c: 03 10 00 6d sethi %hi(0x4001b400), %g1 40006270: c4 00 62 30 ld [ %g1 + 0x230 ], %g2 ! 4001b630 <_Thread_Dispatch_disable_level> 40006274: b0 10 20 00 clr %i0 40006278: 84 00 bf ff add %g2, -1, %g2 4000627c: c4 20 62 30 st %g2, [ %g1 + 0x230 ] 40006280: c6 00 62 30 ld [ %g1 + 0x230 ], %g3 40006284: 80 a0 e0 00 cmp %g3, 0 40006288: 12 80 00 04 bne 40006298 4000628c: 01 00 00 00 nop _Thread_Dispatch(); 40006290: 40 00 0d 4b call 400097bc <_Thread_Dispatch> 40006294: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006298: 81 c7 e0 08 ret 4000629c: 81 e8 00 00 restore { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 400062a0: 08 bf ff fe bleu 40006298 <== NOT EXECUTED 400062a4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 400062a8: 81 c7 e0 08 ret <== NOT EXECUTED 400062ac: 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( 400062b0: 92 10 20 00 clr %o1 400062b4: 40 00 04 74 call 40007484 <_CORE_mutex_Flush> 400062b8: 94 10 20 01 mov 1, %o2 400062bc: 30 bf ff ec b,a 4000626c 40005d88 : rtems_status_code rtems_semaphore_obtain( rtems_id id, uint32_t option_set, rtems_interval timeout ) { 40005d88: 9d e3 bf 90 save %sp, -112, %sp Objects_Id id, Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) 40005d8c: 11 10 00 66 sethi %hi(0x40019800), %o0 40005d90: 92 10 00 18 mov %i0, %o1 40005d94: 90 12 21 c4 or %o0, 0x1c4, %o0 40005d98: 94 07 bf f4 add %fp, -12, %o2 40005d9c: 40 00 07 ab call 40007c48 <_Objects_Get_isr_disable> 40005da0: 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 ) { 40005da4: c2 07 bf f4 ld [ %fp + -12 ], %g1 40005da8: 80 a0 60 00 cmp %g1, 0 40005dac: 12 80 00 19 bne 40005e10 40005db0: 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) ) { 40005db4: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40005db8: 80 88 60 30 btst 0x30, %g1 40005dbc: 12 80 00 1b bne 40005e28 40005dc0: 23 10 00 66 sethi %hi(0x40019800), %l1 Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 40005dc4: 27 10 00 66 sethi %hi(0x40019800), %l3 40005dc8: e4 04 e3 ec ld [ %l3 + 0x3ec ], %l2 ! 40019bec <_Thread_Executing> Watchdog_Interval timeout, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 40005dcc: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 40005dd0: c0 24 a0 34 clr [ %l2 + 0x34 ] if ( the_semaphore->count != 0 ) { 40005dd4: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 40005dd8: 80 a0 60 00 cmp %g1, 0 40005ddc: 12 80 00 8f bne 40006018 40005de0: 80 8e 60 01 btst 1, %i1 the_semaphore->count -= 1; _ISR_Enable( level ); return; } if ( !wait ) { 40005de4: 02 80 00 73 be 40005fb0 40005de8: 01 00 00 00 nop _ISR_Enable( level ); 40005dec: 7f ff ef ff call 40001de8 40005df0: 01 00 00 00 nop executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 40005df4: 82 10 20 01 mov 1, %g1 ! 1 40005df8: 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( 40005dfc: c2 04 e3 ec ld [ %l3 + 0x3ec ], %g1 40005e00: 40 00 00 f4 call 400061d0 <_Semaphore_Translate_core_semaphore_return_code> 40005e04: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40005e08: 81 c7 e0 08 ret 40005e0c: 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 ) { 40005e10: 80 a0 60 02 cmp %g1, 2 40005e14: 08 bf ff fd bleu 40005e08 40005e18: 90 10 20 04 mov 4, %o0 40005e1c: 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 */ } 40005e20: 81 c7 e0 08 ret <== NOT EXECUTED 40005e24: 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( 40005e28: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 40005e2c: 80 a0 60 00 cmp %g1, 0 40005e30: 02 80 00 0e be 40005e68 40005e34: 27 10 00 66 sethi %hi(0x40019800), %l3 40005e38: 80 8e 60 01 btst 1, %i1 40005e3c: 12 80 00 0c bne 40005e6c 40005e40: c6 04 e3 ec ld [ %l3 + 0x3ec ], %g3 40005e44: 03 10 00 67 sethi %hi(0x40019c00), %g1 40005e48: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 40019cf0 <_System_state_Current> 40005e4c: 80 a0 a0 01 cmp %g2, 1 40005e50: 08 80 00 07 bleu 40005e6c 40005e54: 90 10 20 00 clr %o0 40005e58: 92 10 20 00 clr %o1 <== NOT EXECUTED 40005e5c: 40 00 06 1b call 400076c8 <_Internal_error_Occurred> <== NOT EXECUTED 40005e60: 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; 40005e64: 27 10 00 66 sethi %hi(0x40019800), %l3 <== NOT EXECUTED 40005e68: c6 04 e3 ec ld [ %l3 + 0x3ec ], %g3 ! 40019bec <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 40005e6c: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 40005e70: c0 20 e0 34 clr [ %g3 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 40005e74: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 40005e78: 80 a0 60 00 cmp %g1, 0 40005e7c: 22 80 00 37 be,a 40005f58 40005e80: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 40005e84: c0 24 20 64 clr [ %l0 + 0x64 ] the_mutex->holder = executing; 40005e88: c6 24 20 70 st %g3, [ %l0 + 0x70 ] the_mutex->holder_id = executing->Object.id; 40005e8c: 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; 40005e90: 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; 40005e94: 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; 40005e98: c2 24 20 74 st %g1, [ %l0 + 0x74 ] the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 40005e9c: 80 a0 a0 02 cmp %g2, 2 40005ea0: 12 80 00 24 bne 40005f30 40005ea4: c8 24 20 68 st %g4, [ %l0 + 0x68 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 40005ea8: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 40005eac: 82 00 60 01 inc %g1 40005eb0: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 40005eb4: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 40005eb8: 80 a0 a0 03 cmp %g2, 3 40005ebc: 12 80 00 20 bne 40005f3c 40005ec0: 01 00 00 00 nop */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 40005ec4: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 <== NOT EXECUTED current = executing->current_priority; 40005ec8: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 40005ecc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 40005ed0: 02 80 00 79 be 400060b4 <== NOT EXECUTED 40005ed4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 40005ed8: 1a 80 00 6d bcc 4000608c <== NOT EXECUTED 40005edc: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40005ee0: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 40005ee4: 82 00 60 01 inc %g1 <== NOT EXECUTED 40005ee8: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 40005eec: 7f ff ef bf call 40001de8 <== NOT EXECUTED 40005ef0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Change_priority( 40005ef4: d2 04 20 60 ld [ %l0 + 0x60 ], %o1 <== NOT EXECUTED 40005ef8: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 <== NOT EXECUTED 40005efc: 40 00 0b 75 call 40008cd0 <_Thread_Change_priority> <== NOT EXECUTED 40005f00: 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 ) 40005f04: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 <== NOT EXECUTED 40005f08: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 40005f0c: c2 24 63 10 st %g1, [ %l1 + 0x310 ] <== NOT EXECUTED 40005f10: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 <== NOT EXECUTED 40005f14: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40005f18: 32 80 00 0c bne,a 40005f48 <== NOT EXECUTED 40005f1c: c2 04 e3 ec ld [ %l3 + 0x3ec ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 40005f20: 40 00 0c 90 call 40009160 <_Thread_Dispatch> <== NOT EXECUTED 40005f24: 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( 40005f28: 10 80 00 08 b 40005f48 <== NOT EXECUTED 40005f2c: c2 04 e3 ec ld [ %l3 + 0x3ec ], %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 ) || 40005f30: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 40005f34: 22 bf ff de be,a 40005eac <== NOT EXECUTED 40005f38: 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 ); 40005f3c: 7f ff ef ab call 40001de8 40005f40: 01 00 00 00 nop 40005f44: c2 04 e3 ec ld [ %l3 + 0x3ec ], %g1 40005f48: 40 00 00 98 call 400061a8 <_Semaphore_Translate_core_mutex_return_code> 40005f4c: 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 */ } 40005f50: 81 c7 e0 08 ret 40005f54: 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 ) ) { 40005f58: 80 a0 40 03 cmp %g1, %g3 40005f5c: 12 80 00 0d bne 40005f90 40005f60: 80 8e 60 01 btst 1, %i1 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 40005f64: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 40005f68: 80 a0 60 00 cmp %g1, 0 40005f6c: 12 80 00 40 bne 4000606c 40005f70: 80 a0 60 01 cmp %g1, 1 case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 40005f74: c2 04 20 68 ld [ %l0 + 0x68 ], %g1 40005f78: 82 00 60 01 inc %g1 40005f7c: c2 24 20 68 st %g1, [ %l0 + 0x68 ] _ISR_Enable( level ); 40005f80: 7f ff ef 9a call 40001de8 40005f84: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 40005f88: 10 bf ff f0 b 40005f48 40005f8c: c2 04 e3 ec ld [ %l3 + 0x3ec ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 40005f90: 02 80 00 28 be 40006030 40005f94: c6 04 e3 ec ld [ %l3 + 0x3ec ], %g3 40005f98: 7f ff ef 94 call 40001de8 40005f9c: d0 07 bf f0 ld [ %fp + -16 ], %o0 40005fa0: c4 04 e3 ec ld [ %l3 + 0x3ec ], %g2 40005fa4: 82 10 20 01 mov 1, %g1 40005fa8: 10 bf ff e7 b 40005f44 40005fac: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40005fb0: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 40005fb4: 82 00 60 01 inc %g1 40005fb8: c2 24 63 10 st %g1, [ %l1 + 0x310 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 40005fbc: 82 10 20 01 mov 1, %g1 40005fc0: 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; 40005fc4: 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; 40005fc8: a0 04 20 14 add %l0, 0x14, %l0 40005fcc: e0 24 a0 44 st %l0, [ %l2 + 0x44 ] executing->Wait.id = id; _ISR_Enable( level ); 40005fd0: 7f ff ef 86 call 40001de8 40005fd4: 01 00 00 00 nop _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 40005fd8: 90 10 00 10 mov %l0, %o0 40005fdc: 92 10 00 1a mov %i2, %o1 40005fe0: 15 10 00 27 sethi %hi(0x40009c00), %o2 40005fe4: 40 00 0d cf call 40009720 <_Thread_queue_Enqueue_with_handler> 40005fe8: 94 12 a0 60 or %o2, 0x60, %o2 ! 40009c60 <_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 ) 40005fec: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 40005ff0: 82 00 7f ff add %g1, -1, %g1 40005ff4: c2 24 63 10 st %g1, [ %l1 + 0x310 ] 40005ff8: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 40005ffc: 80 a0 a0 00 cmp %g2, 0 40006000: 32 bf ff 80 bne,a 40005e00 40006004: c2 04 e3 ec ld [ %l3 + 0x3ec ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 40006008: 40 00 0c 56 call 40009160 <_Thread_Dispatch> 4000600c: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 40006010: 10 bf ff 7c b 40005e00 40006014: c2 04 e3 ec ld [ %l3 + 0x3ec ], %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; 40006018: 82 00 7f ff add %g1, -1, %g1 4000601c: c2 24 20 5c st %g1, [ %l0 + 0x5c ] _ISR_Enable( level ); 40006020: 7f ff ef 72 call 40001de8 40006024: 01 00 00 00 nop 40006028: 10 bf ff 76 b 40005e00 4000602c: c2 04 e3 ec ld [ %l3 + 0x3ec ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006030: c4 04 63 10 ld [ %l1 + 0x310 ], %g2 40006034: 82 10 20 01 mov 1, %g1 40006038: 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( 4000603c: f0 20 e0 20 st %i0, [ %g3 + 0x20 ] 40006040: 84 00 a0 01 inc %g2 40006044: a0 04 20 14 add %l0, 0x14, %l0 40006048: c4 24 63 10 st %g2, [ %l1 + 0x310 ] 4000604c: e0 20 e0 44 st %l0, [ %g3 + 0x44 ] 40006050: 7f ff ef 66 call 40001de8 40006054: d0 07 bf f0 ld [ %fp + -16 ], %o0 40006058: 90 10 00 10 mov %l0, %o0 4000605c: 40 00 03 74 call 40006e2c <_CORE_mutex_Seize_interrupt_blocking> 40006060: 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( 40006064: 10 bf ff b9 b 40005f48 40006068: c2 04 e3 ec ld [ %l3 + 0x3ec ], %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 ) { 4000606c: 12 bf ff c9 bne 40005f90 40006070: 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; 40006074: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 40006078: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 4000607c: 7f ff ef 5b call 40001de8 <== NOT EXECUTED 40006080: 01 00 00 00 nop <== NOT EXECUTED 40006084: 10 bf ff b1 b 40005f48 <== NOT EXECUTED 40006088: c2 04 e3 ec ld [ %l3 + 0x3ec ], %g1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 4000608c: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 40006090: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 40006094: c0 24 20 68 clr [ %l0 + 0x68 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 40006098: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 4000609c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400060a0: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 400060a4: 7f ff ef 51 call 40001de8 <== NOT EXECUTED 400060a8: 01 00 00 00 nop <== NOT EXECUTED 400060ac: 10 bf ff a7 b 40005f48 <== NOT EXECUTED 400060b0: c2 04 e3 ec ld [ %l3 + 0x3ec ], %g1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 400060b4: 7f ff ef 4d call 40001de8 <== NOT EXECUTED 400060b8: 01 00 00 00 nop <== NOT EXECUTED 400060bc: 10 bf ff a3 b 40005f48 <== NOT EXECUTED 400060c0: c2 04 e3 ec ld [ %l3 + 0x3ec ], %g1 <== NOT EXECUTED 400060c4 : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 400060c4: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 400060c8: 11 10 00 66 sethi %hi(0x40019800), %o0 400060cc: 92 10 00 18 mov %i0, %o1 400060d0: 90 12 21 c4 or %o0, 0x1c4, %o0 400060d4: 40 00 06 fb call 40007cc0 <_Objects_Get> 400060d8: 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 ) { 400060dc: c2 07 bf f4 ld [ %fp + -12 ], %g1 400060e0: 80 a0 60 00 cmp %g1, 0 400060e4: 12 80 00 16 bne 4000613c 400060e8: 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) ) { 400060ec: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 400060f0: 80 88 60 30 btst 0x30, %g1 400060f4: 02 80 00 17 be 40006150 400060f8: 92 10 00 18 mov %i0, %o1 mutex_status = _CORE_mutex_Surrender( 400060fc: 94 10 20 00 clr %o2 40006100: 40 00 03 6f call 40006ebc <_CORE_mutex_Surrender> 40006104: 90 02 20 14 add %o0, 0x14, %o0 40006108: 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 ) 4000610c: 03 10 00 66 sethi %hi(0x40019800), %g1 40006110: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 40019b10 <_Thread_Dispatch_disable_level> 40006114: 84 00 bf ff add %g2, -1, %g2 40006118: c4 20 63 10 st %g2, [ %g1 + 0x310 ] 4000611c: c6 00 63 10 ld [ %g1 + 0x310 ], %g3 40006120: 80 a0 e0 00 cmp %g3, 0 40006124: 02 80 00 1e be 4000619c 40006128: 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 ); 4000612c: 40 00 00 1f call 400061a8 <_Semaphore_Translate_core_mutex_return_code> 40006130: 90 10 00 18 mov %i0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006134: 81 c7 e0 08 ret 40006138: 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 ) { 4000613c: 08 bf ff fe bleu 40006134 40006140: 90 10 20 04 mov 4, %o0 40006144: 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 */ } 40006148: 81 c7 e0 08 ret <== NOT EXECUTED 4000614c: 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( 40006150: 94 10 20 00 clr %o2 40006154: 40 00 03 c9 call 40007078 <_CORE_semaphore_Surrender> 40006158: 90 02 20 14 add %o0, 0x14, %o0 4000615c: b0 10 00 08 mov %o0, %i0 40006160: 03 10 00 66 sethi %hi(0x40019800), %g1 40006164: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 40019b10 <_Thread_Dispatch_disable_level> 40006168: 84 00 bf ff add %g2, -1, %g2 4000616c: c4 20 63 10 st %g2, [ %g1 + 0x310 ] 40006170: c6 00 63 10 ld [ %g1 + 0x310 ], %g3 40006174: 80 a0 e0 00 cmp %g3, 0 40006178: 02 80 00 06 be 40006190 4000617c: 01 00 00 00 nop &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return 40006180: 40 00 00 14 call 400061d0 <_Semaphore_Translate_core_semaphore_return_code> 40006184: 90 10 00 18 mov %i0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40006188: 81 c7 e0 08 ret 4000618c: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 40006190: 40 00 0b f4 call 40009160 <_Thread_Dispatch> 40006194: 01 00 00 00 nop 40006198: 30 bf ff fa b,a 40006180 4000619c: 40 00 0b f1 call 40009160 <_Thread_Dispatch> 400061a0: 01 00 00 00 nop 400061a4: 30 bf ff e2 b,a 4000612c 4001783c : */ void rtems_shutdown_executive( uint32_t result ) { 4001783c: 9d e3 bf 98 save %sp, -104, %sp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 40017840: 33 10 00 67 sethi %hi(0x40019c00), %i1 40017844: c2 06 60 f0 ld [ %i1 + 0xf0 ], %g1 ! 40019cf0 <_System_state_Current> 40017848: 80 a0 60 04 cmp %g1, 4 4001784c: 02 80 00 0c be 4001787c 40017850: 11 10 00 62 sethi %hi(0x40018800), %o0 #if defined(__USE_INIT_FINI__) extern void _fini( void ); atexit( _fini ); 40017854: 7f ff da 31 call 4000e118 40017858: 90 12 22 ec or %o0, 0x2ec, %o0 ! 40018aec <_fini> * routine which initialized the system. */ RTEMS_INLINE_ROUTINE void _Thread_Stop_multitasking( void ) { _Context_Switch( &_Thread_Executing->Registers, &_Thread_BSP_context ); 4001785c: 03 10 00 66 sethi %hi(0x40019800), %g1 40017860: f0 00 63 ec ld [ %g1 + 0x3ec ], %i0 ! 40019bec <_Thread_Executing> 40017864: 84 10 20 04 mov 4, %g2 40017868: b0 06 20 e0 add %i0, 0xe0, %i0 4001786c: c4 26 60 f0 st %g2, [ %i1 + 0xf0 ] 40017870: 33 10 00 66 sethi %hi(0x40019800), %i1 40017874: 7f ff cc 62 call 4000a9fc <_CPU_Context_switch> 40017878: 93 ee 62 88 restore %i1, 0x288, %o1 4001787c: 81 c7 e0 08 ret <== NOT EXECUTED 40017880: 81 e8 00 00 restore <== NOT EXECUTED 40011c10 : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 40011c10: 9d e3 bf 90 save %sp, -112, %sp 40011c14: 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 ) 40011c18: 80 a6 60 00 cmp %i1, 0 40011c1c: 02 80 00 1b be 40011c88 40011c20: 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 ) ) { 40011c24: 80 a2 60 00 cmp %o1, 0 40011c28: 12 80 00 1a bne 40011c90 40011c2c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40011c30: 23 10 00 cd sethi %hi(0x40033400), %l1 40011c34: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 40011c38: 82 00 60 01 inc %g1 40011c3c: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 40011c40: 03 10 00 cd sethi %hi(0x40033400), %g1 40011c44: e0 00 61 bc ld [ %g1 + 0x1bc ], %l0 ! 400335bc <_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; 40011c48: 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 ]; 40011c4c: f0 04 21 6c ld [ %l0 + 0x16c ], %i0 asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 40011c50: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 40011c54: 80 a0 60 00 cmp %g1, 0 40011c58: 32 80 00 2c bne,a 40011d08 40011c5c: 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 ) 40011c60: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40011c64: b0 10 20 0b mov 0xb, %i0 40011c68: 82 00 7f ff add %g1, -1, %g1 40011c6c: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] 40011c70: c4 04 60 e0 ld [ %l1 + 0xe0 ], %g2 40011c74: 80 a0 a0 00 cmp %g2, 0 40011c78: 12 80 00 0b bne 40011ca4 40011c7c: 01 00 00 00 nop _Thread_Dispatch(); 40011c80: 40 00 13 4a call 400169a8 <_Thread_Dispatch> 40011c84: 01 00 00 00 nop 40011c88: 81 c7 e0 08 ret 40011c8c: 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); 40011c90: 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 ) { 40011c94: 80 a0 a0 04 cmp %g2, 4 40011c98: 08 80 00 05 bleu 40011cac 40011c9c: 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(); 40011ca0: 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 */ } 40011ca4: 81 c7 e0 08 ret 40011ca8: 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 :) */ 40011cac: 80 a0 60 01 cmp %g1, 1 40011cb0: 12 bf ff f6 bne 40011c88 40011cb4: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40011cb8: 83 28 a0 02 sll %g2, 2, %g1 40011cbc: 05 10 00 cd sethi %hi(0x40033400), %g2 40011cc0: 84 10 a0 40 or %g2, 0x40, %g2 ! 40033440 <_Objects_Information_table> 40011cc4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40011cc8: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40011ccc: 80 a2 20 00 cmp %o0, 0 40011cd0: 02 bf ff f5 be 40011ca4 40011cd4: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40011cd8: 40 00 0e 0c call 40015508 <_Objects_Get> 40011cdc: 94 07 bf f4 add %fp, -12, %o2 if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40011ce0: c2 07 bf f4 ld [ %fp + -12 ], %g1 40011ce4: a0 10 00 08 mov %o0, %l0 40011ce8: 80 a0 60 00 cmp %g1, 0 40011cec: 02 bf ff d8 be 40011c4c 40011cf0: 23 10 00 cd sethi %hi(0x40033400), %l1 40011cf4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40011cf8: 18 bf ff e4 bgu 40011c88 <== NOT EXECUTED 40011cfc: 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(); 40011d00: 81 c7 e0 08 ret <== NOT EXECUTED 40011d04: 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 ) { 40011d08: 80 a0 60 00 cmp %g1, 0 40011d0c: 02 80 00 19 be 40011d70 40011d10: 01 00 00 00 nop rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 40011d14: 7f ff e3 79 call 4000aaf8 40011d18: 01 00 00 00 nop *signal_set |= signals; 40011d1c: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 40011d20: 82 10 40 19 or %g1, %i1, %g1 40011d24: c2 26 20 54 st %g1, [ %i0 + 0x54 ] _ISR_Enable( _level ); 40011d28: 7f ff e3 78 call 4000ab08 40011d2c: 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 ) ) 40011d30: 03 10 00 cd sethi %hi(0x40033400), %g1 40011d34: c4 00 61 a4 ld [ %g1 + 0x1a4 ], %g2 ! 400335a4 <_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; 40011d38: 86 10 20 01 mov 1, %g3 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 40011d3c: 80 a0 a0 00 cmp %g2, 0 40011d40: 02 80 00 09 be 40011d64 40011d44: c6 24 20 78 st %g3, [ %l0 + 0x78 ] 40011d48: 03 10 00 cd sethi %hi(0x40033400), %g1 <== NOT EXECUTED 40011d4c: c4 00 61 bc ld [ %g1 + 0x1bc ], %g2 ! 400335bc <_Thread_Executing> <== NOT EXECUTED 40011d50: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 40011d54: 12 80 00 04 bne 40011d64 <== NOT EXECUTED 40011d58: 01 00 00 00 nop <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 40011d5c: 03 10 00 cd sethi %hi(0x40033400), %g1 <== NOT EXECUTED 40011d60: c6 20 62 68 st %g3, [ %g1 + 0x268 ] ! 40033668 <_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 ) 40011d64: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 40011d68: 10 bf ff c0 b 40011c68 40011d6c: b0 10 20 00 clr %i0 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 40011d70: 7f ff e3 62 call 4000aaf8 40011d74: 01 00 00 00 nop *signal_set |= signals; 40011d78: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 40011d7c: 82 10 40 19 or %g1, %i1, %g1 40011d80: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _ISR_Enable( _level ); 40011d84: 7f ff e3 61 call 4000ab08 40011d88: 01 00 00 00 nop 40011d8c: 30 bf ff f6 b,a 40011d64 40006364 : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 40006364: 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 ) ) { 40006368: 92 96 20 00 orcc %i0, 0, %o1 4000636c: 12 80 00 20 bne 400063ec 40006370: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006374: 21 10 00 66 sethi %hi(0x40019800), %l0 40006378: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> 4000637c: 82 00 60 01 inc %g1 40006380: c2 24 23 10 st %g1, [ %l0 + 0x310 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 40006384: 03 10 00 66 sethi %hi(0x40019800), %g1 40006388: f0 00 63 ec ld [ %g1 + 0x3ec ], %i0 ! 40019bec <_Thread_Executing> 4000638c: 07 10 00 66 sethi %hi(0x40019800), %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; 40006390: c0 27 bf f4 clr [ %fp + -12 ] 40006394: a2 10 e2 70 or %g3, 0x270, %l1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_information = _Objects_Get_information( the_thread->Object.id ); 40006398: c2 06 20 08 ld [ %i0 + 8 ], %g1 4000639c: 85 30 60 16 srl %g1, 0x16, %g2 400063a0: 84 08 a0 1c and %g2, 0x1c, %g2 400063a4: c6 04 40 02 ld [ %l1 + %g2 ], %g3 400063a8: 83 30 60 1b srl %g1, 0x1b, %g1 400063ac: 83 28 60 02 sll %g1, 2, %g1 400063b0: d0 00 c0 01 ld [ %g3 + %g1 ], %o0 if ( !the_information ) { 400063b4: 80 a2 20 00 cmp %o0, 0 400063b8: 12 80 00 13 bne 40006404 400063bc: 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 ) 400063c0: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 <== NOT EXECUTED 400063c4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 400063c8: c2 24 23 10 st %g1, [ %l0 + 0x310 ] <== NOT EXECUTED 400063cc: c4 04 23 10 ld [ %l0 + 0x310 ], %g2 <== NOT EXECUTED 400063d0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 400063d4: 12 80 00 04 bne 400063e4 <== NOT EXECUTED 400063d8: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Dispatch(); 400063dc: 40 00 0b 61 call 40009160 <_Thread_Dispatch> <== NOT EXECUTED 400063e0: 01 00 00 00 nop <== NOT EXECUTED 400063e4: 81 c7 e0 08 ret 400063e8: 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); 400063ec: 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 ) { 400063f0: 80 a0 a0 04 cmp %g2, 4 400063f4: 08 80 00 1b bleu 40006460 400063f8: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 400063fc: 81 c7 e0 08 ret <== NOT EXECUTED 40006400: 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 ); 40006404: 40 00 0a d9 call 40008f68 <_Thread_Close> 40006408: 92 10 00 18 mov %i0, %o1 4000640c: c4 06 20 08 ld [ %i0 + 8 ], %g2 40006410: 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 ]; 40006414: 83 30 a0 16 srl %g2, 0x16, %g1 40006418: 82 08 60 1c and %g1, 0x1c, %g1 4000641c: c6 04 40 01 ld [ %l1 + %g1 ], %g3 40006420: 85 30 a0 1b srl %g2, 0x1b, %g2 40006424: 85 28 a0 02 sll %g2, 2, %g2 40006428: 40 00 05 e3 call 40007bb4 <_Objects_Free> 4000642c: 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 ) 40006430: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 40006434: b0 10 20 00 clr %i0 40006438: 82 00 7f ff add %g1, -1, %g1 4000643c: c2 24 23 10 st %g1, [ %l0 + 0x310 ] 40006440: c4 04 23 10 ld [ %l0 + 0x310 ], %g2 40006444: 80 a0 a0 00 cmp %g2, 0 40006448: 12 80 00 04 bne 40006458 4000644c: 01 00 00 00 nop _Thread_Dispatch(); 40006450: 40 00 0b 44 call 40009160 <_Thread_Dispatch> 40006454: 01 00 00 00 nop 40006458: 81 c7 e0 08 ret 4000645c: 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 :) */ 40006460: 80 a0 60 01 cmp %g1, 1 40006464: 12 bf ff e0 bne 400063e4 40006468: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4000646c: 85 28 a0 02 sll %g2, 2, %g2 40006470: 07 10 00 66 sethi %hi(0x40019800), %g3 40006474: a2 10 e2 70 or %g3, 0x270, %l1 ! 40019a70 <_Objects_Information_table> 40006478: c2 04 40 02 ld [ %l1 + %g2 ], %g1 4000647c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 40006480: 80 a2 20 00 cmp %o0, 0 40006484: 02 bf ff f5 be 40006458 40006488: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4000648c: 40 00 06 0d call 40007cc0 <_Objects_Get> 40006490: 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 ) { 40006494: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006498: b0 10 00 08 mov %o0, %i0 4000649c: 80 a0 60 00 cmp %g1, 0 400064a0: 02 bf ff be be 40006398 400064a4: 21 10 00 66 sethi %hi(0x40019800), %l0 400064a8: 80 a0 60 02 cmp %g1, 2 400064ac: 18 bf ff ce bgu 400063e4 400064b0: 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(); 400064b4: 81 c7 e0 08 ret 400064b8: 91 e8 20 04 restore %g0, 4, %o0 40007c70 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 40007c70: 9d e3 bf 90 save %sp, -112, %sp 40007c74: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !note ) 40007c78: 80 a6 a0 00 cmp %i2, 0 40007c7c: 02 80 00 3b be 40007d68 40007c80: 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 ) 40007c84: 80 a6 60 0f cmp %i1, 0xf 40007c88: 18 80 00 38 bgu 40007d68 40007c8c: 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 ) || 40007c90: 80 a2 60 00 cmp %o1, 0 40007c94: 12 80 00 09 bne 40007cb8 40007c98: 07 10 00 7b sethi %hi(0x4001ec00), %g3 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 40007c9c: c2 00 e1 ec ld [ %g3 + 0x1ec ], %g1 ! 4001edec <_Thread_Executing> 40007ca0: 87 2e 60 02 sll %i1, 2, %g3 40007ca4: c4 00 61 6c ld [ %g1 + 0x16c ], %g2 40007ca8: c2 00 80 03 ld [ %g2 + %g3 ], %g1 40007cac: c2 26 80 00 st %g1, [ %i2 ] 40007cb0: 81 c7 e0 08 ret 40007cb4: 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 ) || 40007cb8: c2 00 e1 ec ld [ %g3 + 0x1ec ], %g1 40007cbc: c4 00 60 08 ld [ %g1 + 8 ], %g2 40007cc0: 80 a2 40 02 cmp %o1, %g2 40007cc4: 22 bf ff f8 be,a 40007ca4 40007cc8: 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); 40007ccc: 83 32 60 18 srl %o1, 0x18, %g1 40007cd0: 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 ) { 40007cd4: 80 a0 a0 04 cmp %g2, 4 40007cd8: 08 80 00 04 bleu 40007ce8 40007cdc: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007ce0: 81 c7 e0 08 ret <== NOT EXECUTED 40007ce4: 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 :) */ 40007ce8: 80 a0 60 01 cmp %g1, 1 40007cec: 12 80 00 1f bne 40007d68 40007cf0: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007cf4: 83 28 a0 02 sll %g2, 2, %g1 40007cf8: 05 10 00 7b sethi %hi(0x4001ec00), %g2 40007cfc: 84 10 a0 70 or %g2, 0x70, %g2 ! 4001ec70 <_Objects_Information_table> 40007d00: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40007d04: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40007d08: 80 a2 20 00 cmp %o0, 0 40007d0c: 02 80 00 17 be 40007d68 40007d10: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007d14: 40 00 07 53 call 40009a60 <_Objects_Get> 40007d18: 94 07 bf f4 add %fp, -12, %o2 *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007d1c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007d20: 80 a0 60 00 cmp %g1, 0 40007d24: 12 80 00 13 bne 40007d70 40007d28: 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 ]; 40007d2c: c6 02 21 6c ld [ %o0 + 0x16c ], %g3 40007d30: 83 2e 60 02 sll %i1, 2, %g1 40007d34: c4 00 c0 01 ld [ %g3 + %g1 ], %g2 40007d38: 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 ) 40007d3c: 07 10 00 7b sethi %hi(0x4001ec00), %g3 40007d40: c2 00 e1 10 ld [ %g3 + 0x110 ], %g1 ! 4001ed10 <_Thread_Dispatch_disable_level> 40007d44: b0 10 20 00 clr %i0 40007d48: 82 00 7f ff add %g1, -1, %g1 40007d4c: c2 20 e1 10 st %g1, [ %g3 + 0x110 ] 40007d50: c4 00 e1 10 ld [ %g3 + 0x110 ], %g2 40007d54: 80 a0 a0 00 cmp %g2, 0 40007d58: 12 80 00 04 bne 40007d68 40007d5c: 01 00 00 00 nop _Thread_Dispatch(); 40007d60: 40 00 0c 2c call 4000ae10 <_Thread_Dispatch> 40007d64: 01 00 00 00 nop 40007d68: 81 c7 e0 08 ret 40007d6c: 81 e8 00 00 restore *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007d70: 18 bf ff fe bgu 40007d68 <== NOT EXECUTED 40007d74: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 40007d78: 81 c7 e0 08 ret <== NOT EXECUTED 40007d7c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40006b4c : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 40006b4c: 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 ) ) { 40006b50: 92 96 20 00 orcc %i0, 0, %o1 40006b54: 12 80 00 19 bne 40006bb8 40006b58: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006b5c: 05 10 00 72 sethi %hi(0x4001c800), %g2 <== NOT EXECUTED 40006b60: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 4001cbb0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40006b64: 82 00 60 01 inc %g1 <== NOT EXECUTED 40006b68: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 40006b6c: 03 10 00 73 sethi %hi(0x4001cc00), %g1 <== NOT EXECUTED 40006b70: d0 00 60 8c ld [ %g1 + 0x8c ], %o0 ! 4001cc8c <_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; 40006b74: 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 ) ) { 40006b78: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40006b7c: 80 88 60 02 btst 2, %g1 40006b80: 02 80 00 15 be 40006bd4 40006b84: 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 ) 40006b88: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 40006b8c: b0 10 20 0f mov 0xf, %i0 40006b90: 82 00 7f ff add %g1, -1, %g1 40006b94: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] 40006b98: c4 00 a3 b0 ld [ %g2 + 0x3b0 ], %g2 40006b9c: 80 a0 a0 00 cmp %g2, 0 40006ba0: 12 80 00 0b bne 40006bcc 40006ba4: 01 00 00 00 nop _Thread_Dispatch(); 40006ba8: 40 00 0b 4e call 400098e0 <_Thread_Dispatch> 40006bac: 01 00 00 00 nop 40006bb0: 81 c7 e0 08 ret 40006bb4: 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); 40006bb8: 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 ) { 40006bbc: 80 a0 a0 04 cmp %g2, 4 40006bc0: 08 80 00 08 bleu 40006be0 40006bc4: 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(); 40006bc8: 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 */ } 40006bcc: 81 c7 e0 08 ret <== NOT EXECUTED 40006bd0: 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 ) 40006bd4: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 40006bd8: 10 bf ff ee b 40006b90 40006bdc: 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 :) */ 40006be0: 80 a0 60 01 cmp %g1, 1 40006be4: 12 bf ff f3 bne 40006bb0 40006be8: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40006bec: 83 28 a0 02 sll %g2, 2, %g1 40006bf0: 05 10 00 72 sethi %hi(0x4001c800), %g2 40006bf4: 84 10 a3 10 or %g2, 0x310, %g2 ! 4001cb10 <_Objects_Information_table> 40006bf8: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40006bfc: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40006c00: 80 a2 20 00 cmp %o0, 0 40006c04: 02 bf ff f2 be 40006bcc 40006c08: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40006c0c: 40 00 06 49 call 40008530 <_Objects_Get> 40006c10: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40006c14: c2 07 bf f4 ld [ %fp + -12 ], %g1 40006c18: 80 a0 60 00 cmp %g1, 0 40006c1c: 02 bf ff d7 be 40006b78 40006c20: 05 10 00 72 sethi %hi(0x4001c800), %g2 40006c24: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40006c28: 18 bf ff e2 bgu 40006bb0 <== NOT EXECUTED 40006c2c: 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(); 40006c30: 81 c7 e0 08 ret <== NOT EXECUTED 40006c34: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40007128 : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 40007128: 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 ) ) { 4000712c: 92 96 20 00 orcc %i0, 0, %o1 40007130: 12 80 00 1b bne 4000719c 40007134: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007138: 21 10 00 74 sethi %hi(0x4001d000), %l0 4000713c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 ! 4001d060 <_Thread_Dispatch_disable_level> 40007140: 82 00 60 01 inc %g1 40007144: c2 24 20 60 st %g1, [ %l0 + 0x60 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 40007148: 03 10 00 74 sethi %hi(0x4001d000), %g1 4000714c: d0 00 61 3c ld [ %g1 + 0x13c ], %o0 ! 4001d13c <_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; 40007150: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 40007154: 94 10 00 19 mov %i1, %o2 40007158: 40 00 0e 25 call 4000a9ec <_Thread_Restart> 4000715c: 92 10 20 00 clr %o1 40007160: 80 a2 20 00 cmp %o0, 0 40007164: 12 80 00 15 bne 400071b8 40007168: 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 ) 4000716c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 40007170: b0 10 20 0e mov 0xe, %i0 40007174: 82 00 7f ff add %g1, -1, %g1 40007178: c2 24 20 60 st %g1, [ %l0 + 0x60 ] 4000717c: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 40007180: 80 a0 a0 00 cmp %g2, 0 40007184: 12 80 00 0b bne 400071b0 40007188: 01 00 00 00 nop _Thread_Dispatch(); 4000718c: 40 00 0b 22 call 40009e14 <_Thread_Dispatch> 40007190: 01 00 00 00 nop 40007194: 81 c7 e0 08 ret 40007198: 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); 4000719c: 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 ) { 400071a0: 80 a0 a0 04 cmp %g2, 4 400071a4: 08 80 00 08 bleu 400071c4 400071a8: 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(); 400071ac: 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 */ } 400071b0: 81 c7 e0 08 ret <== NOT EXECUTED 400071b4: 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 ) 400071b8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 400071bc: 10 bf ff ee b 40007174 400071c0: 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 :) */ 400071c4: 80 a0 60 01 cmp %g1, 1 400071c8: 12 bf ff f3 bne 40007194 400071cc: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400071d0: 83 28 a0 02 sll %g2, 2, %g1 400071d4: 05 10 00 73 sethi %hi(0x4001cc00), %g2 400071d8: 84 10 a3 c0 or %g2, 0x3c0, %g2 ! 4001cfc0 <_Objects_Information_table> 400071dc: c6 00 80 01 ld [ %g2 + %g1 ], %g3 400071e0: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 400071e4: 80 a2 20 00 cmp %o0, 0 400071e8: 02 bf ff f2 be 400071b0 400071ec: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 400071f0: 40 00 06 1d call 40008a64 <_Objects_Get> 400071f4: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 400071f8: c2 07 bf f4 ld [ %fp + -12 ], %g1 400071fc: 80 a0 60 00 cmp %g1, 0 40007200: 02 bf ff d5 be 40007154 40007204: 21 10 00 74 sethi %hi(0x4001d000), %l0 40007208: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000720c: 18 bf ff e2 bgu 40007194 <== NOT EXECUTED 40007210: 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(); 40007214: 81 c7 e0 08 ret <== NOT EXECUTED 40007218: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40007be4 : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 40007be4: 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 ) ) { 40007be8: 92 96 20 00 orcc %i0, 0, %o1 40007bec: 12 80 00 19 bne 40007c50 40007bf0: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007bf4: 21 10 00 98 sethi %hi(0x40026000), %l0 40007bf8: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 ! 400260e0 <_Thread_Dispatch_disable_level> 40007bfc: 82 00 60 01 inc %g1 40007c00: c2 24 20 e0 st %g1, [ %l0 + 0xe0 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 40007c04: 03 10 00 98 sethi %hi(0x40026000), %g1 40007c08: d0 00 61 bc ld [ %g1 + 0x1bc ], %o0 ! 400261bc <_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; 40007c0c: 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 ) ) { 40007c10: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40007c14: 80 88 60 02 btst 2, %g1 40007c18: 12 80 00 2b bne 40007cc4 40007c1c: 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 ) 40007c20: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 40007c24: b0 10 20 0e mov 0xe, %i0 40007c28: 82 00 7f ff add %g1, -1, %g1 40007c2c: c2 24 20 e0 st %g1, [ %l0 + 0xe0 ] 40007c30: c4 04 20 e0 ld [ %l0 + 0xe0 ], %g2 40007c34: 80 a0 a0 00 cmp %g2, 0 40007c38: 12 80 00 0b bne 40007c64 40007c3c: 01 00 00 00 nop _Thread_Dispatch(); 40007c40: 40 00 0c 07 call 4000ac5c <_Thread_Dispatch> 40007c44: 01 00 00 00 nop 40007c48: 81 c7 e0 08 ret 40007c4c: 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); 40007c50: 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 ) { 40007c54: 80 a0 a0 04 cmp %g2, 4 40007c58: 08 80 00 05 bleu 40007c6c 40007c5c: 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(); 40007c60: 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 */ } 40007c64: 81 c7 e0 08 ret 40007c68: 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 :) */ 40007c6c: 80 a0 60 01 cmp %g1, 1 40007c70: 12 bf ff f6 bne 40007c48 40007c74: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007c78: 83 28 a0 02 sll %g2, 2, %g1 40007c7c: 05 10 00 98 sethi %hi(0x40026000), %g2 40007c80: 84 10 a0 40 or %g2, 0x40, %g2 ! 40026040 <_Objects_Information_table> 40007c84: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40007c88: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40007c8c: 80 a2 20 00 cmp %o0, 0 40007c90: 02 bf ff f5 be 40007c64 40007c94: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007c98: 40 00 07 05 call 400098ac <_Objects_Get> 40007c9c: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007ca0: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007ca4: 80 a0 60 00 cmp %g1, 0 40007ca8: 02 bf ff da be 40007c10 40007cac: 21 10 00 98 sethi %hi(0x40026000), %l0 40007cb0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40007cb4: 18 bf ff e5 bgu 40007c48 <== NOT EXECUTED 40007cb8: 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(); 40007cbc: 81 c7 e0 08 ret <== NOT EXECUTED 40007cc0: 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 ); 40007cc4: 40 00 0e f2 call 4000b88c <_Thread_Resume> 40007cc8: 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 ) 40007ccc: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 40007cd0: 10 bf ff d6 b 40007c28 40007cd4: b0 10 20 00 clr %i0 40007f50 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 40007f50: 9d e3 bf 90 save %sp, -112, %sp 40007f54: 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 ) 40007f58: 80 a6 60 0f cmp %i1, 0xf 40007f5c: 18 80 00 36 bgu 40008034 40007f60: 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 ) || 40007f64: 80 a2 60 00 cmp %o1, 0 40007f68: 12 80 00 08 bne 40007f88 40007f6c: 07 10 00 7b sethi %hi(0x4001ec00), %g3 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 40007f70: c2 00 e1 ec ld [ %g3 + 0x1ec ], %g1 ! 4001edec <_Thread_Executing> <== NOT EXECUTED 40007f74: c4 00 61 6c ld [ %g1 + 0x16c ], %g2 <== NOT EXECUTED 40007f78: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED 40007f7c: f4 20 80 03 st %i2, [ %g2 + %g3 ] <== NOT EXECUTED 40007f80: 81 c7 e0 08 ret <== NOT EXECUTED 40007f84: 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 ) || 40007f88: c2 00 e1 ec ld [ %g3 + 0x1ec ], %g1 40007f8c: c4 00 60 08 ld [ %g1 + 8 ], %g2 40007f90: 80 a2 40 02 cmp %o1, %g2 40007f94: 22 bf ff f9 be,a 40007f78 40007f98: c4 00 61 6c ld [ %g1 + 0x16c ], %g2 <== NOT EXECUTED 40007f9c: 83 32 60 18 srl %o1, 0x18, %g1 40007fa0: 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 ) { 40007fa4: 80 a0 a0 04 cmp %g2, 4 40007fa8: 08 80 00 04 bleu 40007fb8 40007fac: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40007fb0: 81 c7 e0 08 ret <== NOT EXECUTED 40007fb4: 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 :) */ 40007fb8: 80 a0 60 01 cmp %g1, 1 40007fbc: 12 80 00 1e bne 40008034 40007fc0: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007fc4: 83 28 a0 02 sll %g2, 2, %g1 40007fc8: 05 10 00 7b sethi %hi(0x4001ec00), %g2 40007fcc: 84 10 a0 70 or %g2, 0x70, %g2 ! 4001ec70 <_Objects_Information_table> 40007fd0: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40007fd4: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40007fd8: 80 a2 20 00 cmp %o0, 0 40007fdc: 02 80 00 16 be 40008034 40007fe0: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007fe4: 40 00 06 9f call 40009a60 <_Objects_Get> 40007fe8: 94 07 bf f4 add %fp, -12, %o2 api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007fec: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007ff0: 80 a0 60 00 cmp %g1, 0 40007ff4: 12 80 00 12 bne 4000803c 40007ff8: 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; 40007ffc: c4 02 21 6c ld [ %o0 + 0x16c ], %g2 40008000: 83 2e 60 02 sll %i1, 2, %g1 40008004: 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 ) 40008008: 07 10 00 7b sethi %hi(0x4001ec00), %g3 4000800c: c2 00 e1 10 ld [ %g3 + 0x110 ], %g1 ! 4001ed10 <_Thread_Dispatch_disable_level> 40008010: b0 10 20 00 clr %i0 40008014: 82 00 7f ff add %g1, -1, %g1 40008018: c2 20 e1 10 st %g1, [ %g3 + 0x110 ] 4000801c: c4 00 e1 10 ld [ %g3 + 0x110 ], %g2 40008020: 80 a0 a0 00 cmp %g2, 0 40008024: 12 80 00 04 bne 40008034 40008028: 01 00 00 00 nop _Thread_Dispatch(); 4000802c: 40 00 0b 79 call 4000ae10 <_Thread_Dispatch> 40008030: 01 00 00 00 nop 40008034: 81 c7 e0 08 ret 40008038: 81 e8 00 00 restore api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000803c: 18 bf ff fe bgu 40008034 <== NOT EXECUTED 40008040: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 40008044: 81 c7 e0 08 ret <== NOT EXECUTED 40008048: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 4000d538 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 4000d538: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 4000d53c: 80 a6 60 00 cmp %i1, 0 4000d540: 02 80 00 06 be 4000d558 4000d544: 92 10 00 18 mov %i0, %o1 4000d548: 82 06 7f ff add %i1, -1, %g1 4000d54c: 80 a0 60 fe cmp %g1, 0xfe 4000d550: 18 80 00 26 bgu 4000d5e8 4000d554: b0 10 20 13 mov 0x13, %i0 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 4000d558: 80 a6 a0 00 cmp %i2, 0 4000d55c: 02 80 00 23 be 4000d5e8 4000d560: 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 ) ) { 4000d564: 80 a2 60 00 cmp %o1, 0 4000d568: 12 80 00 22 bne 4000d5f0 4000d56c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4000d570: 21 10 00 ac sethi %hi(0x4002b000), %l0 4000d574: c2 04 21 90 ld [ %l0 + 0x190 ], %g1 ! 4002b190 <_Thread_Dispatch_disable_level> 4000d578: 82 00 60 01 inc %g1 4000d57c: 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; 4000d580: 03 10 00 ac sethi %hi(0x4002b000), %g1 4000d584: d0 00 62 6c ld [ %g1 + 0x26c ], %o0 ! 4002b26c <_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; 4000d588: 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; 4000d58c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 4000d590: 80 a6 60 00 cmp %i1, 0 4000d594: 02 80 00 0d be 4000d5c8 4000d598: c2 26 80 00 st %g1, [ %i2 ] the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 4000d59c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 4000d5a0: 80 a0 60 00 cmp %g1, 0 4000d5a4: 02 80 00 06 be 4000d5bc 4000d5a8: f2 22 20 18 st %i1, [ %o0 + 0x18 ] 4000d5ac: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 4000d5b0: 80 a6 40 01 cmp %i1, %g1 4000d5b4: 1a 80 00 05 bcc 4000d5c8 4000d5b8: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 4000d5bc: 92 10 00 19 mov %i1, %o1 4000d5c0: 40 00 0a 59 call 4000ff24 <_Thread_Change_priority> 4000d5c4: 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 ) 4000d5c8: c2 04 21 90 ld [ %l0 + 0x190 ], %g1 4000d5cc: b0 10 20 00 clr %i0 4000d5d0: 82 00 7f ff add %g1, -1, %g1 4000d5d4: c2 24 21 90 st %g1, [ %l0 + 0x190 ] 4000d5d8: c4 04 21 90 ld [ %l0 + 0x190 ], %g2 4000d5dc: 80 a0 a0 00 cmp %g2, 0 4000d5e0: 02 80 00 0a be 4000d608 4000d5e4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4000d5e8: 81 c7 e0 08 ret 4000d5ec: 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); 4000d5f0: 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 ) { 4000d5f4: 80 a0 a0 04 cmp %g2, 4 4000d5f8: 08 80 00 08 bleu 4000d618 4000d5fc: 83 32 60 1b srl %o1, 0x1b, %g1 4000d600: 81 c7 e0 08 ret <== NOT EXECUTED 4000d604: 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(); 4000d608: 40 00 0b 6b call 400103b4 <_Thread_Dispatch> 4000d60c: 01 00 00 00 nop 4000d610: 81 c7 e0 08 ret 4000d614: 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 :) */ 4000d618: 80 a0 60 01 cmp %g1, 1 4000d61c: 12 bf ff f3 bne 4000d5e8 4000d620: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4000d624: 83 28 a0 02 sll %g2, 2, %g1 4000d628: 05 10 00 ac sethi %hi(0x4002b000), %g2 4000d62c: 84 10 a0 f0 or %g2, 0xf0, %g2 ! 4002b0f0 <_Objects_Information_table> 4000d630: c6 00 80 01 ld [ %g2 + %g1 ], %g3 4000d634: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 4000d638: 80 a2 20 00 cmp %o0, 0 4000d63c: 02 bf ff f5 be 4000d610 4000d640: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4000d644: 40 00 06 34 call 4000ef14 <_Objects_Get> 4000d648: 94 07 bf f4 add %fp, -12, %o2 if ( !old_priority ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 4000d64c: c2 07 bf f4 ld [ %fp + -12 ], %g1 4000d650: 80 a0 60 00 cmp %g1, 0 4000d654: 02 bf ff ce be 4000d58c 4000d658: 21 10 00 ac sethi %hi(0x4002b000), %l0 4000d65c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4000d660: 18 bf ff e2 bgu 4000d5e8 <== NOT EXECUTED 4000d664: 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(); 4000d668: 81 c7 e0 08 ret <== NOT EXECUTED 4000d66c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 400065f8 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 400065f8: 9d e3 bf 90 save %sp, -112, %sp 400065fc: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 40006600: 80 a6 60 00 cmp %i1, 0 40006604: 02 80 00 1e be 4000667c 40006608: 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 ) ) { 4000660c: 80 a2 60 00 cmp %o1, 0 40006610: 12 80 00 1d bne 40006684 40006614: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40006618: 21 10 00 66 sethi %hi(0x40019800), %l0 4000661c: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 ! 40019b10 <_Thread_Dispatch_disable_level> 40006620: 82 00 60 01 inc %g1 40006624: c2 24 23 10 st %g1, [ %l0 + 0x310 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 40006628: 03 10 00 66 sethi %hi(0x40019800), %g1 4000662c: d0 00 63 ec ld [ %g1 + 0x3ec ], %o0 ! 40019bec <_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; 40006630: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Start( 40006634: 94 10 00 19 mov %i1, %o2 40006638: 98 10 00 1a mov %i2, %o4 4000663c: 92 10 20 00 clr %o1 40006640: 40 00 0e a3 call 4000a0cc <_Thread_Start> 40006644: 96 10 20 00 clr %o3 40006648: 80 a2 20 00 cmp %o0, 0 4000664c: 12 80 00 2b bne 400066f8 40006650: 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 ) 40006654: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 40006658: b0 10 20 0e mov 0xe, %i0 4000665c: 82 00 7f ff add %g1, -1, %g1 40006660: c2 24 23 10 st %g1, [ %l0 + 0x310 ] 40006664: c4 04 23 10 ld [ %l0 + 0x310 ], %g2 40006668: 80 a0 a0 00 cmp %g2, 0 4000666c: 12 80 00 0b bne 40006698 40006670: 01 00 00 00 nop _Thread_Dispatch(); 40006674: 40 00 0a bb call 40009160 <_Thread_Dispatch> 40006678: 01 00 00 00 nop 4000667c: 81 c7 e0 08 ret 40006680: 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); 40006684: 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 ) { 40006688: 80 a0 a0 04 cmp %g2, 4 4000668c: 08 80 00 05 bleu 400066a0 40006690: 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(); 40006694: 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 */ } 40006698: 81 c7 e0 08 ret 4000669c: 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 :) */ 400066a0: 80 a0 60 01 cmp %g1, 1 400066a4: 12 bf ff f6 bne 4000667c 400066a8: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 400066ac: 83 28 a0 02 sll %g2, 2, %g1 400066b0: 05 10 00 66 sethi %hi(0x40019800), %g2 400066b4: 84 10 a2 70 or %g2, 0x270, %g2 ! 40019a70 <_Objects_Information_table> 400066b8: c6 00 80 01 ld [ %g2 + %g1 ], %g3 400066bc: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 400066c0: 80 a2 20 00 cmp %o0, 0 400066c4: 02 bf ff f5 be 40006698 400066c8: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 400066cc: 40 00 05 7d call 40007cc0 <_Objects_Get> 400066d0: 94 07 bf f4 add %fp, -12, %o2 if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 400066d4: c2 07 bf f4 ld [ %fp + -12 ], %g1 400066d8: 80 a0 60 00 cmp %g1, 0 400066dc: 02 bf ff d6 be 40006634 400066e0: 21 10 00 66 sethi %hi(0x40019800), %l0 400066e4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 400066e8: 18 bf ff e5 bgu 4000667c <== NOT EXECUTED 400066ec: 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(); 400066f0: 81 c7 e0 08 ret <== NOT EXECUTED 400066f4: 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 ) 400066f8: c2 04 23 10 ld [ %l0 + 0x310 ], %g1 400066fc: 10 bf ff d8 b 4000665c 40006700: b0 10 20 00 clr %i0 40007de4 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 40007de4: 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 ) ) { 40007de8: 92 96 20 00 orcc %i0, 0, %o1 40007dec: 12 80 00 19 bne 40007e50 40007df0: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 40007df4: 21 10 00 98 sethi %hi(0x40026000), %l0 40007df8: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 ! 400260e0 <_Thread_Dispatch_disable_level> 40007dfc: 82 00 60 01 inc %g1 40007e00: c2 24 20 e0 st %g1, [ %l0 + 0xe0 ] Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 40007e04: 03 10 00 98 sethi %hi(0x40026000), %g1 40007e08: d0 00 61 bc ld [ %g1 + 0x1bc ], %o0 ! 400261bc <_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; 40007e0c: 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 ) ) { 40007e10: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 40007e14: 80 88 60 02 btst 2, %g1 40007e18: 02 80 00 2b be 40007ec4 40007e1c: 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 ) 40007e20: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 40007e24: b0 10 20 0f mov 0xf, %i0 40007e28: 82 00 7f ff add %g1, -1, %g1 40007e2c: c2 24 20 e0 st %g1, [ %l0 + 0xe0 ] 40007e30: c4 04 20 e0 ld [ %l0 + 0xe0 ], %g2 40007e34: 80 a0 a0 00 cmp %g2, 0 40007e38: 12 80 00 0b bne 40007e64 40007e3c: 01 00 00 00 nop _Thread_Dispatch(); 40007e40: 40 00 0b 87 call 4000ac5c <_Thread_Dispatch> 40007e44: 01 00 00 00 nop 40007e48: 81 c7 e0 08 ret 40007e4c: 81 e8 00 00 restore 40007e50: 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 ) { 40007e54: 80 a0 a0 04 cmp %g2, 4 40007e58: 08 80 00 05 bleu 40007e6c 40007e5c: 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(); 40007e60: 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 */ } 40007e64: 81 c7 e0 08 ret <== NOT EXECUTED 40007e68: 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 :) */ 40007e6c: 80 a0 60 01 cmp %g1, 1 40007e70: 12 bf ff f6 bne 40007e48 40007e74: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 40007e78: 83 28 a0 02 sll %g2, 2, %g1 40007e7c: 05 10 00 98 sethi %hi(0x40026000), %g2 40007e80: 84 10 a0 40 or %g2, 0x40, %g2 ! 40026040 <_Objects_Information_table> 40007e84: c6 00 80 01 ld [ %g2 + %g1 ], %g3 40007e88: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 40007e8c: 80 a2 20 00 cmp %o0, 0 40007e90: 02 bf ff f5 be 40007e64 40007e94: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 40007e98: 40 00 06 85 call 400098ac <_Objects_Get> 40007e9c: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 40007ea0: c2 07 bf f4 ld [ %fp + -12 ], %g1 40007ea4: 80 a0 60 00 cmp %g1, 0 40007ea8: 02 bf ff da be 40007e10 40007eac: 21 10 00 98 sethi %hi(0x40026000), %l0 40007eb0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 40007eb4: 18 bf ff e5 bgu 40007e48 <== NOT EXECUTED 40007eb8: 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(); 40007ebc: 81 c7 e0 08 ret <== NOT EXECUTED 40007ec0: 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 ); 40007ec4: 40 00 0f b1 call 4000bd88 <_Thread_Suspend> 40007ec8: 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 ) 40007ecc: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 40007ed0: 10 bf ff d6 b 40007e28 40007ed4: b0 10 20 00 clr %i0 4001a450 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 4001a450: 9d e3 bf 90 save %sp, -112, %sp 4001a454: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 4001a458: 80 a6 60 00 cmp %i1, 0 4001a45c: 02 80 00 22 be 4001a4e4 4001a460: 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 ) ) { 4001a464: 80 a2 60 00 cmp %o1, 0 4001a468: 12 80 00 21 bne 4001a4ec 4001a46c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001a470: 21 10 00 f4 sethi %hi(0x4003d000), %l0 4001a474: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 ! 4003d0a0 <_Thread_Dispatch_disable_level> 4001a478: 82 00 60 01 inc %g1 4001a47c: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] 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; 4001a480: 03 10 00 f4 sethi %hi(0x4003d000), %g1 4001a484: f0 00 61 7c ld [ %g1 + 0x17c ], %i0 ! 4003d17c <_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; 4001a488: c0 27 bf f4 clr [ %fp + -12 ] /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 4001a48c: c4 06 21 7c ld [ %i0 + 0x17c ], %g2 while (tvp) { 4001a490: 80 a0 a0 00 cmp %g2, 0 4001a494: 32 80 00 08 bne,a 4001a4b4 4001a498: 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 ); 4001a49c: 10 80 00 1a b 4001a504 4001a4a0: 11 10 00 f4 sethi %hi(0x4003d000), %o0 4001a4a4: 84 90 60 00 orcc %g1, 0, %g2 <== NOT EXECUTED 4001a4a8: 02 80 00 17 be 4001a504 <== NOT EXECUTED 4001a4ac: 11 10 00 f4 sethi %hi(0x4003d000), %o0 <== NOT EXECUTED if (tvp->ptr == ptr) { 4001a4b0: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 4001a4b4: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 4001a4b8: 32 bf ff fb bne,a 4001a4a4 <== NOT EXECUTED 4001a4bc: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED tvp->dtor = dtor; 4001a4c0: 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 ) 4001a4c4: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 _Thread_Dispatch(); 4001a4c8: 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 ) 4001a4cc: 82 00 7f ff add %g1, -1, %g1 4001a4d0: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] 4001a4d4: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 4001a4d8: 80 a0 a0 00 cmp %g2, 0 4001a4dc: 02 80 00 1c be 4001a54c 4001a4e0: 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 */ } 4001a4e4: 81 c7 e0 08 ret <== NOT EXECUTED 4001a4e8: 81 e8 00 00 restore <== NOT EXECUTED 4001a4ec: 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 ) { 4001a4f0: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 4001a4f4: 08 80 00 21 bleu 4001a578 <== NOT EXECUTED 4001a4f8: 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(); 4001a4fc: 81 c7 e0 08 ret <== NOT EXECUTED 4001a500: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 4001a504: 92 10 20 14 mov 0x14, %o1 4001a508: 7f ff c1 71 call 4000aacc <_Heap_Allocate> 4001a50c: 90 12 20 ec or %o0, 0xec, %o0 * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 4001a510: 80 a2 20 00 cmp %o0, 0 4001a514: 32 80 00 12 bne,a 4001a55c 4001a518: 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 ) 4001a51c: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED 4001a520: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED 4001a524: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001a528: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] <== NOT EXECUTED 4001a52c: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED 4001a530: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001a534: 12 80 00 08 bne 4001a554 <== NOT EXECUTED 4001a538: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4001a53c: 7f ff c9 98 call 4000cb9c <_Thread_Dispatch> <== NOT EXECUTED 4001a540: 01 00 00 00 nop <== NOT EXECUTED 4001a544: 81 c7 e0 08 ret <== NOT EXECUTED 4001a548: 81 e8 00 00 restore <== NOT EXECUTED 4001a54c: 7f ff c9 94 call 4000cb9c <_Thread_Dispatch> 4001a550: b0 10 20 00 clr %i0 4001a554: 81 c7 e0 08 ret 4001a558: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 4001a55c: 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; 4001a560: 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; 4001a564: c2 22 20 08 st %g1, [ %o0 + 8 ] new->ptr = ptr; 4001a568: f2 22 20 04 st %i1, [ %o0 + 4 ] new->dtor = dtor; 4001a56c: f4 22 20 10 st %i2, [ %o0 + 0x10 ] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 4001a570: 10 bf ff d5 b 4001a4c4 4001a574: 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 :) */ 4001a578: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001a57c: 12 bf ff e0 bne 4001a4fc <== NOT EXECUTED 4001a580: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4001a584: 05 10 00 f4 sethi %hi(0x4003d000), %g2 <== NOT EXECUTED 4001a588: 84 10 a0 00 mov %g2, %g2 ! 4003d000 <_Objects_Information_table> <== NOT EXECUTED 4001a58c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 4001a590: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 4001a594: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a598: 02 bf ff d9 be 4001a4fc <== NOT EXECUTED 4001a59c: 01 00 00 00 nop <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4001a5a0: 7f ff c3 fb call 4000b58c <_Objects_Get> <== NOT EXECUTED 4001a5a4: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 4001a5a8: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4001a5ac: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 4001a5b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001a5b4: 02 bf ff b6 be 4001a48c <== NOT EXECUTED 4001a5b8: 21 10 00 f4 sethi %hi(0x4003d000), %l0 <== NOT EXECUTED 4001a5bc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4001a5c0: 18 bf ff c9 bgu 4001a4e4 <== NOT EXECUTED 4001a5c4: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 4001a5c8: 30 bf ff cd b,a 4001a4fc <== NOT EXECUTED 4001a5cc : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 4001a5cc: 9d e3 bf 90 save %sp, -112, %sp Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 4001a5d0: 80 a6 60 00 cmp %i1, 0 4001a5d4: 02 80 00 50 be 4001a714 4001a5d8: 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 ) ) { 4001a5dc: 80 a6 20 00 cmp %i0, 0 4001a5e0: 12 80 00 26 bne 4001a678 4001a5e4: 83 36 20 18 srl %i0, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001a5e8: 21 10 00 f4 sethi %hi(0x4003d000), %l0 4001a5ec: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 ! 4003d0a0 <_Thread_Dispatch_disable_level> 4001a5f0: 82 00 60 01 inc %g1 4001a5f4: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] 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; 4001a5f8: 03 10 00 f4 sethi %hi(0x4003d000), %g1 4001a5fc: d0 00 61 7c ld [ %g1 + 0x17c ], %o0 ! 4003d17c <_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; 4001a600: c0 27 bf f4 clr [ %fp + -12 ] default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; 4001a604: c6 02 21 7c ld [ %o0 + 0x17c ], %g3 while (tvp) { 4001a608: 80 a0 e0 00 cmp %g3, 0 4001a60c: 02 80 00 10 be 4001a64c 4001a610: 01 00 00 00 nop if (tvp->ptr == ptr) { 4001a614: c2 00 e0 04 ld [ %g3 + 4 ], %g1 4001a618: 80 a0 40 19 cmp %g1, %i1 4001a61c: 32 80 00 09 bne,a 4001a640 4001a620: 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; 4001a624: 10 80 00 5b b 4001a790 4001a628: 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) { 4001a62c: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 4001a630: 02 80 00 18 be 4001a690 <== NOT EXECUTED 4001a634: 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(); 4001a638: 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; 4001a63c: c4 00 c0 00 ld [ %g3 ], %g2 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 4001a640: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001a644: 32 bf ff fa bne,a 4001a62c <== NOT EXECUTED 4001a648: 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 ) 4001a64c: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED 4001a650: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001a654: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] <== NOT EXECUTED 4001a658: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED 4001a65c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001a660: 12 80 00 2d bne 4001a714 <== NOT EXECUTED 4001a664: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4001a668: 7f ff c9 4d call 4000cb9c <_Thread_Dispatch> <== NOT EXECUTED 4001a66c: b0 10 20 09 mov 9, %i0 ! 9 <== NOT EXECUTED 4001a670: 81 c7 e0 08 ret <== NOT EXECUTED 4001a674: 81 e8 00 00 restore <== NOT EXECUTED 4001a678: 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 ) { 4001a67c: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 4001a680: 08 80 00 2e bleu 4001a738 <== NOT EXECUTED 4001a684: 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 */ } 4001a688: 81 c7 e0 08 ret <== NOT EXECUTED 4001a68c: 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; 4001a690: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED 4001a694: 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)) { 4001a698: 03 10 00 f4 sethi %hi(0x4003d000), %g1 4001a69c: c4 00 61 7c ld [ %g1 + 0x17c ], %g2 ! 4003d17c <_Thread_Executing> 4001a6a0: 80 a2 00 02 cmp %o0, %g2 4001a6a4: 32 80 00 1e bne,a 4001a71c 4001a6a8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED if (tvp->dtor) 4001a6ac: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 4001a6b0: 80 a0 a0 00 cmp %g2, 0 4001a6b4: 22 80 00 06 be,a 4001a6cc 4001a6b8: c4 06 20 04 ld [ %i0 + 4 ], %g2 (*tvp->dtor)(*tvp->ptr); 4001a6bc: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 4001a6c0: 9f c0 80 00 call %g2 <== NOT EXECUTED 4001a6c4: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 4001a6c8: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED 4001a6cc: c2 06 20 08 ld [ %i0 + 8 ], %g1 4001a6d0: c2 20 80 00 st %g1, [ %g2 ] RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 4001a6d4: 92 10 00 18 mov %i0, %o1 4001a6d8: 11 10 00 f4 sethi %hi(0x4003d000), %o0 4001a6dc: 7f ff c1 2e call 4000ab94 <_Heap_Free> 4001a6e0: 90 12 20 ec or %o0, 0xec, %o0 ! 4003d0ec <_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 ) 4001a6e4: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 4001a6e8: b0 10 20 00 clr %i0 4001a6ec: 82 00 7f ff add %g1, -1, %g1 4001a6f0: c2 24 20 a0 st %g1, [ %l0 + 0xa0 ] 4001a6f4: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 4001a6f8: 80 a0 a0 00 cmp %g2, 0 4001a6fc: 12 80 00 04 bne 4001a70c 4001a700: 01 00 00 00 nop _Thread_Dispatch(); 4001a704: 7f ff c9 26 call 4000cb9c <_Thread_Dispatch> 4001a708: 01 00 00 00 nop 4001a70c: 81 c7 e0 08 ret 4001a710: 81 e8 00 00 restore 4001a714: 81 c7 e0 08 ret <== NOT EXECUTED 4001a718: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED } else { if (tvp->dtor) 4001a71c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001a720: 22 bf ff ee be,a 4001a6d8 <== NOT EXECUTED 4001a724: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 4001a728: 9f c0 40 00 call %g1 <== NOT EXECUTED 4001a72c: d0 06 20 0c ld [ %i0 + 0xc ], %o0 <== NOT EXECUTED 4001a730: 10 bf ff ea b 4001a6d8 <== NOT EXECUTED 4001a734: 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 :) */ 4001a738: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001a73c: 32 bf ff cd bne,a 4001a670 <== NOT EXECUTED 4001a740: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4001a744: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 4001a748: 05 10 00 f4 sethi %hi(0x4003d000), %g2 <== NOT EXECUTED 4001a74c: 84 10 a0 00 mov %g2, %g2 ! 4003d000 <_Objects_Information_table> <== NOT EXECUTED 4001a750: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 4001a754: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 4001a758: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a75c: 22 bf ff c5 be,a 4001a670 <== NOT EXECUTED 4001a760: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4001a764: 7f ff c3 8a call 4000b58c <_Objects_Get> <== NOT EXECUTED 4001a768: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 4001a76c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4001a770: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001a774: 02 bf ff a4 be 4001a604 <== NOT EXECUTED 4001a778: 21 10 00 f4 sethi %hi(0x4003d000), %l0 <== NOT EXECUTED 4001a77c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4001a780: 18 bf ff bc bgu 4001a670 <== NOT EXECUTED 4001a784: 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(); 4001a788: 81 c7 e0 08 ret <== NOT EXECUTED 4001a78c: 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; 4001a790: b0 10 00 03 mov %g3, %i0 4001a794: 10 bf ff c1 b 4001a698 4001a798: c2 22 21 7c st %g1, [ %o0 + 0x17c ] 4001a79c : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 4001a79c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 4001a7a0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4001a7a4: 02 80 00 3b be 4001a890 <== NOT EXECUTED 4001a7a8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 4001a7ac: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 4001a7b0: 02 80 00 38 be 4001a890 <== NOT EXECUTED 4001a7b4: 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 ) ) { 4001a7b8: 12 80 00 21 bne 4001a83c <== NOT EXECUTED 4001a7bc: 83 36 20 18 srl %i0, 0x18, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001a7c0: 05 10 00 f4 sethi %hi(0x4003d000), %g2 <== NOT EXECUTED 4001a7c4: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 ! 4003d0a0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 4001a7c8: 82 00 60 01 inc %g1 <== NOT EXECUTED 4001a7cc: c2 20 a0 a0 st %g1, [ %g2 + 0xa0 ] <== 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; 4001a7d0: 03 10 00 f4 sethi %hi(0x4003d000), %g1 <== NOT EXECUTED 4001a7d4: d0 00 61 7c ld [ %g1 + 0x17c ], %o0 ! 4003d17c <_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; 4001a7d8: 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; 4001a7dc: d0 02 21 7c ld [ %o0 + 0x17c ], %o0 <== NOT EXECUTED while (tvp) { 4001a7e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a7e4: 32 80 00 07 bne,a 4001a800 <== NOT EXECUTED 4001a7e8: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4001a7ec: 30 80 00 1a b,a 4001a854 <== NOT EXECUTED 4001a7f0: 90 90 60 00 orcc %g1, 0, %o0 <== NOT EXECUTED 4001a7f4: 02 80 00 18 be 4001a854 <== NOT EXECUTED 4001a7f8: 01 00 00 00 nop <== NOT EXECUTED if (tvp->ptr == ptr) { 4001a7fc: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4001a800: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 4001a804: 32 bf ff fb bne,a 4001a7f0 <== NOT EXECUTED 4001a808: 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; 4001a80c: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED 4001a810: 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 ) 4001a814: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 <== NOT EXECUTED 4001a818: b0 10 20 00 clr %i0 <== NOT EXECUTED 4001a81c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001a820: c2 20 a0 a0 st %g1, [ %g2 + 0xa0 ] <== NOT EXECUTED 4001a824: c4 00 a0 a0 ld [ %g2 + 0xa0 ], %g2 <== NOT EXECUTED 4001a828: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001a82c: 02 80 00 15 be 4001a880 <== NOT EXECUTED 4001a830: 01 00 00 00 nop <== NOT EXECUTED } _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001a834: 81 c7 e0 08 ret <== NOT EXECUTED 4001a838: 81 e8 00 00 restore <== NOT EXECUTED 4001a83c: 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 ) { 4001a840: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 4001a844: 08 80 00 15 bleu 4001a898 <== NOT EXECUTED 4001a848: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED 4001a84c: 81 c7 e0 08 ret <== NOT EXECUTED 4001a850: 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 ) 4001a854: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 <== NOT EXECUTED 4001a858: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001a85c: c2 20 a0 a0 st %g1, [ %g2 + 0xa0 ] <== NOT EXECUTED 4001a860: c4 00 a0 a0 ld [ %g2 + 0xa0 ], %g2 <== NOT EXECUTED 4001a864: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001a868: 12 80 00 0a bne 4001a890 <== NOT EXECUTED 4001a86c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 4001a870: 7f ff c8 cb call 4000cb9c <_Thread_Dispatch> <== NOT EXECUTED 4001a874: b0 10 20 09 mov 9, %i0 ! 9 <== NOT EXECUTED 4001a878: 81 c7 e0 08 ret <== NOT EXECUTED 4001a87c: 81 e8 00 00 restore <== NOT EXECUTED 4001a880: 7f ff c8 c7 call 4000cb9c <_Thread_Dispatch> <== NOT EXECUTED 4001a884: 01 00 00 00 nop <== NOT EXECUTED 4001a888: 81 c7 e0 08 ret <== NOT EXECUTED 4001a88c: 81 e8 00 00 restore <== NOT EXECUTED 4001a890: 81 c7 e0 08 ret <== NOT EXECUTED 4001a894: 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 :) */ 4001a898: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 4001a89c: 32 bf ff e6 bne,a 4001a834 <== NOT EXECUTED 4001a8a0: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 4001a8a4: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 4001a8a8: 05 10 00 f4 sethi %hi(0x4003d000), %g2 <== NOT EXECUTED 4001a8ac: 84 10 a0 00 mov %g2, %g2 ! 4003d000 <_Objects_Information_table> <== NOT EXECUTED 4001a8b0: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 4001a8b4: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 4001a8b8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a8bc: 22 bf ff de be,a 4001a834 <== NOT EXECUTED 4001a8c0: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 4001a8c4: 7f ff c3 32 call 4000b58c <_Objects_Get> <== NOT EXECUTED 4001a8c8: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 4001a8cc: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 4001a8d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001a8d4: 02 bf ff c2 be 4001a7dc <== NOT EXECUTED 4001a8d8: 05 10 00 f4 sethi %hi(0x4003d000), %g2 <== NOT EXECUTED 4001a8dc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 4001a8e0: 18 bf ff d5 bgu 4001a834 <== NOT EXECUTED 4001a8e4: 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(); 4001a8e8: 81 c7 e0 08 ret <== NOT EXECUTED 4001a8ec: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 40012a48 : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 40012a48: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40012a4c: 11 10 00 ce sethi %hi(0x40033800), %o0 40012a50: 92 10 00 18 mov %i0, %o1 40012a54: 90 12 20 4c or %o0, 0x4c, %o0 40012a58: 40 00 0a ac call 40015508 <_Objects_Get> 40012a5c: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012a60: c2 07 bf f4 ld [ %fp + -12 ], %g1 40012a64: 80 a0 60 00 cmp %g1, 0 40012a68: 12 80 00 11 bne 40012aac 40012a6c: 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 ) ) 40012a70: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 40012a74: 80 a0 60 04 cmp %g1, 4 40012a78: 12 80 00 16 bne 40012ad0 40012a7c: 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 ) 40012a80: 03 10 00 cd sethi %hi(0x40033400), %g1 <== NOT EXECUTED 40012a84: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40012a88: b0 10 20 00 clr %i0 <== NOT EXECUTED 40012a8c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 40012a90: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] <== NOT EXECUTED 40012a94: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 <== NOT EXECUTED 40012a98: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40012a9c: 02 80 00 09 be 40012ac0 <== NOT EXECUTED 40012aa0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012aa4: 81 c7 e0 08 ret <== NOT EXECUTED 40012aa8: 81 e8 00 00 restore <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012aac: 80 a0 00 01 cmp %g0, %g1 40012ab0: 84 60 20 00 subx %g0, 0, %g2 40012ab4: b0 08 a0 15 and %g2, 0x15, %i0 40012ab8: 81 c7 e0 08 ret 40012abc: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 40012ac0: 40 00 0f ba call 400169a8 <_Thread_Dispatch> 40012ac4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012ac8: 81 c7 e0 08 ret 40012acc: 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 ); 40012ad0: 40 00 16 7e call 400184c8 <_Watchdog_Remove> 40012ad4: 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 ) 40012ad8: 03 10 00 cd sethi %hi(0x40033400), %g1 40012adc: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 40012ae0: b0 10 20 00 clr %i0 40012ae4: 84 00 bf ff add %g2, -1, %g2 40012ae8: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 40012aec: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 40012af0: 80 a0 e0 00 cmp %g3, 0 40012af4: 12 bf ff f5 bne 40012ac8 40012af8: 01 00 00 00 nop 40012afc: 30 bf ff f1 b,a 40012ac0 40012bec : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 40012bec: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40012bf0: 21 10 00 ce sethi %hi(0x40033800), %l0 40012bf4: 92 10 00 18 mov %i0, %o1 40012bf8: 94 07 bf f4 add %fp, -12, %o2 40012bfc: 40 00 0a 43 call 40015508 <_Objects_Get> 40012c00: 90 14 20 4c or %l0, 0x4c, %o0 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012c04: c2 07 bf f4 ld [ %fp + -12 ], %g1 40012c08: 80 a0 60 00 cmp %g1, 0 40012c0c: 12 80 00 1f bne 40012c88 40012c10: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40012c14: a0 14 20 4c or %l0, 0x4c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 40012c18: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 40012c1c: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 40012c20: 05 00 00 3f sethi %hi(0xfc00), %g2 40012c24: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 40012c28: 82 08 40 02 and %g1, %g2, %g1 40012c2c: 80 a0 40 03 cmp %g1, %g3 40012c30: 38 80 00 06 bgu,a 40012c48 40012c34: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 40012c38: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 40012c3c: 83 28 60 02 sll %g1, 2, %g1 40012c40: 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; 40012c44: 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 ); 40012c48: 40 00 16 20 call 400184c8 <_Watchdog_Remove> 40012c4c: 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 ); 40012c50: 90 10 00 10 mov %l0, %o0 40012c54: 40 00 09 d6 call 400153ac <_Objects_Free> 40012c58: 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 ) 40012c5c: 03 10 00 cd sethi %hi(0x40033400), %g1 40012c60: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 40012c64: b0 10 20 00 clr %i0 40012c68: 84 00 bf ff add %g2, -1, %g2 40012c6c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 40012c70: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 40012c74: 80 a0 e0 00 cmp %g3, 0 40012c78: 02 80 00 0a be 40012ca0 40012c7c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012c80: 81 c7 e0 08 ret <== NOT EXECUTED 40012c84: 81 e8 00 00 restore <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012c88: 82 18 60 02 xor %g1, 2, %g1 40012c8c: 80 a0 00 01 cmp %g0, %g1 40012c90: 84 60 20 00 subx %g0, 0, %g2 40012c94: b0 08 a0 15 and %g2, 0x15, %i0 40012c98: 81 c7 e0 08 ret 40012c9c: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 40012ca0: 40 00 0f 42 call 400169a8 <_Thread_Dispatch> 40012ca4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012ca8: 81 c7 e0 08 ret 40012cac: 81 e8 00 00 restore 40012cb0 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 40012cb0: 9d e3 bf 90 save %sp, -112, %sp 40012cb4: a4 10 00 18 mov %i0, %l2 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 40012cb8: 80 a6 60 00 cmp %i1, 0 40012cbc: 02 80 00 3e be 40012db4 40012cc0: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( !routine ) 40012cc4: 80 a6 a0 00 cmp %i2, 0 40012cc8: 02 80 00 3b be 40012db4 40012ccc: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 40012cd0: 11 10 00 ce sethi %hi(0x40033800), %o0 40012cd4: 92 10 00 12 mov %l2, %o1 40012cd8: 90 12 20 4c or %o0, 0x4c, %o0 40012cdc: 40 00 0a 0b call 40015508 <_Objects_Get> 40012ce0: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012ce4: c2 07 bf f4 ld [ %fp + -12 ], %g1 40012ce8: 80 a0 60 00 cmp %g1, 0 40012cec: 12 80 00 17 bne 40012d48 40012cf0: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 40012cf4: a2 02 20 10 add %o0, 0x10, %l1 40012cf8: 40 00 15 f4 call 400184c8 <_Watchdog_Remove> 40012cfc: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 40012d00: 7f ff df 7e call 4000aaf8 40012d04: 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 ) { 40012d08: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 40012d0c: 80 a0 60 00 cmp %g1, 0 40012d10: 22 80 00 14 be,a 40012d60 40012d14: f4 24 20 2c st %i2, [ %l0 + 0x2c ] _ISR_Enable( level ); 40012d18: 7f ff df 7c call 4000ab08 <== NOT EXECUTED 40012d1c: 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 ) 40012d20: 03 10 00 cd sethi %hi(0x40033400), %g1 <== NOT EXECUTED 40012d24: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 40012d28: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 40012d2c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] <== NOT EXECUTED 40012d30: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 <== NOT EXECUTED 40012d34: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 40012d38: 02 80 00 1d be 40012dac <== NOT EXECUTED 40012d3c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012d40: 81 c7 e0 08 ret <== NOT EXECUTED 40012d44: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012d48: 82 18 60 02 xor %g1, 2, %g1 40012d4c: 80 a0 00 01 cmp %g0, %g1 40012d50: 84 60 20 00 subx %g0, 0, %g2 40012d54: b0 08 a0 15 and %g2, 0x15, %i0 40012d58: 81 c7 e0 08 ret 40012d5c: 91 ee 20 04 restore %i0, 4, %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 40012d60: e4 24 20 30 st %l2, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 40012d64: 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; 40012d68: c0 24 20 38 clr [ %l0 + 0x38 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40012d6c: c0 24 20 18 clr [ %l0 + 0x18 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 40012d70: 7f ff df 66 call 4000ab08 40012d74: 01 00 00 00 nop ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40012d78: 92 10 00 11 mov %l1, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40012d7c: f2 24 20 1c st %i1, [ %l0 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40012d80: 11 10 00 cd sethi %hi(0x40033400), %o0 40012d84: 40 00 15 67 call 40018320 <_Watchdog_Insert> 40012d88: 90 12 21 dc or %o0, 0x1dc, %o0 ! 400335dc <_Watchdog_Ticks_chain> 40012d8c: 05 10 00 cd sethi %hi(0x40033400), %g2 40012d90: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 40012d94: 82 00 7f ff add %g1, -1, %g1 40012d98: c2 20 a0 e0 st %g1, [ %g2 + 0xe0 ] 40012d9c: c6 00 a0 e0 ld [ %g2 + 0xe0 ], %g3 40012da0: 80 a0 e0 00 cmp %g3, 0 40012da4: 32 80 00 04 bne,a 40012db4 40012da8: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Dispatch(); 40012dac: 40 00 0e ff call 400169a8 <_Thread_Dispatch> 40012db0: b0 10 20 00 clr %i0 40012db4: 81 c7 e0 08 ret 40012db8: 81 e8 00 00 restore 400085f8 : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 400085f8: 9d e3 bf 90 save %sp, -112, %sp 400085fc: 92 10 00 18 mov %i0, %o1 Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 40008600: 80 a6 60 00 cmp %i1, 0 40008604: 02 80 00 1b be 40008670 40008608: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 4000860c: 11 10 00 7c sethi %hi(0x4001f000), %o0 40008610: 94 07 bf f4 add %fp, -12, %o2 40008614: 40 00 07 90 call 4000a454 <_Objects_Get> 40008618: 90 12 23 a4 or %o0, 0x3a4, %o0 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 4000861c: c2 07 bf f4 ld [ %fp + -12 ], %g1 40008620: 80 a0 60 00 cmp %g1, 0 40008624: 12 80 00 15 bne 40008678 40008628: 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; 4000862c: 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; 40008630: c6 02 20 38 ld [ %o0 + 0x38 ], %g3 the_info->initial = the_timer->Ticker.initial; 40008634: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->start_time = the_timer->Ticker.start_time; 40008638: 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; 4000863c: c6 26 40 00 st %g3, [ %i1 ] the_info->initial = the_timer->Ticker.initial; the_info->start_time = the_timer->Ticker.start_time; 40008640: c4 26 60 08 st %g2, [ %i1 + 8 ] the_info->stop_time = the_timer->Ticker.stop_time; 40008644: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 40008648: 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 ) 4000864c: 07 10 00 7d sethi %hi(0x4001f400), %g3 40008650: c2 00 e1 90 ld [ %g3 + 0x190 ], %g1 ! 4001f590 <_Thread_Dispatch_disable_level> 40008654: b0 10 20 00 clr %i0 40008658: 82 00 7f ff add %g1, -1, %g1 4000865c: c2 20 e1 90 st %g1, [ %g3 + 0x190 ] 40008660: c4 00 e1 90 ld [ %g3 + 0x190 ], %g2 40008664: 80 a0 a0 00 cmp %g2, 0 40008668: 02 80 00 09 be 4000868c 4000866c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008670: 81 c7 e0 08 ret <== NOT EXECUTED 40008674: 81 e8 00 00 restore <== NOT EXECUTED if ( !the_info ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40008678: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 4000867c: 84 60 20 00 subx %g0, 0, %g2 <== NOT EXECUTED 40008680: b0 08 a0 15 and %g2, 0x15, %i0 <== NOT EXECUTED 40008684: 81 c7 e0 08 ret <== NOT EXECUTED 40008688: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED _Thread_Dispatch(); 4000868c: 40 00 0c 9a call 4000b8f4 <_Thread_Dispatch> 40008690: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40008694: 81 c7 e0 08 ret 40008698: 81 e8 00 00 restore 40013514 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 40013514: 9d e3 bf 90 save %sp, -112, %sp /* * Make sure the requested priority is valid. */ _priority = priority; if ( priority == RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 40013518: 92 10 20 00 clr %o1 4001351c: 80 a6 3f ff cmp %i0, -1 40013520: 02 80 00 07 be 4001353c 40013524: 94 10 00 19 mov %i1, %o2 _priority = 0; else if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) 40013528: 82 06 3f ff add %i0, -1, %g1 4001352c: 80 a0 60 fe cmp %g1, 0xfe 40013530: 18 80 00 16 bgu 40013588 40013534: a2 10 20 13 mov 0x13, %l1 40013538: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 4001353c: 21 10 00 cd sethi %hi(0x40033400), %l0 40013540: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 ! 400334e0 <_Thread_Dispatch_disable_level> 40013544: 82 00 60 01 inc %g1 40013548: c2 24 20 e0 st %g1, [ %l0 + 0xe0 ] * Just to make sure the test versus create/start operation are atomic. */ _Thread_Disable_dispatch(); if ( _Timer_Server ) { 4001354c: 33 10 00 ce sethi %hi(0x40033800), %i1 40013550: c2 06 60 98 ld [ %i1 + 0x98 ], %g1 ! 40033898 <_Timer_Server> 40013554: 80 a0 60 00 cmp %g1, 0 40013558: 02 80 00 0e be 40013590 4001355c: 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 ) 40013560: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 <== NOT EXECUTED 40013564: a2 10 20 0e mov 0xe, %l1 <== NOT EXECUTED _Thread_Dispatch(); 40013568: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001356c: c2 24 20 e0 st %g1, [ %l0 + 0xe0 ] 40013570: c4 04 20 e0 ld [ %l0 + 0xe0 ], %g2 40013574: 80 a0 a0 00 cmp %g2, 0 40013578: 12 80 00 04 bne 40013588 4001357c: 01 00 00 00 nop 40013580: 40 00 0d 0a call 400169a8 <_Thread_Dispatch> 40013584: 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; } 40013588: 81 c7 e0 08 ret 4001358c: 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( 40013590: 11 15 12 53 sethi %hi(0x54494c00), %o0 40013594: 98 16 80 0c or %i2, %o4, %o4 40013598: 90 12 21 45 or %o0, 0x145, %o0 4001359c: 96 10 21 00 mov 0x100, %o3 400135a0: 7f ff f9 fc call 40011d90 400135a4: 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) { 400135a8: a2 92 20 00 orcc %o0, 0, %l1 400135ac: 02 80 00 05 be 400135c0 400135b0: 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 ) 400135b4: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 400135b8: 10 bf ff ed b 4001356c 400135bc: 82 00 7f ff add %g1, -1, %g1 _Thread_Enable_dispatch(); return status; } status = rtems_task_start( 400135c0: 13 10 00 4c sethi %hi(0x40013000), %o1 400135c4: 94 10 20 00 clr %o2 400135c8: 7f ff fc 3d call 400126bc 400135cc: 92 12 63 c0 or %o1, 0x3c0, %o1 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 400135d0: a2 92 20 00 orcc %o0, 0, %l1 400135d4: 12 bf ff f8 bne 400135b4 400135d8: 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 ) 400135dc: 03 10 00 cc sethi %hi(0x40033000), %g1 400135e0: 9a 10 63 90 or %g1, 0x390, %o5 ! 40033390 <_RTEMS_tasks_Information> 400135e4: c4 13 60 10 lduh [ %o5 + 0x10 ], %g2 400135e8: 03 00 00 3f sethi %hi(0xfc00), %g1 400135ec: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 400135f0: 86 09 00 01 and %g4, %g1, %g3 400135f4: 80 a0 c0 02 cmp %g3, %g2 400135f8: 18 80 00 05 bgu 4001360c 400135fc: 82 10 20 00 clr %g1 40013600: c4 03 60 20 ld [ %o5 + 0x20 ], %g2 40013604: 83 28 e0 02 sll %g3, 2, %g1 40013608: 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; 4001360c: c0 20 60 6c clr [ %g1 + 0x6c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 40013610: c0 20 60 50 clr [ %g1 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; 40013614: c8 20 60 68 st %g4, [ %g1 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 40013618: 07 10 00 5a sethi %hi(0x40016800), %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( 4001361c: c2 26 60 98 st %g1, [ %i1 + 0x98 ] 40013620: 86 10 e1 04 or %g3, 0x104, %g3 40013624: 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; 40013628: 03 10 00 cc sethi %hi(0x40033000), %g1 4001362c: 82 10 63 e0 or %g1, 0x3e0, %g1 ! 400333e0 <_Timer_Ticks_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 40013630: c2 20 7f fc st %g1, [ %g1 + -4 ] 40013634: 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; 40013638: 05 10 00 cc sethi %hi(0x40033000), %g2 Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 4001363c: 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; 40013640: 84 10 a3 f4 or %g2, 0x3f4, %g2 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 40013644: 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); 40013648: c4 20 bf fc st %g2, [ %g2 + -4 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4001364c: 03 10 00 cc sethi %hi(0x40033000), %g1 40013650: 84 00 bf fc add %g2, -4, %g2 40013654: 82 10 63 fc or %g1, 0x3fc, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 40013658: 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; 4001365c: c0 20 a0 04 clr [ %g2 + 4 ] the_watchdog->routine = routine; 40013660: c6 20 60 1c st %g3, [ %g1 + 0x1c ] the_watchdog->id = id; 40013664: c8 20 60 20 st %g4, [ %g1 + 0x20 ] the_watchdog->user_data = user_data; 40013668: c0 20 60 24 clr [ %g1 + 0x24 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 4001366c: 10 bf ff d2 b 400135b4 40013670: c0 20 60 08 clr [ %g1 + 8 ] 40012f08 : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 40012f08: 9d e3 bf 90 save %sp, -112, %sp 40012f0c: 11 10 00 ce sethi %hi(0x40033800), %o0 40012f10: 92 10 00 18 mov %i0, %o1 40012f14: 90 12 20 4c or %o0, 0x4c, %o0 40012f18: 40 00 09 7c call 40015508 <_Objects_Get> 40012f1c: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012f20: c2 07 bf f4 ld [ %fp + -12 ], %g1 40012f24: 80 a0 60 00 cmp %g1, 0 40012f28: 12 80 00 18 bne 40012f88 40012f2c: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 40012f30: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 40012f34: 80 a0 60 01 cmp %g1, 1 40012f38: 22 80 00 2f be,a 40012ff4 40012f3c: 31 10 00 ce sethi %hi(0x40033800), %i0 40012f40: 2a 80 00 18 bcs,a 40012fa0 40012f44: a0 02 20 10 add %o0, 0x10, %l0 40012f48: 80 a0 60 04 cmp %g1, 4 40012f4c: 18 80 00 1b bgu 40012fb8 40012f50: 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 ) 40012f54: 03 10 00 cd sethi %hi(0x40033400), %g1 40012f58: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 40012f5c: b0 10 20 0b mov 0xb, %i0 40012f60: 84 00 bf ff add %g2, -1, %g2 40012f64: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 40012f68: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 40012f6c: 80 a0 e0 00 cmp %g3, 0 40012f70: 12 80 00 1f bne 40012fec 40012f74: 01 00 00 00 nop _Thread_Dispatch(); 40012f78: 40 00 0e 8c call 400169a8 <_Thread_Dispatch> 40012f7c: 01 00 00 00 nop 40012f80: 81 c7 e0 08 ret 40012f84: 81 e8 00 00 restore { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40012f88: 82 18 60 02 xor %g1, 2, %g1 40012f8c: 80 a0 00 01 cmp %g0, %g1 40012f90: 84 60 20 00 subx %g0, 0, %g2 40012f94: b0 08 a0 15 and %g2, 0x15, %i0 40012f98: 81 c7 e0 08 ret 40012f9c: 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 ); 40012fa0: 40 00 15 4a call 400184c8 <_Watchdog_Remove> 40012fa4: 90 10 00 10 mov %l0, %o0 _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 40012fa8: 11 10 00 cd sethi %hi(0x40033400), %o0 40012fac: 92 10 00 10 mov %l0, %o1 40012fb0: 40 00 14 dc call 40018320 <_Watchdog_Insert> 40012fb4: 90 12 21 dc or %o0, 0x1dc, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40012fb8: 03 10 00 cd sethi %hi(0x40033400), %g1 40012fbc: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> 40012fc0: b0 10 20 00 clr %i0 40012fc4: 84 00 bf ff add %g2, -1, %g2 40012fc8: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 40012fcc: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 40012fd0: 80 a0 e0 00 cmp %g3, 0 40012fd4: 02 80 00 04 be 40012fe4 40012fd8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 40012fdc: 81 c7 e0 08 ret <== NOT EXECUTED 40012fe0: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 40012fe4: 40 00 0e 71 call 400169a8 <_Thread_Dispatch> 40012fe8: 01 00 00 00 nop 40012fec: 81 c7 e0 08 ret 40012ff0: 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(); 40012ff4: d0 06 20 98 ld [ %i0 + 0x98 ], %o0 _Watchdog_Remove( &the_timer->Ticker ); 40012ff8: 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(); 40012ffc: 40 00 15 33 call 400184c8 <_Watchdog_Remove> 40013000: 90 02 20 48 add %o0, 0x48, %o0 _Watchdog_Remove( &the_timer->Ticker ); 40013004: 40 00 15 31 call 400184c8 <_Watchdog_Remove> 40013008: 90 10 00 11 mov %l1, %o0 _Timer_Server_process_ticks_chain(); 4001300c: 40 00 00 dc call 4001337c <_Timer_Server_process_ticks_chain> 40013010: 21 10 00 cc sethi %hi(0x40033000), %l0 _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 40013014: 92 10 00 11 mov %l1, %o1 40013018: 40 00 14 c2 call 40018320 <_Watchdog_Insert> 4001301c: 90 14 23 dc or %l0, 0x3dc, %o0 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 40013020: c4 04 23 dc ld [ %l0 + 0x3dc ], %g2 40013024: a0 14 23 dc or %l0, 0x3dc, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40013028: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 4001302c: 80 a0 80 10 cmp %g2, %l0 40013030: 02 bf ff e2 be 40012fb8 40013034: c2 06 20 98 ld [ %i0 + 0x98 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40013038: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4001303c: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40013040: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40013044: 11 10 00 cd sethi %hi(0x40033400), %o0 40013048: 40 00 14 b6 call 40018320 <_Watchdog_Insert> 4001304c: 90 12 21 dc or %o0, 0x1dc, %o0 ! 400335dc <_Watchdog_Ticks_chain> 40013050: 30 bf ff da b,a 40012fb8 40013054 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 40013054: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 40013058: 23 10 00 ce sethi %hi(0x40033800), %l1 4001305c: c2 04 60 98 ld [ %l1 + 0x98 ], %g1 ! 40033898 <_Timer_Server> Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 40013060: a6 10 00 18 mov %i0, %l3 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 40013064: 80 a0 60 00 cmp %g1, 0 40013068: 02 80 00 3b be 40013154 4001306c: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; if ( !routine ) 40013070: 80 a6 a0 00 cmp %i2, 0 40013074: 02 80 00 38 be 40013154 40013078: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 4001307c: 80 a6 60 00 cmp %i1, 0 40013080: 02 80 00 35 be 40013154 40013084: b0 10 20 0a mov 0xa, %i0 40013088: 11 10 00 ce sethi %hi(0x40033800), %o0 4001308c: 92 10 00 13 mov %l3, %o1 40013090: 90 12 20 4c or %o0, 0x4c, %o0 40013094: 40 00 09 1d call 40015508 <_Objects_Get> 40013098: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 4001309c: c2 07 bf f4 ld [ %fp + -12 ], %g1 400130a0: 80 a0 60 00 cmp %g1, 0 400130a4: 12 80 00 30 bne 40013164 400130a8: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 400130ac: a4 02 20 10 add %o0, 0x10, %l2 400130b0: 40 00 15 06 call 400184c8 <_Watchdog_Remove> 400130b4: 90 10 00 12 mov %l2, %o0 _ISR_Disable( level ); 400130b8: 7f ff de 90 call 4000aaf8 400130bc: 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 ) { 400130c0: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 400130c4: 80 a0 60 00 cmp %g1, 0 400130c8: 12 80 00 2d bne 4001317c 400130cc: 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; 400130d0: f2 24 20 1c st %i1, [ %l0 + 0x1c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 400130d4: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 400130d8: e6 24 20 30 st %l3, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 400130dc: f6 24 20 34 st %i3, [ %l0 + 0x34 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 400130e0: 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; 400130e4: 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 ); 400130e8: 7f ff de 88 call 4000ab08 400130ec: 21 10 00 cc sethi %hi(0x40033000), %l0 _Timer_Server_stop_ticks_timer(); 400130f0: d0 04 60 98 ld [ %l1 + 0x98 ], %o0 400130f4: 40 00 14 f5 call 400184c8 <_Watchdog_Remove> 400130f8: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_process_ticks_chain(); 400130fc: 40 00 00 a0 call 4001337c <_Timer_Server_process_ticks_chain> 40013100: 01 00 00 00 nop _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 40013104: 90 14 23 dc or %l0, 0x3dc, %o0 40013108: 40 00 14 86 call 40018320 <_Watchdog_Insert> 4001310c: 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)); 40013110: c4 04 23 dc ld [ %l0 + 0x3dc ], %g2 40013114: a0 14 23 dc or %l0, 0x3dc, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 40013118: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 4001311c: 80 a0 80 10 cmp %g2, %l0 40013120: 12 80 00 1a bne 40013188 40013124: c2 04 60 98 ld [ %l1 + 0x98 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 40013128: 03 10 00 cd sethi %hi(0x40033400), %g1 4001312c: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 400334e0 <_Thread_Dispatch_disable_level> _Thread_Dispatch(); 40013130: 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 ) 40013134: 84 00 bf ff add %g2, -1, %g2 40013138: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 4001313c: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 40013140: 80 a0 e0 00 cmp %g3, 0 40013144: 12 80 00 06 bne 4001315c 40013148: 01 00 00 00 nop _Thread_Dispatch(); 4001314c: 40 00 0e 17 call 400169a8 <_Thread_Dispatch> 40013150: b0 10 20 00 clr %i0 ! 0 40013154: 81 c7 e0 08 ret 40013158: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 4001315c: 81 c7 e0 08 ret <== NOT EXECUTED 40013160: 81 e8 00 00 restore <== NOT EXECUTED if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 40013164: 82 18 60 02 xor %g1, 2, %g1 40013168: 80 a0 00 01 cmp %g0, %g1 4001316c: 84 60 20 00 subx %g0, 0, %g2 40013170: b0 08 a0 15 and %g2, 0x15, %i0 40013174: 81 c7 e0 08 ret 40013178: 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 ); 4001317c: 7f ff de 63 call 4000ab08 <== NOT EXECUTED 40013180: 01 00 00 00 nop <== NOT EXECUTED 40013184: 30 bf ff e9 b,a 40013128 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40013188: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 4001318c: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 40013190: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 40013194: 11 10 00 cd sethi %hi(0x40033400), %o0 40013198: 40 00 14 62 call 40018320 <_Watchdog_Insert> 4001319c: 90 12 21 dc or %o0, 0x1dc, %o0 ! 400335dc <_Watchdog_Ticks_chain> 400131a0: 30 bf ff e2 b,a 40013128