=============================================================================== 3000f974 : /** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ microseconds_per_tick = rtems_configuration_get_microseconds_per_tick(); 3000f974: e59f3030 ldr r3, [pc, #48] ; 3000f9ac <== NOT EXECUTED #include uint32_t TOD_MICROSECONDS_TO_TICKS( uint32_t microseconds ) { 3000f978: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED /** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ microseconds_per_tick = rtems_configuration_get_microseconds_per_tick(); 3000f97c: e593500c ldr r5, [r3, #12] <== NOT EXECUTED #include uint32_t TOD_MICROSECONDS_TO_TICKS( uint32_t microseconds ) { 3000f980: e1a06000 mov r6, r0 <== NOT EXECUTED * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ microseconds_per_tick = rtems_configuration_get_microseconds_per_tick(); ticks = microseconds / microseconds_per_tick; 3000f984: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f988: eb004a48 bl 300222b0 <__aeabi_uidiv> <== NOT EXECUTED if ( (microseconds % microseconds_per_tick) != 0 ) 3000f98c: e1a01005 mov r1, r5 <== NOT EXECUTED * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ microseconds_per_tick = rtems_configuration_get_microseconds_per_tick(); ticks = microseconds / microseconds_per_tick; 3000f990: e1a04000 mov r4, r0 <== NOT EXECUTED if ( (microseconds % microseconds_per_tick) != 0 ) 3000f994: e1a00006 mov r0, r6 <== NOT EXECUTED 3000f998: eb004a8a bl 300223c8 <__umodsi3> <== NOT EXECUTED 3000f99c: e3500000 cmp r0, #0 <== NOT EXECUTED ticks += 1; 3000f9a0: 12844001 addne r4, r4, #1 <== NOT EXECUTED return ticks; } 3000f9a4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f9a8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000b800 : /** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick(); 3000b800: e59f3040 ldr r3, [pc, #64] ; 3000b848 <== NOT EXECUTED #include uint32_t TOD_MILLISECONDS_TO_TICKS( uint32_t milliseconds ) { 3000b804: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED /** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick(); 3000b808: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED #include uint32_t TOD_MILLISECONDS_TO_TICKS( uint32_t milliseconds ) { 3000b80c: e1a06000 mov r6, r0 <== NOT EXECUTED /** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick(); 3000b810: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000b814: eb003d34 bl 3001acec <__aeabi_uidiv> <== NOT EXECUTED 3000b818: e1a05000 mov r5, r0 <== NOT EXECUTED ticks = milliseconds / milliseconds_per_tick; 3000b81c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000b820: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b824: eb003d30 bl 3001acec <__aeabi_uidiv> <== NOT EXECUTED if ( (milliseconds % milliseconds_per_tick) != 0 ) 3000b828: e1a01005 mov r1, r5 <== NOT EXECUTED * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick(); ticks = milliseconds / milliseconds_per_tick; 3000b82c: e1a04000 mov r4, r0 <== NOT EXECUTED if ( (milliseconds % milliseconds_per_tick) != 0 ) 3000b830: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b834: eb003d72 bl 3001ae04 <__umodsi3> <== NOT EXECUTED 3000b838: e3500000 cmp r0, #0 <== NOT EXECUTED ticks += 1; 3000b83c: 12844001 addne r4, r4, #1 <== NOT EXECUTED return ticks; } 3000b840: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b844: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 30028990 : #include #include uint32_t TOD_TICKS_PER_SECOND_method(void) { return (TOD_MICROSECONDS_PER_SECOND / 30028990: e59f3010 ldr r3, [pc, #16] ; 300289a8 <== NOT EXECUTED #include #include #include uint32_t TOD_TICKS_PER_SECOND_method(void) { 30028994: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED return (TOD_MICROSECONDS_PER_SECOND / 30028998: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3002899c: e59f0008 ldr r0, [pc, #8] ; 300289ac <== NOT EXECUTED 300289a0: ebff7105 bl 30004dbc <__aeabi_uidiv> <== NOT EXECUTED rtems_configuration_get_microseconds_per_tick()); } 300289a4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 300118a0 <_CORE_barrier_Wait>: ) { Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 300118a0: e59fc074 ldr ip, [pc, #116] ; 3001191c <_CORE_barrier_Wait+0x7c> Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 300118a4: e92d40f0 push {r4, r5, r6, r7, lr} Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 300118a8: e59cc008 ldr ip, [ip, #8] executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 300118ac: e3a04000 mov r4, #0 300118b0: e58c4034 str r4, [ip, #52] ; 0x34 Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 300118b4: e59d2014 ldr r2, [sp, #20] uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 300118b8: e10f4000 mrs r4, CPSR 300118bc: e3845080 orr r5, r4, #128 ; 0x80 300118c0: e129f005 msr CPSR_fc, r5 ISR_Level level; executing = _Thread_Executing; executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; _ISR_Disable( level ); the_barrier->number_of_waiting_threads++; 300118c4: e5906048 ldr r6, [r0, #72] ; 0x48 if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 300118c8: e5905040 ldr r5, [r0, #64] ; 0x40 ISR_Level level; executing = _Thread_Executing; executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; _ISR_Disable( level ); the_barrier->number_of_waiting_threads++; 300118cc: e2866001 add r6, r6, #1 if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 300118d0: e3550000 cmp r5, #0 ISR_Level level; executing = _Thread_Executing; executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; _ISR_Disable( level ); the_barrier->number_of_waiting_threads++; 300118d4: e5806048 str r6, [r0, #72] ; 0x48 300118d8: e3a05001 mov r5, #1 if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 300118dc: 1a000006 bne 300118fc <_CORE_barrier_Wait+0x5c> if ( the_barrier->number_of_waiting_threads == 300118e0: e5907044 ldr r7, [r0, #68] ; 0x44 <== NOT EXECUTED 300118e4: e1560007 cmp r6, r7 <== NOT EXECUTED 300118e8: 1a000003 bne 300118fc <_CORE_barrier_Wait+0x5c> <== NOT EXECUTED the_barrier->Attributes.maximum_count) { executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; 300118ec: e58c5034 str r5, [ip, #52] ; 0x34 <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 300118f0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); } 300118f4: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { if ( the_barrier->number_of_waiting_threads == the_barrier->Attributes.maximum_count) { executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; _ISR_Enable( level ); _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 300118f8: eaffffdc b 30011870 <_CORE_barrier_Release> <== NOT EXECUTED 300118fc: e5805030 str r5, [r0, #48] ; 0x30 return; } } _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; 30011900: e58c0044 str r0, [ip, #68] ; 0x44 executing->Wait.id = id; 30011904: e58c1020 str r1, [ip, #32] 30011908: e129f004 msr CPSR_fc, r4 _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 3001190c: e59f200c ldr r2, [pc, #12] ; 30011920 <_CORE_barrier_Wait+0x80> 30011910: e1a01003 mov r1, r3 } 30011914: e8bd40f0 pop {r4, r5, r6, r7, lr} _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 30011918: eafff27f b 3000e31c <_Thread_queue_Enqueue_with_handler> =============================================================================== 30019d94 <_CORE_message_queue_Broadcast>: { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 30019d94: e590304c ldr r3, [r0, #76] ; 0x4c Objects_Id id __attribute__((unused)), CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)), #endif uint32_t *count ) { 30019d98: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 30019d9c: e1520003 cmp r2, r3 Objects_Id id __attribute__((unused)), CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)), #endif uint32_t *count ) { 30019da0: e1a06000 mov r6, r0 30019da4: e1a0a001 mov sl, r1 30019da8: e1a07002 mov r7, r2 30019dac: e59d8020 ldr r8, [sp, #32] Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 30019db0: 8a000013 bhi 30019e04 <_CORE_message_queue_Broadcast+0x70> * 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 ) { 30019db4: e5905048 ldr r5, [r0, #72] ; 0x48 30019db8: e3550000 cmp r5, #0 *count = 0; 30019dbc: 13a00000 movne r0, #0 30019dc0: 15880000 strne r0, [r8] * 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 ) { 30019dc4: 0a000007 beq 30019de8 <_CORE_message_queue_Broadcast+0x54> 30019dc8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 30019dcc: e594002c ldr r0, [r4, #44] ; 0x2c 30019dd0: e1a0100a mov r1, sl 30019dd4: e1a02007 mov r2, r7 30019dd8: eb001ca5 bl 30021074 buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 30019ddc: e5943028 ldr r3, [r4, #40] ; 0x28 */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { waitp = &the_thread->Wait; number_broadcasted += 1; 30019de0: e2855001 add r5, r5, #1 buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 30019de4: e5837000 str r7, [r3] /* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = 30019de8: e1a00006 mov r0, r6 30019dec: eb000b29 bl 3001ca98 <_Thread_queue_Dequeue> 30019df0: e2504000 subs r4, r0, #0 30019df4: 1afffff4 bne 30019dcc <_CORE_message_queue_Broadcast+0x38> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 30019df8: e5885000 str r5, [r8] return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 30019dfc: e1a00004 mov r0, r4 30019e00: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE; 30019e04: e3a00001 mov r0, #1 <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 30019e08: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED =============================================================================== 30012b18 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { 30012b18: e92d40f0 push {r4, r5, r6, r7, lr} /* * Check if allocated_message_size is aligned to uintptr-size boundary. * If not, it will increase allocated_message_size to multiplicity of pointer * size. */ if (allocated_message_size & (sizeof(uintptr_t) - 1)) { 30012b1c: e3130003 tst r3, #3 CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { 30012b20: e1a04000 mov r4, r0 size_t message_buffering_required = 0; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; the_message_queue->number_of_pending_messages = 0; 30012b24: e3a00000 mov r0, #0 CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { 30012b28: e1a07001 mov r7, r1 30012b2c: e1a05002 mov r5, r2 size_t message_buffering_required = 0; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 30012b30: e5842044 str r2, [r4, #68] ; 0x44 the_message_queue->number_of_pending_messages = 0; 30012b34: e5840048 str r0, [r4, #72] ; 0x48 the_message_queue->maximum_message_size = maximum_message_size; 30012b38: e584304c str r3, [r4, #76] ; 0x4c /* * Check if allocated_message_size is aligned to uintptr-size boundary. * If not, it will increase allocated_message_size to multiplicity of pointer * size. */ if (allocated_message_size & (sizeof(uintptr_t) - 1)) { 30012b3c: 01a06003 moveq r6, r3 30012b40: 0a000003 beq 30012b54 <_CORE_message_queue_Initialize+0x3c> allocated_message_size += sizeof(uintptr_t); 30012b44: e2836004 add r6, r3, #4 <== NOT EXECUTED allocated_message_size &= ~(sizeof(uintptr_t) - 1); 30012b48: e3c66003 bic r6, r6, #3 <== NOT EXECUTED /* * Check for an overflow. It can occur while increasing allocated_message_size * to multiplicity of uintptr_t above. */ if (allocated_message_size < maximum_message_size) 30012b4c: e1560003 cmp r6, r3 <== NOT EXECUTED 30012b50: 38bd80f0 popcc {r4, r5, r6, r7, pc} <== NOT EXECUTED /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ if ( !size_t_mult32_with_overflow( 30012b54: e2866010 add r6, r6, #16 size_t a, size_t b, size_t *c ) { long long x = (long long)a*b; 30012b58: e0810695 umull r0, r1, r5, r6 if ( x > SIZE_MAX ) 30012b5c: e3e02000 mvn r2, #0 30012b60: e3a03000 mov r3, #0 30012b64: e1520000 cmp r2, r0 30012b68: e0d3c001 sbcs ip, r3, r1 */ if ( !size_t_mult32_with_overflow( (size_t) maximum_pending_messages, allocated_message_size + sizeof(CORE_message_queue_Buffer_control), &message_buffering_required ) ) return false; 30012b6c: b3a00000 movlt r0, #0 size_t *c ) { long long x = (long long)a*b; if ( x > SIZE_MAX ) 30012b70: b8bd80f0 poplt {r4, r5, r6, r7, pc} /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); 30012b74: eb000b1d bl 300157f0 <_Workspace_Allocate> if (the_message_queue->message_buffers == 0) 30012b78: e3500000 cmp r0, #0 /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); 30012b7c: e1a01000 mov r1, r0 return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 30012b80: e584005c str r0, [r4, #92] ; 0x5c _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 30012b84: 0a000013 beq 30012bd8 <_CORE_message_queue_Initialize+0xc0> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 30012b88: e2840060 add r0, r4, #96 ; 0x60 30012b8c: e1a02005 mov r2, r5 30012b90: e1a03006 mov r3, r6 30012b94: ebffffcf bl 30012ad8 <_Chain_Initialize> allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 30012b98: e5971000 ldr r1, [r7] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 30012b9c: e2843050 add r3, r4, #80 ; 0x50 30012ba0: e2842054 add r2, r4, #84 ; 0x54 head->next = tail; head->previous = NULL; tail->previous = head; 30012ba4: e5843058 str r3, [r4, #88] ; 0x58 30012ba8: e2413001 sub r3, r1, #1 30012bac: e2731000 rsbs r1, r3, #0 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 30012bb0: e5842050 str r2, [r4, #80] ; 0x50 head->previous = NULL; 30012bb4: e3a02000 mov r2, #0 30012bb8: e5842054 str r2, [r4, #84] ; 0x54 30012bbc: e1a00004 mov r0, r4 30012bc0: e0a11003 adc r1, r1, r3 30012bc4: e3a02080 mov r2, #128 ; 0x80 30012bc8: e3a03006 mov r3, #6 30012bcc: eb00090b bl 30015000 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 30012bd0: e3a00001 mov r0, #1 30012bd4: e8bd80f0 pop {r4, r5, r6, r7, pc} } 30012bd8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 30012cc0 <_CORE_message_queue_Submit>: ) { CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 30012cc0: e590304c ldr r3, [r0, #76] ; 0x4c #endif CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 30012cc4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 30012cc8: e1520003 cmp r2, r3 #endif CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 30012ccc: e1a05000 mov r5, r0 30012cd0: e1a0a001 mov sl, r1 30012cd4: e1a04002 mov r4, r2 30012cd8: e59d7020 ldr r7, [sp, #32] CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE; 30012cdc: 83a00001 movhi r0, #1 ) { CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 30012ce0: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc} } /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 30012ce4: e5958048 ldr r8, [r5, #72] ; 0x48 30012ce8: e3580000 cmp r8, #0 30012cec: 1a00000b bne 30012d20 <_CORE_message_queue_Submit+0x60> the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 30012cf0: eb0007c8 bl 30014c18 <_Thread_queue_Dequeue> if ( the_thread ) { 30012cf4: e2506000 subs r6, r0, #0 30012cf8: 0a000008 beq 30012d20 <_CORE_message_queue_Submit+0x60> const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 30012cfc: e596002c ldr r0, [r6, #44] ; 0x2c 30012d00: e1a0100a mov r1, sl 30012d04: e1a02004 mov r2, r4 30012d08: eb001a88 bl 30019730 _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 30012d0c: e5963028 ldr r3, [r6, #40] ; 0x28 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 30012d10: e1a00008 mov r0, r8 _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 30012d14: e5834000 str r4, [r3] the_thread->Wait.count = (uint32_t) submit_type; 30012d18: e5867024 str r7, [r6, #36] ; 0x24 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 30012d1c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} 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 *) 30012d20: e2850060 add r0, r5, #96 ; 0x60 30012d24: ebffff5e bl 30012aa4 <_Chain_Get> * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ the_message = _CORE_message_queue_Allocate_message_buffer( the_message_queue ); if ( the_message ) { 30012d28: e2506000 subs r6, r0, #0 30012d2c: 0a00000a beq 30012d5c <_CORE_message_queue_Submit+0x9c> const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 30012d30: e1a0100a mov r1, sl 30012d34: e1a02004 mov r2, r4 30012d38: e286000c add r0, r6, #12 30012d3c: eb001a7b bl 30019730 size ); the_message->Contents.size = size; _CORE_message_queue_Set_message_priority( the_message, submit_type ); _CORE_message_queue_Insert_message( 30012d40: e1a00005 mov r0, r5 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 30012d44: e5864008 str r4, [r6, #8] _CORE_message_queue_Set_message_priority( the_message, submit_type ); _CORE_message_queue_Insert_message( 30012d48: e1a01006 mov r1, r6 30012d4c: e1a02007 mov r2, r7 30012d50: eb001122 bl 300171e0 <_CORE_message_queue_Insert_message> the_message_queue, the_message, submit_type ); return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 30012d54: e3a00000 mov r0, #0 30012d58: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} } #if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND) return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY; 30012d5c: e3a00002 mov r0, #2 <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 30012d60: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED =============================================================================== 3000ada0 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 3000ada0: e92d40f0 push {r4, r5, r6, r7, lr} 3000ada4: e1a07003 mov r7, r3 * This routine returns true if thread dispatch indicates * that we are in a critical section. */ RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void) { if ( _Thread_Dispatch_disable_level == 0 ) 3000ada8: e59f30b4 ldr r3, [pc, #180] ; 3000ae64 <_CORE_mutex_Seize+0xc4> 3000adac: e1a04000 mov r4, r0 3000adb0: e5933000 ldr r3, [r3] 3000adb4: e1a05001 mov r5, r1 3000adb8: e3530000 cmp r3, #0 3000adbc: e20260ff and r6, r2, #255 ; 0xff 3000adc0: 0a000007 beq 3000ade4 <_CORE_mutex_Seize+0x44> 3000adc4: ea000023 b 3000ae58 <_CORE_mutex_Seize+0xb8> _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 3000adc8: e59f3098 ldr r3, [pc, #152] ; 3000ae68 <_CORE_mutex_Seize+0xc8> 3000adcc: e5933000 ldr r3, [r3] 3000add0: e3530001 cmp r3, #1 3000add4: 83a00000 movhi r0, #0 3000add8: 81a01000 movhi r1, r0 3000addc: 83a02012 movhi r2, #18 3000ade0: 8b0001c0 blhi 3000b4e8 <_Internal_error_Occurred> 3000ade4: e1a00004 mov r0, r4 3000ade8: e28d1014 add r1, sp, #20 3000adec: eb001074 bl 3000efc4 <_CORE_mutex_Seize_interrupt_trylock> 3000adf0: e3500000 cmp r0, #0 3000adf4: 08bd80f0 popeq {r4, r5, r6, r7, pc} 3000adf8: e3560000 cmp r6, #0 3000adfc: e59f3068 ldr r3, [pc, #104] ; 3000ae6c <_CORE_mutex_Seize+0xcc> 3000ae00: 1a000005 bne 3000ae1c <_CORE_mutex_Seize+0x7c> 3000ae04: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 3000ae08: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 3000ae0c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000ae10: e3a02001 mov r2, #1 <== NOT EXECUTED 3000ae14: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED 3000ae18: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED 3000ae1c: e5933008 ldr r3, [r3, #8] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 3000ae20: e3a02001 mov r2, #1 3000ae24: e5842030 str r2, [r4, #48] ; 0x30 3000ae28: e5834044 str r4, [r3, #68] ; 0x44 3000ae2c: e5835020 str r5, [r3, #32] * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000ae30: e59f302c ldr r3, [pc, #44] ; 3000ae64 <_CORE_mutex_Seize+0xc4> 3000ae34: e5932000 ldr r2, [r3] ++level; 3000ae38: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 3000ae3c: e5832000 str r2, [r3] 3000ae40: e59d3014 ldr r3, [sp, #20] 3000ae44: e129f003 msr CPSR_fc, r3 3000ae48: e1a00004 mov r0, r4 3000ae4c: e1a01007 mov r1, r7 3000ae50: ebffffb3 bl 3000ad24 <_CORE_mutex_Seize_interrupt_blocking> 3000ae54: e8bd80f0 pop {r4, r5, r6, r7, pc} 3000ae58: e3560000 cmp r6, #0 3000ae5c: 1affffd9 bne 3000adc8 <_CORE_mutex_Seize+0x28> 3000ae60: eaffffdf b 3000ade4 <_CORE_mutex_Seize+0x44> <== NOT EXECUTED =============================================================================== 3000efc4 <_CORE_mutex_Seize_interrupt_trylock>: #if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__) int _CORE_mutex_Seize_interrupt_trylock( CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { 3000efc4: e1a03000 mov r3, r0 { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 3000efc8: e59f2104 ldr r2, [pc, #260] ; 3000f0d4 <_CORE_mutex_Seize_interrupt_trylock+0x110> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 3000efcc: e593c050 ldr ip, [r3, #80] ; 0x50 Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 3000efd0: e3a00000 mov r0, #0 { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 3000efd4: e5922008 ldr r2, [r2, #8] executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 3000efd8: e15c0000 cmp ip, r0 3000efdc: e92d4010 push {r4, lr} Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 3000efe0: e5820034 str r0, [r2, #52] ; 0x34 if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 3000efe4: 0a00002a beq 3000f094 <_CORE_mutex_Seize_interrupt_trylock+0xd0> the_mutex->lock = CORE_MUTEX_LOCKED; 3000efe8: e5830050 str r0, [r3, #80] ; 0x50 the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 3000efec: e5920008 ldr r0, [r2, #8] 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; 3000eff0: e583205c str r2, [r3, #92] ; 0x5c the_mutex->holder_id = executing->Object.id; 3000eff4: e5830060 str r0, [r3, #96] ; 0x60 the_mutex->nest_count = 1; 3000eff8: e3a00001 mov r0, #1 3000effc: e5830054 str r0, [r3, #84] ; 0x54 */ RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 3000f000: e5930048 ldr r0, [r3, #72] ; 0x48 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 ) || 3000f004: e3500002 cmp r0, #2 3000f008: 0a000001 beq 3000f014 <_CORE_mutex_Seize_interrupt_trylock+0x50> 3000f00c: e3500003 cmp r0, #3 3000f010: 1a000029 bne 3000f0bc <_CORE_mutex_Seize_interrupt_trylock+0xf8> _Chain_Prepend_unprotected( &executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = executing->current_priority; #endif executing->resource_count++; 3000f014: e592c01c ldr ip, [r2, #28] } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 3000f018: e3500003 cmp r0, #3 _Chain_Prepend_unprotected( &executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = executing->current_priority; #endif executing->resource_count++; 3000f01c: e28c4001 add r4, ip, #1 3000f020: e582401c str r4, [r2, #28] } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 3000f024: 1a000024 bne 3000f0bc <_CORE_mutex_Seize_interrupt_trylock+0xf8> */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 3000f028: e593004c ldr r0, [r3, #76] ; 0x4c current = executing->current_priority; 3000f02c: e5924014 ldr r4, [r2, #20] if ( current == ceiling ) { 3000f030: e1540000 cmp r4, r0 3000f034: 0a000020 beq 3000f0bc <_CORE_mutex_Seize_interrupt_trylock+0xf8> _ISR_Enable( *level_p ); return 0; } if ( current > ceiling ) { 3000f038: 9a00000b bls 3000f06c <_CORE_mutex_Seize_interrupt_trylock+0xa8> * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000f03c: e59f2094 ldr r2, [pc, #148] ; 3000f0d8 <_CORE_mutex_Seize_interrupt_trylock+0x114><== NOT EXECUTED 3000f040: e5920000 ldr r0, [r2] <== NOT EXECUTED ++level; 3000f044: e2800001 add r0, r0, #1 <== NOT EXECUTED _Thread_Dispatch_disable_level = level; 3000f048: e5820000 str r0, [r2] <== NOT EXECUTED 3000f04c: e5912000 ldr r2, [r1] <== NOT EXECUTED 3000f050: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( *level_p ); _Thread_Change_priority( 3000f054: e3a02000 mov r2, #0 <== NOT EXECUTED 3000f058: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED 3000f05c: e593104c ldr r1, [r3, #76] ; 0x4c <== NOT EXECUTED 3000f060: ebfff4cc bl 3000c398 <_Thread_Change_priority> <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, false ); _Thread_Enable_dispatch(); 3000f064: ebfff5e4 bl 3000c7fc <_Thread_Enable_dispatch> <== NOT EXECUTED 3000f068: ea000015 b 3000f0c4 <_CORE_mutex_Seize_interrupt_trylock+0x100><== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 3000f06c: e3a00005 mov r0, #5 3000f070: e5820034 str r0, [r2, #52] ; 0x34 the_mutex->lock = CORE_MUTEX_UNLOCKED; 3000f074: e3a00001 mov r0, #1 3000f078: e5830050 str r0, [r3, #80] ; 0x50 the_mutex->nest_count = 0; /* undo locking above */ 3000f07c: e3a00000 mov r0, #0 3000f080: e5830054 str r0, [r3, #84] ; 0x54 executing->resource_count--; /* undo locking above */ 3000f084: e582c01c str ip, [r2, #28] 3000f088: e5913000 ldr r3, [r1] 3000f08c: e129f003 msr CPSR_fc, r3 3000f090: e8bd8010 pop {r4, pc} /* * 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 ) ) { 3000f094: e593005c ldr r0, [r3, #92] ; 0x5c 3000f098: e1500002 cmp r0, r2 /* * The mutex is not available and the caller must deal with the possibility * of blocking. */ return 1; 3000f09c: 13a00001 movne r0, #1 /* * 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 ) ) { 3000f0a0: 18bd8010 popne {r4, pc} switch ( the_mutex->Attributes.lock_nesting_behavior ) { 3000f0a4: e5932040 ldr r2, [r3, #64] ; 0x40 3000f0a8: e3520000 cmp r2, #0 3000f0ac: 1a000006 bne 3000f0cc <_CORE_mutex_Seize_interrupt_trylock+0x108> case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 3000f0b0: e5932054 ldr r2, [r3, #84] ; 0x54 3000f0b4: e2822001 add r2, r2, #1 3000f0b8: e5832054 str r2, [r3, #84] ; 0x54 3000f0bc: e5913000 ldr r3, [r1] 3000f0c0: e129f003 msr CPSR_fc, r3 _ISR_Enable( *level_p ); return 0; 3000f0c4: e3a00000 mov r0, #0 3000f0c8: e8bd8010 pop {r4, pc} /* * The mutex is not available and the caller must deal with the possibility * of blocking. */ return 1; 3000f0cc: e3a00001 mov r0, #1 return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 3000f0d0: e8bd8010 pop {r4, pc} =============================================================================== 3000ae70 <_CORE_mutex_Surrender>: #else Objects_Id id __attribute__((unused)), CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused)) #endif ) { 3000ae70: e92d4030 push {r4, r5, lr} 3000ae74: e1a04000 mov r4, r0 * 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 ) { 3000ae78: e5d43044 ldrb r3, [r4, #68] ; 0x44 ) { Thread_Control *the_thread; Thread_Control *holder; holder = the_mutex->holder; 3000ae7c: e590005c ldr r0, [r0, #92] ; 0x5c * 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 ) { 3000ae80: e3530000 cmp r3, #0 3000ae84: 0a000004 beq 3000ae9c <_CORE_mutex_Surrender+0x2c> RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 3000ae88: e59f30e8 ldr r3, [pc, #232] ; 3000af78 <_CORE_mutex_Surrender+0x108> if ( !_Thread_Is_executing( holder ) ) 3000ae8c: e5933008 ldr r3, [r3, #8] 3000ae90: e1500003 cmp r0, r3 return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; 3000ae94: 13a05002 movne r5, #2 * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) { if ( !_Thread_Is_executing( holder ) ) 3000ae98: 1a000034 bne 3000af70 <_CORE_mutex_Surrender+0x100> return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 3000ae9c: e5945054 ldr r5, [r4, #84] ; 0x54 3000aea0: e3550000 cmp r5, #0 3000aea4: 0a000031 beq 3000af70 <_CORE_mutex_Surrender+0x100> return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 3000aea8: e2455001 sub r5, r5, #1 if ( the_mutex->nest_count != 0 ) { 3000aeac: e3550000 cmp r5, #0 /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 3000aeb0: e5845054 str r5, [r4, #84] ; 0x54 /* Currently no API exercises this behavior. */ break; } #else /* must be CORE_MUTEX_NESTING_ACQUIRES or we wouldn't be here */ return CORE_MUTEX_STATUS_SUCCESSFUL; 3000aeb4: 13a05000 movne r5, #0 if ( !the_mutex->nest_count ) return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; if ( the_mutex->nest_count != 0 ) { 3000aeb8: 1a00002c bne 3000af70 <_CORE_mutex_Surrender+0x100> 3000aebc: e5943048 ldr r3, [r4, #72] ; 0x48 /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 3000aec0: e3530002 cmp r3, #2 3000aec4: 0a000001 beq 3000aed0 <_CORE_mutex_Surrender+0x60> 3000aec8: e3530003 cmp r3, #3 3000aecc: 1a000009 bne 3000aef8 <_CORE_mutex_Surrender+0x88> _CORE_mutex_Pop_priority( the_mutex, holder ); if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL ) return pop_status; holder->resource_count--; 3000aed0: e590301c ldr r3, [r0, #28] 3000aed4: e2433001 sub r3, r3, #1 /* * 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 ( holder->resource_count == 0 && 3000aed8: e3530000 cmp r3, #0 _CORE_mutex_Pop_priority( the_mutex, holder ); if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL ) return pop_status; holder->resource_count--; 3000aedc: e580301c str r3, [r0, #28] /* * 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 ( holder->resource_count == 0 && 3000aee0: 1a000004 bne 3000aef8 <_CORE_mutex_Surrender+0x88> holder->real_priority != holder->current_priority ) { 3000aee4: e5901018 ldr r1, [r0, #24] /* * 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 ( holder->resource_count == 0 && 3000aee8: e5903014 ldr r3, [r0, #20] 3000aeec: e1510003 cmp r1, r3 holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, true ); 3000aef0: 13a02001 movne r2, #1 3000aef4: 1b000527 blne 3000c398 <_Thread_Change_priority> } } the_mutex->holder = NULL; 3000aef8: e3a05000 mov r5, #0 3000aefc: e584505c str r5, [r4, #92] ; 0x5c the_mutex->holder_id = 0; 3000af00: e5845060 str r5, [r4, #96] ; 0x60 /* * 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 ) ) ) { 3000af04: e1a00004 mov r0, r4 3000af08: eb000703 bl 3000cb1c <_Thread_queue_Dequeue> 3000af0c: e3a02001 mov r2, #1 3000af10: e2503000 subs r3, r0, #0 } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 3000af14: 05842050 streq r2, [r4, #80] ; 0x50 return CORE_MUTEX_STATUS_SUCCESSFUL; 3000af18: 01a05003 moveq r5, r3 /* * 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 ) ) ) { 3000af1c: 0a000013 beq 3000af70 <_CORE_mutex_Surrender+0x100> } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 3000af20: e5931008 ldr r1, [r3, #8] the_mutex->nest_count = 1; 3000af24: e5842054 str r2, [r4, #84] ; 0x54 switch ( the_mutex->Attributes.discipline ) { 3000af28: e5942048 ldr r2, [r4, #72] ; 0x48 } else #endif { the_mutex->holder = the_thread; 3000af2c: e584305c str r3, [r4, #92] ; 0x5c the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 3000af30: e3520002 cmp r2, #2 case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; 3000af34: 0593201c ldreq r2, [r3, #28] } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 3000af38: e5841060 str r1, [r4, #96] ; 0x60 case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; 3000af3c: 02822001 addeq r2, r2, #1 3000af40: 0583201c streq r2, [r3, #28] the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 3000af44: 0a000009 beq 3000af70 <_CORE_mutex_Surrender+0x100> 3000af48: e3520003 cmp r2, #3 <== NOT EXECUTED 3000af4c: 1a000007 bne 3000af70 <_CORE_mutex_Surrender+0x100> <== NOT EXECUTED _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; 3000af50: e593201c ldr r2, [r3, #28] <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 3000af54: e594104c ldr r1, [r4, #76] ; 0x4c <== NOT EXECUTED _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: _CORE_mutex_Push_priority( the_mutex, the_thread ); the_thread->resource_count++; 3000af58: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000af5c: e583201c str r2, [r3, #28] <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 3000af60: e5933014 ldr r3, [r3, #20] <== NOT EXECUTED 3000af64: e1510003 cmp r1, r3 <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 3000af68: 31a02005 movcc r2, r5 <== NOT EXECUTED 3000af6c: 3b000509 blcc 3000c398 <_Thread_Change_priority> <== NOT EXECUTED } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 3000af70: e1a00005 mov r0, r5 3000af74: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000b32c <_Chain_Append_with_empty_check>: bool _Chain_Append_with_empty_check( Chain_Control *chain, Chain_Node *node ) { 3000b32c: e92d4010 push {r4, lr} <== NOT EXECUTED 3000b330: e1a03000 mov r3, r0 <== NOT EXECUTED 3000b334: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000b338: e3842080 orr r2, r4, #128 ; 0x80 <== NOT EXECUTED 3000b33c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 3000b340: e280c004 add ip, r0, #4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) 3000b344: e5900000 ldr r0, [r0] <== NOT EXECUTED ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; the_node->next = tail; 3000b348: e581c000 str ip, [r1] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) 3000b34c: e06c2000 rsb r2, ip, r0 <== NOT EXECUTED 3000b350: e2720000 rsbs r0, r2, #0 <== NOT EXECUTED 3000b354: e0a00002 adc r0, r0, r2 <== NOT EXECUTED Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 3000b358: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED the_node->next = tail; tail->previous = the_node; 3000b35c: e5831008 str r1, [r3, #8] <== NOT EXECUTED old_last->next = the_node; 3000b360: e5821000 str r1, [r2] <== NOT EXECUTED the_node->previous = old_last; 3000b364: e5812004 str r2, [r1, #4] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000b368: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED _ISR_Disable( level ); was_empty = _Chain_Append_with_empty_check_unprotected( chain, node ); _ISR_Enable( level ); return was_empty; } 3000b36c: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000b39c <_Chain_Get_with_empty_check>: bool _Chain_Get_with_empty_check( Chain_Control *chain, Chain_Node **node ) { 3000b39c: e92d4010 push {r4, lr} <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000b3a0: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000b3a4: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000b3a8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED ) { bool is_empty_now = true; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_first = head->next; 3000b3ac: e5902000 ldr r2, [r0] <== NOT EXECUTED Chain_Node **the_node ) { bool is_empty_now = true; Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 3000b3b0: e280c004 add ip, r0, #4 <== NOT EXECUTED Chain_Node *old_first = head->next; if ( old_first != tail ) { 3000b3b4: e152000c cmp r2, ip <== NOT EXECUTED *the_node = old_first; is_empty_now = new_first == tail; } else *the_node = NULL; 3000b3b8: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000b3bc: 05813000 streq r3, [r1] <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Get_with_empty_check_unprotected( Chain_Control *the_chain, Chain_Node **the_node ) { bool is_empty_now = true; 3000b3c0: 03a00001 moveq r0, #1 <== NOT EXECUTED Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_first = head->next; if ( old_first != tail ) { 3000b3c4: 0a000006 beq 3000b3e4 <_Chain_Get_with_empty_check+0x48> <== NOT EXECUTED Chain_Node *new_first = old_first->next; 3000b3c8: e5923000 ldr r3, [r2] <== NOT EXECUTED head->next = new_first; 3000b3cc: e5803000 str r3, [r0] <== NOT EXECUTED new_first->previous = head; 3000b3d0: e5830004 str r0, [r3, #4] <== NOT EXECUTED *the_node = old_first; is_empty_now = new_first == tail; 3000b3d4: e06c3003 rsb r3, ip, r3 <== NOT EXECUTED 3000b3d8: e2730000 rsbs r0, r3, #0 <== NOT EXECUTED Chain_Node *new_first = old_first->next; head->next = new_first; new_first->previous = head; *the_node = old_first; 3000b3dc: e5812000 str r2, [r1] <== NOT EXECUTED is_empty_now = new_first == tail; 3000b3e0: e0a00003 adc r0, r0, r3 <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000b3e4: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED _ISR_Disable( level ); is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node ); _ISR_Enable( level ); return is_empty_now; } 3000b3e8: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000b420 <_Chain_Insert>: uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000b420: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000b424: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000b428: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 3000b42c: e5903000 ldr r3, [r0] <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 3000b430: e5810004 str r0, [r1, #4] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; 3000b434: e5801000 str r1, [r0] <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 3000b438: e5831004 str r1, [r3, #4] <== 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; 3000b43c: e5813000 str r3, [r1] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000b440: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); _Chain_Insert_unprotected( after_node, node ); _ISR_Enable( level ); } 3000b444: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b488 <_Chain_Prepend_with_empty_check>: uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000b488: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000b48c: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000b490: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3000b494: e5903000 ldr r3, [r0] <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 3000b498: e5810004 str r0, [r1, #4] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; 3000b49c: e4801004 str r1, [r0], #4 <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 3000b4a0: e5831004 str r1, [r3, #4] <== 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; 3000b4a4: e5813000 str r3, [r1] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000b4a8: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED _ISR_Disable( level ); was_empty = _Chain_Prepend_with_empty_check_unprotected( chain, node ); _ISR_Enable( level ); return was_empty; } 3000b4ac: e0603003 rsb r3, r0, r3 <== NOT EXECUTED 3000b4b0: e2730000 rsbs r0, r3, #0 <== NOT EXECUTED 3000b4b4: e0a00003 adc r0, r0, r3 <== NOT EXECUTED 3000b4b8: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 30009cb4 <_Event_Seize>: Thread_Control *executing, Event_Control *event, Thread_blocking_operation_States *sync_state, States_Control wait_state ) { 30009cb4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} 30009cb8: e59d401c ldr r4, [sp, #28] rtems_event_set seized_events; rtems_event_set pending_events; ISR_Level level; Thread_blocking_operation_States current_sync_state; executing->Wait.return_code = RTEMS_SUCCESSFUL; 30009cbc: e3a0c000 mov ip, #0 Thread_Control *executing, Event_Control *event, Thread_blocking_operation_States *sync_state, States_Control wait_state ) { 30009cc0: e59da020 ldr sl, [sp, #32] 30009cc4: e59d5024 ldr r5, [sp, #36] ; 0x24 30009cc8: e59d6028 ldr r6, [sp, #40] ; 0x28 rtems_event_set seized_events; rtems_event_set pending_events; ISR_Level level; Thread_blocking_operation_States current_sync_state; executing->Wait.return_code = RTEMS_SUCCESSFUL; 30009ccc: e584c034 str ip, [r4, #52] ; 0x34 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 30009cd0: e10f7000 mrs r7, CPSR 30009cd4: e387c080 orr ip, r7, #128 ; 0x80 30009cd8: e129f00c msr CPSR_fc, ip _ISR_Disable( level ); pending_events = event->pending_events; 30009cdc: e59a8000 ldr r8, [sl] seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 30009ce0: e010c008 ands ip, r0, r8 30009ce4: 0a000007 beq 30009d08 <_Event_Seize+0x54> 30009ce8: e15c0000 cmp ip, r0 30009cec: 0a000001 beq 30009cf8 <_Event_Seize+0x44> (seized_events == event_in || _Options_Is_any( option_set )) ) { 30009cf0: e3110002 tst r1, #2 <== NOT EXECUTED 30009cf4: 0a000003 beq 30009d08 <_Event_Seize+0x54> <== NOT EXECUTED RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear( rtems_event_set the_event_set, rtems_event_set the_mask ) { return ( the_event_set & ~(the_mask) ); 30009cf8: e1c8800c bic r8, r8, ip event->pending_events = 30009cfc: e58a8000 str r8, [sl] static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 30009d00: e129f007 msr CPSR_fc, r7 30009d04: ea000004 b 30009d1c <_Event_Seize+0x68> _ISR_Enable( level ); *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 30009d08: e3110001 tst r1, #1 30009d0c: 0a000004 beq 30009d24 <_Event_Seize+0x70> 30009d10: e129f007 msr CPSR_fc, r7 _ISR_Enable( level ); executing->Wait.return_code = RTEMS_UNSATISFIED; 30009d14: e3a0200d mov r2, #13 30009d18: e5842034 str r2, [r4, #52] ; 0x34 *event_out = seized_events; 30009d1c: e583c000 str ip, [r3] return; 30009d20: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = option_set; executing->Wait.count = event_in; executing->Wait.return_argument = event_out; 30009d24: e5843028 str r3, [r4, #40] ; 0x28 *sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 30009d28: e3a03001 mov r3, #1 * set properly when we are marked as in the event critical section. * * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = option_set; 30009d2c: e5841030 str r1, [r4, #48] ; 0x30 executing->Wait.count = event_in; 30009d30: e5840024 str r0, [r4, #36] ; 0x24 executing->Wait.return_argument = event_out; *sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 30009d34: e5853000 str r3, [r5] 30009d38: e129f007 msr CPSR_fc, r7 _ISR_Enable( level ); if ( ticks ) { 30009d3c: e3520000 cmp r2, #0 30009d40: 0a00000a beq 30009d70 <_Event_Seize+0xbc> Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 30009d44: e3a01000 mov r1, #0 _Watchdog_Initialize( 30009d48: e5943008 ldr r3, [r4, #8] 30009d4c: e5841050 str r1, [r4, #80] ; 0x50 the_watchdog->routine = routine; 30009d50: e59f1058 ldr r1, [pc, #88] ; 30009db0 <_Event_Seize+0xfc> the_watchdog->id = id; 30009d54: e5843068 str r3, [r4, #104] ; 0x68 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 30009d58: e5841064 str r1, [r4, #100] ; 0x64 the_watchdog->id = id; the_watchdog->user_data = user_data; 30009d5c: e584506c str r5, [r4, #108] ; 0x6c Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 30009d60: e5842054 str r2, [r4, #84] ; 0x54 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 30009d64: e59f0048 ldr r0, [pc, #72] ; 30009db4 <_Event_Seize+0x100> 30009d68: e2841048 add r1, r4, #72 ; 0x48 30009d6c: eb000d7f bl 3000d370 <_Watchdog_Insert> sync_state ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, wait_state ); 30009d70: e1a00004 mov r0, r4 30009d74: e1a01006 mov r1, r6 30009d78: eb000ca5 bl 3000d014 <_Thread_Set_state> uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 30009d7c: e10f2000 mrs r2, CPSR 30009d80: e3823080 orr r3, r2, #128 ; 0x80 30009d84: e129f003 msr CPSR_fc, r3 _ISR_Disable( level ); current_sync_state = *sync_state; 30009d88: e5950000 ldr r0, [r5] *sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 30009d8c: e3a03000 mov r3, #0 if ( current_sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 30009d90: e3500001 cmp r0, #1 _Thread_Set_state( executing, wait_state ); _ISR_Disable( level ); current_sync_state = *sync_state; *sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 30009d94: e5853000 str r3, [r5] if ( current_sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 30009d98: 1a000001 bne 30009da4 <_Event_Seize+0xf0> static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 30009d9c: e129f002 msr CPSR_fc, r2 30009da0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Entering with interrupts disabled and returning with interrupts * enabled! */ _Thread_blocking_operation_Cancel( current_sync_state, executing, level ); 30009da4: e1a01004 mov r1, r4 <== NOT EXECUTED } 30009da8: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Entering with interrupts disabled and returning with interrupts * enabled! */ _Thread_blocking_operation_Cancel( current_sync_state, executing, level ); 30009dac: ea000966 b 3000c34c <_Thread_blocking_operation_Cancel> <== NOT EXECUTED =============================================================================== 30009e04 <_Event_Surrender>: rtems_event_set event_in, Event_Control *event, Thread_blocking_operation_States *sync_state, States_Control wait_state ) { 30009e04: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} 30009e08: e59d801c ldr r8, [sp, #28] rtems_event_set pending_events; rtems_event_set event_condition; rtems_event_set seized_events; rtems_option option_set; option_set = the_thread->Wait.option; 30009e0c: e5906030 ldr r6, [r0, #48] ; 0x30 rtems_event_set event_in, Event_Control *event, Thread_blocking_operation_States *sync_state, States_Control wait_state ) { 30009e10: e1a04000 mov r4, r0 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 30009e14: e10f0000 mrs r0, CPSR 30009e18: e380c080 orr ip, r0, #128 ; 0x80 30009e1c: e129f00c msr CPSR_fc, ip RTEMS_INLINE_ROUTINE void _Event_sets_Post( rtems_event_set the_new_events, rtems_event_set *the_event_set ) { *the_event_set |= the_new_events; 30009e20: e592c000 ldr ip, [r2] 30009e24: e181100c orr r1, r1, ip 30009e28: e5821000 str r1, [r2] option_set = the_thread->Wait.option; _ISR_Disable( level ); _Event_sets_Post( event_in, &event->pending_events ); pending_events = event->pending_events; event_condition = the_thread->Wait.count; 30009e2c: e5945024 ldr r5, [r4, #36] ; 0x24 seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 30009e30: e011c005 ands ip, r1, r5 30009e34: 0a000035 beq 30009f10 <_Event_Surrender+0x10c> /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 30009e38: e59f70d8 ldr r7, [pc, #216] ; 30009f18 <_Event_Surrender+0x114> 30009e3c: e597a000 ldr sl, [r7] 30009e40: e35a0000 cmp sl, #0 30009e44: 0a000013 beq 30009e98 <_Event_Surrender+0x94> 30009e48: e5977008 ldr r7, [r7, #8] <== NOT EXECUTED 30009e4c: e1540007 cmp r4, r7 <== NOT EXECUTED 30009e50: 1a000010 bne 30009e98 <_Event_Surrender+0x94> <== NOT EXECUTED _Thread_Is_executing( the_thread ) && ((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 30009e54: e5937000 ldr r7, [r3] <== NOT EXECUTED 30009e58: e2477001 sub r7, r7, #1 <== NOT EXECUTED /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) && 30009e5c: e3570001 cmp r7, #1 <== NOT EXECUTED 30009e60: 8a00000c bhi 30009e98 <_Event_Surrender+0x94> <== NOT EXECUTED ((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 30009e64: e15c0005 cmp ip, r5 <== NOT EXECUTED 30009e68: 0a000001 beq 30009e74 <_Event_Surrender+0x70> <== NOT EXECUTED 30009e6c: e3160002 tst r6, #2 <== NOT EXECUTED 30009e70: 0a000026 beq 30009f10 <_Event_Surrender+0x10c> <== NOT EXECUTED RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear( rtems_event_set the_event_set, rtems_event_set the_mask ) { return ( the_event_set & ~(the_mask) ); 30009e74: e1c1100c bic r1, r1, ip <== NOT EXECUTED event->pending_events = _Event_sets_Clear( 30009e78: e5821000 str r1, [r2] <== NOT EXECUTED pending_events, seized_events ); the_thread->Wait.count = 0; 30009e7c: e3a02000 mov r2, #0 <== NOT EXECUTED 30009e80: e5842024 str r2, [r4, #36] ; 0x24 <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 30009e84: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED 30009e88: e582c000 str ip, [r2] <== NOT EXECUTED *sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 30009e8c: e3a02003 mov r2, #3 <== NOT EXECUTED 30009e90: e5832000 str r2, [r3] <== NOT EXECUTED 30009e94: ea00001d b 30009f10 <_Event_Surrender+0x10c> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _States_Are_set ( States_Control the_states, States_Control mask ) { return ( (the_states & mask) != STATES_READY); 30009e98: e5943010 ldr r3, [r4, #16] } /* * Otherwise, this is a normal send to another thread */ if ( _States_Are_set( the_thread->current_state, wait_state ) ) { 30009e9c: e1180003 tst r8, r3 30009ea0: 0a00001a beq 30009f10 <_Event_Surrender+0x10c> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 30009ea4: e15c0005 cmp ip, r5 30009ea8: 0a000001 beq 30009eb4 <_Event_Surrender+0xb0> 30009eac: e3160002 tst r6, #2 <== NOT EXECUTED 30009eb0: 0a000016 beq 30009f10 <_Event_Surrender+0x10c> <== NOT EXECUTED 30009eb4: e1c1100c bic r1, r1, ip event->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 30009eb8: e3a03000 mov r3, #0 /* * Otherwise, this is a normal send to another thread */ if ( _States_Are_set( the_thread->current_state, wait_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { event->pending_events = _Event_sets_Clear( 30009ebc: e5821000 str r1, [r2] pending_events, seized_events ); the_thread->Wait.count = 0; 30009ec0: e5843024 str r3, [r4, #36] ; 0x24 *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 30009ec4: e5943028 ldr r3, [r4, #40] ; 0x28 30009ec8: e583c000 str ip, [r3] static inline void arm_interrupt_flash( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 30009ecc: e10f3000 mrs r3, CPSR 30009ed0: e129f000 msr CPSR_fc, r0 30009ed4: e129f003 msr CPSR_fc, r3 _ISR_Flash( level ); if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 30009ed8: e5943050 ldr r3, [r4, #80] ; 0x50 30009edc: e3530002 cmp r3, #2 30009ee0: 0a000001 beq 30009eec <_Event_Surrender+0xe8> static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 30009ee4: e129f000 msr CPSR_fc, r0 30009ee8: ea000004 b 30009f00 <_Event_Surrender+0xfc> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 30009eec: e3a03003 mov r3, #3 30009ef0: e5843050 str r3, [r4, #80] ; 0x50 30009ef4: e129f000 msr CPSR_fc, r0 _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); 30009ef8: e2840048 add r0, r4, #72 ; 0x48 30009efc: eb000d72 bl 3000d4cc <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 30009f00: e59f1014 ldr r1, [pc, #20] ; 30009f1c <_Event_Surrender+0x118> 30009f04: e1a00004 mov r0, r4 } return; } } _ISR_Enable( level ); } 30009f08: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} 30009f0c: ea00095f b 3000c490 <_Thread_Clear_state> 30009f10: e129f000 msr CPSR_fc, r0 30009f14: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} =============================================================================== 30009f20 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *arg ) { 30009f20: e92d4011 push {r0, r4, lr} <== NOT EXECUTED 30009f24: e1a04001 mov r4, r1 <== NOT EXECUTED ISR_Level level; Thread_blocking_operation_States *sync_state; sync_state = arg; the_thread = _Thread_Get( id, &location ); 30009f28: e1a0100d mov r1, sp <== NOT EXECUTED 30009f2c: eb000a3a bl 3000c81c <_Thread_Get> <== NOT EXECUTED switch ( location ) { 30009f30: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30009f34: e3530000 cmp r3, #0 <== NOT EXECUTED 30009f38: 1a000014 bne 30009f90 <_Event_Timeout+0x70> <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 30009f3c: e10f2000 mrs r2, CPSR <== NOT EXECUTED 30009f40: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 30009f44: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 30009f48: e5803024 str r3, [r0, #36] ; 0x24 <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 30009f4c: e59f3040 ldr r3, [pc, #64] ; 30009f94 <_Event_Timeout+0x74><== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) { 30009f50: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30009f54: e1500003 cmp r0, r3 <== NOT EXECUTED 30009f58: 1a000003 bne 30009f6c <_Event_Timeout+0x4c> <== NOT EXECUTED if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 30009f5c: e5943000 ldr r3, [r4] <== NOT EXECUTED 30009f60: e3530001 cmp r3, #1 <== NOT EXECUTED *sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 30009f64: 03a03002 moveq r3, #2 <== NOT EXECUTED 30009f68: 05843000 streq r3, [r4] <== NOT EXECUTED } the_thread->Wait.return_code = RTEMS_TIMEOUT; 30009f6c: e3a03006 mov r3, #6 <== NOT EXECUTED 30009f70: e5803034 str r3, [r0, #52] ; 0x34 <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 30009f74: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 30009f78: e59f1018 ldr r1, [pc, #24] ; 30009f98 <_Event_Timeout+0x78><== NOT EXECUTED 30009f7c: eb000943 bl 3000c490 <_Thread_Clear_state> <== NOT EXECUTED * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 30009f80: e59f3014 ldr r3, [pc, #20] ; 30009f9c <_Event_Timeout+0x7c><== NOT EXECUTED 30009f84: e5932000 ldr r2, [r3] <== NOT EXECUTED --level; 30009f88: e2422001 sub r2, r2, #1 <== NOT EXECUTED _Thread_Dispatch_disable_level = level; 30009f8c: e5832000 str r2, [r3] <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 30009f90: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED =============================================================================== 3000f0dc <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 3000f0dc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} 3000f0e0: e1a08002 mov r8, r2 Heap_Statistics *const stats = &heap->stats; uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE - HEAP_ALLOC_BONUS; uintptr_t const page_size = heap->page_size; 3000f0e4: e5902010 ldr r2, [r0, #16] Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 3000f0e8: e24dd01c sub sp, sp, #28 3000f0ec: e1a0b003 mov fp, r3 Heap_Block *block = NULL; uintptr_t alloc_begin = 0; uint32_t search_count = 0; bool search_again = false; if ( block_size_floor < alloc_size ) { 3000f0f0: e2913004 adds r3, r1, #4 Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 3000f0f4: e1a05000 mov r5, r0 3000f0f8: e1a06001 mov r6, r1 Heap_Statistics *const stats = &heap->stats; uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE - HEAP_ALLOC_BONUS; uintptr_t const page_size = heap->page_size; 3000f0fc: e58d2000 str r2, [sp] Heap_Block *block = NULL; uintptr_t alloc_begin = 0; uint32_t search_count = 0; bool search_again = false; if ( block_size_floor < alloc_size ) { 3000f100: e58d300c str r3, [sp, #12] 3000f104: 2a00006a bcs 3000f2b4 <_Heap_Allocate_aligned_with_boundary+0x1d8> /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 3000f108: e35b0000 cmp fp, #0 3000f10c: 0a000003 beq 3000f120 <_Heap_Allocate_aligned_with_boundary+0x44> if ( boundary < alloc_size ) { 3000f110: e15b0001 cmp fp, r1 <== NOT EXECUTED 3000f114: 3a000066 bcc 3000f2b4 <_Heap_Allocate_aligned_with_boundary+0x1d8><== NOT EXECUTED return NULL; } if ( alignment == 0 ) { alignment = page_size; 3000f118: e3580000 cmp r8, #0 <== NOT EXECUTED 3000f11c: 01a08002 moveq r8, r2 <== NOT EXECUTED uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 3000f120: e59d2000 ldr r2, [sp] + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; 3000f124: e2663004 rsb r3, r6, #4 uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 3000f128: e2822007 add r2, r2, #7 return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 3000f12c: e595a008 ldr sl, [r5, #8] do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 3000f130: e3a07000 mov r7, #0 uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 3000f134: e58d2014 str r2, [sp, #20] + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; 3000f138: e58d3018 str r3, [sp, #24] do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 3000f13c: ea000048 b 3000f264 <_Heap_Allocate_aligned_with_boundary+0x188> /* * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag * field. Thus the value is about one unit larger than the real block * size. The greater than operator takes this into account. */ if ( block->size_and_flag > block_size_floor ) { 3000f140: e59a4004 ldr r4, [sl, #4] 3000f144: e59d200c ldr r2, [sp, #12] 3000f148: e1540002 cmp r4, r2 3000f14c: 9a00003f bls 3000f250 <_Heap_Allocate_aligned_with_boundary+0x174> if ( alignment == 0 ) { 3000f150: e3580000 cmp r8, #0 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 3000f154: 028a4008 addeq r4, sl, #8 3000f158: 0a00003d beq 3000f254 <_Heap_Allocate_aligned_with_boundary+0x178> 3000f15c: e28a2008 add r2, sl, #8 uintptr_t alignment, uintptr_t boundary ) { uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; 3000f160: e5953014 ldr r3, [r5, #20] 3000f164: e58d2008 str r2, [sp, #8] uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size + HEAP_BLOCK_HEADER_SIZE + page_size - 1; 3000f168: e59d2014 ldr r2, [sp, #20] uintptr_t alignment, uintptr_t boundary ) { uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; 3000f16c: e58d3004 str r3, [sp, #4] uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size + HEAP_BLOCK_HEADER_SIZE + page_size - 1; 3000f170: e0639002 rsb r9, r3, r2 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000f174: e3c44001 bic r4, r4, #1 uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; uintptr_t alloc_begin = alloc_end - alloc_size; 3000f178: e59d3018 ldr r3, [sp, #24] uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const block_end = block_begin + block_size; 3000f17c: e08a4004 add r4, sl, r4 uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_begin_ceiling = block_end - min_block_size 3000f180: e0899004 add r9, r9, r4 + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; uintptr_t alloc_begin = alloc_end - alloc_size; 3000f184: e0834004 add r4, r3, r4 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 3000f188: e1a00004 mov r0, r4 3000f18c: e1a01008 mov r1, r8 3000f190: eb002ae1 bl 30019d1c <__umodsi3> 3000f194: e0604004 rsb r4, r0, r4 alloc_begin = _Heap_Align_down( alloc_begin, alignment ); /* Ensure that the we have a valid new block at the end */ if ( alloc_begin > alloc_begin_ceiling ) { 3000f198: e1540009 cmp r4, r9 3000f19c: 9a000003 bls 3000f1b0 <_Heap_Allocate_aligned_with_boundary+0xd4> 3000f1a0: e1a00009 mov r0, r9 3000f1a4: e1a01008 mov r1, r8 3000f1a8: eb002adb bl 30019d1c <__umodsi3> 3000f1ac: e0604009 rsb r4, r0, r9 } alloc_end = alloc_begin + alloc_size; /* Ensure boundary constaint */ if ( boundary != 0 ) { 3000f1b0: e35b0000 cmp fp, #0 3000f1b4: 0a000014 beq 3000f20c <_Heap_Allocate_aligned_with_boundary+0x130> uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; 3000f1b8: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED /* Ensure that the we have a valid new block at the end */ if ( alloc_begin > alloc_begin_ceiling ) { alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment ); } alloc_end = alloc_begin + alloc_size; 3000f1bc: e0849006 add r9, r4, r6 <== NOT EXECUTED /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; 3000f1c0: e0822006 add r2, r2, r6 <== NOT EXECUTED 3000f1c4: e58d2010 str r2, [sp, #16] <== NOT EXECUTED 3000f1c8: ea000008 b 3000f1f0 <_Heap_Allocate_aligned_with_boundary+0x114><== NOT EXECUTED uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { if ( boundary_line < boundary_floor ) { 3000f1cc: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000f1d0: e1500003 cmp r0, r3 <== NOT EXECUTED 3000f1d4: 3a00001d bcc 3000f250 <_Heap_Allocate_aligned_with_boundary+0x174><== NOT EXECUTED return 0; } alloc_begin = boundary_line - alloc_size; 3000f1d8: e0664000 rsb r4, r6, r0 <== NOT EXECUTED 3000f1dc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f1e0: e1a01008 mov r1, r8 <== NOT EXECUTED 3000f1e4: eb002acc bl 30019d1c <__umodsi3> <== NOT EXECUTED 3000f1e8: e0604004 rsb r4, r0, r4 <== NOT EXECUTED alloc_begin = _Heap_Align_down( alloc_begin, alignment ); alloc_end = alloc_begin + alloc_size; 3000f1ec: e0849006 add r9, r4, r6 <== NOT EXECUTED 3000f1f0: e1a00009 mov r0, r9 <== NOT EXECUTED 3000f1f4: e1a0100b mov r1, fp <== NOT EXECUTED 3000f1f8: eb002ac7 bl 30019d1c <__umodsi3> <== NOT EXECUTED 3000f1fc: e0600009 rsb r0, r0, r9 <== NOT EXECUTED /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary ); while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 3000f200: e1500009 cmp r0, r9 <== NOT EXECUTED 3000f204: 31540000 cmpcc r4, r0 <== NOT EXECUTED 3000f208: 3affffef bcc 3000f1cc <_Heap_Allocate_aligned_with_boundary+0xf0><== NOT EXECUTED boundary_line = _Heap_Align_down( alloc_end, boundary ); } } /* Ensure that the we have a valid new block at the beginning */ if ( alloc_begin >= alloc_begin_floor ) { 3000f20c: e59d2008 ldr r2, [sp, #8] 3000f210: e1540002 cmp r4, r2 3000f214: 3a00000d bcc 3000f250 <_Heap_Allocate_aligned_with_boundary+0x174> 3000f218: e1a00004 mov r0, r4 3000f21c: e59d1000 ldr r1, [sp] 3000f220: eb002abd bl 30019d1c <__umodsi3> 3000f224: e3e09007 mvn r9, #7 3000f228: e06a9009 rsb r9, sl, r9 uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 3000f22c: e0899004 add r9, r9, r4 if ( free_size >= min_block_size || free_size == 0 ) { return alloc_begin; } } return 0; 3000f230: e59d2004 ldr r2, [sp, #4] if ( alloc_begin >= alloc_begin_floor ) { uintptr_t const alloc_block_begin = (uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size ); uintptr_t const free_size = alloc_block_begin - block_begin; if ( free_size >= min_block_size || free_size == 0 ) { 3000f234: e0603009 rsb r3, r0, r9 return alloc_begin; } } return 0; 3000f238: e1590000 cmp r9, r0 3000f23c: 11530002 cmpne r3, r2 3000f240: 33a09000 movcc r9, #0 3000f244: 23a09001 movcs r9, #1 3000f248: 31a04009 movcc r4, r9 3000f24c: ea000000 b 3000f254 <_Heap_Allocate_aligned_with_boundary+0x178> /* * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag * field. Thus the value is about one unit larger than the real block * size. The greater than operator takes this into account. */ if ( block->size_and_flag > block_size_floor ) { 3000f250: e3a04000 mov r4, #0 } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 3000f254: e3540000 cmp r4, #0 ); } } /* Statistics */ ++search_count; 3000f258: e2877001 add r7, r7, #1 if ( alloc_begin != 0 ) { 3000f25c: 1a000004 bne 3000f274 <_Heap_Allocate_aligned_with_boundary+0x198> break; } block = block->next; 3000f260: e59aa008 ldr sl, [sl, #8] do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 3000f264: e15a0005 cmp sl, r5 3000f268: 1affffb4 bne 3000f140 <_Heap_Allocate_aligned_with_boundary+0x64> 3000f26c: e3a04000 mov r4, #0 3000f270: ea00000a b 3000f2a0 <_Heap_Allocate_aligned_with_boundary+0x1c4> search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin ); } while ( search_again ); if ( alloc_begin != 0 ) { /* Statistics */ ++stats->allocs; 3000f274: e5953048 ldr r3, [r5, #72] ; 0x48 stats->searches += search_count; block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 3000f278: e1a00005 mov r0, r5 search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin ); } while ( search_again ); if ( alloc_begin != 0 ) { /* Statistics */ ++stats->allocs; 3000f27c: e2833001 add r3, r3, #1 3000f280: e5853048 str r3, [r5, #72] ; 0x48 stats->searches += search_count; 3000f284: e595304c ldr r3, [r5, #76] ; 0x4c block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 3000f288: e1a0100a mov r1, sl } while ( search_again ); if ( alloc_begin != 0 ) { /* Statistics */ ++stats->allocs; stats->searches += search_count; 3000f28c: e0833007 add r3, r3, r7 3000f290: e585304c str r3, [r5, #76] ; 0x4c block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 3000f294: e1a02004 mov r2, r4 3000f298: e1a03006 mov r3, r6 3000f29c: ebfff046 bl 3000b3bc <_Heap_Block_allocate> boundary ); } /* Statistics */ if ( stats->max_search < search_count ) { 3000f2a0: e5953044 ldr r3, [r5, #68] ; 0x44 stats->max_search = search_count; } return (void *) alloc_begin; 3000f2a4: e1a00004 mov r0, r4 boundary ); } /* Statistics */ if ( stats->max_search < search_count ) { 3000f2a8: e1530007 cmp r3, r7 stats->max_search = search_count; 3000f2ac: 35857044 strcc r7, [r5, #68] ; 0x44 } return (void *) alloc_begin; 3000f2b0: ea000000 b 3000f2b8 <_Heap_Allocate_aligned_with_boundary+0x1dc> return NULL; } if ( boundary != 0 ) { if ( boundary < alloc_size ) { return NULL; 3000f2b4: e3a00000 mov r0, #0 if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 3000f2b8: e28dd01c add sp, sp, #28 3000f2bc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} =============================================================================== 3000b3bc <_Heap_Block_allocate>: Heap_Control *heap, Heap_Block *block, uintptr_t alloc_begin, uintptr_t alloc_size ) { 3000b3bc: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000b3c0: e591a004 ldr sl, [r1, #4] RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 3000b3c4: e2426008 sub r6, r2, #8 3000b3c8: e1a04001 mov r4, r1 3000b3cc: e1a07003 mov r7, r3 Heap_Statistics *const stats = &heap->stats; uintptr_t const alloc_area_begin = _Heap_Alloc_area_of_block( block ); uintptr_t const alloc_area_offset = alloc_begin - alloc_area_begin; 3000b3d0: e0613006 rsb r3, r1, r6 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000b3d4: e3ca1001 bic r1, sl, #1 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 3000b3d8: e0849001 add r9, r4, r1 Heap_Control *heap, Heap_Block *block, uintptr_t alloc_begin, uintptr_t alloc_size ) { 3000b3dc: e1a05000 mov r5, r0 block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000b3e0: e5990004 ldr r0, [r9, #4] Heap_Block *free_list_anchor = NULL; _HAssert( alloc_area_begin <= alloc_begin ); if ( _Heap_Is_free( block ) ) { 3000b3e4: e3100001 tst r0, #1 /* Statistics */ --stats->free_blocks; ++stats->used_blocks; stats->free_size -= _Heap_Block_size( block ); } else { free_list_anchor = _Heap_Free_list_head( heap ); 3000b3e8: 11a08005 movne r8, r5 Heap_Block *free_list_anchor = NULL; _HAssert( alloc_area_begin <= alloc_begin ); if ( _Heap_Is_free( block ) ) { 3000b3ec: 1a00000c bne 3000b424 <_Heap_Block_allocate+0x68> return _Heap_Free_list_tail(heap)->prev; } RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; 3000b3f0: e5940008 ldr r0, [r4, #8] free_list_anchor = block->prev; 3000b3f4: e594800c ldr r8, [r4, #12] Heap_Block *prev = block->prev; prev->next = next; 3000b3f8: e5880008 str r0, [r8, #8] next->prev = prev; 3000b3fc: e580800c str r8, [r0, #12] _Heap_Free_list_remove( block ); /* Statistics */ --stats->free_blocks; 3000b400: e5950038 ldr r0, [r5, #56] ; 0x38 3000b404: e2400001 sub r0, r0, #1 3000b408: e5850038 str r0, [r5, #56] ; 0x38 ++stats->used_blocks; 3000b40c: e5950040 ldr r0, [r5, #64] ; 0x40 3000b410: e2800001 add r0, r0, #1 3000b414: e5850040 str r0, [r5, #64] ; 0x40 stats->free_size -= _Heap_Block_size( block ); 3000b418: e5950030 ldr r0, [r5, #48] ; 0x30 3000b41c: e0611000 rsb r1, r1, r0 3000b420: e5851030 str r1, [r5, #48] ; 0x30 } else { free_list_anchor = _Heap_Free_list_head( heap ); } if ( alloc_area_offset < heap->page_size ) { 3000b424: e5951010 ldr r1, [r5, #16] 3000b428: e1530001 cmp r3, r1 3000b42c: 2a000005 bcs 3000b448 <_Heap_Block_allocate+0x8c> Heap_Block *block, Heap_Block *free_list_anchor, uintptr_t alloc_size ) { _Heap_Block_split( heap, block, free_list_anchor, alloc_size ); 3000b430: e1a00005 mov r0, r5 3000b434: e1a01004 mov r1, r4 3000b438: e1a02008 mov r2, r8 3000b43c: e0833007 add r3, r3, r7 3000b440: ebffff31 bl 3000b10c <_Heap_Block_split> 3000b444: ea000021 b 3000b4d0 <_Heap_Block_allocate+0x114> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 3000b448: e1a00002 mov r0, r2 3000b44c: eb003a32 bl 30019d1c <__umodsi3> _HAssert( block_size >= heap->min_block_size ); _HAssert( new_block_size >= heap->min_block_size ); /* Statistics */ stats->free_size += block_size; 3000b450: e5952030 ldr r2, [r5, #48] ; 0x30 uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 3000b454: e0606006 rsb r6, r0, r6 _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); uintptr_t const new_block_begin = (uintptr_t) new_block; uintptr_t const new_block_size = block_end - new_block_begin; block_end = new_block_begin; block_size = block_end - block_begin; 3000b458: e0643006 rsb r3, r4, r6 _HAssert( block_size >= heap->min_block_size ); _HAssert( new_block_size >= heap->min_block_size ); /* Statistics */ stats->free_size += block_size; 3000b45c: e0822003 add r2, r2, r3 if ( _Heap_Is_prev_used( block ) ) { 3000b460: e31a0001 tst sl, #1 uintptr_t block_end = block_begin + block_size; Heap_Block *const new_block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); uintptr_t const new_block_begin = (uintptr_t) new_block; uintptr_t const new_block_size = block_end - new_block_begin; 3000b464: e0669009 rsb r9, r6, r9 _HAssert( block_size >= heap->min_block_size ); _HAssert( new_block_size >= heap->min_block_size ); /* Statistics */ stats->free_size += block_size; 3000b468: e5852030 str r2, [r5, #48] ; 0x30 if ( _Heap_Is_prev_used( block ) ) { 3000b46c: 0a000009 beq 3000b498 <_Heap_Block_allocate+0xdc> RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 3000b470: e5982008 ldr r2, [r8, #8] new_block->next = next; new_block->prev = block_before; 3000b474: e584800c str r8, [r4, #12] Heap_Block *new_block ) { Heap_Block *next = block_before->next; new_block->next = next; 3000b478: e5842008 str r2, [r4, #8] new_block->prev = block_before; block_before->next = new_block; next->prev = new_block; 3000b47c: e582400c str r4, [r2, #12] _Heap_Free_list_insert_after( free_list_anchor, block ); free_list_anchor = block; /* Statistics */ ++stats->free_blocks; 3000b480: e5952038 ldr r2, [r5, #56] ; 0x38 { Heap_Block *next = block_before->next; new_block->next = next; new_block->prev = block_before; block_before->next = new_block; 3000b484: e5884008 str r4, [r8, #8] 3000b488: e2822001 add r2, r2, #1 3000b48c: e5852038 str r2, [r5, #56] ; 0x38 3000b490: e1a02004 mov r2, r4 3000b494: ea000005 b 3000b4b0 <_Heap_Block_allocate+0xf4> RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Prev_block( const Heap_Block *block ) { return (Heap_Block *) ((uintptr_t) block - block->prev_size); 3000b498: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000b49c: e0624004 rsb r4, r2, r4 <== NOT EXECUTED - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000b4a0: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000b4a4: e3c22001 bic r2, r2, #1 <== NOT EXECUTED } else { Heap_Block *const prev_block = _Heap_Prev_block( block ); uintptr_t const prev_block_size = _Heap_Block_size( prev_block ); block = prev_block; block_size += prev_block_size; 3000b4a8: e0833002 add r3, r3, r2 <== NOT EXECUTED 3000b4ac: e1a02008 mov r2, r8 <== NOT EXECUTED } block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 3000b4b0: e3831001 orr r1, r3, #1 3000b4b4: e5841004 str r1, [r4, #4] new_block->prev_size = block_size; new_block->size_and_flag = new_block_size; _Heap_Block_split( heap, new_block, free_list_anchor, alloc_size ); 3000b4b8: e1a00005 mov r0, r5 } block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; new_block->prev_size = block_size; new_block->size_and_flag = new_block_size; 3000b4bc: e8860208 stm r6, {r3, r9} _Heap_Block_split( heap, new_block, free_list_anchor, alloc_size ); 3000b4c0: e1a01006 mov r1, r6 3000b4c4: e1a03007 mov r3, r7 3000b4c8: ebffff0f bl 3000b10c <_Heap_Block_split> 3000b4cc: e1a04006 mov r4, r6 alloc_size ); } /* Statistics */ if ( stats->min_free_size > stats->free_size ) { 3000b4d0: e5953030 ldr r3, [r5, #48] ; 0x30 3000b4d4: e5952034 ldr r2, [r5, #52] ; 0x34 } _Heap_Protection_block_initialize( heap, block ); return block; } 3000b4d8: e1a00004 mov r0, r4 alloc_size ); } /* Statistics */ if ( stats->min_free_size > stats->free_size ) { 3000b4dc: e1520003 cmp r2, r3 stats->min_free_size = stats->free_size; 3000b4e0: 85853034 strhi r3, [r5, #52] ; 0x34 } _Heap_Protection_block_initialize( heap, block ); return block; } 3000b4e4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} =============================================================================== 3000b10c <_Heap_Block_split>: Heap_Control *heap, Heap_Block *block, Heap_Block *free_list_anchor, uintptr_t alloc_size ) { 3000b10c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} Heap_Statistics *const stats = &heap->stats; uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; 3000b110: e5908014 ldr r8, [r0, #20] uintptr_t alloc_size ) { Heap_Statistics *const stats = &heap->stats; uintptr_t const page_size = heap->page_size; 3000b114: e590a010 ldr sl, [r0, #16] uintptr_t const min_block_size = heap->min_block_size; uintptr_t const min_alloc_size = min_block_size - HEAP_BLOCK_HEADER_SIZE; 3000b118: e248b008 sub fp, r8, #8 return heap->stats.size; } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Max( uintptr_t a, uintptr_t b ) { return a > b ? a : b; 3000b11c: e153000b cmp r3, fp 3000b120: 21a0b003 movcs fp, r3 uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const used_size = 3000b124: e28bb008 add fp, fp, #8 Heap_Control *heap, Heap_Block *block, Heap_Block *free_list_anchor, uintptr_t alloc_size ) { 3000b128: e1a05001 mov r5, r1 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000b12c: e5919004 ldr r9, [r1, #4] 3000b130: e1a04000 mov r4, r0 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 3000b134: e1a0100a mov r1, sl 3000b138: e1a0000b mov r0, fp 3000b13c: e1a06002 mov r6, r2 3000b140: eb003af5 bl 30019d1c <__umodsi3> 3000b144: e3c97001 bic r7, r9, #1 if ( remainder != 0 ) { 3000b148: e3500000 cmp r0, #0 uintptr_t const used_size = _Heap_Max( alloc_size, min_alloc_size ) + HEAP_BLOCK_HEADER_SIZE; uintptr_t const used_block_size = _Heap_Align_up( used_size, page_size ); uintptr_t const free_size = block_size + HEAP_ALLOC_BONUS - used_size; 3000b14c: e2872004 add r2, r7, #4 return value - remainder + alignment; 3000b150: 108ba00a addne sl, fp, sl } else { return value; 3000b154: 01a0a00b moveq sl, fp uintptr_t const free_size_limit = min_block_size + HEAP_ALLOC_BONUS; 3000b158: e2888004 add r8, r8, #4 uintptr_t const used_size = _Heap_Max( alloc_size, min_alloc_size ) + HEAP_BLOCK_HEADER_SIZE; uintptr_t const used_block_size = _Heap_Align_up( used_size, page_size ); uintptr_t const free_size = block_size + HEAP_ALLOC_BONUS - used_size; 3000b15c: e06bb002 rsb fp, fp, r2 ) { uintptr_t remainder = value % alignment; if ( remainder != 0 ) { return value - remainder + alignment; 3000b160: 1060a00a rsbne sl, r0, sl RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 3000b164: e0853007 add r3, r5, r7 Heap_Block *next_block = _Heap_Block_at( block, block_size ); _HAssert( used_size <= block_size + HEAP_ALLOC_BONUS ); _HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS ); if ( free_size >= free_size_limit ) { 3000b168: e15b0008 cmp fp, r8 next_block->prev_size = free_block_size; next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; _Heap_Protection_block_initialize( heap, free_block ); } else { next_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 3000b16c: 35932004 ldrcc r2, [r3, #4] 3000b170: 33822001 orrcc r2, r2, #1 Heap_Block *next_block = _Heap_Block_at( block, block_size ); _HAssert( used_size <= block_size + HEAP_ALLOC_BONUS ); _HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS ); if ( free_size >= free_size_limit ) { 3000b174: 3a000023 bcc 3000b208 <_Heap_Block_split+0xfc> _HAssert( used_block_size + free_block_size == block_size ); _Heap_Block_set_size( block, used_block_size ); /* Statistics */ stats->free_size += free_block_size; 3000b178: e5941030 ldr r1, [r4, #48] ; 0x30 RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000b17c: e2099001 and r9, r9, #1 _HAssert( used_size <= block_size + HEAP_ALLOC_BONUS ); _HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS ); if ( free_size >= free_size_limit ) { Heap_Block *const free_block = _Heap_Block_at( block, used_block_size ); uintptr_t free_block_size = block_size - used_block_size; 3000b180: e06a7007 rsb r7, sl, r7 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 3000b184: e08a2005 add r2, sl, r5 uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; block->size_and_flag = size | flag; 3000b188: e18aa009 orr sl, sl, r9 3000b18c: e585a004 str sl, [r5, #4] _HAssert( used_block_size + free_block_size == block_size ); _Heap_Block_set_size( block, used_block_size ); /* Statistics */ stats->free_size += free_block_size; 3000b190: e0811007 add r1, r1, r7 3000b194: e5841030 str r1, [r4, #48] ; 0x30 - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000b198: e5931004 ldr r1, [r3, #4] 3000b19c: e3c11001 bic r1, r1, #1 block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000b1a0: e0830001 add r0, r3, r1 3000b1a4: e5900004 ldr r0, [r0, #4] if ( _Heap_Is_used( next_block ) ) { 3000b1a8: e3100001 tst r0, #1 3000b1ac: 0a000008 beq 3000b1d4 <_Heap_Block_split+0xc8> RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 3000b1b0: e5961008 ldr r1, [r6, #8] new_block->next = next; new_block->prev = block_before; 3000b1b4: e582600c str r6, [r2, #12] Heap_Block *new_block ) { Heap_Block *next = block_before->next; new_block->next = next; 3000b1b8: e5821008 str r1, [r2, #8] new_block->prev = block_before; block_before->next = new_block; next->prev = new_block; 3000b1bc: e581200c str r2, [r1, #12] _Heap_Free_list_insert_after( free_list_anchor, free_block ); /* Statistics */ ++stats->free_blocks; 3000b1c0: e5941038 ldr r1, [r4, #56] ; 0x38 { Heap_Block *next = block_before->next; new_block->next = next; new_block->prev = block_before; block_before->next = new_block; 3000b1c4: e5862008 str r2, [r6, #8] 3000b1c8: e2811001 add r1, r1, #1 3000b1cc: e5841038 str r1, [r4, #56] ; 0x38 3000b1d0: ea000007 b 3000b1f4 <_Heap_Block_split+0xe8> RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace( Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *next = old_block->next; 3000b1d4: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED Heap_Block *prev = old_block->prev; 3000b1d8: e593300c ldr r3, [r3, #12] <== NOT EXECUTED } else { uintptr_t const next_block_size = _Heap_Block_size( next_block ); _Heap_Free_list_replace( next_block, free_block ); free_block_size += next_block_size; 3000b1dc: e0877001 add r7, r7, r1 <== NOT EXECUTED new_block->next = next; new_block->prev = prev; 3000b1e0: e582300c str r3, [r2, #12] <== NOT EXECUTED ) { Heap_Block *next = old_block->next; Heap_Block *prev = old_block->prev; new_block->next = next; 3000b1e4: e5820008 str r0, [r2, #8] <== NOT EXECUTED new_block->prev = prev; next->prev = new_block; 3000b1e8: e580200c str r2, [r0, #12] <== NOT EXECUTED prev->next = new_block; 3000b1ec: e5832008 str r2, [r3, #8] <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 3000b1f0: e0873002 add r3, r7, r2 <== NOT EXECUTED next_block = _Heap_Block_at( free_block, free_block_size ); } free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED; 3000b1f4: e3871001 orr r1, r7, #1 3000b1f8: e5821004 str r1, [r2, #4] next_block->prev_size = free_block_size; next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 3000b1fc: e5932004 ldr r2, [r3, #4] next_block = _Heap_Block_at( free_block, free_block_size ); } free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED; next_block->prev_size = free_block_size; 3000b200: e5837000 str r7, [r3] next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 3000b204: e3c22001 bic r2, r2, #1 _Heap_Protection_block_initialize( heap, free_block ); } else { next_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 3000b208: e5832004 str r2, [r3, #4] 3000b20c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} =============================================================================== 3000f334 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t unused __attribute__((unused)) ) { 3000f334: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED 3000f338: e1a05001 mov r5, r1 <== NOT EXECUTED Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 3000f33c: e5901020 ldr r1, [r0, #32] <== NOT EXECUTED Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t unused __attribute__((unused)) ) { 3000f340: e24dd024 sub sp, sp, #36 ; 0x24 <== NOT EXECUTED Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size; 3000f344: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED uintptr_t extend_area_size, uintptr_t unused __attribute__((unused)) ) { Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 3000f348: e58d1010 str r1, [sp, #16] <== NOT EXECUTED Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size; 3000f34c: e5901030 ldr r1, [r0, #48] ; 0x30 <== NOT EXECUTED Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; 3000f350: e3a08000 mov r8, #0 <== NOT EXECUTED uintptr_t const free_size = stats->free_size; uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { 3000f354: e0956002 adds r6, r5, r2 <== NOT EXECUTED Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t unused __attribute__((unused)) ) { 3000f358: e1a04000 mov r4, r0 <== NOT EXECUTED Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size; 3000f35c: e58d3014 str r3, [sp, #20] <== NOT EXECUTED Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; 3000f360: e58d801c str r8, [sp, #28] <== NOT EXECUTED Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; 3000f364: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; 3000f368: e58d8020 str r8, [sp, #32] <== NOT EXECUTED uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size; 3000f36c: e58d1018 str r1, [sp, #24] <== NOT EXECUTED uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { return 0; 3000f370: 21a00008 movcs r0, r8 <== NOT EXECUTED uintptr_t const free_size = stats->free_size; uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { 3000f374: 2a000099 bcs 3000f5e0 <_Heap_Extend+0x2ac> <== NOT EXECUTED return 0; } extend_area_ok = _Heap_Get_first_and_last_block( 3000f378: e28d101c add r1, sp, #28 <== NOT EXECUTED 3000f37c: e58d1000 str r1, [sp] <== NOT EXECUTED 3000f380: e28d1020 add r1, sp, #32 <== NOT EXECUTED 3000f384: e58d1004 str r1, [sp, #4] <== NOT EXECUTED 3000f388: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f38c: e1a01002 mov r1, r2 <== NOT EXECUTED 3000f390: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 3000f394: ebffefb4 bl 3000b26c <_Heap_Get_first_and_last_block> <== NOT EXECUTED page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 3000f398: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f39c: 0a00008f beq 3000f5e0 <_Heap_Extend+0x2ac> <== NOT EXECUTED 3000f3a0: e59da010 ldr sl, [sp, #16] <== NOT EXECUTED 3000f3a4: e1a07008 mov r7, r8 <== NOT EXECUTED 3000f3a8: e1a09008 mov r9, r8 <== NOT EXECUTED return 0; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 3000f3ac: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED 3000f3b0: e1a03008 mov r3, r8 <== NOT EXECUTED 3000f3b4: e1a0c004 mov ip, r4 <== NOT EXECUTED 3000f3b8: ea000000 b 3000f3c0 <_Heap_Extend+0x8c> <== NOT EXECUTED 3000f3bc: e1a0100a mov r1, sl <== NOT EXECUTED uintptr_t const sub_area_end = start_block->prev_size; 3000f3c0: e59a4000 ldr r4, [sl] <== NOT EXECUTED Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 3000f3c4: e1560001 cmp r6, r1 <== NOT EXECUTED 3000f3c8: 93a00000 movls r0, #0 <== NOT EXECUTED 3000f3cc: 83a00001 movhi r0, #1 <== NOT EXECUTED 3000f3d0: e1550004 cmp r5, r4 <== NOT EXECUTED 3000f3d4: 23a00000 movcs r0, #0 <== NOT EXECUTED 3000f3d8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f3dc: 1a00007e bne 3000f5dc <_Heap_Extend+0x2a8> <== NOT EXECUTED sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return 0; } if ( extend_area_end == sub_area_begin ) { 3000f3e0: e1560001 cmp r6, r1 <== NOT EXECUTED 3000f3e4: 01a0300a moveq r3, sl <== NOT EXECUTED 3000f3e8: 0a000001 beq 3000f3f4 <_Heap_Extend+0xc0> <== NOT EXECUTED merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 3000f3ec: e1560004 cmp r6, r4 <== NOT EXECUTED 3000f3f0: 31a0900a movcc r9, sl <== NOT EXECUTED RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 3000f3f4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f3f8: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 3000f3fc: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000f400: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 3000f404: eb002b0e bl 3001a044 <__umodsi3> <== NOT EXECUTED 3000f408: e244b008 sub fp, r4, #8 <== NOT EXECUTED link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 3000f40c: e1540005 cmp r4, r5 <== NOT EXECUTED uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 3000f410: e060000b rsb r0, r0, fp <== NOT EXECUTED 3000f414: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3000f418: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area( uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) 3000f41c: 01a07000 moveq r7, r0 <== NOT EXECUTED start_block->prev_size = extend_area_end; 3000f420: 058a6000 streq r6, [sl] <== NOT EXECUTED merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 3000f424: 0a000000 beq 3000f42c <_Heap_Extend+0xf8> <== NOT EXECUTED 3000f428: 31a08000 movcc r8, r0 <== NOT EXECUTED - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000f42c: e590a004 ldr sl, [r0, #4] <== NOT EXECUTED } else if ( sub_area_end < extend_area_begin ) { link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 3000f430: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3000f434: e3caa001 bic sl, sl, #1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 3000f438: e080a00a add sl, r0, sl <== NOT EXECUTED 3000f43c: e15a0002 cmp sl, r2 <== NOT EXECUTED 3000f440: 1affffdd bne 3000f3bc <_Heap_Extend+0x88> <== NOT EXECUTED 3000f444: e1a02009 mov r2, r9 <== NOT EXECUTED 3000f448: e1a09003 mov r9, r3 <== NOT EXECUTED if ( extend_area_begin < heap->area_begin ) { 3000f44c: e59c3018 ldr r3, [ip, #24] <== NOT EXECUTED 3000f450: e1a0400c mov r4, ip <== NOT EXECUTED 3000f454: e1550003 cmp r5, r3 <== NOT EXECUTED heap->area_begin = extend_area_begin; 3000f458: 358c5018 strcc r5, [ip, #24] <== NOT EXECUTED } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); if ( extend_area_begin < heap->area_begin ) { 3000f45c: 3a000002 bcc 3000f46c <_Heap_Extend+0x138> <== NOT EXECUTED heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { 3000f460: e59c301c ldr r3, [ip, #28] <== NOT EXECUTED 3000f464: e1530006 cmp r3, r6 <== NOT EXECUTED heap->area_end = extend_area_end; 3000f468: 358c601c strcc r6, [ip, #28] <== NOT EXECUTED } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 3000f46c: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 3000f470: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED extend_first_block->prev_size = extend_area_end; 3000f474: e5816000 str r6, [r1] <== NOT EXECUTED heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { heap->area_end = extend_area_end; } extend_first_block_size = 3000f478: e0610003 rsb r0, r1, r3 <== NOT EXECUTED (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 3000f47c: e380c001 orr ip, r0, #1 <== NOT EXECUTED _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 3000f480: e5830000 str r0, [r3] <== NOT EXECUTED extend_last_block->size_and_flag = 0; 3000f484: e3a00000 mov r0, #0 <== NOT EXECUTED extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; extend_first_block->size_and_flag = 3000f488: e581c004 str ip, [r1, #4] <== NOT EXECUTED extend_first_block_size | HEAP_PREV_BLOCK_USED; _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; extend_last_block->size_and_flag = 0; 3000f48c: e5830004 str r0, [r3, #4] <== NOT EXECUTED _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 3000f490: e5940020 ldr r0, [r4, #32] <== NOT EXECUTED 3000f494: e1500001 cmp r0, r1 <== NOT EXECUTED heap->first_block = extend_first_block; 3000f498: 85841020 strhi r1, [r4, #32] <== NOT EXECUTED extend_last_block->prev_size = extend_first_block_size; extend_last_block->size_and_flag = 0; _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 3000f49c: 8a000002 bhi 3000f4ac <_Heap_Extend+0x178> <== NOT EXECUTED heap->first_block = extend_first_block; } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 3000f4a0: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000f4a4: e1510003 cmp r1, r3 <== NOT EXECUTED heap->last_block = extend_last_block; 3000f4a8: 35843024 strcc r3, [r4, #36] ; 0x24 <== NOT EXECUTED } if ( merge_below_block != NULL ) { 3000f4ac: e3590000 cmp r9, #0 <== NOT EXECUTED 3000f4b0: 0a000010 beq 3000f4f8 <_Heap_Extend+0x1c4> <== NOT EXECUTED Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 3000f4b4: e594a010 ldr sl, [r4, #16] <== NOT EXECUTED uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 3000f4b8: e2855008 add r5, r5, #8 <== NOT EXECUTED RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 3000f4bc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f4c0: e1a0100a mov r1, sl <== NOT EXECUTED 3000f4c4: eb002ade bl 3001a044 <__umodsi3> <== NOT EXECUTED if ( remainder != 0 ) { 3000f4c8: e3500000 cmp r0, #0 <== NOT EXECUTED return value - remainder + alignment; 3000f4cc: 1085500a addne r5, r5, sl <== NOT EXECUTED 3000f4d0: 10605005 rsbne r5, r0, r5 <== NOT EXECUTED uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; 3000f4d4: e5993000 ldr r3, [r9] <== NOT EXECUTED ) { uintptr_t const page_size = heap->page_size; uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const new_first_block_begin = 3000f4d8: e2451008 sub r1, r5, #8 <== NOT EXECUTED uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; 3000f4dc: e5053008 str r3, [r5, #-8] <== NOT EXECUTED uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); uintptr_t const new_first_block_begin = new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE; uintptr_t const first_block_begin = (uintptr_t) first_block; uintptr_t const new_first_block_size = 3000f4e0: e0613009 rsb r3, r1, r9 <== NOT EXECUTED first_block_begin - new_first_block_begin; Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; new_first_block->prev_size = first_block->prev_size; new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED; 3000f4e4: e3833001 orr r3, r3, #1 <== NOT EXECUTED 3000f4e8: e5053004 str r3, [r5, #-4] <== NOT EXECUTED _Heap_Free_block( heap, new_first_block ); 3000f4ec: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f4f0: ebffff7a bl 3000f2e0 <_Heap_Free_block> <== NOT EXECUTED 3000f4f4: ea000004 b 3000f50c <_Heap_Extend+0x1d8> <== NOT EXECUTED heap->last_block = extend_last_block; } if ( merge_below_block != NULL ) { _Heap_Merge_below( heap, extend_area_begin, merge_below_block ); } else if ( link_below_block != NULL ) { 3000f4f8: e3520000 cmp r2, #0 <== NOT EXECUTED _Heap_Link_below( 3000f4fc: 159d3020 ldrne r3, [sp, #32] <== NOT EXECUTED { uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const link_begin = (uintptr_t) link; last_block->size_and_flag = (link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED; 3000f500: 10632002 rsbne r2, r3, r2 <== NOT EXECUTED 3000f504: 13822001 orrne r2, r2, #1 <== NOT EXECUTED ) { uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const link_begin = (uintptr_t) link; last_block->size_and_flag = 3000f508: 15832004 strne r2, [r3, #4] <== NOT EXECUTED link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 3000f50c: e3570000 cmp r7, #0 <== NOT EXECUTED 3000f510: 0a000012 beq 3000f560 <_Heap_Extend+0x22c> <== NOT EXECUTED ) { uintptr_t const page_size = heap->page_size; uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const last_block_new_size = _Heap_Align_down( extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE, 3000f514: e2466008 sub r6, r6, #8 <== NOT EXECUTED uintptr_t extend_area_end ) { uintptr_t const page_size = heap->page_size; uintptr_t const last_block_begin = (uintptr_t) last_block; uintptr_t const last_block_new_size = _Heap_Align_down( 3000f518: e0676006 rsb r6, r7, r6 <== NOT EXECUTED RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 3000f51c: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED 3000f520: e1a00006 mov r0, r6 <== NOT EXECUTED 3000f524: eb002ac6 bl 3001a044 <__umodsi3> <== NOT EXECUTED ); Heap_Block *const new_last_block = _Heap_Block_at( last_block, last_block_new_size ); new_last_block->size_and_flag = (last_block->size_and_flag - last_block_new_size) 3000f528: e5972004 ldr r2, [r7, #4] <== NOT EXECUTED 3000f52c: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 3000f530: e0662002 rsb r2, r6, r2 <== NOT EXECUTED page_size ); Heap_Block *const new_last_block = _Heap_Block_at( last_block, last_block_new_size ); new_last_block->size_and_flag = 3000f534: e0863007 add r3, r6, r7 <== NOT EXECUTED (last_block->size_and_flag - last_block_new_size) | HEAP_PREV_BLOCK_USED; 3000f538: e3822001 orr r2, r2, #1 <== NOT EXECUTED page_size ); Heap_Block *const new_last_block = _Heap_Block_at( last_block, last_block_new_size ); new_last_block->size_and_flag = 3000f53c: e5832004 str r2, [r3, #4] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000f540: e5973004 ldr r3, [r7, #4] <== NOT EXECUTED (last_block->size_and_flag - last_block_new_size) | HEAP_PREV_BLOCK_USED; _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 3000f544: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f548: e2033001 and r3, r3, #1 <== NOT EXECUTED block->size_and_flag = size | flag; 3000f54c: e1866003 orr r6, r6, r3 <== NOT EXECUTED 3000f550: e5876004 str r6, [r7, #4] <== NOT EXECUTED 3000f554: e1a01007 mov r1, r7 <== NOT EXECUTED 3000f558: ebffff60 bl 3000f2e0 <_Heap_Free_block> <== NOT EXECUTED 3000f55c: ea00000b b 3000f590 <_Heap_Extend+0x25c> <== NOT EXECUTED ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 3000f560: e3580000 cmp r8, #0 <== NOT EXECUTED 3000f564: 0a000009 beq 3000f590 <_Heap_Extend+0x25c> <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000f568: e5982004 ldr r2, [r8, #4] <== NOT EXECUTED ) { uintptr_t const link_begin = (uintptr_t) link; uintptr_t const first_block_begin = (uintptr_t) first_block; _Heap_Block_set_size( link, first_block_begin - link_begin ); 3000f56c: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 3000f570: e2022001 and r2, r2, #1 <== NOT EXECUTED 3000f574: e0681001 rsb r1, r8, r1 <== NOT EXECUTED } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { _Heap_Link_above( 3000f578: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED block->size_and_flag = size | flag; 3000f57c: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000f580: e5882004 str r2, [r8, #4] <== NOT EXECUTED uintptr_t const link_begin = (uintptr_t) link; uintptr_t const first_block_begin = (uintptr_t) first_block; _Heap_Block_set_size( link, first_block_begin - link_begin ); last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 3000f584: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000f588: e3822001 orr r2, r2, #1 <== NOT EXECUTED 3000f58c: e5832004 str r2, [r3, #4] <== NOT EXECUTED extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 3000f590: e3570000 cmp r7, #0 <== NOT EXECUTED 3000f594: 03590000 cmpeq r9, #0 <== NOT EXECUTED _Heap_Free_block( heap, extend_first_block ); 3000f598: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000f59c: 059d101c ldreq r1, [sp, #28] <== NOT EXECUTED 3000f5a0: 0bffff4e bleq 3000f2e0 <_Heap_Free_block> <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( heap->last_block, (uintptr_t) heap->first_block - (uintptr_t) heap->last_block 3000f5a4: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED * This feature will be used to terminate the scattered heap area list. See * also _Heap_Extend(). */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( 3000f5a8: e5941020 ldr r1, [r4, #32] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000f5ac: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED * This feature will be used to terminate the scattered heap area list. See * also _Heap_Extend(). */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( 3000f5b0: e0631001 rsb r1, r3, r1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000f5b4: e2022001 and r2, r2, #1 <== NOT EXECUTED block->size_and_flag = size | flag; 3000f5b8: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000f5bc: e5832004 str r2, [r3, #4] <== NOT EXECUTED } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 3000f5c0: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 3000f5c4: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3000f5c8: e0630000 rsb r0, r3, r0 <== NOT EXECUTED /* Statistics */ stats->size += extended_size; 3000f5cc: e594302c ldr r3, [r4, #44] ; 0x2c <== NOT EXECUTED 3000f5d0: e0833000 add r3, r3, r0 <== NOT EXECUTED 3000f5d4: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED return extended_size; 3000f5d8: ea000000 b 3000f5e0 <_Heap_Extend+0x2ac> <== NOT EXECUTED _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return 0; 3000f5dc: e3a00000 mov r0, #0 <== NOT EXECUTED /* Statistics */ stats->size += extended_size; return extended_size; } 3000f5e0: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED 3000f5e4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED =============================================================================== 3000f2e0 <_Heap_Free_block>: { Heap_Statistics *const stats = &heap->stats; Heap_Block *first_free; /* Statistics */ ++stats->used_blocks; 3000f2e0: e5903040 ldr r3, [r0, #64] ; 0x40 <== NOT EXECUTED #include #include #include static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block ) { 3000f2e4: e92d4010 push {r4, lr} <== NOT EXECUTED Heap_Statistics *const stats = &heap->stats; Heap_Block *first_free; /* Statistics */ ++stats->used_blocks; 3000f2e8: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000f2ec: e5803040 str r3, [r0, #64] ; 0x40 <== NOT EXECUTED --stats->frees; 3000f2f0: e5903050 ldr r3, [r0, #80] ; 0x50 <== NOT EXECUTED #include #include #include static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block ) { 3000f2f4: e1a04000 mov r4, r0 <== NOT EXECUTED Heap_Statistics *const stats = &heap->stats; Heap_Block *first_free; /* Statistics */ ++stats->used_blocks; --stats->frees; 3000f2f8: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000f2fc: e5803050 str r3, [r0, #80] ; 0x50 <== NOT EXECUTED /* * The _Heap_Free() will place the block to the head of free list. We want * the new block at the end of the free list. So that initial and earlier * areas are consumed first. */ _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 3000f300: e2811008 add r1, r1, #8 <== NOT EXECUTED 3000f304: eb0000b7 bl 3000f5e8 <_Heap_Free> <== NOT EXECUTED return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 3000f308: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED return _Heap_Free_list_tail(heap)->prev; } RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; 3000f30c: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED Heap_Block *prev = block->prev; 3000f310: e593100c ldr r1, [r3, #12] <== NOT EXECUTED prev->next = next; next->prev = prev; 3000f314: e582100c str r1, [r2, #12] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; Heap_Block *prev = block->prev; prev->next = next; 3000f318: e5812008 str r2, [r1, #8] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_before( Heap_Block *block_next, Heap_Block *new_block ) { Heap_Block *prev = block_next->prev; 3000f31c: e594200c ldr r2, [r4, #12] <== NOT EXECUTED new_block->next = block_next; 3000f320: e5834008 str r4, [r3, #8] <== NOT EXECUTED new_block->prev = prev; 3000f324: e583200c str r2, [r3, #12] <== NOT EXECUTED prev->next = new_block; 3000f328: e5823008 str r3, [r2, #8] <== NOT EXECUTED block_next->prev = new_block; 3000f32c: e584300c str r3, [r4, #12] <== NOT EXECUTED first_free = _Heap_Free_list_first( heap ); _Heap_Free_list_remove( first_free ); _Heap_Free_list_insert_before( _Heap_Free_list_tail( heap ), first_free ); } 3000f330: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000b29c <_Heap_Initialize>: Heap_Control *heap, void *heap_area_begin_ptr, uintptr_t heap_area_size, uintptr_t page_size ) { 3000b29c: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr} 3000b2a0: e1a08002 mov r8, r2 uintptr_t min_block_size = 0; bool area_ok = false; Heap_Block *first_block = NULL; Heap_Block *last_block = NULL; if ( page_size == 0 ) { 3000b2a4: e2535000 subs r5, r3, #0 uintptr_t first_block_begin = 0; uintptr_t first_block_size = 0; uintptr_t last_block_begin = 0; uintptr_t min_block_size = 0; bool area_ok = false; Heap_Block *first_block = NULL; 3000b2a8: e3a02000 mov r2, #0 Heap_Control *heap, void *heap_area_begin_ptr, uintptr_t heap_area_size, uintptr_t page_size ) { 3000b2ac: e1a04000 mov r4, r0 3000b2b0: e1a06001 mov r6, r1 uintptr_t first_block_begin = 0; uintptr_t first_block_size = 0; uintptr_t last_block_begin = 0; uintptr_t min_block_size = 0; bool area_ok = false; Heap_Block *first_block = NULL; 3000b2b4: e58d2008 str r2, [sp, #8] Heap_Block *last_block = NULL; 3000b2b8: e58d200c str r2, [sp, #12] if ( page_size == 0 ) { page_size = CPU_ALIGNMENT; 3000b2bc: 03a05008 moveq r5, #8 uintptr_t min_block_size = 0; bool area_ok = false; Heap_Block *first_block = NULL; Heap_Block *last_block = NULL; if ( page_size == 0 ) { 3000b2c0: 0a000004 beq 3000b2d8 <_Heap_Initialize+0x3c> uintptr_t alignment ) { uintptr_t remainder = value % alignment; if ( remainder != 0 ) { 3000b2c4: e2153007 ands r3, r5, #7 return value - remainder + alignment; 3000b2c8: 12855008 addne r5, r5, #8 3000b2cc: 10635005 rsbne r5, r3, r5 page_size = CPU_ALIGNMENT; } else { page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT ); if ( page_size < CPU_ALIGNMENT ) { 3000b2d0: e3550007 cmp r5, #7 3000b2d4: 9a000034 bls 3000b3ac <_Heap_Initialize+0x110> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 3000b2d8: e1a01005 mov r1, r5 3000b2dc: e3a00010 mov r0, #16 3000b2e0: eb003a8d bl 30019d1c <__umodsi3> if ( remainder != 0 ) { 3000b2e4: e3500000 cmp r0, #0 return value - remainder + alignment; 3000b2e8: 12857010 addne r7, r5, #16 return 0; } } min_block_size = _Heap_Align_up( sizeof( Heap_Block ), page_size ); area_ok = _Heap_Get_first_and_last_block( 3000b2ec: e28d3008 add r3, sp, #8 3000b2f0: 10607007 rsbne r7, r0, r7 } else { return value; 3000b2f4: 03a07010 moveq r7, #16 3000b2f8: e58d3000 str r3, [sp] 3000b2fc: e28d300c add r3, sp, #12 3000b300: e58d3004 str r3, [sp, #4] 3000b304: e1a00006 mov r0, r6 3000b308: e1a01008 mov r1, r8 3000b30c: e1a02005 mov r2, r5 3000b310: e1a03007 mov r3, r7 3000b314: ebffffbd bl 3000b210 <_Heap_Get_first_and_last_block> page_size, min_block_size, &first_block, &last_block ); if ( !area_ok ) { 3000b318: e3500000 cmp r0, #0 3000b31c: 0a000023 beq 3000b3b0 <_Heap_Initialize+0x114> return 0; } memset(heap, 0, sizeof(*heap)); 3000b320: e3a01000 mov r1, #0 3000b324: e3a02058 mov r2, #88 ; 0x58 3000b328: e1a00004 mov r0, r4 3000b32c: eb0018b3 bl 30011600 heap->Protection.block_initialize = _Heap_Protection_block_initialize_default; heap->Protection.block_check = _Heap_Protection_block_check_default; heap->Protection.block_error = _Heap_Protection_block_error_default; #endif first_block_begin = (uintptr_t) first_block; 3000b330: e59d3008 ldr r3, [sp, #8] last_block_begin = (uintptr_t) last_block; 3000b334: e59d200c ldr r2, [sp, #12] uintptr_t page_size ) { Heap_Statistics *const stats = &heap->stats; uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr; uintptr_t const heap_area_end = heap_area_begin + heap_area_size; 3000b338: e0888006 add r8, r8, r6 heap->Protection.block_error = _Heap_Protection_block_error_default; #endif first_block_begin = (uintptr_t) first_block; last_block_begin = (uintptr_t) last_block; first_block_size = last_block_begin - first_block_begin; 3000b33c: e0630002 rsb r0, r3, r2 /* First block */ first_block->prev_size = heap_area_end; first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED; 3000b340: e3801001 orr r1, r0, #1 first_block_begin = (uintptr_t) first_block; last_block_begin = (uintptr_t) last_block; first_block_size = last_block_begin - first_block_begin; /* First block */ first_block->prev_size = heap_area_end; 3000b344: e5838000 str r8, [r3] first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED; first_block->next = _Heap_Free_list_tail( heap ); 3000b348: e9830012 stmib r3, {r1, r4} first_block->prev = _Heap_Free_list_head( heap ); 3000b34c: e583400c str r4, [r3, #12] heap->min_block_size = min_block_size; heap->area_begin = heap_area_begin; heap->area_end = heap_area_end; heap->first_block = first_block; heap->last_block = last_block; _Heap_Free_list_head( heap )->next = first_block; 3000b350: e5843008 str r3, [r4, #8] /* Heap control */ heap->page_size = page_size; heap->min_block_size = min_block_size; heap->area_begin = heap_area_begin; heap->area_end = heap_area_end; heap->first_block = first_block; 3000b354: e5843020 str r3, [r4, #32] heap->last_block = last_block; _Heap_Free_list_head( heap )->next = first_block; _Heap_Free_list_tail( heap )->prev = first_block; 3000b358: e584300c str r3, [r4, #12] * This feature will be used to terminate the scattered heap area list. See * also _Heap_Extend(). */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( 3000b35c: e0623003 rsb r3, r2, r3 heap->page_size = page_size; heap->min_block_size = min_block_size; heap->area_begin = heap_area_begin; heap->area_end = heap_area_end; heap->first_block = first_block; heap->last_block = last_block; 3000b360: e5842024 str r2, [r4, #36] ; 0x24 first_block->next = _Heap_Free_list_tail( heap ); first_block->prev = _Heap_Free_list_head( heap ); _Heap_Protection_block_initialize( heap, first_block ); /* Heap control */ heap->page_size = page_size; 3000b364: e5845010 str r5, [r4, #16] heap->min_block_size = min_block_size; 3000b368: e5847014 str r7, [r4, #20] heap->area_begin = heap_area_begin; 3000b36c: e5846018 str r6, [r4, #24] heap->area_end = heap_area_end; 3000b370: e584801c str r8, [r4, #28] uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; block->size_and_flag = size | flag; 3000b374: e5823004 str r3, [r2, #4] /* Statistics */ stats->size = first_block_size; stats->free_size = first_block_size; stats->min_free_size = first_block_size; stats->free_blocks = 1; 3000b378: e3a03001 mov r3, #1 heap->last_block = last_block; _Heap_Free_list_head( heap )->next = first_block; _Heap_Free_list_tail( heap )->prev = first_block; /* Last block */ last_block->prev_size = first_block_size; 3000b37c: e5820000 str r0, [r2] /* Statistics */ stats->size = first_block_size; stats->free_size = first_block_size; stats->min_free_size = first_block_size; stats->free_blocks = 1; 3000b380: e5843038 str r3, [r4, #56] ; 0x38 stats->max_free_blocks = 1; 3000b384: e584303c str r3, [r4, #60] ; 0x3c stats->instance = instance++; 3000b388: e59f3028 ldr r3, [pc, #40] ; 3000b3b8 <_Heap_Initialize+0x11c> last_block->size_and_flag = 0; _Heap_Set_last_block_size( heap ); _Heap_Protection_block_initialize( heap, last_block ); /* Statistics */ stats->size = first_block_size; 3000b38c: e584002c str r0, [r4, #44] ; 0x2c stats->free_size = first_block_size; stats->min_free_size = first_block_size; stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++; 3000b390: e5932000 ldr r2, [r3] _Heap_Set_last_block_size( heap ); _Heap_Protection_block_initialize( heap, last_block ); /* Statistics */ stats->size = first_block_size; stats->free_size = first_block_size; 3000b394: e5840030 str r0, [r4, #48] ; 0x30 stats->min_free_size = first_block_size; stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++; 3000b398: e5842028 str r2, [r4, #40] ; 0x28 3000b39c: e2822001 add r2, r2, #1 _Heap_Protection_block_initialize( heap, last_block ); /* Statistics */ stats->size = first_block_size; stats->free_size = first_block_size; stats->min_free_size = first_block_size; 3000b3a0: e5840034 str r0, [r4, #52] ; 0x34 stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++; 3000b3a4: e5832000 str r2, [r3] ); _HAssert( _Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size ) ); return first_block_size; 3000b3a8: ea000000 b 3000b3b0 <_Heap_Initialize+0x114> } else { page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT ); if ( page_size < CPU_ALIGNMENT ) { /* Integer overflow */ return 0; 3000b3ac: e3a00000 mov r0, #0 <== NOT EXECUTED _HAssert( _Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size ) ); return first_block_size; } 3000b3b0: e28dd010 add sp, sp, #16 3000b3b4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} =============================================================================== 3000f798 <_Heap_No_extend>: uintptr_t unused_2 __attribute__((unused)), uintptr_t unused_3 __attribute__((unused)) ) { return 0; } 3000f798: e3a00000 mov r0, #0 <== NOT EXECUTED 3000f79c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000f4b0 <_Heap_Resize_block>: void *alloc_begin_ptr, uintptr_t new_alloc_size, uintptr_t *old_size, uintptr_t *new_size ) { 3000f4b0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} 3000f4b4: e1a04000 mov r4, r0 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 3000f4b8: e241a008 sub sl, r1, #8 3000f4bc: e1a00001 mov r0, r1 3000f4c0: e1a05001 mov r5, r1 3000f4c4: e5941010 ldr r1, [r4, #16] 3000f4c8: e1a08003 mov r8, r3 3000f4cc: e1a07002 mov r7, r2 3000f4d0: eb002a11 bl 30019d1c <__umodsi3> 3000f4d4: e59d601c ldr r6, [sp, #28] uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr; Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); *old_size = 0; 3000f4d8: e3a03000 mov r3, #0 3000f4dc: e5883000 str r3, [r8] *new_size = 0; 3000f4e0: e5863000 str r3, [r6] const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 3000f4e4: e5943020 ldr r3, [r4, #32] uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 3000f4e8: e060100a rsb r1, r0, sl const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 3000f4ec: e1530001 cmp r3, r1 new_alloc_size, old_size, new_size ); } return HEAP_RESIZE_FATAL_ERROR; 3000f4f0: 83a00002 movhi r0, #2 3000f4f4: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc} 3000f4f8: e5943024 ldr r3, [r4, #36] ; 0x24 3000f4fc: e1530001 cmp r3, r1 3000f500: 3a000035 bcc 3000f5dc <_Heap_Resize_block+0x12c> - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000f504: e5913004 ldr r3, [r1, #4] uintptr_t const block_begin = (uintptr_t) block; uintptr_t block_size = _Heap_Block_size( block ); uintptr_t block_end = block_begin + block_size; uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS; 3000f508: e265c004 rsb ip, r5, #4 3000f50c: e3c33001 bic r3, r3, #1 { Heap_Statistics *const stats = &heap->stats; uintptr_t const block_begin = (uintptr_t) block; uintptr_t block_size = _Heap_Block_size( block ); uintptr_t block_end = block_begin + block_size; 3000f510: e0812003 add r2, r1, r3 3000f514: e5920004 ldr r0, [r2, #4] uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS; 3000f518: e08cc002 add ip, ip, r2 3000f51c: e3c00001 bic r0, r0, #1 block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000f520: e082a000 add sl, r2, r0 3000f524: e59aa004 ldr sl, [sl, #4] bool next_block_is_free = _Heap_Is_free( next_block ); _HAssert( _Heap_Is_block_in_heap( heap, next_block ) ); _HAssert( _Heap_Is_prev_used( next_block ) ); *old_size = alloc_size; 3000f528: e588c000 str ip, [r8] RTEMS_INLINE_ROUTINE bool _Heap_Is_free( const Heap_Block *block ) { return !_Heap_Is_used( block ); 3000f52c: e31a0001 tst sl, #1 3000f530: 13a0a000 movne sl, #0 3000f534: 03a0a001 moveq sl, #1 if ( next_block_is_free ) { 3000f538: e35a0000 cmp sl, #0 block_size += next_block_size; alloc_size += next_block_size; 3000f53c: 108cc000 addne ip, ip, r0 _HAssert( _Heap_Is_prev_used( next_block ) ); *old_size = alloc_size; if ( next_block_is_free ) { block_size += next_block_size; 3000f540: 10833000 addne r3, r3, r0 alloc_size += next_block_size; } if ( new_alloc_size > alloc_size ) { 3000f544: e157000c cmp r7, ip return HEAP_RESIZE_UNSATISFIED; 3000f548: 83a00001 movhi r0, #1 if ( next_block_is_free ) { block_size += next_block_size; alloc_size += next_block_size; } if ( new_alloc_size > alloc_size ) { 3000f54c: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc} return HEAP_RESIZE_UNSATISFIED; } if ( next_block_is_free ) { 3000f550: e35a0000 cmp sl, #0 3000f554: 0a000011 beq 3000f5a0 <_Heap_Resize_block+0xf0> RTEMS_INLINE_ROUTINE void _Heap_Block_set_size( Heap_Block *block, uintptr_t size ) { uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000f558: e591c004 ldr ip, [r1, #4] 3000f55c: e20cc001 and ip, ip, #1 block->size_and_flag = size | flag; 3000f560: e183c00c orr ip, r3, ip 3000f564: e581c004 str ip, [r1, #4] return _Heap_Free_list_tail(heap)->prev; } RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; 3000f568: e592c008 ldr ip, [r2, #8] Heap_Block *prev = block->prev; 3000f56c: e592200c ldr r2, [r2, #12] RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 3000f570: e0833001 add r3, r3, r1 RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; Heap_Block *prev = block->prev; prev->next = next; 3000f574: e582c008 str ip, [r2, #8] next->prev = prev; 3000f578: e58c200c str r2, [ip, #12] _Heap_Block_set_size( block, block_size ); _Heap_Free_list_remove( next_block ); next_block = _Heap_Block_at( block, block_size ); next_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 3000f57c: e5932004 ldr r2, [r3, #4] 3000f580: e3822001 orr r2, r2, #1 3000f584: e5832004 str r2, [r3, #4] /* Statistics */ --stats->free_blocks; 3000f588: e5943038 ldr r3, [r4, #56] ; 0x38 3000f58c: e2433001 sub r3, r3, #1 3000f590: e5843038 str r3, [r4, #56] ; 0x38 stats->free_size -= next_block_size; 3000f594: e5943030 ldr r3, [r4, #48] ; 0x30 3000f598: e0600003 rsb r0, r0, r3 3000f59c: e5840030 str r0, [r4, #48] ; 0x30 } block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size ); 3000f5a0: e1a02005 mov r2, r5 3000f5a4: e1a03007 mov r3, r7 3000f5a8: e1a00004 mov r0, r4 3000f5ac: ebffef82 bl 3000b3bc <_Heap_Block_allocate> - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000f5b0: e5903004 ldr r3, [r0, #4] 3000f5b4: e3c33001 bic r3, r3, #1 RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 3000f5b8: e2833004 add r3, r3, #4 block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); *new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS; 3000f5bc: e0655003 rsb r5, r5, r3 3000f5c0: e0800005 add r0, r0, r5 3000f5c4: e5860000 str r0, [r6] /* Statistics */ ++stats->resizes; 3000f5c8: e5943054 ldr r3, [r4, #84] ; 0x54 return HEAP_RESIZE_SUCCESSFUL; 3000f5cc: e3a00000 mov r0, #0 block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); *new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS; /* Statistics */ ++stats->resizes; 3000f5d0: e2833001 add r3, r3, #1 3000f5d4: e5843054 str r3, [r4, #84] ; 0x54 3000f5d8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} new_alloc_size, old_size, new_size ); } return HEAP_RESIZE_FATAL_ERROR; 3000f5dc: e3a00002 mov r0, #2 <== NOT EXECUTED } 3000f5e0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED =============================================================================== 3000bea4 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 3000bea4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED uintptr_t const page_size = heap->page_size; 3000bea8: e590c010 ldr ip, [r0, #16] <== NOT EXECUTED bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 3000beac: e24dd030 sub sp, sp, #48 ; 0x30 <== NOT EXECUTED uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 3000beb0: e59f34f0 ldr r3, [pc, #1264] ; 3000c3a8 <_Heap_Walk+0x504> <== NOT EXECUTED 3000beb4: e59f84f0 ldr r8, [pc, #1264] ; 3000c3ac <_Heap_Walk+0x508> <== NOT EXECUTED 3000beb8: e31200ff tst r2, #255 ; 0xff <== NOT EXECUTED Heap_Control *heap, int source, bool dump ) { uintptr_t const page_size = heap->page_size; 3000bebc: e58dc020 str ip, [sp, #32] <== NOT EXECUTED uintptr_t const min_block_size = heap->min_block_size; 3000bec0: e590c014 ldr ip, [r0, #20] <== NOT EXECUTED Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 3000bec4: 11a08003 movne r8, r3 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { 3000bec8: e59f34e0 ldr r3, [pc, #1248] ; 3000c3b0 <_Heap_Walk+0x50c> <== NOT EXECUTED int source, bool dump ) { uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; 3000becc: e58dc028 str ip, [sp, #40] ; 0x28 <== NOT EXECUTED Heap_Block *const first_block = heap->first_block; 3000bed0: e590c020 ldr ip, [r0, #32] <== NOT EXECUTED Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; if ( !_System_state_Is_up( _System_state_Get() ) ) { 3000bed4: e5933000 ldr r3, [r3] <== NOT EXECUTED bool dump ) { uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block; 3000bed8: e58dc024 str ip, [sp, #36] ; 0x24 <== NOT EXECUTED Heap_Block *const last_block = heap->last_block; 3000bedc: e590c024 ldr ip, [r0, #36] ; 0x24 <== NOT EXECUTED Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; if ( !_System_state_Is_up( _System_state_Get() ) ) { 3000bee0: e3530003 cmp r3, #3 <== NOT EXECUTED bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 3000bee4: e1a05000 mov r5, r0 <== NOT EXECUTED 3000bee8: e1a04001 mov r4, r1 <== NOT EXECUTED uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; 3000beec: e58dc02c str ip, [sp, #44] ; 0x2c <== NOT EXECUTED Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; if ( !_System_state_Is_up( _System_state_Get() ) ) { 3000bef0: 1a000120 bne 3000c378 <_Heap_Walk+0x4d4> <== NOT EXECUTED Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; (*printer)( 3000bef4: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bef8: e59f24b4 ldr r2, [pc, #1204] ; 3000c3b4 <_Heap_Walk+0x510> <== NOT EXECUTED 3000befc: e58dc000 str ip, [sp] <== NOT EXECUTED 3000bf00: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED 3000bf04: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bf08: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000bf0c: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 3000bf10: e58dc00c str ip, [sp, #12] <== NOT EXECUTED 3000bf14: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED 3000bf18: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3000bf1c: e58dc010 str ip, [sp, #16] <== NOT EXECUTED 3000bf20: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED 3000bf24: e58d3014 str r3, [sp, #20] <== NOT EXECUTED 3000bf28: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3000bf2c: e1a00001 mov r0, r1 <== NOT EXECUTED 3000bf30: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3000bf34: e3a01000 mov r1, #0 <== NOT EXECUTED 3000bf38: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3000bf3c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf40: e12fff18 bx r8 <== NOT EXECUTED heap->area_begin, heap->area_end, first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { 3000bf44: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000bf48: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000bf4c: 1a000006 bne 3000bf6c <_Heap_Walk+0xc8> <== NOT EXECUTED (*printer)( source, true, "page size is zero\n" ); 3000bf50: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bf54: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bf58: e59f2458 ldr r2, [pc, #1112] ; 3000c3b8 <_Heap_Walk+0x514> <== NOT EXECUTED 3000bf5c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf60: e12fff18 bx r8 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 3000bf64: e59d6020 ldr r6, [sp, #32] <== NOT EXECUTED 3000bf68: ea000103 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED (*printer)( source, true, "page size is zero\n" ); return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 3000bf6c: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000bf70: e21c7007 ands r7, ip, #7 <== NOT EXECUTED (*printer)( 3000bf74: 11a00004 movne r0, r4 <== NOT EXECUTED 3000bf78: 13a01001 movne r1, #1 <== NOT EXECUTED 3000bf7c: 159f2438 ldrne r2, [pc, #1080] ; 3000c3bc <_Heap_Walk+0x518><== NOT EXECUTED 3000bf80: 11a0300c movne r3, ip <== NOT EXECUTED 3000bf84: 1a000103 bne 3000c398 <_Heap_Walk+0x4f4> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 3000bf88: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bf8c: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 3000bf90: ebffe43b bl 30005084 <__umodsi3> <== NOT EXECUTED ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 3000bf94: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000bf98: 0a000006 beq 3000bfb8 <_Heap_Walk+0x114> <== NOT EXECUTED (*printer)( 3000bf9c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bfa0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bfa4: e59f2414 ldr r2, [pc, #1044] ; 3000c3c0 <_Heap_Walk+0x51c> <== NOT EXECUTED 3000bfa8: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bfac: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bfb0: e12fff18 bx r8 <== NOT EXECUTED 3000bfb4: ea000025 b 3000c050 <_Heap_Walk+0x1ac> <== NOT EXECUTED 3000bfb8: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bfbc: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 3000bfc0: e28c0008 add r0, ip, #8 <== NOT EXECUTED 3000bfc4: ebffe42e bl 30005084 <__umodsi3> <== NOT EXECUTED ); return false; } if ( 3000bfc8: e2507000 subs r7, r0, #0 <== NOT EXECUTED !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 3000bfcc: 11a00004 movne r0, r4 <== NOT EXECUTED 3000bfd0: 13a01001 movne r1, #1 <== NOT EXECUTED 3000bfd4: 159f23e8 ldrne r2, [pc, #1000] ; 3000c3c4 <_Heap_Walk+0x520><== NOT EXECUTED 3000bfd8: 159d3024 ldrne r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bfdc: 1a000041 bne 3000c0e8 <_Heap_Walk+0x244> <== NOT EXECUTED block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000bfe0: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bfe4: e59c6004 ldr r6, [ip, #4] <== NOT EXECUTED ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 3000bfe8: e2166001 ands r6, r6, #1 <== NOT EXECUTED (*printer)( 3000bfec: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000bff0: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000bff4: 059f23cc ldreq r2, [pc, #972] ; 3000c3c8 <_Heap_Walk+0x524><== NOT EXECUTED 3000bff8: 0a000009 beq 3000c024 <_Heap_Walk+0x180> <== NOT EXECUTED - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000bffc: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED 3000c000: e59ca004 ldr sl, [ip, #4] <== NOT EXECUTED 3000c004: e3caa001 bic sl, sl, #1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 3000c008: e08ca00a add sl, ip, sl <== NOT EXECUTED block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000c00c: e59a6004 ldr r6, [sl, #4] <== NOT EXECUTED ); return false; } if ( _Heap_Is_free( last_block ) ) { 3000c010: e2166001 ands r6, r6, #1 <== NOT EXECUTED 3000c014: 1a000005 bne 3000c030 <_Heap_Walk+0x18c> <== NOT EXECUTED (*printer)( 3000c018: e59f23ac ldr r2, [pc, #940] ; 3000c3cc <_Heap_Walk+0x528> <== NOT EXECUTED 3000c01c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c020: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c024: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c028: e12fff18 bx r8 <== NOT EXECUTED 3000c02c: ea0000d2 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED ); return false; } if ( 3000c030: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c034: e15a000c cmp sl, ip <== NOT EXECUTED 3000c038: 0a000006 beq 3000c058 <_Heap_Walk+0x1b4> <== NOT EXECUTED _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 3000c03c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c040: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c044: e59f2384 ldr r2, [pc, #900] ; 3000c3d0 <_Heap_Walk+0x52c> <== NOT EXECUTED 3000c048: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c04c: e12fff18 bx r8 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 3000c050: e1a06007 mov r6, r7 <== NOT EXECUTED 3000c054: ea0000c8 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 3000c058: e5957010 ldr r7, [r5, #16] <== NOT EXECUTED return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 3000c05c: e5959008 ldr r9, [r5, #8] <== NOT EXECUTED const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); 3000c060: e1a0b005 mov fp, r5 <== NOT EXECUTED 3000c064: ea000032 b 3000c134 <_Heap_Walk+0x290> <== NOT EXECUTED const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 3000c068: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 3000c06c: e1530009 cmp r3, r9 <== NOT EXECUTED 3000c070: 83a06000 movhi r6, #0 <== NOT EXECUTED 3000c074: 8a000003 bhi 3000c088 <_Heap_Walk+0x1e4> <== NOT EXECUTED 3000c078: e5956024 ldr r6, [r5, #36] ; 0x24 <== NOT EXECUTED 3000c07c: e1560009 cmp r6, r9 <== NOT EXECUTED 3000c080: 33a06000 movcc r6, #0 <== NOT EXECUTED 3000c084: 23a06001 movcs r6, #1 <== NOT EXECUTED const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { if ( !_Heap_Is_block_in_heap( heap, free_block ) ) { 3000c088: e21660ff ands r6, r6, #255 ; 0xff <== NOT EXECUTED (*printer)( 3000c08c: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000c090: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000c094: 059f2338 ldreq r2, [pc, #824] ; 3000c3d4 <_Heap_Walk+0x530><== NOT EXECUTED 3000c098: 0a000011 beq 3000c0e4 <_Heap_Walk+0x240> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 3000c09c: e2890008 add r0, r9, #8 <== NOT EXECUTED 3000c0a0: e1a01007 mov r1, r7 <== NOT EXECUTED 3000c0a4: ebffe3f6 bl 30005084 <__umodsi3> <== NOT EXECUTED ); return false; } if ( 3000c0a8: e2506000 subs r6, r0, #0 <== NOT EXECUTED !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 3000c0ac: 11a00004 movne r0, r4 <== NOT EXECUTED 3000c0b0: 13a01001 movne r1, #1 <== NOT EXECUTED 3000c0b4: 159f231c ldrne r2, [pc, #796] ; 3000c3d8 <_Heap_Walk+0x534><== NOT EXECUTED 3000c0b8: 11a03009 movne r3, r9 <== NOT EXECUTED 3000c0bc: 1a0000b5 bne 3000c398 <_Heap_Walk+0x4f4> <== NOT EXECUTED - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000c0c0: e5993004 ldr r3, [r9, #4] <== NOT EXECUTED 3000c0c4: e3c33001 bic r3, r3, #1 <== NOT EXECUTED block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000c0c8: e0893003 add r3, r9, r3 <== NOT EXECUTED 3000c0cc: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED ); return false; } if ( _Heap_Is_used( free_block ) ) { 3000c0d0: e21cc001 ands ip, ip, #1 <== NOT EXECUTED 3000c0d4: 0a000006 beq 3000c0f4 <_Heap_Walk+0x250> <== NOT EXECUTED (*printer)( 3000c0d8: e59f22fc ldr r2, [pc, #764] ; 3000c3dc <_Heap_Walk+0x538> <== NOT EXECUTED 3000c0dc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c0e0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c0e4: e1a03009 mov r3, r9 <== NOT EXECUTED 3000c0e8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c0ec: e12fff18 bx r8 <== NOT EXECUTED 3000c0f0: ea0000a1 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED ); return false; } if ( free_block->prev != prev_block ) { 3000c0f4: e599300c ldr r3, [r9, #12] <== NOT EXECUTED 3000c0f8: e153000b cmp r3, fp <== NOT EXECUTED 3000c0fc: 0a00000a beq 3000c12c <_Heap_Walk+0x288> <== NOT EXECUTED (*printer)( 3000c100: e58d3000 str r3, [sp] <== NOT EXECUTED 3000c104: e58dc01c str ip, [sp, #28] <== NOT EXECUTED 3000c108: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c10c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c110: e59f22c8 ldr r2, [pc, #712] ; 3000c3e0 <_Heap_Walk+0x53c> <== NOT EXECUTED 3000c114: e1a03009 mov r3, r9 <== NOT EXECUTED 3000c118: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c11c: e12fff18 bx r8 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 3000c120: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 3000c124: e1a0600c mov r6, ip <== NOT EXECUTED 3000c128: ea000093 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED return false; } prev_block = free_block; free_block = free_block->next; 3000c12c: e1a0b009 mov fp, r9 <== NOT EXECUTED 3000c130: e5999008 ldr r9, [r9, #8] <== NOT EXECUTED const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); const Heap_Block *prev_block = free_list_tail; const Heap_Block *free_block = first_free_block; while ( free_block != free_list_tail ) { 3000c134: e1590005 cmp r9, r5 <== NOT EXECUTED 3000c138: 1affffca bne 3000c068 <_Heap_Walk+0x1c4> <== NOT EXECUTED 3000c13c: ea000000 b 3000c144 <_Heap_Walk+0x2a0> <== NOT EXECUTED block->prev_size ); } block = next_block; } while ( block != first_block ); 3000c140: e1a0a009 mov sl, r9 <== NOT EXECUTED - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000c144: e59a6004 ldr r6, [sl, #4] <== NOT EXECUTED const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 3000c148: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED - HEAP_BLOCK_HEADER_SIZE); } RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 3000c14c: e3c6b001 bic fp, r6, #1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 3000c150: e08a900b add r9, sl, fp <== NOT EXECUTED const Heap_Control *heap, const Heap_Block *block ) { return (uintptr_t) block >= (uintptr_t) heap->first_block && (uintptr_t) block <= (uintptr_t) heap->last_block; 3000c154: e1530009 cmp r3, r9 <== NOT EXECUTED 3000c158: 83a03000 movhi r3, #0 <== NOT EXECUTED 3000c15c: 8a000003 bhi 3000c170 <_Heap_Walk+0x2cc> <== NOT EXECUTED 3000c160: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED 3000c164: e1530009 cmp r3, r9 <== NOT EXECUTED 3000c168: 33a03000 movcc r3, #0 <== NOT EXECUTED 3000c16c: 23a03001 movcs r3, #1 <== NOT EXECUTED bool const prev_used = _Heap_Is_prev_used( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); uintptr_t const next_block_begin = (uintptr_t) next_block; bool const is_not_last_block = block != last_block; if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 3000c170: e21330ff ands r3, r3, #255 ; 0xff <== NOT EXECUTED 3000c174: 1a000008 bne 3000c19c <_Heap_Walk+0x2f8> <== NOT EXECUTED 3000c178: e1a06003 mov r6, r3 <== NOT EXECUTED (*printer)( 3000c17c: e58d9000 str r9, [sp] <== NOT EXECUTED 3000c180: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c184: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c188: e59f2254 ldr r2, [pc, #596] ; 3000c3e4 <_Heap_Walk+0x540> <== NOT EXECUTED 3000c18c: e1a0300a mov r3, sl <== NOT EXECUTED 3000c190: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c194: e12fff18 bx r8 <== NOT EXECUTED "block 0x%08x: next block 0x%08x not in heap\n", block, next_block ); return false; 3000c198: ea000077 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED uintptr_t const block_begin = (uintptr_t) block; uintptr_t const block_size = _Heap_Block_size( block ); bool const prev_used = _Heap_Is_prev_used( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); uintptr_t const next_block_begin = (uintptr_t) next_block; bool const is_not_last_block = block != last_block; 3000c19c: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 3000c1a0: e1a0000b mov r0, fp <== NOT EXECUTED 3000c1a4: e05a700c subs r7, sl, ip <== NOT EXECUTED 3000c1a8: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 3000c1ac: 13a07001 movne r7, #1 <== NOT EXECUTED 3000c1b0: ebffe3b3 bl 30005084 <__umodsi3> <== NOT EXECUTED ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 3000c1b4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c1b8: 0a000005 beq 3000c1d4 <_Heap_Walk+0x330> <== NOT EXECUTED 3000c1bc: e3570000 cmp r7, #0 <== NOT EXECUTED (*printer)( 3000c1c0: 158db000 strne fp, [sp] <== NOT EXECUTED 3000c1c4: 11a00004 movne r0, r4 <== NOT EXECUTED 3000c1c8: 13a01001 movne r1, #1 <== NOT EXECUTED 3000c1cc: 159f2214 ldrne r2, [pc, #532] ; 3000c3e8 <_Heap_Walk+0x544><== NOT EXECUTED 3000c1d0: 1a000014 bne 3000c228 <_Heap_Walk+0x384> <== NOT EXECUTED ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 3000c1d4: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 3000c1d8: e15b000c cmp fp, ip <== NOT EXECUTED 3000c1dc: 2a000009 bcs 3000c208 <_Heap_Walk+0x364> <== NOT EXECUTED 3000c1e0: e3570000 cmp r7, #0 <== NOT EXECUTED 3000c1e4: 0a000007 beq 3000c208 <_Heap_Walk+0x364> <== NOT EXECUTED (*printer)( 3000c1e8: e88d1800 stm sp, {fp, ip} <== NOT EXECUTED 3000c1ec: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c1f0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c1f4: e59f21f0 ldr r2, [pc, #496] ; 3000c3ec <_Heap_Walk+0x548> <== NOT EXECUTED 3000c1f8: e1a0300a mov r3, sl <== NOT EXECUTED 3000c1fc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c200: e12fff18 bx r8 <== NOT EXECUTED 3000c204: ea000065 b 3000c3a0 <_Heap_Walk+0x4fc> <== NOT EXECUTED ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 3000c208: e159000a cmp r9, sl <== NOT EXECUTED 3000c20c: 8a000009 bhi 3000c238 <_Heap_Walk+0x394> <== NOT EXECUTED 3000c210: e3570000 cmp r7, #0 <== NOT EXECUTED 3000c214: 0a000007 beq 3000c238 <_Heap_Walk+0x394> <== NOT EXECUTED (*printer)( 3000c218: e59f21d0 ldr r2, [pc, #464] ; 3000c3f0 <_Heap_Walk+0x54c> <== NOT EXECUTED 3000c21c: e58d9000 str r9, [sp] <== NOT EXECUTED 3000c220: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c224: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c228: e1a0300a mov r3, sl <== NOT EXECUTED 3000c22c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c230: e12fff18 bx r8 <== NOT EXECUTED 3000c234: ea000059 b 3000c3a0 <_Heap_Walk+0x4fc> <== NOT EXECUTED block->size_and_flag = size | flag; } RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block ) { return block->size_and_flag & HEAP_PREV_BLOCK_USED; 3000c238: e5993004 ldr r3, [r9, #4] <== NOT EXECUTED 3000c23c: e2066001 and r6, r6, #1 <== NOT EXECUTED ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 3000c240: e3130001 tst r3, #1 <== NOT EXECUTED 3000c244: 1a000036 bne 3000c324 <_Heap_Walk+0x480> <== NOT EXECUTED false, "block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n", block, block_size, block->prev, block->prev == first_free_block ? 3000c248: e59a200c ldr r2, [sl, #12] <== NOT EXECUTED Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 3000c24c: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED return _Heap_Free_list_head(heap)->next; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_last( Heap_Control *heap ) { return _Heap_Free_list_tail(heap)->prev; 3000c250: e595100c ldr r1, [r5, #12] <== NOT EXECUTED 3000c254: e1520003 cmp r2, r3 <== NOT EXECUTED 3000c258: 059f0194 ldreq r0, [pc, #404] ; 3000c3f4 <_Heap_Walk+0x550><== NOT EXECUTED 3000c25c: 0a000003 beq 3000c270 <_Heap_Walk+0x3cc> <== NOT EXECUTED block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 3000c260: e59f3190 ldr r3, [pc, #400] ; 3000c3f8 <_Heap_Walk+0x554> <== NOT EXECUTED 3000c264: e1520005 cmp r2, r5 <== NOT EXECUTED 3000c268: e59f018c ldr r0, [pc, #396] ; 3000c3fc <_Heap_Walk+0x558> <== NOT EXECUTED 3000c26c: 11a00003 movne r0, r3 <== NOT EXECUTED block->next, block->next == last_free_block ? 3000c270: e59a3008 ldr r3, [sl, #8] <== NOT EXECUTED Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 3000c274: e1530001 cmp r3, r1 <== NOT EXECUTED 3000c278: 059f1180 ldreq r1, [pc, #384] ; 3000c400 <_Heap_Walk+0x55c><== NOT EXECUTED 3000c27c: 0a000003 beq 3000c290 <_Heap_Walk+0x3ec> <== NOT EXECUTED " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 3000c280: e59fc17c ldr ip, [pc, #380] ; 3000c404 <_Heap_Walk+0x560> <== NOT EXECUTED 3000c284: e1530005 cmp r3, r5 <== NOT EXECUTED 3000c288: e59f1168 ldr r1, [pc, #360] ; 3000c3f8 <_Heap_Walk+0x554> <== NOT EXECUTED 3000c28c: 01a0100c moveq r1, ip <== NOT EXECUTED Heap_Block *const last_free_block = _Heap_Free_list_last( heap ); bool const prev_used = _Heap_Is_prev_used( block ); uintptr_t const block_size = _Heap_Block_size( block ); Heap_Block *const next_block = _Heap_Block_at( block, block_size ); (*printer)( 3000c290: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000c294: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3000c298: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000c29c: e58d1010 str r1, [sp, #16] <== NOT EXECUTED 3000c2a0: e1a0300a mov r3, sl <== NOT EXECUTED 3000c2a4: e58db000 str fp, [sp] <== NOT EXECUTED 3000c2a8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c2ac: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c2b0: e59f2150 ldr r2, [pc, #336] ; 3000c408 <_Heap_Walk+0x564> <== NOT EXECUTED 3000c2b4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c2b8: e12fff18 bx r8 <== NOT EXECUTED block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { 3000c2bc: e5993000 ldr r3, [r9] <== NOT EXECUTED 3000c2c0: e15b0003 cmp fp, r3 <== NOT EXECUTED 3000c2c4: 0a000008 beq 3000c2ec <_Heap_Walk+0x448> <== NOT EXECUTED (*printer)( 3000c2c8: e98d0208 stmib sp, {r3, r9} <== NOT EXECUTED 3000c2cc: e58db000 str fp, [sp] <== NOT EXECUTED 3000c2d0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c2d4: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c2d8: e59f212c ldr r2, [pc, #300] ; 3000c40c <_Heap_Walk+0x568> <== NOT EXECUTED 3000c2dc: e1a0300a mov r3, sl <== NOT EXECUTED 3000c2e0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c2e4: e12fff18 bx r8 <== NOT EXECUTED 3000c2e8: ea00002c b 3000c3a0 <_Heap_Walk+0x4fc> <== NOT EXECUTED ); return false; } if ( !prev_used ) { 3000c2ec: e3560000 cmp r6, #0 <== NOT EXECUTED (*printer)( 3000c2f0: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000c2f4: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000c2f8: 059f2110 ldreq r2, [pc, #272] ; 3000c410 <_Heap_Walk+0x56c><== NOT EXECUTED 3000c2fc: 01a0300a moveq r3, sl <== NOT EXECUTED 3000c300: 0affff78 beq 3000c0e8 <_Heap_Walk+0x244> <== NOT EXECUTED return &heap->free_list; } RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 3000c304: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000c308: ea000002 b 3000c318 <_Heap_Walk+0x474> <== NOT EXECUTED { const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *free_block = _Heap_Free_list_first( heap ); while ( free_block != free_list_tail ) { if ( free_block == block ) { 3000c30c: e153000a cmp r3, sl <== NOT EXECUTED 3000c310: 0a000015 beq 3000c36c <_Heap_Walk+0x4c8> <== NOT EXECUTED return true; } free_block = free_block->next; 3000c314: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED ) { const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); const Heap_Block *free_block = _Heap_Free_list_first( heap ); while ( free_block != free_list_tail ) { 3000c318: e1530005 cmp r3, r5 <== NOT EXECUTED 3000c31c: 1afffffa bne 3000c30c <_Heap_Walk+0x468> <== NOT EXECUTED 3000c320: ea000018 b 3000c388 <_Heap_Walk+0x4e4> <== NOT EXECUTED if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 3000c324: e3560000 cmp r6, #0 <== NOT EXECUTED (*printer)( 3000c328: e58db000 str fp, [sp] <== NOT EXECUTED if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 3000c32c: 0a000006 beq 3000c34c <_Heap_Walk+0x4a8> <== NOT EXECUTED (*printer)( 3000c330: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c334: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c338: e59f20d4 ldr r2, [pc, #212] ; 3000c414 <_Heap_Walk+0x570> <== NOT EXECUTED 3000c33c: e1a0300a mov r3, sl <== NOT EXECUTED 3000c340: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c344: e12fff18 bx r8 <== NOT EXECUTED 3000c348: ea000007 b 3000c36c <_Heap_Walk+0x4c8> <== NOT EXECUTED "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 3000c34c: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3000c350: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c354: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000c358: e1a01006 mov r1, r6 <== NOT EXECUTED 3000c35c: e59f20b4 ldr r2, [pc, #180] ; 3000c418 <_Heap_Walk+0x574> <== NOT EXECUTED 3000c360: e1a0300a mov r3, sl <== NOT EXECUTED 3000c364: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c368: e12fff18 bx r8 <== NOT EXECUTED block->prev_size ); } block = next_block; } while ( block != first_block ); 3000c36c: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c370: e159000c cmp r9, ip <== NOT EXECUTED 3000c374: 1affff71 bne 3000c140 <_Heap_Walk+0x29c> <== NOT EXECUTED Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; 3000c378: e3a06001 mov r6, #1 <== NOT EXECUTED block = next_block; } while ( block != first_block ); return true; } 3000c37c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000c380: e28dd030 add sp, sp, #48 ; 0x30 <== NOT EXECUTED 3000c384: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 3000c388: e59f208c ldr r2, [pc, #140] ; 3000c41c <_Heap_Walk+0x578> <== NOT EXECUTED 3000c38c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c390: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c394: e1a0300a mov r3, sl <== NOT EXECUTED 3000c398: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c39c: e12fff18 bx r8 <== NOT EXECUTED return false; } if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; 3000c3a0: e3a06000 mov r6, #0 <== NOT EXECUTED 3000c3a4: eafffff4 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED =============================================================================== 3000be60 <_Heap_Walk_print>: static void _Heap_Walk_print( int source, bool error, const char *fmt, ... ) { 3000be60: e92d000c push {r2, r3} <== NOT EXECUTED 3000be64: e92d4001 push {r0, lr} <== NOT EXECUTED 3000be68: e1a03000 mov r3, r0 <== NOT EXECUTED va_list ap; if ( error ) { 3000be6c: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED printk( "FAIL[%d]: ", source ); 3000be70: 159f0024 ldrne r0, [pc, #36] ; 3000be9c <_Heap_Walk_print+0x3c><== NOT EXECUTED } else { printk( "PASS[%d]: ", source ); 3000be74: 059f0024 ldreq r0, [pc, #36] ; 3000bea0 <_Heap_Walk_print+0x40><== NOT EXECUTED 3000be78: e1a01003 mov r1, r3 <== NOT EXECUTED 3000be7c: ebffee89 bl 300078a8 <== NOT EXECUTED } va_start( ap, fmt ); 3000be80: e28d100c add r1, sp, #12 <== NOT EXECUTED vprintk( fmt, ap ); 3000be84: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED printk( "FAIL[%d]: ", source ); } else { printk( "PASS[%d]: ", source ); } va_start( ap, fmt ); 3000be88: e58d1000 str r1, [sp] <== NOT EXECUTED vprintk( fmt, ap ); 3000be8c: ebfff80d bl 30009ec8 <== NOT EXECUTED va_end( ap ); } 3000be90: e8bd4008 pop {r3, lr} <== NOT EXECUTED 3000be94: e28dd008 add sp, sp, #8 <== NOT EXECUTED 3000be98: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000be54 <_Heap_Walk_print_nothing>: int source, bool error, const char *fmt, ... ) { 3000be54: e92d000c push {r2, r3} <== NOT EXECUTED /* Do nothing */ } 3000be58: e28dd008 add sp, sp, #8 <== NOT EXECUTED 3000be5c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b4e8 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 3000b4e8: e92d4007 push {r0, r1, r2, lr} 3000b4ec: e20160ff and r6, r1, #255 ; 0xff 3000b4f0: e1a04000 mov r4, r0 Internal_errors_Source source, bool is_internal, Internal_errors_t error ) { User_extensions_Fatal_context ctx = { source, is_internal, error }; 3000b4f4: e58d0000 str r0, [sp] _User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor ); 3000b4f8: e59f1040 ldr r1, [pc, #64] ; 3000b540 <_Internal_error_Occurred+0x58> 3000b4fc: e1a0000d mov r0, sp 3000b500: e1a05002 mov r5, r2 Internal_errors_Source source, bool is_internal, Internal_errors_t error ) { User_extensions_Fatal_context ctx = { source, is_internal, error }; 3000b504: e58d2008 str r2, [sp, #8] 3000b508: e5cd6004 strb r6, [sp, #4] _User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor ); 3000b50c: eb000755 bl 3000d268 <_User_extensions_Iterate> _User_extensions_Fatal( the_source, is_internal, the_error ); _Internal_errors_What_happened.the_source = the_source; 3000b510: e59f302c ldr r3, [pc, #44] ; 3000b544 <_Internal_error_Occurred+0x5c><== NOT EXECUTED RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 3000b514: e3a02005 mov r2, #5 <== NOT EXECUTED 3000b518: e5834000 str r4, [r3] <== NOT EXECUTED _Internal_errors_What_happened.is_internal = is_internal; 3000b51c: e5c36004 strb r6, [r3, #4] <== NOT EXECUTED _Internal_errors_What_happened.the_error = the_error; 3000b520: e5835008 str r5, [r3, #8] <== NOT EXECUTED 3000b524: e59f301c ldr r3, [pc, #28] ; 3000b548 <_Internal_error_Occurred+0x60><== NOT EXECUTED 3000b528: e5832000 str r2, [r3] <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000b52c: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000b530: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000b534: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 3000b538: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b53c: eafffffe b 3000b53c <_Internal_error_Occurred+0x54> <== NOT EXECUTED =============================================================================== 3000b9f0 <_Objects_Get>: * always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1; 3000b9f0: e5903008 ldr r3, [r0, #8] Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 3000b9f4: e92d4030 push {r4, r5, lr} * always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1; 3000b9f8: e2633001 rsb r3, r3, #1 Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 3000b9fc: e1a04002 mov r4, r2 /* * If the index is less than maximum, then it is OK to use it to * index into the local_table array. */ if ( index <= information->maximum ) { 3000ba00: e1d021b0 ldrh r2, [r0, #16] * always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1; 3000ba04: e0833001 add r3, r3, r1 /* * If the index is less than maximum, then it is OK to use it to * index into the local_table array. */ if ( index <= information->maximum ) { 3000ba08: e1530002 cmp r3, r2 /* * Object Id is not within this API and Class on this node. So * it may be global in a multiprocessing system. But it is clearly * invalid on a single processor system. */ *location = OBJECTS_ERROR; 3000ba0c: 83a03001 movhi r3, #1 3000ba10: 85843000 strhi r3, [r4] #if defined(RTEMS_MULTIPROCESSING) _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; 3000ba14: 83a05000 movhi r5, #0 /* * If the index is less than maximum, then it is OK to use it to * index into the local_table array. */ if ( index <= information->maximum ) { 3000ba18: 8a00000b bhi 3000ba4c <_Objects_Get+0x5c> * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000ba1c: e59f2030 ldr r2, [pc, #48] ; 3000ba54 <_Objects_Get+0x64> 3000ba20: e5921000 ldr r1, [r2] ++level; 3000ba24: e2811001 add r1, r1, #1 _Thread_Dispatch_disable_level = level; 3000ba28: e5821000 str r1, [r2] _Thread_Disable_dispatch(); if ( (the_object = information->local_table[ index ]) != NULL ) { 3000ba2c: e590201c ldr r2, [r0, #28] 3000ba30: e7925103 ldr r5, [r2, r3, lsl #2] 3000ba34: e3550000 cmp r5, #0 *location = OBJECTS_LOCAL; 3000ba38: 13a03000 movne r3, #0 * If the index is less than maximum, then it is OK to use it to * index into the local_table array. */ if ( index <= information->maximum ) { _Thread_Disable_dispatch(); if ( (the_object = information->local_table[ index ]) != NULL ) { 3000ba3c: 1a000001 bne 3000ba48 <_Objects_Get+0x58> /* * Valid Id for this API, Class and Node but the object has not * been allocated yet. */ _Thread_Enable_dispatch(); 3000ba40: eb00036d bl 3000c7fc <_Thread_Enable_dispatch> <== NOT EXECUTED *location = OBJECTS_ERROR; 3000ba44: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ba48: e5843000 str r3, [r4] _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 3000ba4c: e1a00005 mov r0, r5 3000ba50: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000b924 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 3000b924: e1a01801 lsl r1, r1, #16 3000b928: e92d4030 push {r4, r5, lr} Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 3000b92c: e1b05821 lsrs r5, r1, #16 Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 3000b930: e1a04000 mov r4, r0 Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 3000b934: 01a00005 moveq r0, r5 ) { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 3000b938: 08bd8030 popeq {r4, r5, pc} /* * This call implicitly validates the_api so we do not call * _Objects_Is_api_valid above here. */ the_class_api_maximum = _Objects_API_maximum_class( the_api ); 3000b93c: eb000f4e bl 3000f67c <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 3000b940: e3500000 cmp r0, #0 3000b944: 08bd8030 popeq {r4, r5, pc} return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 3000b948: e1550000 cmp r5, r0 3000b94c: 8a00000a bhi 3000b97c <_Objects_Get_information+0x58> return NULL; if ( !_Objects_Information_table[ the_api ] ) 3000b950: e59f302c ldr r3, [pc, #44] ; 3000b984 <_Objects_Get_information+0x60> 3000b954: e7930104 ldr r0, [r3, r4, lsl #2] 3000b958: e3500000 cmp r0, #0 3000b95c: 08bd8030 popeq {r4, r5, pc} return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 3000b960: e7900105 ldr r0, [r0, r5, lsl #2] if ( !info ) 3000b964: e3500000 cmp r0, #0 3000b968: 08bd8030 popeq {r4, r5, pc} * In a multprocessing configuration, we may access remote objects. * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( info->maximum == 0 ) 3000b96c: e1d031b0 ldrh r3, [r0, #16] return NULL; 3000b970: e3530000 cmp r3, #0 3000b974: 03a00000 moveq r0, #0 3000b978: e8bd8030 pop {r4, r5, pc} the_class_api_maximum = _Objects_API_maximum_class( the_api ); if ( the_class_api_maximum == 0 ) return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) return NULL; 3000b97c: e3a00000 mov r0, #0 <== NOT EXECUTED if ( info->maximum == 0 ) return NULL; #endif return info; } 3000b980: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 3000b988 <_Objects_Get_isr_disable>: { Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 3000b988: e590c008 ldr ip, [r0, #8] Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 3000b98c: e92d4010 push {r4, lr} Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 3000b990: e26cc001 rsb ip, ip, #1 3000b994: e08c1001 add r1, ip, r1 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000b998: e10f4000 mrs r4, CPSR 3000b99c: e384c080 orr ip, r4, #128 ; 0x80 3000b9a0: e129f00c msr CPSR_fc, ip _ISR_Disable( level ); if ( information->maximum >= index ) { 3000b9a4: e1d0c1b0 ldrh ip, [r0, #16] 3000b9a8: e15c0001 cmp ip, r1 3000b9ac: 3a00000a bcc 3000b9dc <_Objects_Get_isr_disable+0x54> if ( (the_object = information->local_table[ index ]) != NULL ) { 3000b9b0: e590001c ldr r0, [r0, #28] 3000b9b4: e7900101 ldr r0, [r0, r1, lsl #2] 3000b9b8: e3500000 cmp r0, #0 *location = OBJECTS_LOCAL; 3000b9bc: 13a01000 movne r1, #0 3000b9c0: 15821000 strne r1, [r2] *level_p = level; 3000b9c4: 15834000 strne r4, [r3] index = id - information->minimum_id + 1; _ISR_Disable( level ); if ( information->maximum >= index ) { if ( (the_object = information->local_table[ index ]) != NULL ) { 3000b9c8: 18bd8010 popne {r4, pc} static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000b9cc: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED *location = OBJECTS_LOCAL; *level_p = level; return the_object; } _ISR_Enable( level ); *location = OBJECTS_ERROR; 3000b9d0: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b9d4: e5823000 str r3, [r2] <== NOT EXECUTED return NULL; 3000b9d8: e8bd8010 pop {r4, pc} <== NOT EXECUTED 3000b9dc: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED } _ISR_Enable( level ); *location = OBJECTS_ERROR; 3000b9e0: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b9e4: e5823000 str r3, [r2] <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; 3000b9e8: e3a00000 mov r0, #0 <== NOT EXECUTED #endif } 3000b9ec: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 30015818 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 30015818: e92d4077 push {r0, r1, r2, r4, r5, r6, lr} <== NOT EXECUTED char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 3001581c: e2515000 subs r5, r1, #0 <== NOT EXECUTED char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 30015820: e1a04002 mov r4, r2 <== NOT EXECUTED Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) return NULL; 30015824: 01a04005 moveq r4, r5 <== NOT EXECUTED char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 30015828: 0a00002e beq 300158e8 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED return NULL; if ( name == NULL ) 3001582c: e3540000 cmp r4, #0 <== NOT EXECUTED 30015830: 0a00002c beq 300158e8 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 30015834: e3500000 cmp r0, #0 <== NOT EXECUTED 30015838: 059f30b0 ldreq r3, [pc, #176] ; 300158f0 <_Objects_Get_name_as_string+0xd8><== NOT EXECUTED 3001583c: 11a06000 movne r6, r0 <== NOT EXECUTED 30015840: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED 30015844: 05936008 ldreq r6, [r3, #8] <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 30015848: e1a00006 mov r0, r6 <== NOT EXECUTED 3001584c: ebffe613 bl 3000f0a0 <_Objects_Get_information_id> <== NOT EXECUTED if ( !information ) 30015850: e2503000 subs r3, r0, #0 <== NOT EXECUTED return NULL; 30015854: 01a04003 moveq r4, r3 <== NOT EXECUTED return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; information = _Objects_Get_information_id( tmpId ); if ( !information ) 30015858: 0a000022 beq 300158e8 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, tmpId, &location ); 3001585c: e1a01006 mov r1, r6 <== NOT EXECUTED 30015860: e28d2008 add r2, sp, #8 <== NOT EXECUTED 30015864: ebffe645 bl 3000f180 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 30015868: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3001586c: e3530000 cmp r3, #0 <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* not supported */ #endif case OBJECTS_ERROR: return NULL; 30015870: 13a04000 movne r4, #0 <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); if ( !information ) return NULL; the_object = _Objects_Get( information, tmpId, &location ); switch ( location ) { 30015874: 1a00001b bne 300158e8 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED if ( information->is_string ) { s = the_object->name.name_p; } else #endif { uint32_t u32_name = (uint32_t) the_object->name.name_u32; 30015878: e590200c ldr r2, [r0, #12] <== NOT EXECUTED 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'; 3001587c: e5cd3004 strb r3, [sp, #4] <== NOT EXECUTED } else #endif { uint32_t u32_name = (uint32_t) the_object->name.name_u32; lname[ 0 ] = (u32_name >> 24) & 0xff; 30015880: e1a01c22 lsr r1, r2, #24 <== NOT EXECUTED 30015884: e5cd1000 strb r1, [sp] <== NOT EXECUTED lname[ 1 ] = (u32_name >> 16) & 0xff; 30015888: e1a01822 lsr r1, r2, #16 <== NOT EXECUTED 3001588c: e5cd1001 strb r1, [sp, #1] <== NOT EXECUTED lname[ 2 ] = (u32_name >> 8) & 0xff; 30015890: e1a01422 lsr r1, r2, #8 <== NOT EXECUTED 30015894: e5cd1002 strb r1, [sp, #2] <== NOT EXECUTED lname[ 3 ] = (u32_name >> 0) & 0xff; 30015898: e5cd2003 strb r2, [sp, #3] <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 3001589c: e1a01004 mov r1, r4 <== NOT EXECUTED 300158a0: e2455001 sub r5, r5, #1 <== NOT EXECUTED *d = (isprint((unsigned char)*s)) ? *s : '*'; 300158a4: e59f0048 ldr r0, [pc, #72] ; 300158f4 <_Objects_Get_name_as_string+0xdc><== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 300158a8: ea000006 b 300158c8 <_Objects_Get_name_as_string+0xb0> <== NOT EXECUTED *d = (isprint((unsigned char)*s)) ? *s : '*'; 300158ac: e590c000 ldr ip, [r0] <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 300158b0: e2833001 add r3, r3, #1 <== NOT EXECUTED *d = (isprint((unsigned char)*s)) ? *s : '*'; 300158b4: e08cc002 add ip, ip, r2 <== NOT EXECUTED 300158b8: e5dcc001 ldrb ip, [ip, #1] <== NOT EXECUTED 300158bc: e31c0097 tst ip, #151 ; 0x97 <== NOT EXECUTED 300158c0: 03a0202a moveq r2, #42 ; 0x2a <== NOT EXECUTED 300158c4: e4c12001 strb r2, [r1], #1 <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 300158c8: e1530005 cmp r3, r5 <== NOT EXECUTED 300158cc: 2a000002 bcs 300158dc <_Objects_Get_name_as_string+0xc4> <== NOT EXECUTED 300158d0: e7dd2003 ldrb r2, [sp, r3] <== NOT EXECUTED 300158d4: e3520000 cmp r2, #0 <== NOT EXECUTED 300158d8: 1afffff3 bne 300158ac <_Objects_Get_name_as_string+0x94> <== NOT EXECUTED *d = (isprint((unsigned char)*s)) ? *s : '*'; } } *d = '\0'; 300158dc: e3a03000 mov r3, #0 <== NOT EXECUTED 300158e0: e5c13000 strb r3, [r1] <== NOT EXECUTED _Thread_Enable_dispatch(); 300158e4: ebffe9ca bl 30010014 <_Thread_Enable_dispatch> <== NOT EXECUTED return name; } return NULL; /* unreachable path */ } 300158e8: e1a00004 mov r0, r4 <== NOT EXECUTED 300158ec: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 300179f0 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 300179f0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED Objects_Control *object; Objects_Id next_id; if ( !information ) 300179f4: e2507000 subs r7, r0, #0 <== NOT EXECUTED Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 300179f8: e1a04002 mov r4, r2 <== NOT EXECUTED 300179fc: e1a06003 mov r6, r3 <== NOT EXECUTED Objects_Control *object; Objects_Id next_id; if ( !information ) return NULL; 30017a00: 01a00007 moveq r0, r7 <== NOT EXECUTED ) { Objects_Control *object; Objects_Id next_id; if ( !information ) 30017a04: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED return NULL; if ( !location_p ) 30017a08: e3520000 cmp r2, #0 <== NOT EXECUTED return NULL; 30017a0c: 01a00002 moveq r0, r2 <== NOT EXECUTED Objects_Id next_id; if ( !information ) return NULL; if ( !location_p ) 30017a10: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED return NULL; if ( !next_id_p ) 30017a14: e3530000 cmp r3, #0 <== NOT EXECUTED 30017a18: 0a000016 beq 30017a78 <_Objects_Get_next+0x88> <== NOT EXECUTED return NULL; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 30017a1c: e1b03801 lsls r3, r1, #16 <== NOT EXECUTED next_id = information->minimum_id; 30017a20: 05975008 ldreq r5, [r7, #8] <== NOT EXECUTED else next_id = id; 30017a24: 11a05001 movne r5, r1 <== NOT EXECUTED do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 30017a28: e1d731b0 ldrh r3, [r7, #16] <== NOT EXECUTED 30017a2c: e1a02805 lsl r2, r5, #16 <== NOT EXECUTED 30017a30: e1530822 cmp r3, r2, lsr #16 <== NOT EXECUTED 30017a34: 2a000005 bcs 30017a50 <_Objects_Get_next+0x60> <== NOT EXECUTED { *location_p = OBJECTS_ERROR; 30017a38: e3a03001 mov r3, #1 <== NOT EXECUTED 30017a3c: e5843000 str r3, [r4] <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 30017a40: e3e03000 mvn r3, #0 <== NOT EXECUTED 30017a44: e5863000 str r3, [r6] <== NOT EXECUTED return 0; 30017a48: e3a00000 mov r0, #0 <== NOT EXECUTED 30017a4c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 30017a50: e1a01005 mov r1, r5 <== NOT EXECUTED 30017a54: e1a00007 mov r0, r7 <== NOT EXECUTED 30017a58: e1a02004 mov r2, r4 <== NOT EXECUTED 30017a5c: ebffddc7 bl 3000f180 <_Objects_Get> <== NOT EXECUTED next_id++; } while (*location_p != OBJECTS_LOCAL); 30017a60: e5943000 ldr r3, [r4] <== NOT EXECUTED } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); next_id++; 30017a64: e2855001 add r5, r5, #1 <== NOT EXECUTED } while (*location_p != OBJECTS_LOCAL); 30017a68: e3530000 cmp r3, #0 <== NOT EXECUTED 30017a6c: 1affffed bne 30017a28 <_Objects_Get_next+0x38> <== NOT EXECUTED *next_id_p = next_id; 30017a70: e5865000 str r5, [r6] <== NOT EXECUTED return object; 30017a74: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED if ( !location_p ) return NULL; if ( !next_id_p ) return NULL; 30017a78: e1a00003 mov r0, r3 <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 30017a7c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3000f1e8 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 3000f1e8: e92d4011 push {r0, r4, lr} 3000f1ec: e1a04001 mov r4, r1 /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 3000f1f0: e2501000 subs r1, r0, #0 3000f1f4: 059f306c ldreq r3, [pc, #108] ; 3000f268 <_Objects_Id_to_name+0x80> 3000f1f8: 05933008 ldreq r3, [r3, #8] 3000f1fc: 05931008 ldreq r1, [r3, #8] 3000f200: e1a03c21 lsr r3, r1, #24 3000f204: e2033007 and r3, r3, #7 */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 3000f208: e2432001 sub r2, r3, #1 3000f20c: e3520002 cmp r2, #2 3000f210: 8a00000d bhi 3000f24c <_Objects_Id_to_name+0x64> 3000f214: ea00000e b 3000f254 <_Objects_Id_to_name+0x6c> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 3000f218: e1a02da1 lsr r2, r1, #27 if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 3000f21c: e7930102 ldr r0, [r3, r2, lsl #2] if ( !information ) 3000f220: e3500000 cmp r0, #0 3000f224: 0a000008 beq 3000f24c <_Objects_Id_to_name+0x64> #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 3000f228: e1a0200d mov r2, sp 3000f22c: ebffffd3 bl 3000f180 <_Objects_Get> if ( !the_object ) 3000f230: e3500000 cmp r0, #0 3000f234: 0a000004 beq 3000f24c <_Objects_Id_to_name+0x64> return OBJECTS_INVALID_ID; *name = the_object->name; 3000f238: e590300c ldr r3, [r0, #12] 3000f23c: e5843000 str r3, [r4] _Thread_Enable_dispatch(); 3000f240: eb000373 bl 30010014 <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 3000f244: e3a00000 mov r0, #0 3000f248: ea000000 b 3000f250 <_Objects_Id_to_name+0x68> the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; 3000f24c: e3a00003 mov r0, #3 <== NOT EXECUTED return OBJECTS_INVALID_ID; *name = the_object->name; _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 3000f250: e8bd8018 pop {r3, r4, pc} the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 3000f254: e59f2010 ldr r2, [pc, #16] ; 3000f26c <_Objects_Id_to_name+0x84> 3000f258: e7923103 ldr r3, [r2, r3, lsl #2] 3000f25c: e3530000 cmp r3, #0 3000f260: 1affffec bne 3000f218 <_Objects_Id_to_name+0x30> 3000f264: eafffff8 b 3000f24c <_Objects_Id_to_name+0x64> <== NOT EXECUTED =============================================================================== 3000bb28 <_Objects_Name_to_id_u32>: Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == false */ if ( !id ) 3000bb28: e3530000 cmp r3, #0 Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 3000bb2c: e92d4030 push {r4, r5, lr} #endif /* ASSERT: information->is_string == false */ if ( !id ) return OBJECTS_INVALID_ADDRESS; 3000bb30: 03a00002 moveq r0, #2 Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == false */ if ( !id ) 3000bb34: 08bd8030 popeq {r4, r5, pc} return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 3000bb38: e3510000 cmp r1, #0 3000bb3c: 0a000017 beq 3000bba0 <_Objects_Name_to_id_u32+0x78> return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && 3000bb40: e1d041b0 ldrh r4, [r0, #16] 3000bb44: e3540000 cmp r4, #0 3000bb48: 0a000016 beq 3000bba8 <_Objects_Name_to_id_u32+0x80> 3000bb4c: e3720106 cmn r2, #-2147483647 ; 0x80000001 3000bb50: 13520000 cmpne r2, #0 3000bb54: 03a02001 moveq r2, #1 3000bb58: 0a00000e beq 3000bb98 <_Objects_Name_to_id_u32+0x70> (node == OBJECTS_SEARCH_ALL_NODES || node == OBJECTS_SEARCH_LOCAL_NODE || 3000bb5c: e3520001 cmp r2, #1 <== NOT EXECUTED 3000bb60: 1a00000e bne 3000bba0 <_Objects_Name_to_id_u32+0x78> <== NOT EXECUTED 3000bb64: ea00000b b 3000bb98 <_Objects_Name_to_id_u32+0x70> <== NOT EXECUTED )) search_local_node = true; if ( search_local_node ) { for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; 3000bb68: e590c01c ldr ip, [r0, #28] 3000bb6c: e79cc102 ldr ip, [ip, r2, lsl #2] if ( !the_object ) 3000bb70: e35c0000 cmp ip, #0 3000bb74: 0a000006 beq 3000bb94 <_Objects_Name_to_id_u32+0x6c> continue; if ( name == the_object->name.name_u32 ) { 3000bb78: e59c500c ldr r5, [ip, #12] 3000bb7c: e1510005 cmp r1, r5 3000bb80: 1a000003 bne 3000bb94 <_Objects_Name_to_id_u32+0x6c> *id = the_object->id; 3000bb84: e59c2008 ldr r2, [ip, #8] return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 3000bb88: e3a00000 mov r0, #0 the_object = information->local_table[ index ]; if ( !the_object ) continue; if ( name == the_object->name.name_u32 ) { *id = the_object->id; 3000bb8c: e5832000 str r2, [r3] return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 3000bb90: e8bd8030 pop {r4, r5, pc} _Objects_Is_local_node( node ) )) search_local_node = true; if ( search_local_node ) { for ( index = 1; index <= information->maximum; index++ ) { 3000bb94: e2822001 add r2, r2, #1 3000bb98: e1520004 cmp r2, r4 3000bb9c: 9afffff1 bls 3000bb68 <_Objects_Name_to_id_u32+0x40> if ( !id ) return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) return OBJECTS_INVALID_NAME; 3000bba0: e3a00001 mov r0, #1 <== NOT EXECUTED 3000bba4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED return OBJECTS_INVALID_NAME; name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; 3000bba8: e3a00001 mov r0, #1 #endif } 3000bbac: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000d920 <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 3000d920: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 3000d924: e1a04001 mov r4, r1 <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ); 3000d928: e1d013b8 ldrh r1, [r0, #56] ; 0x38 <== NOT EXECUTED 3000d92c: e1a00002 mov r0, r2 <== NOT EXECUTED bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 3000d930: e1a05002 mov r5, r2 <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ); 3000d934: eb001a53 bl 30014288 <== NOT EXECUTED d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 3000d938: e3500001 cmp r0, #1 <== NOT EXECUTED 3000d93c: 85d53001 ldrbhi r3, [r5, #1] <== NOT EXECUTED 3000d940: e5d52000 ldrb r2, [r5] <== NOT EXECUTED 3000d944: 81a03803 lslhi r3, r3, #16 <== NOT EXECUTED 3000d948: 93a03602 movls r3, #2097152 ; 0x200000 <== NOT EXECUTED 3000d94c: e1a02c02 lsl r2, r2, #24 <== NOT EXECUTED 3000d950: e3500002 cmp r0, #2 <== NOT EXECUTED 3000d954: e1832002 orr r2, r3, r2 <== NOT EXECUTED 3000d958: 85d53002 ldrbhi r3, [r5, #2] <== NOT EXECUTED 3000d95c: 93a03a02 movls r3, #8192 ; 0x2000 <== NOT EXECUTED 3000d960: 81a03403 lslhi r3, r3, #8 <== NOT EXECUTED 3000d964: e3500003 cmp r0, #3 <== NOT EXECUTED 3000d968: e1822003 orr r2, r2, r3 <== NOT EXECUTED 3000d96c: 85d53003 ldrbhi r3, [r5, #3] <== NOT EXECUTED 3000d970: 93a03020 movls r3, #32 <== NOT EXECUTED 3000d974: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000d978: e584300c str r3, [r4, #12] <== NOT EXECUTED ); } return true; } 3000d97c: e3a00001 mov r0, #1 <== NOT EXECUTED 3000d980: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 3000bc8c <_Protected_heap_Extend>: bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, uintptr_t size ) { 3000bc8c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED uintptr_t amount_extended; _RTEMS_Lock_allocator(); 3000bc90: e59f403c ldr r4, [pc, #60] ; 3000bcd4 <_Protected_heap_Extend+0x48><== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, uintptr_t size ) { 3000bc94: e1a05000 mov r5, r0 <== NOT EXECUTED 3000bc98: e1a07001 mov r7, r1 <== NOT EXECUTED 3000bc9c: e1a06002 mov r6, r2 <== NOT EXECUTED uintptr_t amount_extended; _RTEMS_Lock_allocator(); 3000bca0: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000bca4: ebfffbb8 bl 3000ab8c <_API_Mutex_Lock> <== NOT EXECUTED amount_extended = _Heap_Extend( the_heap, starting_address, size, 0 ); 3000bca8: e1a01007 mov r1, r7 <== NOT EXECUTED 3000bcac: e1a02006 mov r2, r6 <== NOT EXECUTED 3000bcb0: e3a03000 mov r3, #0 <== NOT EXECUTED 3000bcb4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bcb8: eb000d9d bl 3000f334 <_Heap_Extend> <== NOT EXECUTED 3000bcbc: e1a05000 mov r5, r0 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 3000bcc0: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000bcc4: ebfffbc9 bl 3000abf0 <_API_Mutex_Unlock> <== NOT EXECUTED return amount_extended != 0; } 3000bcc8: e2950000 adds r0, r5, #0 <== NOT EXECUTED 3000bccc: 13a00001 movne r0, #1 <== NOT EXECUTED 3000bcd0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 30010b50 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 30010b50: e92d4070 push {r4, r5, r6, lr} if ( !the_heap ) 30010b54: e2506000 subs r6, r0, #0 bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 30010b58: e1a05001 mov r5, r1 if ( !the_heap ) return false; 30010b5c: 01a00006 moveq r0, r6 bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { if ( !the_heap ) 30010b60: 08bd8070 popeq {r4, r5, r6, pc} return false; if ( !the_info ) 30010b64: e3510000 cmp r1, #0 30010b68: 0a000009 beq 30010b94 <_Protected_heap_Get_information+0x44> return false; _RTEMS_Lock_allocator(); 30010b6c: e59f4028 ldr r4, [pc, #40] ; 30010b9c <_Protected_heap_Get_information+0x4c> 30010b70: e5940000 ldr r0, [r4] 30010b74: ebfff838 bl 3000ec5c <_API_Mutex_Lock> _Heap_Get_information( the_heap, the_info ); 30010b78: e1a00006 mov r0, r6 30010b7c: e1a01005 mov r1, r5 30010b80: eb000e14 bl 300143d8 <_Heap_Get_information> _RTEMS_Unlock_allocator(); 30010b84: e5940000 ldr r0, [r4] 30010b88: ebfff84c bl 3000ecc0 <_API_Mutex_Unlock> return true; 30010b8c: e3a00001 mov r0, #1 30010b90: e8bd8070 pop {r4, r5, r6, pc} { if ( !the_heap ) return false; if ( !the_info ) return false; 30010b94: e1a00001 mov r0, r1 <== NOT EXECUTED _RTEMS_Lock_allocator(); _Heap_Get_information( the_heap, the_info ); _RTEMS_Unlock_allocator(); return true; } 30010b98: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 30010bfc <_Protected_heap_Walk>: * This routine returns true if thread dispatch indicates * that we are in a critical section. */ RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void) { if ( _Thread_Dispatch_disable_level == 0 ) 30010bfc: e59f3054 ldr r3, [pc, #84] ; 30010c58 <_Protected_heap_Walk+0x5c><== NOT EXECUTED bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 30010c00: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED 30010c04: e5933000 ldr r3, [r3] <== NOT EXECUTED 30010c08: e1a06000 mov r6, r0 <== NOT EXECUTED 30010c0c: e3530000 cmp r3, #0 <== NOT EXECUTED 30010c10: e1a05001 mov r5, r1 <== NOT EXECUTED 30010c14: e20270ff and r7, r2, #255 ; 0xff <== NOT EXECUTED 30010c18: 1a00000b bne 30010c4c <_Protected_heap_Walk+0x50> <== NOT EXECUTED * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( _Thread_Dispatch_in_critical_section() == false ) { _RTEMS_Lock_allocator(); 30010c1c: e59f4038 ldr r4, [pc, #56] ; 30010c5c <_Protected_heap_Walk+0x60><== NOT EXECUTED 30010c20: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010c24: ebfff80c bl 3000ec5c <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Walk( the_heap, source, do_dump ); 30010c28: e1a01005 mov r1, r5 <== NOT EXECUTED 30010c2c: e1a02007 mov r2, r7 <== NOT EXECUTED 30010c30: e1a00006 mov r0, r6 <== NOT EXECUTED 30010c34: ebfffc31 bl 3000fd00 <_Heap_Walk> <== NOT EXECUTED 30010c38: e1a05000 mov r5, r0 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 30010c3c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010c40: ebfff81e bl 3000ecc0 <_API_Mutex_Unlock> <== NOT EXECUTED } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 30010c44: e1a00005 mov r0, r5 <== NOT EXECUTED 30010c48: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED if ( _Thread_Dispatch_in_critical_section() == false ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 30010c4c: e1a02007 mov r2, r7 <== NOT EXECUTED } return status; } 30010c50: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED if ( _Thread_Dispatch_in_critical_section() == false ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 30010c54: eafffc29 b 3000fd00 <_Heap_Walk> <== NOT EXECUTED =============================================================================== 3000ce88 <_RBTree_Iterate_unprotected>: RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First( const RBTree_Control *the_rbtree, RBTree_Direction dir ) { return the_rbtree->first[dir]; 3000ce88: e3510000 cmp r1, #0 <== NOT EXECUTED const RBTree_Control *rbtree, RBTree_Direction dir, RBTree_Visitor visitor, void *visitor_arg ) { 3000ce8c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED 3000ce90: e1a07003 mov r7, r3 <== NOT EXECUTED 3000ce94: 13a03002 movne r3, #2 <== NOT EXECUTED 3000ce98: 03a03003 moveq r3, #3 <== NOT EXECUTED 3000ce9c: e1a04002 mov r4, r2 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 3000cea0: e1a06001 mov r6, r1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First( const RBTree_Control *the_rbtree, RBTree_Direction dir ) { return the_rbtree->first[dir]; 3000cea4: e7905103 ldr r5, [r0, r3, lsl #2] <== NOT EXECUTED 3000cea8: ea00000b b 3000cedc <_RBTree_Iterate_unprotected+0x54> <== NOT EXECUTED RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; while ( !stop && current != NULL ) { stop = (*visitor)( current, dir, visitor_arg ); 3000ceac: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ceb0: e1a01006 mov r1, r6 <== NOT EXECUTED 3000ceb4: e1a02007 mov r2, r7 <== NOT EXECUTED 3000ceb8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000cebc: e12fff14 bx r4 <== NOT EXECUTED current = _RBTree_Next_unprotected( current, dir ); 3000cec0: e1a01006 mov r1, r6 <== NOT EXECUTED RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; while ( !stop && current != NULL ) { stop = (*visitor)( current, dir, visitor_arg ); 3000cec4: e1a08000 mov r8, r0 <== NOT EXECUTED current = _RBTree_Next_unprotected( current, dir ); 3000cec8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000cecc: eb000005 bl 3000cee8 <_RBTree_Next_unprotected> <== NOT EXECUTED { RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; while ( !stop && current != NULL ) { 3000ced0: e3580000 cmp r8, #0 <== NOT EXECUTED stop = (*visitor)( current, dir, visitor_arg ); current = _RBTree_Next_unprotected( current, dir ); 3000ced4: e1a05000 mov r5, r0 <== NOT EXECUTED { RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); const RBTree_Node *current = _RBTree_First( rbtree, opp_dir ); bool stop = false; while ( !stop && current != NULL ) { 3000ced8: 18bd81f0 popne {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED 3000cedc: e3550000 cmp r5, #0 <== NOT EXECUTED 3000cee0: 1afffff1 bne 3000ceac <_RBTree_Iterate_unprotected+0x24> <== NOT EXECUTED 3000cee4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 3000cee8 <_RBTree_Next_unprotected>: const RBTree_Node *node, RBTree_Direction dir ) { RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); RBTree_Node *current = node->child [dir]; 3000cee8: e2813001 add r3, r1, #1 3000ceec: e7903103 ldr r3, [r0, r3, lsl #2] */ RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction( RBTree_Direction the_dir ) { return (RBTree_Direction) !((int) the_dir); 3000cef0: e2712001 rsbs r2, r1, #1 3000cef4: 33a02000 movcc r2, #0 RBTree_Node *next = NULL; if ( current != NULL ) { 3000cef8: e3530000 cmp r3, #0 3000cefc: 1a000001 bne 3000cf08 <_RBTree_Next_unprotected+0x20> 3000cf00: ea000005 b 3000cf1c <_RBTree_Next_unprotected+0x34> next = current; while ( (current = current->child [opp_dir]) != NULL ) { 3000cf04: e1a03001 mov r3, r1 <== NOT EXECUTED 3000cf08: e2821001 add r1, r2, #1 3000cf0c: e7931101 ldr r1, [r3, r1, lsl #2] 3000cf10: e3510000 cmp r1, #0 3000cf14: 1afffffa bne 3000cf04 <_RBTree_Next_unprotected+0x1c> 3000cf18: ea000013 b 3000cf6c <_RBTree_Next_unprotected+0x84> next = current; } } else { RBTree_Node *parent = node->parent; 3000cf1c: e5903000 ldr r3, [r0] if ( parent->parent && node == parent->child [opp_dir] ) { 3000cf20: e593c000 ldr ip, [r3] 3000cf24: e35c0000 cmp ip, #0 3000cf28: 0a000006 beq 3000cf48 <_RBTree_Next_unprotected+0x60> 3000cf2c: e2822001 add r2, r2, #1 3000cf30: e7932102 ldr r2, [r3, r2, lsl #2] 3000cf34: e1500002 cmp r0, r2 3000cf38: 1a000002 bne 3000cf48 <_RBTree_Next_unprotected+0x60> 3000cf3c: ea00000a b 3000cf6c <_RBTree_Next_unprotected+0x84> next = parent; } else { while ( parent->parent && node == parent->child [dir] ) { 3000cf40: e1a00003 mov r0, r3 3000cf44: e1a03002 mov r3, r2 3000cf48: e5932000 ldr r2, [r3] 3000cf4c: e3520000 cmp r2, #0 3000cf50: 0a000004 beq 3000cf68 <_RBTree_Next_unprotected+0x80> 3000cf54: e281c001 add ip, r1, #1 3000cf58: e793c10c ldr ip, [r3, ip, lsl #2] 3000cf5c: e150000c cmp r0, ip 3000cf60: 0afffff6 beq 3000cf40 <_RBTree_Next_unprotected+0x58> 3000cf64: ea000000 b 3000cf6c <_RBTree_Next_unprotected+0x84> RBTree_Direction dir ) { RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir ); RBTree_Node *current = node->child [dir]; RBTree_Node *next = NULL; 3000cf68: e1a03002 mov r3, r2 } } } return next; } 3000cf6c: e1a00003 mov r0, r3 3000cf70: e12fff1e bx lr =============================================================================== 3000c8bc <_RBTree_Sibling>: */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; 3000c8bc: e2502000 subs r2, r0, #0 3000c8c0: 01a00002 moveq r0, r2 3000c8c4: 012fff1e bxeq lr if(!(the_node->parent)) return NULL; 3000c8c8: e5923000 ldr r3, [r2] 3000c8cc: e3530000 cmp r3, #0 3000c8d0: 0a000006 beq 3000c8f0 <_RBTree_Sibling+0x34> if(!(the_node->parent->parent)) return NULL; 3000c8d4: e5930000 ldr r0, [r3] 3000c8d8: e3500000 cmp r0, #0 3000c8dc: 012fff1e bxeq lr if(the_node == the_node->parent->child[RBT_LEFT]) 3000c8e0: e5930004 ldr r0, [r3, #4] 3000c8e4: e1520000 cmp r2, r0 return the_node->parent->child[RBT_RIGHT]; 3000c8e8: 05930008 ldreq r0, [r3, #8] 3000c8ec: e12fff1e bx lr RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL; if(!(the_node->parent)) return NULL; 3000c8f0: e1a00003 mov r0, r3 <== NOT EXECUTED if(the_node == the_node->parent->child[RBT_LEFT]) return the_node->parent->child[RBT_RIGHT]; else return the_node->parent->child[RBT_LEFT]; } 3000c8f4: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000ed94 <_RTEMS_tasks_Delete_extension>: /* * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; 3000ed94: e3a03000 mov r3, #0 static void _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 3000ed98: e92d4070 push {r4, r5, r6, lr} /* * Free per task variable memory */ tvp = deleted->task_variables; 3000ed9c: e59160f8 ldr r6, [r1, #248] ; 0xf8 static void _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 3000eda0: e1a04001 mov r4, r1 /* * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; 3000eda4: e58130f8 str r3, [r1, #248] ; 0xf8 while (tvp) { 3000eda8: ea000004 b 3000edc0 <_RTEMS_tasks_Delete_extension+0x2c> next = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 3000edac: e1a01006 mov r1, r6 <== NOT EXECUTED 3000edb0: e1a00004 mov r0, r4 <== NOT EXECUTED */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { next = (rtems_task_variable_t *)tvp->next; 3000edb4: e5965000 ldr r5, [r6] <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 3000edb8: eb00003d bl 3000eeb4 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED tvp = next; 3000edbc: e1a06005 mov r6, r5 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 3000edc0: e3560000 cmp r6, #0 3000edc4: 1afffff8 bne 3000edac <_RTEMS_tasks_Delete_extension+0x18> /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 3000edc8: e59400ec ldr r0, [r4, #236] ; 0xec 3000edcc: ebfffa4e bl 3000d70c <_Workspace_Free> deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 3000edd0: e58460ec str r6, [r4, #236] ; 0xec } 3000edd4: e8bd8070 pop {r4, r5, r6, pc} =============================================================================== 3000ed1c <_RTEMS_tasks_Switch_extension>: /* * Per Task Variables */ tvp = executing->task_variables; 3000ed1c: e59030f8 ldr r3, [r0, #248] ; 0xf8 while (tvp) { 3000ed20: ea000005 b 3000ed3c <_RTEMS_tasks_Switch_extension+0x20> tvp->tval = *tvp->ptr; 3000ed24: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000ed28: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000ed2c: e583000c str r0, [r3, #12] <== NOT EXECUTED *tvp->ptr = tvp->gval; 3000ed30: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 3000ed34: e5820000 str r0, [r2] <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 3000ed38: e5933000 ldr r3, [r3] <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 3000ed3c: e3530000 cmp r3, #0 3000ed40: 1afffff7 bne 3000ed24 <_RTEMS_tasks_Switch_extension+0x8> tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 3000ed44: e59130f8 ldr r3, [r1, #248] ; 0xf8 while (tvp) { 3000ed48: ea000005 b 3000ed64 <_RTEMS_tasks_Switch_extension+0x48> tvp->gval = *tvp->ptr; 3000ed4c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000ed50: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000ed54: e5831008 str r1, [r3, #8] <== NOT EXECUTED *tvp->ptr = tvp->tval; 3000ed58: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3000ed5c: e5821000 str r1, [r2] <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 3000ed60: e5933000 ldr r3, [r3] <== NOT EXECUTED *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 3000ed64: e3530000 cmp r3, #0 3000ed68: 1afffff7 bne 3000ed4c <_RTEMS_tasks_Switch_extension+0x30> tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 3000ed6c: e12fff1e bx lr =============================================================================== 30031b20 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 30031b20: e92d4011 push {r0, r4, lr} <== NOT EXECUTED 30031b24: e1a01000 mov r1, r0 <== NOT EXECUTED 30031b28: e1a0200d mov r2, sp <== NOT EXECUTED 30031b2c: e59f0088 ldr r0, [pc, #136] ; 30031bbc <_Rate_monotonic_Timeout+0x9c><== NOT EXECUTED 30031b30: ebff69c3 bl 3000c244 <_Objects_Get> <== NOT EXECUTED /* * 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 ) { 30031b34: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30031b38: e1a04000 mov r4, r0 <== NOT EXECUTED 30031b3c: e3530000 cmp r3, #0 <== NOT EXECUTED 30031b40: 1a00001c bne 30031bb8 <_Rate_monotonic_Timeout+0x98> <== NOT EXECUTED case OBJECTS_LOCAL: the_thread = the_period->owner; 30031b44: e5900040 ldr r0, [r0, #64] ; 0x40 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period ( States_Control the_states ) { return (the_states & STATES_WAITING_FOR_PERIOD); 30031b48: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED if ( _States_Is_waiting_for_period( the_thread->current_state ) && 30031b4c: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 30031b50: 0a000006 beq 30031b70 <_Rate_monotonic_Timeout+0x50> <== NOT EXECUTED 30031b54: e5902020 ldr r2, [r0, #32] <== NOT EXECUTED 30031b58: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30031b5c: e1520003 cmp r2, r3 <== NOT EXECUTED 30031b60: 1a000002 bne 30031b70 <_Rate_monotonic_Timeout+0x50> <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 30031b64: e59f1054 ldr r1, [pc, #84] ; 30031bc0 <_Rate_monotonic_Timeout+0xa0><== NOT EXECUTED 30031b68: ebff6c3b bl 3000cc5c <_Thread_Clear_state> <== NOT EXECUTED 30031b6c: ea000006 b 30031b8c <_Rate_monotonic_Timeout+0x6c> <== NOT EXECUTED _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 30031b70: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 30031b74: e3530001 cmp r3, #1 <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 30031b78: 13a03004 movne r3, #4 <== NOT EXECUTED 30031b7c: 15843038 strne r3, [r4, #56] ; 0x38 <== NOT EXECUTED _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 30031b80: 1a000008 bne 30031ba8 <_Rate_monotonic_Timeout+0x88> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 30031b84: e3a03003 mov r3, #3 <== NOT EXECUTED 30031b88: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); 30031b8c: e1a00004 mov r0, r4 <== NOT EXECUTED 30031b90: ebffff55 bl 300318ec <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 30031b94: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 30031b98: e59f0024 ldr r0, [pc, #36] ; 30031bc4 <_Rate_monotonic_Timeout+0xa4><== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 30031b9c: e584301c str r3, [r4, #28] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 30031ba0: e2841010 add r1, r4, #16 <== NOT EXECUTED 30031ba4: ebff6fe4 bl 3000db3c <_Watchdog_Insert> <== NOT EXECUTED * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 30031ba8: e59f3018 ldr r3, [pc, #24] ; 30031bc8 <_Rate_monotonic_Timeout+0xa8><== NOT EXECUTED 30031bac: e5932000 ldr r2, [r3] <== NOT EXECUTED --level; 30031bb0: e2422001 sub r2, r2, #1 <== NOT EXECUTED _Thread_Dispatch_disable_level = level; 30031bb4: e5832000 str r2, [r3] <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 30031bb8: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED =============================================================================== 3000d554 <_Scheduler_CBS_Attach_thread>: { Objects_Locations location; Thread_Control *the_thread; Scheduler_CBS_Per_thread *sched_info; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d554: e59f3094 ldr r3, [pc, #148] ; 3000d5f0 <_Scheduler_CBS_Attach_thread+0x9c><== NOT EXECUTED int _Scheduler_CBS_Attach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) { 3000d558: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED Objects_Locations location; Thread_Control *the_thread; Scheduler_CBS_Per_thread *sched_info; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d55c: e5933000 ldr r3, [r3] <== NOT EXECUTED int _Scheduler_CBS_Attach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) { 3000d560: e1a05000 mov r5, r0 <== NOT EXECUTED Objects_Locations location; Thread_Control *the_thread; Scheduler_CBS_Per_thread *sched_info; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d564: e1500003 cmp r0, r3 <== NOT EXECUTED int _Scheduler_CBS_Attach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) { 3000d568: e1a04001 mov r4, r1 <== NOT EXECUTED Objects_Locations location; Thread_Control *the_thread; Scheduler_CBS_Per_thread *sched_info; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d56c: 2a00001b bcs 3000d5e0 <_Scheduler_CBS_Attach_thread+0x8c> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; the_thread = _Thread_Get(task_id, &location); 3000d570: e1a00001 mov r0, r1 <== NOT EXECUTED 3000d574: e1a0100d mov r1, sp <== NOT EXECUTED 3000d578: eb0003b5 bl 3000e454 <_Thread_Get> <== NOT EXECUTED /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) 3000d57c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000d580: 0a000016 beq 3000d5e0 <_Scheduler_CBS_Attach_thread+0x8c> <== NOT EXECUTED _Thread_Enable_dispatch(); 3000d584: eb0003aa bl 3000e434 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !the_thread ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; 3000d588: e5962088 ldr r2, [r6, #136] ; 0x88 <== NOT EXECUTED /* Thread is already attached to a server. */ if ( sched_info->cbs_server ) 3000d58c: e5920018 ldr r0, [r2, #24] <== NOT EXECUTED 3000d590: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d594: 1a000013 bne 3000d5e8 <_Scheduler_CBS_Attach_thread+0x94> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_FULL; /* Server is not valid. */ if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d598: e59f3054 ldr r3, [pc, #84] ; 3000d5f4 <_Scheduler_CBS_Attach_thread+0xa0><== NOT EXECUTED 3000d59c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d5a0: e7933105 ldr r3, [r3, r5, lsl #2] <== NOT EXECUTED 3000d5a4: e3530000 cmp r3, #0 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; 3000d5a8: 03e00018 mvneq r0, #24 <== NOT EXECUTED /* Thread is already attached to a server. */ if ( sched_info->cbs_server ) return SCHEDULER_CBS_ERROR_FULL; /* Server is not valid. */ if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d5ac: 0a00000e beq 3000d5ec <_Scheduler_CBS_Attach_thread+0x98> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; /* Server is already attached to a thread. */ if ( _Scheduler_CBS_Server_list[server_id]->task_id != -1 ) 3000d5b0: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000d5b4: e3710001 cmn r1, #1 <== NOT EXECUTED 3000d5b8: 1a00000a bne 3000d5e8 <_Scheduler_CBS_Attach_thread+0x94> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_FULL; _Scheduler_CBS_Server_list[server_id]->task_id = task_id; 3000d5bc: e5834000 str r4, [r3] <== NOT EXECUTED sched_info->cbs_server = (void *) _Scheduler_CBS_Server_list[server_id]; 3000d5c0: e5823018 str r3, [r2, #24] <== NOT EXECUTED the_thread->budget_callout = _Scheduler_CBS_Budget_callout; 3000d5c4: e59f302c ldr r3, [pc, #44] ; 3000d5f8 <_Scheduler_CBS_Attach_thread+0xa4><== NOT EXECUTED 3000d5c8: e586307c str r3, [r6, #124] ; 0x7c <== NOT EXECUTED the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 3000d5cc: e3a03002 mov r3, #2 <== NOT EXECUTED 3000d5d0: e5863078 str r3, [r6, #120] ; 0x78 <== NOT EXECUTED the_thread->is_preemptible = true; 3000d5d4: e3a03001 mov r3, #1 <== NOT EXECUTED 3000d5d8: e5c63070 strb r3, [r6, #112] ; 0x70 <== NOT EXECUTED return SCHEDULER_CBS_OK; 3000d5dc: ea000002 b 3000d5ec <_Scheduler_CBS_Attach_thread+0x98> <== NOT EXECUTED the_thread = _Thread_Get(task_id, &location); /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) _Thread_Enable_dispatch(); if ( !the_thread ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 3000d5e0: e3e00011 mvn r0, #17 <== NOT EXECUTED 3000d5e4: ea000000 b 3000d5ec <_Scheduler_CBS_Attach_thread+0x98> <== NOT EXECUTED if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; /* Server is already attached to a thread. */ if ( _Scheduler_CBS_Server_list[server_id]->task_id != -1 ) return SCHEDULER_CBS_ERROR_FULL; 3000d5e8: e3e00019 mvn r0, #25 <== NOT EXECUTED the_thread->budget_callout = _Scheduler_CBS_Budget_callout; the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; the_thread->is_preemptible = true; return SCHEDULER_CBS_OK; } 3000d5ec: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000da20 <_Scheduler_CBS_Budget_callout>: Priority_Control new_priority; Scheduler_CBS_Per_thread *sched_info; Scheduler_CBS_Server_id server_id; /* Put violating task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; 3000da20: e59010ac ldr r1, [r0, #172] ; 0xac <== NOT EXECUTED if ( the_thread->real_priority != new_priority ) 3000da24: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED Scheduler_CBS_Server **_Scheduler_CBS_Server_list; void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) { 3000da28: e92d4011 push {r0, r4, lr} <== NOT EXECUTED Scheduler_CBS_Per_thread *sched_info; Scheduler_CBS_Server_id server_id; /* Put violating task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; if ( the_thread->real_priority != new_priority ) 3000da2c: e1530001 cmp r3, r1 <== NOT EXECUTED the_thread->real_priority = new_priority; if ( the_thread->current_priority != new_priority ) 3000da30: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED Scheduler_CBS_Server_id server_id; /* Put violating task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; if ( the_thread->real_priority != new_priority ) the_thread->real_priority = new_priority; 3000da34: 15801018 strne r1, [r0, #24] <== NOT EXECUTED if ( the_thread->current_priority != new_priority ) 3000da38: e1530001 cmp r3, r1 <== NOT EXECUTED Scheduler_CBS_Server **_Scheduler_CBS_Server_list; void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) { 3000da3c: e1a04000 mov r4, r0 <== NOT EXECUTED /* Put violating task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; if ( the_thread->real_priority != new_priority ) the_thread->real_priority = new_priority; if ( the_thread->current_priority != new_priority ) _Thread_Change_priority(the_thread, new_priority, true); 3000da40: 13a02001 movne r2, #1 <== NOT EXECUTED 3000da44: 1b000161 blne 3000dfd0 <_Thread_Change_priority> <== NOT EXECUTED /* Invoke callback function if any. */ sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; 3000da48: e5944088 ldr r4, [r4, #136] ; 0x88 <== NOT EXECUTED if ( sched_info->cbs_server->cbs_budget_overrun ) { 3000da4c: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED 3000da50: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 3000da54: e3520000 cmp r2, #0 <== NOT EXECUTED 3000da58: 0a000006 beq 3000da78 <_Scheduler_CBS_Budget_callout+0x58> <== NOT EXECUTED _Scheduler_CBS_Get_server_id( 3000da5c: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000da60: e1a0100d mov r1, sp <== NOT EXECUTED 3000da64: ebffffd6 bl 3000d9c4 <_Scheduler_CBS_Get_server_id> <== NOT EXECUTED sched_info->cbs_server->task_id, &server_id ); sched_info->cbs_server->cbs_budget_overrun( server_id ); 3000da68: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED 3000da6c: e59d0000 ldr r0, [sp] <== NOT EXECUTED 3000da70: e1a0e00f mov lr, pc <== NOT EXECUTED 3000da74: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED } } 3000da78: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED =============================================================================== 3000d5fc <_Scheduler_CBS_Cleanup>: #include #include #include int _Scheduler_CBS_Cleanup (void) { 3000d5fc: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 3000d600: e3a04000 mov r4, #0 <== NOT EXECUTED 3000d604: e59f603c ldr r6, [pc, #60] ; 3000d648 <_Scheduler_CBS_Cleanup+0x4c><== NOT EXECUTED 3000d608: e59f503c ldr r5, [pc, #60] ; 3000d64c <_Scheduler_CBS_Cleanup+0x50><== NOT EXECUTED 3000d60c: ea000005 b 3000d628 <_Scheduler_CBS_Cleanup+0x2c> <== NOT EXECUTED if ( _Scheduler_CBS_Server_list[ i ] ) 3000d610: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d614: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d618: e3530000 cmp r3, #0 <== NOT EXECUTED _Scheduler_CBS_Destroy_server( i ); 3000d61c: 11a00004 movne r0, r4 <== NOT EXECUTED 3000d620: 1b00003b blne 3000d714 <_Scheduler_CBS_Destroy_server> <== NOT EXECUTED int _Scheduler_CBS_Cleanup (void) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 3000d624: e2844001 add r4, r4, #1 <== NOT EXECUTED 3000d628: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000d62c: e1540003 cmp r4, r3 <== NOT EXECUTED 3000d630: 3afffff6 bcc 3000d610 <_Scheduler_CBS_Cleanup+0x14> <== NOT EXECUTED if ( _Scheduler_CBS_Server_list[ i ] ) _Scheduler_CBS_Destroy_server( i ); } _Workspace_Free( _Scheduler_CBS_Server_list ); 3000d634: e59f3010 ldr r3, [pc, #16] ; 3000d64c <_Scheduler_CBS_Cleanup+0x50><== NOT EXECUTED 3000d638: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000d63c: eb000740 bl 3000f344 <_Workspace_Free> <== NOT EXECUTED return SCHEDULER_CBS_OK; } 3000d640: e3a00000 mov r0, #0 <== NOT EXECUTED 3000d644: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000d650 <_Scheduler_CBS_Create_server>: ) { unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 3000d650: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED int _Scheduler_CBS_Create_server ( Scheduler_CBS_Parameters *params, Scheduler_CBS_Budget_overrun budget_overrun_callback, rtems_id *server_id ) { 3000d654: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 3000d658: e3530000 cmp r3, #0 <== NOT EXECUTED int _Scheduler_CBS_Create_server ( Scheduler_CBS_Parameters *params, Scheduler_CBS_Budget_overrun budget_overrun_callback, rtems_id *server_id ) { 3000d65c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000d660: e1a05001 mov r5, r1 <== NOT EXECUTED 3000d664: e1a0a002 mov sl, r2 <== NOT EXECUTED unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 3000d668: da000023 ble 3000d6fc <_Scheduler_CBS_Create_server+0xac> <== NOT EXECUTED 3000d66c: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000d670: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d674: da000020 ble 3000d6fc <_Scheduler_CBS_Create_server+0xac> <== NOT EXECUTED params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 3000d678: e59f308c ldr r3, [pc, #140] ; 3000d70c <_Scheduler_CBS_Create_server+0xbc><== NOT EXECUTED if ( !_Scheduler_CBS_Server_list[i] ) 3000d67c: e3a06000 mov r6, #0 <== NOT EXECUTED params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 3000d680: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d684: e59f3084 ldr r3, [pc, #132] ; 3000d710 <_Scheduler_CBS_Create_server+0xc0><== NOT EXECUTED 3000d688: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d68c: ea00000f b 3000d6d0 <_Scheduler_CBS_Create_server+0x80> <== NOT EXECUTED if ( !_Scheduler_CBS_Server_list[i] ) 3000d690: e4937004 ldr r7, [r3], #4 <== NOT EXECUTED 3000d694: e3570000 cmp r7, #0 <== NOT EXECUTED 3000d698: 1a00000b bne 3000d6cc <_Scheduler_CBS_Create_server+0x7c> <== NOT EXECUTED if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 3000d69c: e59f806c ldr r8, [pc, #108] ; 3000d710 <_Scheduler_CBS_Create_server+0xc0><== NOT EXECUTED } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; 3000d6a0: e58a6000 str r6, [sl] <== NOT EXECUTED _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); 3000d6a4: e3a00010 mov r0, #16 <== NOT EXECUTED if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 3000d6a8: e5989000 ldr r9, [r8] <== NOT EXECUTED _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); 3000d6ac: eb00071e bl 3000f32c <_Workspace_Allocate> <== NOT EXECUTED if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) 3000d6b0: e7890106 str r0, [r9, r6, lsl #2] <== NOT EXECUTED _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; 3000d6b4: e59a2000 ldr r2, [sl] <== NOT EXECUTED 3000d6b8: e5983000 ldr r3, [r8] <== NOT EXECUTED 3000d6bc: e7933102 ldr r3, [r3, r2, lsl #2] <== NOT EXECUTED if ( !the_server ) 3000d6c0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d6c4: 1a000005 bne 3000d6e0 <_Scheduler_CBS_Create_server+0x90> <== NOT EXECUTED 3000d6c8: ea00000d b 3000d704 <_Scheduler_CBS_Create_server+0xb4> <== NOT EXECUTED params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 3000d6cc: e2866001 add r6, r6, #1 <== NOT EXECUTED 3000d6d0: e1560002 cmp r6, r2 <== NOT EXECUTED 3000d6d4: 1affffed bne 3000d690 <_Scheduler_CBS_Create_server+0x40> <== NOT EXECUTED if ( !_Scheduler_CBS_Server_list[i] ) break; } if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; 3000d6d8: e3e00019 mvn r0, #25 <== NOT EXECUTED 3000d6dc: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED the_server = _Scheduler_CBS_Server_list[*server_id]; if ( !the_server ) return SCHEDULER_CBS_ERROR_NO_MEMORY; the_server->parameters = *params; the_server->task_id = -1; 3000d6e0: e3e02000 mvn r2, #0 <== NOT EXECUTED _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; if ( !the_server ) return SCHEDULER_CBS_ERROR_NO_MEMORY; the_server->parameters = *params; 3000d6e4: e8940003 ldm r4, {r0, r1} <== NOT EXECUTED the_server->task_id = -1; 3000d6e8: e5832000 str r2, [r3] <== NOT EXECUTED _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; if ( !the_server ) return SCHEDULER_CBS_ERROR_NO_MEMORY; the_server->parameters = *params; 3000d6ec: e9830003 stmib r3, {r0, r1} <== NOT EXECUTED the_server->task_id = -1; the_server->cbs_budget_overrun = budget_overrun_callback; 3000d6f0: e583500c str r5, [r3, #12] <== NOT EXECUTED return SCHEDULER_CBS_OK; 3000d6f4: e1a00007 mov r0, r7 <== NOT EXECUTED 3000d6f8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED if ( params->budget <= 0 || params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 3000d6fc: e3e00011 mvn r0, #17 <== NOT EXECUTED 3000d700: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED *server_id = i; _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *) _Workspace_Allocate( sizeof(Scheduler_CBS_Server) ); the_server = _Scheduler_CBS_Server_list[*server_id]; if ( !the_server ) return SCHEDULER_CBS_ERROR_NO_MEMORY; 3000d704: e3e00010 mvn r0, #16 <== NOT EXECUTED the_server->parameters = *params; the_server->task_id = -1; the_server->cbs_budget_overrun = budget_overrun_callback; return SCHEDULER_CBS_OK; } 3000d708: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED =============================================================================== 3000d714 <_Scheduler_CBS_Destroy_server>: ) { int ret = SCHEDULER_CBS_OK; rtems_id tid; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d714: e59f3064 ldr r3, [pc, #100] ; 3000d780 <_Scheduler_CBS_Destroy_server+0x6c><== NOT EXECUTED #include int _Scheduler_CBS_Destroy_server ( Scheduler_CBS_Server_id server_id ) { 3000d718: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED int ret = SCHEDULER_CBS_OK; rtems_id tid; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d71c: e5933000 ldr r3, [r3] <== NOT EXECUTED #include int _Scheduler_CBS_Destroy_server ( Scheduler_CBS_Server_id server_id ) { 3000d720: e1a04000 mov r4, r0 <== NOT EXECUTED int ret = SCHEDULER_CBS_OK; rtems_id tid; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d724: e1500003 cmp r0, r3 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 3000d728: 23e06011 mvncs r6, #17 <== NOT EXECUTED ) { int ret = SCHEDULER_CBS_OK; rtems_id tid; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d72c: 2a000011 bcs 3000d778 <_Scheduler_CBS_Destroy_server+0x64> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d730: e59f504c ldr r5, [pc, #76] ; 3000d784 <_Scheduler_CBS_Destroy_server+0x70><== NOT EXECUTED 3000d734: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d738: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d73c: e3530000 cmp r3, #0 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; 3000d740: 03e06018 mvneq r6, #24 <== NOT EXECUTED rtems_id tid; if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d744: 0a00000b beq 3000d778 <_Scheduler_CBS_Destroy_server+0x64> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; if ( (tid = _Scheduler_CBS_Server_list[server_id]->task_id) != -1 ) 3000d748: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000d74c: e3710001 cmn r1, #1 <== NOT EXECUTED int _Scheduler_CBS_Destroy_server ( Scheduler_CBS_Server_id server_id ) { int ret = SCHEDULER_CBS_OK; 3000d750: 03a06000 moveq r6, #0 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; if ( (tid = _Scheduler_CBS_Server_list[server_id]->task_id) != -1 ) 3000d754: 0a000001 beq 3000d760 <_Scheduler_CBS_Destroy_server+0x4c> <== NOT EXECUTED ret = _Scheduler_CBS_Detach_thread ( server_id, tid ); 3000d758: eb00000a bl 3000d788 <_Scheduler_CBS_Detach_thread> <== NOT EXECUTED 3000d75c: e1a06000 mov r6, r0 <== NOT EXECUTED _Workspace_Free( _Scheduler_CBS_Server_list[server_id] ); 3000d760: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d764: e7930104 ldr r0, [r3, r4, lsl #2] <== NOT EXECUTED 3000d768: eb0006f5 bl 3000f344 <_Workspace_Free> <== NOT EXECUTED _Scheduler_CBS_Server_list[server_id] = NULL; 3000d76c: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d770: e3a02000 mov r2, #0 <== NOT EXECUTED 3000d774: e7832104 str r2, [r3, r4, lsl #2] <== NOT EXECUTED return ret; } 3000d778: e1a00006 mov r0, r6 <== NOT EXECUTED 3000d77c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000d788 <_Scheduler_CBS_Detach_thread>: int _Scheduler_CBS_Detach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) { 3000d788: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED 3000d78c: e1a05000 mov r5, r0 <== NOT EXECUTED 3000d790: e1a04001 mov r4, r1 <== NOT EXECUTED Objects_Locations location; Thread_Control *the_thread; Scheduler_CBS_Per_thread *sched_info; the_thread = _Thread_Get(task_id, &location); 3000d794: e1a00001 mov r0, r1 <== NOT EXECUTED 3000d798: e1a0100d mov r1, sp <== NOT EXECUTED 3000d79c: eb00032c bl 3000e454 <_Thread_Get> <== NOT EXECUTED /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 3000d7a0: e2506000 subs r6, r0, #0 <== NOT EXECUTED _Thread_Enable_dispatch(); 3000d7a4: 1b000322 blne 3000e434 <_Thread_Enable_dispatch> <== NOT EXECUTED } if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d7a8: e59f306c ldr r3, [pc, #108] ; 3000d81c <_Scheduler_CBS_Detach_thread+0x94><== NOT EXECUTED 3000d7ac: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d7b0: e1550003 cmp r5, r3 <== NOT EXECUTED 3000d7b4: 2a000016 bcs 3000d814 <_Scheduler_CBS_Detach_thread+0x8c> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !the_thread ) 3000d7b8: e3560000 cmp r6, #0 <== NOT EXECUTED 3000d7bc: 0a000014 beq 3000d814 <_Scheduler_CBS_Detach_thread+0x8c> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; /* Server is not valid. */ if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d7c0: e59f3058 ldr r3, [pc, #88] ; 3000d820 <_Scheduler_CBS_Detach_thread+0x98><== NOT EXECUTED 3000d7c4: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d7c8: e7933105 ldr r3, [r3, r5, lsl #2] <== NOT EXECUTED 3000d7cc: e3530000 cmp r3, #0 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; 3000d7d0: 03e00018 mvneq r0, #24 <== NOT EXECUTED if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !the_thread ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; /* Server is not valid. */ if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d7d4: 0a00000f beq 3000d818 <_Scheduler_CBS_Detach_thread+0x90> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; /* Thread and server are not attached. */ if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id ) 3000d7d8: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d7dc: e1520004 cmp r2, r4 <== NOT EXECUTED 3000d7e0: 1a00000b bne 3000d814 <_Scheduler_CBS_Detach_thread+0x8c> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; _Scheduler_CBS_Server_list[server_id]->task_id = -1; 3000d7e4: e3e02000 mvn r2, #0 <== NOT EXECUTED 3000d7e8: e5832000 str r2, [r3] <== NOT EXECUTED sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; sched_info->cbs_server = NULL; 3000d7ec: e5963088 ldr r3, [r6, #136] ; 0x88 <== NOT EXECUTED 3000d7f0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000d7f4: e5830018 str r0, [r3, #24] <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 3000d7f8: e59630a0 ldr r3, [r6, #160] ; 0xa0 <== NOT EXECUTED 3000d7fc: e5863078 str r3, [r6, #120] ; 0x78 <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 3000d800: e59630a4 ldr r3, [r6, #164] ; 0xa4 <== NOT EXECUTED 3000d804: e586307c str r3, [r6, #124] ; 0x7c <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 3000d808: e5d6309c ldrb r3, [r6, #156] ; 0x9c <== NOT EXECUTED 3000d80c: e5c63070 strb r3, [r6, #112] ; 0x70 <== NOT EXECUTED return SCHEDULER_CBS_OK; 3000d810: ea000000 b 3000d818 <_Scheduler_CBS_Detach_thread+0x90> <== NOT EXECUTED /* Server is not valid. */ if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; /* Thread and server are not attached. */ if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 3000d814: e3e00011 mvn r0, #17 <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout; the_thread->is_preemptible = the_thread->Start.is_preemptible; return SCHEDULER_CBS_OK; } 3000d818: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000d824 <_Scheduler_CBS_Get_approved_budget>: int _Scheduler_CBS_Get_approved_budget ( Scheduler_CBS_Server_id server_id, time_t *approved_budget ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d824: e59f3030 ldr r3, [pc, #48] ; 3000d85c <_Scheduler_CBS_Get_approved_budget+0x38><== NOT EXECUTED 3000d828: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d82c: e1500003 cmp r0, r3 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 3000d830: 23e00011 mvncs r0, #17 <== NOT EXECUTED int _Scheduler_CBS_Get_approved_budget ( Scheduler_CBS_Server_id server_id, time_t *approved_budget ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d834: 212fff1e bxcs lr <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d838: e59f3020 ldr r3, [pc, #32] ; 3000d860 <_Scheduler_CBS_Get_approved_budget+0x3c><== NOT EXECUTED 3000d83c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d840: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d844: e3530000 cmp r3, #0 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; *approved_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget; 3000d848: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED return SCHEDULER_CBS_OK; 3000d84c: 13a00000 movne r0, #0 <== NOT EXECUTED if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; *approved_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget; 3000d850: 15813000 strne r3, [r1] <== NOT EXECUTED ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; 3000d854: 03e00018 mvneq r0, #24 <== NOT EXECUTED *approved_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget; return SCHEDULER_CBS_OK; } 3000d858: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000d864 <_Scheduler_CBS_Get_execution_time>: ) { Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d864: e59f3090 ldr r3, [pc, #144] ; 3000d8fc <_Scheduler_CBS_Get_execution_time+0x98><== NOT EXECUTED int _Scheduler_CBS_Get_execution_time ( Scheduler_CBS_Server_id server_id, time_t *exec_time, time_t *abs_time ) { 3000d868: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d86c: e5933000 ldr r3, [r3] <== NOT EXECUTED int _Scheduler_CBS_Get_execution_time ( Scheduler_CBS_Server_id server_id, time_t *exec_time, time_t *abs_time ) { 3000d870: e1a04000 mov r4, r0 <== NOT EXECUTED Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d874: e1500003 cmp r0, r3 <== NOT EXECUTED int _Scheduler_CBS_Get_execution_time ( Scheduler_CBS_Server_id server_id, time_t *exec_time, time_t *abs_time ) { 3000d878: e1a05001 mov r5, r1 <== NOT EXECUTED Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 3000d87c: 23e00011 mvncs r0, #17 <== NOT EXECUTED ) { Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d880: 2a00001c bcs 3000d8f8 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d884: e59f6074 ldr r6, [pc, #116] ; 3000d900 <_Scheduler_CBS_Get_execution_time+0x9c><== NOT EXECUTED 3000d888: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000d88c: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d890: e3530000 cmp r3, #0 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; 3000d894: 03e00018 mvneq r0, #24 <== NOT EXECUTED Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d898: 0a000016 beq 3000d8f8 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) { 3000d89c: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000d8a0: e3700001 cmn r0, #1 <== NOT EXECUTED *exec_time = 0; 3000d8a4: 03a00000 moveq r0, #0 <== NOT EXECUTED 3000d8a8: 05810000 streq r0, [r1] <== NOT EXECUTED if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) { 3000d8ac: 0a000011 beq 3000d8f8 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED *exec_time = 0; return SCHEDULER_CBS_OK; } the_thread = _Thread_Get( 3000d8b0: e1a0100d mov r1, sp <== NOT EXECUTED 3000d8b4: eb0002e6 bl 3000e454 <_Thread_Get> <== NOT EXECUTED _Scheduler_CBS_Server_list[server_id]->task_id, &location ); /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 3000d8b8: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000d8bc: 0a000008 beq 3000d8e4 <_Scheduler_CBS_Get_execution_time+0x80><== NOT EXECUTED _Thread_Enable_dispatch(); 3000d8c0: eb0002db bl 3000e434 <_Thread_Enable_dispatch> <== NOT EXECUTED *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget - 3000d8c4: e5963000 ldr r3, [r6] <== NOT EXECUTED the_thread->cpu_time_budget; } else { *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget; } return SCHEDULER_CBS_OK; 3000d8c8: e3a00000 mov r0, #0 <== NOT EXECUTED &location ); /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { _Thread_Enable_dispatch(); *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget - 3000d8cc: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d8d0: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 3000d8d4: e5973074 ldr r3, [r7, #116] ; 0x74 <== NOT EXECUTED 3000d8d8: e0633002 rsb r3, r3, r2 <== NOT EXECUTED 3000d8dc: e5853000 str r3, [r5] <== NOT EXECUTED 3000d8e0: ea000004 b 3000d8f8 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED the_thread->cpu_time_budget; } else { *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget; 3000d8e4: e5963000 ldr r3, [r6] <== NOT EXECUTED } return SCHEDULER_CBS_OK; 3000d8e8: e1a00007 mov r0, r7 <== NOT EXECUTED _Thread_Enable_dispatch(); *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget - the_thread->cpu_time_budget; } else { *exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget; 3000d8ec: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d8f0: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000d8f4: e5853000 str r3, [r5] <== NOT EXECUTED } return SCHEDULER_CBS_OK; } 3000d8f8: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3000d904 <_Scheduler_CBS_Get_parameters>: int _Scheduler_CBS_Get_parameters ( Scheduler_CBS_Server_id server_id, Scheduler_CBS_Parameters *params ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d904: e59f3038 ldr r3, [pc, #56] ; 3000d944 <_Scheduler_CBS_Get_parameters+0x40><== NOT EXECUTED 3000d908: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d90c: e1500003 cmp r0, r3 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 3000d910: 23e00011 mvncs r0, #17 <== NOT EXECUTED int _Scheduler_CBS_Get_parameters ( Scheduler_CBS_Server_id server_id, Scheduler_CBS_Parameters *params ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d914: 212fff1e bxcs lr <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d918: e59f3028 ldr r3, [pc, #40] ; 3000d948 <_Scheduler_CBS_Get_parameters+0x44><== NOT EXECUTED 3000d91c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d920: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d924: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d928: 0a000003 beq 3000d93c <_Scheduler_CBS_Get_parameters+0x38> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; *params = _Scheduler_CBS_Server_list[server_id]->parameters; 3000d92c: e993000c ldmib r3, {r2, r3} <== NOT EXECUTED return SCHEDULER_CBS_OK; 3000d930: e3a00000 mov r0, #0 <== NOT EXECUTED if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; *params = _Scheduler_CBS_Server_list[server_id]->parameters; 3000d934: e881000c stm r1, {r2, r3} <== NOT EXECUTED return SCHEDULER_CBS_OK; 3000d938: e12fff1e bx lr <== NOT EXECUTED ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; 3000d93c: e3e00018 mvn r0, #24 <== NOT EXECUTED *params = _Scheduler_CBS_Server_list[server_id]->parameters; return SCHEDULER_CBS_OK; } 3000d940: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000d94c <_Scheduler_CBS_Get_remaining_budget>: ) { Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d94c: e59f3068 ldr r3, [pc, #104] ; 3000d9bc <_Scheduler_CBS_Get_remaining_budget+0x70><== NOT EXECUTED int _Scheduler_CBS_Get_remaining_budget ( Scheduler_CBS_Server_id server_id, time_t *remaining_budget ) { 3000d950: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d954: e5933000 ldr r3, [r3] <== NOT EXECUTED int _Scheduler_CBS_Get_remaining_budget ( Scheduler_CBS_Server_id server_id, time_t *remaining_budget ) { 3000d958: e1a04001 mov r4, r1 <== NOT EXECUTED Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d95c: e1500003 cmp r0, r3 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 3000d960: 23e00011 mvncs r0, #17 <== NOT EXECUTED ) { Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000d964: 2a000013 bcs 3000d9b8 <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d968: e59f3050 ldr r3, [pc, #80] ; 3000d9c0 <_Scheduler_CBS_Get_remaining_budget+0x74><== NOT EXECUTED 3000d96c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d970: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d974: e3530000 cmp r3, #0 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; 3000d978: 03e00018 mvneq r0, #24 <== NOT EXECUTED Objects_Locations location; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 3000d97c: 0a00000d beq 3000d9b8 <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) { 3000d980: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000d984: e3700001 cmn r0, #1 <== NOT EXECUTED *remaining_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget; 3000d988: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED if ( server_id >= _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) { 3000d98c: 0a000007 beq 3000d9b0 <_Scheduler_CBS_Get_remaining_budget+0x64><== NOT EXECUTED *remaining_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget; return SCHEDULER_CBS_OK; } the_thread = _Thread_Get( 3000d990: e1a0100d mov r1, sp <== NOT EXECUTED 3000d994: eb0002ae bl 3000e454 <_Thread_Get> <== NOT EXECUTED _Scheduler_CBS_Server_list[server_id]->task_id, &location ); /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 3000d998: e2505000 subs r5, r0, #0 <== NOT EXECUTED _Thread_Enable_dispatch(); *remaining_budget = the_thread->cpu_time_budget; } else { *remaining_budget = 0; 3000d99c: 05845000 streq r5, [r4] <== NOT EXECUTED } return SCHEDULER_CBS_OK; 3000d9a0: 01a00005 moveq r0, r5 <== NOT EXECUTED the_thread = _Thread_Get( _Scheduler_CBS_Server_list[server_id]->task_id, &location ); /* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread ) { 3000d9a4: 0a000003 beq 3000d9b8 <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED _Thread_Enable_dispatch(); 3000d9a8: eb0002a1 bl 3000e434 <_Thread_Enable_dispatch> <== NOT EXECUTED *remaining_budget = the_thread->cpu_time_budget; 3000d9ac: e5953074 ldr r3, [r5, #116] ; 0x74 <== NOT EXECUTED 3000d9b0: e5843000 str r3, [r4] <== NOT EXECUTED } else { *remaining_budget = 0; } return SCHEDULER_CBS_OK; 3000d9b4: e3a00000 mov r0, #0 <== NOT EXECUTED } 3000d9b8: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 3000d9c4 <_Scheduler_CBS_Get_server_id>: rtems_id task_id, Scheduler_CBS_Server_id *server_id ) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 3000d9c4: e59f304c ldr r3, [pc, #76] ; 3000da18 <_Scheduler_CBS_Get_server_id+0x54><== NOT EXECUTED int _Scheduler_CBS_Get_server_id ( rtems_id task_id, Scheduler_CBS_Server_id *server_id ) { 3000d9c8: e92d4010 push {r4, lr} <== NOT EXECUTED unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 3000d9cc: e5934000 ldr r4, [r3] <== NOT EXECUTED 3000d9d0: e59f3044 ldr r3, [pc, #68] ; 3000da1c <_Scheduler_CBS_Get_server_id+0x58><== NOT EXECUTED 3000d9d4: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d9d8: e3a03000 mov r3, #0 <== NOT EXECUTED 3000d9dc: ea000009 b 3000da08 <_Scheduler_CBS_Get_server_id+0x44> <== NOT EXECUTED if ( _Scheduler_CBS_Server_list[i] && 3000d9e0: e492c004 ldr ip, [r2], #4 <== NOT EXECUTED 3000d9e4: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000d9e8: 0a000005 beq 3000da04 <_Scheduler_CBS_Get_server_id+0x40> <== NOT EXECUTED 3000d9ec: e59cc000 ldr ip, [ip] <== NOT EXECUTED 3000d9f0: e15c0000 cmp ip, r0 <== NOT EXECUTED 3000d9f4: 1a000002 bne 3000da04 <_Scheduler_CBS_Get_server_id+0x40> <== NOT EXECUTED _Scheduler_CBS_Server_list[i]->task_id == task_id ) { *server_id = i; 3000d9f8: e5813000 str r3, [r1] <== NOT EXECUTED return SCHEDULER_CBS_OK; 3000d9fc: e3a00000 mov r0, #0 <== NOT EXECUTED 3000da00: e8bd8010 pop {r4, pc} <== NOT EXECUTED rtems_id task_id, Scheduler_CBS_Server_id *server_id ) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 3000da04: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000da08: e1530004 cmp r3, r4 <== NOT EXECUTED 3000da0c: 1afffff3 bne 3000d9e0 <_Scheduler_CBS_Get_server_id+0x1c> <== NOT EXECUTED _Scheduler_CBS_Server_list[i]->task_id == task_id ) { *server_id = i; return SCHEDULER_CBS_OK; } } return SCHEDULER_CBS_ERROR_NOSERVER; 3000da10: e3e00018 mvn r0, #24 <== NOT EXECUTED } 3000da14: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000da7c <_Scheduler_CBS_Initialize>: int _Scheduler_CBS_Initialize(void) { 3000da7c: e92d4010 push {r4, lr} <== NOT EXECUTED unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( 3000da80: e59f4050 ldr r4, [pc, #80] ; 3000dad8 <_Scheduler_CBS_Initialize+0x5c><== NOT EXECUTED 3000da84: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000da88: e1a00100 lsl r0, r0, #2 <== NOT EXECUTED 3000da8c: eb000626 bl 3000f32c <_Workspace_Allocate> <== NOT EXECUTED 3000da90: e59f3044 ldr r3, [pc, #68] ; 3000dadc <_Scheduler_CBS_Initialize+0x60><== NOT EXECUTED _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) 3000da94: e3500000 cmp r0, #0 <== NOT EXECUTED } int _Scheduler_CBS_Initialize(void) { unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( 3000da98: e5830000 str r0, [r3] <== NOT EXECUTED 3000da9c: e1a00003 mov r0, r3 <== NOT EXECUTED _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { 3000daa0: 13a03000 movne r3, #0 <== NOT EXECUTED 3000daa4: 15941000 ldrne r1, [r4] <== NOT EXECUTED 3000daa8: 11a02003 movne r2, r3 <== NOT EXECUTED int _Scheduler_CBS_Initialize(void) { unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) 3000daac: 1a000003 bne 3000dac0 <_Scheduler_CBS_Initialize+0x44> <== NOT EXECUTED 3000dab0: ea000006 b 3000dad0 <_Scheduler_CBS_Initialize+0x54> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { _Scheduler_CBS_Server_list[i] = NULL; 3000dab4: e590c000 ldr ip, [r0] <== NOT EXECUTED 3000dab8: e78c2103 str r2, [ip, r3, lsl #2] <== NOT EXECUTED unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) return SCHEDULER_CBS_ERROR_NO_MEMORY; for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { 3000dabc: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000dac0: e1530001 cmp r3, r1 <== NOT EXECUTED 3000dac4: 1afffffa bne 3000dab4 <_Scheduler_CBS_Initialize+0x38> <== NOT EXECUTED _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; 3000dac8: e3a00000 mov r0, #0 <== NOT EXECUTED 3000dacc: e8bd8010 pop {r4, pc} <== NOT EXECUTED { unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate( _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) ); if ( !_Scheduler_CBS_Server_list ) return SCHEDULER_CBS_ERROR_NO_MEMORY; 3000dad0: e3e00010 mvn r0, #16 <== NOT EXECUTED for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) { _Scheduler_CBS_Server_list[i] = NULL; } return SCHEDULER_CBS_OK; } 3000dad4: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000c6fc <_Scheduler_CBS_Release_job>: { Priority_Control new_priority; Scheduler_CBS_Per_thread *sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; Scheduler_CBS_Server *serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server; 3000c6fc: e5903088 ldr r3, [r0, #136] ; 0x88 <== NOT EXECUTED if (deadline) { 3000c700: e3510000 cmp r1, #0 <== NOT EXECUTED ) { Priority_Control new_priority; Scheduler_CBS_Per_thread *sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; Scheduler_CBS_Server *serv_info = 3000c704: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED (Scheduler_CBS_Server *) sched_info->cbs_server; if (deadline) { 3000c708: 0a00000a beq 3000c738 <_Scheduler_CBS_Release_job+0x3c> <== NOT EXECUTED 3000c70c: e59f2044 ldr r2, [pc, #68] ; 3000c758 <_Scheduler_CBS_Release_job+0x5c><== NOT EXECUTED /* Initializing or shifting deadline. */ if (serv_info) 3000c710: e3530000 cmp r3, #0 <== NOT EXECUTED new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline) & ~SCHEDULER_EDF_PRIO_MSB; else new_priority = (_Watchdog_Ticks_since_boot + deadline) 3000c714: 05923000 ldreq r3, [r2] <== NOT EXECUTED 3000c718: 00811003 addeq r1, r1, r3 <== NOT EXECUTED 3000c71c: 03c11102 biceq r1, r1, #-2147483648 ; 0x80000000 <== NOT EXECUTED Scheduler_CBS_Server *serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server; if (deadline) { /* Initializing or shifting deadline. */ if (serv_info) 3000c720: 0a000009 beq 3000c74c <_Scheduler_CBS_Release_job+0x50> <== NOT EXECUTED new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline) 3000c724: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000c728: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000c72c: e0811002 add r1, r1, r2 <== NOT EXECUTED 3000c730: e3c11102 bic r1, r1, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000c734: ea000002 b 3000c744 <_Scheduler_CBS_Release_job+0x48> <== NOT EXECUTED /* Switch back to background priority. */ new_priority = the_thread->Start.initial_priority; } /* Budget replenishment for the next job. */ if (serv_info) 3000c738: e3530000 cmp r3, #0 <== NOT EXECUTED new_priority = (_Watchdog_Ticks_since_boot + deadline) & ~SCHEDULER_EDF_PRIO_MSB; } else { /* Switch back to background priority. */ new_priority = the_thread->Start.initial_priority; 3000c73c: e59010ac ldr r1, [r0, #172] ; 0xac <== NOT EXECUTED } /* Budget replenishment for the next job. */ if (serv_info) 3000c740: 0a000001 beq 3000c74c <_Scheduler_CBS_Release_job+0x50> <== NOT EXECUTED the_thread->cpu_time_budget = serv_info->parameters.budget; 3000c744: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000c748: e5803074 str r3, [r0, #116] ; 0x74 <== NOT EXECUTED the_thread->real_priority = new_priority; _Thread_Change_priority(the_thread, new_priority, true); 3000c74c: e3a02001 mov r2, #1 <== NOT EXECUTED /* Budget replenishment for the next job. */ if (serv_info) the_thread->cpu_time_budget = serv_info->parameters.budget; the_thread->real_priority = new_priority; 3000c750: e5801018 str r1, [r0, #24] <== NOT EXECUTED _Thread_Change_priority(the_thread, new_priority, true); 3000c754: ea00010b b 3000cb88 <_Thread_Change_priority> <== NOT EXECUTED =============================================================================== 3000db40 <_Scheduler_CBS_Set_parameters>: int _Scheduler_CBS_Set_parameters ( Scheduler_CBS_Server_id server_id, Scheduler_CBS_Parameters *params ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) 3000db40: e59f3054 ldr r3, [pc, #84] ; 3000db9c <_Scheduler_CBS_Set_parameters+0x5c><== NOT EXECUTED 3000db44: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000db48: e1500003 cmp r0, r3 <== NOT EXECUTED 3000db4c: 2a00000e bcs 3000db8c <_Scheduler_CBS_Set_parameters+0x4c> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( params->budget <= 0 || 3000db50: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 3000db54: e3530000 cmp r3, #0 <== NOT EXECUTED 3000db58: da00000b ble 3000db8c <_Scheduler_CBS_Set_parameters+0x4c> <== NOT EXECUTED 3000db5c: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000db60: e3530000 cmp r3, #0 <== NOT EXECUTED 3000db64: da000008 ble 3000db8c <_Scheduler_CBS_Set_parameters+0x4c> <== NOT EXECUTED params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id] ) 3000db68: e59f3030 ldr r3, [pc, #48] ; 3000dba0 <_Scheduler_CBS_Set_parameters+0x60><== NOT EXECUTED 3000db6c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000db70: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000db74: e3530000 cmp r3, #0 <== NOT EXECUTED 3000db78: 0a000005 beq 3000db94 <_Scheduler_CBS_Set_parameters+0x54> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_NOSERVER; _Scheduler_CBS_Server_list[server_id]->parameters = *params; 3000db7c: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED 3000db80: e9830003 stmib r3, {r0, r1} <== NOT EXECUTED return SCHEDULER_CBS_OK; 3000db84: e3a00000 mov r0, #0 <== NOT EXECUTED 3000db88: e12fff1e bx lr <== NOT EXECUTED if ( params->budget <= 0 || params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 3000db8c: e3e00011 mvn r0, #17 <== NOT EXECUTED 3000db90: e12fff1e bx lr <== NOT EXECUTED if ( !_Scheduler_CBS_Server_list[server_id] ) return SCHEDULER_CBS_ERROR_NOSERVER; 3000db94: e3e00018 mvn r0, #24 <== NOT EXECUTED _Scheduler_CBS_Server_list[server_id]->parameters = *params; return SCHEDULER_CBS_OK; } 3000db98: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000c75c <_Scheduler_CBS_Unblock>: #include void _Scheduler_CBS_Unblock( Thread_Control *the_thread ) { 3000c75c: e92d4030 push {r4, r5, lr} 3000c760: e1a04000 mov r4, r0 Scheduler_CBS_Per_thread *sched_info; Scheduler_CBS_Server *serv_info; Priority_Control new_priority; _Scheduler_EDF_Enqueue(the_thread); 3000c764: eb00003d bl 3000c860 <_Scheduler_EDF_Enqueue> /* TODO: flash critical section? */ sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server; 3000c768: e5943088 ldr r3, [r4, #136] ; 0x88 3000c76c: e5933018 ldr r3, [r3, #24] * Late unblock rule for deadline-driven tasks. The remaining time to * deadline must be sufficient to serve the remaining computation time * without increased utilization of this task. It might cause a deadline * miss of another task. */ if (serv_info) { 3000c770: e3530000 cmp r3, #0 3000c774: 0a000012 beq 3000c7c4 <_Scheduler_CBS_Unblock+0x68> time_t deadline = serv_info->parameters.deadline; time_t budget = serv_info->parameters.budget; time_t deadline_left = the_thread->cpu_time_budget; time_t budget_left = the_thread->real_priority - 3000c778: e59f1094 ldr r1, [pc, #148] ; 3000c814 <_Scheduler_CBS_Unblock+0xb8><== NOT EXECUTED 3000c77c: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED 3000c780: e5911000 ldr r1, [r1] <== NOT EXECUTED _Watchdog_Ticks_since_boot; if ( deadline*budget_left > budget*deadline_left ) { 3000c784: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED */ if (serv_info) { time_t deadline = serv_info->parameters.deadline; time_t budget = serv_info->parameters.budget; time_t deadline_left = the_thread->cpu_time_budget; time_t budget_left = the_thread->real_priority - 3000c788: e0611002 rsb r1, r1, r2 <== NOT EXECUTED _Watchdog_Ticks_since_boot; if ( deadline*budget_left > budget*deadline_left ) { 3000c78c: e0010190 mul r1, r0, r1 <== NOT EXECUTED 3000c790: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000c794: e5940074 ldr r0, [r4, #116] ; 0x74 <== NOT EXECUTED 3000c798: e0030390 mul r3, r0, r3 <== NOT EXECUTED 3000c79c: e1510003 cmp r1, r3 <== NOT EXECUTED 3000c7a0: da000007 ble 3000c7c4 <_Scheduler_CBS_Unblock+0x68> <== NOT EXECUTED /* Put late unblocked task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; 3000c7a4: e59410ac ldr r1, [r4, #172] ; 0xac <== NOT EXECUTED if ( the_thread->real_priority != new_priority ) the_thread->real_priority = new_priority; if ( the_thread->current_priority != new_priority ) 3000c7a8: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED _Watchdog_Ticks_since_boot; if ( deadline*budget_left > budget*deadline_left ) { /* Put late unblocked task to background until the end of period. */ new_priority = the_thread->Start.initial_priority; if ( the_thread->real_priority != new_priority ) 3000c7ac: e1520001 cmp r2, r1 <== NOT EXECUTED the_thread->real_priority = new_priority; 3000c7b0: 15841018 strne r1, [r4, #24] <== NOT EXECUTED if ( the_thread->current_priority != new_priority ) 3000c7b4: e1530001 cmp r3, r1 <== NOT EXECUTED _Thread_Change_priority(the_thread, new_priority, true); 3000c7b8: 11a00004 movne r0, r4 <== NOT EXECUTED 3000c7bc: 13a02001 movne r2, #1 <== NOT EXECUTED 3000c7c0: 1b0000f0 blne 3000cb88 <_Thread_Change_priority> <== NOT EXECUTED * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority, 3000c7c4: e59f504c ldr r5, [pc, #76] ; 3000c818 <_Scheduler_CBS_Unblock+0xbc> 3000c7c8: e5940014 ldr r0, [r4, #20] 3000c7cc: e595300c ldr r3, [r5, #12] 3000c7d0: e5931014 ldr r1, [r3, #20] 3000c7d4: e59f3040 ldr r3, [pc, #64] ; 3000c81c <_Scheduler_CBS_Unblock+0xc0> 3000c7d8: e1a0e00f mov lr, pc 3000c7dc: e593f030 ldr pc, [r3, #48] ; 0x30 3000c7e0: e3500000 cmp r0, #0 3000c7e4: d8bd8030 pople {r4, r5, pc} _Thread_Heir->current_priority)) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 3000c7e8: e5953008 ldr r3, [r5, #8] * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority, _Thread_Heir->current_priority)) { _Thread_Heir = the_thread; 3000c7ec: e585400c str r4, [r5, #12] if ( _Thread_Executing->is_preemptible || 3000c7f0: e5d33070 ldrb r3, [r3, #112] ; 0x70 3000c7f4: e3530000 cmp r3, #0 3000c7f8: 1a000002 bne 3000c808 <_Scheduler_CBS_Unblock+0xac> 3000c7fc: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000c800: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c804: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 3000c808: e3a03001 mov r3, #1 3000c80c: e5c53004 strb r3, [r5, #4] 3000c810: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000c820 <_Scheduler_EDF_Block>: #include void _Scheduler_EDF_Block( Thread_Control *the_thread ) { 3000c820: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 3000c824: e1a04000 mov r4, r0 <== NOT EXECUTED _Scheduler_EDF_Extract( the_thread ); 3000c828: eb000015 bl 3000c884 <_Scheduler_EDF_Extract> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_heir ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Heir ); 3000c82c: e59f3024 ldr r3, [pc, #36] ; 3000c858 <_Scheduler_EDF_Block+0x38><== NOT EXECUTED /* TODO: flash critical section? */ if ( _Thread_Is_heir( the_thread ) ) 3000c830: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 3000c834: e1a05003 mov r5, r3 <== NOT EXECUTED 3000c838: e1540002 cmp r4, r2 <== NOT EXECUTED _Scheduler_EDF_Schedule(); 3000c83c: 0b000040 bleq 3000c944 <_Scheduler_EDF_Schedule> <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) 3000c840: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000c844: e1540003 cmp r4, r3 <== NOT EXECUTED _Thread_Dispatch_necessary = true; 3000c848: 059f3008 ldreq r3, [pc, #8] ; 3000c858 <_Scheduler_EDF_Block+0x38><== NOT EXECUTED 3000c84c: 03a02001 moveq r2, #1 <== NOT EXECUTED 3000c850: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED 3000c854: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 3000c85c <_Scheduler_EDF_Enqueue_first>: void _Scheduler_EDF_Enqueue_first( Thread_Control *the_thread ) { _Scheduler_EDF_Enqueue(the_thread); 3000c85c: eaffffff b 3000c860 <_Scheduler_EDF_Enqueue> <== NOT EXECUTED =============================================================================== 3000c884 <_Scheduler_EDF_Extract>: #include void _Scheduler_EDF_Extract( Thread_Control *the_thread ) { 3000c884: e92d4010 push {r4, lr} <== NOT EXECUTED Scheduler_EDF_Per_thread *sched_info = 3000c888: e5904088 ldr r4, [r0, #136] ; 0x88 <== NOT EXECUTED (Scheduler_EDF_Per_thread*) the_thread->scheduler_info; RBTree_Node *node = &(sched_info->Node); _RBTree_Extract( &_Scheduler_EDF_Ready_queue, node ); 3000c88c: e59f0010 ldr r0, [pc, #16] ; 3000c8a4 <_Scheduler_EDF_Extract+0x20><== NOT EXECUTED 3000c890: e2841004 add r1, r4, #4 <== NOT EXECUTED 3000c894: eb000e8a bl 300102c4 <_RBTree_Extract> <== NOT EXECUTED sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY; 3000c898: e3a03000 mov r3, #0 <== NOT EXECUTED 3000c89c: e5843014 str r3, [r4, #20] <== NOT EXECUTED } 3000c8a0: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000c8a8 <_Scheduler_EDF_Free>: void _Scheduler_EDF_Free( Thread_Control *the_thread ) { _Workspace_Free( the_thread->scheduler_info ); 3000c8a8: e5900088 ldr r0, [r0, #136] ; 0x88 <== NOT EXECUTED 3000c8ac: ea0005ba b 3000df9c <_Workspace_Free> <== NOT EXECUTED =============================================================================== 3000c814 <_Scheduler_EDF_Release_job>: uint32_t deadline ) { Priority_Control new_priority; if (deadline) { 3000c814: e3510000 cmp r1, #0 <== NOT EXECUTED /* Initializing or shifting deadline. */ new_priority = (_Watchdog_Ticks_since_boot + deadline) 3000c818: 159f3018 ldrne r3, [pc, #24] ; 3000c838 <_Scheduler_EDF_Release_job+0x24><== NOT EXECUTED & ~SCHEDULER_EDF_PRIO_MSB; } else { /* Switch back to background priority. */ new_priority = the_thread->Start.initial_priority; 3000c81c: 059010ac ldreq r1, [r0, #172] ; 0xac <== NOT EXECUTED { Priority_Control new_priority; if (deadline) { /* Initializing or shifting deadline. */ new_priority = (_Watchdog_Ticks_since_boot + deadline) 3000c820: 15933000 ldrne r3, [r3] <== NOT EXECUTED /* Switch back to background priority. */ new_priority = the_thread->Start.initial_priority; } the_thread->real_priority = new_priority; _Thread_Change_priority(the_thread, new_priority, true); 3000c824: e3a02001 mov r2, #1 <== NOT EXECUTED { Priority_Control new_priority; if (deadline) { /* Initializing or shifting deadline. */ new_priority = (_Watchdog_Ticks_since_boot + deadline) 3000c828: 10811003 addne r1, r1, r3 <== NOT EXECUTED 3000c82c: 13c11102 bicne r1, r1, #-2147483648 ; 0x80000000 <== NOT EXECUTED else { /* Switch back to background priority. */ new_priority = the_thread->Start.initial_priority; } the_thread->real_priority = new_priority; 3000c830: e5801018 str r1, [r0, #24] <== NOT EXECUTED _Thread_Change_priority(the_thread, new_priority, true); 3000c834: ea0000aa b 3000cae4 <_Thread_Change_priority> <== NOT EXECUTED =============================================================================== 3000c944 <_Scheduler_EDF_Schedule>: RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First( const RBTree_Control *the_rbtree, RBTree_Direction dir ) { return the_rbtree->first[dir]; 3000c944: e59f3010 ldr r3, [pc, #16] ; 3000c95c <_Scheduler_EDF_Schedule+0x18><== NOT EXECUTED { RBTree_Node *first = _RBTree_First(&_Scheduler_EDF_Ready_queue, RBT_LEFT); Scheduler_EDF_Per_thread *sched_info = _RBTree_Container_of(first, Scheduler_EDF_Per_thread, Node); _Thread_Heir = (Thread_Control *) sched_info->thread; 3000c948: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000c94c: e5132004 ldr r2, [r3, #-4] <== NOT EXECUTED 3000c950: e59f3008 ldr r3, [pc, #8] ; 3000c960 <_Scheduler_EDF_Schedule+0x1c><== NOT EXECUTED 3000c954: e583200c str r2, [r3, #12] <== NOT EXECUTED } 3000c958: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000c85c <_Scheduler_EDF_Unblock>: #include void _Scheduler_EDF_Unblock( Thread_Control *the_thread ) { 3000c85c: e92d4030 push {r4, r5, lr} * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_lower_than( 3000c860: e59f5050 ldr r5, [pc, #80] ; 3000c8b8 <_Scheduler_EDF_Unblock+0x5c> #include void _Scheduler_EDF_Unblock( Thread_Control *the_thread ) { 3000c864: e1a04000 mov r4, r0 _Scheduler_EDF_Enqueue(the_thread); 3000c868: ebffffb0 bl 3000c730 <_Scheduler_EDF_Enqueue> * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_lower_than( 3000c86c: e595300c ldr r3, [r5, #12] 3000c870: e5941014 ldr r1, [r4, #20] 3000c874: e5930014 ldr r0, [r3, #20] 3000c878: e59f303c ldr r3, [pc, #60] ; 3000c8bc <_Scheduler_EDF_Unblock+0x60> 3000c87c: e1a0e00f mov lr, pc 3000c880: e593f030 ldr pc, [r3, #48] ; 0x30 3000c884: e3500000 cmp r0, #0 3000c888: a8bd8030 popge {r4, r5, pc} _Thread_Heir->current_priority, the_thread->current_priority )) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 3000c88c: e5953008 ldr r3, [r5, #8] * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_lower_than( _Thread_Heir->current_priority, the_thread->current_priority )) { _Thread_Heir = the_thread; 3000c890: e585400c str r4, [r5, #12] if ( _Thread_Executing->is_preemptible || 3000c894: e5d33070 ldrb r3, [r3, #112] ; 0x70 3000c898: e3530000 cmp r3, #0 3000c89c: 1a000002 bne 3000c8ac <_Scheduler_EDF_Unblock+0x50> 3000c8a0: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3000c8a4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c8a8: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 3000c8ac: e3a03001 mov r3, #1 3000c8b0: e5c53004 strb r3, [r5, #4] 3000c8b4: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000c994 <_Scheduler_EDF_Yield>: #include #include #include void _Scheduler_EDF_Yield(void) { 3000c994: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED ISR_Level level; Thread_Control *executing = _Thread_Executing; 3000c998: e59f5050 ldr r5, [pc, #80] ; 3000c9f0 <_Scheduler_EDF_Yield+0x5c><== NOT EXECUTED Scheduler_EDF_Per_thread *executing_info = (Scheduler_EDF_Per_thread *) executing->scheduler_info; 3000c99c: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED RBTree_Node *executing_node = &(executing_info->Node); 3000c9a0: e5936088 ldr r6, [r3, #136] ; 0x88 <== NOT EXECUTED 3000c9a4: e2866004 add r6, r6, #4 <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000c9a8: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000c9ac: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000c9b0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED /* * The RBTree has more than one node, enqueue behind the tasks * with the same priority in case there are such ones. */ _RBTree_Extract( &_Scheduler_EDF_Ready_queue, executing_node ); 3000c9b4: e59f7038 ldr r7, [pc, #56] ; 3000c9f4 <_Scheduler_EDF_Yield+0x60><== NOT EXECUTED 3000c9b8: e1a01006 mov r1, r6 <== NOT EXECUTED 3000c9bc: e1a00007 mov r0, r7 <== NOT EXECUTED 3000c9c0: eb000e3f bl 300102c4 <_RBTree_Extract> <== NOT EXECUTED _RBTree_Insert( &_Scheduler_EDF_Ready_queue, executing_node ); 3000c9c4: e1a00007 mov r0, r7 <== NOT EXECUTED 3000c9c8: e1a01006 mov r1, r6 <== NOT EXECUTED 3000c9cc: eb000ec1 bl 300104d8 <_RBTree_Insert> <== NOT EXECUTED static inline void arm_interrupt_flash( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000c9d0: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000c9d4: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000c9d8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _ISR_Flash( level ); _Scheduler_EDF_Schedule(); 3000c9dc: ebffffd8 bl 3000c944 <_Scheduler_EDF_Schedule> <== NOT EXECUTED _Thread_Dispatch_necessary = true; 3000c9e0: e3a03001 mov r3, #1 <== NOT EXECUTED 3000c9e4: e5c53004 strb r3, [r5, #4] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000c9e8: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED _ISR_Enable( level ); } 3000c9ec: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3000c10c <_Scheduler_priority_Tick>: void _Scheduler_priority_Tick( void ) { Thread_Control *executing; executing = _Thread_Executing; 3000c10c: e59f3088 ldr r3, [pc, #136] ; 3000c19c <_Scheduler_priority_Tick+0x90> #include #include void _Scheduler_priority_Tick( void ) { 3000c110: e92d4010 push {r4, lr} Thread_Control *executing; executing = _Thread_Executing; 3000c114: e5934008 ldr r4, [r3, #8] /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 3000c118: e5d43070 ldrb r3, [r4, #112] ; 0x70 3000c11c: e3530000 cmp r3, #0 3000c120: 08bd8010 popeq {r4, pc} return; if ( !_States_Is_ready( executing->current_state ) ) 3000c124: e5943010 ldr r3, [r4, #16] 3000c128: e3530000 cmp r3, #0 3000c12c: 18bd8010 popne {r4, pc} /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 3000c130: e5943078 ldr r3, [r4, #120] ; 0x78 3000c134: e3530001 cmp r3, #1 3000c138: 0a000002 beq 3000c148 <_Scheduler_priority_Tick+0x3c> 3000c13c: e3530002 cmp r3, #2 3000c140: 18bd8010 popne {r4, pc} 3000c144: ea00000b b 3000c178 <_Scheduler_priority_Tick+0x6c> <== NOT EXECUTED case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: #endif if ( (int)(--executing->cpu_time_budget) <= 0 ) { 3000c148: e5943074 ldr r3, [r4, #116] ; 0x74 <== NOT EXECUTED 3000c14c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000c150: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c154: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED 3000c158: c8bd8010 popgt {r4, pc} <== NOT EXECUTED * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield(); 3000c15c: e59f303c ldr r3, [pc, #60] ; 3000c1a0 <_Scheduler_priority_Tick+0x94><== NOT EXECUTED 3000c160: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c164: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED * executing thread's timeslice is reset. Otherwise, the * currently executing thread is placed at the rear of the * FIFO for this priority and a new heir is selected. */ _Scheduler_Yield(); executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 3000c168: e59f3034 ldr r3, [pc, #52] ; 3000c1a4 <_Scheduler_priority_Tick+0x98><== NOT EXECUTED 3000c16c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000c170: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED 3000c174: e8bd8010 pop {r4, pc} <== NOT EXECUTED } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 3000c178: e5943074 ldr r3, [r4, #116] ; 0x74 <== NOT EXECUTED 3000c17c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000c180: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c184: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED 3000c188: 18bd8010 popne {r4, pc} <== NOT EXECUTED (*executing->budget_callout)( executing ); 3000c18c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c190: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c194: e594f07c ldr pc, [r4, #124] ; 0x7c <== NOT EXECUTED 3000c198: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000c728 <_Scheduler_simple_Block>: #include void _Scheduler_simple_Block( Thread_Control *the_thread ) { 3000c728: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 3000c72c: e1a04000 mov r4, r0 <== NOT EXECUTED _Scheduler_simple_Extract(the_thread); 3000c730: eb00000d bl 3000c76c <_Scheduler_simple_Extract> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_heir ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Heir ); 3000c734: e59f3024 ldr r3, [pc, #36] ; 3000c760 <_Scheduler_simple_Block+0x38><== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 3000c738: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 3000c73c: e1a05003 mov r5, r3 <== NOT EXECUTED 3000c740: e1540002 cmp r4, r2 <== NOT EXECUTED _Scheduler_simple_Schedule(); 3000c744: 0b000042 bleq 3000c854 <_Scheduler_simple_Schedule> <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) 3000c748: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000c74c: e1540003 cmp r4, r3 <== NOT EXECUTED _Thread_Dispatch_necessary = true; 3000c750: 059f3008 ldreq r3, [pc, #8] ; 3000c760 <_Scheduler_simple_Block+0x38><== NOT EXECUTED 3000c754: 03a02001 moveq r2, #1 <== NOT EXECUTED 3000c758: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED 3000c75c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 3000c768 <_Scheduler_simple_Enqueue>: void _Scheduler_simple_Enqueue( Thread_Control *the_thread ) { _Scheduler_simple_Ready_queue_enqueue( the_thread ); 3000c768: ea000024 b 3000c800 <_Scheduler_simple_Ready_queue_enqueue><== NOT EXECUTED =============================================================================== 3000c764 <_Scheduler_simple_Enqueue_first>: void _Scheduler_simple_Enqueue_first( Thread_Control *the_thread ) { _Scheduler_simple_Ready_queue_enqueue_first( the_thread ); 3000c764: ea000014 b 3000c7bc <_Scheduler_simple_Ready_queue_enqueue_first><== NOT EXECUTED =============================================================================== 3000c76c <_Scheduler_simple_Extract>: { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 3000c76c: e890000c ldm r0, {r2, r3} <== NOT EXECUTED next->previous = previous; 3000c770: e5823004 str r3, [r2, #4] <== NOT EXECUTED previous->next = next; 3000c774: e5832000 str r2, [r3] <== NOT EXECUTED void _Scheduler_simple_Extract( Thread_Control *the_thread ) { _Chain_Extract_unprotected( &the_thread->Object.Node ); } 3000c778: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000c788 <_Scheduler_simple_Free>: void _Scheduler_simple_Free( Thread_Control *the_thread ) { } 3000c788: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000c800 <_Scheduler_simple_Ready_queue_enqueue>: { Chain_Control *ready; Chain_Node *the_node; Thread_Control *current; ready = (Chain_Control *)_Scheduler.information; 3000c800: e59f3048 ldr r3, [pc, #72] ; 3000c850 <_Scheduler_simple_Ready_queue_enqueue+0x50> 3000c804: e5933000 ldr r3, [r3] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 3000c808: e5932000 ldr r2, [r3] RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( const Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Immutable_tail( the_chain )); 3000c80c: e2831004 add r1, r3, #4 the_node = _Chain_First( ready ); current = (Thread_Control *)ready; for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) { 3000c810: ea000006 b 3000c830 <_Scheduler_simple_Ready_queue_enqueue+0x30> current = (Thread_Control *) the_node; /* break when AT END OR PAST our priority */ if ( the_thread->current_priority < current->current_priority ) { 3000c814: e590c014 ldr ip, [r0, #20] 3000c818: e5923014 ldr r3, [r2, #20] 3000c81c: e15c0003 cmp ip, r3 current = (Thread_Control *)current->Object.Node.previous; 3000c820: 35923004 ldrcc r3, [r2, #4] break; 3000c824: 3a000003 bcc 3000c838 <_Scheduler_simple_Ready_queue_enqueue+0x38> ready = (Chain_Control *)_Scheduler.information; the_node = _Chain_First( ready ); current = (Thread_Control *)ready; for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) { 3000c828: e1a03002 mov r3, r2 <== NOT EXECUTED 3000c82c: e5922000 ldr r2, [r2] <== NOT EXECUTED 3000c830: e1520001 cmp r2, r1 3000c834: 1afffff6 bne 3000c814 <_Scheduler_simple_Ready_queue_enqueue+0x14> ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 3000c838: e5932000 ldr r2, [r3] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 3000c83c: e5803004 str r3, [r0, #4] before_node = after_node->next; after_node->next = the_node; 3000c840: e5830000 str r0, [r3] the_node->next = before_node; before_node->previous = the_node; 3000c844: e5820004 str r0, [r2, #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; 3000c848: e5802000 str r2, [r0] } } /* enqueue */ _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node ); } 3000c84c: e12fff1e bx lr =============================================================================== 3000c7bc <_Scheduler_simple_Ready_queue_enqueue_first>: { Chain_Control *ready; Chain_Node *the_node; Thread_Control *current; ready = (Chain_Control *)_Scheduler.information; 3000c7bc: e59f3038 ldr r3, [pc, #56] ; 3000c7fc <_Scheduler_simple_Ready_queue_enqueue_first+0x40><== NOT EXECUTED */ for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) { current = (Thread_Control *) the_node; /* break when AT HEAD OF (or PAST) our priority */ if ( the_thread->current_priority <= current->current_priority ) { 3000c7c0: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 3000c7c4: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000c7c8: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000c7cc: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED 3000c7d0: e1520001 cmp r2, r1 <== NOT EXECUTED 3000c7d4: 8a000006 bhi 3000c7f4 <_Scheduler_simple_Ready_queue_enqueue_first+0x38><== NOT EXECUTED current = (Thread_Control *)current->Object.Node.previous; 3000c7d8: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 3000c7dc: e5932000 ldr r2, [r3] <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 3000c7e0: e5803004 str r3, [r0, #4] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; 3000c7e4: e5830000 str r0, [r3] <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 3000c7e8: e5820004 str r0, [r2, #4] <== 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; 3000c7ec: e5802000 str r2, [r0] <== NOT EXECUTED } } /* enqueue */ _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node ); } 3000c7f0: e12fff1e bx lr <== NOT EXECUTED * Do NOT need to check for end of chain because there is always * at least one task on the ready chain -- the IDLE task. It can * never block, should never attempt to obtain a semaphore or mutex, * and thus will always be there. */ for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) { 3000c7f4: e5933000 ldr r3, [r3] <== NOT EXECUTED /* break when AT HEAD OF (or PAST) our priority */ if ( the_thread->current_priority <= current->current_priority ) { current = (Thread_Control *)current->Object.Node.previous; break; } } 3000c7f8: eafffff3 b 3000c7cc <_Scheduler_simple_Ready_queue_enqueue_first+0x10><== NOT EXECUTED =============================================================================== 3000c854 <_Scheduler_simple_Schedule>: #include void _Scheduler_simple_Schedule(void) { _Thread_Heir = (Thread_Control *) _Chain_First( (Chain_Control *) _Scheduler.information 3000c854: e59f3010 ldr r3, [pc, #16] ; 3000c86c <_Scheduler_simple_Schedule+0x18><== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 3000c858: e5933000 ldr r3, [r3] <== NOT EXECUTED #include #include void _Scheduler_simple_Schedule(void) { _Thread_Heir = (Thread_Control *) _Chain_First( 3000c85c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c860: e59f3008 ldr r3, [pc, #8] ; 3000c870 <_Scheduler_simple_Schedule+0x1c><== NOT EXECUTED 3000c864: e583200c str r2, [r3, #12] <== NOT EXECUTED (Chain_Control *) _Scheduler.information ); } 3000c868: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000c874 <_Scheduler_simple_Unblock>: #include void _Scheduler_simple_Unblock( Thread_Control *the_thread ) { 3000c874: e92d4010 push {r4, lr} 3000c878: e1a04000 mov r4, r0 _Scheduler_simple_Ready_queue_enqueue(the_thread); 3000c87c: ebffffdf bl 3000c800 <_Scheduler_simple_Ready_queue_enqueue> * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 3000c880: e59f3038 ldr r3, [pc, #56] ; 3000c8c0 <_Scheduler_simple_Unblock+0x4c> 3000c884: e5942014 ldr r2, [r4, #20] 3000c888: e593100c ldr r1, [r3, #12] 3000c88c: e5911014 ldr r1, [r1, #20] 3000c890: e1520001 cmp r2, r1 3000c894: 28bd8010 popcs {r4, pc} _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 3000c898: e5931008 ldr r1, [r3, #8] * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; 3000c89c: e583400c str r4, [r3, #12] if ( _Thread_Executing->is_preemptible || 3000c8a0: e5d11070 ldrb r1, [r1, #112] ; 0x70 3000c8a4: e3510000 cmp r1, #0 3000c8a8: 1a000001 bne 3000c8b4 <_Scheduler_simple_Unblock+0x40> 3000c8ac: e3520000 cmp r2, #0 <== NOT EXECUTED 3000c8b0: 18bd8010 popne {r4, pc} <== NOT EXECUTED the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 3000c8b4: e3a02001 mov r2, #1 3000c8b8: e5c32004 strb r2, [r3, #4] 3000c8bc: e8bd8010 pop {r4, pc} =============================================================================== 3000c8c4 <_Scheduler_simple_Yield>: #include #include #include void _Scheduler_simple_Yield( void ) { 3000c8c4: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED ISR_Level level; Thread_Control *executing; executing = _Thread_Executing; 3000c8c8: e59f5048 ldr r5, [pc, #72] ; 3000c918 <_Scheduler_simple_Yield+0x54><== NOT EXECUTED 3000c8cc: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000c8d0: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000c8d4: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000c8d8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 3000c8dc: e894000c ldm r4, {r2, r3} <== NOT EXECUTED { /* extract */ _Chain_Extract_unprotected( &the_thread->Object.Node ); /* enqueue */ _Scheduler_simple_Ready_queue_enqueue( the_thread ); 3000c8e0: e1a00004 mov r0, r4 <== NOT EXECUTED next->previous = previous; 3000c8e4: e5823004 str r3, [r2, #4] <== NOT EXECUTED previous->next = next; 3000c8e8: e5832000 str r2, [r3] <== NOT EXECUTED 3000c8ec: ebffffc3 bl 3000c800 <_Scheduler_simple_Ready_queue_enqueue><== NOT EXECUTED static inline void arm_interrupt_flash( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000c8f0: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000c8f4: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000c8f8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _Scheduler_simple_Ready_queue_requeue(&_Scheduler, executing); _ISR_Flash( level ); _Scheduler_simple_Schedule(); 3000c8fc: ebffffd4 bl 3000c854 <_Scheduler_simple_Schedule> <== NOT EXECUTED if ( !_Thread_Is_heir( executing ) ) 3000c900: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3000c904: e1540003 cmp r4, r3 <== NOT EXECUTED _Thread_Dispatch_necessary = true; 3000c908: 13a03001 movne r3, #1 <== NOT EXECUTED 3000c90c: 15c53004 strbne r3, [r5, #4] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000c910: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED _ISR_Enable( level ); } 3000c914: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 30026494 <_TOD_Get_uptime_as_timespec>: #include void _TOD_Get_uptime_as_timespec( struct timespec *uptime ) { 30026494: e92d40d3 push {r0, r1, r4, r6, r7, lr} <== NOT EXECUTED 30026498: e1a04000 mov r4, r0 <== NOT EXECUTED 3002649c: e59f103c ldr r1, [pc, #60] ; 300264e0 <_TOD_Get_uptime_as_timespec+0x4c><== NOT EXECUTED 300264a0: e1a0000d mov r0, sp <== NOT EXECUTED 300264a4: ebff94e9 bl 3000b850 <_TOD_Get_with_nanoseconds> <== NOT EXECUTED Timestamp_Control uptime_ts; /* assume time checked for NULL by caller */ _TOD_Get_uptime( &uptime_ts ); _Timestamp_To_timespec( &uptime_ts, uptime ); 300264a8: e89d00c0 ldm sp, {r6, r7} <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 300264ac: e59f2030 ldr r2, [pc, #48] ; 300264e4 <_TOD_Get_uptime_as_timespec+0x50><== NOT EXECUTED 300264b0: e3a03000 mov r3, #0 <== NOT EXECUTED 300264b4: e1a00006 mov r0, r6 <== NOT EXECUTED 300264b8: e1a01007 mov r1, r7 <== NOT EXECUTED 300264bc: eb00a1fa bl 3004ecac <__divdi3> <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 300264c0: e1a01007 mov r1, r7 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 300264c4: e5840000 str r0, [r4] <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 300264c8: e59f2014 ldr r2, [pc, #20] ; 300264e4 <_TOD_Get_uptime_as_timespec+0x50><== NOT EXECUTED 300264cc: e1a00006 mov r0, r6 <== NOT EXECUTED 300264d0: e3a03000 mov r3, #0 <== NOT EXECUTED 300264d4: eb00a32f bl 3004f198 <__moddi3> <== NOT EXECUTED 300264d8: e5840004 str r0, [r4, #4] <== NOT EXECUTED } 300264dc: e8bd80dc pop {r2, r3, r4, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3000b078 <_TOD_Tickle_ticks>: void _TOD_Tickle_ticks( void ) { Timestamp_Control tick; uint32_t nanoseconds_per_tick; nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); 3000b078: e59f3074 ldr r3, [pc, #116] ; 3000b0f4 <_TOD_Tickle_ticks+0x7c> #include #include #include void _TOD_Tickle_ticks( void ) { 3000b07c: e92d4030 push {r4, r5, lr} Timestamp_Control tick; uint32_t nanoseconds_per_tick; nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); 3000b080: e5932010 ldr r2, [r3, #16] /* Convert the tick quantum to a timestamp */ _Timestamp_Set( &tick, 0, nanoseconds_per_tick ); /* Update the counter of ticks since boot */ _Watchdog_Ticks_since_boot += 1; 3000b084: e59f306c ldr r3, [pc, #108] ; 3000b0f8 <_TOD_Tickle_ticks+0x80> uint32_t nanoseconds_per_tick; nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); /* Convert the tick quantum to a timestamp */ _Timestamp_Set( &tick, 0, nanoseconds_per_tick ); 3000b088: e3a01000 mov r1, #0 /* Update the counter of ticks since boot */ _Watchdog_Ticks_since_boot += 1; 3000b08c: e593c000 ldr ip, [r3] 3000b090: e28cc001 add ip, ip, #1 3000b094: e583c000 str ip, [r3] static inline void _Timestamp64_implementation_Add_to( Timestamp64_Control *_time, const Timestamp64_Control *_add ) { *_time += *_add; 3000b098: e59f305c ldr r3, [pc, #92] ; 3000b0fc <_TOD_Tickle_ticks+0x84> 3000b09c: e2835008 add r5, r3, #8 3000b0a0: e8950030 ldm r5, {r4, r5} 3000b0a4: e0944002 adds r4, r4, r2 3000b0a8: e0a55001 adc r5, r5, r1 3000b0ac: e5834008 str r4, [r3, #8] 3000b0b0: e583500c str r5, [r3, #12] 3000b0b4: e8930030 ldm r3, {r4, r5} 3000b0b8: e0944002 adds r4, r4, r2 3000b0bc: e0a55001 adc r5, r5, r1 /* we do not care how much the uptime changed */ /* Update the current TOD */ _Timestamp_Add_to( &_TOD.now, &tick ); _TOD.seconds_trigger += nanoseconds_per_tick; 3000b0c0: e5931010 ldr r1, [r3, #16] 3000b0c4: e8830030 stm r3, {r4, r5} 3000b0c8: e0821001 add r1, r2, r1 if ( _TOD.seconds_trigger >= 1000000000UL ) { 3000b0cc: e59f202c ldr r2, [pc, #44] ; 3000b100 <_TOD_Tickle_ticks+0x88> /* we do not care how much the uptime changed */ /* Update the current TOD */ _Timestamp_Add_to( &_TOD.now, &tick ); _TOD.seconds_trigger += nanoseconds_per_tick; 3000b0d0: e5831010 str r1, [r3, #16] if ( _TOD.seconds_trigger >= 1000000000UL ) { 3000b0d4: e1510002 cmp r1, r2 3000b0d8: 98bd8030 popls {r4, r5, pc} _TOD.seconds_trigger -= 1000000000UL; 3000b0dc: e59f2020 ldr r2, [pc, #32] ; 3000b104 <_TOD_Tickle_ticks+0x8c><== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void ) { _Watchdog_Tickle( &_Watchdog_Seconds_chain ); 3000b0e0: e59f0020 ldr r0, [pc, #32] ; 3000b108 <_TOD_Tickle_ticks+0x90><== NOT EXECUTED 3000b0e4: e0812002 add r2, r1, r2 <== NOT EXECUTED 3000b0e8: e5832010 str r2, [r3, #16] <== NOT EXECUTED _Watchdog_Tickle_seconds(); } } 3000b0ec: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED 3000b0f0: ea00091e b 3000d570 <_Watchdog_Tickle> <== NOT EXECUTED =============================================================================== 3000adac <_TOD_Validate>: }; bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 3000adac: e92d4010 push {r4, lr} uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 3000adb0: e2504000 subs r4, r0, #0 (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; 3000adb4: 01a00004 moveq r0, r4 uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 3000adb8: 08bd8010 popeq {r4, pc} ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 3000adbc: e59f309c ldr r3, [pc, #156] ; 3000ae60 <_TOD_Validate+0xb4> 3000adc0: e59f009c ldr r0, [pc, #156] ; 3000ae64 <_TOD_Validate+0xb8> 3000adc4: e593100c ldr r1, [r3, #12] 3000adc8: eb004330 bl 3001ba90 <__aeabi_uidiv> rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 3000adcc: e5943018 ldr r3, [r4, #24] 3000add0: e1530000 cmp r3, r0 3000add4: 2a00001d bcs 3000ae50 <_TOD_Validate+0xa4> (the_tod->ticks >= ticks_per_second) || 3000add8: e5943014 ldr r3, [r4, #20] 3000addc: e353003b cmp r3, #59 ; 0x3b 3000ade0: 8a00001a bhi 3000ae50 <_TOD_Validate+0xa4> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 3000ade4: e5943010 ldr r3, [r4, #16] 3000ade8: e353003b cmp r3, #59 ; 0x3b 3000adec: 8a000017 bhi 3000ae50 <_TOD_Validate+0xa4> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 3000adf0: e594300c ldr r3, [r4, #12] 3000adf4: e3530017 cmp r3, #23 3000adf8: 8a000014 bhi 3000ae50 <_TOD_Validate+0xa4> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 3000adfc: e5943004 ldr r3, [r4, #4] rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || 3000ae00: e3530000 cmp r3, #0 (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; 3000ae04: 01a00003 moveq r0, r3 rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || 3000ae08: 08bd8010 popeq {r4, pc} (the_tod->month == 0) || 3000ae0c: e353000c cmp r3, #12 3000ae10: 8a00000e bhi 3000ae50 <_TOD_Validate+0xa4> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 3000ae14: e5942000 ldr r2, [r4] (the_tod->ticks >= ticks_per_second) || (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || 3000ae18: e59f1048 ldr r1, [pc, #72] ; 3000ae68 <_TOD_Validate+0xbc> 3000ae1c: e1520001 cmp r2, r1 3000ae20: 9a00000c bls 3000ae58 <_TOD_Validate+0xac> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 3000ae24: e5940008 ldr r0, [r4, #8] (the_tod->second >= TOD_SECONDS_PER_MINUTE) || (the_tod->minute >= TOD_MINUTES_PER_HOUR) || (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 3000ae28: e3500000 cmp r0, #0 3000ae2c: 08bd8010 popeq {r4, pc} (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 3000ae30: e3120003 tst r2, #3 3000ae34: e59f2030 ldr r2, [pc, #48] ; 3000ae6c <_TOD_Validate+0xc0> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 3000ae38: 0283300d addeq r3, r3, #13 else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 3000ae3c: e7924103 ldr r4, [r2, r3, lsl #2] const uint32_t _TOD_Days_per_month[ 2 ][ 13 ] = { { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } }; bool _TOD_Validate( 3000ae40: e1500004 cmp r0, r4 3000ae44: 83a00000 movhi r0, #0 3000ae48: 93a00001 movls r0, #1 3000ae4c: e8bd8010 pop {r4, pc} (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; 3000ae50: e3a00000 mov r0, #0 <== NOT EXECUTED 3000ae54: e8bd8010 pop {r4, pc} <== NOT EXECUTED 3000ae58: e3a00000 mov r0, #0 <== NOT EXECUTED if ( the_tod->day > days_in_month ) return false; return true; } 3000ae5c: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000c398 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 3000c398: e92d40f0 push {r4, r5, r6, r7, lr} 3000c39c: e1a04000 mov r4, r0 3000c3a0: e1a05001 mov r5, r1 3000c3a4: e20260ff and r6, r2, #255 ; 0xff States_Control state, original_state; /* * Save original state */ original_state = the_thread->current_state; 3000c3a8: e5907010 ldr r7, [r0, #16] /* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread ); 3000c3ac: eb000327 bl 3000d050 <_Thread_Set_transient> /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 3000c3b0: e5943014 ldr r3, [r4, #20] 3000c3b4: e1530005 cmp r3, r5 _Thread_Set_priority( the_thread, new_priority ); 3000c3b8: 11a00004 movne r0, r4 3000c3bc: 11a01005 movne r1, r5 3000c3c0: 1b00030c blne 3000cff8 <_Thread_Set_priority> uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000c3c4: e10f5000 mrs r5, CPSR 3000c3c8: e3853080 orr r3, r5, #128 ; 0x80 3000c3cc: e129f003 msr CPSR_fc, r3 /* * If the thread has more than STATES_TRANSIENT set, then it is blocked, * If it is blocked on a thread queue, then we need to requeue it. */ state = the_thread->current_state; 3000c3d0: e5942010 ldr r2, [r4, #16] 3000c3d4: e2077004 and r7, r7, #4 if ( state != STATES_TRANSIENT ) { 3000c3d8: e3520004 cmp r2, #4 3000c3dc: 0a00000b beq 3000c410 <_Thread_Change_priority+0x78> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 3000c3e0: e3570000 cmp r7, #0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 3000c3e4: 03c23004 biceq r3, r2, #4 <== NOT EXECUTED the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 3000c3e8: 05843010 streq r3, [r4, #16] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000c3ec: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue ( States_Control the_states ) { return (the_states & STATES_WAITING_ON_THREAD_QUEUE); 3000c3f0: e59f308c ldr r3, [pc, #140] ; 3000c484 <_Thread_Change_priority+0xec><== NOT EXECUTED 3000c3f4: e0023003 and r3, r2, r3 <== NOT EXECUTED _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { 3000c3f8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c3fc: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 3000c400: e5940044 ldr r0, [r4, #68] ; 0x44 <== NOT EXECUTED 3000c404: e1a01004 mov r1, r4 <== NOT EXECUTED if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 3000c408: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 3000c40c: ea0002d4 b 3000cf64 <_Thread_queue_Requeue> <== NOT EXECUTED } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 3000c410: e3570000 cmp r7, #0 3000c414: 1a000009 bne 3000c440 <_Thread_Change_priority+0xa8> * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); if ( prepend_it ) 3000c418: e3560000 cmp r6, #0 * Interrupts are STILL disabled. * We now know the thread will be in the READY state when we remove * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 3000c41c: e5847010 str r7, [r4, #16] */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue_first( the_thread ); 3000c420: e1a00004 mov r0, r4 3000c424: e59f305c ldr r3, [pc, #92] ; 3000c488 <_Thread_Change_priority+0xf0> if ( prepend_it ) 3000c428: 0a000002 beq 3000c438 <_Thread_Change_priority+0xa0> 3000c42c: e1a0e00f mov lr, pc 3000c430: e593f028 ldr pc, [r3, #40] ; 0x28 3000c434: ea000001 b 3000c440 <_Thread_Change_priority+0xa8> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue( the_thread ); 3000c438: e1a0e00f mov lr, pc 3000c43c: e593f024 ldr pc, [r3, #36] ; 0x24 static inline void arm_interrupt_flash( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000c440: e10f3000 mrs r3, CPSR 3000c444: e129f005 msr CPSR_fc, r5 3000c448: e129f003 msr CPSR_fc, r3 * This kernel routine implements the scheduling decision logic for * the scheduler. It does NOT dispatch. */ RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void ) { _Scheduler.Operations.schedule(); 3000c44c: e59f3034 ldr r3, [pc, #52] ; 3000c488 <_Thread_Change_priority+0xf0> 3000c450: e1a0e00f mov lr, pc 3000c454: e593f008 ldr pc, [r3, #8] * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 3000c458: e59f302c ldr r3, [pc, #44] ; 3000c48c <_Thread_Change_priority+0xf4> 3000c45c: e5932008 ldr r2, [r3, #8] * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Scheduler_Schedule(); if ( !_Thread_Is_executing_also_the_heir() && 3000c460: e593100c ldr r1, [r3, #12] 3000c464: e1520001 cmp r2, r1 3000c468: 0a000003 beq 3000c47c <_Thread_Change_priority+0xe4> 3000c46c: e5d22070 ldrb r2, [r2, #112] ; 0x70 3000c470: e3520000 cmp r2, #0 _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 3000c474: 13a02001 movne r2, #1 3000c478: 15c32004 strbne r2, [r3, #4] static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000c47c: e129f005 msr CPSR_fc, r5 3000c480: e8bd80f0 pop {r4, r5, r6, r7, pc} =============================================================================== 3000c660 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 3000c660: e92d4001 push {r0, lr} <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000c664: e1a0100d mov r1, sp <== NOT EXECUTED 3000c668: eb00006b bl 3000c81c <_Thread_Get> <== NOT EXECUTED switch ( location ) { 3000c66c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000c670: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c674: 1a000005 bne 3000c690 <_Thread_Delay_ended+0x30> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 3000c678: e59f1014 ldr r1, [pc, #20] ; 3000c694 <_Thread_Delay_ended+0x34><== NOT EXECUTED 3000c67c: ebffff83 bl 3000c490 <_Thread_Clear_state> <== NOT EXECUTED * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000c680: e59f3010 ldr r3, [pc, #16] ; 3000c698 <_Thread_Delay_ended+0x38><== NOT EXECUTED 3000c684: e5932000 ldr r2, [r3] <== NOT EXECUTED --level; 3000c688: e2422001 sub r2, r2, #1 <== NOT EXECUTED _Thread_Dispatch_disable_level = level; 3000c68c: e5832000 str r2, [r3] <== NOT EXECUTED | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 3000c690: e8bd8008 pop {r3, pc} <== NOT EXECUTED =============================================================================== 3000c81c <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 3000c81c: e1a02001 mov r2, r1 uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 3000c820: e2501000 subs r1, r0, #0 3000c824: 1a000007 bne 3000c848 <_Thread_Get+0x2c> * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000c828: e59f3074 ldr r3, [pc, #116] ; 3000c8a4 <_Thread_Get+0x88> 3000c82c: e5930000 ldr r0, [r3] ++level; 3000c830: e2800001 add r0, r0, #1 _Thread_Dispatch_disable_level = level; 3000c834: e5830000 str r0, [r3] _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 3000c838: e59f3068 ldr r3, [pc, #104] ; 3000c8a8 <_Thread_Get+0x8c> 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; 3000c83c: e5821000 str r1, [r2] tp = _Thread_Executing; 3000c840: e5930008 ldr r0, [r3, #8] goto done; 3000c844: e12fff1e bx lr */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 3000c848: e1a00c21 lsr r0, r1, #24 3000c84c: e2000007 and r0, r0, #7 */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 3000c850: e2403001 sub r3, r0, #1 3000c854: e3530002 cmp r3, #2 3000c858: 9a00000d bls 3000c894 <_Thread_Get+0x78> goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; 3000c85c: e3a03001 mov r3, #1 3000c860: e5823000 str r3, [r2] { uint32_t the_api; uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; 3000c864: e3a00000 mov r0, #0 } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; goto done; 3000c868: e12fff1e bx lr } api_information = _Objects_Information_table[ the_api ]; 3000c86c: e59fc038 ldr ip, [pc, #56] ; 3000c8ac <_Thread_Get+0x90> 3000c870: e79c0100 ldr r0, [ip, r0, lsl #2] * There is no way for this to happen if POSIX is enabled. But there * is actually a test case in sp43 for this which trips it whether or * not POSIX is enabled. So in the interest of safety, this is left * on in all configurations. */ if ( !api_information ) { 3000c874: e3500000 cmp r0, #0 3000c878: 0a000002 beq 3000c888 <_Thread_Get+0x6c> *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 3000c87c: e5900004 ldr r0, [r0, #4] if ( !information ) { 3000c880: e3500000 cmp r0, #0 3000c884: 1a000001 bne 3000c890 <_Thread_Get+0x74> *location = OBJECTS_ERROR; 3000c888: e5823000 str r3, [r2] <== NOT EXECUTED goto done; 3000c88c: e12fff1e bx lr <== NOT EXECUTED } tp = (Thread_Control *) _Objects_Get( information, id, location ); 3000c890: eafffc56 b 3000b9f0 <_Objects_Get> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 3000c894: e1a03da1 lsr r3, r1, #27 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 3000c898: e3530001 cmp r3, #1 3000c89c: 0afffff2 beq 3000c86c <_Thread_Get+0x50> 3000c8a0: eaffffed b 3000c85c <_Thread_Get+0x40> <== NOT EXECUTED =============================================================================== 3000d120 <_Thread_Start>: */ RTEMS_INLINE_ROUTINE bool _States_Is_dormant ( States_Control the_states ) { return (the_states & STATES_DORMANT); 3000d120: e590c010 ldr ip, [r0, #16] Thread_Start_types the_prototype, void *entry_point, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 3000d124: e92d4010 push {r4, lr} if ( _States_Is_dormant( the_thread->current_state ) ) { 3000d128: e21cc001 ands ip, ip, #1 Thread_Start_types the_prototype, void *entry_point, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 3000d12c: e1a04000 mov r4, r0 if ( _States_Is_dormant( the_thread->current_state ) ) { 3000d130: 0a00000c beq 3000d168 <_Thread_Start+0x48> the_thread->Start.entry_point = (Thread_Entry) entry_point; the_thread->Start.prototype = the_prototype; the_thread->Start.pointer_argument = pointer_argument; 3000d134: e5803094 str r3, [r0, #148] ; 0x94 the_thread->Start.numeric_argument = numeric_argument; 3000d138: e59d3008 ldr r3, [sp, #8] Thread_Entry_numeric_type numeric_argument ) { if ( _States_Is_dormant( the_thread->current_state ) ) { the_thread->Start.entry_point = (Thread_Entry) entry_point; 3000d13c: e580208c str r2, [r0, #140] ; 0x8c the_thread->Start.prototype = the_prototype; 3000d140: e5801090 str r1, [r0, #144] ; 0x90 the_thread->Start.pointer_argument = pointer_argument; the_thread->Start.numeric_argument = numeric_argument; 3000d144: e5803098 str r3, [r0, #152] ; 0x98 _Thread_Load_environment( the_thread ); 3000d148: eb000952 bl 3000f698 <_Thread_Load_environment> _Thread_Ready( the_thread ); 3000d14c: e1a00004 mov r0, r4 3000d150: eb0009e6 bl 3000f8f0 <_Thread_Ready> ); } static inline void _User_extensions_Thread_start( Thread_Control *started ) { _User_extensions_Iterate( 3000d154: e1a00004 mov r0, r4 3000d158: e59f1010 ldr r1, [pc, #16] ; 3000d170 <_Thread_Start+0x50> 3000d15c: eb000041 bl 3000d268 <_User_extensions_Iterate> _User_extensions_Thread_start( the_thread ); return true; 3000d160: e3a00001 mov r0, #1 3000d164: e8bd8010 pop {r4, pc} } return false; 3000d168: e1a0000c mov r0, ip <== NOT EXECUTED } 3000d16c: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000c34c <_Thread_blocking_operation_Cancel>: #endif /* * The thread is not waiting on anything after this completes. */ the_thread->Wait.queue = NULL; 3000c34c: e3a03000 mov r3, #0 <== NOT EXECUTED Thread_blocking_operation_States sync_state __attribute__((unused)), #endif Thread_Control *the_thread, ISR_Level level ) { 3000c350: e92d4010 push {r4, lr} <== NOT EXECUTED #endif /* * The thread is not waiting on anything after this completes. */ the_thread->Wait.queue = NULL; 3000c354: e5813044 str r3, [r1, #68] ; 0x44 <== NOT EXECUTED /* * If the sync state is timed out, this is very likely not needed. * But better safe than sorry when it comes to critical sections. */ if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 3000c358: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED Thread_blocking_operation_States sync_state __attribute__((unused)), #endif Thread_Control *the_thread, ISR_Level level ) { 3000c35c: e1a04001 mov r4, r1 <== NOT EXECUTED /* * If the sync state is timed out, this is very likely not needed. * But better safe than sorry when it comes to critical sections. */ if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 3000c360: e3530002 cmp r3, #2 <== NOT EXECUTED 3000c364: 1a000005 bne 3000c380 <_Thread_blocking_operation_Cancel+0x34><== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 3000c368: e3a03003 mov r3, #3 <== NOT EXECUTED 3000c36c: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 3000c370: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); 3000c374: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 3000c378: eb000453 bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED 3000c37c: ea000000 b 3000c384 <_Thread_blocking_operation_Cancel+0x38><== NOT EXECUTED 3000c380: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 3000c384: e59f1008 ldr r1, [pc, #8] ; 3000c394 <_Thread_blocking_operation_Cancel+0x48><== NOT EXECUTED 3000c388: e1a00004 mov r0, r4 <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 3000c38c: e8bd4010 pop {r4, lr} <== NOT EXECUTED 3000c390: ea00003e b 3000c490 <_Thread_Clear_state> <== NOT EXECUTED =============================================================================== 3000f6e4 <_Thread_queue_Dequeue_fifo>: #include Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 3000f6e4: e92d4010 push {r4, lr} uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000f6e8: e10f3000 mrs r3, CPSR 3000f6ec: e3832080 orr r2, r3, #128 ; 0x80 3000f6f0: e129f002 msr CPSR_fc, r2 */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3000f6f4: e1a02000 mov r2, r0 3000f6f8: e4924004 ldr r4, [r2], #4 ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 3000f6fc: e1540002 cmp r4, r2 3000f700: 0a000012 beq 3000f750 <_Thread_queue_Dequeue_fifo+0x6c> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 3000f704: e5942000 ldr r2, [r4] head->next = new_first; 3000f708: e5802000 str r2, [r0] new_first->previous = head; 3000f70c: e5820004 str r0, [r2, #4] the_thread = (Thread_Control *) _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; 3000f710: e3a02000 mov r2, #0 3000f714: e5842044 str r2, [r4, #68] ; 0x44 if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 3000f718: e5942050 ldr r2, [r4, #80] ; 0x50 3000f71c: e3520002 cmp r2, #2 3000f720: 0a000001 beq 3000f72c <_Thread_queue_Dequeue_fifo+0x48> static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000f724: e129f003 msr CPSR_fc, r3 3000f728: ea000004 b 3000f740 <_Thread_queue_Dequeue_fifo+0x5c> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 3000f72c: e3a02003 mov r2, #3 <== NOT EXECUTED 3000f730: e5842050 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED 3000f734: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); 3000f738: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000f73c: ebfff762 bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 3000f740: e1a00004 mov r0, r4 3000f744: e59f1014 ldr r1, [pc, #20] ; 3000f760 <_Thread_queue_Dequeue_fifo+0x7c> 3000f748: ebfff350 bl 3000c490 <_Thread_Clear_state> 3000f74c: ea000001 b 3000f758 <_Thread_queue_Dequeue_fifo+0x74> 3000f750: e129f003 msr CPSR_fc, r3 return the_thread; } _ISR_Enable( level ); return NULL; 3000f754: e3a04000 mov r4, #0 } 3000f758: e1a00004 mov r0, r4 3000f75c: e8bd8010 pop {r4, pc} =============================================================================== 3000cb84 <_Thread_queue_Dequeue_priority>: #include Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 3000cb84: e92d4030 push {r4, r5, lr} uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000cb88: e10f2000 mrs r2, CPSR 3000cb8c: e3823080 orr r3, r2, #128 ; 0x80 3000cb90: e129f003 msr CPSR_fc, r3 Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; 3000cb94: e3a03000 mov r3, #0 index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { 3000cb98: e3a0c00c mov ip, #12 3000cb9c: e001039c mul r1, ip, r3 */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3000cba0: e7904001 ldr r4, [r0, r1] 3000cba4: e0805001 add r5, r0, r1 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 3000cba8: e2851004 add r1, r5, #4 3000cbac: e1540001 cmp r4, r1 3000cbb0: 0a000008 beq 3000cbd8 <_Thread_queue_Dequeue_priority+0x54> */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 3000cbb4: e3a03000 mov r3, #0 3000cbb8: e5843044 str r3, [r4, #68] ; 0x44 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 3000cbbc: e5943038 ldr r3, [r4, #56] ; 0x38 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 3000cbc0: e284c03c add ip, r4, #60 ; 0x3c new_first_node = _Chain_First( &the_thread->Wait.Block2n ); 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 ) ) { 3000cbc4: e153000c cmp r3, ip dequeue: the_thread->Wait.queue = NULL; new_first_node = _Chain_First( &the_thread->Wait.Block2n ); new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 3000cbc8: e5941000 ldr r1, [r4] previous_node = the_thread->Object.Node.previous; 3000cbcc: e5940004 ldr r0, [r4, #4] if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 3000cbd0: 1a000006 bne 3000cbf0 <_Thread_queue_Dequeue_priority+0x6c> 3000cbd4: ea000016 b 3000cc34 <_Thread_queue_Dequeue_priority+0xb0> Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 3000cbd8: e2833001 add r3, r3, #1 Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; 3000cbdc: e3530004 cmp r3, #4 3000cbe0: 1affffed bne 3000cb9c <_Thread_queue_Dequeue_priority+0x18> static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000cbe4: e129f002 msr CPSR_fc, r2 /* * We did not find a thread to unblock. */ _ISR_Enable( level ); return NULL; 3000cbe8: e3a04000 mov r4, #0 3000cbec: ea00001f b 3000cc70 <_Thread_queue_Dequeue_priority+0xec> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last( Chain_Control *the_chain ) { return _Chain_Tail( the_chain )->previous; 3000cbf0: e594c040 ldr ip, [r4, #64] ; 0x40 <== NOT EXECUTED next_node = the_thread->Object.Node.next; previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { last_node = _Chain_Last( &the_thread->Wait.Block2n ); new_second_node = new_first_node->next; 3000cbf4: e593e000 ldr lr, [r3] <== NOT EXECUTED previous_node->next = new_first_node; next_node->previous = new_first_node; 3000cbf8: e5813004 str r3, [r1, #4] <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { last_node = _Chain_Last( &the_thread->Wait.Block2n ); new_second_node = new_first_node->next; previous_node->next = new_first_node; 3000cbfc: e5803000 str r3, [r0] <== NOT EXECUTED next_node->previous = new_first_node; new_first_node->next = next_node; new_first_node->previous = previous_node; 3000cc00: e5830004 str r0, [r3, #4] <== NOT EXECUTED last_node = _Chain_Last( &the_thread->Wait.Block2n ); new_second_node = new_first_node->next; previous_node->next = new_first_node; next_node->previous = new_first_node; new_first_node->next = next_node; 3000cc04: e5831000 str r1, [r3] <== NOT EXECUTED new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 3000cc08: e5940038 ldr r0, [r4, #56] ; 0x38 <== NOT EXECUTED 3000cc0c: e5941040 ldr r1, [r4, #64] ; 0x40 <== NOT EXECUTED 3000cc10: e1500001 cmp r0, r1 <== NOT EXECUTED 3000cc14: 0a000008 beq 3000cc3c <_Thread_queue_Dequeue_priority+0xb8><== NOT EXECUTED /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 3000cc18: e2831038 add r1, r3, #56 ; 0x38 <== NOT EXECUTED tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); new_second_node->previous = head; head->next = new_second_node; 3000cc1c: e583e038 str lr, [r3, #56] ; 0x38 <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); new_second_node->previous = head; 3000cc20: e58e1004 str r1, [lr, #4] <== NOT EXECUTED head->next = new_second_node; tail->previous = last_node; 3000cc24: e583c040 str ip, [r3, #64] ; 0x40 <== NOT EXECUTED new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); 3000cc28: e283303c add r3, r3, #60 ; 0x3c <== NOT EXECUTED new_second_node->previous = head; head->next = new_second_node; tail->previous = last_node; last_node->next = tail; 3000cc2c: e58c3000 str r3, [ip] <== NOT EXECUTED 3000cc30: ea000001 b 3000cc3c <_Thread_queue_Dequeue_priority+0xb8> <== NOT EXECUTED } } else { previous_node->next = next_node; 3000cc34: e5801000 str r1, [r0] next_node->previous = previous_node; 3000cc38: e5810004 str r0, [r1, #4] } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 3000cc3c: e5943050 ldr r3, [r4, #80] ; 0x50 3000cc40: e3530002 cmp r3, #2 3000cc44: 0a000001 beq 3000cc50 <_Thread_queue_Dequeue_priority+0xcc> 3000cc48: e129f002 msr CPSR_fc, r2 3000cc4c: ea000004 b 3000cc64 <_Thread_queue_Dequeue_priority+0xe0> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 3000cc50: e3a03003 mov r3, #3 <== NOT EXECUTED 3000cc54: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000cc58: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); 3000cc5c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000cc60: eb000219 bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 3000cc64: e1a00004 mov r0, r4 3000cc68: e59f1008 ldr r1, [pc, #8] ; 3000cc78 <_Thread_queue_Dequeue_priority+0xf4> 3000cc6c: ebfffe07 bl 3000c490 <_Thread_Clear_state> #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 3000cc70: e1a00004 mov r0, r4 3000cc74: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000f764 <_Thread_queue_Enqueue_fifo>: Thread_blocking_operation_States _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 3000f764: e92d4010 push {r4, lr} 3000f768: e1a03000 mov r3, r0 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000f76c: e10fc000 mrs ip, CPSR 3000f770: e38c0080 orr r0, ip, #128 ; 0x80 3000f774: e129f000 msr CPSR_fc, r0 Thread_blocking_operation_States sync_state; ISR_Level level; _ISR_Disable( level ); sync_state = the_thread_queue->sync_state; 3000f778: e5930030 ldr r0, [r3, #48] ; 0x30 the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 3000f77c: e3a04000 mov r4, #0 if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { 3000f780: e3500001 cmp r0, #1 ISR_Level level; _ISR_Disable( level ); sync_state = the_thread_queue->sync_state; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 3000f784: e5834030 str r4, [r3, #48] ; 0x30 if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { 3000f788: 1a000008 bne 3000f7b0 <_Thread_queue_Enqueue_fifo+0x4c> Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 3000f78c: e5932008 ldr r2, [r3, #8] RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 3000f790: e2834004 add r4, r3, #4 Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 3000f794: e5831008 str r1, [r3, #8] ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; the_node->next = tail; 3000f798: e5814000 str r4, [r1] tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last; 3000f79c: e5812004 str r2, [r1, #4] Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; old_last->next = the_node; 3000f7a0: e5821000 str r1, [r2] _Chain_Append_unprotected( &the_thread_queue->Queues.Fifo, &the_thread->Object.Node ); the_thread->Wait.queue = the_thread_queue; 3000f7a4: e5813044 str r3, [r1, #68] ; 0x44 static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000f7a8: e129f00c msr CPSR_fc, ip the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 3000f7ac: e8bd8010 pop {r4, pc} * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 3000f7b0: e582c000 str ip, [r2] <== NOT EXECUTED return sync_state; } 3000f7b4: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000cd1c <_Thread_queue_Enqueue_priority>: RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 3000cd1c: e281c03c add ip, r1, #60 ; 0x3c head->next = tail; 3000cd20: e581c038 str ip, [r1, #56] ; 0x38 head->previous = NULL; 3000cd24: e3a0c000 mov ip, #0 3000cd28: e581c03c str ip, [r1, #60] ; 0x3c Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 3000cd2c: e591c014 ldr ip, [r1, #20] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 3000cd30: e2813038 add r3, r1, #56 ; 0x38 Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 3000cd34: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} head->next = tail; head->previous = NULL; tail->previous = head; 3000cd38: e5813040 str r3, [r1, #64] ; 0x40 _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 3000cd3c: e3a0500c mov r5, #12 RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number ( Priority_Control the_priority ) { return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER); 3000cd40: e1a0332c lsr r3, ip, #6 block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 3000cd44: e31c0020 tst ip, #32 _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 3000cd48: e0250593 mla r5, r3, r5, r0 block_state = the_thread_queue->state; 3000cd4c: e5908038 ldr r8, [r0, #56] ; 0x38 the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 3000cd50: 159fa150 ldrne sl, [pc, #336] ; 3000cea8 <_Thread_queue_Enqueue_priority+0x18c> 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 ) ) 3000cd54: 1a000022 bne 3000cde4 <_Thread_queue_Enqueue_priority+0xc8> RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( const Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Immutable_tail( the_chain )); 3000cd58: e285a004 add sl, r5, #4 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000cd5c: e10f4000 mrs r4, CPSR 3000cd60: e3843080 orr r3, r4, #128 ; 0x80 3000cd64: e129f003 msr CPSR_fc, r3 3000cd68: e1a06004 mov r6, r4 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; 3000cd6c: e3e07000 mvn r7, #0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 3000cd70: e5953000 ldr r3, [r5] _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 3000cd74: ea00000b b 3000cda8 <_Thread_queue_Enqueue_priority+0x8c> search_priority = search_thread->current_priority; 3000cd78: e5937014 ldr r7, [r3, #20] if ( priority <= search_priority ) 3000cd7c: e15c0007 cmp ip, r7 3000cd80: 9a00000a bls 3000cdb0 <_Thread_queue_Enqueue_priority+0x94> static inline void arm_interrupt_flash( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000cd84: e10f9000 mrs r9, CPSR 3000cd88: e129f004 msr CPSR_fc, r4 3000cd8c: e129f009 msr CPSR_fc, r9 RTEMS_INLINE_ROUTINE bool _States_Are_set ( States_Control the_states, States_Control mask ) { return ( (the_states & mask) != STATES_READY); 3000cd90: e5939010 ldr r9, [r3, #16] search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { 3000cd94: e1180009 tst r8, r9 3000cd98: 1a000001 bne 3000cda4 <_Thread_queue_Enqueue_priority+0x88> static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000cd9c: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000cda0: eaffffed b 3000cd5c <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED _ISR_Enable( level ); goto restart_forward_search; } search_thread = 3000cda4: e5933000 ldr r3, [r3] restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 3000cda8: e153000a cmp r3, sl 3000cdac: 1afffff1 bne 3000cd78 <_Thread_queue_Enqueue_priority+0x5c> } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 3000cdb0: e5905030 ldr r5, [r0, #48] ; 0x30 3000cdb4: e3550001 cmp r5, #1 3000cdb8: 1a000037 bne 3000ce9c <_Thread_queue_Enqueue_priority+0x180> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 3000cdbc: e3a02000 mov r2, #0 if ( priority == search_priority ) 3000cdc0: e15c0007 cmp ip, r7 if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 3000cdc4: e5802030 str r2, [r0, #48] ; 0x30 if ( priority == search_priority ) 3000cdc8: 0a000029 beq 3000ce74 <_Thread_queue_Enqueue_priority+0x158> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 3000cdcc: e5932004 ldr r2, [r3, #4] the_node = (Chain_Node *) the_thread; the_node->next = search_node; 3000cdd0: e5813000 str r3, [r1] the_node->previous = previous_node; 3000cdd4: e5812004 str r2, [r1, #4] previous_node->next = the_node; 3000cdd8: e5821000 str r1, [r2] search_node->previous = the_node; 3000cddc: e5831004 str r1, [r3, #4] 3000cde0: ea000020 b 3000ce68 <_Thread_queue_Enqueue_priority+0x14c> the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 3000cde4: e5da7000 ldrb r7, [sl] 3000cde8: e2877001 add r7, r7, #1 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000cdec: e10f4000 mrs r4, CPSR 3000cdf0: e3843080 orr r3, r4, #128 ; 0x80 3000cdf4: e129f003 msr CPSR_fc, r3 3000cdf8: e1a06004 mov r6, r4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last( Chain_Control *the_chain ) { return _Chain_Tail( the_chain )->previous; 3000cdfc: e5953008 ldr r3, [r5, #8] _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 3000ce00: ea00000b b 3000ce34 <_Thread_queue_Enqueue_priority+0x118> search_priority = search_thread->current_priority; 3000ce04: e5937014 ldr r7, [r3, #20] if ( priority >= search_priority ) 3000ce08: e15c0007 cmp ip, r7 3000ce0c: 2a00000a bcs 3000ce3c <_Thread_queue_Enqueue_priority+0x120> static inline void arm_interrupt_flash( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000ce10: e10f9000 mrs r9, CPSR <== NOT EXECUTED 3000ce14: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000ce18: e129f009 msr CPSR_fc, r9 <== NOT EXECUTED 3000ce1c: e5939010 ldr r9, [r3, #16] <== NOT EXECUTED search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { 3000ce20: e1180009 tst r8, r9 <== NOT EXECUTED 3000ce24: 1a000001 bne 3000ce30 <_Thread_queue_Enqueue_priority+0x114><== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000ce28: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000ce2c: eaffffec b 3000cde4 <_Thread_queue_Enqueue_priority+0xc8> <== NOT EXECUTED _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 3000ce30: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_Last( header ); while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 3000ce34: e1530005 cmp r3, r5 3000ce38: 1afffff1 bne 3000ce04 <_Thread_queue_Enqueue_priority+0xe8> } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 3000ce3c: e5905030 ldr r5, [r0, #48] ; 0x30 3000ce40: e3550001 cmp r5, #1 3000ce44: 1a000014 bne 3000ce9c <_Thread_queue_Enqueue_priority+0x180> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 3000ce48: e3a02000 mov r2, #0 if ( priority == search_priority ) 3000ce4c: e15c0007 cmp ip, r7 if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 3000ce50: e5802030 str r2, [r0, #48] ; 0x30 if ( priority == search_priority ) 3000ce54: 0a000006 beq 3000ce74 <_Thread_queue_Enqueue_priority+0x158> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 3000ce58: e5932000 ldr r2, [r3] the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 3000ce5c: e881000c stm r1, {r2, r3} search_node->next = the_node; 3000ce60: e5831000 str r1, [r3] next_node->previous = the_node; 3000ce64: e5821004 str r1, [r2, #4] the_thread->Wait.queue = the_thread_queue; 3000ce68: e5810044 str r0, [r1, #68] ; 0x44 3000ce6c: e129f004 msr CPSR_fc, r4 3000ce70: ea000007 b 3000ce94 <_Thread_queue_Enqueue_priority+0x178> _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 3000ce74: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); 3000ce78: e283c03c add ip, r3, #60 ; 0x3c <== NOT EXECUTED previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; 3000ce7c: e581c000 str ip, [r1] <== NOT EXECUTED the_node->previous = previous_node; 3000ce80: e5812004 str r2, [r1, #4] <== NOT EXECUTED previous_node->next = the_node; 3000ce84: e5821000 str r1, [r2] <== NOT EXECUTED search_node->previous = the_node; 3000ce88: e5831040 str r1, [r3, #64] ; 0x40 <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 3000ce8c: e5810044 str r0, [r1, #68] ; 0x44 <== NOT EXECUTED 3000ce90: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 3000ce94: e3a00001 mov r0, #1 3000ce98: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 3000ce9c: e5826000 str r6, [r2] <== NOT EXECUTED return the_thread_queue->sync_state; 3000cea0: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED } 3000cea4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED =============================================================================== 30010b64 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread ) { 30010b64: e92d4010 push {r4, lr} 30010b68: e1a04001 mov r4, r1 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 30010b6c: e10f3000 mrs r3, CPSR 30010b70: e3832080 orr r2, r3, #128 ; 0x80 30010b74: e129f002 msr CPSR_fc, r2 30010b78: e59f2060 ldr r2, [pc, #96] ; 30010be0 <_Thread_queue_Extract_fifo+0x7c> 30010b7c: e5911010 ldr r1, [r1, #16] 30010b80: e0012002 and r2, r1, r2 ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 30010b84: e3520000 cmp r2, #0 30010b88: 1a000001 bne 30010b94 <_Thread_queue_Extract_fifo+0x30> static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 30010b8c: e129f003 msr CPSR_fc, r3 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 30010b90: e8bd8010 pop {r4, pc} { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 30010b94: e8940006 ldm r4, {r1, r2} next->previous = previous; 30010b98: e5812004 str r2, [r1, #4] previous->next = next; 30010b9c: e5821000 str r1, [r2] return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 30010ba0: e3a02000 mov r2, #0 30010ba4: e5842044 str r2, [r4, #68] ; 0x44 if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 30010ba8: e5942050 ldr r2, [r4, #80] ; 0x50 30010bac: e3520002 cmp r2, #2 30010bb0: 0a000001 beq 30010bbc <_Thread_queue_Extract_fifo+0x58> 30010bb4: e129f003 msr CPSR_fc, r3 30010bb8: ea000004 b 30010bd0 <_Thread_queue_Extract_fifo+0x6c> 30010bbc: e3a02003 mov r2, #3 <== NOT EXECUTED 30010bc0: e5842050 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED 30010bc4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); 30010bc8: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30010bcc: ebfff23e bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 30010bd0: e59f100c ldr r1, [pc, #12] ; 30010be4 <_Thread_queue_Extract_fifo+0x80> 30010bd4: e1a00004 mov r0, r4 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 30010bd8: e8bd4010 pop {r4, lr} 30010bdc: eaffee2b b 3000c490 <_Thread_Clear_state> =============================================================================== 3000f7d0 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread, bool requeuing ) { 3000f7d0: e92d4070 push {r4, r5, r6, lr} 3000f7d4: e20220ff and r2, r2, #255 ; 0xff 3000f7d8: e1a04001 mov r4, r1 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000f7dc: e10f1000 mrs r1, CPSR 3000f7e0: e3813080 orr r3, r1, #128 ; 0x80 3000f7e4: e129f003 msr CPSR_fc, r3 */ RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue ( States_Control the_states ) { return (the_states & STATES_WAITING_ON_THREAD_QUEUE); 3000f7e8: e59f30ac ldr r3, [pc, #172] ; 3000f89c <_Thread_queue_Extract_priority_helper+0xcc> 3000f7ec: e5940010 ldr r0, [r4, #16] 3000f7f0: e0003003 and r3, r0, r3 Chain_Node *new_second_node; Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 3000f7f4: e3530000 cmp r3, #0 3000f7f8: 0a000017 beq 3000f85c <_Thread_queue_Extract_priority_helper+0x8c> */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3000f7fc: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 3000f800: e284503c add r5, r4, #60 ; 0x3c <== NOT EXECUTED */ next_node = the_node->next; previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 3000f804: e1530005 cmp r3, r5 <== NOT EXECUTED /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; previous_node = the_node->previous; 3000f808: e8941001 ldm r4, {r0, ip} <== NOT EXECUTED head->next = new_second_node; tail->previous = last_node; last_node->next = tail; } } else { previous_node->next = next_node; 3000f80c: 058c0000 streq r0, [ip] <== NOT EXECUTED next_node->previous = previous_node; 3000f810: 0580c004 streq ip, [r0, #4] <== NOT EXECUTED */ next_node = the_node->next; previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 3000f814: 0a00000e beq 3000f854 <_Thread_queue_Extract_priority_helper+0x84><== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last( Chain_Control *the_chain ) { return _Chain_Tail( the_chain )->previous; 3000f818: e5945040 ldr r5, [r4, #64] ; 0x40 <== NOT EXECUTED new_first_node = _Chain_First( &the_thread->Wait.Block2n ); new_first_thread = (Thread_Control *) new_first_node; last_node = _Chain_Last( &the_thread->Wait.Block2n ); new_second_node = new_first_node->next; 3000f81c: e5936000 ldr r6, [r3] <== NOT EXECUTED previous_node->next = new_first_node; next_node->previous = new_first_node; 3000f820: e5803004 str r3, [r0, #4] <== NOT EXECUTED new_first_node = _Chain_First( &the_thread->Wait.Block2n ); new_first_thread = (Thread_Control *) new_first_node; last_node = _Chain_Last( &the_thread->Wait.Block2n ); new_second_node = new_first_node->next; previous_node->next = new_first_node; 3000f824: e58c3000 str r3, [ip] <== NOT EXECUTED next_node->previous = new_first_node; new_first_node->next = next_node; new_first_node->previous = previous_node; 3000f828: e8831001 stm r3, {r0, ip} <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 3000f82c: e594c038 ldr ip, [r4, #56] ; 0x38 <== NOT EXECUTED 3000f830: e5940040 ldr r0, [r4, #64] ; 0x40 <== NOT EXECUTED 3000f834: e15c0000 cmp ip, r0 <== NOT EXECUTED 3000f838: 0a000005 beq 3000f854 <_Thread_queue_Extract_priority_helper+0x84><== NOT EXECUTED /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 3000f83c: e2830038 add r0, r3, #56 ; 0x38 <== NOT EXECUTED tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); new_second_node->previous = head; head->next = new_second_node; 3000f840: e5836038 str r6, [r3, #56] ; 0x38 <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); new_second_node->previous = head; 3000f844: e5860004 str r0, [r6, #4] <== NOT EXECUTED head->next = new_second_node; tail->previous = last_node; 3000f848: e5835040 str r5, [r3, #64] ; 0x40 <== NOT EXECUTED new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); 3000f84c: e283303c add r3, r3, #60 ; 0x3c <== NOT EXECUTED new_second_node->previous = head; head->next = new_second_node; tail->previous = last_node; last_node->next = tail; 3000f850: e5853000 str r3, [r5] <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 3000f854: e3520000 cmp r2, #0 <== NOT EXECUTED 3000f858: 0a000001 beq 3000f864 <_Thread_queue_Extract_priority_helper+0x94><== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000f85c: e129f001 msr CPSR_fc, r1 3000f860: e8bd8070 pop {r4, r5, r6, pc} _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 3000f864: e5943050 ldr r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000f868: e3530002 cmp r3, #2 <== NOT EXECUTED 3000f86c: 0a000001 beq 3000f878 <_Thread_queue_Extract_priority_helper+0xa8><== NOT EXECUTED 3000f870: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 3000f874: ea000004 b 3000f88c <_Thread_queue_Extract_priority_helper+0xbc><== NOT EXECUTED 3000f878: e3a03003 mov r3, #3 <== NOT EXECUTED 3000f87c: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000f880: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); 3000f884: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000f888: ebfff70f bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED 3000f88c: e59f100c ldr r1, [pc, #12] ; 3000f8a0 <_Thread_queue_Extract_priority_helper+0xd0><== NOT EXECUTED 3000f890: e1a00004 mov r0, r4 <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 3000f894: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED 3000f898: eafff2fc b 3000c490 <_Thread_Clear_state> <== NOT EXECUTED =============================================================================== 3001f4a8 <_Thread_queue_First_priority>: Thread_queue_Control *the_thread_queue ) { uint32_t index; for( index=0 ; 3001f4a8: e3a03000 mov r3, #0 <== NOT EXECUTED index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) 3001f4ac: e3a0100c mov r1, #12 <== NOT EXECUTED 3001f4b0: e0020391 mul r2, r1, r3 <== NOT EXECUTED 3001f4b4: e080c002 add ip, r0, r2 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3001f4b8: e7902002 ldr r2, [r0, r2] <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 3001f4bc: e28cc004 add ip, ip, #4 <== NOT EXECUTED 3001f4c0: e152000c cmp r2, ip <== NOT EXECUTED 3001f4c4: 1a000003 bne 3001f4d8 <_Thread_queue_First_priority+0x30> <== NOT EXECUTED { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 3001f4c8: e2833001 add r3, r3, #1 <== NOT EXECUTED Thread_queue_Control *the_thread_queue ) { uint32_t index; for( index=0 ; 3001f4cc: e3530004 cmp r3, #4 <== NOT EXECUTED 3001f4d0: 1afffff6 bne 3001f4b0 <_Thread_queue_First_priority+0x8> <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Priority[ index ] ); } return NULL; 3001f4d4: e3a02000 mov r2, #0 <== NOT EXECUTED } 3001f4d8: e1a00002 mov r0, r2 <== NOT EXECUTED 3001f4dc: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000f8a4 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 3000f8a4: e1a01000 mov r1, r0 <== NOT EXECUTED Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 3000f8a8: e5900044 ldr r0, [r0, #68] ; 0x44 <== 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. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && 3000f8ac: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000f8b0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f8b4: 0a000009 beq 3000f8e0 <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 3000f8b8: e59f202c ldr r2, [pc, #44] ; 3000f8ec <_Thread_queue_Process_timeout+0x48><== NOT EXECUTED 3000f8bc: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000f8c0: e1510002 cmp r1, r2 <== NOT EXECUTED 3000f8c4: 1a000005 bne 3000f8e0 <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 3000f8c8: e3530003 cmp r3, #3 <== NOT EXECUTED the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 3000f8cc: 1590303c ldrne r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000f8d0: 15813034 strne r3, [r1, #52] ; 0x34 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 3000f8d4: 13a03002 movne r3, #2 <== NOT EXECUTED 3000f8d8: 15803030 strne r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000f8dc: e12fff1e bx lr <== NOT EXECUTED } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 3000f8e0: e590303c ldr r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000f8e4: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 3000f8e8: eaffffb2 b 3000f7b8 <_Thread_queue_Extract> <== NOT EXECUTED =============================================================================== 3000cf64 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 3000cf64: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 3000cf68: e2504000 subs r4, r0, #0 <== NOT EXECUTED void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 3000cf6c: e1a05001 mov r5, r1 <== NOT EXECUTED /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 3000cf70: 0a000011 beq 3000cfbc <_Thread_queue_Requeue+0x58> <== NOT EXECUTED /* * If queueing by FIFO, there is nothing to do. This only applies to * priority blocking discipline. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 3000cf74: e5942034 ldr r2, [r4, #52] ; 0x34 <== NOT EXECUTED 3000cf78: e3520001 cmp r2, #1 <== NOT EXECUTED 3000cf7c: 1a00000e bne 3000cfbc <_Thread_queue_Requeue+0x58> <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000cf80: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000cf84: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000cf88: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 3000cf8c: e59f302c ldr r3, [pc, #44] ; 3000cfc0 <_Thread_queue_Requeue+0x5c><== NOT EXECUTED 3000cf90: e591c010 ldr ip, [r1, #16] <== NOT EXECUTED 3000cf94: e00c3003 and r3, ip, r3 <== NOT EXECUTED Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 3000cf98: e3530000 cmp r3, #0 <== NOT EXECUTED 3000cf9c: 0a000005 beq 3000cfb8 <_Thread_queue_Requeue+0x54> <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 3000cfa0: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); 3000cfa4: eb000a09 bl 3000f7d0 <_Thread_queue_Extract_priority_helper><== NOT EXECUTED (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 3000cfa8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cfac: e1a01005 mov r1, r5 <== NOT EXECUTED 3000cfb0: e1a0200d mov r2, sp <== NOT EXECUTED 3000cfb4: ebffff58 bl 3000cd1c <_Thread_queue_Enqueue_priority> <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000cfb8: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED } _ISR_Enable( level ); } } 3000cfbc: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000cfc4 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 3000cfc4: e92d4001 push {r0, lr} <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000cfc8: e1a0100d mov r1, sp <== NOT EXECUTED 3000cfcc: ebfffe12 bl 3000c81c <_Thread_Get> <== NOT EXECUTED switch ( location ) { 3000cfd0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000cfd4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000cfd8: 1a000004 bne 3000cff0 <_Thread_queue_Timeout+0x2c> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 3000cfdc: eb000a30 bl 3000f8a4 <_Thread_queue_Process_timeout> <== NOT EXECUTED * * This routine decrements the thread dispatch level. */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000cfe0: e59f300c ldr r3, [pc, #12] ; 3000cff4 <_Thread_queue_Timeout+0x30><== NOT EXECUTED 3000cfe4: e5932000 ldr r2, [r3] <== NOT EXECUTED --level; 3000cfe8: e2422001 sub r2, r2, #1 <== NOT EXECUTED _Thread_Dispatch_disable_level = level; 3000cfec: e5832000 str r2, [r3] <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 3000cff0: e8bd8008 pop {r3, pc} <== NOT EXECUTED =============================================================================== 300191bc <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 300191bc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED 300191c0: e24dd01c sub sp, sp, #28 <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 300191c4: e28d8004 add r8, sp, #4 <== NOT EXECUTED 300191c8: e28d5010 add r5, sp, #16 <== NOT EXECUTED head->previous = NULL; 300191cc: e3a03000 mov r3, #0 <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 300191d0: e2889004 add r9, r8, #4 <== NOT EXECUTED 300191d4: e2856004 add r6, r5, #4 <== NOT EXECUTED 300191d8: e1a04000 mov r4, r0 <== NOT EXECUTED 300191dc: e58d9004 str r9, [sp, #4] <== NOT EXECUTED head->previous = NULL; 300191e0: e58d3008 str r3, [sp, #8] <== NOT EXECUTED tail->previous = head; 300191e4: e58d800c str r8, [sp, #12] <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 300191e8: e58d6010 str r6, [sp, #16] <== NOT EXECUTED head->previous = NULL; 300191ec: e58d3014 str r3, [sp, #20] <== NOT EXECUTED tail->previous = head; 300191f0: e58d5018 str r5, [sp, #24] <== NOT EXECUTED static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 300191f4: e59f7178 ldr r7, [pc, #376] ; 30019374 <_Timer_server_Body+0x1b8><== NOT EXECUTED { /* * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain; 300191f8: e5848078 str r8, [r4, #120] ; 0x78 <== NOT EXECUTED static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 300191fc: e5973000 ldr r3, [r7] <== NOT EXECUTED /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 30019200: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 30019204: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 30019208: e0611003 rsb r1, r1, r3 <== NOT EXECUTED /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; 3001920c: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 30019210: e1a02005 mov r2, r5 <== NOT EXECUTED 30019214: eb001079 bl 3001d400 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 30019218: e59f3158 ldr r3, [pc, #344] ; 30019378 <_Timer_server_Body+0x1bc><== NOT EXECUTED 3001921c: e59f2158 ldr r2, [pc, #344] ; 3001937c <_Timer_server_Body+0x1c0><== NOT EXECUTED 30019220: e8930003 ldm r3, {r0, r1} <== NOT EXECUTED 30019224: e3a03000 mov r3, #0 <== NOT EXECUTED 30019228: eb004b53 bl 3002bf7c <__divdi3> <== NOT EXECUTED Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 3001922c: e5942074 ldr r2, [r4, #116] ; 0x74 <== NOT EXECUTED 30019230: e1a0a000 mov sl, r0 <== NOT EXECUTED /* * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the watchdogs->Chain to indicate this. */ if ( snapshot > last_snapshot ) { 30019234: e1500002 cmp r0, r2 <== NOT EXECUTED 30019238: 9a000004 bls 30019250 <_Timer_server_Body+0x94> <== NOT EXECUTED /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 3001923c: e062100a rsb r1, r2, sl <== NOT EXECUTED 30019240: e2840068 add r0, r4, #104 ; 0x68 <== NOT EXECUTED 30019244: e1a02005 mov r2, r5 <== NOT EXECUTED 30019248: eb00106c bl 3001d400 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 3001924c: ea000003 b 30019260 <_Timer_server_Body+0xa4> <== NOT EXECUTED /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 30019250: 32840068 addcc r0, r4, #104 ; 0x68 <== NOT EXECUTED 30019254: 33a01001 movcc r1, #1 <== NOT EXECUTED 30019258: 306a2002 rsbcc r2, sl, r2 <== NOT EXECUTED 3001925c: 3b00103f blcc 3001d360 <_Watchdog_Adjust> <== NOT EXECUTED } watchdogs->last_snapshot = snapshot; 30019260: e584a074 str sl, [r4, #116] ; 0x74 <== NOT EXECUTED ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 30019264: e284b068 add fp, r4, #104 ; 0x68 <== NOT EXECUTED Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 30019268: e284a030 add sl, r4, #48 ; 0x30 <== NOT EXECUTED } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 3001926c: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED 30019270: eb0002aa bl 30019d20 <_Chain_Get> <== NOT EXECUTED if ( timer == NULL ) { 30019274: e2501000 subs r1, r0, #0 <== NOT EXECUTED 30019278: 0a000009 beq 300192a4 <_Timer_server_Body+0xe8> <== NOT EXECUTED static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 3001927c: e5913038 ldr r3, [r1, #56] ; 0x38 <== NOT EXECUTED 30019280: e3530001 cmp r3, #1 <== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 30019284: 01a0000a moveq r0, sl <== NOT EXECUTED static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 30019288: 0a000002 beq 30019298 <_Timer_server_Body+0xdc> <== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 3001928c: e3530003 cmp r3, #3 <== NOT EXECUTED 30019290: 1afffff5 bne 3001926c <_Timer_server_Body+0xb0> <== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 30019294: e1a0000b mov r0, fp <== NOT EXECUTED 30019298: e2811010 add r1, r1, #16 <== NOT EXECUTED 3001929c: eb00107c bl 3001d494 <_Watchdog_Insert> <== NOT EXECUTED 300192a0: eafffff1 b 3001926c <_Timer_server_Body+0xb0> <== NOT EXECUTED * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 300192a4: e58d1000 str r1, [sp] <== NOT EXECUTED 300192a8: ebffff97 bl 3001910c <== NOT EXECUTED if ( _Chain_Is_empty( insert_chain ) ) { 300192ac: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 300192b0: e59d1000 ldr r1, [sp] <== NOT EXECUTED 300192b4: e1530009 cmp r3, r9 <== NOT EXECUTED 300192b8: 1a000006 bne 300192d8 <_Timer_server_Body+0x11c> <== NOT EXECUTED ts->insert_chain = NULL; 300192bc: e5841078 str r1, [r4, #120] ; 0x78 <== NOT EXECUTED 300192c0: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED _Chain_Initialize_empty( &fire_chain ); while ( true ) { _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain ); if ( !_Chain_Is_empty( &fire_chain ) ) { 300192c4: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 300192c8: e1530006 cmp r3, r6 <== NOT EXECUTED * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; 300192cc: 13a07000 movne r7, #0 <== NOT EXECUTED _Chain_Initialize_empty( &fire_chain ); while ( true ) { _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain ); if ( !_Chain_Is_empty( &fire_chain ) ) { 300192d0: 1a000002 bne 300192e0 <_Timer_server_Body+0x124> <== NOT EXECUTED 300192d4: ea000011 b 30019320 <_Timer_server_Body+0x164> <== NOT EXECUTED 300192d8: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 300192dc: eaffffc6 b 300191fc <_Timer_server_Body+0x40> <== NOT EXECUTED /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 300192e0: ebffff89 bl 3001910c <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 300192e4: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 300192e8: e1530006 cmp r3, r6 <== NOT EXECUTED 300192ec: 0a000009 beq 30019318 <_Timer_server_Body+0x15c> <== NOT EXECUTED Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 300192f0: e5932000 ldr r2, [r3] <== NOT EXECUTED head->next = new_first; new_first->previous = head; 300192f4: e5825004 str r5, [r2, #4] <== NOT EXECUTED { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; head->next = new_first; 300192f8: e58d2010 str r2, [sp, #16] <== NOT EXECUTED watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; 300192fc: e5837008 str r7, [r3, #8] <== NOT EXECUTED 30019300: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED /* * The timer server may block here and wait for resources or time. * The system watchdogs are inactive and will remain inactive since * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); 30019304: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 30019308: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 3001930c: e1a0e00f mov lr, pc <== NOT EXECUTED 30019310: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED } 30019314: eafffff1 b 300192e0 <_Timer_server_Body+0x124> <== NOT EXECUTED 30019318: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 3001931c: eaffffb4 b 300191f4 <_Timer_server_Body+0x38> <== NOT EXECUTED } else { ts->active = false; 30019320: e3a03000 mov r3, #0 <== NOT EXECUTED 30019324: e5c4307c strb r3, [r4, #124] ; 0x7c <== NOT EXECUTED * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 30019328: e59f3050 ldr r3, [pc, #80] ; 30019380 <_Timer_server_Body+0x1c4><== NOT EXECUTED 3001932c: e5932000 ldr r2, [r3] <== NOT EXECUTED ++level; 30019330: e2822001 add r2, r2, #1 <== NOT EXECUTED _Thread_Dispatch_disable_level = level; 30019334: e5832000 str r2, [r3] <== NOT EXECUTED /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 30019338: e3a01008 mov r1, #8 <== NOT EXECUTED 3001933c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30019340: eb000f2f bl 3001d004 <_Thread_Set_state> <== NOT EXECUTED _Timer_server_Reset_interval_system_watchdog( ts ); 30019344: e1a00004 mov r0, r4 <== NOT EXECUTED 30019348: ebffff73 bl 3001911c <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED _Timer_server_Reset_tod_system_watchdog( ts ); 3001934c: e1a00004 mov r0, r4 <== NOT EXECUTED 30019350: ebffff85 bl 3001916c <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED _Thread_Enable_dispatch(); 30019354: eb000d07 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED ts->active = true; 30019358: e3a03001 mov r3, #1 <== NOT EXECUTED 3001935c: e5c4307c strb r3, [r4, #124] ; 0x7c <== NOT EXECUTED static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 30019360: e2840008 add r0, r4, #8 <== NOT EXECUTED 30019364: eb0010a1 bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 30019368: e2840040 add r0, r4, #64 ; 0x40 <== NOT EXECUTED 3001936c: eb00109f bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED 30019370: eaffff9f b 300191f4 <_Timer_server_Body+0x38> <== NOT EXECUTED =============================================================================== 3001911c <_Timer_server_Reset_interval_system_watchdog>: } static void _Timer_server_Reset_interval_system_watchdog( Timer_server_Control *ts ) { 3001911c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 30019120: e2805008 add r5, r0, #8 <== NOT EXECUTED } static void _Timer_server_Reset_interval_system_watchdog( Timer_server_Control *ts ) { 30019124: e1a04000 mov r4, r0 <== NOT EXECUTED static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 30019128: e1a00005 mov r0, r5 <== NOT EXECUTED 3001912c: eb00112f bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED { ISR_Level level; _Timer_server_Stop_interval_system_watchdog( ts ); _ISR_Disable( level ); 30019130: ebfffff5 bl 3001910c <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 30019134: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 30019138: e2842034 add r2, r4, #52 ; 0x34 <== NOT EXECUTED if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 3001913c: e1530002 cmp r3, r2 <== NOT EXECUTED 30019140: 0a000006 beq 30019160 <_Timer_server_Reset_interval_system_watchdog+0x44><== NOT EXECUTED Watchdog_Interval delta_interval = 30019144: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 30019148: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 3001914c: e59f0014 ldr r0, [pc, #20] ; 30019168 <_Timer_server_Reset_interval_system_watchdog+0x4c><== NOT EXECUTED 30019150: e1a01005 mov r1, r5 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 30019154: e5843014 str r3, [r4, #20] <== NOT EXECUTED delta_interval ); } else { _ISR_Enable( level ); } } 30019158: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 3001915c: ea0010cc b 3001d494 <_Watchdog_Insert> <== NOT EXECUTED 30019160: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 30019164: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 3001916c <_Timer_server_Reset_tod_system_watchdog>: } static void _Timer_server_Reset_tod_system_watchdog( Timer_server_Control *ts ) { 3001916c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 30019170: e2805040 add r5, r0, #64 ; 0x40 <== NOT EXECUTED } static void _Timer_server_Reset_tod_system_watchdog( Timer_server_Control *ts ) { 30019174: e1a04000 mov r4, r0 <== NOT EXECUTED static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 30019178: e1a00005 mov r0, r5 <== NOT EXECUTED 3001917c: eb00111b bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED { ISR_Level level; _Timer_server_Stop_tod_system_watchdog( ts ); _ISR_Disable( level ); 30019180: ebffffe1 bl 3001910c <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 30019184: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 30019188: e284206c add r2, r4, #108 ; 0x6c <== NOT EXECUTED if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 3001918c: e1530002 cmp r3, r2 <== NOT EXECUTED 30019190: 0a000006 beq 300191b0 <_Timer_server_Reset_tod_system_watchdog+0x44><== NOT EXECUTED Watchdog_Interval delta_interval = 30019194: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED 30019198: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 3001919c: e59f0014 ldr r0, [pc, #20] ; 300191b8 <_Timer_server_Reset_tod_system_watchdog+0x4c><== NOT EXECUTED 300191a0: e1a01005 mov r1, r5 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 300191a4: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED delta_interval ); } else { _ISR_Enable( level ); } } 300191a8: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 300191ac: ea0010b8 b 3001d494 <_Watchdog_Insert> <== NOT EXECUTED 300191b0: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 300191b4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 30019384 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 30019384: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED if ( ts->insert_chain == NULL ) { 30019388: e5906078 ldr r6, [r0, #120] ; 0x78 <== NOT EXECUTED static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 3001938c: e1a04000 mov r4, r0 <== NOT EXECUTED if ( ts->insert_chain == NULL ) { 30019390: e3560000 cmp r6, #0 <== NOT EXECUTED static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 30019394: e1a05001 mov r5, r1 <== NOT EXECUTED if ( ts->insert_chain == NULL ) { 30019398: 1a000040 bne 300194a0 <_Timer_server_Schedule_operation_method+0x11c><== NOT EXECUTED * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3001939c: e59f3108 ldr r3, [pc, #264] ; 300194ac <_Timer_server_Schedule_operation_method+0x128><== NOT EXECUTED 300193a0: e5932000 ldr r2, [r3] <== NOT EXECUTED ++level; 300193a4: e2822001 add r2, r2, #1 <== NOT EXECUTED _Thread_Dispatch_disable_level = level; 300193a8: e5832000 str r2, [r3] <== NOT EXECUTED * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 300193ac: e5913038 ldr r3, [r1, #56] ; 0x38 <== NOT EXECUTED 300193b0: e3530001 cmp r3, #1 <== NOT EXECUTED 300193b4: 1a000017 bne 30019418 <_Timer_server_Schedule_operation_method+0x94><== NOT EXECUTED /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 300193b8: ebffff53 bl 3001910c <== NOT EXECUTED snapshot = _Watchdog_Ticks_since_boot; 300193bc: e59f30ec ldr r3, [pc, #236] ; 300194b0 <_Timer_server_Schedule_operation_method+0x12c><== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 300193c0: e284c034 add ip, r4, #52 ; 0x34 <== NOT EXECUTED 300193c4: e5932000 ldr r2, [r3] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 300193c8: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED last_snapshot = ts->Interval_watchdogs.last_snapshot; 300193cc: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 300193d0: e153000c cmp r3, ip <== NOT EXECUTED 300193d4: 0a000004 beq 300193ec <_Timer_server_Schedule_operation_method+0x68><== NOT EXECUTED /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; delta_interval = first_watchdog->delta_interval; 300193d8: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 300193dc: e0611002 rsb r1, r1, r2 <== NOT EXECUTED delta_interval = first_watchdog->delta_interval; if (delta_interval > delta) { 300193e0: e15c0001 cmp ip, r1 <== NOT EXECUTED delta_interval -= delta; 300193e4: 8061600c rsbhi r6, r1, ip <== NOT EXECUTED } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 300193e8: e5836010 str r6, [r3, #16] <== NOT EXECUTED } ts->Interval_watchdogs.last_snapshot = snapshot; 300193ec: e584203c str r2, [r4, #60] ; 0x3c <== NOT EXECUTED 300193f0: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED _ISR_Enable( level ); _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 300193f4: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 300193f8: e2851010 add r1, r5, #16 <== NOT EXECUTED 300193fc: eb001024 bl 3001d494 <_Watchdog_Insert> <== NOT EXECUTED if ( !ts->active ) { 30019400: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 30019404: e3530000 cmp r3, #0 <== NOT EXECUTED 30019408: 1a000022 bne 30019498 <_Timer_server_Schedule_operation_method+0x114><== NOT EXECUTED _Timer_server_Reset_interval_system_watchdog( ts ); 3001940c: e1a00004 mov r0, r4 <== NOT EXECUTED 30019410: ebffff41 bl 3001911c <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED 30019414: ea00001f b 30019498 <_Timer_server_Schedule_operation_method+0x114><== NOT EXECUTED } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 30019418: e3530003 cmp r3, #3 <== NOT EXECUTED 3001941c: 1a00001d bne 30019498 <_Timer_server_Schedule_operation_method+0x114><== NOT EXECUTED /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 30019420: ebffff39 bl 3001910c <== NOT EXECUTED 30019424: e1a07000 mov r7, r0 <== NOT EXECUTED 30019428: e59f3084 ldr r3, [pc, #132] ; 300194b4 <_Timer_server_Schedule_operation_method+0x130><== NOT EXECUTED 3001942c: e59f2084 ldr r2, [pc, #132] ; 300194b8 <_Timer_server_Schedule_operation_method+0x134><== NOT EXECUTED 30019430: e8930003 ldm r3, {r0, r1} <== NOT EXECUTED 30019434: e3a03000 mov r3, #0 <== NOT EXECUTED 30019438: eb004acf bl 3002bf7c <__divdi3> <== NOT EXECUTED 3001943c: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 30019440: e284106c add r1, r4, #108 ; 0x6c <== NOT EXECUTED snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); last_snapshot = ts->TOD_watchdogs.last_snapshot; if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 30019444: e1530001 cmp r3, r1 <== NOT EXECUTED * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); last_snapshot = ts->TOD_watchdogs.last_snapshot; 30019448: e5942074 ldr r2, [r4, #116] ; 0x74 <== NOT EXECUTED if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 3001944c: 0a000008 beq 30019474 <_Timer_server_Schedule_operation_method+0xf0><== NOT EXECUTED first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 30019450: e5931010 ldr r1, [r3, #16] <== NOT EXECUTED if ( snapshot > last_snapshot ) { 30019454: e1500002 cmp r0, r2 <== NOT EXECUTED } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 30019458: 90816002 addls r6, r1, r2 <== NOT EXECUTED delta_interval += delta; 3001945c: 90606006 rsbls r6, r0, r6 <== NOT EXECUTED snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); last_snapshot = ts->TOD_watchdogs.last_snapshot; if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; if ( snapshot > last_snapshot ) { 30019460: 9a000002 bls 30019470 <_Timer_server_Schedule_operation_method+0xec><== NOT EXECUTED /* * We advanced in time. */ delta = snapshot - last_snapshot; 30019464: e0622000 rsb r2, r2, r0 <== NOT EXECUTED if (delta_interval > delta) { 30019468: e1510002 cmp r1, r2 <== NOT EXECUTED delta_interval -= delta; 3001946c: 80626001 rsbhi r6, r2, r1 <== NOT EXECUTED * Someone put us in the past. */ delta = last_snapshot - snapshot; delta_interval += delta; } first_watchdog->delta_interval = delta_interval; 30019470: e5836010 str r6, [r3, #16] <== NOT EXECUTED } ts->TOD_watchdogs.last_snapshot = snapshot; 30019474: e5840074 str r0, [r4, #116] ; 0x74 <== NOT EXECUTED 30019478: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED _ISR_Enable( level ); _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 3001947c: e2840068 add r0, r4, #104 ; 0x68 <== NOT EXECUTED 30019480: e2851010 add r1, r5, #16 <== NOT EXECUTED 30019484: eb001002 bl 3001d494 <_Watchdog_Insert> <== NOT EXECUTED if ( !ts->active ) { 30019488: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3001948c: e3530000 cmp r3, #0 <== NOT EXECUTED _Timer_server_Reset_tod_system_watchdog( ts ); 30019490: 01a00004 moveq r0, r4 <== NOT EXECUTED 30019494: 0bffff34 bleq 3001916c <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); } } 30019498: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 3001949c: ea000cb5 b 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 300194a0: e5900078 ldr r0, [r0, #120] ; 0x78 <== NOT EXECUTED } } 300194a4: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 300194a8: ea000211 b 30019cf4 <_Chain_Append> <== NOT EXECUTED =============================================================================== 3000d88c <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 3000d88c: e1a03000 mov r3, r0 <== NOT EXECUTED uint32_t seconds = add->tv_sec; /* Add the basics */ time->tv_sec += add->tv_sec; 3000d890: e5932000 ldr r2, [r3] <== NOT EXECUTED uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { uint32_t seconds = add->tv_sec; 3000d894: e5910000 ldr r0, [r1] <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; 3000d898: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED ) { uint32_t seconds = add->tv_sec; /* Add the basics */ time->tv_sec += add->tv_sec; 3000d89c: e0822000 add r2, r2, r0 <== NOT EXECUTED 3000d8a0: e5832000 str r2, [r3] <== NOT EXECUTED time->tv_nsec += add->tv_nsec; 3000d8a4: e5912004 ldr r2, [r1, #4] <== NOT EXECUTED 3000d8a8: e08c2002 add r2, ip, r2 <== NOT EXECUTED 3000d8ac: e5832004 str r2, [r3, #4] <== NOT EXECUTED /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 3000d8b0: e59fc02c ldr ip, [pc, #44] ; 3000d8e4 <_Timespec_Add_to+0x58><== NOT EXECUTED 3000d8b4: ea000006 b 3000d8d4 <_Timespec_Add_to+0x48> <== NOT EXECUTED time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 3000d8b8: e59f2028 ldr r2, [pc, #40] ; 3000d8e8 <_Timespec_Add_to+0x5c><== NOT EXECUTED time->tv_sec++; seconds++; 3000d8bc: e2800001 add r0, r0, #1 <== NOT EXECUTED time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 3000d8c0: e0812002 add r2, r1, r2 <== NOT EXECUTED 3000d8c4: e5832004 str r2, [r3, #4] <== NOT EXECUTED time->tv_sec++; 3000d8c8: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d8cc: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000d8d0: e5832000 str r2, [r3] <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 3000d8d4: e5931004 ldr r1, [r3, #4] <== NOT EXECUTED 3000d8d8: e151000c cmp r1, ip <== NOT EXECUTED 3000d8dc: 8afffff5 bhi 3000d8b8 <_Timespec_Add_to+0x2c> <== NOT EXECUTED time->tv_sec++; seconds++; } return seconds; } 3000d8e0: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000cf4c <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 3000cf4c: e92d40f0 push {r4, r5, r6, r7, lr} * 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; 3000cf50: e5914000 ldr r4, [r1] right += rhs->tv_nsec; 3000cf54: e5911004 ldr r1, [r1, #4] const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 3000cf58: e1a06002 mov r6, r2 3000cf5c: e1a07003 mov r7, r3 * 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; right += rhs->tv_nsec; 3000cf60: e1a02001 mov r2, r1 3000cf64: e1a03fc1 asr r3, r1, #31 3000cf68: e59f106c ldr r1, [pc, #108] ; 3000cfdc <_Timespec_Divide+0x90> /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 3000cf6c: e590c000 ldr ip, [r0] left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec; 3000cf70: e0e32491 smlal r2, r3, r1, r4 if ( right == 0 ) { 3000cf74: e1924003 orrs r4, r2, r3 *ival_percentage = 0; 3000cf78: 03a03000 moveq r3, #0 /* * 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; 3000cf7c: e5900004 ldr r0, [r0, #4] right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec; if ( right == 0 ) { *ival_percentage = 0; 3000cf80: 05863000 streq r3, [r6] *fval_percentage = 0; 3000cf84: 05873000 streq r3, [r7] left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec; if ( right == 0 ) { 3000cf88: 08bd80f0 popeq {r4, r5, r6, r7, pc} /* * 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; 3000cf8c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000cf90: e1a05fc0 asr r5, r0, #31 <== NOT EXECUTED 3000cf94: e0e54c91 smlal r4, r5, r1, ip <== NOT EXECUTED * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 3000cf98: e59fc040 ldr ip, [pc, #64] ; 3000cfe0 <_Timespec_Divide+0x94><== NOT EXECUTED 3000cf9c: e0810c94 umull r0, r1, r4, ip <== NOT EXECUTED 3000cfa0: e021159c mla r1, ip, r5, r1 <== NOT EXECUTED 3000cfa4: eb003811 bl 3001aff0 <__udivdi3> <== NOT EXECUTED *ival_percentage = answer / 1000; 3000cfa8: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000cfac: e3a03000 mov r3, #0 <== NOT EXECUTED * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 3000cfb0: e1a05000 mov r5, r0 <== NOT EXECUTED 3000cfb4: e1a04001 mov r4, r1 <== NOT EXECUTED *ival_percentage = answer / 1000; 3000cfb8: eb00380c bl 3001aff0 <__udivdi3> <== NOT EXECUTED *fval_percentage = answer % 1000; 3000cfbc: e1a01004 mov r1, r4 <== NOT EXECUTED * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 3000cfc0: e5860000 str r0, [r6] <== NOT EXECUTED *fval_percentage = answer % 1000; 3000cfc4: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000cfc8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000cfcc: e3a03000 mov r3, #0 <== NOT EXECUTED 3000cfd0: eb00392a bl 3001b480 <__umoddi3> <== NOT EXECUTED 3000cfd4: e5870000 str r0, [r7] <== NOT EXECUTED 3000cfd8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3002686c <_Timespec_Divide_by_integer>: void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 3002686c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED 30026870: e1a04002 mov r4, r2 <== NOT EXECUTED * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; t *= TOD_NANOSECONDS_PER_SECOND; t += time->tv_nsec; 30026874: e5902004 ldr r2, [r0, #4] <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; 30026878: e590c000 ldr ip, [r0] <== NOT EXECUTED void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 3002687c: e1a03001 mov r3, r1 <== NOT EXECUTED * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; t *= TOD_NANOSECONDS_PER_SECOND; t += time->tv_nsec; 30026880: e1a00002 mov r0, r2 <== NOT EXECUTED 30026884: e1a01fc2 asr r1, r2, #31 <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 30026888: e59f2040 ldr r2, [pc, #64] ; 300268d0 <_Timespec_Divide_by_integer+0x64><== NOT EXECUTED 3002688c: e0e10c92 smlal r0, r1, r2, ip <== NOT EXECUTED 30026890: e1a02003 mov r2, r3 <== NOT EXECUTED 30026894: e3a03000 mov r3, #0 <== NOT EXECUTED 30026898: eb00a34c bl 3004f5d0 <__udivdi3> <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 3002689c: e59f202c ldr r2, [pc, #44] ; 300268d0 <_Timespec_Divide_by_integer+0x64><== NOT EXECUTED 300268a0: e3a03000 mov r3, #0 <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 300268a4: e1a06000 mov r6, r0 <== NOT EXECUTED 300268a8: e1a05001 mov r5, r1 <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 300268ac: eb00a347 bl 3004f5d0 <__udivdi3> <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 300268b0: e1a01005 mov r1, r5 <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 300268b4: e5840000 str r0, [r4] <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 300268b8: e59f2010 ldr r2, [pc, #16] ; 300268d0 <_Timespec_Divide_by_integer+0x64><== NOT EXECUTED 300268bc: e1a00006 mov r0, r6 <== NOT EXECUTED 300268c0: e3a03000 mov r3, #0 <== NOT EXECUTED 300268c4: eb00a465 bl 3004fa60 <__umoddi3> <== NOT EXECUTED 300268c8: e5840004 str r0, [r4, #4] <== NOT EXECUTED } 300268cc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 30028814 <_Timespec_From_ticks>: struct timespec *time ) { uint32_t usecs; usecs = ticks * rtems_configuration_get_microseconds_per_tick(); 30028814: e59f3038 ldr r3, [pc, #56] ; 30028854 <_Timespec_From_ticks+0x40><== NOT EXECUTED void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 30028818: e92d4030 push {r4, r5, lr} <== NOT EXECUTED uint32_t usecs; usecs = ticks * rtems_configuration_get_microseconds_per_tick(); 3002881c: e593500c ldr r5, [r3, #12] <== NOT EXECUTED void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 30028820: e1a04001 mov r4, r1 <== NOT EXECUTED uint32_t usecs; usecs = ticks * rtems_configuration_get_microseconds_per_tick(); 30028824: e0050590 mul r5, r0, r5 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 30028828: e59f1028 ldr r1, [pc, #40] ; 30028858 <_Timespec_From_ticks+0x44><== NOT EXECUTED 3002882c: e1a00005 mov r0, r5 <== NOT EXECUTED 30028830: ebff7161 bl 30004dbc <__aeabi_uidiv> <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 30028834: e59f101c ldr r1, [pc, #28] ; 30028858 <_Timespec_From_ticks+0x44><== NOT EXECUTED { uint32_t usecs; usecs = ticks * rtems_configuration_get_microseconds_per_tick(); time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 30028838: e5840000 str r0, [r4] <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 3002883c: e1a00005 mov r0, r5 <== NOT EXECUTED 30028840: ebfff746 bl 30026560 <__umodsi3> <== NOT EXECUTED 30028844: e3a03ffa mov r3, #1000 ; 0x3e8 <== NOT EXECUTED 30028848: e0030390 mul r3, r0, r3 <== NOT EXECUTED 3002884c: e5843004 str r3, [r4, #4] <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 30028850: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 3002885c <_Timespec_Is_valid>: bool _Timespec_Is_valid( const struct timespec *time ) { if ( !time ) 3002885c: e3500000 cmp r0, #0 <== NOT EXECUTED 30028860: 012fff1e bxeq lr <== NOT EXECUTED return false; if ( time->tv_sec < 0 ) 30028864: e5903000 ldr r3, [r0] <== NOT EXECUTED 30028868: e3530000 cmp r3, #0 <== NOT EXECUTED return false; 3002886c: b3a00000 movlt r0, #0 <== NOT EXECUTED ) { if ( !time ) return false; if ( time->tv_sec < 0 ) 30028870: b12fff1e bxlt lr <== NOT EXECUTED return false; if ( time->tv_nsec < 0 ) 30028874: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 30028878: e3530000 cmp r3, #0 <== NOT EXECUTED 3002887c: ba000004 blt 30028894 <_Timespec_Is_valid+0x38> <== NOT EXECUTED #include #include #include bool _Timespec_Is_valid( 30028880: e59f0014 ldr r0, [pc, #20] ; 3002889c <_Timespec_Is_valid+0x40><== NOT EXECUTED 30028884: e1530000 cmp r3, r0 <== NOT EXECUTED 30028888: 83a00000 movhi r0, #0 <== NOT EXECUTED 3002888c: 93a00001 movls r0, #1 <== NOT EXECUTED 30028890: e12fff1e bx lr <== NOT EXECUTED if ( time->tv_sec < 0 ) return false; if ( time->tv_nsec < 0 ) return false; 30028894: e3a00000 mov r0, #0 <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return false; return true; } 30028898: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000cfe4 <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 3000cfe4: e5902000 ldr r2, [r0] 3000cfe8: e5913000 ldr r3, [r1] 3000cfec: e1520003 cmp r2, r3 return true; 3000cff0: b3a00001 movlt r0, #1 bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 3000cff4: b12fff1e bxlt lr return true; if ( lhs->tv_sec > rhs->tv_sec ) 3000cff8: ca000005 bgt 3000d014 <_Timespec_Less_than+0x30> #include #include #include bool _Timespec_Less_than( 3000cffc: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED 3000d000: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 3000d004: e1500003 cmp r0, r3 <== NOT EXECUTED 3000d008: a3a00000 movge r0, #0 <== NOT EXECUTED 3000d00c: b3a00001 movlt r0, #1 <== NOT EXECUTED 3000d010: e12fff1e bx lr <== NOT EXECUTED { if ( lhs->tv_sec < rhs->tv_sec ) return true; if ( lhs->tv_sec > rhs->tv_sec ) return false; 3000d014: e3a00000 mov r0, #0 /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) return true; return false; } 3000d018: e12fff1e bx lr =============================================================================== 3000dfc4 <_Timespec_Subtract>: const struct timespec *end, struct timespec *result ) { if (end->tv_nsec < start->tv_nsec) { 3000dfc4: e591c004 ldr ip, [r1, #4] <== NOT EXECUTED 3000dfc8: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED void _Timespec_Subtract( const struct timespec *start, const struct timespec *end, struct timespec *result ) { 3000dfcc: e92d4010 push {r4, lr} <== NOT EXECUTED 3000dfd0: e5914000 ldr r4, [r1] <== NOT EXECUTED 3000dfd4: e5901000 ldr r1, [r0] <== NOT EXECUTED if (end->tv_nsec < start->tv_nsec) { 3000dfd8: e15c0003 cmp ip, r3 <== NOT EXECUTED result->tv_sec = end->tv_sec - start->tv_sec - 1; 3000dfdc: e0611004 rsb r1, r1, r4 <== NOT EXECUTED 3000dfe0: b2411001 sublt r1, r1, #1 <== NOT EXECUTED 3000dfe4: b5821000 strlt r1, [r2] <== NOT EXECUTED result->tv_nsec = (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; 3000dfe8: b59f1014 ldrlt r1, [pc, #20] ; 3000e004 <_Timespec_Subtract+0x40><== NOT EXECUTED } else { result->tv_sec = end->tv_sec - start->tv_sec; result->tv_nsec = end->tv_nsec - start->tv_nsec; 3000dfec: a063300c rsbge r3, r3, ip <== NOT EXECUTED { if (end->tv_nsec < start->tv_nsec) { result->tv_sec = end->tv_sec - start->tv_sec - 1; result->tv_nsec = (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; 3000dff0: b08c1001 addlt r1, ip, r1 <== NOT EXECUTED 3000dff4: b0633001 rsblt r3, r3, r1 <== NOT EXECUTED } else { result->tv_sec = end->tv_sec - start->tv_sec; 3000dff8: a5821000 strge r1, [r2] <== NOT EXECUTED result->tv_nsec = end->tv_nsec - start->tv_nsec; 3000dffc: e5823004 str r3, [r2, #4] <== NOT EXECUTED 3000e000: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 300288a0 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 300288a0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED uint32_t ticks; uint32_t nanoseconds_per_tick; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 300288a4: e5905000 ldr r5, [r0] <== NOT EXECUTED */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 300288a8: e1a06000 mov r6, r0 <== NOT EXECUTED uint32_t ticks; uint32_t nanoseconds_per_tick; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 300288ac: e3550000 cmp r5, #0 <== NOT EXECUTED 300288b0: 1a000002 bne 300288c0 <_Timespec_To_ticks+0x20> <== NOT EXECUTED 300288b4: e5904004 ldr r4, [r0, #4] <== NOT EXECUTED 300288b8: e3540000 cmp r4, #0 <== NOT EXECUTED 300288bc: 0a00000d beq 300288f8 <_Timespec_To_ticks+0x58> <== NOT EXECUTED /** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 300288c0: eb000032 bl 30028990 <== NOT EXECUTED nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); 300288c4: e59f3034 ldr r3, [pc, #52] ; 30028900 <_Timespec_To_ticks+0x60><== NOT EXECUTED /** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 300288c8: e0040095 mul r4, r5, r0 <== NOT EXECUTED nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); ticks += time->tv_nsec / nanoseconds_per_tick; 300288cc: e5966004 ldr r6, [r6, #4] <== NOT EXECUTED * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ ticks = time->tv_sec * TOD_TICKS_PER_SECOND; nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); 300288d0: e5935010 ldr r5, [r3, #16] <== NOT EXECUTED ticks += time->tv_nsec / nanoseconds_per_tick; 300288d4: e1a00006 mov r0, r6 <== NOT EXECUTED 300288d8: e1a01005 mov r1, r5 <== NOT EXECUTED 300288dc: ebff7136 bl 30004dbc <__aeabi_uidiv> <== NOT EXECUTED if ( (time->tv_nsec % nanoseconds_per_tick) != 0 ) 300288e0: e1a01005 mov r1, r5 <== NOT EXECUTED * need to have it be greater than or equal to the requested time. It * should not be shorter. */ ticks = time->tv_sec * TOD_TICKS_PER_SECOND; nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); ticks += time->tv_nsec / nanoseconds_per_tick; 300288e4: e0844000 add r4, r4, r0 <== NOT EXECUTED if ( (time->tv_nsec % nanoseconds_per_tick) != 0 ) 300288e8: e1a00006 mov r0, r6 <== NOT EXECUTED 300288ec: ebfff71b bl 30026560 <__umodsi3> <== NOT EXECUTED 300288f0: e3500000 cmp r0, #0 <== NOT EXECUTED ticks += 1; 300288f4: 12844001 addne r4, r4, #1 <== NOT EXECUTED return ticks; } 300288f8: e1a00004 mov r0, r4 <== NOT EXECUTED 300288fc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000e75c <_Timestamp64_Divide>: const Timestamp64_Control *_lhs, const Timestamp64_Control *_rhs, uint32_t *_ival_percentage, uint32_t *_fval_percentage ) { 3000e75c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED 3000e760: e1a04002 mov r4, r2 <== NOT EXECUTED 3000e764: e1a05003 mov r5, r3 <== NOT EXECUTED Timestamp64_Control answer; if ( *_rhs == 0 ) { 3000e768: e891000c ldm r1, {r2, r3} <== NOT EXECUTED 3000e76c: e1921003 orrs r1, r2, r3 <== NOT EXECUTED *_ival_percentage = 0; 3000e770: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000e774: 05843000 streq r3, [r4] <== NOT EXECUTED *_fval_percentage = 0; 3000e778: 05853000 streq r3, [r5] <== NOT EXECUTED uint32_t *_fval_percentage ) { Timestamp64_Control answer; if ( *_rhs == 0 ) { 3000e77c: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED * This looks odd but gives the results the proper precision. * * TODO: Rounding on the last digit of the fval. */ answer = (*_lhs * 100000) / *_rhs; 3000e780: e59fc044 ldr ip, [pc, #68] ; 3000e7cc <_Timestamp64_Divide+0x70><== NOT EXECUTED 3000e784: e5906000 ldr r6, [r0] <== NOT EXECUTED 3000e788: e590e004 ldr lr, [r0, #4] <== NOT EXECUTED 3000e78c: e0810c96 umull r0, r1, r6, ip <== NOT EXECUTED 3000e790: e0211e9c mla r1, ip, lr, r1 <== NOT EXECUTED 3000e794: eb0037c5 bl 3001c6b0 <__divdi3> <== NOT EXECUTED *_ival_percentage = answer / 1000; 3000e798: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000e79c: e3a03000 mov r3, #0 <== NOT EXECUTED * This looks odd but gives the results the proper precision. * * TODO: Rounding on the last digit of the fval. */ answer = (*_lhs * 100000) / *_rhs; 3000e7a0: e1a07000 mov r7, r0 <== NOT EXECUTED 3000e7a4: e1a06001 mov r6, r1 <== NOT EXECUTED *_ival_percentage = answer / 1000; 3000e7a8: eb0037c0 bl 3001c6b0 <__divdi3> <== NOT EXECUTED *_fval_percentage = answer % 1000; 3000e7ac: e1a01006 mov r1, r6 <== NOT EXECUTED * TODO: Rounding on the last digit of the fval. */ answer = (*_lhs * 100000) / *_rhs; *_ival_percentage = answer / 1000; 3000e7b0: e5840000 str r0, [r4] <== NOT EXECUTED *_fval_percentage = answer % 1000; 3000e7b4: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000e7b8: e1a00007 mov r0, r7 <== NOT EXECUTED 3000e7bc: e3a03000 mov r3, #0 <== NOT EXECUTED 3000e7c0: eb0038f5 bl 3001cb9c <__moddi3> <== NOT EXECUTED 3000e7c4: e5850000 str r0, [r5] <== NOT EXECUTED 3000e7c8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 30010bc4 <_User_extensions_Remove_set>: #include void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 30010bc4: e92d4010 push {r4, lr} 30010bc8: e1a04000 mov r4, r0 _Chain_Extract( &the_extension->Node ); 30010bcc: eb0010d1 bl 30014f18 <_Chain_Extract> /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 30010bd0: e5943024 ldr r3, [r4, #36] ; 0x24 30010bd4: e3530000 cmp r3, #0 30010bd8: 08bd8010 popeq {r4, pc} _Chain_Extract( &the_extension->Switch.Node ); 30010bdc: e2840008 add r0, r4, #8 <== NOT EXECUTED } 30010be0: e8bd4010 pop {r4, lr} <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) _Chain_Extract( &the_extension->Switch.Node ); 30010be4: ea0010cb b 30014f18 <_Chain_Extract> <== NOT EXECUTED =============================================================================== 3000d220 <_User_extensions_Thread_exitted_visitor>: Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { User_extensions_thread_exitted_extension callout = callouts->thread_exitted; 3000d220: e5923018 ldr r3, [r2, #24] void _User_extensions_Thread_exitted_visitor( Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { 3000d224: e52de004 push {lr} ; (str lr, [sp, #-4]!) User_extensions_thread_exitted_extension callout = callouts->thread_exitted; if ( callout != NULL ) { 3000d228: e3530000 cmp r3, #0 3000d22c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) (*callout)( executing ); 3000d230: e1a0e00f mov lr, pc <== NOT EXECUTED 3000d234: e12fff13 bx r3 <== NOT EXECUTED 3000d238: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 3000ea08 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 3000ea08: e92d40f0 push {r4, r5, r6, r7, lr} 3000ea0c: e1a04000 mov r4, r0 3000ea10: e1a05002 mov r5, r2 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000ea14: e10f3000 mrs r3, CPSR 3000ea18: e3832080 orr r2, r3, #128 ; 0x80 3000ea1c: e129f002 msr CPSR_fc, r2 */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3000ea20: e1a06000 mov r6, r0 3000ea24: e4962004 ldr r2, [r6], #4 * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 3000ea28: e1520006 cmp r2, r6 3000ea2c: 0a00001b beq 3000eaa0 <_Watchdog_Adjust+0x98> switch ( direction ) { 3000ea30: e3510000 cmp r1, #0 <== NOT EXECUTED if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 3000ea34: 03a07001 moveq r7, #1 <== NOT EXECUTED * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 3000ea38: 0a000016 beq 3000ea98 <_Watchdog_Adjust+0x90> <== NOT EXECUTED 3000ea3c: e3510001 cmp r1, #1 <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 3000ea40: 05921010 ldreq r1, [r2, #16] <== NOT EXECUTED 3000ea44: 00815005 addeq r5, r1, r5 <== NOT EXECUTED * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 3000ea48: 1a000014 bne 3000eaa0 <_Watchdog_Adjust+0x98> <== NOT EXECUTED 3000ea4c: ea000004 b 3000ea64 <_Watchdog_Adjust+0x5c> <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 3000ea50: e5942000 ldr r2, [r4] <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 3000ea54: e5921010 ldr r1, [r2, #16] <== NOT EXECUTED 3000ea58: e1550001 cmp r5, r1 <== NOT EXECUTED 3000ea5c: 2a000002 bcs 3000ea6c <_Watchdog_Adjust+0x64> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; 3000ea60: e0655001 rsb r5, r5, r1 <== NOT EXECUTED 3000ea64: e5825010 str r5, [r2, #16] <== NOT EXECUTED break; 3000ea68: ea00000c b 3000eaa0 <_Watchdog_Adjust+0x98> <== NOT EXECUTED } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 3000ea6c: e5827010 str r7, [r2, #16] <== NOT EXECUTED while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; 3000ea70: e0615005 rsb r5, r1, r5 <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000ea74: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _Watchdog_First( header )->delta_interval = 1; _ISR_Enable( level ); _Watchdog_Tickle( header ); 3000ea78: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ea7c: eb000089 bl 3000eca8 <_Watchdog_Tickle> <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000ea80: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000ea84: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000ea88: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 3000ea8c: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000ea90: e1520006 cmp r2, r6 <== NOT EXECUTED 3000ea94: 0a000001 beq 3000eaa0 <_Watchdog_Adjust+0x98> <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 3000ea98: e3550000 cmp r5, #0 <== NOT EXECUTED 3000ea9c: 1affffeb bne 3000ea50 <_Watchdog_Adjust+0x48> <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000eaa0: e129f003 msr CPSR_fc, r3 } } _ISR_Enable( level ); } 3000eaa4: e8bd80f0 pop {r4, r5, r6, r7, pc} =============================================================================== 3001d400 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 3001d400: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3001d404: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3001d408: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3001d40c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED /* * The first set happens in less than units, so take all of them * off the chain and adjust units to reflect this. */ units -= first->delta_interval; first->delta_interval = 0; 3001d410: e3a08000 mov r8, #0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 3001d414: e2805004 add r5, r0, #4 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 3001d418: e2827004 add r7, r2, #4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3001d41c: e5903000 ldr r3, [r0] <== NOT EXECUTED Watchdog_Control *first; _ISR_Disable( level ); while ( 1 ) { if ( _Chain_Is_empty( header ) ) { 3001d420: e1530005 cmp r3, r5 <== NOT EXECUTED 3001d424: 0a000018 beq 3001d48c <_Watchdog_Adjust_to_chain+0x8c> <== NOT EXECUTED /* * If it is longer than "units" until the first element on the chain * fires, then bump it and quit. */ if ( units < first->delta_interval ) { 3001d428: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001d42c: e151000c cmp r1, ip <== NOT EXECUTED first->delta_interval -= units; 3001d430: 3061100c rsbcc r1, r1, ip <== NOT EXECUTED 3001d434: 35831010 strcc r1, [r3, #16] <== NOT EXECUTED break; 3001d438: 3a000013 bcc 3001d48c <_Watchdog_Adjust_to_chain+0x8c> <== NOT EXECUTED /* * The first set happens in less than units, so take all of them * off the chain and adjust units to reflect this. */ units -= first->delta_interval; 3001d43c: e06c1001 rsb r1, ip, r1 <== NOT EXECUTED first->delta_interval = 0; 3001d440: e5838010 str r8, [r3, #16] <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 3001d444: e8931040 ldm r3, {r6, ip} <== NOT EXECUTED next->previous = previous; 3001d448: e586c004 str ip, [r6, #4] <== NOT EXECUTED previous->next = next; 3001d44c: e58c6000 str r6, [ip] <== NOT EXECUTED Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 3001d450: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED the_node->next = tail; 3001d454: e5837000 str r7, [r3] <== NOT EXECUTED tail->previous = the_node; old_last->next = the_node; 3001d458: e58c3000 str r3, [ip] <== NOT EXECUTED { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 3001d45c: e5823008 str r3, [r2, #8] <== NOT EXECUTED old_last->next = the_node; the_node->previous = old_last; 3001d460: e583c004 str ip, [r3, #4] <== NOT EXECUTED static inline void arm_interrupt_flash( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3001d464: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3001d468: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3001d46c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3001d470: e5903000 ldr r3, [r0] <== NOT EXECUTED _Chain_Extract_unprotected( &first->Node ); _Chain_Append_unprotected( to_fire, &first->Node ); _ISR_Flash( level ); if ( _Chain_Is_empty( header ) ) 3001d474: e1530005 cmp r3, r5 <== NOT EXECUTED 3001d478: 0affffe7 beq 3001d41c <_Watchdog_Adjust_to_chain+0x1c> <== NOT EXECUTED break; first = _Watchdog_First( header ); if ( first->delta_interval != 0 ) 3001d47c: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001d480: e35c0000 cmp ip, #0 <== NOT EXECUTED 3001d484: 0affffee beq 3001d444 <_Watchdog_Adjust_to_chain+0x44> <== NOT EXECUTED 3001d488: eaffffe3 b 3001d41c <_Watchdog_Adjust_to_chain+0x1c> <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3001d48c: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED break; } } _ISR_Enable( level ); } 3001d490: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 3000e564 <_Watchdog_Report>: void _Watchdog_Report( const char *name, Watchdog_Control *watch ) { 3000e564: e92d401f push {r0, r1, r2, r3, r4, lr} <== NOT EXECUTED 3000e568: e1a03001 mov r3, r1 <== NOT EXECUTED printk( 3000e56c: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000e570: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000e574: 059f1034 ldreq r1, [pc, #52] ; 3000e5b0 <_Watchdog_Report+0x4c><== NOT EXECUTED 3000e578: e88d0009 stm sp, {r0, r3} <== NOT EXECUTED 3000e57c: e593001c ldr r0, [r3, #28] <== NOT EXECUTED 3000e580: 01a02001 moveq r2, r1 <== NOT EXECUTED 3000e584: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3000e588: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 3000e58c: 159f2020 ldrne r2, [pc, #32] ; 3000e5b4 <_Watchdog_Report+0x50><== NOT EXECUTED 3000e590: e58d000c str r0, [sp, #12] <== NOT EXECUTED 3000e594: e5930024 ldr r0, [r3, #36] ; 0x24 <== NOT EXECUTED 3000e598: e58d0010 str r0, [sp, #16] <== NOT EXECUTED 3000e59c: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED 3000e5a0: e59f0010 ldr r0, [pc, #16] ; 3000e5b8 <_Watchdog_Report+0x54><== NOT EXECUTED 3000e5a4: ebffe570 bl 30007b6c <== NOT EXECUTED watch, watch->routine, watch->id, watch->user_data ); } 3000e5a8: e28dd014 add sp, sp, #20 <== NOT EXECUTED 3000e5ac: e8bd8000 pop {pc} <== NOT EXECUTED =============================================================================== 3000e4e8 <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 3000e4e8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED 3000e4ec: e1a04000 mov r4, r0 <== NOT EXECUTED 3000e4f0: e1a05001 mov r5, r1 <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000e4f4: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000e4f8: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000e4fc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED ISR_Level level; Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); 3000e500: e59f0050 ldr r0, [pc, #80] ; 3000e558 <_Watchdog_Report_chain+0x70><== NOT EXECUTED 3000e504: e1a02005 mov r2, r5 <== NOT EXECUTED 3000e508: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e50c: ebffe596 bl 30007b6c <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3000e510: e4957004 ldr r7, [r5], #4 <== NOT EXECUTED if ( !_Chain_Is_empty( header ) ) { 3000e514: e1570005 cmp r7, r5 <== NOT EXECUTED 3000e518: 1a000004 bne 3000e530 <_Watchdog_Report_chain+0x48> <== NOT EXECUTED 3000e51c: ea000009 b 3000e548 <_Watchdog_Report_chain+0x60> <== NOT EXECUTED node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 3000e520: e1a01007 mov r1, r7 <== NOT EXECUTED 3000e524: e3a00000 mov r0, #0 <== NOT EXECUTED 3000e528: eb00000d bl 3000e564 <_Watchdog_Report> <== NOT EXECUTED _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; node != _Chain_Tail(header) ; node = node->next ) 3000e52c: e5977000 ldr r7, [r7] <== NOT EXECUTED Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = _Chain_First( header ) ; 3000e530: e1570005 cmp r7, r5 <== NOT EXECUTED 3000e534: 1afffff9 bne 3000e520 <_Watchdog_Report_chain+0x38> <== NOT EXECUTED { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 3000e538: e59f001c ldr r0, [pc, #28] ; 3000e55c <_Watchdog_Report_chain+0x74><== NOT EXECUTED 3000e53c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e540: ebffe589 bl 30007b6c <== NOT EXECUTED 3000e544: ea000001 b 3000e550 <_Watchdog_Report_chain+0x68> <== NOT EXECUTED } else { printk( "Chain is empty\n" ); 3000e548: e59f0010 ldr r0, [pc, #16] ; 3000e560 <_Watchdog_Report_chain+0x78><== NOT EXECUTED 3000e54c: ebffe586 bl 30007b6c <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000e550: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED } _ISR_Enable( level ); } 3000e554: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3000d570 <_Watchdog_Tickle>: #include void _Watchdog_Tickle( Chain_Control *header ) { 3000d570: e92d40f0 push {r4, r5, r6, r7, lr} 3000d574: e1a06000 mov r6, r0 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000d578: e10f7000 mrs r7, CPSR 3000d57c: e3873080 orr r3, r7, #128 ; 0x80 3000d580: e129f003 msr CPSR_fc, r3 */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3000d584: e1a05000 mov r5, r0 3000d588: e4954004 ldr r4, [r5], #4 * volatile data - till, 2003/7 */ _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 3000d58c: e1540005 cmp r4, r5 3000d590: 0a000015 beq 3000d5ec <_Watchdog_Tickle+0x7c> * to be inserted has already had its delta_interval adjusted to 0, and * so is added to the head of the chain with a delta_interval of 0. * * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc) */ if (the_watchdog->delta_interval != 0) { 3000d594: e5943010 ldr r3, [r4, #16] 3000d598: e3530000 cmp r3, #0 3000d59c: 0a000003 beq 3000d5b0 <_Watchdog_Tickle+0x40> the_watchdog->delta_interval--; 3000d5a0: e2433001 sub r3, r3, #1 3000d5a4: e5843010 str r3, [r4, #16] if ( the_watchdog->delta_interval != 0 ) 3000d5a8: e3530000 cmp r3, #0 3000d5ac: 1a00000e bne 3000d5ec <_Watchdog_Tickle+0x7c> goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 3000d5b0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d5b4: ebffffc4 bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000d5b8: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED _ISR_Enable( level ); switch( watchdog_state ) { 3000d5bc: e3500002 cmp r0, #2 <== NOT EXECUTED case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 3000d5c0: 05940020 ldreq r0, [r4, #32] <== NOT EXECUTED 3000d5c4: 05941024 ldreq r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000d5c8: 01a0e00f moveq lr, pc <== NOT EXECUTED 3000d5cc: 0594f01c ldreq pc, [r4, #28] <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000d5d0: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3000d5d4: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3000d5d8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 3000d5dc: e5964000 ldr r4, [r6] <== NOT EXECUTED _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 3000d5e0: e1540005 cmp r4, r5 <== NOT EXECUTED } _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && 3000d5e4: 15943010 ldrne r3, [r4, #16] <== NOT EXECUTED 3000d5e8: 1affffee bne 3000d5a8 <_Watchdog_Tickle+0x38> <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000d5ec: e129f007 msr CPSR_fc, r7 (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 3000d5f0: e8bd80f0 pop {r4, r5, r6, r7, pc} =============================================================================== 3000d71c <_Workspace_Allocate_or_fatal_error>: 3000d71c: e3a02000 mov r2, #0 } void *_Workspace_Allocate_or_fatal_error( size_t size ) { 3000d720: e1a01000 mov r1, r0 3000d724: e52de004 push {lr} ; (str lr, [sp, #-4]!) 3000d728: e59f0018 ldr r0, [pc, #24] ; 3000d748 <_Workspace_Allocate_or_fatal_error+0x2c> 3000d72c: e1a03002 mov r3, r2 3000d730: eb000669 bl 3000f0dc <_Heap_Allocate_aligned_with_boundary> __builtin_return_address( 1 ), memory ); #endif if ( memory == NULL ) 3000d734: e3500000 cmp r0, #0 3000d738: 149df004 popne {pc} ; (ldrne pc, [sp], #4) _Internal_error_Occurred( 3000d73c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000d740: e3a02003 mov r2, #3 <== NOT EXECUTED 3000d744: ebfff767 bl 3000b4e8 <_Internal_error_Occurred> <== NOT EXECUTED =============================================================================== 3000b118 : rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { if (b->begin < a->begin) { 3000b118: e592c018 ldr ip, [r2, #24] <== NOT EXECUTED return rtems_rbheap_chunk_of_node( _RBTree_Next_unprotected(&chunk->tree_node, dir) ); } static void check_and_merge( 3000b11c: e92d4010 push {r4, lr} <== NOT EXECUTED rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { if (b->begin < a->begin) { 3000b120: e5934018 ldr r4, [r3, #24] <== NOT EXECUTED 3000b124: e154000c cmp r4, ip <== NOT EXECUTED 3000b128: 31a0c002 movcc ip, r2 <== NOT EXECUTED 3000b12c: 31a02003 movcc r2, r3 <== NOT EXECUTED 3000b130: 31a0300c movcc r3, ip <== NOT EXECUTED a = b; b = t; } a->size += b->size; 3000b134: e592401c ldr r4, [r2, #28] <== NOT EXECUTED 3000b138: e593c01c ldr ip, [r3, #28] <== NOT EXECUTED 3000b13c: e084c00c add ip, r4, ip <== NOT EXECUTED 3000b140: e582c01c str ip, [r2, #28] <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 3000b144: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 3000b148: e593c000 ldr ip, [r3] <== NOT EXECUTED previous = the_node->previous; next->previous = previous; previous->next = next; 3000b14c: e582c000 str ip, [r2] <== NOT EXECUTED Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 3000b150: e58c2004 str r2, [ip, #4] <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 3000b154: e5902000 ldr r2, [r0] <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 3000b158: e5830004 str r0, [r3, #4] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; 3000b15c: e5803000 str r3, [r0] <== NOT EXECUTED rtems_chain_extract_unprotected(&b->chain_node); add_to_chain(free_chain, b); _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); 3000b160: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b164: e2831008 add r1, r3, #8 <== NOT EXECUTED the_node->next = before_node; 3000b168: e5832000 str r2, [r3] <== NOT EXECUTED before_node->previous = the_node; 3000b16c: e5823004 str r3, [r2, #4] <== NOT EXECUTED } } 3000b170: e8bd4010 pop {r4, lr} <== NOT EXECUTED } a->size += b->size; rtems_chain_extract_unprotected(&b->chain_node); add_to_chain(free_chain, b); _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); 3000b174: ea00065c b 3000caec <_RBTree_Extract_unprotected> <== NOT EXECUTED =============================================================================== 3000b108 : static int chunk_compare(const rtems_rbtree_node *a, const rtems_rbtree_node *b) { const rtems_rbheap_chunk *left = rtems_rbheap_chunk_of_node(a); const rtems_rbheap_chunk *right = rtems_rbheap_chunk_of_node(b); return (int) (left->begin - right->begin); 3000b108: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 3000b10c: e5910010 ldr r0, [r1, #16] <== NOT EXECUTED } 3000b110: e0600003 rsb r0, r0, r3 <== NOT EXECUTED 3000b114: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 30011020 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 30011020: e92d41f3 push {r0, r1, r4, r5, r6, r7, r8, lr} Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 30011024: e2508000 subs r8, r0, #0 rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 30011028: e1a04001 mov r4, r1 3001102c: e1a06003 mov r6, r3 Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 30011030: 03a00003 moveq r0, #3 ) { Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 30011034: 0a000024 beq 300110cc return RTEMS_INVALID_NAME; if ( !id ) 30011038: e3530000 cmp r3, #0 return RTEMS_INVALID_ADDRESS; 3001103c: 03a00009 moveq r0, #9 CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 30011040: 0a000021 beq 300110cc return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 30011044: e3110010 tst r1, #16 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 30011048: 03a03001 moveq r3, #1 3001104c: 058d3000 streq r3, [sp] if ( !id ) return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 30011050: 0a000004 beq 30011068 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 30011054: e3a03000 mov r3, #0 <== NOT EXECUTED if ( maximum_waiters == 0 ) 30011058: e1520003 cmp r2, r3 <== NOT EXECUTED if ( !id ) return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 3001105c: e58d3000 str r3, [sp] <== NOT EXECUTED if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; 30011060: 03a0000a moveq r0, #10 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 30011064: 0a000018 beq 300110cc <== NOT EXECUTED * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 30011068: e59f3060 ldr r3, [pc, #96] ; 300110d0 return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 3001106c: e58d2004 str r2, [sp, #4] 30011070: e5932000 ldr r2, [r3] ++level; 30011074: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 30011078: e5832000 str r2, [r3] * 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 ); 3001107c: e59f7050 ldr r7, [pc, #80] ; 300110d4 30011080: e1a00007 mov r0, r7 30011084: ebffeeff bl 3000cc88 <_Objects_Allocate> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 30011088: e2505000 subs r5, r0, #0 3001108c: 1a000002 bne 3001109c _Thread_Enable_dispatch(); 30011090: ebfff381 bl 3000de9c <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 30011094: e3a00005 mov r0, #5 <== NOT EXECUTED 30011098: ea00000b b 300110cc <== NOT EXECUTED } the_barrier->attribute_set = attribute_set; _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 3001109c: e2850014 add r0, r5, #20 300110a0: e1a0100d mov r1, sp if ( !the_barrier ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 300110a4: e5854010 str r4, [r5, #16] _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 300110a8: eb0001e6 bl 30011848 <_CORE_barrier_Initialize> #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300110ac: e597201c ldr r2, [r7, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 300110b0: e5953008 ldr r3, [r5, #8] 300110b4: e1d510b8 ldrh r1, [r5, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300110b8: e7825101 str r5, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 300110bc: e585800c str r8, [r5, #12] &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 300110c0: e5863000 str r3, [r6] _Thread_Enable_dispatch(); 300110c4: ebfff374 bl 3000de9c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 300110c8: e3a00000 mov r0, #0 } 300110cc: e8bd81fc pop {r2, r3, r4, r5, r6, r7, r8, pc} =============================================================================== 3000b994 : uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 3000b994: e1a00c00 lsl r0, r0, #24 <== NOT EXECUTED 3000b998: e1800d81 orr r0, r0, r1, lsl #27 <== NOT EXECUTED (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 3000b99c: e1800003 orr r0, r0, r3 <== NOT EXECUTED uint32_t node, uint32_t index ) { return _Objects_Build_id( api, class, node, index ); } 3000b9a0: e1800802 orr r0, r0, r2, lsl #16 <== NOT EXECUTED 3000b9a4: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b9a8 : char C1, char C2, char C3, char C4 ) { 3000b9a8: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); 3000b9ac: e20118ff and r1, r1, #16711680 ; 0xff0000 <== NOT EXECUTED char C1, char C2, char C3, char C4 ) { 3000b9b0: e1a02402 lsl r2, r2, #8 <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); 3000b9b4: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED 3000b9b8: e2022cff and r2, r2, #65280 ; 0xff00 <== NOT EXECUTED char C1, char C2, char C3, char C4 ) { 3000b9bc: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); 3000b9c0: e1800002 orr r0, r0, r2 <== NOT EXECUTED } 3000b9c4: e1800003 orr r0, r0, r3 <== NOT EXECUTED 3000b9c8: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000ae0c : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 3000ae0c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 3000ae10: e1a04002 mov r4, r2 <== NOT EXECUTED 3000ae14: e1a05003 mov r5, r3 <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check( rtems_chain_control *chain, rtems_chain_node *node ) { return _Chain_Append_with_empty_check( chain, node ); 3000ae18: eb000143 bl 3000b32c <_Chain_Append_with_empty_check> <== NOT EXECUTED rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_append_with_empty_check( chain, node ); if ( was_empty ) { 3000ae1c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ae20: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED sc = rtems_event_send( task, events ); 3000ae24: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ae28: e1a01005 mov r1, r5 <== NOT EXECUTED } return sc; } 3000ae2c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_append_with_empty_check( chain, node ); if ( was_empty ) { sc = rtems_event_send( task, events ); 3000ae30: eafffd99 b 3000a49c <== NOT EXECUTED =============================================================================== 3000ae34 : rtems_chain_control *chain, rtems_id task, rtems_event_set events, rtems_chain_node **node ) { 3000ae34: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 3000ae38: e1a04001 mov r4, r1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool rtems_chain_get_with_empty_check( rtems_chain_control *chain, rtems_chain_node **node ) { return _Chain_Get_with_empty_check( chain, node ); 3000ae3c: e1a01003 mov r1, r3 <== NOT EXECUTED 3000ae40: e1a05002 mov r5, r2 <== NOT EXECUTED 3000ae44: eb000154 bl 3000b39c <_Chain_Get_with_empty_check> <== NOT EXECUTED rtems_status_code sc = RTEMS_SUCCESSFUL; bool is_empty = rtems_chain_get_with_empty_check( chain, node ); if ( is_empty ) { 3000ae48: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ae4c: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED sc = rtems_event_send( task, events ); 3000ae50: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ae54: e1a01005 mov r1, r5 <== NOT EXECUTED } return sc; } 3000ae58: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED { rtems_status_code sc = RTEMS_SUCCESSFUL; bool is_empty = rtems_chain_get_with_empty_check( chain, node ); if ( is_empty ) { sc = rtems_event_send( task, events ); 3000ae5c: eafffd8e b 3000a49c <== NOT EXECUTED =============================================================================== 3000ae60 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 3000ae60: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED 3000ae64: e1a07000 mov r7, r0 <== NOT EXECUTED 3000ae68: e1a06001 mov r6, r1 <== NOT EXECUTED 3000ae6c: e1a05002 mov r5, r2 <== NOT EXECUTED 3000ae70: e1a08003 mov r8, r3 <== NOT EXECUTED 3000ae74: ea000006 b 3000ae94 <== NOT EXECUTED while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL ) { rtems_event_set out; sc = rtems_event_receive( 3000ae78: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ae7c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000ae80: e1a02005 mov r2, r5 <== NOT EXECUTED 3000ae84: e1a0300d mov r3, sp <== NOT EXECUTED 3000ae88: ebfffd24 bl 3000a320 <== NOT EXECUTED ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 3000ae8c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ae90: 1a000004 bne 3000aea8 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 3000ae94: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ae98: eb000153 bl 3000b3ec <_Chain_Get> <== NOT EXECUTED sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 3000ae9c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000aea0: 0afffff4 beq 3000ae78 <== NOT EXECUTED 3000aea4: e3a00000 mov r0, #0 <== NOT EXECUTED timeout, &out ); } *node_ptr = node; 3000aea8: e5884000 str r4, [r8] <== NOT EXECUTED return sc; } 3000aeac: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 3000aeb0 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 3000aeb0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 3000aeb4: e1a04002 mov r4, r2 <== NOT EXECUTED 3000aeb8: e1a05003 mov r5, r3 <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check( rtems_chain_control *chain, rtems_chain_node *node ) { return _Chain_Prepend_with_empty_check( chain, node ); 3000aebc: eb000171 bl 3000b488 <_Chain_Prepend_with_empty_check> <== NOT EXECUTED rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_prepend_with_empty_check( chain, node ); if (was_empty) { 3000aec0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000aec4: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED sc = rtems_event_send( task, events ); 3000aec8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aecc: e1a01005 mov r1, r5 <== NOT EXECUTED } return sc; } 3000aed0: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_prepend_with_empty_check( chain, node ); if (was_empty) { sc = rtems_event_send( task, events ); 3000aed4: eafffd70 b 3000a49c <== NOT EXECUTED =============================================================================== 3000ac44 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 3000ac44: e92d4010 push {r4, lr} <== NOT EXECUTED if ( !time_buffer ) 3000ac48: e2514000 subs r4, r1, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 3000ac4c: 03a00009 moveq r0, #9 <== NOT EXECUTED rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { if ( !time_buffer ) 3000ac50: 08bd8010 popeq {r4, pc} <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( option == RTEMS_CLOCK_GET_TOD ) 3000ac54: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ac58: 1a000002 bne 3000ac68 <== NOT EXECUTED return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 3000ac5c: e1a00004 mov r0, r4 <== NOT EXECUTED if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); return RTEMS_INVALID_NUMBER; } 3000ac60: e8bd4010 pop {r4, lr} <== NOT EXECUTED { if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( option == RTEMS_CLOCK_GET_TOD ) return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 3000ac64: ea000034 b 3000ad3c <== NOT EXECUTED if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH ) 3000ac68: e3500001 cmp r0, #1 <== NOT EXECUTED 3000ac6c: 1a000002 bne 3000ac7c <== NOT EXECUTED return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 3000ac70: e1a00004 mov r0, r4 <== NOT EXECUTED if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); return RTEMS_INVALID_NUMBER; } 3000ac74: e8bd4010 pop {r4, lr} <== NOT EXECUTED if ( option == RTEMS_CLOCK_GET_TOD ) return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH ) return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 3000ac78: ea000010 b 3000acc0 <== NOT EXECUTED if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) { 3000ac7c: e3500002 cmp r0, #2 <== NOT EXECUTED 3000ac80: 1a000001 bne 3000ac8c <== NOT EXECUTED rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_since_boot(); 3000ac84: eb000028 bl 3000ad2c <== NOT EXECUTED 3000ac88: ea000002 b 3000ac98 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) { 3000ac8c: e3500003 cmp r0, #3 <== NOT EXECUTED 3000ac90: 1a000003 bne 3000aca4 <== NOT EXECUTED rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_per_second(); 3000ac94: eb00001c bl 3000ad0c <== NOT EXECUTED 3000ac98: e5840000 str r0, [r4] <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000ac9c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000aca0: e8bd8010 pop {r4, pc} <== NOT EXECUTED } if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) 3000aca4: e3500004 cmp r0, #4 <== NOT EXECUTED 3000aca8: 1a000002 bne 3000acb8 <== NOT EXECUTED return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 3000acac: e1a00004 mov r0, r4 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; } 3000acb0: e8bd4010 pop {r4, lr} <== NOT EXECUTED *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 3000acb4: ea000059 b 3000ae20 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 3000acb8: e3a0000a mov r0, #10 <== NOT EXECUTED } 3000acbc: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000aabc : #include rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { 3000aabc: e92d4010 push {r4, lr} if ( !the_interval ) 3000aac0: e2504000 subs r4, r0, #0 return RTEMS_INVALID_ADDRESS; 3000aac4: 03a00009 moveq r0, #9 rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { if ( !the_interval ) 3000aac8: 08bd8010 popeq {r4, pc} return RTEMS_INVALID_ADDRESS; if ( !_TOD.is_set ) 3000aacc: e59f302c ldr r3, [pc, #44] ; 3000ab00 3000aad0: e5d32014 ldrb r2, [r3, #20] 3000aad4: e3520000 cmp r2, #0 3000aad8: 0a000006 beq 3000aaf8 static inline uint32_t _Timestamp64_implementation_Get_seconds( const Timestamp64_Control *_time ) { return (uint32_t) (*_time / 1000000000L); 3000aadc: e8930003 ldm r3, {r0, r1} 3000aae0: e59f201c ldr r2, [pc, #28] ; 3000ab04 3000aae4: e3a03000 mov r3, #0 3000aae8: eb0046f0 bl 3001c6b0 <__divdi3> 3000aaec: e5840000 str r0, [r4] return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch(); return RTEMS_SUCCESSFUL; 3000aaf0: e3a00000 mov r0, #0 3000aaf4: e8bd8010 pop {r4, pc} { if ( !the_interval ) return RTEMS_INVALID_ADDRESS; if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; 3000aaf8: e3a0000b mov r0, #11 <== NOT EXECUTED *the_interval = _TOD_Seconds_since_epoch(); return RTEMS_SUCCESSFUL; } 3000aafc: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 30009b9c : #include #include rtems_interval rtems_clock_get_ticks_per_second(void) { return TOD_MICROSECONDS_PER_SECOND / 30009b9c: e59f3010 ldr r3, [pc, #16] ; 30009bb4 <== NOT EXECUTED #include #include #include rtems_interval rtems_clock_get_ticks_per_second(void) { 30009ba0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED return TOD_MICROSECONDS_PER_SECOND / 30009ba4: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 30009ba8: e59f0008 ldr r0, [pc, #8] ; 30009bb8 <== NOT EXECUTED 30009bac: eb004014 bl 30019c04 <__aeabi_uidiv> <== NOT EXECUTED rtems_configuration_get_microseconds_per_tick(); } 30009bb0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 30009bbc : #include #include rtems_interval rtems_clock_get_ticks_since_boot(void) { return _Watchdog_Ticks_since_boot; 30009bbc: e59f3004 ldr r3, [pc, #4] ; 30009bc8 <== NOT EXECUTED 30009bc0: e5930000 ldr r0, [r3] <== NOT EXECUTED } 30009bc4: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 30016e9c : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 30016e9c: e92d40d3 push {r0, r1, r4, r6, r7, lr} <== NOT EXECUTED if ( !time ) 30016ea0: e2504000 subs r4, r0, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 30016ea4: 03a00009 moveq r0, #9 <== NOT EXECUTED rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { if ( !time ) 30016ea8: 0a000017 beq 30016f0c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD.is_set ) 30016eac: e59f105c ldr r1, [pc, #92] ; 30016f10 <== NOT EXECUTED 30016eb0: e5d13014 ldrb r3, [r1, #20] <== NOT EXECUTED 30016eb4: e3530000 cmp r3, #0 <== NOT EXECUTED return RTEMS_NOT_DEFINED; 30016eb8: 03a0000b moveq r0, #11 <== NOT EXECUTED ) { if ( !time ) return RTEMS_INVALID_ADDRESS; if ( !_TOD.is_set ) 30016ebc: 0a000012 beq 30016f0c <== NOT EXECUTED ) { Timestamp_Control snapshot_as_timestamp; Timestamp_Control *snapshot_as_timestamp_ptr; snapshot_as_timestamp_ptr = 30016ec0: e1a0000d mov r0, sp <== NOT EXECUTED 30016ec4: ebffd890 bl 3000d10c <_TOD_Get_with_nanoseconds> <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timeval( const Timestamp64_Control *_timestamp, struct timeval *_timeval ) { _timeval->tv_sec = (time_t) (*_timestamp / 1000000000U); 30016ec8: e59f2044 ldr r2, [pc, #68] ; 30016f14 <== NOT EXECUTED return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; } 30016ecc: e89000c0 ldm r0, {r6, r7} <== NOT EXECUTED 30016ed0: e3a03000 mov r3, #0 <== NOT EXECUTED 30016ed4: e1a00006 mov r0, r6 <== NOT EXECUTED 30016ed8: e1a01007 mov r1, r7 <== NOT EXECUTED 30016edc: ebffba54 bl 30005834 <__divdi3> <== NOT EXECUTED _timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U); 30016ee0: e59f202c ldr r2, [pc, #44] ; 30016f14 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timeval( const Timestamp64_Control *_timestamp, struct timeval *_timeval ) { _timeval->tv_sec = (time_t) (*_timestamp / 1000000000U); 30016ee4: e5840000 str r0, [r4] <== NOT EXECUTED _timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U); 30016ee8: e3a03000 mov r3, #0 <== NOT EXECUTED 30016eec: e1a00006 mov r0, r6 <== NOT EXECUTED 30016ef0: e1a01007 mov r1, r7 <== NOT EXECUTED 30016ef4: eb004c85 bl 3002a110 <__moddi3> <== NOT EXECUTED 30016ef8: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 30016efc: e3a03000 mov r3, #0 <== NOT EXECUTED 30016f00: ebffba4b bl 30005834 <__divdi3> <== NOT EXECUTED 30016f04: e5840004 str r0, [r4, #4] <== NOT EXECUTED if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; 30016f08: e3a00000 mov r0, #0 <== NOT EXECUTED } 30016f0c: e8bd80dc pop {r2, r3, r4, r6, r7, pc} <== NOT EXECUTED =============================================================================== 30025bb0 : */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime ) 30025bb0: e3500000 cmp r0, #0 <== NOT EXECUTED * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 30025bb4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED if ( !uptime ) 30025bb8: 0a000002 beq 30025bc8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime_as_timespec( uptime ); 30025bbc: eb000234 bl 30026494 <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30025bc0: e3a00000 mov r0, #0 <== NOT EXECUTED 30025bc4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime ) return RTEMS_INVALID_ADDRESS; 30025bc8: e3a00009 mov r0, #9 <== NOT EXECUTED _TOD_Get_uptime_as_timespec( uptime ); return RTEMS_SUCCESSFUL; } 30025bcc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 30015e68 : #endif #include time_t rtems_clock_get_uptime_seconds( void ) { 30015e68: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 30015e6c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30015e70: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30015e74: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED Timestamp_Control snapshot_as_timestamp; struct timespec snapshot_as_timespec; ISR_Level level; _ISR_Disable( level ); snapshot_as_timestamp = _TOD.uptime; 30015e78: e59f2018 ldr r2, [pc, #24] ; 30015e98 <== NOT EXECUTED 30015e7c: e2821008 add r1, r2, #8 <== NOT EXECUTED 30015e80: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 30015e84: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 30015e88: e59f200c ldr r2, [pc, #12] ; 30015e9c <== NOT EXECUTED 30015e8c: e3a03000 mov r3, #0 <== NOT EXECUTED 30015e90: eb005839 bl 3002bf7c <__divdi3> <== NOT EXECUTED _ISR_Enable( level ); _Timestamp_To_timespec( &snapshot_as_timestamp, &snapshot_as_timespec ); return snapshot_as_timespec.tv_sec; } 30015e94: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 30015ea0 : #endif #include void rtems_clock_get_uptime_timeval( struct timeval *uptime ) { 30015ea0: e92d40d3 push {r0, r1, r4, r6, r7, lr} <== NOT EXECUTED 30015ea4: e1a04000 mov r4, r0 <== NOT EXECUTED */ static inline void _TOD_Get_uptime( Timestamp_Control *time ) { _TOD_Get_with_nanoseconds( time, &_TOD.uptime ); 30015ea8: e59f1048 ldr r1, [pc, #72] ; 30015ef8 <== NOT EXECUTED 30015eac: e1a0000d mov r0, sp <== NOT EXECUTED 30015eb0: eb001174 bl 3001a488 <_TOD_Get_with_nanoseconds> <== NOT EXECUTED Timestamp_Control snapshot_as_timestamp; _TOD_Get_uptime( &snapshot_as_timestamp ); _Timestamp_To_timeval( &snapshot_as_timestamp, uptime ); 30015eb4: e89d00c0 ldm sp, {r6, r7} <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timeval( const Timestamp64_Control *_timestamp, struct timeval *_timeval ) { _timeval->tv_sec = (time_t) (*_timestamp / 1000000000U); 30015eb8: e59f203c ldr r2, [pc, #60] ; 30015efc <== NOT EXECUTED 30015ebc: e3a03000 mov r3, #0 <== NOT EXECUTED 30015ec0: e1a00006 mov r0, r6 <== NOT EXECUTED 30015ec4: e1a01007 mov r1, r7 <== NOT EXECUTED 30015ec8: eb00582b bl 3002bf7c <__divdi3> <== NOT EXECUTED _timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U); 30015ecc: e59f2028 ldr r2, [pc, #40] ; 30015efc <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timeval( const Timestamp64_Control *_timestamp, struct timeval *_timeval ) { _timeval->tv_sec = (time_t) (*_timestamp / 1000000000U); 30015ed0: e5840000 str r0, [r4] <== NOT EXECUTED _timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U); 30015ed4: e3a03000 mov r3, #0 <== NOT EXECUTED 30015ed8: e1a00006 mov r0, r6 <== NOT EXECUTED 30015edc: e1a01007 mov r1, r7 <== NOT EXECUTED 30015ee0: eb005960 bl 3002c468 <__moddi3> <== NOT EXECUTED 30015ee4: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 30015ee8: e3a03000 mov r3, #0 <== NOT EXECUTED 30015eec: eb005822 bl 3002bf7c <__divdi3> <== NOT EXECUTED 30015ef0: e5840004 str r0, [r4, #4] <== NOT EXECUTED } 30015ef4: e8bd80dc pop {r2, r3, r4, r6, r7, pc} <== NOT EXECUTED =============================================================================== 30009be8 : #include #include #include rtems_status_code rtems_clock_tick( void ) { 30009be8: e52de004 push {lr} ; (str lr, [sp, #-4]!) _TOD_Tickle_ticks(); 30009bec: eb000521 bl 3000b078 <_TOD_Tickle_ticks> */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 30009bf0: e59f0034 ldr r0, [pc, #52] ; 30009c2c 30009bf4: eb000e5d bl 3000d570 <_Watchdog_Tickle> * scheduler which support standard RTEMS features, this includes * time-slicing management. */ RTEMS_INLINE_ROUTINE void _Scheduler_Tick( void ) { _Scheduler.Operations.tick(); 30009bf8: e59f3030 ldr r3, [pc, #48] ; 30009c30 30009bfc: e1a0e00f mov lr, pc 30009c00: e593f038 ldr pc, [r3, #56] ; 0x38 * otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void ) { return ( _Thread_Dispatch_necessary ); 30009c04: e59f3028 ldr r3, [pc, #40] ; 30009c34 30009c08: e5d33004 ldrb r3, [r3, #4] _Watchdog_Tickle_ticks(); _Scheduler_Tick(); if ( _Thread_Is_context_switch_necessary() && 30009c0c: e3530000 cmp r3, #0 30009c10: 0a000003 beq 30009c24 * This routine returns true if thread dispatch indicates * that we are in a critical section. */ RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void) { if ( _Thread_Dispatch_disable_level == 0 ) 30009c14: e59f301c ldr r3, [pc, #28] ; 30009c38 <== NOT EXECUTED 30009c18: e5933000 ldr r3, [r3] <== NOT EXECUTED 30009c1c: e3530000 cmp r3, #0 <== NOT EXECUTED _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 30009c20: 0b000a9d bleq 3000c69c <_Thread_Dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 30009c24: e3a00000 mov r0, #0 30009c28: e49df004 pop {pc} ; (ldr pc, [sp], #4) =============================================================================== 3000df50 : rtems_status_code rtems_extension_create( rtems_name name, const rtems_extensions_table *extension_table, rtems_id *id ) { 3000df50: e92d41f0 push {r4, r5, r6, r7, r8, lr} Extension_Control *the_extension; if ( !id ) 3000df54: e2527000 subs r7, r2, #0 rtems_status_code rtems_extension_create( rtems_name name, const rtems_extensions_table *extension_table, rtems_id *id ) { 3000df58: e1a05000 mov r5, r0 3000df5c: e1a08001 mov r8, r1 Extension_Control *the_extension; if ( !id ) return RTEMS_INVALID_ADDRESS; 3000df60: 03a00009 moveq r0, #9 rtems_id *id ) { Extension_Control *the_extension; if ( !id ) 3000df64: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 3000df68: e3550000 cmp r5, #0 3000df6c: 0a00001c beq 3000dfe4 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000df70: e59f3074 ldr r3, [pc, #116] ; 3000dfec 3000df74: e5932000 ldr r2, [r3] ++level; 3000df78: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 3000df7c: e5832000 str r2, [r3] #ifndef __EXTENSION_MANAGER_inl #define __EXTENSION_MANAGER_inl RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void ) { return (Extension_Control *) _Objects_Allocate( &_Extension_Information ); 3000df80: e59f6068 ldr r6, [pc, #104] ; 3000dff0 3000df84: e1a00006 mov r0, r6 3000df88: eb000358 bl 3000ecf0 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 3000df8c: e2504000 subs r4, r0, #0 3000df90: 1a000002 bne 3000dfa0 _Thread_Enable_dispatch(); 3000df94: eb00081e bl 30010014 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 3000df98: e3a00005 mov r0, #5 <== NOT EXECUTED 3000df9c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table( User_extensions_Control *extension, const User_extensions_Table *extension_table ) { extension->Callouts = *extension_table; 3000dfa0: e284c024 add ip, r4, #36 ; 0x24 3000dfa4: e1a0e008 mov lr, r8 3000dfa8: e8be000f ldm lr!, {r0, r1, r2, r3} 3000dfac: e8ac000f stmia ip!, {r0, r1, r2, r3} 3000dfb0: e89e000f ldm lr, {r0, r1, r2, r3} 3000dfb4: e88c000f stm ip, {r0, r1, r2, r3} _User_extensions_Add_set( extension ); 3000dfb8: e2840010 add r0, r4, #16 3000dfbc: eb000a72 bl 3001098c <_User_extensions_Add_set> #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000dfc0: e596201c ldr r2, [r6, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 3000dfc4: e5943008 ldr r3, [r4, #8] 3000dfc8: e1d410b8 ldrh r1, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000dfcc: e7824101 str r4, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 3000dfd0: e584500c str r5, [r4, #12] &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 3000dfd4: e5873000 str r3, [r7] _Thread_Enable_dispatch(); 3000dfd8: eb00080d bl 30010014 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000dfdc: e3a00000 mov r0, #0 3000dfe0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 3000dfe4: e3a00003 mov r0, #3 <== NOT EXECUTED ); *id = the_extension->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 3000dfe8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 3000c654 : rtems_status_code rtems_extension_ident( rtems_name name, rtems_id *id ) { 3000c654: e1a02000 mov r2, r0 <== NOT EXECUTED 3000c658: e1a03001 mov r3, r1 <== NOT EXECUTED 3000c65c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 3000c660: e1a01002 mov r1, r2 <== NOT EXECUTED 3000c664: e59f0010 ldr r0, [pc, #16] ; 3000c67c <== NOT EXECUTED 3000c668: e3e02102 mvn r2, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000c66c: eb00049f bl 3000d8f0 <_Objects_Name_to_id_u32> <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 3000c670: e59f3008 ldr r3, [pc, #8] ; 3000c680 <== NOT EXECUTED 3000c674: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3000c678: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 3000c580 : #include const char *rtems_get_version_string(void) { return _RTEMS_version; } 3000c580: e59f0000 ldr r0, [pc] ; 3000c588 <== NOT EXECUTED 3000c584: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000ab44 : uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000ab44: e10f0000 mrs r0, CPSR <== NOT EXECUTED 3000ab48: e3803080 orr r3, r0, #128 ; 0x80 <== NOT EXECUTED 3000ab4c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED rtems_interrupt_level previous_level; _ISR_Disable( previous_level ); return previous_level; } 3000ab50: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000ab54 : static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000ab54: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED void rtems_interrupt_enable( rtems_interrupt_level previous_level ) { _ISR_Enable( previous_level ); } 3000ab58: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000ab5c : static inline void arm_interrupt_flash( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000ab5c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000ab60: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 3000ab64: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED void rtems_interrupt_flash( rtems_interrupt_level previous_level ) { _ISR_Flash( previous_level ); } 3000ab68: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000ab6c : #undef rtems_interrupt_is_in_progress bool rtems_interrupt_is_in_progress( void ) { return _ISR_Is_in_progress(); 3000ab6c: e59f300c ldr r3, [pc, #12] ; 3000ab80 <== NOT EXECUTED 3000ab70: e5930000 ldr r0, [r3] <== NOT EXECUTED } 3000ab74: e2900000 adds r0, r0, #0 <== NOT EXECUTED 3000ab78: 13a00001 movne r0, #1 <== NOT EXECUTED 3000ab7c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000ab84 : Modes_Control rtems_interrupt_level_body( uint32_t level ) { return RTEMS_INTERRUPT_LEVEL(level); } 3000ab84: e2000080 and r0, r0, #128 ; 0x80 <== NOT EXECUTED 3000ab88: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3001093c : void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3001093c: e59fc044 ldr ip, [pc, #68] ; 30010988 rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 30010940: e1a03000 mov r3, r0 rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010944: e59cc000 ldr ip, [ip] rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 30010948: e92d4010 push {r4, lr} rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3001094c: e150000c cmp r0, ip return RTEMS_INVALID_NUMBER; 30010950: 23a0000a movcs r0, #10 void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010954: 28bd8010 popcs {r4, pc} return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 30010958: e59fc02c ldr ip, [pc, #44] ; 3001098c 3001095c: e3a04018 mov r4, #24 30010960: e59cc000 ldr ip, [ip] 30010964: e023c394 mla r3, r4, r3, ip 30010968: e5933008 ldr r3, [r3, #8] return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 3001096c: e3530000 cmp r3, #0 30010970: 0a000002 beq 30010980 30010974: e1a0e00f mov lr, pc 30010978: e12fff13 bx r3 3001097c: e8bd8010 pop {r4, pc} 30010980: e1a00003 mov r0, r3 <== NOT EXECUTED } 30010984: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 30010990 : void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010990: e59fc044 ldr ip, [pc, #68] ; 300109dc rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 30010994: e1a03000 mov r3, r0 rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010998: e59cc000 ldr ip, [ip] rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 3001099c: e92d4010 push {r4, lr} rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 300109a0: e150000c cmp r0, ip return RTEMS_INVALID_NUMBER; 300109a4: 23a0000a movcs r0, #10 void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 300109a8: 28bd8010 popcs {r4, pc} return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 300109ac: e59fc02c ldr ip, [pc, #44] ; 300109e0 300109b0: e3a04018 mov r4, #24 300109b4: e59cc000 ldr ip, [ip] 300109b8: e023c394 mla r3, r4, r3, ip 300109bc: e5933014 ldr r3, [r3, #20] return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 300109c0: e3530000 cmp r3, #0 300109c4: 0a000002 beq 300109d4 300109c8: e1a0e00f mov lr, pc 300109cc: e12fff13 bx r3 300109d0: e8bd8010 pop {r4, pc} 300109d4: e1a00003 mov r0, r3 <== NOT EXECUTED } 300109d8: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 300109e4 : void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 300109e4: e59fc044 ldr ip, [pc, #68] ; 30010a30 rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 300109e8: e1a03000 mov r3, r0 rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 300109ec: e59cc000 ldr ip, [ip] rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 300109f0: e92d4010 push {r4, lr} rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 300109f4: e150000c cmp r0, ip return RTEMS_INVALID_NUMBER; 300109f8: 23a0000a movcs r0, #10 void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 300109fc: 28bd8010 popcs {r4, pc} return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 30010a00: e59fc02c ldr ip, [pc, #44] ; 30010a34 30010a04: e3a04018 mov r4, #24 30010a08: e59cc000 ldr ip, [ip] 30010a0c: e023c394 mla r3, r4, r3, ip 30010a10: e5933004 ldr r3, [r3, #4] return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 30010a14: e3530000 cmp r3, #0 30010a18: 0a000002 beq 30010a28 30010a1c: e1a0e00f mov lr, pc 30010a20: e12fff13 bx r3 30010a24: e8bd8010 pop {r4, pc} 30010a28: e1a00003 mov r0, r3 <== NOT EXECUTED } 30010a2c: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 30010a38 : void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010a38: e59fc044 ldr ip, [pc, #68] ; 30010a84 rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 30010a3c: e1a03000 mov r3, r0 rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010a40: e59cc000 ldr ip, [ip] rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 30010a44: e92d4010 push {r4, lr} rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010a48: e150000c cmp r0, ip return RTEMS_INVALID_NUMBER; 30010a4c: 23a0000a movcs r0, #10 void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010a50: 28bd8010 popcs {r4, pc} return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 30010a54: e59fc02c ldr ip, [pc, #44] ; 30010a88 30010a58: e3a04018 mov r4, #24 30010a5c: e59cc000 ldr ip, [ip] 30010a60: e023c394 mla r3, r4, r3, ip 30010a64: e593300c ldr r3, [r3, #12] return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 30010a68: e3530000 cmp r3, #0 30010a6c: 0a000002 beq 30010a7c 30010a70: e1a0e00f mov lr, pc 30010a74: e12fff13 bx r3 30010a78: e8bd8010 pop {r4, pc} 30010a7c: e1a00003 mov r0, r3 <== NOT EXECUTED } 30010a80: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000beb0 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 3000beb0: e92d4010 push {r4, lr} 3000beb4: e1a04000 mov r4, r0 rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) 3000beb8: e59f0158 ldr r0, [pc, #344] ; 3000c018 rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { rtems_device_major_number major_limit = _IO_Number_of_drivers; 3000bebc: e59f3158 ldr r3, [pc, #344] ; 3000c01c if ( rtems_interrupt_is_in_progress() ) 3000bec0: e5900000 ldr r0, [r0] rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { rtems_device_major_number major_limit = _IO_Number_of_drivers; 3000bec4: e5933000 ldr r3, [r3] if ( rtems_interrupt_is_in_progress() ) 3000bec8: e3500000 cmp r0, #0 return RTEMS_CALLED_FROM_ISR; 3000becc: 13a00012 movne r0, #18 rtems_device_major_number *registered_major ) { rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) 3000bed0: 18bd8010 popne {r4, pc} return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 3000bed4: e3520000 cmp r2, #0 3000bed8: 0a000041 beq 3000bfe4 return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; if ( driver_table == NULL ) 3000bedc: e3510000 cmp r1, #0 if ( registered_major == NULL ) return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 3000bee0: e5823000 str r3, [r2] if ( driver_table == NULL ) 3000bee4: 0a00003e beq 3000bfe4 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 3000bee8: e5910000 ldr r0, [r1] 3000beec: e3500000 cmp r0, #0 3000bef0: 1a00003f bne 3000bff4 3000bef4: e5910004 ldr r0, [r1, #4] 3000bef8: e3500000 cmp r0, #0 3000befc: 1a00003c bne 3000bff4 3000bf00: ea000037 b 3000bfe4 <== NOT EXECUTED * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000bf04: e59f3114 ldr r3, [pc, #276] ; 3000c020 3000bf08: e5930000 ldr r0, [r3] ++level; 3000bf0c: e2800001 add r0, r0, #1 _Thread_Dispatch_disable_level = level; 3000bf10: e5830000 str r0, [r3] if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 3000bf14: e3540000 cmp r4, #0 3000bf18: e59f0104 ldr r0, [pc, #260] ; 3000c024 3000bf1c: 1a000010 bne 3000bf64 static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 3000bf20: e59f30f4 ldr r3, [pc, #244] ; 3000c01c 3000bf24: e593c000 ldr ip, [r3] 3000bf28: e5903000 ldr r3, [r0] 3000bf2c: ea000006 b 3000bf4c static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 3000bf30: e5930000 ldr r0, [r3] 3000bf34: e3500000 cmp r0, #0 3000bf38: 1a000030 bne 3000c000 3000bf3c: e5930004 ldr r0, [r3, #4] 3000bf40: e3500000 cmp r0, #0 3000bf44: 1a00002d bne 3000c000 3000bf48: ea000001 b 3000bf54 rtems_device_major_number n = _IO_Number_of_drivers; rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 3000bf4c: e154000c cmp r4, ip 3000bf50: 1afffff6 bne 3000bf30 } /* Assigns invalid value in case of failure */ *major = m; if ( m != n ) 3000bf54: e154000c cmp r4, ip if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 3000bf58: e5824000 str r4, [r2] if ( m != n ) 3000bf5c: 1a000011 bne 3000bfa8 3000bf60: ea000029 b 3000c00c <== NOT EXECUTED _Thread_Enable_dispatch(); return sc; } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; 3000bf64: e3a03018 mov r3, #24 <== NOT EXECUTED 3000bf68: e0030394 mul r3, r4, r3 <== NOT EXECUTED 3000bf6c: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000bf70: e080c003 add ip, r0, r3 <== NOT EXECUTED static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 3000bf74: e7903003 ldr r3, [r0, r3] <== NOT EXECUTED 3000bf78: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bf7c: 13a03000 movne r3, #0 <== NOT EXECUTED 3000bf80: 1a000002 bne 3000bf90 <== NOT EXECUTED return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; } rtems_status_code rtems_io_register_driver( 3000bf84: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 3000bf88: e2733001 rsbs r3, r3, #1 <== NOT EXECUTED 3000bf8c: 33a03000 movcc r3, #0 <== NOT EXECUTED } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; if ( !rtems_io_is_empty_table( table ) ) { 3000bf90: e3530000 cmp r3, #0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } *registered_major = major; 3000bf94: 15824000 strne r4, [r2] <== NOT EXECUTED } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; if ( !rtems_io_is_empty_table( table ) ) { 3000bf98: 1a000002 bne 3000bfa8 <== NOT EXECUTED _Thread_Enable_dispatch(); 3000bf9c: eb0007a2 bl 3000de2c <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_RESOURCE_IN_USE; 3000bfa0: e3a0000c mov r0, #12 <== NOT EXECUTED 3000bfa4: e8bd8010 pop {r4, pc} <== NOT EXECUTED } *registered_major = major; } _IO_Driver_address_table [major] = *driver_table; 3000bfa8: e59f3074 ldr r3, [pc, #116] ; 3000c024 3000bfac: e3a0c018 mov ip, #24 3000bfb0: e5933000 ldr r3, [r3] 3000bfb4: e1a0e001 mov lr, r1 3000bfb8: e02c3c94 mla ip, r4, ip, r3 3000bfbc: e8be000f ldm lr!, {r0, r1, r2, r3} 3000bfc0: e8ac000f stmia ip!, {r0, r1, r2, r3} 3000bfc4: e89e0003 ldm lr, {r0, r1} 3000bfc8: e88c0003 stm ip, {r0, r1} _Thread_Enable_dispatch(); 3000bfcc: eb000796 bl 3000de2c <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 3000bfd0: e3a01000 mov r1, #0 3000bfd4: e1a00004 mov r0, r4 3000bfd8: e1a02001 mov r2, r1 } 3000bfdc: e8bd4010 pop {r4, lr} _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 3000bfe0: ea001cbb b 300132d4 if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 3000bfe4: e3a00009 mov r0, #9 <== NOT EXECUTED 3000bfe8: e8bd8010 pop {r4, pc} <== NOT EXECUTED if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; 3000bfec: e3a0000a mov r0, #10 <== NOT EXECUTED _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 3000bff0: e8bd8010 pop {r4, pc} <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 3000bff4: e1540003 cmp r4, r3 3000bff8: 2afffffb bcs 3000bfec 3000bffc: eaffffc0 b 3000bf04 rtems_device_major_number n = _IO_Number_of_drivers; rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 3000c000: e2844001 add r4, r4, #1 3000c004: e2833018 add r3, r3, #24 3000c008: eaffffcf b 3000bf4c if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 3000c00c: eb000786 bl 3000de2c <_Thread_Enable_dispatch> <== NOT EXECUTED *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 3000c010: e3a00005 mov r0, #5 <== NOT EXECUTED if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); return sc; 3000c014: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000c028 : rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( rtems_interrupt_is_in_progress() ) 3000c028: e59f305c ldr r3, [pc, #92] ; 3000c08c #include rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 3000c02c: e92d4010 push {r4, lr} if ( rtems_interrupt_is_in_progress() ) 3000c030: e5934000 ldr r4, [r3] 3000c034: e3540000 cmp r4, #0 return RTEMS_CALLED_FROM_ISR; 3000c038: 13a00012 movne r0, #18 rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( rtems_interrupt_is_in_progress() ) 3000c03c: 18bd8010 popne {r4, pc} return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { 3000c040: e59f3048 ldr r3, [pc, #72] ; 3000c090 3000c044: e5933000 ldr r3, [r3] 3000c048: e1500003 cmp r0, r3 3000c04c: 2a00000c bcs 3000c084 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000c050: e59f303c ldr r3, [pc, #60] ; 3000c094 3000c054: e5932000 ldr r2, [r3] ++level; 3000c058: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 3000c05c: e5832000 str r2, [r3] _Thread_Disable_dispatch(); memset( 3000c060: e59f3030 ldr r3, [pc, #48] ; 3000c098 &_IO_Driver_address_table[major], 3000c064: e3a02018 mov r2, #24 if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { _Thread_Disable_dispatch(); memset( 3000c068: e5933000 ldr r3, [r3] 3000c06c: e1a01004 mov r1, r4 3000c070: e0203092 mla r0, r2, r0, r3 3000c074: eb002614 bl 300158cc &_IO_Driver_address_table[major], 0, sizeof( rtems_driver_address_table ) ); _Thread_Enable_dispatch(); 3000c078: eb00076b bl 3000de2c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000c07c: e1a00004 mov r0, r4 3000c080: e8bd8010 pop {r4, pc} } return RTEMS_UNSATISFIED; 3000c084: e3a0000d mov r0, #13 <== NOT EXECUTED } 3000c088: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 30010a8c : void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010a8c: e59fc044 ldr ip, [pc, #68] ; 30010ad8 rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 30010a90: e1a03000 mov r3, r0 rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010a94: e59cc000 ldr ip, [ip] rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 30010a98: e92d4010 push {r4, lr} rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010a9c: e150000c cmp r0, ip return RTEMS_INVALID_NUMBER; 30010aa0: 23a0000a movcs r0, #10 void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010aa4: 28bd8010 popcs {r4, pc} return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 30010aa8: e59fc02c ldr ip, [pc, #44] ; 30010adc 30010aac: e3a04018 mov r4, #24 30010ab0: e59cc000 ldr ip, [ip] 30010ab4: e023c394 mla r3, r4, r3, ip 30010ab8: e5933010 ldr r3, [r3, #16] return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 30010abc: e3530000 cmp r3, #0 30010ac0: 0a000002 beq 30010ad0 30010ac4: e1a0e00f mov lr, pc 30010ac8: e12fff13 bx r3 30010acc: e8bd8010 pop {r4, pc} 30010ad0: e1a00003 mov r0, r3 <== NOT EXECUTED } 30010ad4: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000ca88 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 3000ca88: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 3000ca8c: e2508000 subs r8, r0, #0 <== NOT EXECUTED 3000ca90: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED 3000ca94: e59f4050 ldr r4, [pc, #80] ; 3000caec <== NOT EXECUTED #endif #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) 3000ca98: e284700c add r7, r4, #12 <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) 3000ca9c: e5b43004 ldr r3, [r4, #4]! <== NOT EXECUTED 3000caa0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000caa4: 0a00000d beq 3000cae0 <== NOT EXECUTED continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 3000caa8: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED if ( !information ) 3000caac: e3560000 cmp r6, #0 <== NOT EXECUTED 3000cab0: 13a05001 movne r5, #1 <== NOT EXECUTED 3000cab4: 1a000006 bne 3000cad4 <== NOT EXECUTED 3000cab8: ea000008 b 3000cae0 <== NOT EXECUTED continue; for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 3000cabc: e596301c ldr r3, [r6, #28] <== NOT EXECUTED 3000cac0: e7930105 ldr r0, [r3, r5, lsl #2] <== NOT EXECUTED if ( !the_thread ) 3000cac4: e3500000 cmp r0, #0 <== NOT EXECUTED continue; (*routine)(the_thread); 3000cac8: 11a0e00f movne lr, pc <== NOT EXECUTED 3000cacc: 112fff18 bxne r8 <== NOT EXECUTED information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 3000cad0: e2855001 add r5, r5, #1 <== NOT EXECUTED 3000cad4: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED 3000cad8: e1550003 cmp r5, r3 <== NOT EXECUTED 3000cadc: 9afffff6 bls 3000cabc <== NOT EXECUTED Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 3000cae0: e1540007 cmp r4, r7 <== NOT EXECUTED 3000cae4: 1affffec bne 3000ca9c <== NOT EXECUTED 3000cae8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 300166b4 : rtems_id id, const void *buffer, size_t size, uint32_t *count ) { 300166b4: e92d40f7 push {r0, r1, r2, r4, r5, r6, r7, lr} register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status core_status; if ( !buffer ) 300166b8: e2517000 subs r7, r1, #0 rtems_id id, const void *buffer, size_t size, uint32_t *count ) { 300166bc: e1a04000 mov r4, r0 300166c0: e1a05002 mov r5, r2 300166c4: e1a06003 mov r6, r3 register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status core_status; if ( !buffer ) 300166c8: 0a000014 beq 30016720 return RTEMS_INVALID_ADDRESS; if ( !count ) 300166cc: e3530000 cmp r3, #0 300166d0: 0a000012 beq 30016720 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 300166d4: e59f004c ldr r0, [pc, #76] ; 30016728 300166d8: e1a01004 mov r1, r4 300166dc: e28d2008 add r2, sp, #8 300166e0: eb0014a1 bl 3001b96c <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 300166e4: e59d3008 ldr r3, [sp, #8] 300166e8: e3530000 cmp r3, #0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 300166ec: 13a00004 movne r0, #4 if ( !count ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 300166f0: 1a00000b bne 30016724 case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 300166f4: e88d0048 stm sp, {r3, r6} 300166f8: e1a01007 mov r1, r7 300166fc: e1a03004 mov r3, r4 30016700: e1a02005 mov r2, r5 30016704: e2800014 add r0, r0, #20 30016708: eb000da1 bl 30019d94 <_CORE_message_queue_Broadcast> 3001670c: e1a04000 mov r4, r0 NULL, #endif count ); _Thread_Enable_dispatch(); 30016710: eb001818 bl 3001c778 <_Thread_Enable_dispatch> return 30016714: e1a00004 mov r0, r4 30016718: eb0000cd bl 30016a54 <_Message_queue_Translate_core_message_queue_return_code> 3001671c: ea000000 b 30016724 if ( !buffer ) return RTEMS_INVALID_ADDRESS; if ( !count ) return RTEMS_INVALID_ADDRESS; 30016720: e3a00009 mov r0, #9 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30016724: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc} =============================================================================== 30011814 : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, rtems_id *id ) { 30011814: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} #if defined(RTEMS_MULTIPROCESSING) bool is_global; size_t max_packet_payload_size; #endif if ( !rtems_is_name_valid( name ) ) 30011818: e2507000 subs r7, r0, #0 uint32_t count, size_t max_message_size, rtems_attribute attribute_set, rtems_id *id ) { 3001181c: e1a06001 mov r6, r1 30011820: e1a05002 mov r5, r2 30011824: e1a0a003 mov sl, r3 30011828: e59d8020 ldr r8, [sp, #32] bool is_global; size_t max_packet_payload_size; #endif if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 3001182c: 03a00003 moveq r0, #3 #if defined(RTEMS_MULTIPROCESSING) bool is_global; size_t max_packet_payload_size; #endif if ( !rtems_is_name_valid( name ) ) 30011830: 0a00002e beq 300118f0 return RTEMS_INVALID_NAME; if ( !id ) 30011834: e3580000 cmp r8, #0 return RTEMS_INVALID_ADDRESS; 30011838: 03a00009 moveq r0, #9 #endif if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 3001183c: 0a00002b beq 300118f0 if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 30011840: e3510000 cmp r1, #0 return RTEMS_INVALID_NUMBER; 30011844: 03a0000a moveq r0, #10 if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 30011848: 0a000028 beq 300118f0 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 3001184c: e3520000 cmp r2, #0 return RTEMS_INVALID_SIZE; 30011850: 03a00008 moveq r0, #8 #endif if ( count == 0 ) return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 30011854: 0a000025 beq 300118f0 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 30011858: e59f3094 ldr r3, [pc, #148] ; 300118f4 3001185c: e5932000 ldr r2, [r3] ++level; 30011860: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 30011864: e5832000 str r2, [r3] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 30011868: eb00155f bl 30016dec <_Message_queue_Allocate> if ( !the_message_queue ) { 3001186c: e2504000 subs r4, r0, #0 30011870: 1a000002 bne 30011880 _Thread_Enable_dispatch(); 30011874: eb000c1f bl 300148f8 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 30011878: e3a00005 mov r0, #5 <== NOT EXECUTED 3001187c: ea00001b b 300118f0 <== 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; 30011880: e31a0004 tst sl, #4 30011884: 03a03000 moveq r3, #0 30011888: 13a03001 movne r3, #1 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_message_queue->attribute_set = attribute_set; 3001188c: e28d1004 add r1, sp, #4 30011890: e5213004 str r3, [r1, #-4]! 30011894: e584a010 str sl, [r4, #16] if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 30011898: e2840014 add r0, r4, #20 3001189c: e1a0100d mov r1, sp 300118a0: e1a02006 mov r2, r6 300118a4: e1a03005 mov r3, r5 300118a8: eb00049a bl 30012b18 <_CORE_message_queue_Initialize> 300118ac: e3500000 cmp r0, #0 300118b0: 1a000005 bne 300118cc */ RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 300118b4: e59f003c ldr r0, [pc, #60] ; 300118f8 <== NOT EXECUTED 300118b8: e1a01004 mov r1, r4 <== NOT EXECUTED 300118bc: eb000835 bl 30013998 <_Objects_Free> <== NOT EXECUTED _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 300118c0: eb000c0c bl 300148f8 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_UNSATISFIED; 300118c4: e3a0000d mov r0, #13 <== NOT EXECUTED 300118c8: ea000008 b 300118f0 <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300118cc: e59f2024 ldr r2, [pc, #36] ; 300118f8 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 300118d0: e5943008 ldr r3, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300118d4: e592201c ldr r2, [r2, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 300118d8: e1d410b8 ldrh r1, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300118dc: e7824101 str r4, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 300118e0: e584700c str r7, [r4, #12] &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 300118e4: e5883000 str r3, [r8] name, 0 ); #endif _Thread_Enable_dispatch(); 300118e8: eb000c02 bl 300148f8 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 300118ec: e3a00000 mov r0, #0 } 300118f0: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} =============================================================================== 300168c4 : rtems_status_code rtems_message_queue_get_number_pending( rtems_id id, uint32_t *count ) { 300168c4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 300168c8: e2514000 subs r4, r1, #0 <== NOT EXECUTED rtems_status_code rtems_message_queue_get_number_pending( rtems_id id, uint32_t *count ) { 300168cc: e1a03000 mov r3, r0 <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) return RTEMS_INVALID_ADDRESS; 300168d0: 03a00009 moveq r0, #9 <== NOT EXECUTED ) { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 300168d4: 0a00000b beq 30016908 <== NOT EXECUTED 300168d8: e59f002c ldr r0, [pc, #44] ; 3001690c <== NOT EXECUTED 300168dc: e1a01003 mov r1, r3 <== NOT EXECUTED 300168e0: e1a0200d mov r2, sp <== NOT EXECUTED 300168e4: eb001420 bl 3001b96c <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 300168e8: e59d5000 ldr r5, [sp] <== NOT EXECUTED 300168ec: e3550000 cmp r5, #0 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 300168f0: 13a00004 movne r0, #4 <== NOT EXECUTED if ( !count ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 300168f4: 1a000003 bne 30016908 <== NOT EXECUTED case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 300168f8: e590305c ldr r3, [r0, #92] ; 0x5c <== NOT EXECUTED 300168fc: e5843000 str r3, [r4] <== NOT EXECUTED _Thread_Enable_dispatch(); 30016900: eb00179c bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30016904: e1a00005 mov r0, r5 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30016908: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 30011930 : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 30011930: e92d4077 push {r0, r1, r2, r4, r5, r6, lr} register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 30011934: e2515000 subs r5, r1, #0 void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 30011938: e1a0c000 mov ip, r0 3001193c: e1a04002 mov r4, r2 30011940: e1a06003 mov r6, r3 register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 30011944: 0a00001a beq 300119b4 return RTEMS_INVALID_ADDRESS; if ( !size ) 30011948: e3520000 cmp r2, #0 3001194c: 0a000018 beq 300119b4 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 30011950: e28d2008 add r2, sp, #8 30011954: e59f0060 ldr r0, [pc, #96] ; 300119bc 30011958: e1a0100c mov r1, ip 3001195c: eb000862 bl 30013aec <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 30011960: e59d2008 ldr r2, [sp, #8] 30011964: e1a03000 mov r3, r0 30011968: e3520000 cmp r2, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3001196c: 13a00004 movne r0, #4 if ( !size ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 30011970: 1a000010 bne 300119b8 if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 30011974: e59d201c ldr r2, [sp, #28] */ RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait ( rtems_option option_set ) { return (option_set & RTEMS_NO_WAIT) ? true : false; 30011978: e2066001 and r6, r6, #1 3001197c: e2266001 eor r6, r6, #1 30011980: e58d2004 str r2, [sp, #4] 30011984: e58d6000 str r6, [sp] 30011988: e2830014 add r0, r3, #20 3001198c: e5931008 ldr r1, [r3, #8] 30011990: e1a02005 mov r2, r5 30011994: e1a03004 mov r3, r4 30011998: eb00048f bl 30012bdc <_CORE_message_queue_Seize> buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 3001199c: eb000bd5 bl 300148f8 <_Thread_Enable_dispatch> return _Message_queue_Translate_core_message_queue_return_code( _Thread_Executing->Wait.return_code 300119a0: e59f3018 ldr r3, [pc, #24] ; 300119c0 300119a4: e5933008 ldr r3, [r3, #8] size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 300119a8: e5930034 ldr r0, [r3, #52] ; 0x34 300119ac: eb000023 bl 30011a40 <_Message_queue_Translate_core_message_queue_return_code> 300119b0: ea000000 b 300119b8 if ( !buffer ) return RTEMS_INVALID_ADDRESS; if ( !size ) return RTEMS_INVALID_ADDRESS; 300119b4: e3a00009 mov r0, #9 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 300119b8: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} =============================================================================== 3000b9cc : int rtems_object_api_maximum_class( int api ) { return _Objects_API_maximum_class(api); 3000b9cc: ea000622 b 3000d25c <_Objects_API_maximum_class> <== NOT EXECUTED =============================================================================== 3000b9d0 : */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 3000b9d0: e2400001 sub r0, r0, #1 <== NOT EXECUTED int api ) { if ( _Objects_Is_api_valid( api ) ) return 1; return -1; 3000b9d4: e3500003 cmp r0, #3 <== NOT EXECUTED } 3000b9d8: 33a00001 movcc r0, #1 <== NOT EXECUTED 3000b9dc: 23e00000 mvncs r0, #0 <== NOT EXECUTED 3000b9e0: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b9e4 : ) { const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 3000b9e4: e3500001 cmp r0, #1 <== NOT EXECUTED const char *rtems_object_get_api_class_name( int the_api, int the_class ) { 3000b9e8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 3000b9ec: 0a000003 beq 3000ba00 <== NOT EXECUTED api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 3000b9f0: e3500002 cmp r0, #2 <== NOT EXECUTED api_assoc = rtems_object_api_classic_assoc; 3000b9f4: 059f002c ldreq r0, [pc, #44] ; 3000ba28 <== NOT EXECUTED const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 3000b9f8: 1a000006 bne 3000ba18 <== NOT EXECUTED 3000b9fc: ea000000 b 3000ba04 <== NOT EXECUTED { const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) api_assoc = rtems_object_api_internal_assoc; 3000ba00: e59f0024 ldr r0, [pc, #36] ; 3000ba2c <== NOT EXECUTED else if ( the_api == OBJECTS_POSIX_API ) api_assoc = rtems_object_api_posix_assoc; #endif else return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); 3000ba04: eb0011b5 bl 300100e0 <== NOT EXECUTED if ( class_assoc ) 3000ba08: e3500000 cmp r0, #0 <== NOT EXECUTED return class_assoc->name; 3000ba0c: 15900000 ldrne r0, [r0] <== NOT EXECUTED api_assoc = rtems_object_api_posix_assoc; #endif else return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); if ( class_assoc ) 3000ba10: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED 3000ba14: ea000001 b 3000ba20 <== NOT EXECUTED #ifdef RTEMS_POSIX_API else if ( the_api == OBJECTS_POSIX_API ) api_assoc = rtems_object_api_posix_assoc; #endif else return "BAD API"; 3000ba18: e59f0010 ldr r0, [pc, #16] ; 3000ba30 <== NOT EXECUTED 3000ba1c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); if ( class_assoc ) return class_assoc->name; return "BAD CLASS"; 3000ba20: e59f000c ldr r0, [pc, #12] ; 3000ba34 <== NOT EXECUTED } 3000ba24: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 3000ba38 : }; const char *rtems_object_get_api_name( int api ) { 3000ba38: e1a01000 mov r1, r0 <== NOT EXECUTED 3000ba3c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); 3000ba40: e59f0010 ldr r0, [pc, #16] ; 3000ba58 <== NOT EXECUTED 3000ba44: eb0011a5 bl 300100e0 <== NOT EXECUTED if ( api_assoc ) 3000ba48: e3500000 cmp r0, #0 <== NOT EXECUTED return api_assoc->name; 3000ba4c: 15900000 ldrne r0, [r0] <== NOT EXECUTED return "BAD CLASS"; 3000ba50: 059f0004 ldreq r0, [pc, #4] ; 3000ba5c <== NOT EXECUTED } 3000ba54: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 3000ba90 : rtems_status_code rtems_object_get_class_information( int the_api, int the_class, rtems_object_api_class_information *info ) { 3000ba90: e92d4010 push {r4, lr} <== NOT EXECUTED int i; /* * Validate parameters and look up information structure. */ if ( !info ) 3000ba94: e2524000 subs r4, r2, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 3000ba98: 03a00009 moveq r0, #9 <== NOT EXECUTED int i; /* * Validate parameters and look up information structure. */ if ( !info ) 3000ba9c: 08bd8010 popeq {r4, pc} <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 3000baa0: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000baa4: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3000baa8: eb0006c1 bl 3000d5b4 <_Objects_Get_information> <== NOT EXECUTED if ( !obj_info ) 3000baac: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bab0: 0a000014 beq 3000bb08 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 3000bab4: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; 3000bab8: e1d011b0 ldrh r1, [r0, #16] <== NOT EXECUTED return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 3000babc: e5843000 str r3, [r4] <== NOT EXECUTED info->maximum_id = obj_info->maximum_id; 3000bac0: e590300c ldr r3, [r0, #12] <== NOT EXECUTED info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 3000bac4: e3a02000 mov r2, #0 <== NOT EXECUTED /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; 3000bac8: e5843004 str r3, [r4, #4] <== NOT EXECUTED info->auto_extend = obj_info->auto_extend; 3000bacc: e5d03012 ldrb r3, [r0, #18] <== NOT EXECUTED info->maximum = obj_info->maximum; 3000bad0: e5841008 str r1, [r4, #8] <== NOT EXECUTED /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; 3000bad4: e5c4300c strb r3, [r4, #12] <== NOT EXECUTED info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 3000bad8: e3a03001 mov r3, #1 <== NOT EXECUTED 3000badc: ea000004 b 3000baf4 <== NOT EXECUTED if ( !obj_info->local_table[i] ) 3000bae0: e590c01c ldr ip, [r0, #28] <== NOT EXECUTED 3000bae4: e79cc103 ldr ip, [ip, r3, lsl #2] <== NOT EXECUTED info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 3000bae8: e2833001 add r3, r3, #1 <== NOT EXECUTED if ( !obj_info->local_table[i] ) 3000baec: e35c0000 cmp ip, #0 <== NOT EXECUTED unallocated++; 3000baf0: 02822001 addeq r2, r2, #1 <== NOT EXECUTED info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 3000baf4: e1530001 cmp r3, r1 <== NOT EXECUTED 3000baf8: 9afffff8 bls 3000bae0 <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 3000bafc: e5842010 str r2, [r4, #16] <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000bb00: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bb04: e8bd8010 pop {r4, pc} <== NOT EXECUTED if ( !info ) return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); if ( !obj_info ) return RTEMS_INVALID_NUMBER; 3000bb08: e3a0000a mov r0, #10 <== NOT EXECUTED unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 3000bb0c: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 30014bf4 : Objects_Id id, size_t length, char *name ) { return _Objects_Get_name_as_string( id, length, name ); 30014bf4: ea000307 b 30015818 <_Objects_Get_name_as_string> <== NOT EXECUTED =============================================================================== 3000bb14 : #undef rtems_object_id_api_maximum int rtems_object_id_api_maximum(void) { return OBJECTS_APIS_LAST; } 3000bb14: e3a00003 mov r0, #3 <== NOT EXECUTED 3000bb18: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000bb1c : #undef rtems_object_id_api_minimum int rtems_object_id_api_minimum(void) { return OBJECTS_INTERNAL_API; } 3000bb1c: e3a00001 mov r0, #1 <== NOT EXECUTED 3000bb20: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000bb24 : */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 3000bb24: e1a00c20 lsr r0, r0, #24 <== NOT EXECUTED int rtems_object_id_get_api( rtems_id id ) { return _Objects_Get_API( id ); } 3000bb28: e2000007 and r0, r0, #7 <== NOT EXECUTED 3000bb2c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000bb30 : int rtems_object_id_get_class( rtems_id id ) { return _Objects_Get_class( id ); } 3000bb30: e1a00da0 lsr r0, r0, #27 <== NOT EXECUTED 3000bb34: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000bb38 : #undef rtems_object_id_get_index int rtems_object_id_get_index( rtems_id id ) { return _Objects_Get_index( id ); 3000bb38: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED } 3000bb3c: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 3000bb40: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000bb44 : * be a single processor system. */ #if defined(RTEMS_USE_16_BIT_OBJECT) return 1; #else return (id >> OBJECTS_NODE_START_BIT) & OBJECTS_NODE_VALID_BITS; 3000bb44: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED int rtems_object_id_get_node( rtems_id id ) { return _Objects_Get_node( id ); } 3000bb48: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 3000bb4c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000bb50 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 3000bb50: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 3000bb54: e2515000 subs r5, r1, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 3000bb58: 03a00009 moveq r0, #9 <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 3000bb5c: 0a000016 beq 3000bbbc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 3000bb60: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bb64: 059f3054 ldreq r3, [pc, #84] ; 3000bbc0 <== NOT EXECUTED 3000bb68: 11a04000 movne r4, r0 <== NOT EXECUTED 3000bb6c: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED 3000bb70: 05934008 ldreq r4, [r3, #8] <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 3000bb74: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bb78: eb000688 bl 3000d5a0 <_Objects_Get_information_id> <== NOT EXECUTED if ( !information ) 3000bb7c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000bb80: 0a00000c beq 3000bbb8 <== NOT EXECUTED return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 3000bb84: e1a01004 mov r1, r4 <== NOT EXECUTED 3000bb88: e1a0200d mov r2, sp <== NOT EXECUTED 3000bb8c: eb0006f3 bl 3000d760 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 3000bb90: e59d4000 ldr r4, [sp] <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); if ( !information ) return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 3000bb94: e1a01000 mov r1, r0 <== NOT EXECUTED switch ( location ) { 3000bb98: e3540000 cmp r4, #0 <== NOT EXECUTED 3000bb9c: 1a000005 bne 3000bbb8 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 3000bba0: e1a02005 mov r2, r5 <== NOT EXECUTED 3000bba4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000bba8: eb00075c bl 3000d920 <_Objects_Set_name> <== NOT EXECUTED _Thread_Enable_dispatch(); 3000bbac: eb000a87 bl 3000e5d0 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000bbb0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bbb4: ea000000 b 3000bbbc <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000bbb8: e3a00004 mov r0, #4 <== NOT EXECUTED } 3000bbbc: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 30016ae0 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 30016ae0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 30016ae4: e2508000 subs r8, r0, #0 uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 30016ae8: e1a05001 mov r5, r1 30016aec: e1a09002 mov r9, r2 30016af0: e1a0a003 mov sl, r3 register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 30016af4: 03a00003 moveq r0, #3 rtems_id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 30016af8: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc} return RTEMS_INVALID_NAME; if ( !starting_address ) 30016afc: e3510000 cmp r1, #0 30016b00: 0a000030 beq 30016bc8 return RTEMS_INVALID_ADDRESS; if ( !id ) 30016b04: e59d2028 ldr r2, [sp, #40] ; 0x28 30016b08: e3520000 cmp r2, #0 30016b0c: 0a00002d beq 30016bc8 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 30016b10: e3590000 cmp r9, #0 30016b14: 13530000 cmpne r3, #0 30016b18: 0a00002c beq 30016bd0 30016b1c: e1590003 cmp r9, r3 30016b20: 3a00002a bcc 30016bd0 30016b24: e3130003 tst r3, #3 30016b28: 1a000028 bne 30016bd0 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 30016b2c: e2116007 ands r6, r1, #7 30016b30: 1a000028 bne 30016bd8 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 30016b34: e59f30a4 ldr r3, [pc, #164] ; 30016be0 30016b38: e5932000 ldr r2, [r3] ++level; 30016b3c: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 30016b40: e5832000 str r2, [r3] * This function allocates a partition control block from * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 30016b44: e59f7098 ldr r7, [pc, #152] ; 30016be4 30016b48: e1a00007 mov r0, r7 30016b4c: eb001254 bl 3001b4a4 <_Objects_Allocate> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 30016b50: e2504000 subs r4, r0, #0 30016b54: 1a000002 bne 30016b64 _Thread_Enable_dispatch(); 30016b58: eb001706 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 30016b5c: e3a00005 mov r0, #5 <== NOT EXECUTED 30016b60: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED #endif the_partition->starting_address = starting_address; the_partition->length = length; the_partition->buffer_size = buffer_size; the_partition->attribute_set = attribute_set; 30016b64: e59d3024 ldr r3, [sp, #36] ; 0x24 the_partition->number_of_used_blocks = 0; _Chain_Initialize( &the_partition->Memory, starting_address, 30016b68: e1a0100a mov r1, sl #endif the_partition->starting_address = starting_address; the_partition->length = length; the_partition->buffer_size = buffer_size; the_partition->attribute_set = attribute_set; 30016b6c: e584301c str r3, [r4, #28] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 30016b70: e5845010 str r5, [r4, #16] the_partition->length = length; 30016b74: e5849014 str r9, [r4, #20] the_partition->buffer_size = buffer_size; 30016b78: e584a018 str sl, [r4, #24] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 30016b7c: e5846020 str r6, [r4, #32] _Chain_Initialize( &the_partition->Memory, starting_address, 30016b80: e1a00009 mov r0, r9 30016b84: eb0051f4 bl 3002b35c <__aeabi_uidiv> 30016b88: e284b024 add fp, r4, #36 ; 0x24 30016b8c: e1a02000 mov r2, r0 30016b90: e1a01005 mov r1, r5 30016b94: e1a0000b mov r0, fp 30016b98: e1a0300a mov r3, sl 30016b9c: eb000c6c bl 30019d54 <_Chain_Initialize> #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30016ba0: e597201c ldr r2, [r7, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 30016ba4: e1d410b8 ldrh r1, [r4, #8] 30016ba8: e5943008 ldr r3, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30016bac: e7824101 str r4, [r2, r1, lsl #2] &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 30016bb0: e59d2028 ldr r2, [sp, #40] ; 0x28 information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 30016bb4: e584800c str r8, [r4, #12] 30016bb8: e5823000 str r3, [r2] name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 30016bbc: eb0016ed bl 3001c778 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30016bc0: e1a00006 mov r0, r6 30016bc4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} if ( !starting_address ) return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; 30016bc8: e3a00009 mov r0, #9 <== NOT EXECUTED 30016bcc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED if ( length == 0 || buffer_size == 0 || length < buffer_size || !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 30016bd0: e3a00008 mov r0, #8 <== NOT EXECUTED 30016bd4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; 30016bd8: e3a00009 mov r0, #9 <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 30016bdc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED =============================================================================== 30016be8 : #include rtems_status_code rtems_partition_delete( rtems_id id ) { 30016be8: e92d4031 push {r0, r4, r5, lr} 30016bec: e1a01000 mov r1, r0 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 30016bf0: e1a0200d mov r2, sp 30016bf4: e59f0050 ldr r0, [pc, #80] ; 30016c4c 30016bf8: eb00135b bl 3001b96c <_Objects_Get> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 30016bfc: e59d3000 ldr r3, [sp] 30016c00: e1a04000 mov r4, r0 30016c04: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30016c08: 13a00004 movne r0, #4 { register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 30016c0c: 1a00000d bne 30016c48 case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 30016c10: e5945020 ldr r5, [r4, #32] 30016c14: e3550000 cmp r5, #0 30016c18: 1a000008 bne 30016c40 _Objects_Close( &_Partition_Information, &the_partition->Object ); 30016c1c: e59f0028 ldr r0, [pc, #40] ; 30016c4c 30016c20: e1a01004 mov r1, r4 30016c24: eb001240 bl 3001b52c <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Partition_Free ( Partition_Control *the_partition ) { _Objects_Free( &_Partition_Information, &the_partition->Object ); 30016c28: e59f001c ldr r0, [pc, #28] ; 30016c4c 30016c2c: e1a01004 mov r1, r4 30016c30: eb0012ea bl 3001b7e0 <_Objects_Free> 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 30016c34: eb0016cf bl 3001c778 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30016c38: e1a00005 mov r0, r5 30016c3c: ea000001 b 30016c48 } _Thread_Enable_dispatch(); 30016c40: eb0016cc bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_RESOURCE_IN_USE; 30016c44: e3a0000c mov r0, #12 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30016c48: e8bd8038 pop {r3, r4, r5, pc} =============================================================================== 30016cf8 : rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) { 30016cf8: e92d4071 push {r0, r4, r5, r6, lr} 30016cfc: e1a03000 mov r3, r0 30016d00: e1a04001 mov r4, r1 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 30016d04: e59f0088 ldr r0, [pc, #136] ; 30016d94 30016d08: e1a01003 mov r1, r3 30016d0c: e1a0200d mov r2, sp 30016d10: eb001315 bl 3001b96c <_Objects_Get> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 30016d14: e59d3000 ldr r3, [sp] 30016d18: e1a05000 mov r5, r0 30016d1c: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30016d20: 13a00004 movne r0, #4 { register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 30016d24: 1a000016 bne 30016d84 ) { void *starting; void *ending; starting = the_partition->starting_address; 30016d28: e5950010 ldr r0, [r5, #16] 30016d2c: e5953014 ldr r3, [r5, #20] 30016d30: e0803003 add r3, r0, r3 const void *address, const void *base, const void *limit ) { return (address >= base && address <= limit); 30016d34: e1540003 cmp r4, r3 30016d38: 83a03000 movhi r3, #0 30016d3c: 93a03001 movls r3, #1 30016d40: e1540000 cmp r4, r0 30016d44: 33a03000 movcc r3, #0 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 30016d48: e3530000 cmp r3, #0 30016d4c: 0a00000d beq 30016d88 offset = (uint32_t) _Addresses_Subtract( the_buffer, the_partition->starting_address ); return ((offset % the_partition->buffer_size) == 0); 30016d50: e0600004 rsb r0, r0, r4 30016d54: e5951018 ldr r1, [r5, #24] 30016d58: eb0051c5 bl 3002b474 <__umodsi3> starting = the_partition->starting_address; ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 30016d5c: e2506000 subs r6, r0, #0 30016d60: 1a000008 bne 30016d88 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 30016d64: e2850024 add r0, r5, #36 ; 0x24 30016d68: e1a01004 mov r1, r4 30016d6c: eb000be0 bl 30019cf4 <_Chain_Append> case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 30016d70: e5953020 ldr r3, [r5, #32] 30016d74: e2433001 sub r3, r3, #1 30016d78: e5853020 str r3, [r5, #32] _Thread_Enable_dispatch(); 30016d7c: eb00167d bl 3001c778 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30016d80: e1a00006 mov r0, r6 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30016d84: e8bd8078 pop {r3, r4, r5, r6, pc} _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 30016d88: eb00167a bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 30016d8c: e3a00009 mov r0, #9 <== NOT EXECUTED 30016d90: eafffffb b 30016d84 <== NOT EXECUTED =============================================================================== 30016154 : void *internal_start, void *external_start, uint32_t length, rtems_id *id ) { 30016154: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) 30016158: e250a000 subs sl, r0, #0 void *internal_start, void *external_start, uint32_t length, rtems_id *id ) { 3001615c: e1a04001 mov r4, r1 30016160: e1a05002 mov r5, r2 30016164: e1a09003 mov r9, r3 30016168: e59d6020 ldr r6, [sp, #32] register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 3001616c: 03a00003 moveq r0, #3 rtems_id *id ) { register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) 30016170: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} return RTEMS_INVALID_NAME; if ( !id ) 30016174: e3560000 cmp r6, #0 return RTEMS_INVALID_ADDRESS; 30016178: 03a00009 moveq r0, #9 register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 3001617c: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} #include #include #include #include rtems_status_code rtems_port_create( 30016180: e1828001 orr r8, r2, r1 return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 30016184: e2188007 ands r8, r8, #7 30016188: 1a000018 bne 300161f0 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3001618c: e59f3064 ldr r3, [pc, #100] ; 300161f8 30016190: e5932000 ldr r2, [r3] ++level; 30016194: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 30016198: e5832000 str r2, [r3] * of free port control blocks. */ RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Allocate ( void ) { return (Dual_ported_memory_Control *) 3001619c: e59f7058 ldr r7, [pc, #88] ; 300161fc 300161a0: e1a00007 mov r0, r7 300161a4: eb0014be bl 3001b4a4 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 300161a8: e3500000 cmp r0, #0 300161ac: 1a000002 bne 300161bc _Thread_Enable_dispatch(); 300161b0: eb001970 bl 3001c778 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 300161b4: e3a00005 mov r0, #5 300161b8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 300161bc: e5903008 ldr r3, [r0, #8] 300161c0: e1d010b8 ldrh r1, [r0, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300161c4: e597201c ldr r2, [r7, #28] } the_port->internal_base = internal_start; the_port->external_base = external_start; the_port->length = length - 1; 300161c8: e2499001 sub r9, r9, #1 if ( !the_port ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 300161cc: e5804010 str r4, [r0, #16] the_port->external_base = external_start; 300161d0: e5805014 str r5, [r0, #20] the_port->length = length - 1; 300161d4: e5809018 str r9, [r0, #24] 300161d8: e7820101 str r0, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 300161dc: e580a00c str sl, [r0, #12] &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 300161e0: e5863000 str r3, [r6] _Thread_Enable_dispatch(); 300161e4: eb001963 bl 3001c778 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 300161e8: e1a00008 mov r0, r8 300161ec: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || !_Addresses_Is_aligned( external_start ) ) return RTEMS_INVALID_ADDRESS; 300161f0: e3a00009 mov r0, #9 <== NOT EXECUTED ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 300161f4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED =============================================================================== 30016d98 : #include rtems_status_code rtems_rate_monotonic_cancel( rtems_id id ) { 30016d98: e92d4031 push {r0, r4, r5, lr} 30016d9c: e1a01000 mov r1, r0 RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get ( Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) 30016da0: e1a0200d mov r2, sp 30016da4: e59f0060 ldr r0, [pc, #96] ; 30016e0c 30016da8: eb0012ef bl 3001b96c <_Objects_Get> Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 30016dac: e59d4000 ldr r4, [sp] 30016db0: e1a05000 mov r5, r0 30016db4: e3540000 cmp r4, #0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30016db8: 13a00004 movne r0, #4 { Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 30016dbc: 1a000011 bne 30016e08 case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 30016dc0: e59f3048 ldr r3, [pc, #72] ; 30016e10 30016dc4: e5952040 ldr r2, [r5, #64] ; 0x40 30016dc8: e5933008 ldr r3, [r3, #8] 30016dcc: e1520003 cmp r2, r3 30016dd0: 0a000002 beq 30016de0 _Thread_Enable_dispatch(); 30016dd4: eb001667 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_NOT_OWNER_OF_RESOURCE; 30016dd8: e3a00017 mov r0, #23 <== NOT EXECUTED 30016ddc: ea000009 b 30016e08 <== NOT EXECUTED } (void) _Watchdog_Remove( &the_period->Timer ); 30016de0: e2850010 add r0, r5, #16 30016de4: eb001a01 bl 3001d5f0 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Scheduler_Release_job( Thread_Control *the_thread, uint32_t length ) { _Scheduler.Operations.release_job(the_thread, length); 30016de8: e5950040 ldr r0, [r5, #64] ; 0x40 30016dec: e1a01004 mov r1, r4 30016df0: e59f301c ldr r3, [pc, #28] ; 30016e14 the_period->state = RATE_MONOTONIC_INACTIVE; 30016df4: e5854038 str r4, [r5, #56] ; 0x38 30016df8: e1a0e00f mov lr, pc 30016dfc: e593f034 ldr pc, [r3, #52] ; 0x34 _Scheduler_Release_job(the_period->owner, 0); _Thread_Enable_dispatch(); 30016e00: eb00165c bl 3001c778 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30016e04: e1a00004 mov r0, r4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30016e08: e8bd8038 pop {r3, r4, r5, pc} =============================================================================== 3000aacc : rtems_status_code rtems_rate_monotonic_create( rtems_name name, rtems_id *id ) { 3000aacc: e92d41f0 push {r4, r5, r6, r7, r8, lr} Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 3000aad0: e2508000 subs r8, r0, #0 rtems_status_code rtems_rate_monotonic_create( rtems_name name, rtems_id *id ) { 3000aad4: e1a06001 mov r6, r1 Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 3000aad8: 03a00003 moveq r0, #3 rtems_id *id ) { Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 3000aadc: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} return RTEMS_INVALID_NAME; if ( !id ) 3000aae0: e3510000 cmp r1, #0 3000aae4: 0a000027 beq 3000ab88 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000aae8: e59f30a0 ldr r3, [pc, #160] ; 3000ab90 3000aaec: e5932000 ldr r2, [r3] ++level; 3000aaf0: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 3000aaf4: e5832000 str r2, [r3] * This function allocates a period control block from * the inactive chain of free period control blocks. */ RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void ) { return (Rate_monotonic_Control *) 3000aaf8: e59f7094 ldr r7, [pc, #148] ; 3000ab94 3000aafc: e1a00007 mov r0, r7 3000ab00: eb0007bc bl 3000c9f8 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 3000ab04: e2504000 subs r4, r0, #0 3000ab08: 1a000002 bne 3000ab18 _Thread_Enable_dispatch(); 3000ab0c: eb000c98 bl 3000dd74 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 3000ab10: e3a00005 mov r0, #5 <== NOT EXECUTED 3000ab14: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED } the_period->owner = _Thread_Executing; 3000ab18: e59f3078 ldr r3, [pc, #120] ; 3000ab98 the_period->state = RATE_MONOTONIC_INACTIVE; 3000ab1c: e3a05000 mov r5, #0 if ( !the_period ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 3000ab20: e5933008 ldr r3, [r3, #8] the_period->state = RATE_MONOTONIC_INACTIVE; _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 3000ab24: e1a01005 mov r1, r5 if ( !the_period ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 3000ab28: e5843040 str r3, [r4, #64] ; 0x40 the_period->state = RATE_MONOTONIC_INACTIVE; _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 3000ab2c: e3a02038 mov r2, #56 ; 0x38 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; the_period->state = RATE_MONOTONIC_INACTIVE; 3000ab30: e5845038 str r5, [r4, #56] ; 0x38 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 3000ab34: e5845018 str r5, [r4, #24] the_watchdog->routine = routine; 3000ab38: e584502c str r5, [r4, #44] ; 0x2c the_watchdog->id = id; 3000ab3c: e5845030 str r5, [r4, #48] ; 0x30 the_watchdog->user_data = user_data; 3000ab40: e5845034 str r5, [r4, #52] ; 0x34 _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 3000ab44: e2840054 add r0, r4, #84 ; 0x54 3000ab48: eb0020dc bl 30012ec0 Timestamp64_Control *_time, Timestamp64_Control _seconds, Timestamp64_Control _nanoseconds ) { *_time = _seconds * 1000000000L + _nanoseconds; 3000ab4c: e59f2048 ldr r2, [pc, #72] ; 3000ab9c 3000ab50: e59f3048 ldr r3, [pc, #72] ; 3000aba0 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 3000ab54: e1d410b8 ldrh r1, [r4, #8] 3000ab58: e584205c str r2, [r4, #92] ; 0x5c 3000ab5c: e5843060 str r3, [r4, #96] ; 0x60 3000ab60: e5842074 str r2, [r4, #116] ; 0x74 3000ab64: e5843078 str r3, [r4, #120] ; 0x78 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000ab68: e597201c ldr r2, [r7, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 3000ab6c: e5943008 ldr r3, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000ab70: e7824101 str r4, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 3000ab74: e584800c str r8, [r4, #12] &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 3000ab78: e5863000 str r3, [r6] _Thread_Enable_dispatch(); 3000ab7c: eb000c7c bl 3000dd74 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000ab80: e1a00005 mov r0, r5 3000ab84: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 3000ab88: e3a00009 mov r0, #9 <== NOT EXECUTED ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 3000ab8c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 300314bc : rtems_status_code rtems_rate_monotonic_get_statistics( rtems_id id, rtems_rate_monotonic_period_statistics *statistics ) { 300314bc: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; rtems_rate_monotonic_period_statistics *dst; Rate_monotonic_Statistics *src; if ( !statistics ) 300314c0: e2514000 subs r4, r1, #0 <== NOT EXECUTED rtems_status_code rtems_rate_monotonic_get_statistics( rtems_id id, rtems_rate_monotonic_period_statistics *statistics ) { 300314c4: e1a03000 mov r3, r0 <== NOT EXECUTED Rate_monotonic_Control *the_period; rtems_rate_monotonic_period_statistics *dst; Rate_monotonic_Statistics *src; if ( !statistics ) return RTEMS_INVALID_ADDRESS; 300314c8: 03a00009 moveq r0, #9 <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; rtems_rate_monotonic_period_statistics *dst; Rate_monotonic_Statistics *src; if ( !statistics ) 300314cc: 0a000062 beq 3003165c <== NOT EXECUTED 300314d0: e59f0188 ldr r0, [pc, #392] ; 30031660 <== NOT EXECUTED 300314d4: e1a01003 mov r1, r3 <== NOT EXECUTED 300314d8: e1a0200d mov r2, sp <== NOT EXECUTED 300314dc: ebff6b58 bl 3000c244 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 300314e0: e59d8000 ldr r8, [sp] <== NOT EXECUTED 300314e4: e1a05000 mov r5, r0 <== NOT EXECUTED 300314e8: e3580000 cmp r8, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 300314ec: 13a00004 movne r0, #4 <== NOT EXECUTED if ( !statistics ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 300314f0: 1a000059 bne 3003165c <== NOT EXECUTED case OBJECTS_LOCAL: dst = statistics; src = &the_period->Statistics; dst->count = src->count; 300314f4: e5953054 ldr r3, [r5, #84] ; 0x54 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 300314f8: e285705c add r7, r5, #92 ; 0x5c <== NOT EXECUTED 300314fc: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED switch ( location ) { case OBJECTS_LOCAL: dst = statistics; src = &the_period->Statistics; dst->count = src->count; 30031500: e5843000 str r3, [r4] <== NOT EXECUTED dst->missed_count = src->missed_count; 30031504: e5953058 ldr r3, [r5, #88] ; 0x58 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 30031508: e1a00006 mov r0, r6 <== NOT EXECUTED 3003150c: e5843004 str r3, [r4, #4] <== NOT EXECUTED 30031510: e1a01007 mov r1, r7 <== NOT EXECUTED 30031514: e59f2148 ldr r2, [pc, #328] ; 30031664 <== NOT EXECUTED 30031518: e3a03000 mov r3, #0 <== NOT EXECUTED 3003151c: eb0075e2 bl 3004ecac <__divdi3> <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031520: e1a01007 mov r1, r7 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 30031524: e5840008 str r0, [r4, #8] <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031528: e59f2134 ldr r2, [pc, #308] ; 30031664 <== NOT EXECUTED 3003152c: e1a00006 mov r0, r6 <== NOT EXECUTED 30031530: e3a03000 mov r3, #0 <== NOT EXECUTED 30031534: eb007717 bl 3004f198 <__moddi3> <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30031538: e2857064 add r7, r5, #100 ; 0x64 <== NOT EXECUTED 3003153c: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED 30031540: e584000c str r0, [r4, #12] <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 30031544: e1a01007 mov r1, r7 <== NOT EXECUTED 30031548: e1a00006 mov r0, r6 <== NOT EXECUTED 3003154c: e59f2110 ldr r2, [pc, #272] ; 30031664 <== NOT EXECUTED 30031550: e3a03000 mov r3, #0 <== NOT EXECUTED 30031554: eb0075d4 bl 3004ecac <__divdi3> <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031558: e1a01007 mov r1, r7 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 3003155c: e5840010 str r0, [r4, #16] <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031560: e59f20fc ldr r2, [pc, #252] ; 30031664 <== NOT EXECUTED 30031564: e1a00006 mov r0, r6 <== NOT EXECUTED 30031568: e3a03000 mov r3, #0 <== NOT EXECUTED 3003156c: eb007709 bl 3004f198 <__moddi3> <== NOT EXECUTED 30031570: e285706c add r7, r5, #108 ; 0x6c <== NOT EXECUTED 30031574: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED 30031578: e5840014 str r0, [r4, #20] <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 3003157c: e1a01007 mov r1, r7 <== NOT EXECUTED 30031580: e1a00006 mov r0, r6 <== NOT EXECUTED 30031584: e59f20d8 ldr r2, [pc, #216] ; 30031664 <== NOT EXECUTED 30031588: e3a03000 mov r3, #0 <== NOT EXECUTED 3003158c: eb0075c6 bl 3004ecac <__divdi3> <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031590: e1a01007 mov r1, r7 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 30031594: e5840018 str r0, [r4, #24] <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031598: e59f20c4 ldr r2, [pc, #196] ; 30031664 <== NOT EXECUTED 3003159c: e1a00006 mov r0, r6 <== NOT EXECUTED 300315a0: e3a03000 mov r3, #0 <== NOT EXECUTED 300315a4: eb0076fb bl 3004f198 <__moddi3> <== NOT EXECUTED 300315a8: e2857074 add r7, r5, #116 ; 0x74 <== NOT EXECUTED 300315ac: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED 300315b0: e584001c str r0, [r4, #28] <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 300315b4: e1a01007 mov r1, r7 <== NOT EXECUTED 300315b8: e1a00006 mov r0, r6 <== NOT EXECUTED 300315bc: e59f20a0 ldr r2, [pc, #160] ; 30031664 <== NOT EXECUTED 300315c0: e3a03000 mov r3, #0 <== NOT EXECUTED 300315c4: eb0075b8 bl 3004ecac <__divdi3> <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 300315c8: e1a01007 mov r1, r7 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 300315cc: e5840020 str r0, [r4, #32] <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 300315d0: e59f208c ldr r2, [pc, #140] ; 30031664 <== NOT EXECUTED 300315d4: e1a00006 mov r0, r6 <== NOT EXECUTED 300315d8: e3a03000 mov r3, #0 <== NOT EXECUTED 300315dc: eb0076ed bl 3004f198 <__moddi3> <== NOT EXECUTED 300315e0: e285707c add r7, r5, #124 ; 0x7c <== NOT EXECUTED 300315e4: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED 300315e8: e5840024 str r0, [r4, #36] ; 0x24 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 300315ec: e1a01007 mov r1, r7 <== NOT EXECUTED 300315f0: e1a00006 mov r0, r6 <== NOT EXECUTED 300315f4: e59f2068 ldr r2, [pc, #104] ; 30031664 <== NOT EXECUTED 300315f8: e3a03000 mov r3, #0 <== NOT EXECUTED 300315fc: eb0075aa bl 3004ecac <__divdi3> <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031600: e1a01007 mov r1, r7 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 30031604: e5840028 str r0, [r4, #40] ; 0x28 <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031608: e59f2054 ldr r2, [pc, #84] ; 30031664 <== NOT EXECUTED 3003160c: e1a00006 mov r0, r6 <== NOT EXECUTED 30031610: e3a03000 mov r3, #0 <== NOT EXECUTED 30031614: eb0076df bl 3004f198 <__moddi3> <== NOT EXECUTED 30031618: e2857084 add r7, r5, #132 ; 0x84 <== NOT EXECUTED 3003161c: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED 30031620: e584002c str r0, [r4, #44] ; 0x2c <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 30031624: e59f2038 ldr r2, [pc, #56] ; 30031664 <== NOT EXECUTED 30031628: e3a03000 mov r3, #0 <== NOT EXECUTED 3003162c: e1a00006 mov r0, r6 <== NOT EXECUTED 30031630: e1a01007 mov r1, r7 <== NOT EXECUTED 30031634: eb00759c bl 3004ecac <__divdi3> <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031638: e59f2024 ldr r2, [pc, #36] ; 30031664 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 3003163c: e5840030 str r0, [r4, #48] ; 0x30 <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031640: e3a03000 mov r3, #0 <== NOT EXECUTED 30031644: e1a00006 mov r0, r6 <== NOT EXECUTED 30031648: e1a01007 mov r1, r7 <== NOT EXECUTED 3003164c: eb0076d1 bl 3004f198 <__moddi3> <== NOT EXECUTED 30031650: e5840034 str r0, [r4, #52] ; 0x34 <== NOT EXECUTED dst->min_wall_time = src->min_wall_time; dst->max_wall_time = src->max_wall_time; dst->total_wall_time = src->total_wall_time; #endif _Thread_Enable_dispatch(); 30031654: ebff6e5b bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30031658: e1a00008 mov r0, r8 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3003165c: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 30031668 : rtems_status_code rtems_rate_monotonic_get_status( rtems_id id, rtems_rate_monotonic_period_status *status ) { 30031668: e92d40d0 push {r4, r6, r7, lr} <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Period_time_t since_last_period; Rate_monotonic_Control *the_period; bool valid_status; if ( !status ) 3003166c: e2514000 subs r4, r1, #0 <== NOT EXECUTED rtems_status_code rtems_rate_monotonic_get_status( rtems_id id, rtems_rate_monotonic_period_status *status ) { 30031670: e1a03000 mov r3, r0 <== NOT EXECUTED 30031674: e24dd014 sub sp, sp, #20 <== NOT EXECUTED Rate_monotonic_Period_time_t since_last_period; Rate_monotonic_Control *the_period; bool valid_status; if ( !status ) return RTEMS_INVALID_ADDRESS; 30031678: 03a00009 moveq r0, #9 <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Period_time_t since_last_period; Rate_monotonic_Control *the_period; bool valid_status; if ( !status ) 3003167c: 0a000038 beq 30031764 <== NOT EXECUTED 30031680: e1a01003 mov r1, r3 <== NOT EXECUTED 30031684: e28d2010 add r2, sp, #16 <== NOT EXECUTED 30031688: e59f00dc ldr r0, [pc, #220] ; 3003176c <== NOT EXECUTED 3003168c: ebff6aec bl 3000c244 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 30031690: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 30031694: e1a03000 mov r3, r0 <== NOT EXECUTED 30031698: e3520000 cmp r2, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3003169c: 13a00004 movne r0, #4 <== NOT EXECUTED if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 300316a0: 1a00002f bne 30031764 <== NOT EXECUTED case OBJECTS_LOCAL: status->owner = the_period->owner->Object.id; 300316a4: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED status->state = the_period->state; 300316a8: e5933038 ldr r3, [r3, #56] ; 0x38 <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status->owner = the_period->owner->Object.id; 300316ac: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED status->state = the_period->state; /* * If the period is inactive, there is no information. */ if ( status->state == RATE_MONOTONIC_INACTIVE ) { 300316b0: e3530000 cmp r3, #0 <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status->owner = the_period->owner->Object.id; 300316b4: e5842000 str r2, [r4] <== NOT EXECUTED status->state = the_period->state; 300316b8: e5843004 str r3, [r4, #4] <== NOT EXECUTED /* * If the period is inactive, there is no information. */ if ( status->state == RATE_MONOTONIC_INACTIVE ) { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timespec_Set_to_zero( &status->since_last_period ); 300316bc: 05843008 streq r3, [r4, #8] <== NOT EXECUTED 300316c0: 0584300c streq r3, [r4, #12] <== NOT EXECUTED _Timespec_Set_to_zero( &status->executed_since_last_period ); 300316c4: 05843010 streq r3, [r4, #16] <== NOT EXECUTED 300316c8: 05843014 streq r3, [r4, #20] <== NOT EXECUTED 300316cc: 0a000022 beq 3003175c <== NOT EXECUTED } else { /* * Grab the current status. */ valid_status = 300316d0: e28d1008 add r1, sp, #8 <== NOT EXECUTED 300316d4: e1a0200d mov r2, sp <== NOT EXECUTED 300316d8: eb000025 bl 30031774 <_Rate_monotonic_Get_status> <== NOT EXECUTED _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) { 300316dc: e3500000 cmp r0, #0 <== NOT EXECUTED 300316e0: 1a000002 bne 300316f0 <== NOT EXECUTED _Thread_Enable_dispatch(); 300316e4: ebff6e37 bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_NOT_DEFINED; 300316e8: e3a0000b mov r0, #11 <== NOT EXECUTED 300316ec: ea00001c b 30031764 <== NOT EXECUTED } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_To_timespec( 300316f0: e28d7008 add r7, sp, #8 <== NOT EXECUTED 300316f4: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 300316f8: e59f2070 ldr r2, [pc, #112] ; 30031770 <== NOT EXECUTED 300316fc: e1a00006 mov r0, r6 <== NOT EXECUTED 30031700: e1a01007 mov r1, r7 <== NOT EXECUTED 30031704: e3a03000 mov r3, #0 <== NOT EXECUTED 30031708: eb007567 bl 3004ecac <__divdi3> <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 3003170c: e1a01007 mov r1, r7 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 30031710: e5840008 str r0, [r4, #8] <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031714: e59f2054 ldr r2, [pc, #84] ; 30031770 <== NOT EXECUTED 30031718: e1a00006 mov r0, r6 <== NOT EXECUTED 3003171c: e3a03000 mov r3, #0 <== NOT EXECUTED 30031720: eb00769c bl 3004f198 <__moddi3> <== NOT EXECUTED &since_last_period, &status->since_last_period ); _Timestamp_To_timespec( 30031724: e89d00c0 ldm sp, {r6, r7} <== NOT EXECUTED 30031728: e584000c str r0, [r4, #12] <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 3003172c: e59f203c ldr r2, [pc, #60] ; 30031770 <== NOT EXECUTED 30031730: e3a03000 mov r3, #0 <== NOT EXECUTED 30031734: e1a00006 mov r0, r6 <== NOT EXECUTED 30031738: e1a01007 mov r1, r7 <== NOT EXECUTED 3003173c: eb00755a bl 3004ecac <__divdi3> <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031740: e1a01007 mov r1, r7 <== NOT EXECUTED static inline void _Timestamp64_implementation_To_timespec( const Timestamp64_Control *_timestamp, struct timespec *_timespec ) { _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L); 30031744: e5840010 str r0, [r4, #16] <== NOT EXECUTED _timespec->tv_nsec = (long) (*_timestamp % 1000000000L); 30031748: e59f2020 ldr r2, [pc, #32] ; 30031770 <== NOT EXECUTED 3003174c: e1a00006 mov r0, r6 <== NOT EXECUTED 30031750: e3a03000 mov r3, #0 <== NOT EXECUTED 30031754: eb00768f bl 3004f198 <__moddi3> <== NOT EXECUTED 30031758: e5840014 str r0, [r4, #20] <== NOT EXECUTED status->since_last_period = since_last_period; status->executed_since_last_period = executed; #endif } _Thread_Enable_dispatch(); 3003175c: ebff6e19 bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30031760: e3a00000 mov r0, #0 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30031764: e28dd014 add sp, sp, #20 <== NOT EXECUTED 30031768: e8bd80d0 pop {r4, r6, r7, pc} <== NOT EXECUTED =============================================================================== 30031974 : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 30031974: e92d40f1 push {r0, r4, r5, r6, r7, lr} 30031978: e1a05000 mov r5, r0 3003197c: e1a04001 mov r4, r1 30031980: e59f0180 ldr r0, [pc, #384] ; 30031b08 30031984: e1a01005 mov r1, r5 30031988: e1a0200d mov r2, sp 3003198c: ebff6a2c bl 3000c244 <_Objects_Get> rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 30031990: e59d3000 ldr r3, [sp] 30031994: e1a06000 mov r6, r0 30031998: e3530000 cmp r3, #0 3003199c: 1a000056 bne 30031afc case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 300319a0: e59f3164 ldr r3, [pc, #356] ; 30031b0c 300319a4: e5902040 ldr r2, [r0, #64] ; 0x40 300319a8: e5933008 ldr r3, [r3, #8] 300319ac: e1520003 cmp r2, r3 300319b0: 0a000002 beq 300319c0 _Thread_Enable_dispatch(); 300319b4: ebff6d83 bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_NOT_OWNER_OF_RESOURCE; 300319b8: e3a04017 mov r4, #23 <== NOT EXECUTED 300319bc: ea00004f b 30031b00 <== NOT EXECUTED } if ( length == RTEMS_PERIOD_STATUS ) { 300319c0: e3540000 cmp r4, #0 300319c4: 1a000005 bne 300319e0 switch ( the_period->state ) { 300319c8: e5903038 ldr r3, [r0, #56] ; 0x38 300319cc: e3530004 cmp r3, #4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 300319d0: 959f2138 ldrls r2, [pc, #312] ; 30031b10 300319d4: 97d24003 ldrbls r4, [r2, r3] case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 300319d8: ebff6d7a bl 3000cfc8 <_Thread_Enable_dispatch> return( return_value ); 300319dc: ea000047 b 30031b00 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 300319e0: e10f7000 mrs r7, CPSR 300319e4: e3873080 orr r3, r7, #128 ; 0x80 300319e8: e129f003 msr CPSR_fc, r3 } _ISR_Disable( level ); if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 300319ec: e5903038 ldr r3, [r0, #56] ; 0x38 300319f0: e3530000 cmp r3, #0 300319f4: 1a000011 bne 30031a40 static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 300319f8: e129f007 msr CPSR_fc, r7 _ISR_Enable( level ); the_period->next_length = length; 300319fc: e580403c str r4, [r0, #60] ; 0x3c /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 30031a00: ebffffb9 bl 300318ec <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 30031a04: e3a03002 mov r3, #2 30031a08: e5863038 str r3, [r6, #56] ; 0x38 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 30031a0c: e59f3100 ldr r3, [pc, #256] ; 30031b14 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 30031a10: e3a07000 mov r7, #0 the_watchdog->routine = routine; 30031a14: e586302c str r3, [r6, #44] ; 0x2c Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 30031a18: e586401c str r4, [r6, #28] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 30031a1c: e59f00f4 ldr r0, [pc, #244] ; 30031b18 30031a20: e2861010 add r1, r6, #16 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 30031a24: e5867018 str r7, [r6, #24] the_watchdog->routine = routine; the_watchdog->id = id; 30031a28: e5865030 str r5, [r6, #48] ; 0x30 the_watchdog->user_data = user_data; 30031a2c: e5867034 str r7, [r6, #52] ; 0x34 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 30031a30: ebff7041 bl 3000db3c <_Watchdog_Insert> NULL ); _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 30031a34: e1a04007 mov r4, r7 id, NULL ); _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 30031a38: ebff6d62 bl 3000cfc8 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30031a3c: ea00002f b 30031b00 } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 30031a40: e3530002 cmp r3, #2 30031a44: 1a000019 bne 30031ab0 /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 30031a48: ebffff70 bl 30031810 <_Rate_monotonic_Update_statistics> /* * 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; 30031a4c: e3a03001 mov r3, #1 30031a50: e5863038 str r3, [r6, #56] ; 0x38 the_period->next_length = length; 30031a54: e586403c str r4, [r6, #60] ; 0x3c 30031a58: e129f007 msr CPSR_fc, r7 _ISR_Enable( level ); _Thread_Executing->Wait.id = the_period->Object.id; 30031a5c: e59f30a8 ldr r3, [pc, #168] ; 30031b0c _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 30031a60: e3a01901 mov r1, #16384 ; 0x4000 the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING; the_period->next_length = length; _ISR_Enable( level ); _Thread_Executing->Wait.id = the_period->Object.id; 30031a64: e5930008 ldr r0, [r3, #8] 30031a68: e5963008 ldr r3, [r6, #8] 30031a6c: e5803020 str r3, [r0, #32] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 30031a70: ebff6f5a bl 3000d7e0 <_Thread_Set_state> uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 30031a74: e10f2000 mrs r2, CPSR 30031a78: e3823080 orr r3, r2, #128 ; 0x80 30031a7c: e129f003 msr CPSR_fc, r3 * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); local_state = the_period->state; the_period->state = RATE_MONOTONIC_ACTIVE; 30031a80: e3a01002 mov r1, #2 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); local_state = the_period->state; 30031a84: e5963038 ldr r3, [r6, #56] ; 0x38 the_period->state = RATE_MONOTONIC_ACTIVE; 30031a88: e5861038 str r1, [r6, #56] ; 0x38 static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 30031a8c: e129f002 msr CPSR_fc, r2 /* * 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 ) 30031a90: e3530003 cmp r3, #3 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 30031a94: 059f3070 ldreq r3, [pc, #112] ; 30031b0c 30031a98: 03a01901 moveq r1, #16384 ; 0x4000 30031a9c: 05930008 ldreq r0, [r3, #8] 30031aa0: 0bff6c6d bleq 3000cc5c <_Thread_Clear_state> _Thread_Enable_dispatch(); 30031aa4: ebff6d47 bl 3000cfc8 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30031aa8: e3a04000 mov r4, #0 <== NOT EXECUTED 30031aac: ea000013 b 30031b00 <== NOT EXECUTED } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 30031ab0: e3530004 cmp r3, #4 <== NOT EXECUTED 30031ab4: 1a000010 bne 30031afc <== NOT EXECUTED /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 30031ab8: ebffff54 bl 30031810 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED 30031abc: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 30031ac0: e3a03002 mov r3, #2 <== NOT EXECUTED 30031ac4: e5863038 str r3, [r6, #56] ; 0x38 <== NOT EXECUTED the_period->next_length = length; 30031ac8: e586403c str r4, [r6, #60] ; 0x3c <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 30031acc: e586401c str r4, [r6, #28] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 30031ad0: e59f0040 ldr r0, [pc, #64] ; 30031b18 <== NOT EXECUTED 30031ad4: e2861010 add r1, r6, #16 <== NOT EXECUTED 30031ad8: ebff7017 bl 3000db3c <_Watchdog_Insert> <== NOT EXECUTED 30031adc: e5960040 ldr r0, [r6, #64] ; 0x40 <== NOT EXECUTED 30031ae0: e596103c ldr r1, [r6, #60] ; 0x3c <== NOT EXECUTED 30031ae4: e59f3030 ldr r3, [pc, #48] ; 30031b1c <== NOT EXECUTED 30031ae8: e1a0e00f mov lr, pc <== NOT EXECUTED 30031aec: e593f034 ldr pc, [r3, #52] ; 0x34 <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Scheduler_Release_job(the_period->owner, the_period->next_length); _Thread_Enable_dispatch(); return RTEMS_TIMEOUT; 30031af0: e3a04006 mov r4, #6 <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); _Scheduler_Release_job(the_period->owner, the_period->next_length); _Thread_Enable_dispatch(); 30031af4: ebff6d33 bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TIMEOUT; 30031af8: ea000000 b 30031b00 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30031afc: e3a04004 mov r4, #4 <== NOT EXECUTED } 30031b00: e1a00004 mov r0, r4 30031b04: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} =============================================================================== 30025fa8 : void rtems_rate_monotonic_report_statistics( void ) { rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin ); 30025fa8: e59f1004 ldr r1, [pc, #4] ; 30025fb4 <== NOT EXECUTED 30025fac: e3a00000 mov r0, #0 <== NOT EXECUTED 30025fb0: eaffff7f b 30025db4 <== NOT EXECUTED =============================================================================== 30025db4 : void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 30025db4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 30025db8: e2514000 subs r4, r1, #0 <== NOT EXECUTED void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 30025dbc: e24dd070 sub sp, sp, #112 ; 0x70 <== NOT EXECUTED 30025dc0: e1a05000 mov r5, r0 <== NOT EXECUTED rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 30025dc4: 0a00006b beq 30025f78 <== NOT EXECUTED return; (*print)( context, "Period information by period\n" ); 30025dc8: e59f11b0 ldr r1, [pc, #432] ; 30025f80 <== NOT EXECUTED 30025dcc: e1a0e00f mov lr, pc <== NOT EXECUTED 30025dd0: e12fff14 bx r4 <== NOT EXECUTED #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 30025dd4: e59f11a8 ldr r1, [pc, #424] ; 30025f84 <== NOT EXECUTED 30025dd8: e1a00005 mov r0, r5 <== NOT EXECUTED 30025ddc: e1a0e00f mov lr, pc <== NOT EXECUTED 30025de0: e12fff14 bx r4 <== NOT EXECUTED (*print)( context, "--- Wall times are in seconds ---\n" ); 30025de4: e59f119c ldr r1, [pc, #412] ; 30025f88 <== NOT EXECUTED 30025de8: e1a00005 mov r0, r5 <== NOT EXECUTED 30025dec: e1a0e00f mov lr, pc <== NOT EXECUTED 30025df0: e12fff14 bx r4 <== NOT EXECUTED /* * 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 ; 30025df4: e59f7190 ldr r7, [pc, #400] ; 30025f8c <== NOT EXECUTED Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 30025df8: e59f1190 ldr r1, [pc, #400] ; 30025f90 <== NOT EXECUTED 30025dfc: e1a00005 mov r0, r5 <== NOT EXECUTED 30025e00: e1a0e00f mov lr, pc <== NOT EXECUTED 30025e04: e12fff14 bx r4 <== NOT EXECUTED #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 30025e08: e1a00005 mov r0, r5 <== NOT EXECUTED 30025e0c: e59f1180 ldr r1, [pc, #384] ; 30025f94 <== NOT EXECUTED 30025e10: e1a0e00f mov lr, pc <== NOT EXECUTED 30025e14: e12fff14 bx r4 <== NOT EXECUTED { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ struct timespec cpu_average; struct timespec *min_cpu = &the_stats.min_cpu_time; struct timespec *max_cpu = &the_stats.max_cpu_time; struct timespec *total_cpu = &the_stats.total_cpu_time; 30025e18: e28d8028 add r8, sp, #40 ; 0x28 <== NOT EXECUTED /* * 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 ; 30025e1c: e5976008 ldr r6, [r7, #8] <== NOT EXECUTED 30025e20: ea000051 b 30025f6c <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 30025e24: e1a00006 mov r0, r6 <== NOT EXECUTED 30025e28: e28d1010 add r1, sp, #16 <== NOT EXECUTED 30025e2c: eb002da2 bl 300314bc <== NOT EXECUTED if ( status != RTEMS_SUCCESSFUL ) 30025e30: e3500000 cmp r0, #0 <== NOT EXECUTED 30025e34: 1a00004b bne 30025f68 <== NOT EXECUTED #if defined(RTEMS_DEBUG) status = rtems_rate_monotonic_get_status( id, &the_status ); if ( status != RTEMS_SUCCESSFUL ) continue; #else (void) rtems_rate_monotonic_get_status( id, &the_status ); 30025e38: e28d1048 add r1, sp, #72 ; 0x48 <== NOT EXECUTED 30025e3c: e1a00006 mov r0, r6 <== NOT EXECUTED 30025e40: eb002e08 bl 30031668 <== NOT EXECUTED #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 30025e44: e3a01005 mov r1, #5 <== NOT EXECUTED 30025e48: e28d2068 add r2, sp, #104 ; 0x68 <== NOT EXECUTED 30025e4c: e59d0048 ldr r0, [sp, #72] ; 0x48 <== NOT EXECUTED 30025e50: ebffadde bl 300115d0 <== NOT EXECUTED /* * Print part of report line that is not dependent on granularity */ (*print)( context, 30025e54: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30025e58: e59f1138 ldr r1, [pc, #312] ; 30025f98 <== NOT EXECUTED 30025e5c: e58d3000 str r3, [sp] <== NOT EXECUTED 30025e60: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 30025e64: e1a00005 mov r0, r5 <== NOT EXECUTED 30025e68: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 30025e6c: e1a02006 mov r2, r6 <== NOT EXECUTED 30025e70: e28d3068 add r3, sp, #104 ; 0x68 <== NOT EXECUTED 30025e74: e1a0e00f mov lr, pc <== NOT EXECUTED 30025e78: e12fff14 bx r4 <== NOT EXECUTED ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 30025e7c: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 30025e80: e3510000 cmp r1, #0 <== NOT EXECUTED 30025e84: 1a000004 bne 30025e9c <== NOT EXECUTED (*print)( context, "\n" ); 30025e88: e1a00005 mov r0, r5 <== NOT EXECUTED 30025e8c: e59f1108 ldr r1, [pc, #264] ; 30025f9c <== NOT EXECUTED 30025e90: e1a0e00f mov lr, pc <== NOT EXECUTED 30025e94: e12fff14 bx r4 <== NOT EXECUTED continue; 30025e98: ea000032 b 30025f68 <== NOT EXECUTED struct timespec cpu_average; struct timespec *min_cpu = &the_stats.min_cpu_time; struct timespec *max_cpu = &the_stats.max_cpu_time; struct timespec *total_cpu = &the_stats.total_cpu_time; _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 30025e9c: e28d2060 add r2, sp, #96 ; 0x60 <== NOT EXECUTED 30025ea0: e1a00008 mov r0, r8 <== NOT EXECUTED 30025ea4: eb000270 bl 3002686c <_Timespec_Divide_by_integer> <== NOT EXECUTED (*print)( context, 30025ea8: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED 30025eac: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025eb0: eb009ffa bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025eb4: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 30025eb8: e1a0a000 mov sl, r0 <== NOT EXECUTED 30025ebc: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025ec0: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 30025ec4: e58d3000 str r3, [sp] <== NOT EXECUTED 30025ec8: eb009ff4 bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025ecc: e59d3060 ldr r3, [sp, #96] ; 0x60 <== NOT EXECUTED 30025ed0: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 30025ed4: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025ed8: e59d0064 ldr r0, [sp, #100] ; 0x64 <== NOT EXECUTED 30025edc: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 30025ee0: eb009fee bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025ee4: e1a0300a mov r3, sl <== NOT EXECUTED 30025ee8: e58d000c str r0, [sp, #12] <== NOT EXECUTED 30025eec: e59f10ac ldr r1, [pc, #172] ; 30025fa0 <== NOT EXECUTED 30025ef0: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 30025ef4: e1a00005 mov r0, r5 <== NOT EXECUTED 30025ef8: e1a0e00f mov lr, pc <== NOT EXECUTED 30025efc: e12fff14 bx r4 <== NOT EXECUTED struct timespec wall_average; struct timespec *min_wall = &the_stats.min_wall_time; struct timespec *max_wall = &the_stats.max_wall_time; struct timespec *total_wall = &the_stats.total_wall_time; _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 30025f00: e28d2060 add r2, sp, #96 ; 0x60 <== NOT EXECUTED 30025f04: e28d0040 add r0, sp, #64 ; 0x40 <== NOT EXECUTED 30025f08: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 30025f0c: eb000256 bl 3002686c <_Timespec_Divide_by_integer> <== NOT EXECUTED (*print)( context, 30025f10: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025f14: e59d0034 ldr r0, [sp, #52] ; 0x34 <== NOT EXECUTED 30025f18: eb009fe0 bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025f1c: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED 30025f20: e1a0a000 mov sl, r0 <== NOT EXECUTED 30025f24: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025f28: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED 30025f2c: e58d3000 str r3, [sp] <== NOT EXECUTED 30025f30: eb009fda bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025f34: e59d3060 ldr r3, [sp, #96] ; 0x60 <== NOT EXECUTED 30025f38: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 30025f3c: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025f40: e59d0064 ldr r0, [sp, #100] ; 0x64 <== NOT EXECUTED 30025f44: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 30025f48: eb009fd4 bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025f4c: e59f1050 ldr r1, [pc, #80] ; 30025fa4 <== NOT EXECUTED 30025f50: e58d000c str r0, [sp, #12] <== NOT EXECUTED 30025f54: e59d2030 ldr r2, [sp, #48] ; 0x30 <== NOT EXECUTED 30025f58: e1a00005 mov r0, r5 <== NOT EXECUTED 30025f5c: e1a0300a mov r3, sl <== NOT EXECUTED 30025f60: e1a0e00f mov lr, pc <== NOT EXECUTED 30025f64: e12fff14 bx r4 <== NOT EXECUTED * 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++ ) { 30025f68: e2866001 add r6, r6, #1 <== NOT EXECUTED /* * 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 ; 30025f6c: e597300c ldr r3, [r7, #12] <== NOT EXECUTED 30025f70: e1560003 cmp r6, r3 <== NOT EXECUTED 30025f74: 9affffaa bls 30025e24 <== NOT EXECUTED the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 30025f78: e28dd070 add sp, sp, #112 ; 0x70 <== NOT EXECUTED 30025f7c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED =============================================================================== 30025fb8 : * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 30025fb8: e59f3038 ldr r3, [pc, #56] ; 30025ff8 <== NOT EXECUTED /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 30025fbc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 30025fc0: e5932000 ldr r2, [r3] <== NOT EXECUTED ++level; 30025fc4: e2822001 add r2, r2, #1 <== NOT EXECUTED _Thread_Dispatch_disable_level = level; 30025fc8: e5832000 str r2, [r3] <== NOT EXECUTED /* * 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 ; 30025fcc: e59f5028 ldr r5, [pc, #40] ; 30025ffc <== NOT EXECUTED 30025fd0: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED 30025fd4: ea000002 b 30025fe4 <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { (void) rtems_rate_monotonic_reset_statistics( id ); 30025fd8: e1a00004 mov r0, r4 <== NOT EXECUTED 30025fdc: eb000007 bl 30026000 <== NOT EXECUTED * 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 ; id++ ) { 30025fe0: e2844001 add r4, r4, #1 <== NOT EXECUTED /* * 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 ; 30025fe4: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 30025fe8: e1540003 cmp r4, r3 <== NOT EXECUTED 30025fec: 9afffff9 bls 30025fd8 <== NOT EXECUTED /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 30025ff0: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 30025ff4: eaff9bf3 b 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED =============================================================================== 30026000 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( rtems_id id ) { 30026000: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED 30026004: e1a01000 mov r1, r0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get ( Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) 30026008: e1a0200d mov r2, sp <== NOT EXECUTED 3002600c: e59f0048 ldr r0, [pc, #72] ; 3002605c <== NOT EXECUTED 30026010: ebff988b bl 3000c244 <_Objects_Get> <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 30026014: e59d4000 ldr r4, [sp] <== NOT EXECUTED 30026018: e1a05000 mov r5, r0 <== NOT EXECUTED 3002601c: e3540000 cmp r4, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30026020: 13a00004 movne r0, #4 <== NOT EXECUTED { Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 30026024: 1a00000b bne 30026058 <== NOT EXECUTED case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 30026028: e1a01004 mov r1, r4 <== NOT EXECUTED 3002602c: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 30026030: e2850054 add r0, r5, #84 ; 0x54 <== NOT EXECUTED 30026034: eb0048c2 bl 30038344 <== NOT EXECUTED 30026038: e59f2020 ldr r2, [pc, #32] ; 30026060 <== NOT EXECUTED 3002603c: e59f3020 ldr r3, [pc, #32] ; 30026064 <== NOT EXECUTED 30026040: e585205c str r2, [r5, #92] ; 0x5c <== NOT EXECUTED 30026044: e5853060 str r3, [r5, #96] ; 0x60 <== NOT EXECUTED 30026048: e5852074 str r2, [r5, #116] ; 0x74 <== NOT EXECUTED 3002604c: e5853078 str r3, [r5, #120] ; 0x78 <== NOT EXECUTED _Thread_Enable_dispatch(); 30026050: ebff9bdc bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30026054: e1a00004 mov r0, r4 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30026058: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 3000b29c : return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { 3000b29c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED void *ptr = NULL; rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment; 3000b2a0: e5906030 ldr r6, [r0, #48] ; 0x30 <== NOT EXECUTED return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { 3000b2a4: e1a05001 mov r5, r1 <== NOT EXECUTED 3000b2a8: e1a04000 mov r4, r0 <== NOT EXECUTED #include static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 3000b2ac: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b2b0: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b2b4: eb003f17 bl 3001af18 <__umodsi3> <== NOT EXECUTED if (excess > 0) { 3000b2b8: e3500000 cmp r0, #0 <== NOT EXECUTED value += alignment - excess; 3000b2bc: 10856006 addne r6, r5, r6 <== NOT EXECUTED 3000b2c0: 10606006 rsbne r6, r0, r6 <== NOT EXECUTED static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; if (excess > 0) { 3000b2c4: 01a06005 moveq r6, r5 <== NOT EXECUTED rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment; uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { 3000b2c8: e1550006 cmp r5, r6 <== NOT EXECUTED 3000b2cc: 83a00000 movhi r0, #0 <== NOT EXECUTED 3000b2d0: 93a00001 movls r0, #1 <== NOT EXECUTED 3000b2d4: e3550000 cmp r5, #0 <== NOT EXECUTED 3000b2d8: 03a00000 moveq r0, #0 <== NOT EXECUTED 3000b2dc: e3500000 cmp r0, #0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next; 3000b2e0: 11a02004 movne r2, r4 <== NOT EXECUTED 3000b2e4: 14923004 ldrne r3, [r2], #4 <== NOT EXECUTED size_t size ) { rtems_chain_node *current = rtems_chain_first(free_chain); const rtems_chain_node *tail = rtems_chain_tail(free_chain); rtems_rbheap_chunk *big_enough = NULL; 3000b2e8: 13a07000 movne r7, #0 <== NOT EXECUTED rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment; uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { 3000b2ec: 1a000005 bne 3000b308 <== NOT EXECUTED 3000b2f0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED rtems_rbheap_chunk *big_enough = NULL; while (current != tail && big_enough == NULL) { rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current; if (free_chunk->size >= size) { 3000b2f4: e593701c ldr r7, [r3, #28] <== NOT EXECUTED 3000b2f8: e1570006 cmp r7, r6 <== NOT EXECUTED 3000b2fc: 21a07003 movcs r7, r3 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next( Chain_Node *the_node ) { return the_node->next; 3000b300: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000b304: 33a07000 movcc r7, #0 <== NOT EXECUTED { rtems_chain_node *current = rtems_chain_first(free_chain); const rtems_chain_node *tail = rtems_chain_tail(free_chain); rtems_rbheap_chunk *big_enough = NULL; while (current != tail && big_enough == NULL) { 3000b308: e2778001 rsbs r8, r7, #1 <== NOT EXECUTED 3000b30c: 33a08000 movcc r8, #0 <== NOT EXECUTED 3000b310: e1530002 cmp r3, r2 <== NOT EXECUTED 3000b314: 03a08000 moveq r8, #0 <== NOT EXECUTED 3000b318: e3580000 cmp r8, #0 <== NOT EXECUTED 3000b31c: 1afffff4 bne 3000b2f4 <== NOT EXECUTED uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size); if (free_chunk != NULL) { 3000b320: e3570000 cmp r7, #0 <== NOT EXECUTED return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { void *ptr = NULL; 3000b324: 01a00007 moveq r0, r7 <== NOT EXECUTED uintptr_t aligned_size = align_up(alignment, size); if (size > 0 && size <= aligned_size) { rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size); if (free_chunk != NULL) { 3000b328: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED uintptr_t free_size = free_chunk->size; 3000b32c: e597901c ldr r9, [r7, #28] <== NOT EXECUTED if (free_size > aligned_size) { 3000b330: e1590006 cmp r9, r6 <== NOT EXECUTED 3000b334: 9a00001f bls 3000b3b8 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3000b338: e1a0a004 mov sl, r4 <== NOT EXECUTED 3000b33c: e5ba500c ldr r5, [sl, #12]! <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 3000b340: e2843010 add r3, r4, #16 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 3000b344: e1550003 cmp r5, r3 <== NOT EXECUTED Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 3000b348: 15953000 ldrne r3, [r5] <== NOT EXECUTED head->next = new_first; 3000b34c: 1584300c strne r3, [r4, #12] <== NOT EXECUTED new_first->previous = head; 3000b350: 1583a004 strne sl, [r3, #4] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 3000b354: 1a000009 bne 3000b380 <== NOT EXECUTED { rtems_chain_control *chain = &control->spare_descriptor_chain; rtems_chain_node *chunk = rtems_chain_get_unprotected(chain); if (chunk == NULL) { (*control->extend_descriptors)(control); 3000b358: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b35c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b360: e594f034 ldr pc, [r4, #52] ; 0x34 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3000b364: e594300c ldr r3, [r4, #12] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 3000b368: e1530005 cmp r3, r5 <== NOT EXECUTED 3000b36c: 0a000018 beq 3000b3d4 <== NOT EXECUTED Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 3000b370: e5932000 ldr r2, [r3] <== NOT EXECUTED head->next = new_first; new_first->previous = head; 3000b374: e1a05003 mov r5, r3 <== NOT EXECUTED { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; head->next = new_first; 3000b378: e584200c str r2, [r4, #12] <== NOT EXECUTED new_first->previous = head; 3000b37c: e582a004 str sl, [r2, #4] <== NOT EXECUTED if (new_chunk != NULL) { uintptr_t new_free_size = free_size - aligned_size; free_chunk->size = new_free_size; new_chunk->begin = free_chunk->begin + new_free_size; 3000b380: e5973018 ldr r3, [r7, #24] <== NOT EXECUTED if (free_size > aligned_size) { rtems_rbheap_chunk *new_chunk = get_chunk(control); if (new_chunk != NULL) { uintptr_t new_free_size = free_size - aligned_size; 3000b384: e0669009 rsb r9, r6, r9 <== NOT EXECUTED free_chunk->size = new_free_size; 3000b388: e587901c str r9, [r7, #28] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain( Chain_Node *node ) { node->next = node->previous = NULL; 3000b38c: e1a01005 mov r1, r5 <== NOT EXECUTED new_chunk->begin = free_chunk->begin + new_free_size; 3000b390: e0899003 add r9, r9, r3 <== NOT EXECUTED 3000b394: e3a03000 mov r3, #0 <== NOT EXECUTED 3000b398: e5859018 str r9, [r5, #24] <== NOT EXECUTED new_chunk->size = aligned_size; 3000b39c: e585601c str r6, [r5, #28] <== NOT EXECUTED 3000b3a0: e5853004 str r3, [r5, #4] <== NOT EXECUTED 3000b3a4: e4813008 str r3, [r1], #8 <== NOT EXECUTED static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 3000b3a8: e2840018 add r0, r4, #24 <== NOT EXECUTED 3000b3ac: eb000648 bl 3000ccd4 <_RBTree_Insert_unprotected> <== NOT EXECUTED free_chunk->size = new_free_size; new_chunk->begin = free_chunk->begin + new_free_size; new_chunk->size = aligned_size; rtems_chain_set_off_chain(&new_chunk->chain_node); insert_into_tree(chunk_tree, new_chunk); ptr = (void *) new_chunk->begin; 3000b3b0: e5950018 ldr r0, [r5, #24] <== NOT EXECUTED 3000b3b4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 3000b3b8: e897000c ldm r7, {r2, r3} <== NOT EXECUTED } } else { rtems_chain_extract_unprotected(&free_chunk->chain_node); rtems_chain_set_off_chain(&free_chunk->chain_node); ptr = (void *) free_chunk->begin; 3000b3bc: e5970018 ldr r0, [r7, #24] <== NOT EXECUTED next->previous = previous; 3000b3c0: e5823004 str r3, [r2, #4] <== NOT EXECUTED previous->next = next; 3000b3c4: e5832000 str r2, [r3] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain( Chain_Node *node ) { node->next = node->previous = NULL; 3000b3c8: e5878004 str r8, [r7, #4] <== NOT EXECUTED 3000b3cc: e5878000 str r8, [r7] <== NOT EXECUTED 3000b3d0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) { void *ptr = NULL; 3000b3d4: e1a00008 mov r0, r8 <== NOT EXECUTED } } } return ptr; } 3000b3d8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED =============================================================================== 3000b55c : void rtems_rbheap_extend_descriptors_never(rtems_rbheap_control *control) { /* Do nothing */ } 3000b55c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b560 : void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control) { 3000b560: e92d4010 push {r4, lr} <== NOT EXECUTED 3000b564: e1a04000 mov r4, r0 <== NOT EXECUTED rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk)); 3000b568: e3a00020 mov r0, #32 <== NOT EXECUTED 3000b56c: ebffeea1 bl 30006ff8 <== NOT EXECUTED if (chunk != NULL) { 3000b570: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b574: 08bd8010 popeq {r4, pc} <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert_unprotected(_Chain_Head(the_chain), the_node); 3000b578: e284300c add r3, r4, #12 <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 3000b57c: e5803004 str r3, [r0, #4] <== NOT EXECUTED before_node = after_node->next; 3000b580: e594300c ldr r3, [r4, #12] <== NOT EXECUTED after_node->next = the_node; 3000b584: e584000c str r0, [r4, #12] <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 3000b588: e5830004 str r0, [r3, #4] <== 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; 3000b58c: e5803000 str r3, [r0] <== NOT EXECUTED 3000b590: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000b3dc : _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { 3000b3dc: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED rtems_status_code sc = RTEMS_SUCCESSFUL; if (ptr != NULL) { 3000b3e0: e2516000 subs r6, r1, #0 <== NOT EXECUTED _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { 3000b3e4: e24dd020 sub sp, sp, #32 <== NOT EXECUTED 3000b3e8: e1a05000 mov r5, r0 <== NOT EXECUTED rtems_status_code sc = RTEMS_SUCCESSFUL; if (ptr != NULL) { 3000b3ec: 0a000057 beq 3000b550 <== NOT EXECUTED #define NULL_PAGE rtems_rbheap_chunk_of_node(NULL) static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key) { rtems_rbheap_chunk chunk = { .begin = key }; 3000b3f0: e1a0000d mov r0, sp <== NOT EXECUTED 3000b3f4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b3f8: e3a02020 mov r2, #32 <== NOT EXECUTED RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; 3000b3fc: e3a04000 mov r4, #0 <== NOT EXECUTED 3000b400: eb001cfd bl 300127fc <== NOT EXECUTED return rtems_rbheap_chunk_of_node( 3000b404: e08d3004 add r3, sp, r4 <== NOT EXECUTED #define NULL_PAGE rtems_rbheap_chunk_of_node(NULL) static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key) { rtems_rbheap_chunk chunk = { .begin = key }; 3000b408: e58d6018 str r6, [sp, #24] <== NOT EXECUTED return rtems_rbheap_chunk_of_node( 3000b40c: e2837008 add r7, r3, #8 <== NOT EXECUTED RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Node* iter_node = the_rbtree->root; 3000b410: e595601c ldr r6, [r5, #28] <== NOT EXECUTED 3000b414: ea00000d b 3000b450 <== NOT EXECUTED RBTree_Node* found = NULL; int compare_result; while (iter_node) { compare_result = the_rbtree->compare_function(the_node, iter_node); 3000b418: e1a00007 mov r0, r7 <== NOT EXECUTED 3000b41c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b420: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b424: e595f028 ldr pc, [r5, #40] ; 0x28 <== NOT EXECUTED if ( _RBTree_Is_equal( compare_result ) ) { 3000b428: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b42c: 1a000003 bne 3000b440 <== NOT EXECUTED found = iter_node; if ( the_rbtree->is_unique ) 3000b430: e5d5302c ldrb r3, [r5, #44] ; 0x2c <== NOT EXECUTED 3000b434: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b438: 1a000007 bne 3000b45c <== NOT EXECUTED 3000b43c: e1a04006 mov r4, r6 <== NOT EXECUTED break; } RBTree_Direction dir = (RBTree_Direction) _RBTree_Is_greater( compare_result ); iter_node = iter_node->child[dir]; 3000b440: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b444: c3a00008 movgt r0, #8 <== NOT EXECUTED 3000b448: d3a00004 movle r0, #4 <== NOT EXECUTED 3000b44c: e7906006 ldr r6, [r0, r6] <== NOT EXECUTED ) { RBTree_Node* iter_node = the_rbtree->root; RBTree_Node* found = NULL; int compare_result; while (iter_node) { 3000b450: e3560000 cmp r6, #0 <== NOT EXECUTED 3000b454: 1affffef bne 3000b418 <== NOT EXECUTED 3000b458: e1a06004 mov r6, r4 <== NOT EXECUTED 3000b45c: e2464008 sub r4, r6, #8 <== NOT EXECUTED if (ptr != NULL) { rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr); if (chunk != NULL_PAGE) { 3000b460: e3740008 cmn r4, #8 <== NOT EXECUTED check_and_merge(free_chain, chunk_tree, chunk, pred); } else { sc = RTEMS_INCORRECT_STATE; } } else { sc = RTEMS_INVALID_ID; 3000b464: 03a06004 moveq r6, #4 <== NOT EXECUTED if (ptr != NULL) { rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr); if (chunk != NULL_PAGE) { 3000b468: 0a000038 beq 3000b550 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 3000b46c: e5163008 ldr r3, [r6, #-8] <== NOT EXECUTED 3000b470: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b474: 13a0a000 movne sl, #0 <== NOT EXECUTED 3000b478: 1a000002 bne 3000b488 <== NOT EXECUTED add_to_chain(free_chain, b); _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) 3000b47c: e594a004 ldr sl, [r4, #4] <== NOT EXECUTED 3000b480: e27aa001 rsbs sl, sl, #1 <== NOT EXECUTED 3000b484: 33a0a000 movcc sl, #0 <== NOT EXECUTED rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr); if (chunk != NULL_PAGE) { if (!rtems_rbheap_is_chunk_free(chunk)) { 3000b488: e23aa001 eors sl, sl, #1 <== NOT EXECUTED check_and_merge(free_chain, chunk_tree, chunk, succ); add_to_chain(free_chain, chunk); check_and_merge(free_chain, chunk_tree, chunk, pred); } else { sc = RTEMS_INCORRECT_STATE; 3000b48c: 13a0600e movne r6, #14 <== NOT EXECUTED rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr); if (chunk != NULL_PAGE) { if (!rtems_rbheap_is_chunk_free(chunk)) { 3000b490: 1a00002e bne 3000b550 <== NOT EXECUTED static rtems_rbheap_chunk *get_next( const rtems_rbheap_chunk *chunk, RBTree_Direction dir ) { return rtems_rbheap_chunk_of_node( 3000b494: e2849008 add r9, r4, #8 <== NOT EXECUTED 3000b498: e1a0100a mov r1, sl <== NOT EXECUTED 3000b49c: e1a00009 mov r0, r9 <== NOT EXECUTED 3000b4a0: eb000690 bl 3000cee8 <_RBTree_Next_unprotected> <== NOT EXECUTED 3000b4a4: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b4a8: e1a06000 mov r6, r0 <== NOT EXECUTED 3000b4ac: e2408008 sub r8, r0, #8 <== NOT EXECUTED 3000b4b0: e1a00009 mov r0, r9 <== NOT EXECUTED 3000b4b4: eb00068b bl 3000cee8 <_RBTree_Next_unprotected> <== NOT EXECUTED 3000b4b8: e2403008 sub r3, r0, #8 <== NOT EXECUTED rtems_rbtree_control *chunk_tree, rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { 3000b4bc: e3730008 cmn r3, #8 <== NOT EXECUTED { rtems_status_code sc = RTEMS_SUCCESSFUL; if (ptr != NULL) { rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; 3000b4c0: e2857018 add r7, r5, #24 <== NOT EXECUTED rtems_rbtree_control *chunk_tree, rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { 3000b4c4: 0a00000a beq 3000b4f4 <== NOT EXECUTED 3000b4c8: e5102008 ldr r2, [r0, #-8] <== NOT EXECUTED 3000b4cc: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b4d0: 1a000002 bne 3000b4e0 <== NOT EXECUTED add_to_chain(free_chain, b); _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) 3000b4d4: e510a004 ldr sl, [r0, #-4] <== NOT EXECUTED 3000b4d8: e27aa001 rsbs sl, sl, #1 <== NOT EXECUTED 3000b4dc: 33a0a000 movcc sl, #0 <== NOT EXECUTED rtems_rbtree_control *chunk_tree, rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { 3000b4e0: e35a0000 cmp sl, #0 <== NOT EXECUTED 3000b4e4: 01a00005 moveq r0, r5 <== NOT EXECUTED 3000b4e8: 01a01007 moveq r1, r7 <== NOT EXECUTED 3000b4ec: 01a02004 moveq r2, r4 <== NOT EXECUTED 3000b4f0: 0bffff08 bleq 3000b118 <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 3000b4f4: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000b4f8: e3780008 cmn r8, #8 <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 3000b4fc: e5845004 str r5, [r4, #4] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; 3000b500: e5854000 str r4, [r5] <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 3000b504: e5834004 str r4, [r3, #4] <== 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; 3000b508: e5843000 str r3, [r4] <== NOT EXECUTED 3000b50c: 0a00000e beq 3000b54c <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL); 3000b510: e5163008 ldr r3, [r6, #-8] <== NOT EXECUTED 3000b514: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b518: 13a06000 movne r6, #0 <== NOT EXECUTED 3000b51c: 1a000002 bne 3000b52c <== NOT EXECUTED add_to_chain(free_chain, b); _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) 3000b520: e5166004 ldr r6, [r6, #-4] <== NOT EXECUTED 3000b524: e2766001 rsbs r6, r6, #1 <== NOT EXECUTED 3000b528: 33a06000 movcc r6, #0 <== NOT EXECUTED rtems_rbtree_control *chunk_tree, rtems_rbheap_chunk *a, rtems_rbheap_chunk *b ) { if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) { 3000b52c: e21660ff ands r6, r6, #255 ; 0xff <== NOT EXECUTED 3000b530: 1a000005 bne 3000b54c <== NOT EXECUTED 3000b534: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b538: e1a01007 mov r1, r7 <== NOT EXECUTED 3000b53c: e1a02004 mov r2, r4 <== NOT EXECUTED 3000b540: e1a03008 mov r3, r8 <== NOT EXECUTED 3000b544: ebfffef3 bl 3000b118 <== NOT EXECUTED 3000b548: ea000000 b 3000b550 <== NOT EXECUTED } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) { rtems_status_code sc = RTEMS_SUCCESSFUL; 3000b54c: e3a06000 mov r6, #0 <== NOT EXECUTED sc = RTEMS_INVALID_ID; } } return sc; } 3000b550: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b554: e28dd020 add sp, sp, #32 <== NOT EXECUTED 3000b558: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED =============================================================================== 3000b178 : uintptr_t area_size, uintptr_t alignment, rtems_rbheap_extend_descriptors extend_descriptors, void *handler_arg ) { 3000b178: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED rtems_status_code sc = RTEMS_SUCCESSFUL; if (alignment > 0) { 3000b17c: e2538000 subs r8, r3, #0 <== NOT EXECUTED uintptr_t area_size, uintptr_t alignment, rtems_rbheap_extend_descriptors extend_descriptors, void *handler_arg ) { 3000b180: e1a04000 mov r4, r0 <== NOT EXECUTED 3000b184: e1a05001 mov r5, r1 <== NOT EXECUTED 3000b188: e59d6024 ldr r6, [sp, #36] ; 0x24 <== NOT EXECUTED } } else { sc = RTEMS_INVALID_ADDRESS; } } else { sc = RTEMS_INVALID_NUMBER; 3000b18c: 03a0000a moveq r0, #10 <== NOT EXECUTED void *handler_arg ) { rtems_status_code sc = RTEMS_SUCCESSFUL; if (alignment > 0) { 3000b190: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED uintptr_t begin = (uintptr_t) area_begin; uintptr_t end = begin + area_size; 3000b194: e081a002 add sl, r1, r2 <== NOT EXECUTED #include static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 3000b198: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b19c: e1a01008 mov r1, r8 <== NOT EXECUTED 3000b1a0: eb003f5c bl 3001af18 <__umodsi3> <== NOT EXECUTED if (excess > 0) { 3000b1a4: e3500000 cmp r0, #0 <== NOT EXECUTED value += alignment - excess; 3000b1a8: 10857008 addne r7, r5, r8 <== NOT EXECUTED 3000b1ac: 10607007 rsbne r7, r0, r7 <== NOT EXECUTED static uintptr_t align_up(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; if (excess > 0) { 3000b1b0: 01a07005 moveq r7, r5 <== NOT EXECUTED uintptr_t begin = (uintptr_t) area_begin; uintptr_t end = begin + area_size; uintptr_t aligned_begin = align_up(alignment, begin); uintptr_t aligned_end = align_down(alignment, end); if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) { 3000b1b4: e1550007 cmp r5, r7 <== NOT EXECUTED 3000b1b8: 9155000a cmpls r5, sl <== NOT EXECUTED 3000b1bc: 2a000031 bcs 3000b288 <== NOT EXECUTED return value; } static uintptr_t align_down(uintptr_t alignment, uintptr_t value) { uintptr_t excess = value % alignment; 3000b1c0: e1a0000a mov r0, sl <== NOT EXECUTED 3000b1c4: e1a01008 mov r1, r8 <== NOT EXECUTED 3000b1c8: eb003f52 bl 3001af18 <__umodsi3> <== NOT EXECUTED return value - excess; 3000b1cc: e060a00a rsb sl, r0, sl <== NOT EXECUTED uintptr_t begin = (uintptr_t) area_begin; uintptr_t end = begin + area_size; uintptr_t aligned_begin = align_up(alignment, begin); uintptr_t aligned_end = align_down(alignment, end); if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) { 3000b1d0: e157000a cmp r7, sl <== NOT EXECUTED 3000b1d4: 2a00002b bcs 3000b288 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 3000b1d8: e2843004 add r3, r4, #4 <== NOT EXECUTED head->next = tail; 3000b1dc: e5843000 str r3, [r4] <== NOT EXECUTED { the_rbtree->permanent_null = NULL; the_rbtree->root = NULL; the_rbtree->first[0] = NULL; the_rbtree->first[1] = NULL; the_rbtree->compare_function = compare_function; 3000b1e0: e59f30b0 ldr r3, [pc, #176] ; 3000b298 <== NOT EXECUTED head->previous = NULL; 3000b1e4: e3a05000 mov r5, #0 <== NOT EXECUTED 3000b1e8: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED the_rbtree->is_unique = is_unique; 3000b1ec: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b1f0: e5c4302c strb r3, [r4, #44] ; 0x2c <== NOT EXECUTED rtems_chain_initialize_empty(free_chain); rtems_chain_initialize_empty(&control->spare_descriptor_chain); rtems_rbtree_initialize_empty(chunk_tree, chunk_compare, true); control->alignment = alignment; control->handler_arg = handler_arg; 3000b1f4: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 3000b1f8: e284b010 add fp, r4, #16 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 3000b1fc: e284900c add r9, r4, #12 <== NOT EXECUTED Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; head->previous = NULL; 3000b200: e5845004 str r5, [r4, #4] <== NOT EXECUTED tail->previous = head; 3000b204: e5844008 str r4, [r4, #8] <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 3000b208: e584b00c str fp, [r4, #12] <== NOT EXECUTED head->previous = NULL; 3000b20c: e5845010 str r5, [r4, #16] <== NOT EXECUTED tail->previous = head; 3000b210: e5849014 str r9, [r4, #20] <== NOT EXECUTED RBTree_Control *the_rbtree, RBTree_Compare_function compare_function, bool is_unique ) { the_rbtree->permanent_null = NULL; 3000b214: e5845018 str r5, [r4, #24] <== NOT EXECUTED the_rbtree->root = NULL; 3000b218: e584501c str r5, [r4, #28] <== NOT EXECUTED the_rbtree->first[0] = NULL; 3000b21c: e5845020 str r5, [r4, #32] <== NOT EXECUTED the_rbtree->first[1] = NULL; 3000b220: e5845024 str r5, [r4, #36] ; 0x24 <== NOT EXECUTED rtems_rbheap_chunk *first = NULL; rtems_chain_initialize_empty(free_chain); rtems_chain_initialize_empty(&control->spare_descriptor_chain); rtems_rbtree_initialize_empty(chunk_tree, chunk_compare, true); control->alignment = alignment; 3000b224: e5848030 str r8, [r4, #48] ; 0x30 <== NOT EXECUTED control->handler_arg = handler_arg; 3000b228: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED control->extend_descriptors = extend_descriptors; 3000b22c: e5846034 str r6, [r4, #52] ; 0x34 <== NOT EXECUTED { rtems_chain_control *chain = &control->spare_descriptor_chain; rtems_chain_node *chunk = rtems_chain_get_unprotected(chain); if (chunk == NULL) { (*control->extend_descriptors)(control); 3000b230: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b234: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b238: e12fff16 bx r6 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first( const Chain_Control *the_chain ) { return _Chain_Immutable_head( the_chain )->next; 3000b23c: e594100c ldr r1, [r4, #12] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 3000b240: e151000b cmp r1, fp <== NOT EXECUTED 3000b244: 0a000011 beq 3000b290 <== NOT EXECUTED Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 3000b248: e5913000 ldr r3, [r1] <== NOT EXECUTED { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; 3000b24c: e1a00004 mov r0, r4 <== NOT EXECUTED { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; head->next = new_first; 3000b250: e584300c str r3, [r4, #12] <== NOT EXECUTED new_first->previous = head; 3000b254: e5839004 str r9, [r3, #4] <== NOT EXECUTED ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 3000b258: e5943000 ldr r3, [r4] <== NOT EXECUTED control->extend_descriptors = extend_descriptors; first = get_chunk(control); if (first != NULL) { first->begin = aligned_begin; first->size = aligned_end - aligned_begin; 3000b25c: e067a00a rsb sl, r7, sl <== NOT EXECUTED control->handler_arg = handler_arg; control->extend_descriptors = extend_descriptors; first = get_chunk(control); if (first != NULL) { first->begin = aligned_begin; 3000b260: e5817018 str r7, [r1, #24] <== NOT EXECUTED first->size = aligned_end - aligned_begin; 3000b264: e581a01c str sl, [r1, #28] <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 3000b268: e5814004 str r4, [r1, #4] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; 3000b26c: e4801018 str r1, [r0], #24 <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 3000b270: e5831004 str r1, [r3, #4] <== 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; 3000b274: e5813000 str r3, [r1] <== NOT EXECUTED static void insert_into_tree( rtems_rbtree_control *tree, rtems_rbheap_chunk *chunk ) { _RBTree_Insert_unprotected(tree, &chunk->tree_node); 3000b278: e2811008 add r1, r1, #8 <== NOT EXECUTED 3000b27c: eb000694 bl 3000ccd4 <_RBTree_Insert_unprotected> <== NOT EXECUTED uintptr_t alignment, rtems_rbheap_extend_descriptors extend_descriptors, void *handler_arg ) { rtems_status_code sc = RTEMS_SUCCESSFUL; 3000b280: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b284: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED insert_into_tree(chunk_tree, first); } else { sc = RTEMS_NO_MEMORY; } } else { sc = RTEMS_INVALID_ADDRESS; 3000b288: e3a00009 mov r0, #9 <== NOT EXECUTED 3000b28c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED first->begin = aligned_begin; first->size = aligned_end - aligned_begin; add_to_chain(free_chain, first); insert_into_tree(chunk_tree, first); } else { sc = RTEMS_NO_MEMORY; 3000b290: e3a0001a mov r0, #26 <== NOT EXECUTED } else { sc = RTEMS_INVALID_NUMBER; } return sc; } 3000b294: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED =============================================================================== 300176a4 : uintptr_t length, uintptr_t page_size, rtems_attribute attribute_set, rtems_id *id ) { 300176a4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 300176a8: e2509000 subs r9, r0, #0 uintptr_t length, uintptr_t page_size, rtems_attribute attribute_set, rtems_id *id ) { 300176ac: e1a06001 mov r6, r1 300176b0: e1a07002 mov r7, r2 300176b4: e1a08003 mov r8, r3 300176b8: e59da024 ldr sl, [sp, #36] ; 0x24 300176bc: e59db028 ldr fp, [sp, #40] ; 0x28 rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 300176c0: 03a06003 moveq r6, #3 ) { rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 300176c4: 0a000031 beq 30017790 return RTEMS_INVALID_NAME; if ( !starting_address ) 300176c8: e3560000 cmp r6, #0 300176cc: 0a00002e beq 3001778c return RTEMS_INVALID_ADDRESS; if ( !id ) 300176d0: e35b0000 cmp fp, #0 300176d4: 0a00002c beq 3001778c return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 300176d8: e59f30b8 ldr r3, [pc, #184] ; 30017798 * This function allocates a region control block from * the inactive chain of free region control blocks. */ RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void ) { return (Region_Control *) _Objects_Allocate( &_Region_Information ); 300176dc: e59f50b8 ldr r5, [pc, #184] ; 3001779c 300176e0: e5930000 ldr r0, [r3] 300176e4: eb00095c bl 30019c5c <_API_Mutex_Lock> 300176e8: e1a00005 mov r0, r5 300176ec: eb000f6c bl 3001b4a4 <_Objects_Allocate> the_region = _Region_Allocate(); if ( !the_region ) 300176f0: e2504000 subs r4, r0, #0 return_status = RTEMS_TOO_MANY; 300176f4: 03a06005 moveq r6, #5 _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Allocate(); if ( !the_region ) 300176f8: 0a00001f beq 3001777c return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 300176fc: e2840068 add r0, r4, #104 ; 0x68 30017700: e1a01006 mov r1, r6 30017704: e1a02007 mov r2, r7 30017708: e1a03008 mov r3, r8 3001770c: eb000e40 bl 3001b014 <_Heap_Initialize> &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 30017710: e3500000 cmp r0, #0 if ( !the_region ) return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 30017714: e584005c str r0, [r4, #92] ; 0x5c &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 30017718: 1a000004 bne 30017730 */ RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 3001771c: e1a00005 mov r0, r5 <== NOT EXECUTED 30017720: e1a01004 mov r1, r4 <== NOT EXECUTED 30017724: eb00102d bl 3001b7e0 <_Objects_Free> <== NOT EXECUTED _Region_Free( the_region ); return_status = RTEMS_INVALID_SIZE; 30017728: e3a06008 mov r6, #8 <== NOT EXECUTED 3001772c: ea000012 b 3001777c <== NOT EXECUTED } else { the_region->starting_address = starting_address; 30017730: e5846050 str r6, [r4, #80] ; 0x50 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( 30017734: e31a0004 tst sl, #4 the_region->starting_address = starting_address; the_region->length = length; the_region->page_size = page_size; the_region->attribute_set = attribute_set; the_region->number_of_used_blocks = 0; 30017738: e3a06000 mov r6, #0 _Thread_queue_Initialize( 3001773c: 03a01000 moveq r1, #0 30017740: 13a01001 movne r1, #1 30017744: e3a02040 mov r2, #64 ; 0x40 30017748: e3a03006 mov r3, #6 } else { the_region->starting_address = starting_address; the_region->length = length; 3001774c: e5847054 str r7, [r4, #84] ; 0x54 the_region->page_size = page_size; 30017750: e5848058 str r8, [r4, #88] ; 0x58 the_region->attribute_set = attribute_set; 30017754: e584a060 str sl, [r4, #96] ; 0x60 the_region->number_of_used_blocks = 0; 30017758: e5846064 str r6, [r4, #100] ; 0x64 _Thread_queue_Initialize( 3001775c: e2840010 add r0, r4, #16 30017760: eb0015c6 bl 3001ce80 <_Thread_queue_Initialize> #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30017764: e595201c ldr r2, [r5, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 30017768: e5943008 ldr r3, [r4, #8] 3001776c: e1d410b8 ldrh r1, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30017770: e7824101 str r4, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 30017774: e584900c str r9, [r4, #12] &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 30017778: e58b3000 str r3, [fp] return_status = RTEMS_SUCCESSFUL; } } _RTEMS_Unlock_allocator(); 3001777c: e59f3014 ldr r3, [pc, #20] ; 30017798 30017780: e5930000 ldr r0, [r3] 30017784: eb00094d bl 30019cc0 <_API_Mutex_Unlock> return return_status; 30017788: ea000000 b 30017790 if ( !starting_address ) return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; 3001778c: e3a06009 mov r6, #9 <== NOT EXECUTED } } _RTEMS_Unlock_allocator(); return return_status; } 30017790: e1a00006 mov r0, r6 30017794: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} =============================================================================== 30017818 : rtems_status_code rtems_region_extend( rtems_id id, void *starting_address, uintptr_t length ) { 30017818: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED uintptr_t amount_extended; Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; if ( !starting_address ) 3001781c: e2517000 subs r7, r1, #0 <== NOT EXECUTED rtems_status_code rtems_region_extend( rtems_id id, void *starting_address, uintptr_t length ) { 30017820: e1a04000 mov r4, r0 <== NOT EXECUTED 30017824: e1a06002 mov r6, r2 <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 30017828: 03a05009 moveq r5, #9 <== NOT EXECUTED uintptr_t amount_extended; Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; if ( !starting_address ) 3001782c: 0a00001c beq 300178a4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 30017830: e59f3074 ldr r3, [pc, #116] ; 300178ac <== NOT EXECUTED 30017834: e5930000 ldr r0, [r3] <== NOT EXECUTED 30017838: eb000907 bl 30019c5c <_API_Mutex_Lock> <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 3001783c: e1a01004 mov r1, r4 <== NOT EXECUTED 30017840: e59f0068 ldr r0, [pc, #104] ; 300178b0 <== NOT EXECUTED 30017844: e1a0200d mov r2, sp <== NOT EXECUTED 30017848: eb001039 bl 3001b934 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 3001784c: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30017850: e1a04000 mov r4, r0 <== NOT EXECUTED 30017854: e3550000 cmp r5, #0 <== NOT EXECUTED break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 30017858: 13a05004 movne r5, #4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 3001785c: 1a00000d bne 30017898 <== NOT EXECUTED case OBJECTS_LOCAL: amount_extended = _Heap_Extend( 30017860: e1a03005 mov r3, r5 <== NOT EXECUTED 30017864: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017868: e1a01007 mov r1, r7 <== NOT EXECUTED 3001786c: e1a02006 mov r2, r6 <== NOT EXECUTED 30017870: eb000c16 bl 3001a8d0 <_Heap_Extend> <== NOT EXECUTED starting_address, length, 0 ); if ( amount_extended > 0 ) { 30017874: e3500000 cmp r0, #0 <== NOT EXECUTED the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; } else { return_status = RTEMS_INVALID_ADDRESS; 30017878: 03a05009 moveq r5, #9 <== NOT EXECUTED starting_address, length, 0 ); if ( amount_extended > 0 ) { 3001787c: 0a000005 beq 30017898 <== NOT EXECUTED the_region->length += amount_extended; 30017880: e5943054 ldr r3, [r4, #84] ; 0x54 <== NOT EXECUTED 30017884: e0833000 add r3, r3, r0 <== NOT EXECUTED 30017888: e5843054 str r3, [r4, #84] ; 0x54 <== NOT EXECUTED the_region->maximum_segment_size += amount_extended; 3001788c: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED 30017890: e0830000 add r0, r3, r0 <== NOT EXECUTED 30017894: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30017898: e59f300c ldr r3, [pc, #12] ; 300178ac <== NOT EXECUTED 3001789c: e5930000 ldr r0, [r3] <== NOT EXECUTED 300178a0: eb000906 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 300178a4: e1a00005 mov r0, r5 <== NOT EXECUTED 300178a8: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 300178b4 : rtems_status_code rtems_region_get_free_information( rtems_id id, Heap_Information_block *the_info ) { 300178b4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) 300178b8: e2514000 subs r4, r1, #0 <== NOT EXECUTED rtems_status_code rtems_region_get_free_information( rtems_id id, Heap_Information_block *the_info ) { 300178bc: e1a05000 mov r5, r0 <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) return RTEMS_INVALID_ADDRESS; 300178c0: 03a05009 moveq r5, #9 <== NOT EXECUTED { Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) 300178c4: 0a000013 beq 30017918 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 300178c8: e59f3050 ldr r3, [pc, #80] ; 30017920 <== NOT EXECUTED 300178cc: e5930000 ldr r0, [r3] <== NOT EXECUTED 300178d0: eb0008e1 bl 30019c5c <_API_Mutex_Lock> <== NOT EXECUTED 300178d4: e1a01005 mov r1, r5 <== NOT EXECUTED 300178d8: e59f0044 ldr r0, [pc, #68] ; 30017924 <== NOT EXECUTED 300178dc: e1a0200d mov r2, sp <== NOT EXECUTED 300178e0: eb001013 bl 3001b934 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 300178e4: e59d5000 ldr r5, [sp] <== NOT EXECUTED 300178e8: e3550000 cmp r5, #0 <== NOT EXECUTED break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 300178ec: 13a05004 movne r5, #4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 300178f0: 1a000005 bne 3001790c <== NOT EXECUTED case OBJECTS_LOCAL: the_info->Used.number = 0; 300178f4: e584500c str r5, [r4, #12] <== NOT EXECUTED the_info->Used.total = 0; 300178f8: e5845014 str r5, [r4, #20] <== NOT EXECUTED the_info->Used.largest = 0; 300178fc: e5845010 str r5, [r4, #16] <== NOT EXECUTED _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); 30017900: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017904: e1a01004 mov r1, r4 <== NOT EXECUTED 30017908: eb000d19 bl 3001ad74 <_Heap_Get_free_information> <== NOT EXECUTED default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 3001790c: e59f300c ldr r3, [pc, #12] ; 30017920 <== NOT EXECUTED 30017910: e5930000 ldr r0, [r3] <== NOT EXECUTED 30017914: eb0008e9 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 30017918: e1a00005 mov r0, r5 <== NOT EXECUTED 3001791c: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 30017928 : rtems_status_code rtems_region_get_information( rtems_id id, Heap_Information_block *the_info ) { 30017928: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) 3001792c: e2515000 subs r5, r1, #0 <== NOT EXECUTED rtems_status_code rtems_region_get_information( rtems_id id, Heap_Information_block *the_info ) { 30017930: e1a06000 mov r6, r0 <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) return RTEMS_INVALID_ADDRESS; 30017934: 03a06009 moveq r6, #9 <== NOT EXECUTED { Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) 30017938: 0a00000e beq 30017978 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 3001793c: e59f403c ldr r4, [pc, #60] ; 30017980 <== NOT EXECUTED 30017940: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017944: eb0008c4 bl 30019c5c <_API_Mutex_Lock> <== NOT EXECUTED 30017948: e1a01006 mov r1, r6 <== NOT EXECUTED 3001794c: e59f0030 ldr r0, [pc, #48] ; 30017984 <== NOT EXECUTED 30017950: e1a0200d mov r2, sp <== NOT EXECUTED 30017954: eb000ff6 bl 3001b934 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 30017958: e59d6000 ldr r6, [sp] <== NOT EXECUTED 3001795c: e3560000 cmp r6, #0 <== NOT EXECUTED break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 30017960: 13a06004 movne r6, #4 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: _Heap_Get_information( &the_region->Memory, the_info ); 30017964: 02800068 addeq r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017968: 01a01005 moveq r1, r5 <== NOT EXECUTED 3001796c: 0b000d22 bleq 3001adfc <_Heap_Get_information> <== NOT EXECUTED default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30017970: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017974: eb0008d1 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 30017978: e1a00006 mov r0, r6 <== NOT EXECUTED 3001797c: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 30017ab4 : rtems_status_code rtems_region_get_segment_size( rtems_id id, void *segment, uintptr_t *size ) { 30017ab4: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_SUCCESSFUL; register Region_Control *the_region; if ( !segment ) 30017ab8: e2515000 subs r5, r1, #0 <== NOT EXECUTED rtems_status_code rtems_region_get_segment_size( rtems_id id, void *segment, uintptr_t *size ) { 30017abc: e1a06000 mov r6, r0 <== NOT EXECUTED 30017ac0: e1a04002 mov r4, r2 <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_SUCCESSFUL; register Region_Control *the_region; if ( !segment ) 30017ac4: 0a000019 beq 30017b30 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 30017ac8: e3520000 cmp r2, #0 <== NOT EXECUTED 30017acc: 0a000017 beq 30017b30 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 30017ad0: e59f3064 ldr r3, [pc, #100] ; 30017b3c <== NOT EXECUTED 30017ad4: e5930000 ldr r0, [r3] <== NOT EXECUTED 30017ad8: eb00085f bl 30019c5c <_API_Mutex_Lock> <== NOT EXECUTED 30017adc: e59f005c ldr r0, [pc, #92] ; 30017b40 <== NOT EXECUTED 30017ae0: e1a01006 mov r1, r6 <== NOT EXECUTED 30017ae4: e1a0200d mov r2, sp <== NOT EXECUTED 30017ae8: eb000f91 bl 3001b934 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 30017aec: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30017af0: e3530000 cmp r3, #0 <== NOT EXECUTED 30017af4: 0a000002 beq 30017b04 <== NOT EXECUTED void *segment, uintptr_t *size ) { Objects_Locations location; rtems_status_code return_status = RTEMS_SUCCESSFUL; 30017af8: e3530001 cmp r3, #1 <== NOT EXECUTED 30017afc: 03a04004 moveq r4, #4 <== NOT EXECUTED 30017b00: ea000005 b 30017b1c <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) ) 30017b04: e1a02004 mov r2, r4 <== NOT EXECUTED 30017b08: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017b0c: e1a01005 mov r1, r5 <== NOT EXECUTED 30017b10: eb000e1f bl 3001b394 <_Heap_Size_of_alloc_area> <== NOT EXECUTED void *segment, uintptr_t *size ) { Objects_Locations location; rtems_status_code return_status = RTEMS_SUCCESSFUL; 30017b14: e3500000 cmp r0, #0 <== NOT EXECUTED 30017b18: 03a04009 moveq r4, #9 <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30017b1c: e59f3018 ldr r3, [pc, #24] ; 30017b3c <== NOT EXECUTED void *segment, uintptr_t *size ) { Objects_Locations location; rtems_status_code return_status = RTEMS_SUCCESSFUL; 30017b20: 13a04000 movne r4, #0 <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30017b24: e5930000 ldr r0, [r3] <== NOT EXECUTED 30017b28: eb000864 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; 30017b2c: ea000000 b 30017b34 <== NOT EXECUTED if ( !segment ) return RTEMS_INVALID_ADDRESS; if ( !size ) return RTEMS_INVALID_ADDRESS; 30017b30: e3a04009 mov r4, #9 <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 30017b34: e1a00004 mov r0, r4 <== NOT EXECUTED 30017b38: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 30017b74 : rtems_id id, void *segment, uintptr_t size, uintptr_t *old_size ) { 30017b74: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED uintptr_t osize; rtems_status_code return_status; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) 30017b78: e2538000 subs r8, r3, #0 <== NOT EXECUTED rtems_id id, void *segment, uintptr_t size, uintptr_t *old_size ) { 30017b7c: e1a05000 mov r5, r0 <== NOT EXECUTED 30017b80: e1a07001 mov r7, r1 <== NOT EXECUTED 30017b84: e1a06002 mov r6, r2 <== NOT EXECUTED rtems_status_code return_status; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) return RTEMS_INVALID_ADDRESS; 30017b88: 03a00009 moveq r0, #9 <== NOT EXECUTED uintptr_t osize; rtems_status_code return_status; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) 30017b8c: 0a000022 beq 30017c1c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 30017b90: e59f408c ldr r4, [pc, #140] ; 30017c24 <== NOT EXECUTED 30017b94: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017b98: eb00082f bl 30019c5c <_API_Mutex_Lock> <== NOT EXECUTED 30017b9c: e1a01005 mov r1, r5 <== NOT EXECUTED 30017ba0: e59f0080 ldr r0, [pc, #128] ; 30017c28 <== NOT EXECUTED 30017ba4: e28d2008 add r2, sp, #8 <== NOT EXECUTED 30017ba8: eb000f61 bl 3001b934 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 30017bac: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30017bb0: e1a05000 mov r5, r0 <== NOT EXECUTED 30017bb4: e3530000 cmp r3, #0 <== NOT EXECUTED 30017bb8: 1a000014 bne 30017c10 <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 30017bbc: e28d3004 add r3, sp, #4 <== NOT EXECUTED 30017bc0: e58d3000 str r3, [sp] <== NOT EXECUTED 30017bc4: e1a02006 mov r2, r6 <== NOT EXECUTED 30017bc8: e28d300c add r3, sp, #12 <== NOT EXECUTED 30017bcc: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017bd0: e1a01007 mov r1, r7 <== NOT EXECUTED 30017bd4: eb000da1 bl 3001b260 <_Heap_Resize_block> <== NOT EXECUTED segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 30017bd8: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) 30017bdc: e2506000 subs r6, r0, #0 <== NOT EXECUTED segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 30017be0: e5883000 str r3, [r8] <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) 30017be4: 1a000003 bne 30017bf8 <== NOT EXECUTED _Region_Process_queue( the_region ); /* unlocks allocator */ 30017be8: e1a00005 mov r0, r5 <== NOT EXECUTED 30017bec: eb001c70 bl 3001edb4 <_Region_Process_queue> <== NOT EXECUTED else _RTEMS_Unlock_allocator(); if (status == HEAP_RESIZE_SUCCESSFUL) return RTEMS_SUCCESSFUL; 30017bf0: e1a00006 mov r0, r6 <== NOT EXECUTED 30017bf4: ea000008 b 30017c1c <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 30017bf8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017bfc: eb00082f bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED if (status == HEAP_RESIZE_SUCCESSFUL) return RTEMS_SUCCESSFUL; if (status == HEAP_RESIZE_UNSATISFIED) return RTEMS_UNSATISFIED; 30017c00: e3560001 cmp r6, #1 <== NOT EXECUTED 30017c04: 13a00009 movne r0, #9 <== NOT EXECUTED 30017c08: 03a0000d moveq r0, #13 <== NOT EXECUTED 30017c0c: ea000002 b 30017c1c <== NOT EXECUTED default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30017c10: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017c14: eb000829 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; 30017c18: e3a00004 mov r0, #4 <== NOT EXECUTED } 30017c1c: e28dd010 add sp, sp, #16 <== NOT EXECUTED 30017c20: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 30017c2c : rtems_status_code rtems_region_return_segment( rtems_id id, void *segment ) { 30017c2c: e92d4071 push {r0, r4, r5, r6, lr} uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 30017c30: e59f3074 ldr r3, [pc, #116] ; 30017cac rtems_status_code rtems_region_return_segment( rtems_id id, void *segment ) { 30017c34: e1a05000 mov r5, r0 uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 30017c38: e5930000 ldr r0, [r3] rtems_status_code rtems_region_return_segment( rtems_id id, void *segment ) { 30017c3c: e1a04001 mov r4, r1 uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 30017c40: eb000805 bl 30019c5c <_API_Mutex_Lock> 30017c44: e1a01005 mov r1, r5 30017c48: e59f0060 ldr r0, [pc, #96] ; 30017cb0 30017c4c: e1a0200d mov r2, sp 30017c50: eb000f37 bl 3001b934 <_Objects_Get_no_protection> the_region = _Region_Get( id, &location ); switch ( location ) { 30017c54: e59d6000 ldr r6, [sp] 30017c58: e1a05000 mov r5, r0 30017c5c: e3560000 cmp r6, #0 break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 30017c60: 13a06004 movne r6, #4 register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 30017c64: 1a00000b bne 30017c98 RTEMS_INLINE_ROUTINE bool _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 30017c68: e2800068 add r0, r0, #104 ; 0x68 30017c6c: e1a01004 mov r1, r4 30017c70: eb000bc3 bl 3001ab84 <_Heap_Free> #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 30017c74: e3500000 cmp r0, #0 return_status = RTEMS_INVALID_ADDRESS; 30017c78: 03a06009 moveq r6, #9 #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 30017c7c: 0a000005 beq 30017c98 return_status = RTEMS_INVALID_ADDRESS; else { the_region->number_of_used_blocks -= 1; 30017c80: e5953064 ldr r3, [r5, #100] ; 0x64 _Region_Process_queue(the_region); /* unlocks allocator */ 30017c84: e1a00005 mov r0, r5 _Region_Debug_Walk( the_region, 4 ); if ( !status ) return_status = RTEMS_INVALID_ADDRESS; else { the_region->number_of_used_blocks -= 1; 30017c88: e2433001 sub r3, r3, #1 30017c8c: e5853064 str r3, [r5, #100] ; 0x64 _Region_Process_queue(the_region); /* unlocks allocator */ 30017c90: eb001c47 bl 3001edb4 <_Region_Process_queue> return RTEMS_SUCCESSFUL; 30017c94: ea000002 b 30017ca4 default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30017c98: e59f300c ldr r3, [pc, #12] ; 30017cac <== NOT EXECUTED 30017c9c: e5930000 ldr r0, [r3] <== NOT EXECUTED 30017ca0: eb000806 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 30017ca4: e1a00006 mov r0, r6 30017ca8: e8bd8078 pop {r3, r4, r5, r6, pc} =============================================================================== 30009fa0 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 30009fa0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attr; CORE_semaphore_Attributes the_semaphore_attr; CORE_mutex_Status mutex_status; if ( !rtems_is_name_valid( name ) ) 30009fa4: e2507000 subs r7, r0, #0 uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 30009fa8: e24dd018 sub sp, sp, #24 30009fac: e1a04001 mov r4, r1 30009fb0: e1a08002 mov r8, r2 30009fb4: e1a09003 mov r9, r3 30009fb8: e59d6038 ldr r6, [sp, #56] ; 0x38 CORE_mutex_Attributes the_mutex_attr; CORE_semaphore_Attributes the_semaphore_attr; CORE_mutex_Status mutex_status; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 30009fbc: 03a00003 moveq r0, #3 register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attr; CORE_semaphore_Attributes the_semaphore_attr; CORE_mutex_Status mutex_status; if ( !rtems_is_name_valid( name ) ) 30009fc0: 0a00005a beq 3000a130 return RTEMS_INVALID_NAME; if ( !id ) 30009fc4: e3560000 cmp r6, #0 return RTEMS_INVALID_ADDRESS; 30009fc8: 03a00009 moveq r0, #9 CORE_mutex_Status mutex_status; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 30009fcc: 0a000057 beq 3000a130 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 30009fd0: e21230c0 ands r3, r2, #192 ; 0xc0 30009fd4: 0a000006 beq 30009ff4 */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE); 30009fd8: e2022030 and r2, r2, #48 ; 0x30 _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) && 30009fdc: e3520010 cmp r2, #16 30009fe0: 1a000051 bne 3000a12c 30009fe4: e3180004 tst r8, #4 30009fe8: 0a00004f beq 3000a12c _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 30009fec: e35300c0 cmp r3, #192 ; 0xc0 30009ff0: 0a00004d beq 3000a12c _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 30009ff4: e218a030 ands sl, r8, #48 ; 0x30 30009ff8: 0a000002 beq 3000a008 30009ffc: e3540001 cmp r4, #1 return RTEMS_INVALID_NUMBER; 3000a000: 83a0000a movhi r0, #10 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 ) ) 3000a004: 8a000049 bhi 3000a130 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000a008: e59f3128 ldr r3, [pc, #296] ; 3000a138 3000a00c: e5932000 ldr r2, [r3] ++level; 3000a010: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 3000a014: e5832000 str r2, [r3] * This function allocates a semaphore control block from * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 3000a018: e59f011c ldr r0, [pc, #284] ; 3000a13c 3000a01c: eb00054f bl 3000b560 <_Objects_Allocate> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 3000a020: e2505000 subs r5, r0, #0 3000a024: 1a000002 bne 3000a034 _Thread_Enable_dispatch(); 3000a028: eb0009f3 bl 3000c7fc <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 3000a02c: e3a00005 mov r0, #5 3000a030: ea00003e b 3000a130 the_semaphore->attribute_set = attribute_set; /* * Initialize it as a counting semaphore. */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { 3000a034: e35a0000 cmp sl, #0 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_semaphore->attribute_set = attribute_set; 3000a038: e5858010 str r8, [r5, #16] 3000a03c: e2083004 and r3, r8, #4 /* * Initialize it as a counting semaphore. */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { 3000a040: 1a00000b bne 3000a074 * This effectively disables limit checking. */ the_semaphore_attr.maximum_count = 0xFFFFFFFF; if ( _Attributes_Is_priority( attribute_set ) ) the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 3000a044: e2933000 adds r3, r3, #0 */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { /* * This effectively disables limit checking. */ the_semaphore_attr.maximum_count = 0xFFFFFFFF; 3000a048: e3e02000 mvn r2, #0 3000a04c: e58d2010 str r2, [sp, #16] if ( _Attributes_Is_priority( attribute_set ) ) the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 3000a050: 13a03001 movne r3, #1 * The following are just to make Purify happy. */ the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM; _CORE_semaphore_Initialize( 3000a054: e2850014 add r0, r5, #20 3000a058: e28d1010 add r1, sp, #16 3000a05c: e1a02004 mov r2, r4 */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { /* * This effectively disables limit checking. */ the_semaphore_attr.maximum_count = 0xFFFFFFFF; 3000a060: e58d3014 str r3, [sp, #20] the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; /* * The following are just to make Purify happy. */ the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 3000a064: e58da000 str sl, [sp] the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM; 3000a068: e58da00c str sl, [sp, #12] _CORE_semaphore_Initialize( 3000a06c: eb0003c3 bl 3000af80 <_CORE_semaphore_Initialize> 3000a070: ea000023 b 3000a104 /* * It is either simple binary semaphore or a more powerful mutex * style binary semaphore. This is the mutex style. */ if ( _Attributes_Is_priority( attribute_set ) ) the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 3000a074: e2933000 adds r3, r3, #0 3000a078: 13a03001 movne r3, #1 else the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 3000a07c: e35a0010 cmp sl, #16 /* * It is either simple binary semaphore or a more powerful mutex * style binary semaphore. This is the mutex style. */ if ( _Attributes_Is_priority( attribute_set ) ) the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 3000a080: e58d3008 str r3, [sp, #8] 3000a084: e3a02000 mov r2, #0 the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; the_mutex_attr.only_owner_release = true; } } } else /* must be simple binary semaphore */ { the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; 3000a088: 13a03001 movne r3, #1 3000a08c: 158d3000 strne r3, [sp] the_mutex_attr.only_owner_release = false; 3000a090: 15cd2004 strbne r2, [sp, #4] if ( _Attributes_Is_priority( attribute_set ) ) the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 3000a094: 1a00000c bne 3000a0cc the_mutex_attr.priority_ceiling = priority_ceiling; the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; the_mutex_attr.only_owner_release = false; if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) { 3000a098: e3530001 cmp r3, #1 the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { the_mutex_attr.priority_ceiling = priority_ceiling; 3000a09c: e58d900c str r9, [sp, #12] the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 3000a0a0: e58d2000 str r2, [sp] the_mutex_attr.only_owner_release = false; 3000a0a4: e5cd2004 strb r2, [sp, #4] if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) { 3000a0a8: 1a000007 bne 3000a0cc if ( _Attributes_Is_inherit_priority( attribute_set ) ) { 3000a0ac: e3180040 tst r8, #64 ; 0x40 the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 3000a0b0: 13a02002 movne r2, #2 the_mutex_attr.priority_ceiling = priority_ceiling; the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; the_mutex_attr.only_owner_release = false; if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) { if ( _Attributes_Is_inherit_priority( attribute_set ) ) { 3000a0b4: 1a000002 bne 3000a0c4 the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; the_mutex_attr.only_owner_release = true; } else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) { 3000a0b8: e3180080 tst r8, #128 ; 0x80 3000a0bc: 0a000002 beq 3000a0cc the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 3000a0c0: e3a02003 mov r2, #3 3000a0c4: e58d2008 str r2, [sp, #8] the_mutex_attr.only_owner_release = true; 3000a0c8: e5cd3004 strb r3, [sp, #4] } else /* must be simple binary semaphore */ { the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; the_mutex_attr.only_owner_release = false; } mutex_status = _CORE_mutex_Initialize( 3000a0cc: e2443001 sub r3, r4, #1 3000a0d0: e2732000 rsbs r2, r3, #0 3000a0d4: e0a22003 adc r2, r2, r3 3000a0d8: e2850014 add r0, r5, #20 3000a0dc: e1a0100d mov r1, sp 3000a0e0: eb0002e1 bl 3000ac6c <_CORE_mutex_Initialize> &the_semaphore->Core_control.mutex, &the_mutex_attr, (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED ); if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) { 3000a0e4: e3500005 cmp r0, #5 3000a0e8: 1a000005 bne 3000a104 */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 3000a0ec: e59f0048 ldr r0, [pc, #72] ; 3000a13c 3000a0f0: e1a01005 mov r1, r5 3000a0f4: eb0005e8 bl 3000b89c <_Objects_Free> _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 3000a0f8: eb0009bf bl 3000c7fc <_Thread_Enable_dispatch> return RTEMS_INVALID_PRIORITY; 3000a0fc: e3a00013 mov r0, #19 3000a100: ea00000a b 3000a130 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000a104: e59f2030 ldr r2, [pc, #48] ; 3000a13c Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 3000a108: e5953008 ldr r3, [r5, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000a10c: e592201c ldr r2, [r2, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 3000a110: e1d510b8 ldrh r1, [r5, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000a114: e7825101 str r5, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 3000a118: e585700c str r7, [r5, #12] &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 3000a11c: e5863000 str r3, [r6] the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 3000a120: eb0009b5 bl 3000c7fc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000a124: e3a00000 mov r0, #0 3000a128: ea000000 b 3000a130 } if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; 3000a12c: e3a0000b mov r0, #11 <== NOT EXECUTED 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 3000a130: e28dd018 add sp, sp, #24 3000a134: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} =============================================================================== 3000a140 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 3000a140: e92d4011 push {r0, r4, lr} 3000a144: e1a01000 mov r1, r0 RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 3000a148: e1a0200d mov r2, sp 3000a14c: e59f0084 ldr r0, [pc, #132] ; 3000a1d8 3000a150: eb000626 bl 3000b9f0 <_Objects_Get> register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 3000a154: e59d3000 ldr r3, [sp] 3000a158: e1a04000 mov r4, r0 3000a15c: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000a160: 13a00004 movne r0, #4 { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 3000a164: 1a00001a bne 3000a1d4 */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 3000a168: e5941010 ldr r1, [r4, #16] case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 3000a16c: e2111030 ands r1, r1, #48 ; 0x30 3000a170: 0a00000c beq 3000a1a8 if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 3000a174: e5943064 ldr r3, [r4, #100] ; 0x64 3000a178: e3530000 cmp r3, #0 3000a17c: 1a000004 bne 3000a194 3000a180: e3510020 cmp r1, #32 3000a184: 0a000002 beq 3000a194 !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 3000a188: eb00099b bl 3000c7fc <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_RESOURCE_IN_USE; 3000a18c: e3a0000c mov r0, #12 <== NOT EXECUTED 3000a190: ea00000f b 3000a1d4 <== NOT EXECUTED } _CORE_mutex_Flush( 3000a194: e2840014 add r0, r4, #20 3000a198: e3a01000 mov r1, #0 3000a19c: e3a02003 mov r2, #3 3000a1a0: eb0002b0 bl 3000ac68 <_CORE_mutex_Flush> 3000a1a4: ea000002 b 3000a1b4 &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 3000a1a8: e2840014 add r0, r4, #20 3000a1ac: e3a02002 mov r2, #2 3000a1b0: eb000371 bl 3000af7c <_CORE_semaphore_Flush> SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_SEMAPHORE_WAS_DELETED ); } _Objects_Close( &_Semaphore_Information, &the_semaphore->Object ); 3000a1b4: e59f001c ldr r0, [pc, #28] ; 3000a1d8 3000a1b8: e1a01004 mov r1, r4 3000a1bc: eb000509 bl 3000b5e8 <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 3000a1c0: e59f0010 ldr r0, [pc, #16] ; 3000a1d8 3000a1c4: e1a01004 mov r1, r4 3000a1c8: eb0005b3 bl 3000b89c <_Objects_Free> 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 3000a1cc: eb00098a bl 3000c7fc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000a1d0: e3a00000 mov r0, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000a1d4: e8bd8018 pop {r3, r4, pc} =============================================================================== 30012df8 : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 30012df8: e92d4001 push {r0, lr} 30012dfc: e1a01000 mov r1, r0 30012e00: e1a0200d mov r2, sp 30012e04: e59f0044 ldr r0, [pc, #68] ; 30012e50 30012e08: ebffe8a6 bl 3000d0a8 <_Objects_Get> register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 30012e0c: e59d3000 ldr r3, [sp] 30012e10: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30012e14: 13a00004 movne r0, #4 { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 30012e18: 1a00000b bne 30012e4c 30012e1c: e5901010 ldr r1, [r0, #16] 30012e20: e2800014 add r0, r0, #20 case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 30012e24: e2111030 ands r1, r1, #48 ; 0x30 30012e28: 0a000003 beq 30012e3c _CORE_mutex_Flush( 30012e2c: e1a01003 mov r1, r3 30012e30: e3a02001 mov r2, #1 30012e34: ebffe539 bl 3000c320 <_CORE_mutex_Flush> 30012e38: ea000001 b 30012e44 &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 30012e3c: e3a02001 mov r2, #1 <== NOT EXECUTED 30012e40: ebffe5fb bl 3000c634 <_CORE_semaphore_Flush> <== NOT EXECUTED &the_semaphore->Core_control.semaphore, SEND_OBJECT_WAS_DELETED, CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT ); } _Thread_Enable_dispatch(); 30012e44: ebffebf8 bl 3000de2c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30012e48: e3a00000 mov r0, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30012e4c: e8bd8008 pop {r3, pc} =============================================================================== 3000a1dc : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 3000a1dc: e92d4077 push {r0, r1, r2, r4, r5, r6, lr} 3000a1e0: e1a04000 mov r4, r0 Objects_Id id, Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) 3000a1e4: e28d3008 add r3, sp, #8 3000a1e8: e1a06001 mov r6, r1 3000a1ec: e1a05002 mov r5, r2 3000a1f0: e59f00f0 ldr r0, [pc, #240] ; 3000a2e8 3000a1f4: e1a01004 mov r1, r4 3000a1f8: e28d2004 add r2, sp, #4 3000a1fc: eb0005e1 bl 3000b988 <_Objects_Get_isr_disable> register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 3000a200: e59d3004 ldr r3, [sp, #4] 3000a204: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000a208: 13a00004 movne r0, #4 register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 3000a20c: 1a000034 bne 3000a2e4 3000a210: e5903010 ldr r3, [r0, #16] case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 3000a214: e2132030 ands r2, r3, #48 ; 0x30 3000a218: 0a00000c beq 3000a250 _CORE_mutex_Seize( 3000a21c: e59d3008 ldr r3, [sp, #8] */ RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait ( rtems_option option_set ) { return (option_set & RTEMS_NO_WAIT) ? true : false; 3000a220: e2062001 and r2, r6, #1 3000a224: e58d3000 str r3, [sp] 3000a228: e2800014 add r0, r0, #20 3000a22c: e1a03005 mov r3, r5 3000a230: e1a01004 mov r1, r4 3000a234: e2222001 eor r2, r2, #1 3000a238: eb0002d8 bl 3000ada0 <_CORE_mutex_Seize> ((_Options_Is_no_wait( option_set )) ? false : true), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( _Thread_Executing->Wait.return_code ); 3000a23c: e59f30a8 ldr r3, [pc, #168] ; 3000a2ec 3000a240: e5933008 ldr r3, [r3, #8] id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 3000a244: e5930034 ldr r0, [r3, #52] ; 0x34 3000a248: eb000047 bl 3000a36c <_Semaphore_Translate_core_mutex_return_code> 3000a24c: ea000024 b 3000a2e4 { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 3000a250: e59f3094 ldr r3, [pc, #148] ; 3000a2ec 3000a254: e5933008 ldr r3, [r3, #8] executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 3000a258: e5832034 str r2, [r3, #52] ; 0x34 if ( the_semaphore->count != 0 ) { 3000a25c: e590205c ldr r2, [r0, #92] ; 0x5c 3000a260: e3520000 cmp r2, #0 3000a264: 0a000004 beq 3000a27c the_semaphore->count -= 1; 3000a268: e2422001 sub r2, r2, #1 3000a26c: e580205c str r2, [r0, #92] ; 0x5c 3000a270: e59d3008 ldr r3, [sp, #8] 3000a274: e129f003 msr CPSR_fc, r3 3000a278: ea000015 b 3000a2d4 _ISR_Enable( *level_p ); return; } if ( !wait ) { 3000a27c: e3160001 tst r6, #1 3000a280: 0a000004 beq 3000a298 3000a284: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 3000a288: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED _ISR_Enable( *level_p ); executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 3000a28c: e3a02001 mov r2, #1 <== NOT EXECUTED 3000a290: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED 3000a294: ea00000e b 3000a2d4 <== NOT EXECUTED * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000a298: e59f2050 ldr r2, [pc, #80] ; 3000a2f0 3000a29c: e5921000 ldr r1, [r2] ++level; 3000a2a0: e2811001 add r1, r1, #1 _Thread_Dispatch_disable_level = level; 3000a2a4: e5821000 str r1, [r2] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 3000a2a8: e3a02001 mov r2, #1 3000a2ac: e5802044 str r2, [r0, #68] ; 0x44 return; } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 3000a2b0: e2800014 add r0, r0, #20 3000a2b4: e5830044 str r0, [r3, #68] ; 0x44 executing->Wait.id = id; 3000a2b8: e5834020 str r4, [r3, #32] 3000a2bc: e59d3008 ldr r3, [sp, #8] 3000a2c0: e129f003 msr CPSR_fc, r3 _ISR_Enable( *level_p ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 3000a2c4: e59f2028 ldr r2, [pc, #40] ; 3000a2f4 3000a2c8: e1a01005 mov r1, r5 3000a2cc: eb000a6a bl 3000cc7c <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 3000a2d0: eb000949 bl 3000c7fc <_Thread_Enable_dispatch> ((_Options_Is_no_wait( option_set )) ? false : true), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( _Thread_Executing->Wait.return_code ); 3000a2d4: e59f3010 ldr r3, [pc, #16] ; 3000a2ec 3000a2d8: e5933008 ldr r3, [r3, #8] id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 3000a2dc: e5930034 ldr r0, [r3, #52] ; 0x34 3000a2e0: eb000025 bl 3000a37c <_Semaphore_Translate_core_semaphore_return_code> break; } return RTEMS_INVALID_ID; } 3000a2e4: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} =============================================================================== 3000a870 : void rtems_shutdown_executive( uint32_t result ) { if ( _System_state_Is_up( _System_state_Get() ) ) { 3000a870: e59f3038 ldr r3, [pc, #56] ; 3000a8b0 */ void rtems_shutdown_executive( uint32_t result ) { 3000a874: e52de004 push {lr} ; (str lr, [sp, #-4]!) if ( _System_state_Is_up( _System_state_Get() ) ) { 3000a878: e5932000 ldr r2, [r3] 3000a87c: e3520003 cmp r2, #3 3000a880: 1a000006 bne 3000a8a0 #if defined(RTEMS_SMP) _SMP_Request_other_cores_to_shutdown(); #endif _Per_CPU_Information[0].idle->Wait.return_code = result; 3000a884: e59f2028 ldr r2, [pc, #40] ; 3000a8b4 3000a888: e5922010 ldr r2, [r2, #16] 3000a88c: e5820034 str r0, [r2, #52] ; 0x34 3000a890: e3a02004 mov r2, #4 3000a894: e5832000 str r2, [r3] * if we were running within the same context, it would work. * * And we will not return to this thread, so there is no point of * saving the context. */ _Context_Restart_self( &_Thread_BSP_context ); 3000a898: e59f0018 ldr r0, [pc, #24] ; 3000a8b8 3000a89c: eb000c7f bl 3000daa0 <_CPU_Context_restore> ****** RETURN TO RTEMS_INITIALIZE_START_MULTITASKING() ****** ****** AND THEN TO BOOT_CARD() ****** ******************************************************************* *******************************************************************/ } _Internal_error_Occurred( 3000a8a0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a8a4: e3a01001 mov r1, #1 <== NOT EXECUTED 3000a8a8: e3a02014 mov r2, #20 <== NOT EXECUTED 3000a8ac: eb00030d bl 3000b4e8 <_Internal_error_Occurred> <== NOT EXECUTED =============================================================================== 30018134 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 30018134: e92d4011 push {r0, r4, lr} register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 30018138: e2514000 subs r4, r1, #0 return RTEMS_INVALID_NUMBER; 3001813c: 03a0000a moveq r0, #10 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 30018140: 0a000025 beq 300181dc return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 30018144: e1a0100d mov r1, sp 30018148: eb001192 bl 3001c798 <_Thread_Get> switch ( location ) { 3001814c: e59d3000 ldr r3, [sp] 30018150: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30018154: 13a00004 movne r0, #4 if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); switch ( location ) { 30018158: 1a00001f bne 300181dc case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 3001815c: e59030ec ldr r3, [r0, #236] ; 0xec asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 30018160: e593200c ldr r2, [r3, #12] 30018164: e3520000 cmp r2, #0 30018168: 0a000019 beq 300181d4 if ( asr->is_enabled ) { 3001816c: e5d32008 ldrb r2, [r3, #8] 30018170: e3520000 cmp r2, #0 uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 30018174: e10f2000 mrs r2, CPSR 30018178: e3821080 orr r1, r2, #128 ; 0x80 3001817c: e129f001 msr CPSR_fc, r1 30018180: 0a00000c beq 300181b8 ) { ISR_Level _level; _ISR_Disable( _level ); *signal_set |= signals; 30018184: e5931014 ldr r1, [r3, #20] 30018188: e1814004 orr r4, r1, r4 3001818c: e5834014 str r4, [r3, #20] static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 30018190: e129f002 msr CPSR_fc, r2 _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 30018194: e59f3044 ldr r3, [pc, #68] ; 300181e0 30018198: e5932000 ldr r2, [r3] 3001819c: e3520000 cmp r2, #0 300181a0: 0a000008 beq 300181c8 300181a4: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 300181a8: e1500002 cmp r0, r2 <== NOT EXECUTED _Thread_Dispatch_necessary = true; 300181ac: 03a02001 moveq r2, #1 <== NOT EXECUTED 300181b0: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED 300181b4: ea000003 b 300181c8 <== NOT EXECUTED 300181b8: e5931018 ldr r1, [r3, #24] <== NOT EXECUTED 300181bc: e1814004 orr r4, r1, r4 <== NOT EXECUTED 300181c0: e5834018 str r4, [r3, #24] <== NOT EXECUTED 300181c4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 300181c8: eb00116a bl 3001c778 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 300181cc: e3a00000 mov r0, #0 300181d0: ea000001 b 300181dc } _Thread_Enable_dispatch(); 300181d4: eb001167 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_NOT_DEFINED; 300181d8: e3a0000b mov r0, #11 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 300181dc: e8bd8018 pop {r3, r4, pc} =============================================================================== 3000a528 : #include rtems_status_code rtems_task_delete( rtems_id id ) { 3000a528: e92d4071 push {r0, r4, r5, r6, lr} register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 3000a52c: e59f5068 ldr r5, [pc, #104] ; 3000a59c #include rtems_status_code rtems_task_delete( rtems_id id ) { 3000a530: e1a04000 mov r4, r0 register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 3000a534: e5950000 ldr r0, [r5] 3000a538: eb00017c bl 3000ab30 <_API_Mutex_Lock> the_thread = _Thread_Get( id, &location ); 3000a53c: e1a00004 mov r0, r4 3000a540: e1a0100d mov r1, sp 3000a544: eb0008b4 bl 3000c81c <_Thread_Get> switch ( location ) { 3000a548: e59d6000 ldr r6, [sp] Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); the_thread = _Thread_Get( id, &location ); 3000a54c: e1a04000 mov r4, r0 switch ( location ) { 3000a550: e3560000 cmp r6, #0 3000a554: 1a00000c bne 3000a58c case OBJECTS_LOCAL: the_information = _Objects_Get_information_id( the_thread->Object.id ); 3000a558: e5900008 ldr r0, [r0, #8] 3000a55c: eb0004eb bl 3000b910 <_Objects_Get_information_id> 0 /* Not used */ ); } #endif _Thread_Close( the_information, the_thread ); 3000a560: e1a01004 mov r1, r4 3000a564: eb0007d9 bl 3000c4d0 <_Thread_Close> 3000a568: e5940008 ldr r0, [r4, #8] 3000a56c: eb0004e7 bl 3000b910 <_Objects_Get_information_id> 3000a570: e1a01004 mov r1, r4 3000a574: eb0004c8 bl 3000b89c <_Objects_Free> _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 3000a578: e5950000 ldr r0, [r5] 3000a57c: eb000184 bl 3000ab94 <_API_Mutex_Unlock> _Thread_Enable_dispatch(); 3000a580: eb00089d bl 3000c7fc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000a584: e1a00006 mov r0, r6 3000a588: ea000002 b 3000a598 case OBJECTS_ERROR: break; } _RTEMS_Unlock_allocator(); 3000a58c: e5950000 ldr r0, [r5] <== NOT EXECUTED 3000a590: eb00017f bl 3000ab94 <_API_Mutex_Unlock> <== NOT EXECUTED return RTEMS_INVALID_ID; 3000a594: e3a00004 mov r0, #4 <== NOT EXECUTED } 3000a598: e8bd8078 pop {r3, r4, r5, r6, pc} =============================================================================== 3000c014 : rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 3000c014: e92d4071 push {r0, r4, r5, r6, lr} 3000c018: e1a05002 mov r5, r2 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000c01c: e59f2098 ldr r2, [pc, #152] ; 3000c0bc rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 3000c020: e1a03000 mov r3, r0 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000c024: e5d22004 ldrb r2, [r2, #4] rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 3000c028: e1a04001 mov r4, r1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000c02c: e3520000 cmp r2, #0 return RTEMS_NOT_CONFIGURED; 3000c030: 03a00016 moveq r0, #22 { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000c034: 0a00001f beq 3000c0b8 return RTEMS_NOT_CONFIGURED; if ( !note ) 3000c038: e3550000 cmp r5, #0 return RTEMS_INVALID_ADDRESS; 3000c03c: 03a00009 moveq r0, #9 RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; if ( !note ) 3000c040: 0a00001c beq 3000c0b8 /* * 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 ) 3000c044: e351000f cmp r1, #15 return RTEMS_INVALID_NUMBER; 3000c048: 83a0000a movhi r0, #10 /* * 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 ) 3000c04c: 8a000019 bhi 3000c0b8 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 3000c050: e3530000 cmp r3, #0 3000c054: e59f2064 ldr r2, [pc, #100] ; 3000c0c0 3000c058: 0a000003 beq 3000c06c _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 3000c05c: e5921008 ldr r1, [r2, #8] /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 3000c060: e5911008 ldr r1, [r1, #8] 3000c064: e1530001 cmp r3, r1 3000c068: 1a000006 bne 3000c088 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 3000c06c: e5923008 ldr r3, [r2, #8] <== NOT EXECUTED *note = api->Notepads[ notepad ]; 3000c070: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000c074: e59330ec ldr r3, [r3, #236] ; 0xec <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000c078: e3a00000 mov r0, #0 <== NOT EXECUTED */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 3000c07c: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000c080: e5853000 str r3, [r5] <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000c084: ea00000b b 3000c0b8 <== NOT EXECUTED } the_thread = _Thread_Get( id, &location ); 3000c088: e1a0100d mov r1, sp 3000c08c: eb000954 bl 3000e5e4 <_Thread_Get> switch ( location ) { 3000c090: e59d6000 ldr r6, [sp] 3000c094: e3560000 cmp r6, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000c098: 13a00004 movne r0, #4 *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000c09c: 1a000005 bne 3000c0b8 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 3000c0a0: e59030ec ldr r3, [r0, #236] ; 0xec 3000c0a4: e2844008 add r4, r4, #8 3000c0a8: e7933104 ldr r3, [r3, r4, lsl #2] 3000c0ac: e5853000 str r3, [r5] _Thread_Enable_dispatch(); 3000c0b0: eb000943 bl 3000e5c4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000c0b4: e1a00006 mov r0, r6 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000c0b8: e8bd8078 pop {r3, r4, r5, r6, pc} =============================================================================== 3000a5a0 : rtems_id *id ) { Objects_Name_or_id_lookup_errors status; if ( !id ) 3000a5a0: e2523000 subs r3, r2, #0 rtems_status_code rtems_task_ident( rtems_name name, uint32_t node, rtems_id *id ) { 3000a5a4: e92d4010 push {r4, lr} 3000a5a8: e1a0c000 mov ip, r0 3000a5ac: e1a04001 mov r4, r1 Objects_Name_or_id_lookup_errors status; if ( !id ) 3000a5b0: 0a00000d beq 3000a5ec return RTEMS_INVALID_ADDRESS; if ( name == OBJECTS_ID_OF_SELF ) { 3000a5b4: e3500000 cmp r0, #0 3000a5b8: 1a000004 bne 3000a5d0 *id = _Thread_Executing->Object.id; 3000a5bc: e59f2030 ldr r2, [pc, #48] ; 3000a5f4 3000a5c0: e5922008 ldr r2, [r2, #8] 3000a5c4: e5922008 ldr r2, [r2, #8] 3000a5c8: e5832000 str r2, [r3] return RTEMS_SUCCESSFUL; 3000a5cc: e8bd8010 pop {r4, pc} } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); 3000a5d0: e59f0020 ldr r0, [pc, #32] ; 3000a5f8 3000a5d4: e1a0100c mov r1, ip 3000a5d8: e1a02004 mov r2, r4 3000a5dc: eb000551 bl 3000bb28 <_Objects_Name_to_id_u32> return _Status_Object_name_errors_to_status[ status ]; 3000a5e0: e59f3014 ldr r3, [pc, #20] ; 3000a5fc 3000a5e4: e7930100 ldr r0, [r3, r0, lsl #2] 3000a5e8: e8bd8010 pop {r4, pc} ) { Objects_Name_or_id_lookup_errors status; if ( !id ) return RTEMS_INVALID_ADDRESS; 3000a5ec: e3a00009 mov r0, #9 <== NOT EXECUTED } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); return _Status_Object_name_errors_to_status[ status ]; } 3000a5f0: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 30018588 : */ rtems_status_code rtems_task_is_suspended( rtems_id id ) { 30018588: e92d4011 push {r0, r4, lr} <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3001858c: e1a0100d mov r1, sp <== NOT EXECUTED 30018590: eb001080 bl 3001c798 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 30018594: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30018598: e3530000 cmp r3, #0 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3001859c: 13a00004 movne r0, #4 <== NOT EXECUTED { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 300185a0: 1a000007 bne 300185c4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _States_Is_suspended ( States_Control the_states ) { return (the_states & STATES_SUSPENDED); 300185a4: e5904010 ldr r4, [r0, #16] <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 300185a8: e2144002 ands r4, r4, #2 <== NOT EXECUTED 300185ac: 1a000002 bne 300185bc <== NOT EXECUTED _Thread_Enable_dispatch(); 300185b0: eb001070 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 300185b4: e1a00004 mov r0, r4 <== NOT EXECUTED 300185b8: ea000001 b 300185c4 <== NOT EXECUTED } _Thread_Enable_dispatch(); 300185bc: eb00106d bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_ALREADY_SUSPENDED; 300185c0: e3a0000f mov r0, #15 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 300185c4: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED =============================================================================== 3000ada0 : rtems_status_code rtems_task_restart( rtems_id id, uint32_t argument ) { 3000ada0: e92d4031 push {r0, r4, r5, lr} 3000ada4: e1a05001 mov r5, r1 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000ada8: e1a0100d mov r1, sp 3000adac: eb000876 bl 3000cf8c <_Thread_Get> switch ( location ) { 3000adb0: e59d4000 ldr r4, [sp] 3000adb4: e3540000 cmp r4, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000adb8: 13a00004 movne r0, #4 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000adbc: 1a000009 bne 3000ade8 case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 3000adc0: e1a01004 mov r1, r4 3000adc4: e1a02005 mov r2, r5 3000adc8: eb000a66 bl 3000d768 <_Thread_Restart> 3000adcc: e3500000 cmp r0, #0 3000add0: 0a000002 beq 3000ade0 _Thread_Enable_dispatch(); 3000add4: eb000864 bl 3000cf6c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000add8: e1a00004 mov r0, r4 3000addc: ea000001 b 3000ade8 } _Thread_Enable_dispatch(); 3000ade0: eb000861 bl 3000cf6c <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_INCORRECT_STATE; 3000ade4: e3a0000e mov r0, #14 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000ade8: e8bd8038 pop {r3, r4, r5, pc} =============================================================================== 3000d7b0 : #include rtems_status_code rtems_task_resume( rtems_id id ) { 3000d7b0: e92d4011 push {r0, r4, lr} register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000d7b4: e1a0100d mov r1, sp 3000d7b8: eb00086b bl 3000f96c <_Thread_Get> switch ( location ) { 3000d7bc: e59d4000 ldr r4, [sp] ) { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000d7c0: e1a03000 mov r3, r0 switch ( location ) { 3000d7c4: e3540000 cmp r4, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000d7c8: 13a00004 movne r0, #4 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000d7cc: 1a000009 bne 3000d7f8 */ RTEMS_INLINE_ROUTINE bool _States_Is_suspended ( States_Control the_states ) { return (the_states & STATES_SUSPENDED); 3000d7d0: e5933010 ldr r3, [r3, #16] case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 3000d7d4: e3130002 tst r3, #2 3000d7d8: 0a000004 beq 3000d7f0 _Thread_Resume( the_thread ); 3000d7dc: e3a01002 mov r1, #2 3000d7e0: eb00077e bl 3000f5e0 <_Thread_Clear_state> _Thread_Enable_dispatch(); 3000d7e4: eb000858 bl 3000f94c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000d7e8: e1a00004 mov r0, r4 3000d7ec: ea000001 b 3000d7f8 } _Thread_Enable_dispatch(); 3000d7f0: eb000855 bl 3000f94c <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_INCORRECT_STATE; 3000d7f4: e3a0000e mov r0, #14 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000d7f8: e8bd8018 pop {r3, r4, pc} =============================================================================== 3000c1a8 : rtems_status_code rtems_task_set_note( rtems_id id, uint32_t notepad, uint32_t note ) { 3000c1a8: e92d4071 push {r0, r4, r5, r6, lr} 3000c1ac: e1a05002 mov r5, r2 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000c1b0: e59f2084 ldr r2, [pc, #132] ; 3000c23c rtems_status_code rtems_task_set_note( rtems_id id, uint32_t notepad, uint32_t note ) { 3000c1b4: e1a03000 mov r3, r0 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000c1b8: e5d22004 ldrb r2, [r2, #4] rtems_status_code rtems_task_set_note( rtems_id id, uint32_t notepad, uint32_t note ) { 3000c1bc: e1a04001 mov r4, r1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000c1c0: e3520000 cmp r2, #0 return RTEMS_NOT_CONFIGURED; 3000c1c4: 03a00016 moveq r0, #22 { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000c1c8: 0a00001a beq 3000c238 /* * 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 ) 3000c1cc: e351000f cmp r1, #15 return RTEMS_INVALID_NUMBER; 3000c1d0: 83a0000a movhi r0, #10 /* * 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 ) 3000c1d4: 8a000017 bhi 3000c238 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 3000c1d8: e3530000 cmp r3, #0 3000c1dc: e59f205c ldr r2, [pc, #92] ; 3000c240 3000c1e0: 0a000003 beq 3000c1f4 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 3000c1e4: e5921008 ldr r1, [r2, #8] /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 3000c1e8: e5911008 ldr r1, [r1, #8] 3000c1ec: e1530001 cmp r3, r1 3000c1f0: 1a000005 bne 3000c20c _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 3000c1f4: e5923008 ldr r3, [r2, #8] <== NOT EXECUTED api->Notepads[ notepad ] = note; 3000c1f8: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000c1fc: e59330ec ldr r3, [r3, #236] ; 0xec <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000c200: e3a00000 mov r0, #0 <== NOT EXECUTED */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 3000c204: e7835104 str r5, [r3, r4, lsl #2] <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000c208: ea00000a b 3000c238 <== NOT EXECUTED } the_thread = _Thread_Get( id, &location ); 3000c20c: e1a0100d mov r1, sp 3000c210: eb0008f3 bl 3000e5e4 <_Thread_Get> switch ( location ) { 3000c214: e59d6000 ldr r6, [sp] 3000c218: e3560000 cmp r6, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000c21c: 13a00004 movne r0, #4 api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000c220: 1a000004 bne 3000c238 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 3000c224: e59030ec ldr r3, [r0, #236] ; 0xec 3000c228: e2844008 add r4, r4, #8 3000c22c: e7835104 str r5, [r3, r4, lsl #2] _Thread_Enable_dispatch(); 3000c230: eb0008e3 bl 3000e5c4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000c234: e1a00006 mov r0, r6 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000c238: e8bd8078 pop {r3, r4, r5, r6, pc} =============================================================================== 3000e488 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 3000e488: e92d4031 push {r0, r4, r5, lr} register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 3000e48c: e2514000 subs r4, r1, #0 rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 3000e490: e1a05002 mov r5, r2 register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 3000e494: 0a000004 beq 3000e4ac RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 3000e498: e59f3074 ldr r3, [pc, #116] ; 3000e514 3000e49c: e5d33000 ldrb r3, [r3] 3000e4a0: e1540003 cmp r4, r3 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 3000e4a4: 83a00013 movhi r0, #19 ) { register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 3000e4a8: 8a000018 bhi 3000e510 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 3000e4ac: e3550000 cmp r5, #0 return RTEMS_INVALID_ADDRESS; 3000e4b0: 03a00009 moveq r0, #9 if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 3000e4b4: 0a000015 beq 3000e510 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 3000e4b8: e1a0100d mov r1, sp 3000e4bc: eb0008ca bl 300107ec <_Thread_Get> switch ( location ) { 3000e4c0: e59d3000 ldr r3, [sp] 3000e4c4: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000e4c8: 13a00004 movne r0, #4 if ( !old_priority ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000e4cc: 1a00000f bne 3000e510 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 3000e4d0: e5903014 ldr r3, [r0, #20] if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 3000e4d4: e3540000 cmp r4, #0 the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 3000e4d8: e5853000 str r3, [r5] if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 3000e4dc: 0a000009 beq 3000e508 the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 3000e4e0: e590301c ldr r3, [r0, #28] case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; if ( new_priority != RTEMS_CURRENT_PRIORITY ) { the_thread->real_priority = new_priority; 3000e4e4: e5804018 str r4, [r0, #24] if ( the_thread->resource_count == 0 || 3000e4e8: e3530000 cmp r3, #0 3000e4ec: 0a000002 beq 3000e4fc 3000e4f0: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000e4f4: e1530004 cmp r3, r4 <== NOT EXECUTED 3000e4f8: 9a000002 bls 3000e508 <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 3000e4fc: e1a01004 mov r1, r4 3000e500: e3a02000 mov r2, #0 3000e504: eb000797 bl 30010368 <_Thread_Change_priority> } _Thread_Enable_dispatch(); 3000e508: eb0008af bl 300107cc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000e50c: e3a00000 mov r0, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000e510: e8bd8038 pop {r3, r4, r5, pc} =============================================================================== 3000a684 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 3000a684: e92d4073 push {r0, r1, r4, r5, r6, lr} register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 3000a688: e2515000 subs r5, r1, #0 rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 3000a68c: e1a06002 mov r6, r2 register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; 3000a690: 03a00009 moveq r0, #9 ) { register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 3000a694: 0a000011 beq 3000a6e0 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 3000a698: e28d1004 add r1, sp, #4 3000a69c: eb00085e bl 3000c81c <_Thread_Get> switch ( location ) { 3000a6a0: e59d4004 ldr r4, [sp, #4] 3000a6a4: e3540000 cmp r4, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000a6a8: 13a00004 movne r0, #4 if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000a6ac: 1a00000b bne 3000a6e0 case OBJECTS_LOCAL: if ( _Thread_Start( 3000a6b0: e1a01004 mov r1, r4 3000a6b4: e1a02005 mov r2, r5 3000a6b8: e1a03004 mov r3, r4 3000a6bc: e58d6000 str r6, [sp] 3000a6c0: eb000a96 bl 3000d120 <_Thread_Start> 3000a6c4: e3500000 cmp r0, #0 3000a6c8: 0a000002 beq 3000a6d8 the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 3000a6cc: eb00084a bl 3000c7fc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000a6d0: e1a00004 mov r0, r4 3000a6d4: ea000001 b 3000a6e0 } _Thread_Enable_dispatch(); 3000a6d8: eb000847 bl 3000c7fc <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_INCORRECT_STATE; 3000a6dc: e3a0000e mov r0, #14 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000a6e0: e8bd807c pop {r2, r3, r4, r5, r6, pc} =============================================================================== 3000da3c : #include rtems_status_code rtems_task_suspend( rtems_id id ) { 3000da3c: e92d4011 push {r0, r4, lr} register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000da40: e1a0100d mov r1, sp 3000da44: eb00083b bl 3000fb38 <_Thread_Get> switch ( location ) { 3000da48: e59d2000 ldr r2, [sp] ) { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000da4c: e1a03000 mov r3, r0 switch ( location ) { 3000da50: e3520000 cmp r2, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000da54: 13a00004 movne r0, #4 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000da58: 1a000009 bne 3000da84 */ RTEMS_INLINE_ROUTINE bool _States_Is_suspended ( States_Control the_states ) { return (the_states & STATES_SUSPENDED); 3000da5c: e5934010 ldr r4, [r3, #16] case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 3000da60: e2144002 ands r4, r4, #2 3000da64: 1a000004 bne 3000da7c _Thread_Suspend( the_thread ); 3000da68: e3a01002 mov r1, #2 3000da6c: eb000a2f bl 30010330 <_Thread_Set_state> _Thread_Enable_dispatch(); 3000da70: eb000828 bl 3000fb18 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000da74: e1a00004 mov r0, r4 3000da78: ea000001 b 3000da84 } _Thread_Enable_dispatch(); 3000da7c: eb000825 bl 3000fb18 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_ALREADY_SUSPENDED; 3000da80: e3a0000f mov r0, #15 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000da84: e8bd8018 pop {r3, r4, pc} =============================================================================== 30008ed4 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 30008ed4: e92d40f1 push {r0, r4, r5, r6, r7, lr} Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 30008ed8: e2514000 subs r4, r1, #0 rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 30008edc: e1a05002 mov r5, r2 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) return RTEMS_INVALID_ADDRESS; 30008ee0: 03a00009 moveq r0, #9 { Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 30008ee4: 0a000023 beq 30008f78 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 30008ee8: e1a0100d mov r1, sp 30008eec: eb000795 bl 3000ad48 <_Thread_Get> switch (location) { 30008ef0: e59d3000 ldr r3, [sp] rtems_task_variable_t *tvp, *new; if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 30008ef4: e1a07000 mov r7, r0 switch (location) { 30008ef8: e3530000 cmp r3, #0 case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 30008efc: 059060f8 ldreq r6, [r0, #248] ; 0xf8 if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 30008f00: 0a000008 beq 30008f28 30008f04: ea00001a b 30008f74 <== NOT EXECUTED /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 30008f08: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED 30008f0c: e1530004 cmp r3, r4 <== NOT EXECUTED 30008f10: 1a000003 bne 30008f24 <== NOT EXECUTED tvp->dtor = dtor; 30008f14: e5865010 str r5, [r6, #16] <== NOT EXECUTED _Thread_Enable_dispatch(); 30008f18: eb000782 bl 3000ad28 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30008f1c: e3a00000 mov r0, #0 <== NOT EXECUTED 30008f20: ea000014 b 30008f78 <== NOT EXECUTED } tvp = (rtems_task_variable_t *)tvp->next; 30008f24: e5966000 ldr r6, [r6] <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 30008f28: e3560000 cmp r6, #0 30008f2c: 1afffff5 bne 30008f08 } /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) 30008f30: e3a00014 mov r0, #20 30008f34: eb000b23 bl 3000bbc8 <_Workspace_Allocate> _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 30008f38: e3500000 cmp r0, #0 30008f3c: 1a000002 bne 30008f4c _Thread_Enable_dispatch(); 30008f40: eb000778 bl 3000ad28 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_NO_MEMORY; 30008f44: e3a0001a mov r0, #26 <== NOT EXECUTED 30008f48: ea00000a b 30008f78 <== NOT EXECUTED } new->gval = *ptr; 30008f4c: e5943000 ldr r3, [r4] new->ptr = ptr; 30008f50: e5804004 str r4, [r0, #4] _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 30008f54: e5803008 str r3, [r0, #8] new->ptr = ptr; new->dtor = dtor; new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 30008f58: e59730f8 ldr r3, [r7, #248] ; 0xf8 _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; new->ptr = ptr; new->dtor = dtor; 30008f5c: e5805010 str r5, [r0, #16] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 30008f60: e5803000 str r3, [r0] the_thread->task_variables = new; 30008f64: e58700f8 str r0, [r7, #248] ; 0xf8 _Thread_Enable_dispatch(); 30008f68: eb00076e bl 3000ad28 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30008f6c: e1a00006 mov r0, r6 30008f70: ea000000 b 30008f78 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30008f74: e3a00004 mov r0, #4 <== NOT EXECUTED } 30008f78: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} =============================================================================== 30008f7c : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 30008f7c: e92d4011 push {r0, r4, lr} Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 30008f80: e2514000 subs r4, r1, #0 30008f84: 0a000016 beq 30008fe4 return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 30008f88: e1a0100d mov r1, sp 30008f8c: eb00076d bl 3000ad48 <_Thread_Get> switch (location) { 30008f90: e59d3000 ldr r3, [sp] 30008f94: e3530000 cmp r3, #0 case OBJECTS_LOCAL: tvp = the_thread->task_variables; 30008f98: 059010f8 ldreq r1, [r0, #248] ; 0xf8 return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 30008f9c: 0a00000d beq 30008fd8 30008fa0: ea000011 b 30008fec <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 30008fa4: e5912004 ldr r2, [r1, #4] 30008fa8: e1520004 cmp r2, r4 30008fac: 1a000007 bne 30008fd0 30008fb0: e5912000 ldr r2, [r1] if (prev) 30008fb4: e3530000 cmp r3, #0 prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 30008fb8: 058020f8 streq r2, [r0, #248] ; 0xf8 case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 30008fbc: 15832000 strne r2, [r3] else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 30008fc0: eb000028 bl 30009068 <_RTEMS_Tasks_Invoke_task_variable_dtor> _Thread_Enable_dispatch(); 30008fc4: eb000757 bl 3000ad28 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30008fc8: e3a00000 mov r0, #0 30008fcc: ea000007 b 30008ff0 } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 30008fd0: e1a03001 mov r3, r1 <== NOT EXECUTED 30008fd4: e5911000 ldr r1, [r1] <== NOT EXECUTED the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 30008fd8: e3510000 cmp r1, #0 30008fdc: 1afffff0 bne 30008fa4 return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 30008fe0: eb000750 bl 3000ad28 <_Thread_Enable_dispatch> <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) return RTEMS_INVALID_ADDRESS; 30008fe4: e3a00009 mov r0, #9 <== NOT EXECUTED 30008fe8: ea000000 b 30008ff0 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30008fec: e3a00004 mov r0, #4 <== NOT EXECUTED } 30008ff0: e8bd8018 pop {r3, r4, pc} =============================================================================== 30008ff4 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 30008ff4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 30008ff8: e2515000 subs r5, r1, #0 <== NOT EXECUTED rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 30008ffc: e1a04002 mov r4, r2 <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 30009000: 0a000014 beq 30009058 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 30009004: e3520000 cmp r2, #0 <== NOT EXECUTED 30009008: 0a000012 beq 30009058 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 3000900c: e1a0100d mov r1, sp <== NOT EXECUTED 30009010: eb00074c bl 3000ad48 <_Thread_Get> <== NOT EXECUTED switch (location) { 30009014: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30009018: e3530000 cmp r3, #0 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 3000901c: 059030f8 ldreq r3, [r0, #248] ; 0xf8 <== NOT EXECUTED if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 30009020: 0a000009 beq 3000904c <== NOT EXECUTED 30009024: ea00000d b 30009060 <== NOT EXECUTED /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 30009028: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000902c: e1520005 cmp r2, r5 <== NOT EXECUTED 30009030: 1a000004 bne 30009048 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 30009034: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 30009038: e5843000 str r3, [r4] <== NOT EXECUTED _Thread_Enable_dispatch(); 3000903c: eb000739 bl 3000ad28 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30009040: e3a00000 mov r0, #0 <== NOT EXECUTED 30009044: ea000006 b 30009064 <== NOT EXECUTED } tvp = (rtems_task_variable_t *)tvp->next; 30009048: e5933000 ldr r3, [r3] <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 3000904c: e3530000 cmp r3, #0 <== NOT EXECUTED 30009050: 1afffff4 bne 30009028 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 30009054: eb000733 bl 3000ad28 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !ptr ) return RTEMS_INVALID_ADDRESS; if ( !result ) return RTEMS_INVALID_ADDRESS; 30009058: e3a00009 mov r0, #9 <== NOT EXECUTED 3000905c: ea000000 b 30009064 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30009060: e3a00004 mov r0, #4 <== NOT EXECUTED } 30009064: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 3000a6e4 : * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000a6e4: e59f3074 ldr r3, [pc, #116] ; 3000a760 #include rtems_status_code rtems_task_wake_after( rtems_interval ticks ) { 3000a6e8: e92d4030 push {r4, r5, lr} 3000a6ec: e5932000 ldr r2, [r3] 3000a6f0: e1a04000 mov r4, r0 ++level; 3000a6f4: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 3000a6f8: e5832000 str r2, [r3] _Thread_Disable_dispatch(); if ( ticks == 0 ) { 3000a6fc: e3500000 cmp r0, #0 3000a700: 1a000003 bne 3000a714 * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield(); 3000a704: e59f3058 ldr r3, [pc, #88] ; 3000a764 3000a708: e1a0e00f mov lr, pc 3000a70c: e593f00c ldr pc, [r3, #12] 3000a710: ea00000f b 3000a754 _Scheduler_Yield(); } else { _Thread_Set_state( _Thread_Executing, STATES_DELAYING ); 3000a714: e59f504c ldr r5, [pc, #76] ; 3000a768 <== NOT EXECUTED 3000a718: e3a01008 mov r1, #8 <== NOT EXECUTED 3000a71c: e5950008 ldr r0, [r5, #8] <== NOT EXECUTED 3000a720: eb000a3b bl 3000d014 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( &_Thread_Executing->Timer, 3000a724: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 3000a728: e59f003c ldr r0, [pc, #60] ; 3000a76c <== NOT EXECUTED _Thread_Disable_dispatch(); if ( ticks == 0 ) { _Scheduler_Yield(); } else { _Thread_Set_state( _Thread_Executing, STATES_DELAYING ); _Watchdog_Initialize( 3000a72c: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 3000a730: e3a03000 mov r3, #0 <== NOT EXECUTED the_watchdog->routine = routine; 3000a734: e5810064 str r0, [r1, #100] ; 0x64 <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 3000a738: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED the_watchdog->routine = routine; the_watchdog->id = id; 3000a73c: e5812068 str r2, [r1, #104] ; 0x68 <== NOT EXECUTED the_watchdog->user_data = user_data; 3000a740: e581306c str r3, [r1, #108] ; 0x6c <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 3000a744: e5814054 str r4, [r1, #84] ; 0x54 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 3000a748: e59f0020 ldr r0, [pc, #32] ; 3000a770 <== NOT EXECUTED 3000a74c: e2811048 add r1, r1, #72 ; 0x48 <== NOT EXECUTED 3000a750: eb000b06 bl 3000d370 <_Watchdog_Insert> <== NOT EXECUTED _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); } _Thread_Enable_dispatch(); 3000a754: eb000828 bl 3000c7fc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; } 3000a758: e3a00000 mov r0, #0 3000a75c: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000b5c0 : #include rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 3000b5c0: e92d40f0 push {r4, r5, r6, r7, lr} Watchdog_Interval seconds; if ( !_TOD.is_set ) 3000b5c4: e59f60cc ldr r6, [pc, #204] ; 3000b698 #include rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 3000b5c8: e1a04000 mov r4, r0 Watchdog_Interval seconds; if ( !_TOD.is_set ) 3000b5cc: e5d63014 ldrb r3, [r6, #20] 3000b5d0: e3530000 cmp r3, #0 return RTEMS_NOT_DEFINED; 3000b5d4: 03a0000b moveq r0, #11 rtems_time_of_day *time_buffer ) { Watchdog_Interval seconds; if ( !_TOD.is_set ) 3000b5d8: 08bd80f0 popeq {r4, r5, r6, r7, pc} return RTEMS_NOT_DEFINED; if ( !time_buffer ) 3000b5dc: e3540000 cmp r4, #0 return RTEMS_INVALID_ADDRESS; 3000b5e0: 03a00009 moveq r0, #9 Watchdog_Interval seconds; if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; if ( !time_buffer ) 3000b5e4: 08bd80f0 popeq {r4, r5, r6, r7, pc} return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 3000b5e8: e3a05000 mov r5, #0 3000b5ec: e5845018 str r5, [r4, #24] if ( !_TOD_Validate( time_buffer ) ) 3000b5f0: ebfffcfa bl 3000a9e0 <_TOD_Validate> 3000b5f4: e1500005 cmp r0, r5 return RTEMS_INVALID_CLOCK; 3000b5f8: 03a00014 moveq r0, #20 if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; if ( !_TOD_Validate( time_buffer ) ) 3000b5fc: 08bd80f0 popeq {r4, r5, r6, r7, pc} return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 3000b600: e1a00004 mov r0, r4 3000b604: ebfffccd bl 3000a940 <_TOD_To_seconds> static inline uint32_t _Timestamp64_implementation_Get_seconds( const Timestamp64_Control *_time ) { return (uint32_t) (*_time / 1000000000L); 3000b608: e59f208c ldr r2, [pc, #140] ; 3000b69c 3000b60c: e1a07000 mov r7, r0 3000b610: e3a03000 mov r3, #0 3000b614: e8960003 ldm r6, {r0, r1} 3000b618: eb00420d bl 3001be54 <__divdi3> if ( seconds <= _TOD_Seconds_since_epoch() ) 3000b61c: e1570000 cmp r7, r0 3000b620: 9a00001a bls 3000b690 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000b624: e59f3074 ldr r3, [pc, #116] ; 3000b6a0 3000b628: e5932000 ldr r2, [r3] ++level; 3000b62c: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 3000b630: e5832000 str r2, [r3] return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 3000b634: e59f4068 ldr r4, [pc, #104] ; 3000b6a4 3000b638: e3a01010 mov r1, #16 3000b63c: e5940008 ldr r0, [r4, #8] 3000b640: eb000a6d bl 3000dffc <_Thread_Set_state> 3000b644: e8960003 ldm r6, {r0, r1} _Watchdog_Initialize( &_Thread_Executing->Timer, 3000b648: e5944008 ldr r4, [r4, #8] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 3000b64c: e59f2054 ldr r2, [pc, #84] ; 3000b6a8 if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); _Watchdog_Initialize( 3000b650: e5943008 ldr r3, [r4, #8] 3000b654: e5842064 str r2, [r4, #100] ; 0x64 the_watchdog->id = id; 3000b658: e5843068 str r3, [r4, #104] ; 0x68 3000b65c: e59f2038 ldr r2, [pc, #56] ; 3000b69c 3000b660: e3a03000 mov r3, #0 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 3000b664: e5845050 str r5, [r4, #80] ; 0x50 the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 3000b668: e584506c str r5, [r4, #108] ; 0x6c 3000b66c: eb0041f8 bl 3001be54 <__divdi3> &_Thread_Executing->Timer, _Thread_Delay_ended, _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_seconds( 3000b670: e0600007 rsb r0, r0, r7 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 3000b674: e5840054 str r0, [r4, #84] ; 0x54 _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 3000b678: e2841048 add r1, r4, #72 ; 0x48 3000b67c: e59f0028 ldr r0, [pc, #40] ; 3000b6ac 3000b680: eb000b5c bl 3000e3f8 <_Watchdog_Insert> &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 3000b684: eb000856 bl 3000d7e4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000b688: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b68c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 3000b690: e3a00014 mov r0, #20 <== NOT EXECUTED &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 3000b694: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3000a708 : rtems_status_code rtems_timer_create( rtems_name name, rtems_id *id ) { 3000a708: e92d40f0 push {r4, r5, r6, r7, lr} Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 3000a70c: e2506000 subs r6, r0, #0 rtems_status_code rtems_timer_create( rtems_name name, rtems_id *id ) { 3000a710: e1a04001 mov r4, r1 Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 3000a714: 03a00003 moveq r0, #3 rtems_id *id ) { Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 3000a718: 08bd80f0 popeq {r4, r5, r6, r7, pc} return RTEMS_INVALID_NAME; if ( !id ) 3000a71c: e3510000 cmp r1, #0 3000a720: 0a00001b beq 3000a794 * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000a724: e59f3070 ldr r3, [pc, #112] ; 3000a79c 3000a728: e5932000 ldr r2, [r3] ++level; 3000a72c: e2822001 add r2, r2, #1 _Thread_Dispatch_disable_level = level; 3000a730: e5832000 str r2, [r3] * This function allocates a timer control block from * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void ) { return (Timer_Control *) _Objects_Allocate( &_Timer_Information ); 3000a734: e59f5064 ldr r5, [pc, #100] ; 3000a7a0 3000a738: e1a00005 mov r0, r5 3000a73c: eb0003c0 bl 3000b644 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 3000a740: e3500000 cmp r0, #0 3000a744: 1a000002 bne 3000a754 _Thread_Enable_dispatch(); 3000a748: eb000842 bl 3000c858 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 3000a74c: e3a00005 mov r0, #5 <== NOT EXECUTED 3000a750: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED } the_timer->the_class = TIMER_DORMANT; 3000a754: e3a03004 mov r3, #4 3000a758: e5803038 str r3, [r0, #56] ; 0x38 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 3000a75c: e1d010b8 ldrh r1, [r0, #8] 3000a760: e5903008 ldr r3, [r0, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000a764: e595201c ldr r2, [r5, #28] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 3000a768: e3a07000 mov r7, #0 3000a76c: e5807018 str r7, [r0, #24] the_watchdog->routine = routine; 3000a770: e580702c str r7, [r0, #44] ; 0x2c the_watchdog->id = id; 3000a774: e5807030 str r7, [r0, #48] ; 0x30 the_watchdog->user_data = user_data; 3000a778: e5807034 str r7, [r0, #52] ; 0x34 3000a77c: e7820101 str r0, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 3000a780: e580600c str r6, [r0, #12] &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 3000a784: e5843000 str r3, [r4] _Thread_Enable_dispatch(); 3000a788: eb000832 bl 3000c858 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000a78c: e1a00007 mov r0, r7 3000a790: e8bd80f0 pop {r4, r5, r6, r7, pc} if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 3000a794: e3a00009 mov r0, #9 <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 3000a798: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3000a7a4 : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 3000a7a4: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 3000a7a8: e2516000 subs r6, r1, #0 rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 3000a7ac: e1a04000 mov r4, r0 3000a7b0: e1a05002 mov r5, r2 3000a7b4: e1a07003 mov r7, r3 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; 3000a7b8: 03a0000a moveq r0, #10 { Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 3000a7bc: 0a000022 beq 3000a84c return RTEMS_INVALID_NUMBER; if ( !routine ) 3000a7c0: e3520000 cmp r2, #0 return RTEMS_INVALID_ADDRESS; 3000a7c4: 03a00009 moveq r0, #9 ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; if ( !routine ) 3000a7c8: 0a00001f beq 3000a84c RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 3000a7cc: e59f007c ldr r0, [pc, #124] ; 3000a850 3000a7d0: e1a01004 mov r1, r4 3000a7d4: e1a0200d mov r2, sp 3000a7d8: eb0004bd bl 3000bad4 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 3000a7dc: e59d3000 ldr r3, [sp] 3000a7e0: e1a08000 mov r8, r0 3000a7e4: e3530000 cmp r3, #0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000a7e8: 13a00004 movne r0, #4 if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 3000a7ec: 1a000016 bne 3000a84c case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 3000a7f0: e288a010 add sl, r8, #16 3000a7f4: e1a0000a mov r0, sl 3000a7f8: eb000b4a bl 3000d528 <_Watchdog_Remove> uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 3000a7fc: e10f2000 mrs r2, CPSR 3000a800: e3823080 orr r3, r2, #128 ; 0x80 3000a804: e129f003 msr CPSR_fc, r3 /* * 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 ) { 3000a808: e5983018 ldr r3, [r8, #24] 3000a80c: e3530000 cmp r3, #0 3000a810: 0a000001 beq 3000a81c static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000a814: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 3000a818: ea000009 b 3000a844 <== NOT EXECUTED /* * 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; 3000a81c: e5883038 str r3, [r8, #56] ; 0x38 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 3000a820: e5883018 str r3, [r8, #24] the_watchdog->routine = routine; 3000a824: e588502c str r5, [r8, #44] ; 0x2c the_watchdog->id = id; 3000a828: e5884030 str r4, [r8, #48] ; 0x30 the_watchdog->user_data = user_data; 3000a82c: e5887034 str r7, [r8, #52] ; 0x34 3000a830: e129f002 msr CPSR_fc, r2 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 3000a834: e59f0018 ldr r0, [pc, #24] ; 3000a854 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 3000a838: e588601c str r6, [r8, #28] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 3000a83c: e1a0100a mov r1, sl 3000a840: eb000ae1 bl 3000d3cc <_Watchdog_Insert> _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 3000a844: eb000803 bl 3000c858 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000a848: e3a00000 mov r0, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000a84c: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} =============================================================================== 30018d0c : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 30018d0c: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD.is_set ) 30018d10: e59f60dc ldr r6, [pc, #220] ; 30018df4 rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 30018d14: e1a0b003 mov fp, r3 Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD.is_set ) 30018d18: e5d63014 ldrb r3, [r6, #20] rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 30018d1c: e1a0a000 mov sl, r0 Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD.is_set ) 30018d20: e3530000 cmp r3, #0 rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 30018d24: e1a04001 mov r4, r1 30018d28: e1a08002 mov r8, r2 Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; 30018d2c: 03a0000b moveq r0, #11 { Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD.is_set ) 30018d30: 0a00002e beq 30018df0 return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 30018d34: e1a00001 mov r0, r1 30018d38: ebfff4d4 bl 30016090 <_TOD_Validate> 30018d3c: e3500000 cmp r0, #0 30018d40: 0a000029 beq 30018dec return RTEMS_INVALID_CLOCK; if ( !routine ) 30018d44: e3580000 cmp r8, #0 return RTEMS_INVALID_ADDRESS; 30018d48: 03a00009 moveq r0, #9 return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; if ( !routine ) 30018d4c: 0a000027 beq 30018df0 return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 30018d50: e1a00004 mov r0, r4 30018d54: ebfff4a5 bl 30015ff0 <_TOD_To_seconds> 30018d58: e59f2098 ldr r2, [pc, #152] ; 30018df8 30018d5c: e1a07000 mov r7, r0 30018d60: e3a03000 mov r3, #0 30018d64: e8960003 ldm r6, {r0, r1} 30018d68: eb004c83 bl 3002bf7c <__divdi3> if ( seconds <= _TOD_Seconds_since_epoch() ) 30018d6c: e1570000 cmp r7, r0 30018d70: 9a00001d bls 30018dec 30018d74: e59f0080 ldr r0, [pc, #128] ; 30018dfc 30018d78: e1a0100a mov r1, sl 30018d7c: e1a0200d mov r2, sp 30018d80: eb000af9 bl 3001b96c <_Objects_Get> return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018d84: e59d5000 ldr r5, [sp] 30018d88: e1a04000 mov r4, r0 30018d8c: e3550000 cmp r5, #0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30018d90: 13a00004 movne r0, #4 seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018d94: 1a000015 bne 30018df0 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 30018d98: e2849010 add r9, r4, #16 30018d9c: e1a00009 mov r0, r9 30018da0: eb001212 bl 3001d5f0 <_Watchdog_Remove> 30018da4: e8960003 ldm r6, {r0, r1} the_timer->the_class = TIMER_TIME_OF_DAY; 30018da8: e3a03002 mov r3, #2 30018dac: e59f2044 ldr r2, [pc, #68] ; 30018df8 30018db0: e5843038 str r3, [r4, #56] ; 0x38 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 30018db4: e5845018 str r5, [r4, #24] 30018db8: e3a03000 mov r3, #0 the_watchdog->routine = routine; 30018dbc: e584802c str r8, [r4, #44] ; 0x2c the_watchdog->id = id; 30018dc0: e584a030 str sl, [r4, #48] ; 0x30 the_watchdog->user_data = user_data; 30018dc4: e584b034 str fp, [r4, #52] ; 0x34 30018dc8: eb004c6b bl 3002bf7c <__divdi3> _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( 30018dcc: e0600007 rsb r0, r0, r7 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 30018dd0: e584001c str r0, [r4, #28] _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 30018dd4: e1a01009 mov r1, r9 30018dd8: e59f0020 ldr r0, [pc, #32] ; 30018e00 30018ddc: eb0011ac bl 3001d494 <_Watchdog_Insert> &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 30018de0: eb000e64 bl 3001c778 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30018de4: e1a00005 mov r0, r5 30018de8: ea000000 b 30018df0 if ( !routine ) return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 30018dec: e3a00014 mov r0, #20 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30018df0: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} =============================================================================== 30018e04 : rtems_status_code rtems_timer_get_information( rtems_id id, rtems_timer_information *the_info ) { 30018e04: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 30018e08: e2514000 subs r4, r1, #0 <== NOT EXECUTED rtems_status_code rtems_timer_get_information( rtems_id id, rtems_timer_information *the_info ) { 30018e0c: e1a03000 mov r3, r0 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) return RTEMS_INVALID_ADDRESS; 30018e10: 03a00009 moveq r0, #9 <== NOT EXECUTED ) { Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 30018e14: 0a000011 beq 30018e60 <== NOT EXECUTED 30018e18: e59f0044 ldr r0, [pc, #68] ; 30018e64 <== NOT EXECUTED 30018e1c: e1a01003 mov r1, r3 <== NOT EXECUTED 30018e20: e1a0200d mov r2, sp <== NOT EXECUTED 30018e24: eb000ad0 bl 3001b96c <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018e28: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30018e2c: e3550000 cmp r5, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30018e30: 13a00004 movne r0, #4 <== NOT EXECUTED if ( !the_info ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018e34: 1a000009 bne 30018e60 <== NOT EXECUTED case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 30018e38: e5903038 ldr r3, [r0, #56] ; 0x38 <== NOT EXECUTED 30018e3c: e5843000 str r3, [r4] <== NOT EXECUTED the_info->initial = the_timer->Ticker.initial; 30018e40: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 30018e44: e5843004 str r3, [r4, #4] <== NOT EXECUTED the_info->start_time = the_timer->Ticker.start_time; 30018e48: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 30018e4c: e5843008 str r3, [r4, #8] <== NOT EXECUTED the_info->stop_time = the_timer->Ticker.stop_time; 30018e50: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 30018e54: e584300c str r3, [r4, #12] <== NOT EXECUTED _Thread_Enable_dispatch(); 30018e58: eb000e46 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30018e5c: e1a00005 mov r0, r5 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30018e60: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 300194bc : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 300194bc: e92d41f7 push {r0, r1, r2, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 300194c0: e3500000 cmp r0, #0 <== NOT EXECUTED 300194c4: e1a05001 mov r5, r1 <== NOT EXECUTED 300194c8: e1a08002 mov r8, r2 <== NOT EXECUTED 300194cc: 01a07000 moveq r7, r0 <== NOT EXECUTED 300194d0: 0a000004 beq 300194e8 <== NOT EXECUTED ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 300194d4: e59f3148 ldr r3, [pc, #328] ; 30019624 <== NOT EXECUTED 300194d8: e5d37000 ldrb r7, [r3] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 300194dc: e1500007 cmp r0, r7 <== NOT EXECUTED 300194e0: 83a07000 movhi r7, #0 <== NOT EXECUTED 300194e4: 93a07001 movls r7, #1 <== NOT EXECUTED * Make sure the requested priority is valid. The if is * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { 300194e8: e21770ff ands r7, r7, #255 ; 0xff <== NOT EXECUTED 300194ec: 1a000003 bne 30019500 <== NOT EXECUTED if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 300194f0: e3700001 cmn r0, #1 <== NOT EXECUTED return RTEMS_INVALID_PRIORITY; 300194f4: 13a05013 movne r5, #19 <== NOT EXECUTED * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 300194f8: 1a000047 bne 3001961c <== NOT EXECUTED 300194fc: ea000000 b 30019504 <== NOT EXECUTED * Make sure the requested priority is valid. The if is * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { 30019500: e1a07000 mov r7, r0 <== NOT EXECUTED * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 30019504: e59f311c ldr r3, [pc, #284] ; 30019628 <== NOT EXECUTED 30019508: e5932000 ldr r2, [r3] <== NOT EXECUTED ++level; 3001950c: e2822001 add r2, r2, #1 <== NOT EXECUTED _Thread_Dispatch_disable_level = level; 30019510: e5832000 str r2, [r3] <== NOT EXECUTED /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 30019514: e59f4110 ldr r4, [pc, #272] ; 3001962c <== NOT EXECUTED initialized = true; 30019518: e3a03001 mov r3, #1 <== NOT EXECUTED /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 3001951c: e5d46000 ldrb r6, [r4] <== NOT EXECUTED initialized = true; 30019520: e5c43000 strb r3, [r4] <== NOT EXECUTED _Thread_Enable_dispatch(); 30019524: eb000c93 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( tmpInitialized ) 30019528: e3560000 cmp r6, #0 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; 3001952c: 13a0500e movne r5, #14 <== NOT EXECUTED _Thread_Disable_dispatch(); tmpInitialized = initialized; initialized = true; _Thread_Enable_dispatch(); if ( tmpInitialized ) 30019530: 1a000039 bne 3001961c <== NOT EXECUTED * other library rules. For example, if using a TSR written in Ada the * 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( 30019534: e28d3008 add r3, sp, #8 <== NOT EXECUTED 30019538: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3001953c: e1a02005 mov r2, r5 <== NOT EXECUTED 30019540: e3888902 orr r8, r8, #32768 ; 0x8000 <== NOT EXECUTED 30019544: e59f00e4 ldr r0, [pc, #228] ; 30019630 <== NOT EXECUTED 30019548: e1a01007 mov r1, r7 <== NOT EXECUTED 3001954c: e3a03c01 mov r3, #256 ; 0x100 <== NOT EXECUTED 30019550: e58d8000 str r8, [sp] <== NOT EXECUTED 30019554: ebfffb36 bl 30018234 <== NOT EXECUTED /* 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) { 30019558: e2505000 subs r5, r0, #0 <== NOT EXECUTED initialized = false; 3001955c: 15c46000 strbne r6, [r4] <== NOT EXECUTED /* 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) { 30019560: 1a00002d bne 3001961c <== NOT EXECUTED */ #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return NULL; #endif return information->local_table[ index ]; 30019564: e59f30c8 ldr r3, [pc, #200] ; 30019634 <== NOT EXECUTED 30019568: e1dd20b8 ldrh r2, [sp, #8] <== NOT EXECUTED 3001956c: e593301c ldr r3, [r3, #28] <== NOT EXECUTED /* * We work with the TCB pointer, not the ID, so we need to convert * to a TCB pointer from here out. */ ts->thread = (Thread_Control *)_Objects_Get_local_object( 30019570: e1a06004 mov r6, r4 <== NOT EXECUTED 30019574: e7933102 ldr r3, [r3, r2, lsl #2] <== NOT EXECUTED 30019578: e59d7008 ldr r7, [sp, #8] <== NOT EXECUTED 3001957c: e5a63004 str r3, [r6, #4]! <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 30019580: e2843038 add r3, r4, #56 ; 0x38 <== NOT EXECUTED 30019584: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED head->previous = NULL; tail->previous = head; 30019588: e2843034 add r3, r4, #52 ; 0x34 <== NOT EXECUTED 3001958c: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 30019590: e2843070 add r3, r4, #112 ; 0x70 <== NOT EXECUTED 30019594: e584306c str r3, [r4, #108] ; 0x6c <== NOT EXECUTED head->previous = NULL; tail->previous = head; 30019598: e284306c add r3, r4, #108 ; 0x6c <== NOT EXECUTED 3001959c: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 300195a0: e59f3090 ldr r3, [pc, #144] ; 30019638 <== NOT EXECUTED 300195a4: e59f2090 ldr r2, [pc, #144] ; 3001963c <== NOT EXECUTED 300195a8: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300195ac: e5843060 str r3, [r4, #96] ; 0x60 <== NOT EXECUTED /* * Initialize the pointer to the timer schedule method so applications that * do not use the Timer Server do not have to pull it in. */ ts->schedule_operation = _Timer_server_Schedule_operation_method; 300195b0: e59f3088 ldr r3, [pc, #136] ; 30019640 <== NOT EXECUTED { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; head->previous = NULL; 300195b4: e5845038 str r5, [r4, #56] ; 0x38 <== NOT EXECUTED 300195b8: e5843008 str r3, [r4, #8] <== NOT EXECUTED ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot; 300195bc: e59f3080 ldr r3, [pc, #128] ; 30019644 <== NOT EXECUTED 300195c0: e5845070 str r5, [r4, #112] ; 0x70 <== NOT EXECUTED 300195c4: e5933000 ldr r3, [r3] <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 300195c8: e5845014 str r5, [r4, #20] <== NOT EXECUTED 300195cc: e5843040 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED 300195d0: e59f3070 ldr r3, [pc, #112] ; 30019648 <== NOT EXECUTED the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 300195d4: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED 300195d8: e8930003 ldm r3, {r0, r1} <== NOT EXECUTED 300195dc: e3a03000 mov r3, #0 <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 300195e0: e584504c str r5, [r4, #76] ; 0x4c <== NOT EXECUTED the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 300195e4: e5845068 str r5, [r4, #104] ; 0x68 <== NOT EXECUTED void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 300195e8: e584702c str r7, [r4, #44] ; 0x2c <== NOT EXECUTED 300195ec: e5847064 str r7, [r4, #100] ; 0x64 <== NOT EXECUTED 300195f0: eb004a61 bl 3002bf7c <__divdi3> <== NOT EXECUTED ts->active = false; /* * The default timer server is now available. */ _Timer_server = ts; 300195f4: e59f3050 ldr r3, [pc, #80] ; 3001964c <== NOT EXECUTED * do not use the Timer Server do not have to pull it in. */ ts->schedule_operation = _Timer_server_Schedule_operation_method; ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot; ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 300195f8: e5840078 str r0, [r4, #120] ; 0x78 <== NOT EXECUTED _Timer_server = ts; /* * Start the timer server */ status = rtems_task_start( 300195fc: e59f104c ldr r1, [pc, #76] ; 30019650 <== NOT EXECUTED ts->schedule_operation = _Timer_server_Schedule_operation_method; ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot; ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); ts->insert_chain = NULL; 30019600: e584507c str r5, [r4, #124] ; 0x7c <== NOT EXECUTED _Timer_server = ts; /* * Start the timer server */ status = rtems_task_start( 30019604: e1a00007 mov r0, r7 <== NOT EXECUTED ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot; ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); ts->insert_chain = NULL; ts->active = false; 30019608: e5c45080 strb r5, [r4, #128] ; 0x80 <== NOT EXECUTED _Timer_server = ts; /* * Start the timer server */ status = rtems_task_start( 3001960c: e1a02006 mov r2, r6 <== NOT EXECUTED ts->active = false; /* * The default timer server is now available. */ _Timer_server = ts; 30019610: e5836000 str r6, [r3] <== NOT EXECUTED /* * Start the timer server */ status = rtems_task_start( 30019614: ebfffcb6 bl 300188f4 <== NOT EXECUTED 30019618: e1a05000 mov r5, r0 <== NOT EXECUTED initialized = false; } #endif return status; } 3001961c: e1a00005 mov r0, r5 <== NOT EXECUTED 30019620: e8bd81fe pop {r1, r2, r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 30018e98 : */ rtems_status_code rtems_timer_reset( rtems_id id ) { 30018e98: e92d4071 push {r0, r4, r5, r6, lr} 30018e9c: e1a01000 mov r1, r0 30018ea0: e1a0200d mov r2, sp 30018ea4: e59f0078 ldr r0, [pc, #120] ; 30018f24 30018ea8: eb000aaf bl 3001b96c <_Objects_Get> Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018eac: e59d5000 ldr r5, [sp] 30018eb0: e1a06000 mov r6, r0 30018eb4: e3550000 cmp r5, #0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30018eb8: 13a04004 movne r4, #4 Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018ebc: 1a000016 bne 30018f1c case OBJECTS_LOCAL: if ( the_timer->the_class == TIMER_INTERVAL ) { 30018ec0: e5904038 ldr r4, [r0, #56] ; 0x38 30018ec4: e3540000 cmp r4, #0 30018ec8: 1a000006 bne 30018ee8 _Watchdog_Remove( &the_timer->Ticker ); 30018ecc: e2806010 add r6, r0, #16 30018ed0: e1a00006 mov r0, r6 30018ed4: eb0011c5 bl 3001d5f0 <_Watchdog_Remove> _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 30018ed8: e59f0048 ldr r0, [pc, #72] ; 30018f28 30018edc: e1a01006 mov r1, r6 30018ee0: eb00116b bl 3001d494 <_Watchdog_Insert> 30018ee4: ea00000b b 30018f18 } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 30018ee8: e3540001 cmp r4, #1 <== NOT EXECUTED /* * Must be dormant or time of day timer (e.g. TIMER_DORMANT, * TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We * can only reset active interval timers. */ status = RTEMS_NOT_DEFINED; 30018eec: 13a0400b movne r4, #11 <== NOT EXECUTED case OBJECTS_LOCAL: if ( the_timer->the_class == TIMER_INTERVAL ) { _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 30018ef0: 1a000008 bne 30018f18 <== NOT EXECUTED Timer_server_Control *timer_server = _Timer_server; 30018ef4: e59f3030 ldr r3, [pc, #48] ; 30018f2c <== NOT EXECUTED if ( !timer_server ) { _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } #endif _Watchdog_Remove( &the_timer->Ticker ); 30018ef8: e2800010 add r0, r0, #16 <== NOT EXECUTED case OBJECTS_LOCAL: if ( the_timer->the_class == TIMER_INTERVAL ) { _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { Timer_server_Control *timer_server = _Timer_server; 30018efc: e5934000 ldr r4, [r3] <== NOT EXECUTED if ( !timer_server ) { _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } #endif _Watchdog_Remove( &the_timer->Ticker ); 30018f00: eb0011ba bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED (*timer_server->schedule_operation)( timer_server, the_timer ); 30018f04: e1a00004 mov r0, r4 <== NOT EXECUTED 30018f08: e1a01006 mov r1, r6 <== NOT EXECUTED 30018f0c: e1a0e00f mov lr, pc <== NOT EXECUTED 30018f10: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED rtems_id id ) { Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; 30018f14: e1a04005 mov r4, r5 <== NOT EXECUTED * TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We * can only reset active interval timers. */ status = RTEMS_NOT_DEFINED; } _Thread_Enable_dispatch(); 30018f18: eb000e16 bl 3001c778 <_Thread_Enable_dispatch> case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30018f1c: e1a00004 mov r0, r4 30018f20: e8bd8078 pop {r3, r4, r5, r6, pc} =============================================================================== 30018f30 : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 30018f30: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED 30018f34: e1a08003 mov r8, r3 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; 30018f38: e59f30b8 ldr r3, [pc, #184] ; 30018ff8 <== NOT EXECUTED rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 30018f3c: e1a05000 mov r5, r0 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; 30018f40: e5937000 ldr r7, [r3] <== NOT EXECUTED rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 30018f44: e1a04001 mov r4, r1 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) 30018f48: e3570000 cmp r7, #0 <== NOT EXECUTED rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 30018f4c: e1a06002 mov r6, r2 <== NOT EXECUTED Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; 30018f50: 03a0000e moveq r0, #14 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) 30018f54: 0a000026 beq 30018ff4 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !routine ) 30018f58: e3520000 cmp r2, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 30018f5c: 03a00009 moveq r0, #9 <== NOT EXECUTED Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !routine ) 30018f60: 0a000023 beq 30018ff4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 30018f64: e3510000 cmp r1, #0 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 30018f68: 03a0000a moveq r0, #10 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !routine ) return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 30018f6c: 0a000020 beq 30018ff4 <== NOT EXECUTED 30018f70: e59f0084 ldr r0, [pc, #132] ; 30018ffc <== NOT EXECUTED 30018f74: e1a01005 mov r1, r5 <== NOT EXECUTED 30018f78: e1a0200d mov r2, sp <== NOT EXECUTED 30018f7c: eb000a7a bl 3001b96c <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018f80: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30018f84: e1a0a000 mov sl, r0 <== NOT EXECUTED 30018f88: e3530000 cmp r3, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30018f8c: 13a00004 movne r0, #4 <== NOT EXECUTED if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018f90: 1a000017 bne 30018ff4 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 30018f94: e28a0010 add r0, sl, #16 <== NOT EXECUTED 30018f98: eb001194 bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED uint32_t level; #if defined(ARM_MULTILIB_ARCH_V4) uint32_t arm_switch_reg; __asm__ volatile ( 30018f9c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30018fa0: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30018fa4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED /* * 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 ) { 30018fa8: e59a2018 ldr r2, [sl, #24] <== NOT EXECUTED 30018fac: e3520000 cmp r2, #0 <== NOT EXECUTED 30018fb0: 0a000001 beq 30018fbc <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { #if defined(ARM_MULTILIB_ARCH_V4) ARM_SWITCH_REGISTERS; __asm__ volatile ( 30018fb4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 30018fb8: ea00000b b 30018fec <== NOT EXECUTED /* * 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; 30018fbc: e3a01001 mov r1, #1 <== NOT EXECUTED 30018fc0: e58a1038 str r1, [sl, #56] ; 0x38 <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 30018fc4: e58a2018 str r2, [sl, #24] <== NOT EXECUTED the_watchdog->routine = routine; 30018fc8: e58a602c str r6, [sl, #44] ; 0x2c <== NOT EXECUTED the_watchdog->id = id; 30018fcc: e58a5030 str r5, [sl, #48] ; 0x30 <== NOT EXECUTED the_watchdog->user_data = user_data; 30018fd0: e58a8034 str r8, [sl, #52] ; 0x34 <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 30018fd4: e58a401c str r4, [sl, #28] <== NOT EXECUTED 30018fd8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _ISR_Enable( level ); (*timer_server->schedule_operation)( timer_server, the_timer ); 30018fdc: e1a00007 mov r0, r7 <== NOT EXECUTED 30018fe0: e1a0100a mov r1, sl <== NOT EXECUTED 30018fe4: e1a0e00f mov lr, pc <== NOT EXECUTED 30018fe8: e597f004 ldr pc, [r7, #4] <== NOT EXECUTED _Thread_Enable_dispatch(); 30018fec: eb000de1 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30018ff0: e3a00000 mov r0, #0 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30018ff4: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED =============================================================================== 30019000 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 30019000: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED 30019004: e1a0b003 mov fp, r3 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 30019008: e59f30ec ldr r3, [pc, #236] ; 300190fc <== NOT EXECUTED rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 3001900c: e1a09000 mov r9, r0 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 30019010: e5935000 ldr r5, [r3] <== NOT EXECUTED rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 30019014: e1a04001 mov r4, r1 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) 30019018: e3550000 cmp r5, #0 <== NOT EXECUTED rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 3001901c: e1a0a002 mov sl, r2 <== NOT EXECUTED Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; 30019020: 03a0000e moveq r0, #14 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) 30019024: 0a000033 beq 300190f8 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) 30019028: e59f60d0 ldr r6, [pc, #208] ; 30019100 <== NOT EXECUTED 3001902c: e5d63014 ldrb r3, [r6, #20] <== NOT EXECUTED 30019030: e3530000 cmp r3, #0 <== NOT EXECUTED return RTEMS_NOT_DEFINED; 30019034: 03a0000b moveq r0, #11 <== NOT EXECUTED Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) 30019038: 0a00002e beq 300190f8 <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !routine ) 3001903c: e3520000 cmp r2, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 30019040: 03a00009 moveq r0, #9 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !_TOD.is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 30019044: 0a00002b beq 300190f8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 30019048: e1a00001 mov r0, r1 <== NOT EXECUTED 3001904c: ebfff40f bl 30016090 <_TOD_Validate> <== NOT EXECUTED 30019050: e3500000 cmp r0, #0 <== NOT EXECUTED 30019054: 0a000026 beq 300190f4 <== NOT EXECUTED return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 30019058: e1a00004 mov r0, r4 <== NOT EXECUTED 3001905c: ebfff3e3 bl 30015ff0 <_TOD_To_seconds> <== NOT EXECUTED 30019060: e59f209c ldr r2, [pc, #156] ; 30019104 <== NOT EXECUTED 30019064: e1a07000 mov r7, r0 <== NOT EXECUTED 30019068: e3a03000 mov r3, #0 <== NOT EXECUTED 3001906c: e8960003 ldm r6, {r0, r1} <== NOT EXECUTED 30019070: eb004bc1 bl 3002bf7c <__divdi3> <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch() ) 30019074: e1570000 cmp r7, r0 <== NOT EXECUTED 30019078: 9a00001d bls 300190f4 <== NOT EXECUTED 3001907c: e59f0084 ldr r0, [pc, #132] ; 30019108 <== NOT EXECUTED 30019080: e1a01009 mov r1, r9 <== NOT EXECUTED 30019084: e1a0200d mov r2, sp <== NOT EXECUTED 30019088: eb000a37 bl 3001b96c <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 3001908c: e59d8000 ldr r8, [sp] <== NOT EXECUTED 30019090: e1a04000 mov r4, r0 <== NOT EXECUTED 30019094: e3580000 cmp r8, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30019098: 13a00004 movne r0, #4 <== NOT EXECUTED seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 3001909c: 1a000015 bne 300190f8 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 300190a0: e2840010 add r0, r4, #16 <== NOT EXECUTED 300190a4: eb001151 bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED 300190a8: e8960003 ldm r6, {r0, r1} <== NOT EXECUTED the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 300190ac: e3a03003 mov r3, #3 <== NOT EXECUTED 300190b0: e59f204c ldr r2, [pc, #76] ; 30019104 <== NOT EXECUTED 300190b4: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 300190b8: e5848018 str r8, [r4, #24] <== NOT EXECUTED 300190bc: e3a03000 mov r3, #0 <== NOT EXECUTED the_watchdog->routine = routine; 300190c0: e584a02c str sl, [r4, #44] ; 0x2c <== NOT EXECUTED the_watchdog->id = id; 300190c4: e5849030 str r9, [r4, #48] ; 0x30 <== NOT EXECUTED the_watchdog->user_data = user_data; 300190c8: e584b034 str fp, [r4, #52] ; 0x34 <== NOT EXECUTED 300190cc: eb004baa bl 3002bf7c <__divdi3> <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 300190d0: e0600007 rsb r0, r0, r7 <== NOT EXECUTED 300190d4: e584001c str r0, [r4, #28] <== NOT EXECUTED (*timer_server->schedule_operation)( timer_server, the_timer ); 300190d8: e1a01004 mov r1, r4 <== NOT EXECUTED 300190dc: e1a00005 mov r0, r5 <== NOT EXECUTED 300190e0: e1a0e00f mov lr, pc <== NOT EXECUTED 300190e4: e595f004 ldr pc, [r5, #4] <== NOT EXECUTED _Thread_Enable_dispatch(); 300190e8: eb000da2 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 300190ec: e1a00008 mov r0, r8 <== NOT EXECUTED 300190f0: ea000000 b 300190f8 <== NOT EXECUTED if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 300190f4: e3a00014 mov r0, #20 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 300190f8: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED =============================================================================== 3000ab44 : void *rtems_workspace_greedy_allocate( const uintptr_t *block_sizes, size_t block_count ) { 3000ab44: e1a02001 mov r2, r1 <== NOT EXECUTED * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000ab48: e59f102c ldr r1, [pc, #44] ; 3000ab7c <== NOT EXECUTED 3000ab4c: e1a03000 mov r3, r0 <== NOT EXECUTED 3000ab50: e5910000 ldr r0, [r1] <== NOT EXECUTED 3000ab54: e92d4010 push {r4, lr} <== NOT EXECUTED ++level; 3000ab58: e2800001 add r0, r0, #1 <== NOT EXECUTED _Thread_Dispatch_disable_level = level; 3000ab5c: e5810000 str r0, [r1] <== NOT EXECUTED void *opaque; _Thread_Disable_dispatch(); opaque = _Heap_Greedy_allocate( &_Workspace_Area, block_sizes, block_count ); 3000ab60: e59f0018 ldr r0, [pc, #24] ; 3000ab80 <== NOT EXECUTED 3000ab64: e1a01003 mov r1, r3 <== NOT EXECUTED 3000ab68: eb00027e bl 3000b568 <_Heap_Greedy_allocate> <== NOT EXECUTED 3000ab6c: e1a04000 mov r4, r0 <== NOT EXECUTED _Thread_Enable_dispatch(); 3000ab70: eb00084e bl 3000ccb0 <_Thread_Enable_dispatch> <== NOT EXECUTED return opaque; } 3000ab74: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ab78: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000ab84 : * * This rountine increments the thread dispatch level */ RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void) { uint32_t level = _Thread_Dispatch_disable_level; 3000ab84: e59f3020 ldr r3, [pc, #32] ; 3000abac <== NOT EXECUTED void rtems_workspace_greedy_free( void *opaque ) { 3000ab88: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED 3000ab8c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000ab90: e1a01000 mov r1, r0 <== NOT EXECUTED ++level; 3000ab94: e2822001 add r2, r2, #1 <== NOT EXECUTED _Thread_Dispatch_disable_level = level; 3000ab98: e5832000 str r2, [r3] <== NOT EXECUTED _Thread_Disable_dispatch(); _Heap_Greedy_free( &_Workspace_Area, opaque ); 3000ab9c: e59f000c ldr r0, [pc, #12] ; 3000abb0 <== NOT EXECUTED 3000aba0: eb00029e bl 3000b620 <_Heap_Greedy_free> <== NOT EXECUTED _Thread_Enable_dispatch(); } 3000aba4: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED void rtems_workspace_greedy_free( void *opaque ) { _Thread_Disable_dispatch(); _Heap_Greedy_free( &_Workspace_Area, opaque ); _Thread_Enable_dispatch(); 3000aba8: ea000840 b 3000ccb0 <_Thread_Enable_dispatch> <== NOT EXECUTED