=============================================================================== 3000f2c8 : uint32_t TOD_MICROSECONDS_TO_TICKS( uint32_t microseconds ) { return (microseconds / rtems_configuration_get_microseconds_per_tick()); 3000f2c8: e59f300c ldr r3, [pc, #12] ; 3000f2dc <== NOT EXECUTED #include uint32_t TOD_MICROSECONDS_TO_TICKS( uint32_t microseconds ) { 3000f2cc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED return (microseconds / rtems_configuration_get_microseconds_per_tick()); 3000f2d0: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3000f2d4: eb004c64 bl 3002246c <__aeabi_uidiv> <== NOT EXECUTED } 3000f2d8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 3000af1c : uint32_t TOD_MILLISECONDS_TO_TICKS( uint32_t milliseconds ) { return (milliseconds / rtems_configuration_get_milliseconds_per_tick()); 3000af1c: e59f3020 ldr r3, [pc, #32] ; 3000af44 <== NOT EXECUTED #include uint32_t TOD_MILLISECONDS_TO_TICKS( uint32_t milliseconds ) { 3000af20: e92d4010 push {r4, lr} <== NOT EXECUTED return (milliseconds / rtems_configuration_get_milliseconds_per_tick()); 3000af24: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED #include uint32_t TOD_MILLISECONDS_TO_TICKS( uint32_t milliseconds ) { 3000af28: e1a04000 mov r4, r0 <== NOT EXECUTED return (milliseconds / rtems_configuration_get_milliseconds_per_tick()); 3000af2c: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000af30: eb003e86 bl 3001a950 <__aeabi_uidiv> <== NOT EXECUTED 3000af34: e1a01000 mov r1, r0 <== NOT EXECUTED 3000af38: e1a00004 mov r0, r4 <== NOT EXECUTED 3000af3c: eb003e83 bl 3001a950 <__aeabi_uidiv> <== NOT EXECUTED } 3000af40: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3001d3e0 : #include #include uint32_t TOD_TICKS_PER_SECOND_method(void) { return (TOD_MICROSECONDS_PER_SECOND / 3001d3e0: e59f3010 ldr r3, [pc, #16] ; 3001d3f8 <== NOT EXECUTED #include #include #include uint32_t TOD_TICKS_PER_SECOND_method(void) { 3001d3e4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED return (TOD_MICROSECONDS_PER_SECOND / 3001d3e8: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3001d3ec: e59f0008 ldr r0, [pc, #8] ; 3001d3fc <== NOT EXECUTED 3001d3f0: ebfff59b bl 3001aa64 <__aeabi_uidiv> <== NOT EXECUTED rtems_configuration_get_microseconds_per_tick()); } 3001d3f4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 30011b8c <_Barrier_Translate_core_barrier_return_code>: #if defined(RTEMS_DEBUG) if ( the_barrier_status > CORE_BARRIER_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Barrier_Translate_core_barrier_return_code_[the_barrier_status]; } 30011b8c: e59f3004 ldr r3, [pc, #4] ; 30011b98 <_Barrier_Translate_core_barrier_return_code+0xc><== NOT EXECUTED 30011b90: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 30011b94: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 30011200 <_CORE_barrier_Release>: #else Objects_Id id __attribute__((unused)), CORE_barrier_API_mp_support_callout api_barrier_mp_support __attribute__((unused)) #endif ) { 30011200: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 30011204: e1a05000 mov r5, r0 <== NOT EXECUTED Thread_Control *the_thread; uint32_t count; count = 0; 30011208: e3a04000 mov r4, #0 <== NOT EXECUTED while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 3001120c: ea000000 b 30011214 <_CORE_barrier_Release+0x14> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_barrier_mp_support) ( the_thread, id ); #endif count++; 30011210: e2844001 add r4, r4, #1 <== NOT EXECUTED { Thread_Control *the_thread; uint32_t count; count = 0; while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 30011214: e1a00005 mov r0, r5 <== NOT EXECUTED 30011218: ebfff1b3 bl 3000d8ec <_Thread_queue_Dequeue> <== NOT EXECUTED 3001121c: e3500000 cmp r0, #0 <== NOT EXECUTED 30011220: 1afffffa bne 30011210 <_CORE_barrier_Release+0x10> <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_barrier_mp_support) ( the_thread, id ); #endif count++; } the_barrier->number_of_waiting_threads = 0; 30011224: e5850048 str r0, [r5, #72] ; 0x48 <== NOT EXECUTED return count; } 30011228: e1a00004 mov r0, r4 <== NOT EXECUTED 3001122c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 30011230 <_CORE_barrier_Wait>: ) { Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 30011230: e59fc078 ldr ip, [pc, #120] ; 300112b0 <_CORE_barrier_Wait+0x80><== NOT EXECUTED Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 30011234: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 30011238: e59cc004 ldr ip, [ip, #4] <== NOT EXECUTED executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 3001123c: e3a04000 mov r4, #0 <== NOT EXECUTED 30011240: e58c4034 str r4, [ip, #52] ; 0x34 <== NOT EXECUTED Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 30011244: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 30011248: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3001124c: e3845080 orr r5, r4, #128 ; 0x80 <== NOT EXECUTED 30011250: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED ISR_Level level; executing = _Thread_Executing; executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; _ISR_Disable( level ); the_barrier->number_of_waiting_threads++; 30011254: e5905048 ldr r5, [r0, #72] ; 0x48 <== NOT EXECUTED if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 30011258: e5906040 ldr r6, [r0, #64] ; 0x40 <== NOT EXECUTED ISR_Level level; executing = _Thread_Executing; executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; _ISR_Disable( level ); the_barrier->number_of_waiting_threads++; 3001125c: e2855001 add r5, r5, #1 <== NOT EXECUTED if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 30011260: e3560000 cmp r6, #0 <== NOT EXECUTED ISR_Level level; executing = _Thread_Executing; executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; _ISR_Disable( level ); the_barrier->number_of_waiting_threads++; 30011264: e5805048 str r5, [r0, #72] ; 0x48 <== NOT EXECUTED if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 30011268: 1a000007 bne 3001128c <_CORE_barrier_Wait+0x5c> <== NOT EXECUTED if ( the_barrier->number_of_waiting_threads == 3001126c: e5906044 ldr r6, [r0, #68] ; 0x44 <== NOT EXECUTED 30011270: e1550006 cmp r5, r6 <== NOT EXECUTED 30011274: 1a000004 bne 3001128c <_CORE_barrier_Wait+0x5c> <== NOT EXECUTED the_barrier->Attributes.maximum_count) { executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; 30011278: e3a03001 mov r3, #1 <== NOT EXECUTED 3001127c: e58c3034 str r3, [ip, #52] ; 0x34 <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 30011280: 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 ); } 30011284: e8bd4070 pop {r4, r5, r6, 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 ); 30011288: eaffffdc b 30011200 <_CORE_barrier_Release> <== NOT EXECUTED 3001128c: e3a02001 mov r2, #1 <== NOT EXECUTED 30011290: e5802030 str r2, [r0, #48] ; 0x30 <== NOT EXECUTED return; } } _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; 30011294: e58c0044 str r0, [ip, #68] ; 0x44 <== NOT EXECUTED executing->Wait.id = id; 30011298: e58c1020 str r1, [ip, #32] <== NOT EXECUTED 3001129c: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 300112a0: e59f200c ldr r2, [pc, #12] ; 300112b4 <_CORE_barrier_Wait+0x84><== NOT EXECUTED 300112a4: e1a01003 mov r1, r3 <== NOT EXECUTED } 300112a8: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED _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 ); 300112ac: eafff1e9 b 3000da58 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED =============================================================================== 300191e4 <_CORE_message_queue_Broadcast>: { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 300191e4: 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 ) { 300191e8: 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 ) { 300191ec: 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 ) { 300191f0: e1a06000 mov r6, r0 300191f4: e1a0a001 mov sl, r1 300191f8: e1a07002 mov r7, r2 300191fc: 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 ) { 30019200: 8a000013 bhi 30019254 <_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 ) { 30019204: e5905048 ldr r5, [r0, #72] ; 0x48 30019208: e3550000 cmp r5, #0 *count = 0; 3001920c: 13a00000 movne r0, #0 30019210: 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 ) { 30019214: 0a000007 beq 30019238 <_CORE_message_queue_Broadcast+0x54> 30019218: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 3001921c: e594002c ldr r0, [r4, #44] ; 0x2c 30019220: e1a0100a mov r1, sl 30019224: e1a02007 mov r2, r7 30019228: eb001e1a bl 30020a98 buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 3001922c: 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; 30019230: e2855001 add r5, r5, #1 buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 30019234: 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 = 30019238: e1a00006 mov r0, r6 3001923c: eb000a87 bl 3001bc60 <_Thread_queue_Dequeue> 30019240: e2504000 subs r4, r0, #0 30019244: 1afffff4 bne 3001921c <_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; 30019248: e5885000 str r5, [r8] return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 3001924c: e1a00004 mov r0, r4 30019250: 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; 30019254: e3a00001 mov r0, #1 <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 30019258: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED =============================================================================== 300121e8 <_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 ) { 300121e8: e92d40f0 push {r4, r5, r6, r7, lr} /* * Round size up to multiple of a pointer for chain init and * check for overflow on adding overhead to each message. */ allocated_message_size = maximum_message_size; if (allocated_message_size & (sizeof(uint32_t) - 1)) { 300121ec: 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 ) { 300121f0: e1a04000 mov r4, r0 size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; the_message_queue->number_of_pending_messages = 0; 300121f4: 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 ) { 300121f8: e1a06002 mov r6, r2 size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 300121fc: e5842044 str r2, [r4, #68] ; 0x44 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 ) { 30012200: e1a05001 mov r5, r1 size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; the_message_queue->number_of_pending_messages = 0; 30012204: e5840048 str r0, [r4, #72] ; 0x48 the_message_queue->maximum_message_size = maximum_message_size; 30012208: e584304c str r3, [r4, #76] ; 0x4c /* * Round size up to multiple of a pointer for chain init and * check for overflow on adding overhead to each message. */ allocated_message_size = maximum_message_size; if (allocated_message_size & (sizeof(uint32_t) - 1)) { 3001220c: 01a02003 moveq r2, r3 30012210: 0a000003 beq 30012224 <_CORE_message_queue_Initialize+0x3c> allocated_message_size += sizeof(uint32_t); 30012214: e2832004 add r2, r3, #4 <== NOT EXECUTED allocated_message_size &= ~(sizeof(uint32_t) - 1); 30012218: e3c22003 bic r2, r2, #3 <== NOT EXECUTED } if (allocated_message_size < maximum_message_size) 3001221c: e1520003 cmp r2, r3 <== NOT EXECUTED 30012220: 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. */ message_buffering_required = (size_t) maximum_pending_messages * (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); 30012224: e2827010 add r7, r2, #16 /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * 30012228: e0000796 mul r0, r6, r7 (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 3001222c: e1500002 cmp r0, r2 return false; 30012230: 33a00000 movcc r0, #0 * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 30012234: 38bd80f0 popcc {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 ); 30012238: eb000b17 bl 30014e9c <_Workspace_Allocate> if (the_message_queue->message_buffers == 0) 3001223c: e3500000 cmp r0, #0 /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); 30012240: e1a01000 mov r1, r0 return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 30012244: e584005c str r0, [r4, #92] ; 0x5c _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 30012248: 0a000013 beq 3001229c <_CORE_message_queue_Initialize+0xb4> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 3001224c: e2840060 add r0, r4, #96 ; 0x60 30012250: e1a02006 mov r2, r6 30012254: e1a03007 mov r3, r7 30012258: eb001252 bl 30016ba8 <_Chain_Initialize> 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 ); 3001225c: e2843054 add r3, r4, #84 ; 0x54 head->next = tail; 30012260: e5843050 str r3, [r4, #80] ; 0x50 head->previous = NULL; 30012264: e3a03000 mov r3, #0 30012268: e5843054 str r3, [r4, #84] ; 0x54 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 3001226c: e2843050 add r3, r4, #80 ; 0x50 Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; head->previous = NULL; tail->previous = head; 30012270: e5843058 str r3, [r4, #88] ; 0x58 allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 30012274: e5951000 ldr r1, [r5] 30012278: e1a00004 mov r0, r4 3001227c: e3510001 cmp r1, #1 30012280: 13a01000 movne r1, #0 30012284: 03a01001 moveq r1, #1 30012288: e3a02080 mov r2, #128 ; 0x80 3001228c: e3a03006 mov r3, #6 30012290: eb0008b3 bl 30014564 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 30012294: e3a00001 mov r0, #1 30012298: e8bd80f0 pop {r4, r5, r6, r7, pc} } 3001229c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3001238c <_CORE_message_queue_Submit>: ) { CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 3001238c: e590304c ldr r3, [r0, #76] ; 0x4c #endif CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 30012390: 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 ) { 30012394: e1520003 cmp r2, r3 #endif CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 30012398: e1a04000 mov r4, r0 3001239c: e1a0a001 mov sl, r1 300123a0: e1a05002 mov r5, r2 300123a4: 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; 300123a8: 83a00001 movhi r0, #1 ) { CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 300123ac: 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 ) { 300123b0: e5948048 ldr r8, [r4, #72] ; 0x48 300123b4: e3580000 cmp r8, #0 300123b8: 1a00000b bne 300123ec <_CORE_message_queue_Submit+0x60> the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 300123bc: eb000769 bl 30014168 <_Thread_queue_Dequeue> if ( the_thread ) { 300123c0: e2506000 subs r6, r0, #0 300123c4: 0a000008 beq 300123ec <_CORE_message_queue_Submit+0x60> const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 300123c8: e596002c ldr r0, [r6, #44] ; 0x2c 300123cc: e1a0100a mov r1, sl 300123d0: e1a02005 mov r2, r5 300123d4: eb001b84 bl 300191ec _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 300123d8: 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; 300123dc: 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; 300123e0: e5835000 str r5, [r3] the_thread->Wait.count = (uint32_t) submit_type; 300123e4: 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; 300123e8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 300123ec: e5942048 ldr r2, [r4, #72] ; 0x48 300123f0: e5943044 ldr r3, [r4, #68] ; 0x44 300123f4: e1520003 cmp r2, r3 300123f8: 2a00000d bcs 30012434 <_CORE_message_queue_Submit+0xa8> _CORE_message_queue_Allocate_message_buffer ( CORE_message_queue_Control *the_message_queue ) { return (CORE_message_queue_Buffer_control *) _Chain_Get( &the_message_queue->Inactive_messages ); 300123fc: e2840060 add r0, r4, #96 ; 0x60 30012400: ebffff61 bl 3001218c <_Chain_Get> const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 30012404: e1a0100a mov r1, sl _CORE_message_queue_Allocate_message_buffer ( CORE_message_queue_Control *the_message_queue ) { return (CORE_message_queue_Buffer_control *) _Chain_Get( &the_message_queue->Inactive_messages ); 30012408: e1a06000 mov r6, r0 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 3001240c: e1a02005 mov r2, r5 30012410: e280000c add r0, r0, #12 30012414: eb001b74 bl 300191ec size ); the_message->Contents.size = size; _CORE_message_queue_Set_message_priority( the_message, submit_type ); _CORE_message_queue_Insert_message( 30012418: e1a00004 mov r0, r4 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 3001241c: e5865008 str r5, [r6, #8] _CORE_message_queue_Set_message_priority( the_message, submit_type ); _CORE_message_queue_Insert_message( 30012420: e1a01006 mov r1, r6 30012424: e1a02007 mov r2, r7 30012428: eb0011ee bl 30016be8 <_CORE_message_queue_Insert_message> the_message_queue, the_message, submit_type ); return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 3001242c: e3a00000 mov r0, #0 30012430: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} } #if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND) return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY; 30012434: e3a00002 mov r0, #2 <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 30012438: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED =============================================================================== 30009f58 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 30009f58: e92d40f0 push {r4, r5, r6, r7, lr} 30009f5c: e1a07003 mov r7, r3 _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 30009f60: e59f30ac ldr r3, [pc, #172] ; 3000a014 <_CORE_mutex_Seize+0xbc> Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 30009f64: e1a04000 mov r4, r0 _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 30009f68: e5933000 ldr r3, [r3] Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 30009f6c: e1a05001 mov r5, r1 _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 30009f70: e3530000 cmp r3, #0 Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 30009f74: e20260ff and r6, r2, #255 ; 0xff _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 30009f78: 0a000008 beq 30009fa0 <_CORE_mutex_Seize+0x48> 30009f7c: e3560000 cmp r6, #0 30009f80: 0a000006 beq 30009fa0 <_CORE_mutex_Seize+0x48> 30009f84: e59f308c ldr r3, [pc, #140] ; 3000a018 <_CORE_mutex_Seize+0xc0> 30009f88: e5933000 ldr r3, [r3] 30009f8c: e3530001 cmp r3, #1 30009f90: 83a00000 movhi r0, #0 30009f94: 81a01000 movhi r1, r0 30009f98: 83a02012 movhi r2, #18 30009f9c: 8b0001bf blhi 3000a6a0 <_Internal_error_Occurred> 30009fa0: e1a00004 mov r0, r4 30009fa4: e28d1014 add r1, sp, #20 30009fa8: eb001164 bl 3000e540 <_CORE_mutex_Seize_interrupt_trylock> 30009fac: e3500000 cmp r0, #0 30009fb0: 08bd80f0 popeq {r4, r5, r6, r7, pc} 30009fb4: e3560000 cmp r6, #0 30009fb8: e59f305c ldr r3, [pc, #92] ; 3000a01c <_CORE_mutex_Seize+0xc4> 30009fbc: 1a000005 bne 30009fd8 <_CORE_mutex_Seize+0x80> 30009fc0: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 30009fc4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 30009fc8: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30009fcc: e3a02001 mov r2, #1 <== NOT EXECUTED 30009fd0: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED 30009fd4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED 30009fd8: e5933004 ldr r3, [r3, #4] 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; 30009fdc: e3a02001 mov r2, #1 30009fe0: e5842030 str r2, [r4, #48] ; 0x30 30009fe4: e5834044 str r4, [r3, #68] ; 0x44 30009fe8: e5835020 str r5, [r3, #32] 30009fec: e59f3020 ldr r3, [pc, #32] ; 3000a014 <_CORE_mutex_Seize+0xbc> 30009ff0: e5932000 ldr r2, [r3] 30009ff4: e2822001 add r2, r2, #1 30009ff8: e5832000 str r2, [r3] 30009ffc: e59d3014 ldr r3, [sp, #20] 3000a000: e129f003 msr CPSR_fc, r3 3000a004: e1a00004 mov r0, r4 3000a008: e1a01007 mov r1, r7 3000a00c: ebffffb8 bl 30009ef4 <_CORE_mutex_Seize_interrupt_blocking> 3000a010: e8bd80f0 pop {r4, r5, r6, r7, pc} =============================================================================== 3000e540 <_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 ) { 3000e540: e1a03000 mov r3, r0 { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 3000e544: e59f210c ldr r2, [pc, #268] ; 3000e658 <_CORE_mutex_Seize_interrupt_trylock+0x118> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 3000e548: 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; 3000e54c: e3a00000 mov r0, #0 { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 3000e550: e5922004 ldr r2, [r2, #4] executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 3000e554: e15c0000 cmp ip, r0 3000e558: e92d4010 push {r4, lr} Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 3000e55c: e5820034 str r0, [r2, #52] ; 0x34 if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 3000e560: 0a00002c beq 3000e618 <_CORE_mutex_Seize_interrupt_trylock+0xd8> the_mutex->lock = CORE_MUTEX_LOCKED; 3000e564: e5830050 str r0, [r3, #80] ; 0x50 the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 3000e568: 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; 3000e56c: e583205c str r2, [r3, #92] ; 0x5c the_mutex->holder_id = executing->Object.id; 3000e570: e5830060 str r0, [r3, #96] ; 0x60 the_mutex->nest_count = 1; 3000e574: e3a00001 mov r0, #1 3000e578: e5830054 str r0, [r3, #84] ; 0x54 return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 3000e57c: e5930048 ldr r0, [r3, #72] ; 0x48 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 3000e580: e3500002 cmp r0, #2 3000e584: 0a000001 beq 3000e590 <_CORE_mutex_Seize_interrupt_trylock+0x50> 3000e588: e3500003 cmp r0, #3 3000e58c: 1a000004 bne 3000e5a4 <_CORE_mutex_Seize_interrupt_trylock+0x64> _Chain_Prepend_unprotected( &executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = executing->current_priority; #endif executing->resource_count++; 3000e590: e592c01c ldr ip, [r2, #28] } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 3000e594: 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++; 3000e598: e28c4001 add r4, ip, #1 3000e59c: e582401c str r4, [r2, #28] } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 3000e5a0: 0a000000 beq 3000e5a8 <_CORE_mutex_Seize_interrupt_trylock+0x68> _ISR_Enable( *level_p ); 3000e5a4: ea000025 b 3000e640 <_CORE_mutex_Seize_interrupt_trylock+0x100> */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 3000e5a8: e593004c ldr r0, [r3, #76] ; 0x4c current = executing->current_priority; 3000e5ac: e5924014 ldr r4, [r2, #20] if ( current == ceiling ) { 3000e5b0: e1540000 cmp r4, r0 3000e5b4: 1a000000 bne 3000e5bc <_CORE_mutex_Seize_interrupt_trylock+0x7c> _ISR_Enable( *level_p ); 3000e5b8: ea000020 b 3000e640 <_CORE_mutex_Seize_interrupt_trylock+0x100><== NOT EXECUTED return 0; } if ( current > ceiling ) { 3000e5bc: 9a00000b bls 3000e5f0 <_CORE_mutex_Seize_interrupt_trylock+0xb0> rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 3000e5c0: e59f2094 ldr r2, [pc, #148] ; 3000e65c <_CORE_mutex_Seize_interrupt_trylock+0x11c><== NOT EXECUTED 3000e5c4: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000e5c8: e2800001 add r0, r0, #1 <== NOT EXECUTED 3000e5cc: e5820000 str r0, [r2] <== NOT EXECUTED 3000e5d0: e5912000 ldr r2, [r1] <== NOT EXECUTED 3000e5d4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( *level_p ); _Thread_Change_priority( 3000e5d8: e3a02000 mov r2, #0 <== NOT EXECUTED 3000e5dc: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED 3000e5e0: e593104c ldr r1, [r3, #76] ; 0x4c <== NOT EXECUTED 3000e5e4: ebfff377 bl 3000b3c8 <_Thread_Change_priority> <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, false ); _Thread_Enable_dispatch(); 3000e5e8: ebfff479 bl 3000b7d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 3000e5ec: ea000015 b 3000e648 <_CORE_mutex_Seize_interrupt_trylock+0x108><== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 3000e5f0: e3a00005 mov r0, #5 3000e5f4: e5820034 str r0, [r2, #52] ; 0x34 the_mutex->lock = CORE_MUTEX_UNLOCKED; 3000e5f8: e3a00001 mov r0, #1 3000e5fc: e5830050 str r0, [r3, #80] ; 0x50 the_mutex->nest_count = 0; /* undo locking above */ 3000e600: e3a00000 mov r0, #0 3000e604: e5830054 str r0, [r3, #84] ; 0x54 executing->resource_count--; /* undo locking above */ 3000e608: e582c01c str ip, [r2, #28] 3000e60c: e5913000 ldr r3, [r1] 3000e610: e129f003 msr CPSR_fc, r3 3000e614: 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 ) ) { 3000e618: e593005c ldr r0, [r3, #92] ; 0x5c 3000e61c: e1500002 cmp r0, r2 /* * The mutex is not available and the caller must deal with the possibility * of blocking. */ return 1; 3000e620: 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 ) ) { 3000e624: 18bd8010 popne {r4, pc} switch ( the_mutex->Attributes.lock_nesting_behavior ) { 3000e628: e5932040 ldr r2, [r3, #64] ; 0x40 3000e62c: e3520000 cmp r2, #0 3000e630: 1a000006 bne 3000e650 <_CORE_mutex_Seize_interrupt_trylock+0x110> case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 3000e634: e5932054 ldr r2, [r3, #84] ; 0x54 3000e638: e2822001 add r2, r2, #1 3000e63c: e5832054 str r2, [r3, #84] ; 0x54 3000e640: e5913000 ldr r3, [r1] 3000e644: e129f003 msr CPSR_fc, r3 _ISR_Enable( *level_p ); return 0; 3000e648: e3a00000 mov r0, #0 3000e64c: e8bd8010 pop {r4, pc} /* * The mutex is not available and the caller must deal with the possibility * of blocking. */ return 1; 3000e650: e3a00001 mov r0, #1 3000e654: e8bd8010 pop {r4, pc} =============================================================================== 3000a020 <_CORE_mutex_Surrender>: #else Objects_Id id __attribute__((unused)), CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused)) #endif ) { 3000a020: e92d4030 push {r4, r5, lr} 3000a024: 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 ) { 3000a028: e5d43044 ldrb r3, [r4, #68] ; 0x44 ) { Thread_Control *the_thread; Thread_Control *holder; holder = the_mutex->holder; 3000a02c: 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 ) { 3000a030: e3530000 cmp r3, #0 3000a034: 0a000004 beq 3000a04c <_CORE_mutex_Surrender+0x2c> RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 3000a038: e59f30ec ldr r3, [pc, #236] ; 3000a12c <_CORE_mutex_Surrender+0x10c> if ( !_Thread_Is_executing( holder ) ) 3000a03c: e5933004 ldr r3, [r3, #4] 3000a040: e1500003 cmp r0, r3 return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; 3000a044: 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 ) ) 3000a048: 1a000035 bne 3000a124 <_CORE_mutex_Surrender+0x104> return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 3000a04c: e5945054 ldr r5, [r4, #84] ; 0x54 3000a050: e3550000 cmp r5, #0 3000a054: 0a000032 beq 3000a124 <_CORE_mutex_Surrender+0x104> return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 3000a058: e2455001 sub r5, r5, #1 if ( the_mutex->nest_count != 0 ) { 3000a05c: e3550000 cmp r5, #0 /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 3000a060: 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; 3000a064: 13a05000 movne r5, #0 if ( !the_mutex->nest_count ) return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; if ( the_mutex->nest_count != 0 ) { 3000a068: 1a00002d bne 3000a124 <_CORE_mutex_Surrender+0x104> } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 3000a06c: 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 ) || 3000a070: e3530002 cmp r3, #2 3000a074: 0a000001 beq 3000a080 <_CORE_mutex_Surrender+0x60> 3000a078: e3530003 cmp r3, #3 3000a07c: 1a000009 bne 3000a0a8 <_CORE_mutex_Surrender+0x88> _CORE_mutex_Pop_priority( the_mutex, holder ); if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL ) return pop_status; holder->resource_count--; 3000a080: e590301c ldr r3, [r0, #28] 3000a084: 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 && 3000a088: e3530000 cmp r3, #0 _CORE_mutex_Pop_priority( the_mutex, holder ); if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL ) return pop_status; holder->resource_count--; 3000a08c: 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 && 3000a090: 1a000004 bne 3000a0a8 <_CORE_mutex_Surrender+0x88> holder->real_priority != holder->current_priority ) { 3000a094: 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 && 3000a098: e5903014 ldr r3, [r0, #20] 3000a09c: e1510003 cmp r1, r3 holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, true ); 3000a0a0: 13a02001 movne r2, #1 3000a0a4: 1b0004c7 blne 3000b3c8 <_Thread_Change_priority> } } the_mutex->holder = NULL; 3000a0a8: e3a05000 mov r5, #0 3000a0ac: e584505c str r5, [r4, #92] ; 0x5c the_mutex->holder_id = 0; 3000a0b0: 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 ) ) ) { 3000a0b4: e1a00004 mov r0, r4 3000a0b8: eb000683 bl 3000bacc <_Thread_queue_Dequeue> 3000a0bc: e2503000 subs r3, r0, #0 } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 3000a0c0: 03a02001 moveq r2, #1 3000a0c4: 05842050 streq r2, [r4, #80] ; 0x50 return CORE_MUTEX_STATUS_SUCCESSFUL; 3000a0c8: 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 ) ) ) { 3000a0cc: 0a000014 beq 3000a124 <_CORE_mutex_Surrender+0x104> } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 3000a0d0: e5932008 ldr r2, [r3, #8] } else #endif { the_mutex->holder = the_thread; 3000a0d4: e584305c str r3, [r4, #92] ; 0x5c the_mutex->holder_id = the_thread->Object.id; 3000a0d8: e5842060 str r2, [r4, #96] ; 0x60 the_mutex->nest_count = 1; 3000a0dc: e3a02001 mov r2, #1 3000a0e0: e5842054 str r2, [r4, #84] ; 0x54 switch ( the_mutex->Attributes.discipline ) { 3000a0e4: e5942048 ldr r2, [r4, #72] ; 0x48 3000a0e8: 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++; 3000a0ec: 0593201c ldreq r2, [r3, #28] 3000a0f0: 02822001 addeq r2, r2, #1 3000a0f4: 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 ) { 3000a0f8: 0a000009 beq 3000a124 <_CORE_mutex_Surrender+0x104> 3000a0fc: e3520003 cmp r2, #3 <== NOT EXECUTED 3000a100: 1a000007 bne 3000a124 <_CORE_mutex_Surrender+0x104> <== 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++; 3000a104: e593201c ldr r2, [r3, #28] <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 3000a108: 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++; 3000a10c: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000a110: e583201c str r2, [r3, #28] <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 3000a114: e5933014 ldr r3, [r3, #20] <== NOT EXECUTED 3000a118: e1510003 cmp r1, r3 <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 3000a11c: 31a02005 movcc r2, r5 <== NOT EXECUTED 3000a120: 3b0004a8 blcc 3000b3c8 <_Thread_Change_priority> <== NOT EXECUTED } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 3000a124: e1a00005 mov r0, r5 3000a128: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000a730 <_Chain_Append_with_empty_check>: bool _Chain_Append_with_empty_check( Chain_Control *chain, Chain_Node *node ) { 3000a730: e92d4010 push {r4, lr} <== NOT EXECUTED 3000a734: e1a03000 mov r3, r0 <== NOT EXECUTED 3000a738: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000a73c: e3842080 orr r2, r4, #128 ; 0x80 <== NOT EXECUTED 3000a740: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 3000a744: e5932008 ldr r2, [r3, #8] <== 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 ); 3000a748: 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 ) 3000a74c: e5900000 ldr r0, [r0] <== NOT EXECUTED { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 3000a750: e5831008 str r1, [r3, #8] <== NOT EXECUTED ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; the_node->next = tail; 3000a754: e581c000 str ip, [r1] <== NOT EXECUTED tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last; 3000a758: e5812004 str r2, [r1, #4] <== NOT EXECUTED 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; 3000a75c: e5821000 str r1, [r2] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) 3000a760: e150000c cmp r0, ip <== NOT EXECUTED 3000a764: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a768: 03a00001 moveq r0, #1 <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000a76c: 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; } 3000a770: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000a7c0 <_Chain_Get_with_empty_check>: bool _Chain_Get_with_empty_check( Chain_Control *chain, Chain_Node **node ) { 3000a7c0: e92d4010 push {r4, lr} <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000a7c4: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000a7c8: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000a7cc: 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; 3000a7d0: 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 ); 3000a7d4: e280c004 add ip, r0, #4 <== NOT EXECUTED Chain_Node *old_first = head->next; if ( old_first != tail ) { 3000a7d8: e152000c cmp r2, ip <== NOT EXECUTED *the_node = old_first; is_empty_now = new_first == tail; } else *the_node = NULL; 3000a7dc: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000a7e0: 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; 3000a7e4: 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 ) { 3000a7e8: 0a000006 beq 3000a808 <_Chain_Get_with_empty_check+0x48> <== NOT EXECUTED Chain_Node *new_first = old_first->next; 3000a7ec: e5923000 ldr r3, [r2] <== NOT EXECUTED head->next = new_first; 3000a7f0: e5803000 str r3, [r0] <== NOT EXECUTED new_first->previous = head; 3000a7f4: e5830004 str r0, [r3, #4] <== NOT EXECUTED *the_node = old_first; 3000a7f8: e5812000 str r2, [r1] <== NOT EXECUTED is_empty_now = new_first == tail; 3000a7fc: e153000c cmp r3, ip <== NOT EXECUTED 3000a800: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a804: 03a00001 moveq r0, #1 <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000a808: 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; } 3000a80c: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000a86c <_Chain_Prepend_with_empty_check>: static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000a86c: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000a870: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000a874: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _ISR_Disable( level ); was_empty = _Chain_Prepend_with_empty_check_unprotected( chain, node ); _ISR_Enable( level ); return was_empty; } 3000a878: e5903000 ldr r3, [r0] <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 3000a87c: e5810004 str r0, [r1, #4] <== NOT EXECUTED before_node = after_node->next; after_node->next = the_node; 3000a880: e4801004 str r1, [r0], #4 <== NOT EXECUTED the_node->next = before_node; before_node->previous = the_node; 3000a884: 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; 3000a888: e5813000 str r3, [r1] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000a88c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 3000a890: e1530000 cmp r3, r0 <== NOT EXECUTED 3000a894: 13a00000 movne r0, #0 <== NOT EXECUTED 3000a898: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000a89c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 30008f48 <_Event_Seize>: rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Thread_blocking_operation_States sync_state; executing = _Thread_Executing; 30008f48: e59fc0f8 ldr ip, [pc, #248] ; 30009048 <_Event_Seize+0x100> rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 30008f4c: e92d40f0 push {r4, r5, r6, r7, lr} rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Thread_blocking_operation_States sync_state; executing = _Thread_Executing; 30008f50: e59c4004 ldr r4, [ip, #4] executing->Wait.return_code = RTEMS_SUCCESSFUL; 30008f54: e3a0c000 mov ip, #0 30008f58: e584c034 str ip, [r4, #52] ; 0x34 api = executing->API_Extensions[ THREAD_API_RTEMS ]; 30008f5c: e59470f4 ldr r7, [r4, #244] ; 0xf4 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 30008f60: e10f5000 mrs r5, CPSR 30008f64: e385c080 orr ip, r5, #128 ; 0x80 30008f68: e129f00c msr CPSR_fc, ip _ISR_Disable( level ); pending_events = api->pending_events; 30008f6c: e5976000 ldr r6, [r7] seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 30008f70: e010c006 ands ip, r0, r6 30008f74: 0a000007 beq 30008f98 <_Event_Seize+0x50> 30008f78: e15c0000 cmp ip, r0 30008f7c: 0a000001 beq 30008f88 <_Event_Seize+0x40> (seized_events == event_in || _Options_Is_any( option_set )) ) { 30008f80: e3110002 tst r1, #2 <== NOT EXECUTED 30008f84: 0a000003 beq 30008f98 <_Event_Seize+0x50> <== 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) ); 30008f88: e1c6600c bic r6, r6, ip api->pending_events = 30008f8c: e5876000 str r6, [r7] static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 30008f90: e129f005 msr CPSR_fc, r5 30008f94: ea000004 b 30008fac <_Event_Seize+0x64> _ISR_Enable( level ); *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 30008f98: e3110001 tst r1, #1 30008f9c: 0a000004 beq 30008fb4 <_Event_Seize+0x6c> 30008fa0: e129f005 msr CPSR_fc, r5 _ISR_Enable( level ); executing->Wait.return_code = RTEMS_UNSATISFIED; 30008fa4: e3a0200d mov r2, #13 30008fa8: e5842034 str r2, [r4, #52] ; 0x34 *event_out = seized_events; 30008fac: e583c000 str ip, [r3] return; 30008fb0: e8bd80f0 pop {r4, r5, r6, r7, pc} * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = (uint32_t) option_set; executing->Wait.count = (uint32_t) event_in; executing->Wait.return_argument = event_out; 30008fb4: e5843028 str r3, [r4, #40] ; 0x28 _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 30008fb8: e59f308c ldr r3, [pc, #140] ; 3000904c <_Event_Seize+0x104> * 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 = (uint32_t) option_set; 30008fbc: e5841030 str r1, [r4, #48] ; 0x30 executing->Wait.count = (uint32_t) event_in; executing->Wait.return_argument = event_out; _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 30008fc0: e3a01001 mov r1, #1 * * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = (uint32_t) option_set; executing->Wait.count = (uint32_t) event_in; 30008fc4: e5840024 str r0, [r4, #36] ; 0x24 executing->Wait.return_argument = event_out; _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 30008fc8: e5831000 str r1, [r3] 30008fcc: e129f005 msr CPSR_fc, r5 _ISR_Enable( level ); if ( ticks ) { 30008fd0: e3520000 cmp r2, #0 30008fd4: 0a00000a beq 30009004 <_Event_Seize+0xbc> _Watchdog_Initialize( 30008fd8: e5941008 ldr r1, [r4, #8] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 30008fdc: e59f006c ldr r0, [pc, #108] ; 30009050 <_Event_Seize+0x108> Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 30008fe0: e3a03000 mov r3, #0 the_watchdog->routine = routine; 30008fe4: e5840064 str r0, [r4, #100] ; 0x64 the_watchdog->id = id; 30008fe8: e5841068 str r1, [r4, #104] ; 0x68 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 30008fec: e5843050 str r3, [r4, #80] ; 0x50 the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 30008ff0: e584306c str r3, [r4, #108] ; 0x6c Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 30008ff4: e5842054 str r2, [r4, #84] ; 0x54 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 30008ff8: e59f0054 ldr r0, [pc, #84] ; 30009054 <_Event_Seize+0x10c> 30008ffc: e2841048 add r1, r4, #72 ; 0x48 30009000: eb000d43 bl 3000c514 <_Watchdog_Insert> NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 30009004: e1a00004 mov r0, r4 30009008: e3a01c01 mov r1, #256 ; 0x100 3000900c: eb000bf3 bl 3000bfe0 <_Thread_Set_state> static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 30009010: e10f2000 mrs r2, CPSR 30009014: e3823080 orr r3, r2, #128 ; 0x80 30009018: e129f003 msr CPSR_fc, r3 _ISR_Disable( level ); sync_state = _Event_Sync_state; 3000901c: e59f3028 ldr r3, [pc, #40] ; 3000904c <_Event_Seize+0x104> _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 30009020: e3a01000 mov r1, #0 _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); _ISR_Disable( level ); sync_state = _Event_Sync_state; 30009024: e5930000 ldr r0, [r3] _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 30009028: e5831000 str r1, [r3] if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 3000902c: e3500001 cmp r0, #1 30009030: 1a000001 bne 3000903c <_Event_Seize+0xf4> static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 30009034: e129f002 msr CPSR_fc, r2 30009038: e8bd80f0 pop {r4, r5, r6, r7, pc} * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 3000903c: e1a01004 mov r1, r4 <== NOT EXECUTED } 30009040: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 30009044: ea0008cc b 3000b37c <_Thread_blocking_operation_Cancel> <== NOT EXECUTED =============================================================================== 300090a8 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 300090a8: e92d40f0 push {r4, r5, r6, r7, lr} rtems_event_set event_condition; rtems_event_set seized_events; rtems_option option_set; RTEMS_API_Control *api; api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 300090ac: e590c0f4 ldr ip, [r0, #244] ; 0xf4 option_set = (rtems_option) the_thread->Wait.option; 300090b0: e5905030 ldr r5, [r0, #48] ; 0x30 */ void _Event_Surrender( Thread_Control *the_thread ) { 300090b4: e1a04000 mov r4, r0 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 300090b8: e10f3000 mrs r3, CPSR 300090bc: e3832080 orr r2, r3, #128 ; 0x80 300090c0: e129f002 msr CPSR_fc, r2 api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; option_set = (rtems_option) the_thread->Wait.option; _ISR_Disable( level ); pending_events = api->pending_events; 300090c4: e59c1000 ldr r1, [ip] event_condition = (rtems_event_set) the_thread->Wait.count; 300090c8: e5900024 ldr r0, [r0, #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 ) ) { 300090cc: e0102001 ands r2, r0, r1 300090d0: 1a000000 bne 300090d8 <_Event_Surrender+0x30> _ISR_Enable( level ); 300090d4: ea000039 b 300091c0 <_Event_Surrender+0x118> /* * 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() && 300090d8: e59f60e8 ldr r6, [pc, #232] ; 300091c8 <_Event_Surrender+0x120> 300090dc: e5967000 ldr r7, [r6] 300090e0: e3570000 cmp r7, #0 300090e4: 0a000017 beq 30009148 <_Event_Surrender+0xa0> 300090e8: e5966004 ldr r6, [r6, #4] <== NOT EXECUTED 300090ec: e1540006 cmp r4, r6 <== NOT EXECUTED 300090f0: 1a000014 bne 30009148 <_Event_Surrender+0xa0> <== NOT EXECUTED _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 300090f4: e59f60d0 ldr r6, [pc, #208] ; 300091cc <_Event_Surrender+0x124><== NOT EXECUTED 300090f8: e5967000 ldr r7, [r6] <== 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 ) && 300090fc: e3570002 cmp r7, #2 <== NOT EXECUTED 30009100: 0a000002 beq 30009110 <_Event_Surrender+0x68> <== NOT EXECUTED ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 30009104: e5966000 ldr r6, [r6] <== 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 ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 30009108: e3560001 cmp r6, #1 <== NOT EXECUTED 3000910c: 1a00000d bne 30009148 <_Event_Surrender+0xa0> <== NOT EXECUTED (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 30009110: e1520000 cmp r2, r0 <== NOT EXECUTED 30009114: 0a000001 beq 30009120 <_Event_Surrender+0x78> <== NOT EXECUTED 30009118: e3150002 tst r5, #2 <== NOT EXECUTED 3000911c: 0a000008 beq 30009144 <_Event_Surrender+0x9c> <== 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) ); 30009120: e1c11002 bic r1, r1, r2 <== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 30009124: e58c1000 str r1, [ip] <== NOT EXECUTED the_thread->Wait.count = 0; 30009128: e3a01000 mov r1, #0 <== NOT EXECUTED 3000912c: e5841024 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 30009130: e5941028 ldr r1, [r4, #40] ; 0x28 <== NOT EXECUTED 30009134: e5812000 str r2, [r1] <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 30009138: e59f208c ldr r2, [pc, #140] ; 300091cc <_Event_Surrender+0x124><== NOT EXECUTED 3000913c: e3a01003 mov r1, #3 <== NOT EXECUTED 30009140: e5821000 str r1, [r2] <== NOT EXECUTED } _ISR_Enable( level ); 30009144: ea00001d b 300091c0 <_Event_Surrender+0x118> <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event ( States_Control the_states ) { return (the_states & STATES_WAITING_FOR_EVENT); 30009148: e5946010 ldr r6, [r4, #16] } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 3000914c: e3160c01 tst r6, #256 ; 0x100 30009150: 0a00001a beq 300091c0 <_Event_Surrender+0x118> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 30009154: e1520000 cmp r2, r0 30009158: 0a000001 beq 30009164 <_Event_Surrender+0xbc> 3000915c: e3150002 tst r5, #2 <== NOT EXECUTED 30009160: 0a000016 beq 300091c0 <_Event_Surrender+0x118> <== NOT EXECUTED 30009164: e1c11002 bic r1, r1, r2 api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 30009168: e58c1000 str r1, [ip] the_thread->Wait.count = 0; 3000916c: e3a01000 mov r1, #0 30009170: e5841024 str r1, [r4, #36] ; 0x24 *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 30009174: e5941028 ldr r1, [r4, #40] ; 0x28 30009178: e5812000 str r2, [r1] static inline void arm_interrupt_flash( uint32_t level ) { uint32_t arm_switch_reg; __asm__ volatile ( 3000917c: e10f2000 mrs r2, CPSR 30009180: e129f003 msr CPSR_fc, r3 30009184: e129f002 msr CPSR_fc, r2 _ISR_Flash( level ); if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 30009188: e5942050 ldr r2, [r4, #80] ; 0x50 3000918c: e3520002 cmp r2, #2 30009190: 0a000001 beq 3000919c <_Event_Surrender+0xf4> static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 30009194: e129f003 msr CPSR_fc, r3 30009198: ea000004 b 300091b0 <_Event_Surrender+0x108> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 3000919c: e3a02003 mov r2, #3 <== NOT EXECUTED 300091a0: e5842050 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED 300091a4: 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 ); 300091a8: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 300091ac: eb000d30 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 300091b0: e59f1018 ldr r1, [pc, #24] ; 300091d0 <_Event_Surrender+0x128> 300091b4: e1a00004 mov r0, r4 } return; } } _ISR_Enable( level ); } 300091b8: e8bd40f0 pop {r4, r5, r6, r7, lr} 300091bc: ea0008c0 b 3000b4c4 <_Thread_Clear_state> 300091c0: e129f003 msr CPSR_fc, r3 300091c4: e8bd80f0 pop {r4, r5, r6, r7, pc} =============================================================================== 300091d4 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 300091d4: e92d4001 push {r0, lr} <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 300091d8: e1a0100d mov r1, sp <== NOT EXECUTED 300091dc: eb000985 bl 3000b7f8 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 300091e0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 300091e4: e3530000 cmp r3, #0 <== NOT EXECUTED 300091e8: 1a000015 bne 30009244 <_Event_Timeout+0x70> <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 300091ec: e10f2000 mrs r2, CPSR <== NOT EXECUTED 300091f0: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 300091f4: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 300091f8: 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 ); 300091fc: e59f3044 ldr r3, [pc, #68] ; 30009248 <_Event_Timeout+0x74><== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) { 30009200: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30009204: e1500003 cmp r0, r3 <== NOT EXECUTED 30009208: 1a000004 bne 30009220 <_Event_Timeout+0x4c> <== NOT EXECUTED if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 3000920c: e59f3038 ldr r3, [pc, #56] ; 3000924c <_Event_Timeout+0x78><== NOT EXECUTED 30009210: e5931000 ldr r1, [r3] <== NOT EXECUTED 30009214: e3510001 cmp r1, #1 <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 30009218: 02811001 addeq r1, r1, #1 <== NOT EXECUTED 3000921c: 05831000 streq r1, [r3] <== NOT EXECUTED } the_thread->Wait.return_code = RTEMS_TIMEOUT; 30009220: e3a03006 mov r3, #6 <== NOT EXECUTED 30009224: e5803034 str r3, [r0, #52] ; 0x34 <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 30009228: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 3000922c: e59f101c ldr r1, [pc, #28] ; 30009250 <_Event_Timeout+0x7c><== NOT EXECUTED 30009230: eb0008a3 bl 3000b4c4 <_Thread_Clear_state> <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 30009234: e59f3018 ldr r3, [pc, #24] ; 30009254 <_Event_Timeout+0x80><== NOT EXECUTED 30009238: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000923c: e2422001 sub r2, r2, #1 <== NOT EXECUTED 30009240: e5832000 str r2, [r3] <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 30009244: e8bd8008 pop {r3, pc} <== NOT EXECUTED =============================================================================== 3000e6bc <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 3000e6bc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} 3000e6c0: 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; 3000e6c4: e5902010 ldr r2, [r0, #16] Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 3000e6c8: e24dd01c sub sp, sp, #28 3000e6cc: 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 ) { 3000e6d0: e2913004 adds r3, r1, #4 Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 3000e6d4: e1a05000 mov r5, r0 3000e6d8: 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; 3000e6dc: 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 ) { 3000e6e0: e58d300c str r3, [sp, #12] 3000e6e4: 2a00006a bcs 3000e894 <_Heap_Allocate_aligned_with_boundary+0x1d8> /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 3000e6e8: e35b0000 cmp fp, #0 3000e6ec: 0a000003 beq 3000e700 <_Heap_Allocate_aligned_with_boundary+0x44> if ( boundary < alloc_size ) { 3000e6f0: e15b0001 cmp fp, r1 <== NOT EXECUTED 3000e6f4: 3a000066 bcc 3000e894 <_Heap_Allocate_aligned_with_boundary+0x1d8><== NOT EXECUTED return NULL; } if ( alignment == 0 ) { alignment = page_size; 3000e6f8: e3580000 cmp r8, #0 <== NOT EXECUTED 3000e6fc: 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 3000e700: e59d2000 ldr r2, [sp] + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; 3000e704: 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 3000e708: e2822007 add r2, r2, #7 if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 3000e70c: 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 ) { 3000e710: 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 3000e714: e58d2014 str r2, [sp, #20] + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; 3000e718: 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 ) { 3000e71c: ea000048 b 3000e844 <_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 ) { 3000e720: e59a4004 ldr r4, [sl, #4] 3000e724: e59d200c ldr r2, [sp, #12] 3000e728: e1540002 cmp r4, r2 3000e72c: 9a00003f bls 3000e830 <_Heap_Allocate_aligned_with_boundary+0x174> 3000e730: e28a3008 add r3, sl, #8 if ( alignment == 0 ) { 3000e734: e3580000 cmp r8, #0 3000e738: e58d3008 str r3, [sp, #8] RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 3000e73c: 01a04003 moveq r4, r3 3000e740: 0a00003b beq 3000e834 <_Heap_Allocate_aligned_with_boundary+0x178> uintptr_t alignment, uintptr_t boundary ) { uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; 3000e744: e5952014 ldr r2, [r5, #20] 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; 3000e748: e59d3014 ldr r3, [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; 3000e74c: e58d2004 str r2, [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; 3000e750: e0629003 rsb r9, r2, r3 - 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; 3000e754: e3c44001 bic r4, r4, #1 uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; uintptr_t alloc_begin = alloc_end - alloc_size; 3000e758: e59d2018 ldr r2, [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; 3000e75c: 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 3000e760: 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; 3000e764: e0824004 add r4, r2, r4 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 3000e768: e1a00004 mov r0, r4 3000e76c: e1a01008 mov r1, r8 3000e770: eb00150c bl 30013ba8 <__umodsi3> 3000e774: 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 ) { 3000e778: e1540009 cmp r4, r9 3000e77c: 9a000003 bls 3000e790 <_Heap_Allocate_aligned_with_boundary+0xd4> 3000e780: e1a00009 mov r0, r9 <== NOT EXECUTED 3000e784: e1a01008 mov r1, r8 <== NOT EXECUTED 3000e788: eb001506 bl 30013ba8 <__umodsi3> <== NOT EXECUTED 3000e78c: e0604009 rsb r4, r0, r9 <== NOT EXECUTED } alloc_end = alloc_begin + alloc_size; /* Ensure boundary constaint */ if ( boundary != 0 ) { 3000e790: e35b0000 cmp fp, #0 3000e794: 0a000014 beq 3000e7ec <_Heap_Allocate_aligned_with_boundary+0x130> uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; 3000e798: e59d3008 ldr r3, [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; 3000e79c: e0849006 add r9, r4, r6 <== NOT EXECUTED /* Ensure boundary constaint */ if ( boundary != 0 ) { uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; 3000e7a0: e0833006 add r3, r3, r6 <== NOT EXECUTED 3000e7a4: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 3000e7a8: ea000008 b 3000e7d0 <_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 ) { 3000e7ac: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3000e7b0: e1500002 cmp r0, r2 <== NOT EXECUTED 3000e7b4: 3a00001d bcc 3000e830 <_Heap_Allocate_aligned_with_boundary+0x174><== NOT EXECUTED return 0; } alloc_begin = boundary_line - alloc_size; 3000e7b8: e0664000 rsb r4, r6, r0 <== NOT EXECUTED 3000e7bc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000e7c0: e1a01008 mov r1, r8 <== NOT EXECUTED 3000e7c4: eb0014f7 bl 30013ba8 <__umodsi3> <== NOT EXECUTED 3000e7c8: e0604004 rsb r4, r0, r4 <== NOT EXECUTED alloc_begin = _Heap_Align_down( alloc_begin, alignment ); alloc_end = alloc_begin + alloc_size; 3000e7cc: e0849006 add r9, r4, r6 <== NOT EXECUTED 3000e7d0: e1a00009 mov r0, r9 <== NOT EXECUTED 3000e7d4: e1a0100b mov r1, fp <== NOT EXECUTED 3000e7d8: eb0014f2 bl 30013ba8 <__umodsi3> <== NOT EXECUTED 3000e7dc: 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 ) { 3000e7e0: e1500009 cmp r0, r9 <== NOT EXECUTED 3000e7e4: 31540000 cmpcc r4, r0 <== NOT EXECUTED 3000e7e8: 3affffef bcc 3000e7ac <_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 ) { 3000e7ec: e59d3008 ldr r3, [sp, #8] 3000e7f0: e1540003 cmp r4, r3 3000e7f4: 3a00000d bcc 3000e830 <_Heap_Allocate_aligned_with_boundary+0x174> 3000e7f8: e1a00004 mov r0, r4 3000e7fc: e59d1000 ldr r1, [sp] 3000e800: eb0014e8 bl 30013ba8 <__umodsi3> 3000e804: e3e09007 mvn r9, #7 3000e808: 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); 3000e80c: e0899004 add r9, r9, r4 if ( free_size >= min_block_size || free_size == 0 ) { return alloc_begin; } } return 0; 3000e810: 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 ) { 3000e814: e0603009 rsb r3, r0, r9 return alloc_begin; } } return 0; 3000e818: e1590000 cmp r9, r0 3000e81c: 11530002 cmpne r3, r2 3000e820: 33a09000 movcc r9, #0 3000e824: 23a09001 movcs r9, #1 3000e828: 31a04009 movcc r4, r9 3000e82c: ea000000 b 3000e834 <_Heap_Allocate_aligned_with_boundary+0x178> 3000e830: e3a04000 mov r4, #0 } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 3000e834: e3540000 cmp r4, #0 ); } } /* Statistics */ ++search_count; 3000e838: e2877001 add r7, r7, #1 if ( alloc_begin != 0 ) { 3000e83c: 1a000004 bne 3000e854 <_Heap_Allocate_aligned_with_boundary+0x198> break; } block = block->next; 3000e840: 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 ) { 3000e844: e15a0005 cmp sl, r5 3000e848: 1affffb4 bne 3000e720 <_Heap_Allocate_aligned_with_boundary+0x64> 3000e84c: e3a04000 mov r4, #0 3000e850: ea00000a b 3000e880 <_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; 3000e854: e5953048 ldr r3, [r5, #72] ; 0x48 stats->searches += search_count; block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 3000e858: e1a00005 mov r0, r5 search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin ); } while ( search_again ); if ( alloc_begin != 0 ) { /* Statistics */ ++stats->allocs; 3000e85c: e2833001 add r3, r3, #1 3000e860: e5853048 str r3, [r5, #72] ; 0x48 stats->searches += search_count; 3000e864: e595304c ldr r3, [r5, #76] ; 0x4c block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 3000e868: e1a0100a mov r1, sl } while ( search_again ); if ( alloc_begin != 0 ) { /* Statistics */ ++stats->allocs; stats->searches += search_count; 3000e86c: e0833007 add r3, r3, r7 3000e870: e585304c str r3, [r5, #76] ; 0x4c block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 3000e874: e1a02004 mov r2, r4 3000e878: e1a03006 mov r3, r6 3000e87c: ebffef3c bl 3000a574 <_Heap_Block_allocate> boundary ); } /* Statistics */ if ( stats->max_search < search_count ) { 3000e880: e5953044 ldr r3, [r5, #68] ; 0x44 stats->max_search = search_count; } return (void *) alloc_begin; 3000e884: e1a00004 mov r0, r4 boundary ); } /* Statistics */ if ( stats->max_search < search_count ) { 3000e888: e1530007 cmp r3, r7 stats->max_search = search_count; 3000e88c: 35857044 strcc r7, [r5, #68] ; 0x44 } return (void *) alloc_begin; 3000e890: ea000000 b 3000e898 <_Heap_Allocate_aligned_with_boundary+0x1dc> return NULL; } if ( boundary != 0 ) { if ( boundary < alloc_size ) { return NULL; 3000e894: e3a00000 mov r0, #0 if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 3000e898: e28dd01c add sp, sp, #28 3000e89c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} =============================================================================== 3000a574 <_Heap_Block_allocate>: Heap_Control *heap, Heap_Block *block, uintptr_t alloc_begin, uintptr_t alloc_size ) { 3000a574: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} } _Heap_Protection_block_initialize( heap, block ); return block; } 3000a578: 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; 3000a57c: e2426008 sub r6, r2, #8 Heap_Control *heap, Heap_Block *block, uintptr_t alloc_begin, uintptr_t alloc_size ) { 3000a580: e1a04001 mov r4, r1 3000a584: 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; 3000a588: 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; 3000a58c: 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); 3000a590: e0849001 add r9, r4, r1 Heap_Control *heap, Heap_Block *block, uintptr_t alloc_begin, uintptr_t alloc_size ) { 3000a594: 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; 3000a598: e5990004 ldr r0, [r9, #4] Heap_Block *free_list_anchor = NULL; _HAssert( alloc_area_begin <= alloc_begin ); if ( _Heap_Is_free( block ) ) { 3000a59c: 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 ); 3000a5a0: 11a08005 movne r8, r5 Heap_Block *free_list_anchor = NULL; _HAssert( alloc_area_begin <= alloc_begin ); if ( _Heap_Is_free( block ) ) { 3000a5a4: 1a00000c bne 3000a5dc <_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; 3000a5a8: e5940008 ldr r0, [r4, #8] free_list_anchor = block->prev; 3000a5ac: e594800c ldr r8, [r4, #12] Heap_Block *prev = block->prev; prev->next = next; 3000a5b0: e5880008 str r0, [r8, #8] next->prev = prev; 3000a5b4: e580800c str r8, [r0, #12] _Heap_Free_list_remove( block ); /* Statistics */ --stats->free_blocks; 3000a5b8: e5950038 ldr r0, [r5, #56] ; 0x38 3000a5bc: e2400001 sub r0, r0, #1 3000a5c0: e5850038 str r0, [r5, #56] ; 0x38 ++stats->used_blocks; 3000a5c4: e5950040 ldr r0, [r5, #64] ; 0x40 3000a5c8: e2800001 add r0, r0, #1 3000a5cc: e5850040 str r0, [r5, #64] ; 0x40 stats->free_size -= _Heap_Block_size( block ); 3000a5d0: e5950030 ldr r0, [r5, #48] ; 0x30 3000a5d4: e0611000 rsb r1, r1, r0 3000a5d8: e5851030 str r1, [r5, #48] ; 0x30 } else { free_list_anchor = _Heap_Free_list_head( heap ); } if ( alloc_area_offset < heap->page_size ) { 3000a5dc: e5951010 ldr r1, [r5, #16] 3000a5e0: e1530001 cmp r3, r1 3000a5e4: 2a000005 bcs 3000a600 <_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 ); 3000a5e8: e1a00005 mov r0, r5 3000a5ec: e1a01004 mov r1, r4 3000a5f0: e1a02008 mov r2, r8 3000a5f4: e0833007 add r3, r3, r7 3000a5f8: ebffff31 bl 3000a2c4 <_Heap_Block_split> 3000a5fc: ea000021 b 3000a688 <_Heap_Block_allocate+0x114> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 3000a600: e1a00002 mov r0, r2 3000a604: eb002567 bl 30013ba8 <__umodsi3> _HAssert( block_size >= heap->min_block_size ); _HAssert( new_block_size >= heap->min_block_size ); /* Statistics */ stats->free_size += block_size; 3000a608: 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); 3000a60c: 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; 3000a610: 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; 3000a614: e0822003 add r2, r2, r3 if ( _Heap_Is_prev_used( block ) ) { 3000a618: 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; 3000a61c: 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; 3000a620: e5852030 str r2, [r5, #48] ; 0x30 if ( _Heap_Is_prev_used( block ) ) { 3000a624: 0a000009 beq 3000a650 <_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; 3000a628: e5982008 ldr r2, [r8, #8] new_block->next = next; new_block->prev = block_before; 3000a62c: e584800c str r8, [r4, #12] Heap_Block *new_block ) { Heap_Block *next = block_before->next; new_block->next = next; 3000a630: e5842008 str r2, [r4, #8] new_block->prev = block_before; block_before->next = new_block; next->prev = new_block; 3000a634: e582400c str r4, [r2, #12] _Heap_Free_list_insert_after( free_list_anchor, block ); free_list_anchor = block; /* Statistics */ ++stats->free_blocks; 3000a638: 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; 3000a63c: e5884008 str r4, [r8, #8] 3000a640: e2822001 add r2, r2, #1 3000a644: e5852038 str r2, [r5, #56] ; 0x38 3000a648: e1a02004 mov r2, r4 3000a64c: ea000005 b 3000a668 <_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); 3000a650: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000a654: 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; 3000a658: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000a65c: 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; 3000a660: e0833002 add r3, r3, r2 <== NOT EXECUTED 3000a664: e1a02008 mov r2, r8 <== NOT EXECUTED } block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 3000a668: e3831001 orr r1, r3, #1 3000a66c: e5841004 str r1, [r4, #4] new_block->prev_size = block_size; 3000a670: e8860208 stm r6, {r3, r9} new_block->size_and_flag = new_block_size; _Heap_Block_split( heap, new_block, free_list_anchor, alloc_size ); 3000a674: e1a00005 mov r0, r5 3000a678: e1a01006 mov r1, r6 3000a67c: e1a03007 mov r3, r7 3000a680: ebffff0f bl 3000a2c4 <_Heap_Block_split> 3000a684: e1a04006 mov r4, r6 alloc_size ); } /* Statistics */ if ( stats->min_free_size > stats->free_size ) { 3000a688: e5953030 ldr r3, [r5, #48] ; 0x30 3000a68c: e5952034 ldr r2, [r5, #52] ; 0x34 } _Heap_Protection_block_initialize( heap, block ); return block; } 3000a690: e1a00004 mov r0, r4 alloc_size ); } /* Statistics */ if ( stats->min_free_size > stats->free_size ) { 3000a694: e1520003 cmp r2, r3 stats->min_free_size = stats->free_size; 3000a698: 85853034 strhi r3, [r5, #52] ; 0x34 } _Heap_Protection_block_initialize( heap, block ); return block; } 3000a69c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} =============================================================================== 3000a2c4 <_Heap_Block_split>: Heap_Control *heap, Heap_Block *block, Heap_Block *free_list_anchor, uintptr_t alloc_size ) { 3000a2c4: 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; 3000a2c8: e5908014 ldr r8, [r0, #20] uintptr_t alloc_size ) { Heap_Statistics *const stats = &heap->stats; uintptr_t const page_size = heap->page_size; 3000a2cc: 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; 3000a2d0: 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; 3000a2d4: e153000b cmp r3, fp 3000a2d8: 21a0b003 movcs fp, r3 uintptr_t const block_size = _Heap_Block_size( block ); uintptr_t const used_size = 3000a2dc: e28bb008 add fp, fp, #8 Heap_Control *heap, Heap_Block *block, Heap_Block *free_list_anchor, uintptr_t alloc_size ) { 3000a2e0: e1a05001 mov r5, r1 } _Heap_Protection_block_initialize( heap, block ); return block; } 3000a2e4: e5919004 ldr r9, [r1, #4] Heap_Control *heap, Heap_Block *block, Heap_Block *free_list_anchor, uintptr_t alloc_size ) { 3000a2e8: e1a04000 mov r4, r0 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 3000a2ec: e1a0100a mov r1, sl 3000a2f0: e1a0000b mov r0, fp 3000a2f4: e1a06002 mov r6, r2 3000a2f8: eb00262a bl 30013ba8 <__umodsi3> - 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; 3000a2fc: e3c97001 bic r7, r9, #1 uintptr_t alignment ) { uintptr_t remainder = value % alignment; if ( remainder != 0 ) { 3000a300: 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; 3000a304: e2872004 add r2, r7, #4 return value - remainder + alignment; 3000a308: 108ba00a addne sl, fp, sl } else { return value; 3000a30c: 01a0a00b moveq sl, fp uintptr_t const free_size_limit = min_block_size + HEAP_ALLOC_BONUS; 3000a310: 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; 3000a314: e06bb002 rsb fp, fp, r2 ) { uintptr_t remainder = value % alignment; if ( remainder != 0 ) { return value - remainder + alignment; 3000a318: 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); 3000a31c: 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 ) { 3000a320: 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; 3000a324: 35932004 ldrcc r2, [r3, #4] 3000a328: 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 ) { 3000a32c: 3a000023 bcc 3000a3c0 <_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; 3000a330: 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; 3000a334: 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; 3000a338: 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); 3000a33c: 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; 3000a340: e18aa009 orr sl, sl, r9 3000a344: 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; 3000a348: e0811007 add r1, r1, r7 3000a34c: 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; 3000a350: e5931004 ldr r1, [r3, #4] 3000a354: e3c11001 bic r1, r1, #1 } _Heap_Protection_block_initialize( heap, block ); return block; } 3000a358: e0830001 add r0, r3, r1 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; 3000a35c: e5900004 ldr r0, [r0, #4] _Heap_Block_set_size( block, used_block_size ); /* Statistics */ stats->free_size += free_block_size; if ( _Heap_Is_used( next_block ) ) { 3000a360: e3100001 tst r0, #1 3000a364: 0a000008 beq 3000a38c <_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; 3000a368: e5961008 ldr r1, [r6, #8] new_block->next = next; new_block->prev = block_before; 3000a36c: e582600c str r6, [r2, #12] Heap_Block *new_block ) { Heap_Block *next = block_before->next; new_block->next = next; 3000a370: e5821008 str r1, [r2, #8] new_block->prev = block_before; block_before->next = new_block; next->prev = new_block; 3000a374: e581200c str r2, [r1, #12] _Heap_Free_list_insert_after( free_list_anchor, free_block ); /* Statistics */ ++stats->free_blocks; 3000a378: 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; 3000a37c: e5862008 str r2, [r6, #8] 3000a380: e2811001 add r1, r1, #1 3000a384: e5841038 str r1, [r4, #56] ; 0x38 3000a388: ea000007 b 3000a3ac <_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; 3000a38c: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED Heap_Block *prev = old_block->prev; 3000a390: 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; 3000a394: e0877001 add r7, r7, r1 <== NOT EXECUTED new_block->next = next; new_block->prev = prev; 3000a398: e582300c str r3, [r2, #12] <== NOT EXECUTED ) { Heap_Block *next = old_block->next; Heap_Block *prev = old_block->prev; new_block->next = next; 3000a39c: e5820008 str r0, [r2, #8] <== NOT EXECUTED new_block->prev = prev; next->prev = new_block; 3000a3a0: e580200c str r2, [r0, #12] <== NOT EXECUTED prev->next = new_block; 3000a3a4: 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); 3000a3a8: 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; 3000a3ac: e3871001 orr r1, r7, #1 3000a3b0: e5821004 str r1, [r2, #4] next_block->prev_size = free_block_size; next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 3000a3b4: 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; 3000a3b8: e5837000 str r7, [r3] next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 3000a3bc: e3c22001 bic r2, r2, #1 _Heap_Protection_block_initialize( heap, free_block ); } else { next_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 3000a3c0: e5832004 str r2, [r3, #4] 3000a3c4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} =============================================================================== 3000ebd8 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 3000ebd8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED 3000ebdc: e1a05001 mov r5, r1 <== NOT EXECUTED Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 3000ebe0: e5901020 ldr r1, [r0, #32] <== NOT EXECUTED Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 3000ebe4: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 3000ebe8: e58d3018 str r3, [sp, #24] <== NOT EXECUTED Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 3000ebec: e58d1010 str r1, [sp, #16] <== 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; 3000ebf0: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 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; 3000ebf4: 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; 3000ebf8: 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 ) { 3000ebfc: e0956002 adds r6, r5, r2 <== NOT EXECUTED Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 3000ec00: 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; 3000ec04: 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; 3000ec08: e58d8024 str r8, [sp, #36] ; 0x24 <== 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; 3000ec0c: 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; 3000ec10: 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; 3000ec14: e58d101c str r1, [sp, #28] <== 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 false; 3000ec18: 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 ) { 3000ec1c: 2a00009d bcs 3000ee98 <_Heap_Extend+0x2c0> <== NOT EXECUTED return false; } extend_area_ok = _Heap_Get_first_and_last_block( 3000ec20: e28d1024 add r1, sp, #36 ; 0x24 <== NOT EXECUTED 3000ec24: e58d1000 str r1, [sp] <== NOT EXECUTED 3000ec28: e28d1020 add r1, sp, #32 <== NOT EXECUTED 3000ec2c: e58d1004 str r1, [sp, #4] <== NOT EXECUTED 3000ec30: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ec34: e1a01002 mov r1, r2 <== NOT EXECUTED 3000ec38: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 3000ec3c: ebffeeb7 bl 3000a720 <_Heap_Get_first_and_last_block> <== NOT EXECUTED page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 3000ec40: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ec44: 0a000093 beq 3000ee98 <_Heap_Extend+0x2c0> <== NOT EXECUTED 3000ec48: e59da010 ldr sl, [sp, #16] <== NOT EXECUTED 3000ec4c: e1a07008 mov r7, r8 <== NOT EXECUTED 3000ec50: e1a09008 mov r9, r8 <== NOT EXECUTED return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 3000ec54: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED 3000ec58: e1a03008 mov r3, r8 <== NOT EXECUTED 3000ec5c: e1a0c004 mov ip, r4 <== NOT EXECUTED 3000ec60: ea000000 b 3000ec68 <_Heap_Extend+0x90> <== NOT EXECUTED 3000ec64: e1a0100a mov r1, sl <== NOT EXECUTED uintptr_t const sub_area_end = start_block->prev_size; 3000ec68: e59a4000 ldr r4, [sl] <== NOT EXECUTED Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 3000ec6c: e1560001 cmp r6, r1 <== NOT EXECUTED 3000ec70: 93a00000 movls r0, #0 <== NOT EXECUTED 3000ec74: 83a00001 movhi r0, #1 <== NOT EXECUTED 3000ec78: e1550004 cmp r5, r4 <== NOT EXECUTED 3000ec7c: 23a00000 movcs r0, #0 <== NOT EXECUTED 3000ec80: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ec84: 1a000082 bne 3000ee94 <_Heap_Extend+0x2bc> <== NOT EXECUTED sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 3000ec88: e1560001 cmp r6, r1 <== NOT EXECUTED 3000ec8c: 01a0300a moveq r3, sl <== NOT EXECUTED 3000ec90: 0a000001 beq 3000ec9c <_Heap_Extend+0xc4> <== NOT EXECUTED merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 3000ec94: e1560004 cmp r6, r4 <== NOT EXECUTED 3000ec98: 31a0900a movcc r9, sl <== NOT EXECUTED RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 3000ec9c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000eca0: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 3000eca4: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000eca8: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 3000ecac: eb001512 bl 300140fc <__umodsi3> <== NOT EXECUTED 3000ecb0: e244b008 sub fp, r4, #8 <== NOT EXECUTED link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 3000ecb4: 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); 3000ecb8: e060000b rsb r0, r0, fp <== NOT EXECUTED 3000ecbc: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3000ecc0: 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 ) 3000ecc4: 01a07000 moveq r7, r0 <== NOT EXECUTED start_block->prev_size = extend_area_end; 3000ecc8: 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 ) { 3000eccc: 0a000000 beq 3000ecd4 <_Heap_Extend+0xfc> <== NOT EXECUTED 3000ecd0: 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; 3000ecd4: 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 ); 3000ecd8: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3000ecdc: 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); 3000ece0: e080a00a add sl, r0, sl <== NOT EXECUTED 3000ece4: e15a0002 cmp sl, r2 <== NOT EXECUTED 3000ece8: 1affffdd bne 3000ec64 <_Heap_Extend+0x8c> <== NOT EXECUTED 3000ecec: e1a02009 mov r2, r9 <== NOT EXECUTED 3000ecf0: e1a09003 mov r9, r3 <== NOT EXECUTED if ( extend_area_begin < heap->area_begin ) { 3000ecf4: e59c3018 ldr r3, [ip, #24] <== NOT EXECUTED 3000ecf8: e1a0400c mov r4, ip <== NOT EXECUTED 3000ecfc: e1550003 cmp r5, r3 <== NOT EXECUTED heap->area_begin = extend_area_begin; 3000ed00: 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 ) { 3000ed04: 3a000002 bcc 3000ed14 <_Heap_Extend+0x13c> <== NOT EXECUTED heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { 3000ed08: e59c301c ldr r3, [ip, #28] <== NOT EXECUTED 3000ed0c: e1530006 cmp r3, r6 <== NOT EXECUTED heap->area_end = extend_area_end; 3000ed10: 358c601c strcc r6, [ip, #28] <== NOT EXECUTED } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 3000ed14: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000ed18: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED extend_first_block->prev_size = extend_area_end; 3000ed1c: 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 = 3000ed20: 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; 3000ed24: e380c001 orr ip, r0, #1 <== NOT EXECUTED _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 3000ed28: e5830000 str r0, [r3] <== NOT EXECUTED extend_last_block->size_and_flag = 0; 3000ed2c: 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 = 3000ed30: 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; 3000ed34: 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 ) { 3000ed38: e5940020 ldr r0, [r4, #32] <== NOT EXECUTED 3000ed3c: e1500001 cmp r0, r1 <== NOT EXECUTED heap->first_block = extend_first_block; 3000ed40: 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 ) { 3000ed44: 8a000002 bhi 3000ed54 <_Heap_Extend+0x17c> <== NOT EXECUTED heap->first_block = extend_first_block; } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 3000ed48: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000ed4c: e1510003 cmp r1, r3 <== NOT EXECUTED heap->last_block = extend_last_block; 3000ed50: 35843024 strcc r3, [r4, #36] ; 0x24 <== NOT EXECUTED } if ( merge_below_block != NULL ) { 3000ed54: e3590000 cmp r9, #0 <== NOT EXECUTED 3000ed58: 0a000010 beq 3000eda0 <_Heap_Extend+0x1c8> <== NOT EXECUTED Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 3000ed5c: 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 ); 3000ed60: 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; 3000ed64: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ed68: e1a0100a mov r1, sl <== NOT EXECUTED 3000ed6c: eb0014e2 bl 300140fc <__umodsi3> <== NOT EXECUTED if ( remainder != 0 ) { 3000ed70: e3500000 cmp r0, #0 <== NOT EXECUTED return value - remainder + alignment; 3000ed74: 1085500a addne r5, r5, sl <== NOT EXECUTED 3000ed78: 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; 3000ed7c: 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 = 3000ed80: 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; 3000ed84: 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 = 3000ed88: 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; 3000ed8c: e3833001 orr r3, r3, #1 <== NOT EXECUTED 3000ed90: e5053004 str r3, [r5, #-4] <== NOT EXECUTED _Heap_Free_block( heap, new_first_block ); 3000ed94: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ed98: ebffff86 bl 3000ebb8 <_Heap_Free_block> <== NOT EXECUTED 3000ed9c: ea000004 b 3000edb4 <_Heap_Extend+0x1dc> <== 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 ) { 3000eda0: e3520000 cmp r2, #0 <== NOT EXECUTED _Heap_Link_below( 3000eda4: 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; 3000eda8: 10632002 rsbne r2, r3, r2 <== NOT EXECUTED 3000edac: 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 = 3000edb0: 15832004 strne r2, [r3, #4] <== NOT EXECUTED link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 3000edb4: e3570000 cmp r7, #0 <== NOT EXECUTED 3000edb8: 0a000012 beq 3000ee08 <_Heap_Extend+0x230> <== 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, 3000edbc: 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( 3000edc0: 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); 3000edc4: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED 3000edc8: e1a00006 mov r0, r6 <== NOT EXECUTED 3000edcc: eb0014ca bl 300140fc <__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) 3000edd0: e5972004 ldr r2, [r7, #4] <== NOT EXECUTED 3000edd4: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 3000edd8: 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 = 3000eddc: e0863007 add r3, r6, r7 <== NOT EXECUTED (last_block->size_and_flag - last_block_new_size) | HEAP_PREV_BLOCK_USED; 3000ede0: 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 = 3000ede4: 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; 3000ede8: 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 ); 3000edec: e1a00004 mov r0, r4 <== NOT EXECUTED 3000edf0: e2033001 and r3, r3, #1 <== NOT EXECUTED block->size_and_flag = size | flag; 3000edf4: e1866003 orr r6, r6, r3 <== NOT EXECUTED 3000edf8: e5876004 str r6, [r7, #4] <== NOT EXECUTED 3000edfc: e1a01007 mov r1, r7 <== NOT EXECUTED 3000ee00: ebffff6c bl 3000ebb8 <_Heap_Free_block> <== NOT EXECUTED 3000ee04: ea00000b b 3000ee38 <_Heap_Extend+0x260> <== NOT EXECUTED ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 3000ee08: e3580000 cmp r8, #0 <== NOT EXECUTED 3000ee0c: 0a000009 beq 3000ee38 <_Heap_Extend+0x260> <== 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; 3000ee10: 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 ); 3000ee14: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000ee18: e2022001 and r2, r2, #1 <== NOT EXECUTED 3000ee1c: 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( 3000ee20: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED block->size_and_flag = size | flag; 3000ee24: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000ee28: 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; 3000ee2c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000ee30: e3822001 orr r2, r2, #1 <== NOT EXECUTED 3000ee34: e5832004 str r2, [r3, #4] <== NOT EXECUTED extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 3000ee38: e3570000 cmp r7, #0 <== NOT EXECUTED 3000ee3c: 03590000 cmpeq r9, #0 <== NOT EXECUTED _Heap_Free_block( heap, extend_first_block ); 3000ee40: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000ee44: 059d1024 ldreq r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000ee48: 0bffff5a bleq 3000ebb8 <_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 3000ee4c: 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( 3000ee50: 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; 3000ee54: 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( 3000ee58: 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; 3000ee5c: e2022001 and r2, r2, #1 <== NOT EXECUTED block->size_and_flag = size | flag; 3000ee60: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000ee64: e5832004 str r2, [r3, #4] <== NOT EXECUTED } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 3000ee68: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 3000ee6c: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED /* Statistics */ stats->size += extended_size; 3000ee70: e594202c ldr r2, [r4, #44] ; 0x2c <== NOT EXECUTED _Heap_Free_block( heap, extend_first_block ); } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 3000ee74: e0613003 rsb r3, r1, r3 <== NOT EXECUTED /* Statistics */ stats->size += extended_size; 3000ee78: e0822003 add r2, r2, r3 <== NOT EXECUTED 3000ee7c: e584202c str r2, [r4, #44] ; 0x2c <== NOT EXECUTED if ( extended_size_ptr != NULL ) 3000ee80: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED *extended_size_ptr = extended_size; return true; 3000ee84: e3a00001 mov r0, #1 <== NOT EXECUTED extended_size = stats->free_size - free_size; /* Statistics */ stats->size += extended_size; if ( extended_size_ptr != NULL ) 3000ee88: e3520000 cmp r2, #0 <== NOT EXECUTED *extended_size_ptr = extended_size; 3000ee8c: 15823000 strne r3, [r2] <== NOT EXECUTED 3000ee90: ea000000 b 3000ee98 <_Heap_Extend+0x2c0> <== 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 false; 3000ee94: e3a00000 mov r0, #0 <== NOT EXECUTED if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 3000ee98: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED 3000ee9c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED =============================================================================== 3000ebb8 <_Heap_Free_block>: static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block ) { Heap_Statistics *const stats = &heap->stats; /* Statistics */ ++stats->used_blocks; 3000ebb8: e5902040 ldr r2, [r0, #64] ; 0x40 <== NOT EXECUTED --stats->frees; _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block )); 3000ebbc: e2811008 add r1, r1, #8 <== NOT EXECUTED static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block ) { Heap_Statistics *const stats = &heap->stats; /* Statistics */ ++stats->used_blocks; 3000ebc0: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000ebc4: e5802040 str r2, [r0, #64] ; 0x40 <== NOT EXECUTED --stats->frees; 3000ebc8: e5902050 ldr r2, [r0, #80] ; 0x50 <== NOT EXECUTED 3000ebcc: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000ebd0: e5802050 str r2, [r0, #80] ; 0x50 <== NOT EXECUTED _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block )); 3000ebd4: ea0000b1 b 3000eea0 <_Heap_Free> <== NOT EXECUTED =============================================================================== 3000a454 <_Heap_Initialize>: Heap_Control *heap, void *heap_area_begin_ptr, uintptr_t heap_area_size, uintptr_t page_size ) { 3000a454: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr} 3000a458: 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 ) { 3000a45c: 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; 3000a460: e3a02000 mov r2, #0 Heap_Control *heap, void *heap_area_begin_ptr, uintptr_t heap_area_size, uintptr_t page_size ) { 3000a464: e1a04000 mov r4, r0 3000a468: 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; 3000a46c: e58d200c str r2, [sp, #12] Heap_Block *last_block = NULL; 3000a470: e58d2008 str r2, [sp, #8] if ( page_size == 0 ) { page_size = CPU_ALIGNMENT; 3000a474: 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 ) { 3000a478: 0a000004 beq 3000a490 <_Heap_Initialize+0x3c> uintptr_t alignment ) { uintptr_t remainder = value % alignment; if ( remainder != 0 ) { 3000a47c: e2153007 ands r3, r5, #7 return value - remainder + alignment; 3000a480: 12855008 addne r5, r5, #8 3000a484: 10635005 rsbne r5, r3, r5 page_size = CPU_ALIGNMENT; } else { page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT ); if ( page_size < CPU_ALIGNMENT ) { 3000a488: e3550007 cmp r5, #7 3000a48c: 9a000034 bls 3000a564 <_Heap_Initialize+0x110> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up( uintptr_t value, uintptr_t alignment ) { uintptr_t remainder = value % alignment; 3000a490: e1a01005 mov r1, r5 3000a494: e3a00010 mov r0, #16 3000a498: eb0025c2 bl 30013ba8 <__umodsi3> if ( remainder != 0 ) { 3000a49c: e3500000 cmp r0, #0 return value - remainder + alignment; 3000a4a0: 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( 3000a4a4: e28d300c add r3, sp, #12 3000a4a8: 10607007 rsbne r7, r0, r7 } else { return value; 3000a4ac: 03a07010 moveq r7, #16 3000a4b0: e58d3000 str r3, [sp] 3000a4b4: e28d3008 add r3, sp, #8 3000a4b8: e58d3004 str r3, [sp, #4] 3000a4bc: e1a00006 mov r0, r6 3000a4c0: e1a01008 mov r1, r8 3000a4c4: e1a02005 mov r2, r5 3000a4c8: e1a03007 mov r3, r7 3000a4cc: ebffffbd bl 3000a3c8 <_Heap_Get_first_and_last_block> page_size, min_block_size, &first_block, &last_block ); if ( !area_ok ) { 3000a4d0: e3500000 cmp r0, #0 3000a4d4: 0a000023 beq 3000a568 <_Heap_Initialize+0x114> return 0; } memset(heap, 0, sizeof(*heap)); 3000a4d8: e3a01000 mov r1, #0 3000a4dc: e3a02058 mov r2, #88 ; 0x58 3000a4e0: e1a00004 mov r0, r4 3000a4e4: eb0019b9 bl 30010bd0 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; 3000a4e8: e59d300c ldr r3, [sp, #12] last_block_begin = (uintptr_t) last_block; 3000a4ec: e59d2008 ldr r2, [sp, #8] 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; 3000a4f0: 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; 3000a4f4: 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; 3000a4f8: 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; 3000a4fc: e5838000 str r8, [r3] first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED; 3000a500: e9830012 stmib r3, {r1, r4} first_block->next = _Heap_Free_list_tail( heap ); first_block->prev = _Heap_Free_list_head( heap ); 3000a504: 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; 3000a508: 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; 3000a50c: 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; 3000a510: 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( 3000a514: 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; 3000a518: 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; 3000a51c: e5845010 str r5, [r4, #16] heap->min_block_size = min_block_size; 3000a520: e5847014 str r7, [r4, #20] heap->area_begin = heap_area_begin; 3000a524: e5846018 str r6, [r4, #24] heap->area_end = heap_area_end; 3000a528: 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; 3000a52c: 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; 3000a530: 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; 3000a534: 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; 3000a538: e5843038 str r3, [r4, #56] ; 0x38 stats->max_free_blocks = 1; 3000a53c: e584303c str r3, [r4, #60] ; 0x3c stats->instance = instance++; 3000a540: e59f3028 ldr r3, [pc, #40] ; 3000a570 <_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; 3000a544: 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++; 3000a548: 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; 3000a54c: 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++; 3000a550: e5842028 str r2, [r4, #40] ; 0x28 3000a554: 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; 3000a558: e5840034 str r0, [r4, #52] ; 0x34 stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++; 3000a55c: e5832000 str r2, [r3] ); _HAssert( _Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size ) ); return first_block_size; 3000a560: ea000000 b 3000a568 <_Heap_Initialize+0x114> } else { page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT ); if ( page_size < CPU_ALIGNMENT ) { /* Integer overflow */ return 0; 3000a564: e3a00000 mov r0, #0 <== NOT EXECUTED _HAssert( _Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size ) ); return first_block_size; } 3000a568: e28dd010 add sp, sp, #16 3000a56c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} =============================================================================== 30015f04 <_Heap_Resize_block>: void *alloc_begin_ptr, uintptr_t new_alloc_size, uintptr_t *old_size, uintptr_t *new_size ) { 30015f04: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} 30015f08: e1a04000 mov r4, r0 RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 30015f0c: e241a008 sub sl, r1, #8 30015f10: e1a00001 mov r0, r1 30015f14: e1a05001 mov r5, r1 30015f18: e5941010 ldr r1, [r4, #16] 30015f1c: e1a08003 mov r8, r3 30015f20: e1a07002 mov r7, r2 30015f24: ebfff71f bl 30013ba8 <__umodsi3> 30015f28: 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; 30015f2c: e3a03000 mov r3, #0 30015f30: e5883000 str r3, [r8] *new_size = 0; 30015f34: 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; 30015f38: 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); 30015f3c: 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; 30015f40: e1530001 cmp r3, r1 new_alloc_size, old_size, new_size ); } return HEAP_RESIZE_FATAL_ERROR; 30015f44: 83a00002 movhi r0, #2 30015f48: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc} 30015f4c: e5943024 ldr r3, [r4, #36] ; 0x24 30015f50: e1530001 cmp r3, r1 30015f54: 3a000035 bcc 30016030 <_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; 30015f58: 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; 30015f5c: e265c004 rsb ip, r5, #4 30015f60: 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; 30015f64: e0812003 add r2, r1, r3 30015f68: e5920004 ldr r0, [r2, #4] uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS; 30015f6c: e08cc002 add ip, ip, r2 30015f70: e3c00001 bic r0, r0, #1 old_size, new_size ); } return HEAP_RESIZE_FATAL_ERROR; } 30015f74: e082a000 add sl, r2, 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; 30015f78: 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; 30015f7c: e588c000 str ip, [r8] RTEMS_INLINE_ROUTINE bool _Heap_Is_free( const Heap_Block *block ) { return !_Heap_Is_used( block ); 30015f80: e31a0001 tst sl, #1 30015f84: 13a0a000 movne sl, #0 30015f88: 03a0a001 moveq sl, #1 if ( next_block_is_free ) { 30015f8c: e35a0000 cmp sl, #0 block_size += next_block_size; alloc_size += next_block_size; 30015f90: 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; 30015f94: 10833000 addne r3, r3, r0 alloc_size += next_block_size; } if ( new_alloc_size > alloc_size ) { 30015f98: e157000c cmp r7, ip return HEAP_RESIZE_UNSATISFIED; 30015f9c: 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 ) { 30015fa0: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc} return HEAP_RESIZE_UNSATISFIED; } if ( next_block_is_free ) { 30015fa4: e35a0000 cmp sl, #0 30015fa8: 0a000011 beq 30015ff4 <_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; 30015fac: e591c004 ldr ip, [r1, #4] <== NOT EXECUTED 30015fb0: e20cc001 and ip, ip, #1 <== NOT EXECUTED block->size_and_flag = size | flag; 30015fb4: e183c00c orr ip, r3, ip <== NOT EXECUTED 30015fb8: e581c004 str ip, [r1, #4] <== 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; 30015fbc: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED Heap_Block *prev = block->prev; 30015fc0: e592200c ldr r2, [r2, #12] <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 30015fc4: e0833001 add r3, r3, r1 <== 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; 30015fc8: e582c008 str ip, [r2, #8] <== NOT EXECUTED next->prev = prev; 30015fcc: e58c200c str r2, [ip, #12] <== NOT EXECUTED _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; 30015fd0: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 30015fd4: e3822001 orr r2, r2, #1 <== NOT EXECUTED 30015fd8: e5832004 str r2, [r3, #4] <== NOT EXECUTED /* Statistics */ --stats->free_blocks; 30015fdc: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 30015fe0: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30015fe4: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED stats->free_size -= next_block_size; 30015fe8: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED 30015fec: e0600003 rsb r0, r0, r3 <== NOT EXECUTED 30015ff0: e5840030 str r0, [r4, #48] ; 0x30 <== NOT EXECUTED } block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size ); 30015ff4: e1a02005 mov r2, r5 30015ff8: e1a03007 mov r3, r7 30015ffc: e1a00004 mov r0, r4 30016000: ebffd15b bl 3000a574 <_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; 30016004: e5903004 ldr r3, [r0, #4] 30016008: 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); 3001600c: 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; 30016010: e0655003 rsb r5, r5, r3 30016014: e0800005 add r0, r0, r5 30016018: e5860000 str r0, [r6] /* Statistics */ ++stats->resizes; 3001601c: e5943054 ldr r3, [r4, #84] ; 0x54 return HEAP_RESIZE_SUCCESSFUL; 30016020: 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; 30016024: e2833001 add r3, r3, #1 30016028: e5843054 str r3, [r4, #84] ; 0x54 3001602c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} new_alloc_size, old_size, new_size ); } return HEAP_RESIZE_FATAL_ERROR; 30016030: e3a00002 mov r0, #2 <== NOT EXECUTED } 30016034: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED =============================================================================== 3000b2bc <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 3000b2bc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; 3000b2c0: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 3000b2c4: e24dd030 sub sp, sp, #48 ; 0x30 <== NOT EXECUTED uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; 3000b2c8: e58d3024 str r3, [sp, #36] ; 0x24 <== NOT EXECUTED Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block; 3000b2cc: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 3000b2d0: e59f4500 ldr r4, [pc, #1280] ; 3000b7d8 <_Heap_Walk+0x51c> <== 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; 3000b2d4: e58d3028 str r3, [sp, #40] ; 0x28 <== NOT EXECUTED Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 3000b2d8: e59f34fc ldr r3, [pc, #1276] ; 3000b7dc <_Heap_Walk+0x520> <== NOT EXECUTED 3000b2dc: e31200ff tst r2, #255 ; 0xff <== NOT EXECUTED 3000b2e0: 11a04003 movne r4, r3 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { 3000b2e4: e59f34f4 ldr r3, [pc, #1268] ; 3000b7e0 <_Heap_Walk+0x524> <== 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; 3000b2e8: 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() ) ) { 3000b2ec: e5933000 ldr r3, [r3] <== NOT EXECUTED bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 3000b2f0: e1a06000 mov r6, r0 <== 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() ) ) { 3000b2f4: e3530003 cmp r3, #3 <== NOT EXECUTED bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 3000b2f8: e1a05001 mov r5, r1 <== NOT EXECUTED uintptr_t const page_size = heap->page_size; 3000b2fc: e5909010 ldr r9, [r0, #16] <== NOT EXECUTED uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block; 3000b300: e58dc020 str ip, [sp, #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() ) ) { 3000b304: 1a000127 bne 3000b7a8 <_Heap_Walk+0x4ec> <== 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)( 3000b308: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b30c: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000b310: e58dc000 str ip, [sp] <== NOT EXECUTED 3000b314: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED 3000b318: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000b31c: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 3000b320: e58d200c str r2, [sp, #12] <== NOT EXECUTED 3000b324: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3000b328: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000b32c: e59f24b0 ldr r2, [pc, #1200] ; 3000b7e4 <_Heap_Walk+0x528> <== NOT EXECUTED 3000b330: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 3000b334: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED 3000b338: e58d3014 str r3, [sp, #20] <== NOT EXECUTED 3000b33c: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3000b340: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b344: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3000b348: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b34c: e1a03009 mov r3, r9 <== NOT EXECUTED 3000b350: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b354: e12fff14 bx r4 <== NOT EXECUTED heap->area_begin, heap->area_end, first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { 3000b358: e3590000 cmp r9, #0 <== NOT EXECUTED 3000b35c: 1a000006 bne 3000b37c <_Heap_Walk+0xc0> <== NOT EXECUTED (*printer)( source, true, "page size is zero\n" ); 3000b360: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b364: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b368: e59f2478 ldr r2, [pc, #1144] ; 3000b7e8 <_Heap_Walk+0x52c> <== NOT EXECUTED 3000b36c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b370: e12fff14 bx r4 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 3000b374: e1a08009 mov r8, r9 <== NOT EXECUTED 3000b378: ea00010b b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED (*printer)( source, true, "page size is zero\n" ); return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 3000b37c: e2198007 ands r8, r9, #7 <== NOT EXECUTED (*printer)( 3000b380: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b384: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b388: 159f245c ldrne r2, [pc, #1116] ; 3000b7ec <_Heap_Walk+0x530><== NOT EXECUTED 3000b38c: 11a03009 movne r3, r9 <== NOT EXECUTED 3000b390: 1a00010c bne 3000b7c8 <_Heap_Walk+0x50c> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 3000b394: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b398: e1a01009 mov r1, r9 <== NOT EXECUTED 3000b39c: ebffe749 bl 300050c8 <__umodsi3> <== NOT EXECUTED ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 3000b3a0: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3000b3a4: 0a000006 beq 3000b3c4 <_Heap_Walk+0x108> <== NOT EXECUTED (*printer)( 3000b3a8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b3ac: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b3b0: e59f2438 ldr r2, [pc, #1080] ; 3000b7f0 <_Heap_Walk+0x534> <== NOT EXECUTED 3000b3b4: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b3b8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b3bc: e12fff14 bx r4 <== NOT EXECUTED 3000b3c0: ea0000f9 b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED 3000b3c4: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000b3c8: e1a01009 mov r1, r9 <== NOT EXECUTED 3000b3cc: e28c0008 add r0, ip, #8 <== NOT EXECUTED 3000b3d0: ebffe73c bl 300050c8 <__umodsi3> <== NOT EXECUTED ); return false; } if ( 3000b3d4: e250a000 subs sl, r0, #0 <== NOT EXECUTED !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 3000b3d8: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b3dc: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b3e0: 159f240c ldrne r2, [pc, #1036] ; 3000b7f4 <_Heap_Walk+0x538><== NOT EXECUTED 3000b3e4: 159d3020 ldrne r3, [sp, #32] <== NOT EXECUTED 3000b3e8: 1a0000cc bne 3000b720 <_Heap_Walk+0x464> <== 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; 3000b3ec: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000b3f0: e5928004 ldr r8, [r2, #4] <== NOT EXECUTED ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 3000b3f4: e2188001 ands r8, r8, #1 <== NOT EXECUTED (*printer)( 3000b3f8: 01a00005 moveq r0, r5 <== NOT EXECUTED 3000b3fc: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000b400: 059f23f0 ldreq r2, [pc, #1008] ; 3000b7f8 <_Heap_Walk+0x53c><== NOT EXECUTED 3000b404: 0a000009 beq 3000b430 <_Heap_Walk+0x174> <== 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; 3000b408: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000b40c: e5937004 ldr r7, [r3, #4] <== NOT EXECUTED 3000b410: e3c77001 bic r7, r7, #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); 3000b414: e0837007 add r7, r3, r7 <== 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; 3000b418: e5978004 ldr r8, [r7, #4] <== NOT EXECUTED ); return false; } if ( _Heap_Is_free( last_block ) ) { 3000b41c: e2188001 ands r8, r8, #1 <== NOT EXECUTED 3000b420: 1a000005 bne 3000b43c <_Heap_Walk+0x180> <== NOT EXECUTED (*printer)( 3000b424: e59f23d0 ldr r2, [pc, #976] ; 3000b7fc <_Heap_Walk+0x540> <== NOT EXECUTED 3000b428: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b42c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b430: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b434: e12fff14 bx r4 <== NOT EXECUTED 3000b438: ea0000db b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED ); return false; } if ( 3000b43c: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000b440: e157000c cmp r7, ip <== NOT EXECUTED 3000b444: 0a000006 beq 3000b464 <_Heap_Walk+0x1a8> <== NOT EXECUTED _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 3000b448: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b44c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b450: e59f23a8 ldr r2, [pc, #936] ; 3000b800 <_Heap_Walk+0x544> <== NOT EXECUTED 3000b454: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b458: e12fff14 bx r4 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 3000b45c: e1a0800a mov r8, sl <== NOT EXECUTED 3000b460: ea0000d1 b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 3000b464: e596b010 ldr fp, [r6, #16] <== NOT EXECUTED block = next_block; } while ( block != first_block ); return true; } 3000b468: e5968008 ldr r8, [r6, #8] <== NOT EXECUTED Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); 3000b46c: e1a0a006 mov sl, r6 <== NOT EXECUTED 3000b470: ea000034 b 3000b548 <_Heap_Walk+0x28c> <== 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; 3000b474: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED 3000b478: e1530008 cmp r3, r8 <== NOT EXECUTED 3000b47c: 83a0c000 movhi ip, #0 <== NOT EXECUTED 3000b480: 8a000003 bhi 3000b494 <_Heap_Walk+0x1d8> <== NOT EXECUTED 3000b484: e596c024 ldr ip, [r6, #36] ; 0x24 <== NOT EXECUTED 3000b488: e15c0008 cmp ip, r8 <== NOT EXECUTED 3000b48c: 33a0c000 movcc ip, #0 <== NOT EXECUTED 3000b490: 23a0c001 movcs ip, #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 ) ) { 3000b494: e21cc0ff ands ip, ip, #255 ; 0xff <== NOT EXECUTED (*printer)( 3000b498: 01a00005 moveq r0, r5 <== NOT EXECUTED 3000b49c: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000b4a0: 059f235c ldreq r2, [pc, #860] ; 3000b804 <_Heap_Walk+0x548><== NOT EXECUTED 3000b4a4: 0a000012 beq 3000b4f4 <_Heap_Walk+0x238> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 3000b4a8: e2880008 add r0, r8, #8 <== NOT EXECUTED 3000b4ac: e1a0100b mov r1, fp <== NOT EXECUTED 3000b4b0: ebffe704 bl 300050c8 <__umodsi3> <== NOT EXECUTED ); return false; } if ( 3000b4b4: e250c000 subs ip, r0, #0 <== NOT EXECUTED !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 3000b4b8: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b4bc: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b4c0: 159f2340 ldrne r2, [pc, #832] ; 3000b808 <_Heap_Walk+0x54c><== NOT EXECUTED 3000b4c4: 11a03008 movne r3, r8 <== NOT EXECUTED 3000b4c8: 1a0000be bne 3000b7c8 <_Heap_Walk+0x50c> <== 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; 3000b4cc: e5983004 ldr r3, [r8, #4] <== NOT EXECUTED 3000b4d0: e3c33001 bic r3, r3, #1 <== NOT EXECUTED block = next_block; } while ( block != first_block ); return true; } 3000b4d4: e0883003 add r3, r8, r3 <== 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; 3000b4d8: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED ); return false; } if ( _Heap_Is_used( free_block ) ) { 3000b4dc: e2133001 ands r3, r3, #1 <== NOT EXECUTED 3000b4e0: e58d302c str r3, [sp, #44] ; 0x2c <== NOT EXECUTED 3000b4e4: 0a000009 beq 3000b510 <_Heap_Walk+0x254> <== NOT EXECUTED (*printer)( 3000b4e8: e59f231c ldr r2, [pc, #796] ; 3000b80c <_Heap_Walk+0x550> <== NOT EXECUTED 3000b4ec: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b4f0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b4f4: e1a03008 mov r3, r8 <== NOT EXECUTED 3000b4f8: e58dc01c str ip, [sp, #28] <== NOT EXECUTED 3000b4fc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b500: e12fff14 bx r4 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 3000b504: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 3000b508: e1a0800c mov r8, ip <== NOT EXECUTED 3000b50c: ea0000a6 b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED ); return false; } if ( free_block->prev != prev_block ) { 3000b510: e598300c ldr r3, [r8, #12] <== NOT EXECUTED 3000b514: e153000a cmp r3, sl <== NOT EXECUTED 3000b518: 0a000008 beq 3000b540 <_Heap_Walk+0x284> <== NOT EXECUTED (*printer)( 3000b51c: e58d3000 str r3, [sp] <== NOT EXECUTED 3000b520: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b524: e1a03008 mov r3, r8 <== NOT EXECUTED 3000b528: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b52c: e59f22dc ldr r2, [pc, #732] ; 3000b810 <_Heap_Walk+0x554> <== NOT EXECUTED 3000b530: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b534: e12fff14 bx r4 <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 3000b538: e59d802c ldr r8, [sp, #44] ; 0x2c <== NOT EXECUTED 3000b53c: ea00009a b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED return false; } prev_block = free_block; free_block = free_block->next; 3000b540: e1a0a008 mov sl, r8 <== NOT EXECUTED 3000b544: e5988008 ldr r8, [r8, #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 ) { 3000b548: e1580006 cmp r8, r6 <== NOT EXECUTED 3000b54c: 1affffc8 bne 3000b474 <_Heap_Walk+0x1b8> <== NOT EXECUTED 3000b550: ea000000 b 3000b558 <_Heap_Walk+0x29c> <== NOT EXECUTED block->prev_size ); } block = next_block; } while ( block != first_block ); 3000b554: e1a07008 mov r7, r8 <== NOT EXECUTED return true; } 3000b558: e5973004 ldr r3, [r7, #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; 3000b55c: e5962020 ldr r2, [r6, #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; 3000b560: e3c3a001 bic sl, r3, #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); 3000b564: e087800a add r8, r7, sl <== 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; 3000b568: e1520008 cmp r2, r8 <== NOT EXECUTED 3000b56c: 83a0b000 movhi fp, #0 <== NOT EXECUTED 3000b570: 8a000003 bhi 3000b584 <_Heap_Walk+0x2c8> <== NOT EXECUTED 3000b574: e596b024 ldr fp, [r6, #36] ; 0x24 <== NOT EXECUTED 3000b578: e15b0008 cmp fp, r8 <== NOT EXECUTED 3000b57c: 33a0b000 movcc fp, #0 <== NOT EXECUTED 3000b580: 23a0b001 movcs fp, #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 ) ) { 3000b584: e21bb0ff ands fp, fp, #255 ; 0xff <== NOT EXECUTED 3000b588: 1a000007 bne 3000b5ac <_Heap_Walk+0x2f0> <== NOT EXECUTED (*printer)( 3000b58c: e58d8000 str r8, [sp] <== NOT EXECUTED 3000b590: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b594: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b598: e59f2274 ldr r2, [pc, #628] ; 3000b814 <_Heap_Walk+0x558> <== NOT EXECUTED 3000b59c: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b5a0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b5a4: e12fff14 bx r4 <== NOT EXECUTED 3000b5a8: ea00005e b 3000b728 <_Heap_Walk+0x46c> <== 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; 3000b5ac: e59d2028 ldr r2, [sp, #40] ; 0x28 <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 3000b5b0: e1a0000a mov r0, sl <== NOT EXECUTED 3000b5b4: e1a01009 mov r1, r9 <== NOT EXECUTED 3000b5b8: e057b002 subs fp, r7, r2 <== NOT EXECUTED 3000b5bc: 13a0b001 movne fp, #1 <== NOT EXECUTED 3000b5c0: e58d301c str r3, [sp, #28] <== NOT EXECUTED 3000b5c4: ebffe6bf bl 300050c8 <__umodsi3> <== NOT EXECUTED ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 3000b5c8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b5cc: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 3000b5d0: 0a000005 beq 3000b5ec <_Heap_Walk+0x330> <== NOT EXECUTED 3000b5d4: e35b0000 cmp fp, #0 <== NOT EXECUTED (*printer)( 3000b5d8: 158da000 strne sl, [sp] <== NOT EXECUTED 3000b5dc: 11a00005 movne r0, r5 <== NOT EXECUTED 3000b5e0: 13a01001 movne r1, #1 <== NOT EXECUTED 3000b5e4: 159f222c ldrne r2, [pc, #556] ; 3000b818 <_Heap_Walk+0x55c><== NOT EXECUTED 3000b5e8: 1a000014 bne 3000b640 <_Heap_Walk+0x384> <== NOT EXECUTED ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 3000b5ec: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000b5f0: e15a000c cmp sl, ip <== NOT EXECUTED 3000b5f4: 2a000009 bcs 3000b620 <_Heap_Walk+0x364> <== NOT EXECUTED 3000b5f8: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b5fc: 0a000007 beq 3000b620 <_Heap_Walk+0x364> <== NOT EXECUTED (*printer)( 3000b600: e88d1400 stm sp, {sl, ip} <== NOT EXECUTED 3000b604: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b608: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b60c: e59f2208 ldr r2, [pc, #520] ; 3000b81c <_Heap_Walk+0x560> <== NOT EXECUTED 3000b610: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b614: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b618: e12fff14 bx r4 <== NOT EXECUTED 3000b61c: ea00006b b 3000b7d0 <_Heap_Walk+0x514> <== NOT EXECUTED ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 3000b620: e1580007 cmp r8, r7 <== NOT EXECUTED 3000b624: 8a000009 bhi 3000b650 <_Heap_Walk+0x394> <== NOT EXECUTED 3000b628: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b62c: 0a000007 beq 3000b650 <_Heap_Walk+0x394> <== NOT EXECUTED (*printer)( 3000b630: e59f21e8 ldr r2, [pc, #488] ; 3000b820 <_Heap_Walk+0x564> <== NOT EXECUTED 3000b634: e58d8000 str r8, [sp] <== NOT EXECUTED 3000b638: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b63c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b640: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b644: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b648: e12fff14 bx r4 <== NOT EXECUTED 3000b64c: ea00005f b 3000b7d0 <_Heap_Walk+0x514> <== 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; 3000b650: e203b001 and fp, r3, #1 <== NOT EXECUTED 3000b654: e5983004 ldr r3, [r8, #4] <== NOT EXECUTED ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 3000b658: e3130001 tst r3, #1 <== NOT EXECUTED 3000b65c: 1a00003b bne 3000b750 <_Heap_Walk+0x494> <== 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 ? 3000b660: e597200c ldr r2, [r7, #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)( 3000b664: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED block = next_block; } while ( block != first_block ); return true; } 3000b668: e596100c ldr r1, [r6, #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)( 3000b66c: e1520003 cmp r2, r3 <== NOT EXECUTED 3000b670: 059f01ac ldreq r0, [pc, #428] ; 3000b824 <_Heap_Walk+0x568><== NOT EXECUTED 3000b674: 0a000003 beq 3000b688 <_Heap_Walk+0x3cc> <== NOT EXECUTED block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 3000b678: e59f31a8 ldr r3, [pc, #424] ; 3000b828 <_Heap_Walk+0x56c> <== NOT EXECUTED 3000b67c: e1520006 cmp r2, r6 <== NOT EXECUTED 3000b680: e59f01a4 ldr r0, [pc, #420] ; 3000b82c <_Heap_Walk+0x570> <== NOT EXECUTED 3000b684: 01a00003 moveq r0, r3 <== NOT EXECUTED block->next, block->next == last_free_block ? 3000b688: e5973008 ldr r3, [r7, #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)( 3000b68c: e1530001 cmp r3, r1 <== NOT EXECUTED 3000b690: 059f1198 ldreq r1, [pc, #408] ; 3000b830 <_Heap_Walk+0x574><== NOT EXECUTED 3000b694: 0a000003 beq 3000b6a8 <_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)" : "") 3000b698: e59fc194 ldr ip, [pc, #404] ; 3000b834 <_Heap_Walk+0x578> <== NOT EXECUTED 3000b69c: e1530006 cmp r3, r6 <== NOT EXECUTED 3000b6a0: e59f1184 ldr r1, [pc, #388] ; 3000b82c <_Heap_Walk+0x570> <== NOT EXECUTED 3000b6a4: 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)( 3000b6a8: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000b6ac: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3000b6b0: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000b6b4: e58d1010 str r1, [sp, #16] <== NOT EXECUTED 3000b6b8: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b6bc: e58da000 str sl, [sp] <== NOT EXECUTED 3000b6c0: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b6c4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b6c8: e59f2168 ldr r2, [pc, #360] ; 3000b838 <_Heap_Walk+0x57c> <== NOT EXECUTED 3000b6cc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b6d0: e12fff14 bx r4 <== NOT EXECUTED block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { 3000b6d4: e5983000 ldr r3, [r8] <== NOT EXECUTED 3000b6d8: e15a0003 cmp sl, r3 <== NOT EXECUTED 3000b6dc: 0a000009 beq 3000b708 <_Heap_Walk+0x44c> <== NOT EXECUTED (*printer)( 3000b6e0: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000b6e4: e58da000 str sl, [sp] <== NOT EXECUTED 3000b6e8: e58d8008 str r8, [sp, #8] <== NOT EXECUTED 3000b6ec: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b6f0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b6f4: e59f2140 ldr r2, [pc, #320] ; 3000b83c <_Heap_Walk+0x580> <== NOT EXECUTED 3000b6f8: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b6fc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b700: e12fff14 bx r4 <== NOT EXECUTED 3000b704: ea000031 b 3000b7d0 <_Heap_Walk+0x514> <== NOT EXECUTED ); return false; } if ( !prev_used ) { 3000b708: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b70c: 1a000007 bne 3000b730 <_Heap_Walk+0x474> <== NOT EXECUTED (*printer)( 3000b710: e59f2128 ldr r2, [pc, #296] ; 3000b840 <_Heap_Walk+0x584> <== NOT EXECUTED 3000b714: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b718: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b71c: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b720: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b724: e12fff14 bx r4 <== NOT EXECUTED return false; } if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; 3000b728: e1a0800b mov r8, fp <== NOT EXECUTED 3000b72c: ea00001e b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED block = next_block; } while ( block != first_block ); return true; } 3000b730: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED 3000b734: ea000002 b 3000b744 <_Heap_Walk+0x488> <== 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 ) { 3000b738: e1530007 cmp r3, r7 <== NOT EXECUTED 3000b73c: 0a000016 beq 3000b79c <_Heap_Walk+0x4e0> <== NOT EXECUTED return true; } free_block = free_block->next; 3000b740: 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 ) { 3000b744: e1530006 cmp r3, r6 <== NOT EXECUTED 3000b748: 1afffffa bne 3000b738 <_Heap_Walk+0x47c> <== NOT EXECUTED 3000b74c: ea000019 b 3000b7b8 <_Heap_Walk+0x4fc> <== 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) { 3000b750: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000b754: 0a000007 beq 3000b778 <_Heap_Walk+0x4bc> <== NOT EXECUTED (*printer)( 3000b758: e58da000 str sl, [sp] <== NOT EXECUTED 3000b75c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b760: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b764: e59f20d8 ldr r2, [pc, #216] ; 3000b844 <_Heap_Walk+0x588> <== NOT EXECUTED 3000b768: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b76c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b770: e12fff14 bx r4 <== NOT EXECUTED 3000b774: ea000008 b 3000b79c <_Heap_Walk+0x4e0> <== NOT EXECUTED "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 3000b778: e58da000 str sl, [sp] <== NOT EXECUTED 3000b77c: e5973000 ldr r3, [r7] <== NOT EXECUTED 3000b780: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b784: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000b788: e1a0100b mov r1, fp <== NOT EXECUTED 3000b78c: e59f20b4 ldr r2, [pc, #180] ; 3000b848 <_Heap_Walk+0x58c> <== NOT EXECUTED 3000b790: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b794: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b798: e12fff14 bx r4 <== NOT EXECUTED block->prev_size ); } block = next_block; } while ( block != first_block ); 3000b79c: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000b7a0: e1580002 cmp r8, r2 <== NOT EXECUTED 3000b7a4: 1affff6a bne 3000b554 <_Heap_Walk+0x298> <== 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; 3000b7a8: e3a08001 mov r8, #1 <== NOT EXECUTED block = next_block; } while ( block != first_block ); return true; } 3000b7ac: e1a00008 mov r0, r8 <== NOT EXECUTED 3000b7b0: e28dd030 add sp, sp, #48 ; 0x30 <== NOT EXECUTED 3000b7b4: 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)( 3000b7b8: e59f208c ldr r2, [pc, #140] ; 3000b84c <_Heap_Walk+0x590> <== NOT EXECUTED 3000b7bc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b7c0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b7c4: e1a03007 mov r3, r7 <== NOT EXECUTED 3000b7c8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b7cc: e12fff14 bx r4 <== NOT EXECUTED return false; } if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; 3000b7d0: e3a08000 mov r8, #0 <== NOT EXECUTED 3000b7d4: eafffff4 b 3000b7ac <_Heap_Walk+0x4f0> <== NOT EXECUTED =============================================================================== 3000b278 <_Heap_Walk_print>: static void _Heap_Walk_print( int source, bool error, const char *fmt, ... ) { 3000b278: e92d000c push {r2, r3} <== NOT EXECUTED 3000b27c: e92d4001 push {r0, lr} <== NOT EXECUTED 3000b280: e1a03000 mov r3, r0 <== NOT EXECUTED va_list ap; if ( error ) { 3000b284: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED printk( "FAIL[%d]: ", source ); 3000b288: 159f0024 ldrne r0, [pc, #36] ; 3000b2b4 <_Heap_Walk_print+0x3c><== NOT EXECUTED } else { printk( "PASS[%d]: ", source ); 3000b28c: 059f0024 ldreq r0, [pc, #36] ; 3000b2b8 <_Heap_Walk_print+0x40><== NOT EXECUTED 3000b290: e1a01003 mov r1, r3 <== NOT EXECUTED 3000b294: ebfff17d bl 30007890 <== NOT EXECUTED } va_start( ap, fmt ); 3000b298: e28d100c add r1, sp, #12 <== NOT EXECUTED vprintk( fmt, ap ); 3000b29c: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED printk( "FAIL[%d]: ", source ); } else { printk( "PASS[%d]: ", source ); } va_start( ap, fmt ); 3000b2a0: e58d1000 str r1, [sp] <== NOT EXECUTED vprintk( fmt, ap ); 3000b2a4: ebfff847 bl 300093c8 <== NOT EXECUTED va_end( ap ); } 3000b2a8: e8bd4008 pop {r3, lr} <== NOT EXECUTED 3000b2ac: e28dd008 add sp, sp, #8 <== NOT EXECUTED 3000b2b0: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b26c <_Heap_Walk_print_nothing>: int source, bool error, const char *fmt, ... ) { 3000b26c: e92d000c push {r2, r3} <== NOT EXECUTED /* Do nothing */ } 3000b270: e28dd008 add sp, sp, #8 <== NOT EXECUTED 3000b274: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000a6a0 <_Internal_error_Occurred>: bool is_internal, Internal_errors_t the_error ) { _Internal_errors_What_happened.the_source = the_source; 3000a6a0: e59f3038 ldr r3, [pc, #56] ; 3000a6e0 <_Internal_error_Occurred+0x40> void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 3000a6a4: e20110ff and r1, r1, #255 ; 0xff 3000a6a8: e52de004 push {lr} ; (str lr, [sp, #-4]!) _Internal_errors_What_happened.the_source = the_source; 3000a6ac: e5830000 str r0, [r3] _Internal_errors_What_happened.is_internal = is_internal; 3000a6b0: e5c31004 strb r1, [r3, #4] _Internal_errors_What_happened.the_error = the_error; 3000a6b4: e5832008 str r2, [r3, #8] void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 3000a6b8: e1a04002 mov r4, r2 _Internal_errors_What_happened.the_source = the_source; _Internal_errors_What_happened.is_internal = is_internal; _Internal_errors_What_happened.the_error = the_error; _User_extensions_Fatal( the_source, is_internal, the_error ); 3000a6bc: eb000738 bl 3000c3a4 <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 3000a6c0: e59f301c ldr r3, [pc, #28] ; 3000a6e4 <_Internal_error_Occurred+0x44><== NOT EXECUTED 3000a6c4: e3a02005 mov r2, #5 <== NOT EXECUTED 3000a6c8: e5832000 str r2, [r3] <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000a6cc: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000a6d0: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000a6d4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 3000a6d8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a6dc: eafffffe b 3000a6dc <_Internal_error_Occurred+0x3c> <== NOT EXECUTED =============================================================================== 3000ab6c <_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; 3000ab6c: e5903008 ldr r3, [r0, #8] Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 3000ab70: 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; 3000ab74: e2633001 rsb r3, r3, #1 Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 3000ab78: 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 ) { 3000ab7c: 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; 3000ab80: 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 ) { 3000ab84: 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; 3000ab88: 83a03001 movhi r3, #1 3000ab8c: 85843000 strhi r3, [r4] #if defined(RTEMS_MULTIPROCESSING) _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; 3000ab90: 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 ) { 3000ab94: 8a00000b bhi 3000abc8 <_Objects_Get+0x5c> rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 3000ab98: e59f2030 ldr r2, [pc, #48] ; 3000abd0 <_Objects_Get+0x64> 3000ab9c: e5921000 ldr r1, [r2] 3000aba0: e2811001 add r1, r1, #1 3000aba4: e5821000 str r1, [r2] _Thread_Disable_dispatch(); if ( (the_object = information->local_table[ index ]) != NULL ) { 3000aba8: e590201c ldr r2, [r0, #28] 3000abac: e7925103 ldr r5, [r2, r3, lsl #2] 3000abb0: e3550000 cmp r5, #0 *location = OBJECTS_LOCAL; 3000abb4: 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 ) { 3000abb8: 1a000001 bne 3000abc4 <_Objects_Get+0x58> /* * Valid Id for this API, Class and Node but the object has not * been allocated yet. */ _Thread_Enable_dispatch(); 3000abbc: eb000304 bl 3000b7d4 <_Thread_Enable_dispatch> <== NOT EXECUTED *location = OBJECTS_ERROR; 3000abc0: e3a03001 mov r3, #1 <== NOT EXECUTED 3000abc4: e5843000 str r3, [r4] _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 3000abc8: e1a00005 mov r0, r5 3000abcc: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000aaa0 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 3000aaa0: e1a01801 lsl r1, r1, #16 3000aaa4: e92d4030 push {r4, r5, lr} Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 3000aaa8: e1b05821 lsrs r5, r1, #16 Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 3000aaac: e1a04000 mov r4, r0 Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 3000aab0: 01a00005 moveq r0, r5 ) { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 3000aab4: 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 ); 3000aab8: eb000ff4 bl 3000ea90 <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 3000aabc: e3500000 cmp r0, #0 3000aac0: 08bd8030 popeq {r4, r5, pc} return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 3000aac4: e1550000 cmp r5, r0 3000aac8: 8a00000a bhi 3000aaf8 <_Objects_Get_information+0x58> return NULL; if ( !_Objects_Information_table[ the_api ] ) 3000aacc: e59f302c ldr r3, [pc, #44] ; 3000ab00 <_Objects_Get_information+0x60> 3000aad0: e7930104 ldr r0, [r3, r4, lsl #2] 3000aad4: e3500000 cmp r0, #0 3000aad8: 08bd8030 popeq {r4, r5, pc} return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 3000aadc: e7900105 ldr r0, [r0, r5, lsl #2] if ( !info ) 3000aae0: e3500000 cmp r0, #0 3000aae4: 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 ) 3000aae8: e1d031b0 ldrh r3, [r0, #16] return NULL; 3000aaec: e3530000 cmp r3, #0 3000aaf0: 03a00000 moveq r0, #0 3000aaf4: 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; 3000aaf8: e3a00000 mov r0, #0 <== NOT EXECUTED if ( info->maximum == 0 ) return NULL; #endif return info; } 3000aafc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 3000ab04 <_Objects_Get_isr_disable>: { Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 3000ab04: e590c008 ldr ip, [r0, #8] Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 3000ab08: e92d4010 push {r4, lr} Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 3000ab0c: e26cc001 rsb ip, ip, #1 3000ab10: e08c1001 add r1, ip, r1 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000ab14: e10f4000 mrs r4, CPSR 3000ab18: e384c080 orr ip, r4, #128 ; 0x80 3000ab1c: e129f00c msr CPSR_fc, ip _ISR_Disable( level ); if ( information->maximum >= index ) { 3000ab20: e1d0c1b0 ldrh ip, [r0, #16] 3000ab24: e15c0001 cmp ip, r1 3000ab28: 3a00000a bcc 3000ab58 <_Objects_Get_isr_disable+0x54> if ( (the_object = information->local_table[ index ]) != NULL ) { 3000ab2c: e590001c ldr r0, [r0, #28] 3000ab30: e7900101 ldr r0, [r0, r1, lsl #2] 3000ab34: e3500000 cmp r0, #0 *location = OBJECTS_LOCAL; 3000ab38: 13a01000 movne r1, #0 3000ab3c: 15821000 strne r1, [r2] *level_p = level; 3000ab40: 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 ) { 3000ab44: 18bd8010 popne {r4, pc} static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000ab48: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED *location = OBJECTS_LOCAL; *level_p = level; return the_object; } _ISR_Enable( level ); *location = OBJECTS_ERROR; 3000ab4c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ab50: e5823000 str r3, [r2] <== NOT EXECUTED return NULL; 3000ab54: e8bd8010 pop {r4, pc} <== NOT EXECUTED 3000ab58: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED } _ISR_Enable( level ); *location = OBJECTS_ERROR; 3000ab5c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ab60: 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; 3000ab64: e3a00000 mov r0, #0 <== NOT EXECUTED #endif } 3000ab68: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000c5b8 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 3000c5b8: 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 ) 3000c5bc: e2515000 subs r5, r1, #0 <== NOT EXECUTED char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 3000c5c0: e1a04002 mov r4, r2 <== NOT EXECUTED Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) return NULL; 3000c5c4: 01a04005 moveq r4, r5 <== NOT EXECUTED char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 3000c5c8: 0a00002e beq 3000c688 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED return NULL; if ( name == NULL ) 3000c5cc: e3540000 cmp r4, #0 <== NOT EXECUTED 3000c5d0: 0a00002c beq 3000c688 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 3000c5d4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c5d8: 059f30b0 ldreq r3, [pc, #176] ; 3000c690 <_Objects_Get_name_as_string+0xd8><== NOT EXECUTED 3000c5dc: 11a06000 movne r6, r0 <== NOT EXECUTED 3000c5e0: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000c5e4: 05936008 ldreq r6, [r3, #8] <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 3000c5e8: e1a00006 mov r0, r6 <== NOT EXECUTED 3000c5ec: ebffffb9 bl 3000c4d8 <_Objects_Get_information_id> <== NOT EXECUTED if ( !information ) 3000c5f0: e2503000 subs r3, r0, #0 <== NOT EXECUTED return NULL; 3000c5f4: 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 ) 3000c5f8: 0a000022 beq 3000c688 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, tmpId, &location ); 3000c5fc: e1a01006 mov r1, r6 <== NOT EXECUTED 3000c600: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000c604: eb000023 bl 3000c698 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 3000c608: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3000c60c: e3530000 cmp r3, #0 <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* not supported */ #endif case OBJECTS_ERROR: return NULL; 3000c610: 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 ) { 3000c614: 1a00001b bne 3000c688 <_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; 3000c618: 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'; 3000c61c: 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; 3000c620: e1a01c22 lsr r1, r2, #24 <== NOT EXECUTED 3000c624: e5cd1000 strb r1, [sp] <== NOT EXECUTED lname[ 1 ] = (u32_name >> 16) & 0xff; 3000c628: e1a01822 lsr r1, r2, #16 <== NOT EXECUTED 3000c62c: e5cd1001 strb r1, [sp, #1] <== NOT EXECUTED lname[ 2 ] = (u32_name >> 8) & 0xff; 3000c630: e1a01422 lsr r1, r2, #8 <== NOT EXECUTED lname[ 3 ] = (u32_name >> 0) & 0xff; 3000c634: e5cd2003 strb r2, [sp, #3] <== NOT EXECUTED { uint32_t u32_name = (uint32_t) the_object->name.name_u32; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 3000c638: e5cd1002 strb r1, [sp, #2] <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 3000c63c: e1a02004 mov r2, r4 <== NOT EXECUTED 3000c640: e2455001 sub r5, r5, #1 <== NOT EXECUTED *d = (isprint((unsigned char)*s)) ? *s : '*'; 3000c644: e59f0048 ldr r0, [pc, #72] ; 3000c694 <_Objects_Get_name_as_string+0xdc><== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 3000c648: ea000006 b 3000c668 <_Objects_Get_name_as_string+0xb0> <== NOT EXECUTED *d = (isprint((unsigned char)*s)) ? *s : '*'; 3000c64c: e590c000 ldr ip, [r0] <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 3000c650: e2833001 add r3, r3, #1 <== NOT EXECUTED *d = (isprint((unsigned char)*s)) ? *s : '*'; 3000c654: e08cc001 add ip, ip, r1 <== NOT EXECUTED 3000c658: e5dcc001 ldrb ip, [ip, #1] <== NOT EXECUTED 3000c65c: e31c0097 tst ip, #151 ; 0x97 <== NOT EXECUTED 3000c660: 03a0102a moveq r1, #42 ; 0x2a <== NOT EXECUTED 3000c664: e4c21001 strb r1, [r2], #1 <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 3000c668: e1530005 cmp r3, r5 <== NOT EXECUTED 3000c66c: 2a000002 bcs 3000c67c <_Objects_Get_name_as_string+0xc4> <== NOT EXECUTED 3000c670: e7dd1003 ldrb r1, [sp, r3] <== NOT EXECUTED 3000c674: e3510000 cmp r1, #0 <== NOT EXECUTED 3000c678: 1afffff3 bne 3000c64c <_Objects_Get_name_as_string+0x94> <== NOT EXECUTED *d = (isprint((unsigned char)*s)) ? *s : '*'; } } *d = '\0'; 3000c67c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000c680: e5c23000 strb r3, [r2] <== NOT EXECUTED _Thread_Enable_dispatch(); 3000c684: eb0002fb bl 3000d278 <_Thread_Enable_dispatch> <== NOT EXECUTED return name; } return NULL; /* unreachable path */ } 3000c688: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c68c: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000ad20 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 3000ad20: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED Objects_Control *object; Objects_Id next_id; if ( !information ) 3000ad24: e2507000 subs r7, r0, #0 <== NOT EXECUTED Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 3000ad28: e1a04002 mov r4, r2 <== NOT EXECUTED 3000ad2c: e1a06003 mov r6, r3 <== NOT EXECUTED Objects_Control *object; Objects_Id next_id; if ( !information ) return NULL; 3000ad30: 01a00007 moveq r0, r7 <== NOT EXECUTED ) { Objects_Control *object; Objects_Id next_id; if ( !information ) 3000ad34: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED return NULL; if ( !location_p ) 3000ad38: e3520000 cmp r2, #0 <== NOT EXECUTED return NULL; 3000ad3c: 01a00002 moveq r0, r2 <== NOT EXECUTED Objects_Id next_id; if ( !information ) return NULL; if ( !location_p ) 3000ad40: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED return NULL; if ( !next_id_p ) 3000ad44: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ad48: 0a000016 beq 3000ada8 <_Objects_Get_next+0x88> <== NOT EXECUTED return NULL; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 3000ad4c: e1b03801 lsls r3, r1, #16 <== NOT EXECUTED next_id = information->minimum_id; 3000ad50: 05975008 ldreq r5, [r7, #8] <== NOT EXECUTED else next_id = id; 3000ad54: 11a05001 movne r5, r1 <== NOT EXECUTED do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 3000ad58: e1d731b0 ldrh r3, [r7, #16] <== NOT EXECUTED 3000ad5c: e1a02805 lsl r2, r5, #16 <== NOT EXECUTED 3000ad60: e1530822 cmp r3, r2, lsr #16 <== NOT EXECUTED 3000ad64: 2a000005 bcs 3000ad80 <_Objects_Get_next+0x60> <== NOT EXECUTED { *location_p = OBJECTS_ERROR; 3000ad68: e3a03001 mov r3, #1 <== NOT EXECUTED 3000ad6c: e5843000 str r3, [r4] <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 3000ad70: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000ad74: e5863000 str r3, [r6] <== NOT EXECUTED return 0; 3000ad78: e3a00000 mov r0, #0 <== NOT EXECUTED 3000ad7c: 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); 3000ad80: e1a01005 mov r1, r5 <== NOT EXECUTED 3000ad84: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ad88: e1a02004 mov r2, r4 <== NOT EXECUTED 3000ad8c: eb000007 bl 3000adb0 <_Objects_Get> <== NOT EXECUTED next_id++; } while (*location_p != OBJECTS_LOCAL); 3000ad90: e5943000 ldr r3, [r4] <== NOT EXECUTED } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); next_id++; 3000ad94: e2855001 add r5, r5, #1 <== NOT EXECUTED } while (*location_p != OBJECTS_LOCAL); 3000ad98: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ad9c: 1affffed bne 3000ad58 <_Objects_Get_next+0x38> <== NOT EXECUTED *next_id_p = next_id; 3000ada0: e5865000 str r5, [r6] <== NOT EXECUTED return object; 3000ada4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED if ( !location_p ) return NULL; if ( !next_id_p ) return NULL; 3000ada8: e1a00003 mov r0, r3 <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 3000adac: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3001acc0 <_Objects_Get_no_protection>: /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 3001acc0: e5903008 ldr r3, [r0, #8] 3001acc4: e2633001 rsb r3, r3, #1 3001acc8: e0833001 add r3, r3, r1 if ( information->maximum >= index ) { 3001accc: e1d011b0 ldrh r1, [r0, #16] 3001acd0: e1510003 cmp r1, r3 3001acd4: 3a000005 bcc 3001acf0 <_Objects_Get_no_protection+0x30> if ( (the_object = information->local_table[ index ]) != NULL ) { 3001acd8: e590101c ldr r1, [r0, #28] 3001acdc: e7910103 ldr r0, [r1, r3, lsl #2] 3001ace0: e3500000 cmp r0, #0 *location = OBJECTS_LOCAL; 3001ace4: 13a03000 movne r3, #0 3001ace8: 15823000 strne r3, [r2] * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; if ( information->maximum >= index ) { if ( (the_object = information->local_table[ index ]) != NULL ) { 3001acec: 112fff1e bxne lr /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 3001acf0: e3a03001 mov r3, #1 <== NOT EXECUTED 3001acf4: e5823000 str r3, [r2] <== NOT EXECUTED return NULL; 3001acf8: e3a00000 mov r0, #0 <== NOT EXECUTED } 3001acfc: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000c0c8 <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 3000c0c8: e92d4011 push {r0, r4, lr} <== NOT EXECUTED 3000c0cc: e1a04001 mov r4, r1 <== NOT EXECUTED /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 3000c0d0: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000c0d4: 059f306c ldreq r3, [pc, #108] ; 3000c148 <_Objects_Id_to_name+0x80><== NOT EXECUTED 3000c0d8: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000c0dc: 05931008 ldreq r1, [r3, #8] <== NOT EXECUTED 3000c0e0: e1a03c21 lsr r3, r1, #24 <== NOT EXECUTED 3000c0e4: e2033007 and r3, r3, #7 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 3000c0e8: e2432001 sub r2, r3, #1 <== NOT EXECUTED 3000c0ec: e3520002 cmp r2, #2 <== NOT EXECUTED 3000c0f0: 8a00000d bhi 3000c12c <_Objects_Id_to_name+0x64> <== NOT EXECUTED 3000c0f4: ea00000e b 3000c134 <_Objects_Id_to_name+0x6c> <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 3000c0f8: e1a02da1 lsr r2, r1, #27 <== NOT EXECUTED if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 3000c0fc: e7930102 ldr r0, [r3, r2, lsl #2] <== NOT EXECUTED if ( !information ) 3000c100: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c104: 0a000008 beq 3000c12c <_Objects_Id_to_name+0x64> <== NOT EXECUTED #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 ); 3000c108: e1a0200d mov r2, sp <== NOT EXECUTED 3000c10c: ebffffd3 bl 3000c060 <_Objects_Get> <== NOT EXECUTED if ( !the_object ) 3000c110: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c114: 0a000004 beq 3000c12c <_Objects_Id_to_name+0x64> <== NOT EXECUTED return OBJECTS_INVALID_ID; *name = the_object->name; 3000c118: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3000c11c: e5843000 str r3, [r4] <== NOT EXECUTED _Thread_Enable_dispatch(); 3000c120: eb00030a bl 3000cd50 <_Thread_Enable_dispatch> <== NOT EXECUTED return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 3000c124: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c128: ea000000 b 3000c130 <_Objects_Id_to_name+0x68> <== NOT EXECUTED 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; 3000c12c: e3a00003 mov r0, #3 <== NOT EXECUTED return OBJECTS_INVALID_ID; *name = the_object->name; _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 3000c130: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 3000c134: e59f2010 ldr r2, [pc, #16] ; 3000c14c <_Objects_Id_to_name+0x84><== NOT EXECUTED 3000c138: e7923103 ldr r3, [r2, r3, lsl #2] <== NOT EXECUTED 3000c13c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c140: 1affffec bne 3000c0f8 <_Objects_Id_to_name+0x30> <== NOT EXECUTED 3000c144: eafffff8 b 3000c12c <_Objects_Id_to_name+0x64> <== NOT EXECUTED =============================================================================== 3000aca0 <_Objects_Name_to_id_u32>: Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == false */ if ( !id ) 3000aca0: e3530000 cmp r3, #0 Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 3000aca4: e92d4030 push {r4, r5, lr} #endif /* ASSERT: information->is_string == false */ if ( !id ) return OBJECTS_INVALID_ADDRESS; 3000aca8: 03a00002 moveq r0, #2 Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == false */ if ( !id ) 3000acac: 08bd8030 popeq {r4, r5, pc} return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 3000acb0: e3510000 cmp r1, #0 3000acb4: 0a000017 beq 3000ad18 <_Objects_Name_to_id_u32+0x78> return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && 3000acb8: e1d041b0 ldrh r4, [r0, #16] 3000acbc: e3540000 cmp r4, #0 3000acc0: 0a000016 beq 3000ad20 <_Objects_Name_to_id_u32+0x80> 3000acc4: e3720106 cmn r2, #-2147483647 ; 0x80000001 3000acc8: 13520000 cmpne r2, #0 3000accc: 03a02001 moveq r2, #1 3000acd0: 0a00000e beq 3000ad10 <_Objects_Name_to_id_u32+0x70> (node == OBJECTS_SEARCH_ALL_NODES || node == OBJECTS_SEARCH_LOCAL_NODE || 3000acd4: e3520001 cmp r2, #1 <== NOT EXECUTED 3000acd8: 1a00000e bne 3000ad18 <_Objects_Name_to_id_u32+0x78> <== NOT EXECUTED 3000acdc: ea00000b b 3000ad10 <_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 ]; 3000ace0: e590c01c ldr ip, [r0, #28] 3000ace4: e79cc102 ldr ip, [ip, r2, lsl #2] if ( !the_object ) 3000ace8: e35c0000 cmp ip, #0 3000acec: 0a000006 beq 3000ad0c <_Objects_Name_to_id_u32+0x6c> continue; if ( name == the_object->name.name_u32 ) { 3000acf0: e59c500c ldr r5, [ip, #12] 3000acf4: e1510005 cmp r1, r5 3000acf8: 1a000003 bne 3000ad0c <_Objects_Name_to_id_u32+0x6c> *id = the_object->id; 3000acfc: e59c2008 ldr r2, [ip, #8] return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 3000ad00: 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; 3000ad04: e5832000 str r2, [r3] return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 3000ad08: 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++ ) { 3000ad0c: e2822001 add r2, r2, #1 3000ad10: e1520004 cmp r2, r4 3000ad14: 9afffff1 bls 3000ace0 <_Objects_Name_to_id_u32+0x40> if ( !id ) return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) return OBJECTS_INVALID_NAME; 3000ad18: e3a00001 mov r0, #1 <== NOT EXECUTED 3000ad1c: 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; 3000ad20: e3a00001 mov r0, #1 #endif } 3000ad24: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000d080 <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 3000d080: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 3000d084: e1a04001 mov r4, r1 <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ); 3000d088: e1d013b8 ldrh r1, [r0, #56] ; 0x38 <== NOT EXECUTED 3000d08c: e1a00002 mov r0, r2 <== NOT EXECUTED bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 3000d090: e1a05002 mov r5, r2 <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ); 3000d094: eb001b8f bl 30013ed8 <== NOT EXECUTED d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 3000d098: e3500001 cmp r0, #1 <== NOT EXECUTED 3000d09c: 85d53001 ldrbhi r3, [r5, #1] <== NOT EXECUTED 3000d0a0: e5d52000 ldrb r2, [r5] <== NOT EXECUTED 3000d0a4: 81a03803 lslhi r3, r3, #16 <== NOT EXECUTED 3000d0a8: 93a03602 movls r3, #2097152 ; 0x200000 <== NOT EXECUTED 3000d0ac: e1a02c02 lsl r2, r2, #24 <== NOT EXECUTED 3000d0b0: e3500002 cmp r0, #2 <== NOT EXECUTED 3000d0b4: e1832002 orr r2, r3, r2 <== NOT EXECUTED 3000d0b8: 85d53002 ldrbhi r3, [r5, #2] <== NOT EXECUTED 3000d0bc: 93a03a02 movls r3, #8192 ; 0x2000 <== NOT EXECUTED 3000d0c0: 81a03403 lslhi r3, r3, #8 <== NOT EXECUTED 3000d0c4: e3500003 cmp r0, #3 <== NOT EXECUTED 3000d0c8: e1822003 orr r2, r2, r3 <== NOT EXECUTED 3000d0cc: 85d53003 ldrbhi r3, [r5, #3] <== NOT EXECUTED 3000d0d0: 93a03020 movls r3, #32 <== NOT EXECUTED 3000d0d4: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000d0d8: e584300c str r3, [r4, #12] <== NOT EXECUTED ); } return true; } 3000d0dc: e3a00001 mov r0, #1 <== NOT EXECUTED 3000d0e0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 3000b0f8 <_Protected_heap_Extend>: bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, uintptr_t size ) { 3000b0f8: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED bool extend_ok; uintptr_t amount_extended; _RTEMS_Lock_allocator(); 3000b0fc: e59f4038 ldr r4, [pc, #56] ; 3000b13c <_Protected_heap_Extend+0x44><== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, uintptr_t size ) { 3000b100: e1a05000 mov r5, r0 <== NOT EXECUTED 3000b104: e1a07001 mov r7, r1 <== NOT EXECUTED 3000b108: e1a06002 mov r6, r2 <== NOT EXECUTED bool extend_ok; uintptr_t amount_extended; _RTEMS_Lock_allocator(); 3000b10c: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000b110: ebfffbd8 bl 3000a078 <_API_Mutex_Lock> <== NOT EXECUTED extend_ok = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 3000b114: e1a01007 mov r1, r7 <== NOT EXECUTED 3000b118: e1a02006 mov r2, r6 <== NOT EXECUTED 3000b11c: e1a0300d mov r3, sp <== NOT EXECUTED 3000b120: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b124: eb000eab bl 3000ebd8 <_Heap_Extend> <== NOT EXECUTED 3000b128: e1a05000 mov r5, r0 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 3000b12c: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000b130: ebfffbe9 bl 3000a0dc <_API_Mutex_Unlock> <== NOT EXECUTED return extend_ok; } 3000b134: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b138: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3000b4e8 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 3000b4e8: e92d4070 push {r4, r5, r6, lr} if ( !the_heap ) 3000b4ec: e2506000 subs r6, r0, #0 bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 3000b4f0: e1a05001 mov r5, r1 if ( !the_heap ) return false; 3000b4f4: 01a00006 moveq r0, r6 bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { if ( !the_heap ) 3000b4f8: 08bd8070 popeq {r4, r5, r6, pc} return false; if ( !the_info ) 3000b4fc: e3510000 cmp r1, #0 3000b500: 0a000009 beq 3000b52c <_Protected_heap_Get_information+0x44> return false; _RTEMS_Lock_allocator(); 3000b504: e59f4028 ldr r4, [pc, #40] ; 3000b534 <_Protected_heap_Get_information+0x4c> 3000b508: e5940000 ldr r0, [r4] 3000b50c: ebfffbc6 bl 3000a42c <_API_Mutex_Lock> _Heap_Get_information( the_heap, the_info ); 3000b510: e1a00006 mov r0, r6 3000b514: e1a01005 mov r1, r5 3000b518: eb000fcc bl 3000f450 <_Heap_Get_information> _RTEMS_Unlock_allocator(); 3000b51c: e5940000 ldr r0, [r4] 3000b520: ebfffbda bl 3000a490 <_API_Mutex_Unlock> return true; 3000b524: e3a00001 mov r0, #1 3000b528: e8bd8070 pop {r4, r5, r6, pc} { if ( !the_heap ) return false; if ( !the_info ) return false; 3000b52c: e1a00001 mov r0, r1 <== NOT EXECUTED _RTEMS_Lock_allocator(); _Heap_Get_information( the_heap, the_info ); _RTEMS_Unlock_allocator(); return true; } 3000b530: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000ffcc <_Protected_heap_Walk>: * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { 3000ffcc: e59f3054 ldr r3, [pc, #84] ; 30010028 <_Protected_heap_Walk+0x5c><== NOT EXECUTED bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 3000ffd0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { 3000ffd4: e5933000 ldr r3, [r3] <== NOT EXECUTED bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 3000ffd8: e1a06000 mov r6, r0 <== NOT EXECUTED * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { 3000ffdc: e3530000 cmp r3, #0 <== NOT EXECUTED bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 3000ffe0: e1a05001 mov r5, r1 <== NOT EXECUTED 3000ffe4: e20270ff and r7, r2, #255 ; 0xff <== NOT EXECUTED * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { 3000ffe8: 1a00000b bne 3001001c <_Protected_heap_Walk+0x50> <== NOT EXECUTED _RTEMS_Lock_allocator(); 3000ffec: e59f4038 ldr r4, [pc, #56] ; 3001002c <_Protected_heap_Walk+0x60><== NOT EXECUTED 3000fff0: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000fff4: ebfff86d bl 3000e1b0 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Walk( the_heap, source, do_dump ); 3000fff8: e1a01005 mov r1, r5 <== NOT EXECUTED 3000fffc: e1a02007 mov r2, r7 <== NOT EXECUTED 30010000: e1a00006 mov r0, r6 <== NOT EXECUTED 30010004: ebfffc3e bl 3000f104 <_Heap_Walk> <== NOT EXECUTED 30010008: e1a05000 mov r5, r0 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 3001000c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010010: ebfff87f bl 3000e214 <_API_Mutex_Unlock> <== NOT EXECUTED } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 30010014: e1a00005 mov r0, r5 <== NOT EXECUTED 30010018: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 3001001c: e1a02007 mov r2, r7 <== NOT EXECUTED } return status; } 30010020: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 30010024: eafffc36 b 3000f104 <_Heap_Walk> <== NOT EXECUTED =============================================================================== 3000e410 <_RTEMS_Tasks_Invoke_task_variable_dtor>: RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 3000e410: e59f203c ldr r2, [pc, #60] ; 3000e454 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x44><== NOT EXECUTED ) { void (*dtor)(void *); void *value; dtor = tvp->dtor; 3000e414: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED if (_Thread_Is_executing(the_thread)) { 3000e418: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED void _RTEMS_Tasks_Invoke_task_variable_dtor( Thread_Control *the_thread, rtems_task_variable_t *tvp ) { 3000e41c: e92d4010 push {r4, lr} <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; if (_Thread_Is_executing(the_thread)) { 3000e420: e1520000 cmp r2, r0 <== NOT EXECUTED value = *tvp->ptr; 3000e424: 05912004 ldreq r2, [r1, #4] <== NOT EXECUTED void _RTEMS_Tasks_Invoke_task_variable_dtor( Thread_Control *the_thread, rtems_task_variable_t *tvp ) { 3000e428: e1a04001 mov r4, r1 <== NOT EXECUTED void *value; dtor = tvp->dtor; if (_Thread_Is_executing(the_thread)) { value = *tvp->ptr; *tvp->ptr = tvp->gval; 3000e42c: 05911008 ldreq r1, [r1, #8] <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; if (_Thread_Is_executing(the_thread)) { value = *tvp->ptr; 3000e430: 05920000 ldreq r0, [r2] <== NOT EXECUTED *tvp->ptr = tvp->gval; } else { value = tvp->tval; 3000e434: 1594000c ldrne r0, [r4, #12] <== NOT EXECUTED void *value; dtor = tvp->dtor; if (_Thread_Is_executing(the_thread)) { value = *tvp->ptr; *tvp->ptr = tvp->gval; 3000e438: 05821000 streq r1, [r2] <== NOT EXECUTED } else { value = tvp->tval; } if ( dtor ) 3000e43c: e3530000 cmp r3, #0 <== NOT EXECUTED (*dtor)(value); 3000e440: 11a0e00f movne lr, pc <== NOT EXECUTED 3000e444: 112fff13 bxne r3 <== NOT EXECUTED _Workspace_Free(tvp); 3000e448: e1a00004 mov r0, r4 <== NOT EXECUTED } 3000e44c: e8bd4010 pop {r4, lr} <== NOT EXECUTED } if ( dtor ) (*dtor)(value); _Workspace_Free(tvp); 3000e450: eafff8f0 b 3000c818 <_Workspace_Free> <== NOT EXECUTED =============================================================================== 3000e2e8 <_RTEMS_tasks_Delete_extension>: /* * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; 3000e2e8: e3a03000 mov r3, #0 void _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 3000e2ec: e92d4070 push {r4, r5, r6, lr} /* * Free per task variable memory */ tvp = deleted->task_variables; 3000e2f0: e5916100 ldr r6, [r1, #256] ; 0x100 void _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 3000e2f4: e1a04001 mov r4, r1 /* * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; 3000e2f8: e5813100 str r3, [r1, #256] ; 0x100 while (tvp) { 3000e2fc: ea000004 b 3000e314 <_RTEMS_tasks_Delete_extension+0x2c> next = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 3000e300: e1a01006 mov r1, r6 <== NOT EXECUTED 3000e304: e1a00004 mov r0, r4 <== NOT EXECUTED */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { next = (rtems_task_variable_t *)tvp->next; 3000e308: e5965000 ldr r5, [r6] <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 3000e30c: eb00003f bl 3000e410 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED tvp = next; 3000e310: e1a06005 mov r6, r5 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 3000e314: e3560000 cmp r6, #0 3000e318: 1afffff8 bne 3000e300 <_RTEMS_tasks_Delete_extension+0x18> /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 3000e31c: e59400f4 ldr r0, [r4, #244] ; 0xf4 3000e320: ebfff93c bl 3000c818 <_Workspace_Free> deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 3000e324: e58460f4 str r6, [r4, #244] ; 0xf4 } 3000e328: e8bd8070 pop {r4, r5, r6, pc} =============================================================================== 3000e1ec <_RTEMS_tasks_Switch_extension>: /* * Per Task Variables */ tvp = executing->task_variables; 3000e1ec: e5903100 ldr r3, [r0, #256] ; 0x100 while (tvp) { 3000e1f0: ea000005 b 3000e20c <_RTEMS_tasks_Switch_extension+0x20> tvp->tval = *tvp->ptr; 3000e1f4: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000e1f8: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000e1fc: e583000c str r0, [r3, #12] <== NOT EXECUTED *tvp->ptr = tvp->gval; 3000e200: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 3000e204: e5933000 ldr r3, [r3] <== NOT EXECUTED */ tvp = executing->task_variables; while (tvp) { tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; 3000e208: e5820000 str r0, [r2] <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 3000e20c: e3530000 cmp r3, #0 3000e210: 1afffff7 bne 3000e1f4 <_RTEMS_tasks_Switch_extension+0x8> tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 3000e214: e5913100 ldr r3, [r1, #256] ; 0x100 while (tvp) { 3000e218: ea000005 b 3000e234 <_RTEMS_tasks_Switch_extension+0x48> tvp->gval = *tvp->ptr; 3000e21c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000e220: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000e224: e5831008 str r1, [r3, #8] <== NOT EXECUTED *tvp->ptr = tvp->tval; 3000e228: e593100c ldr r1, [r3, #12] <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 3000e22c: e5933000 ldr r3, [r3] <== NOT EXECUTED } tvp = heir->task_variables; while (tvp) { tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; 3000e230: e5821000 str r1, [r2] <== NOT EXECUTED *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 3000e234: e3530000 cmp r3, #0 3000e238: 1afffff7 bne 3000e21c <_RTEMS_tasks_Switch_extension+0x30> tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 3000e23c: e12fff1e bx lr =============================================================================== 3000a990 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 3000a990: e92d4011 push {r0, r4, lr} <== NOT EXECUTED 3000a994: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a998: e1a0200d mov r2, sp <== NOT EXECUTED 3000a99c: e59f0088 ldr r0, [pc, #136] ; 3000aa2c <_Rate_monotonic_Timeout+0x9c><== NOT EXECUTED 3000a9a0: eb00071c bl 3000c618 <_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 ) { 3000a9a4: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a9a8: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a9ac: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a9b0: 1a00001c bne 3000aa28 <_Rate_monotonic_Timeout+0x98> <== NOT EXECUTED case OBJECTS_LOCAL: the_thread = the_period->owner; 3000a9b4: 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); 3000a9b8: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED if ( _States_Is_waiting_for_period( the_thread->current_state ) && 3000a9bc: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 3000a9c0: 0a000006 beq 3000a9e0 <_Rate_monotonic_Timeout+0x50> <== NOT EXECUTED 3000a9c4: e5902020 ldr r2, [r0, #32] <== NOT EXECUTED 3000a9c8: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000a9cc: e1520003 cmp r2, r3 <== NOT EXECUTED 3000a9d0: 1a000002 bne 3000a9e0 <_Rate_monotonic_Timeout+0x50> <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 3000a9d4: e59f1054 ldr r1, [pc, #84] ; 3000aa30 <_Rate_monotonic_Timeout+0xa0><== NOT EXECUTED 3000a9d8: eb000964 bl 3000cf70 <_Thread_Clear_state> <== NOT EXECUTED 3000a9dc: ea000006 b 3000a9fc <_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 ) { 3000a9e0: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 3000a9e4: 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; 3000a9e8: 13a03004 movne r3, #4 <== NOT EXECUTED 3000a9ec: 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 ) { 3000a9f0: 1a000008 bne 3000aa18 <_Rate_monotonic_Timeout+0x88> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 3000a9f4: e2833002 add r3, r3, #2 <== NOT EXECUTED 3000a9f8: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); 3000a9fc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aa00: ebfffe7a bl 3000a3f0 <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 3000aa04: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 3000aa08: e59f0024 ldr r0, [pc, #36] ; 3000aa34 <_Rate_monotonic_Timeout+0xa4><== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 3000aa0c: e584301c str r3, [r4, #28] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 3000aa10: e2841010 add r1, r4, #16 <== NOT EXECUTED 3000aa14: eb000db6 bl 3000e0f4 <_Watchdog_Insert> <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 3000aa18: e59f3018 ldr r3, [pc, #24] ; 3000aa38 <_Rate_monotonic_Timeout+0xa8><== NOT EXECUTED 3000aa1c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000aa20: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000aa24: e5832000 str r2, [r3] <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 3000aa28: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED =============================================================================== 3000a5c4 <_TOD_Get_uptime_as_timespec>: */ void _TOD_Get_uptime_as_timespec( struct timespec *uptime ) { 3000a5c4: e92d4013 push {r0, r1, r4, lr} <== NOT EXECUTED 3000a5c8: e1a04000 mov r4, r0 <== NOT EXECUTED Timestamp_Control uptime_ts; /* assume time checked for NULL by caller */ _TOD_Get_uptime( &uptime_ts ); 3000a5cc: e1a0000d mov r0, sp <== NOT EXECUTED 3000a5d0: eb00113c bl 3000eac8 <_TOD_Get_uptime> <== NOT EXECUTED _Timestamp_To_timespec( &uptime_ts, uptime ); 3000a5d4: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED 3000a5d8: e884000c stm r4, {r2, r3} <== NOT EXECUTED } 3000a5dc: e8bd801c pop {r2, r3, r4, pc} <== NOT EXECUTED =============================================================================== 3000a248 <_TOD_Tickle_ticks>: * * Output parameters: NONE */ void _TOD_Tickle_ticks( void ) { 3000a248: e92d4013 push {r0, r1, r4, lr} Timestamp_Control tick; uint32_t seconds; /* Convert the tick quantum to a timestamp */ _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() ); 3000a24c: e3a03000 mov r3, #0 3000a250: e58d3000 str r3, [sp] 3000a254: e59f3054 ldr r3, [pc, #84] ; 3000a2b0 <_TOD_Tickle_ticks+0x68> 3000a258: e3a02ffa mov r2, #1000 ; 0x3e8 3000a25c: e593300c ldr r3, [r3, #12] /* Update the counter of ticks since boot */ _Watchdog_Ticks_since_boot += 1; /* Update the timespec format uptime */ _Timestamp_Add_to( &_TOD_Uptime, &tick ); 3000a260: e1a0100d mov r1, sp { Timestamp_Control tick; uint32_t seconds; /* Convert the tick quantum to a timestamp */ _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() ); 3000a264: e0030392 mul r3, r2, r3 3000a268: e58d3004 str r3, [sp, #4] /* Update the counter of ticks since boot */ _Watchdog_Ticks_since_boot += 1; 3000a26c: e59f3040 ldr r3, [pc, #64] ; 3000a2b4 <_TOD_Tickle_ticks+0x6c> /* Update the timespec format uptime */ _Timestamp_Add_to( &_TOD_Uptime, &tick ); 3000a270: e59f0040 ldr r0, [pc, #64] ; 3000a2b8 <_TOD_Tickle_ticks+0x70> /* Convert the tick quantum to a timestamp */ _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() ); /* Update the counter of ticks since boot */ _Watchdog_Ticks_since_boot += 1; 3000a274: e5932000 ldr r2, [r3] 3000a278: e2822001 add r2, r2, #1 3000a27c: e5832000 str r2, [r3] /* Update the timespec format uptime */ _Timestamp_Add_to( &_TOD_Uptime, &tick ); 3000a280: eb0007d6 bl 3000c1e0 <_Timespec_Add_to> /* we do not care how much the uptime changed */ /* Update the timespec format TOD */ seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick ); 3000a284: e59f0030 ldr r0, [pc, #48] ; 3000a2bc <_TOD_Tickle_ticks+0x74> 3000a288: e1a0100d mov r1, sp 3000a28c: eb0007d3 bl 3000c1e0 <_Timespec_Add_to> 3000a290: e1a04000 mov r4, r0 while ( seconds ) { 3000a294: ea000002 b 3000a2a4 <_TOD_Tickle_ticks+0x5c> */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void ) { _Watchdog_Tickle( &_Watchdog_Seconds_chain ); 3000a298: e59f0020 ldr r0, [pc, #32] ; 3000a2c0 <_TOD_Tickle_ticks+0x78><== NOT EXECUTED 3000a29c: eb00091d bl 3000c718 <_Watchdog_Tickle> <== NOT EXECUTED _Watchdog_Tickle_seconds(); seconds--; 3000a2a0: e2444001 sub r4, r4, #1 <== NOT EXECUTED _Timestamp_Add_to( &_TOD_Uptime, &tick ); /* we do not care how much the uptime changed */ /* Update the timespec format TOD */ seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick ); while ( seconds ) { 3000a2a4: e3540000 cmp r4, #0 3000a2a8: 1afffffa bne 3000a298 <_TOD_Tickle_ticks+0x50> _Watchdog_Tickle_seconds(); seconds--; } } 3000a2ac: e8bd801c pop {r2, r3, r4, pc} =============================================================================== 3000a4b4 <_TOD_Validate>: { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); 3000a4b4: e59f30ac ldr r3, [pc, #172] ; 3000a568 <_TOD_Validate+0xb4> */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 3000a4b8: 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) || 3000a4bc: e2504000 subs r4, r0, #0 { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); 3000a4c0: e593100c ldr r1, [r3, #12] (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; 3000a4c4: 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) || 3000a4c8: 08bd8010 popeq {r4, pc} ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 3000a4cc: e59f0098 ldr r0, [pc, #152] ; 3000a56c <_TOD_Validate+0xb8> 3000a4d0: eb00442d bl 3001b58c <__aeabi_uidiv> rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 3000a4d4: e5943018 ldr r3, [r4, #24] 3000a4d8: e1530000 cmp r3, r0 3000a4dc: 2a00001d bcs 3000a558 <_TOD_Validate+0xa4> (the_tod->ticks >= ticks_per_second) || 3000a4e0: e5943014 ldr r3, [r4, #20] 3000a4e4: e353003b cmp r3, #59 ; 0x3b 3000a4e8: 8a00001a bhi 3000a558 <_TOD_Validate+0xa4> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 3000a4ec: e5943010 ldr r3, [r4, #16] 3000a4f0: e353003b cmp r3, #59 ; 0x3b 3000a4f4: 8a000017 bhi 3000a558 <_TOD_Validate+0xa4> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 3000a4f8: e594300c ldr r3, [r4, #12] 3000a4fc: e3530017 cmp r3, #23 3000a500: 8a000014 bhi 3000a558 <_TOD_Validate+0xa4> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 3000a504: 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) || 3000a508: 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; 3000a50c: 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) || 3000a510: 08bd8010 popeq {r4, pc} (the_tod->month == 0) || 3000a514: e353000c cmp r3, #12 3000a518: 8a00000e bhi 3000a558 <_TOD_Validate+0xa4> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 3000a51c: 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) || 3000a520: e59f1048 ldr r1, [pc, #72] ; 3000a570 <_TOD_Validate+0xbc> 3000a524: e1520001 cmp r2, r1 3000a528: 9a00000c bls 3000a560 <_TOD_Validate+0xac> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 3000a52c: 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) || 3000a530: e3500000 cmp r0, #0 3000a534: 08bd8010 popeq {r4, pc} (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 3000a538: e3120003 tst r2, #3 3000a53c: e59f2030 ldr r2, [pc, #48] ; 3000a574 <_TOD_Validate+0xc0> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 3000a540: 0283300d addeq r3, r3, #13 else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 3000a544: e7924103 ldr r4, [r2, r3, lsl #2] * false - if the the_tod is invalid * * NOTE: This routine only works for leap-years through 2099. */ bool _TOD_Validate( 3000a548: e1500004 cmp r0, r4 3000a54c: 83a00000 movhi r0, #0 3000a550: 93a00001 movls r0, #1 3000a554: 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; 3000a558: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a55c: e8bd8010 pop {r4, pc} <== NOT EXECUTED 3000a560: e3a00000 mov r0, #0 <== NOT EXECUTED if ( the_tod->day > days_in_month ) return false; return true; } 3000a564: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000b3c8 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 3000b3c8: e92d40f0 push {r4, r5, r6, r7, lr} 3000b3cc: e1a04000 mov r4, r0 3000b3d0: e1a05001 mov r5, r1 3000b3d4: e20260ff and r6, r2, #255 ; 0xff States_Control state, original_state; /* * Save original state */ original_state = the_thread->current_state; 3000b3d8: 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 ); 3000b3dc: eb000310 bl 3000c024 <_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 ) 3000b3e0: e5943014 ldr r3, [r4, #20] 3000b3e4: e1530005 cmp r3, r5 _Thread_Set_priority( the_thread, new_priority ); 3000b3e8: 11a00004 movne r0, r4 3000b3ec: 11a01005 movne r1, r5 3000b3f0: 1b0002f3 blne 3000bfc4 <_Thread_Set_priority> static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000b3f4: e10f5000 mrs r5, CPSR 3000b3f8: e3853080 orr r3, r5, #128 ; 0x80 3000b3fc: 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; 3000b400: e5942010 ldr r2, [r4, #16] 3000b404: e2077004 and r7, r7, #4 if ( state != STATES_TRANSIENT ) { 3000b408: e3520004 cmp r2, #4 3000b40c: 0a00000b beq 3000b440 <_Thread_Change_priority+0x78> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 3000b410: 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); 3000b414: 03c23004 biceq r3, r2, #4 <== NOT EXECUTED the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 3000b418: 05843010 streq r3, [r4, #16] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000b41c: 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); 3000b420: e59f3090 ldr r3, [pc, #144] ; 3000b4b8 <_Thread_Change_priority+0xf0><== NOT EXECUTED 3000b424: e0023003 and r3, r2, r3 <== NOT EXECUTED _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { 3000b428: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b42c: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 3000b430: e5940044 ldr r0, [r4, #68] ; 0x44 <== NOT EXECUTED 3000b434: e1a01004 mov r1, r4 <== NOT EXECUTED if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 3000b438: 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 ); 3000b43c: ea0002bb b 3000bf30 <_Thread_queue_Requeue> <== NOT EXECUTED } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 3000b440: e3570000 cmp r7, #0 3000b444: 1a00000a bne 3000b474 <_Thread_Change_priority+0xac> * 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 ) 3000b448: 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 ); 3000b44c: e5847010 str r7, [r4, #16] 3000b450: e59f3064 ldr r3, [pc, #100] ; 3000b4bc <_Thread_Change_priority+0xf4> if ( prepend_it ) 3000b454: 0a000003 beq 3000b468 <_Thread_Change_priority+0xa0> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue_first( the_thread ); 3000b458: e1a00004 mov r0, r4 3000b45c: e1a0e00f mov lr, pc 3000b460: e593f028 ldr pc, [r3, #40] ; 0x28 3000b464: ea000002 b 3000b474 <_Thread_Change_priority+0xac> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue( the_thread ); 3000b468: e1a00004 mov r0, r4 3000b46c: e1a0e00f mov lr, pc 3000b470: e593f024 ldr pc, [r3, #36] ; 0x24 static inline void arm_interrupt_flash( uint32_t level ) { uint32_t arm_switch_reg; __asm__ volatile ( 3000b474: e10f3000 mrs r3, CPSR 3000b478: e129f005 msr CPSR_fc, r5 3000b47c: 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(); 3000b480: e59f3034 ldr r3, [pc, #52] ; 3000b4bc <_Thread_Change_priority+0xf4> 3000b484: e1a0e00f mov lr, pc 3000b488: 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 ); 3000b48c: e59f302c ldr r3, [pc, #44] ; 3000b4c0 <_Thread_Change_priority+0xf8> 3000b490: e5932004 ldr r2, [r3, #4] * 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() && 3000b494: e5931008 ldr r1, [r3, #8] 3000b498: e1520001 cmp r2, r1 3000b49c: 0a000003 beq 3000b4b0 <_Thread_Change_priority+0xe8> 3000b4a0: e5d22074 ldrb r2, [r2, #116] ; 0x74 3000b4a4: e3520000 cmp r2, #0 _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 3000b4a8: 13a02001 movne r2, #1 3000b4ac: 15c32010 strbne r2, [r3, #16] static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000b4b0: e129f005 msr CPSR_fc, r5 3000b4b4: e8bd80f0 pop {r4, r5, r6, r7, pc} =============================================================================== 3000b688 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 3000b688: e92d4001 push {r0, lr} <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000b68c: e1a0100d mov r1, sp <== NOT EXECUTED 3000b690: eb000058 bl 3000b7f8 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 3000b694: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000b698: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b69c: 1a000005 bne 3000b6b8 <_Thread_Delay_ended+0x30> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 3000b6a0: e59f1014 ldr r1, [pc, #20] ; 3000b6bc <_Thread_Delay_ended+0x34><== NOT EXECUTED 3000b6a4: ebffff86 bl 3000b4c4 <_Thread_Clear_state> <== NOT EXECUTED 3000b6a8: e59f3010 ldr r3, [pc, #16] ; 3000b6c0 <_Thread_Delay_ended+0x38><== NOT EXECUTED 3000b6ac: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b6b0: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000b6b4: e5832000 str r2, [r3] <== NOT EXECUTED | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 3000b6b8: e8bd8008 pop {r3, pc} <== NOT EXECUTED =============================================================================== 3000b7f8 <_Thread_Get>: */ Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 3000b7f8: 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 ) ) { 3000b7fc: e2501000 subs r1, r0, #0 3000b800: 1a000007 bne 3000b824 <_Thread_Get+0x2c> rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 3000b804: e59f3074 ldr r3, [pc, #116] ; 3000b880 <_Thread_Get+0x88> 3000b808: e5930000 ldr r0, [r3] 3000b80c: e2800001 add r0, r0, #1 3000b810: e5830000 str r0, [r3] _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; tp = _Thread_Executing; 3000b814: e59f3068 ldr r3, [pc, #104] ; 3000b884 <_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; 3000b818: e5821000 str r1, [r2] tp = _Thread_Executing; 3000b81c: e5930004 ldr r0, [r3, #4] goto done; 3000b820: 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); 3000b824: e1a00c21 lsr r0, r1, #24 3000b828: 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 ) 3000b82c: e2403001 sub r3, r0, #1 3000b830: e3530002 cmp r3, #2 3000b834: 9a00000d bls 3000b870 <_Thread_Get+0x78> goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; 3000b838: e3a03001 mov r3, #1 3000b83c: 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; 3000b840: e3a00000 mov r0, #0 } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; goto done; 3000b844: e12fff1e bx lr } api_information = _Objects_Information_table[ the_api ]; 3000b848: e59fc038 ldr ip, [pc, #56] ; 3000b888 <_Thread_Get+0x90> 3000b84c: 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 ) { 3000b850: e3500000 cmp r0, #0 3000b854: 0a000002 beq 3000b864 <_Thread_Get+0x6c> *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 3000b858: e5900004 ldr r0, [r0, #4] if ( !information ) { 3000b85c: e3500000 cmp r0, #0 3000b860: 1a000001 bne 3000b86c <_Thread_Get+0x74> *location = OBJECTS_ERROR; 3000b864: e5823000 str r3, [r2] <== NOT EXECUTED goto done; 3000b868: e12fff1e bx lr <== NOT EXECUTED } tp = (Thread_Control *) _Objects_Get( information, id, location ); 3000b86c: eafffcbe b 3000ab6c <_Objects_Get> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 3000b870: 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 :) */ 3000b874: e3530001 cmp r3, #1 3000b878: 0afffff2 beq 3000b848 <_Thread_Get+0x50> 3000b87c: eaffffed b 3000b838 <_Thread_Get+0x40> <== NOT EXECUTED =============================================================================== 3000c128 <_Thread_Start>: */ RTEMS_INLINE_ROUTINE bool _States_Is_dormant ( States_Control the_states ) { return (the_states & STATES_DORMANT); 3000c128: e590c010 ldr ip, [r0, #16] Thread_Start_types the_prototype, void *entry_point, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 3000c12c: e92d4010 push {r4, lr} if ( _States_Is_dormant( the_thread->current_state ) ) { 3000c130: e21cc001 ands ip, ip, #1 Thread_Start_types the_prototype, void *entry_point, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 3000c134: e1a04000 mov r4, r0 if ( _States_Is_dormant( the_thread->current_state ) ) { 3000c138: 0a00000b beq 3000c16c <_Thread_Start+0x44> the_thread->Start.entry_point = (Thread_Entry) entry_point; the_thread->Start.prototype = the_prototype; the_thread->Start.pointer_argument = pointer_argument; 3000c13c: e5803098 str r3, [r0, #152] ; 0x98 the_thread->Start.numeric_argument = numeric_argument; 3000c140: 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; 3000c144: e5802090 str r2, [r0, #144] ; 0x90 the_thread->Start.prototype = the_prototype; 3000c148: e5801094 str r1, [r0, #148] ; 0x94 the_thread->Start.pointer_argument = pointer_argument; the_thread->Start.numeric_argument = numeric_argument; 3000c14c: e580309c str r3, [r0, #156] ; 0x9c _Thread_Load_environment( the_thread ); 3000c150: eb000a55 bl 3000eaac <_Thread_Load_environment> _Thread_Ready( the_thread ); 3000c154: e1a00004 mov r0, r4 3000c158: eb000aeb bl 3000ed0c <_Thread_Ready> _User_extensions_Thread_start( the_thread ); 3000c15c: e1a00004 mov r0, r4 3000c160: eb0000ca bl 3000c490 <_User_extensions_Thread_start> return true; 3000c164: e3a00001 mov r0, #1 3000c168: e8bd8010 pop {r4, pc} } return false; 3000c16c: e1a0000c mov r0, ip <== NOT EXECUTED } 3000c170: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000f764 <_Thread_Suspend>: * select map */ void _Thread_Suspend( Thread_Control *the_thread ) { 3000f764: e92d4010 push {r4, lr} static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000f768: e10f4000 mrs r4, CPSR 3000f76c: e3842080 orr r2, r4, #128 ; 0x80 3000f770: e129f002 msr CPSR_fc, r2 ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_ready( the_thread->current_state ) ) { 3000f774: e5902010 ldr r2, [r0, #16] 3000f778: e3520000 cmp r2, #0 3000f77c: 0a000002 beq 3000f78c <_Thread_Suspend+0x28> RTEMS_INLINE_ROUTINE States_Control _States_Set ( States_Control states_to_set, States_Control current_state ) { return (current_state | states_to_set); 3000f780: e3822002 orr r2, r2, #2 <== NOT EXECUTED the_thread->current_state = 3000f784: e5802010 str r2, [r0, #16] <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 3000f788: ea000004 b 3000f7a0 <_Thread_Suspend+0x3c> <== NOT EXECUTED return; } the_thread->current_state = STATES_SUSPENDED; 3000f78c: e3a02002 mov r2, #2 3000f790: e5802010 str r2, [r0, #16] */ RTEMS_INLINE_ROUTINE void _Scheduler_Block( Thread_Control *the_thread ) { _Scheduler.Operations.block( the_thread ); 3000f794: e59f300c ldr r3, [pc, #12] ; 3000f7a8 <_Thread_Suspend+0x44> 3000f798: e1a0e00f mov lr, pc 3000f79c: e593f010 ldr pc, [r3, #16] static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000f7a0: e129f004 msr CPSR_fc, r4 3000f7a4: e8bd8010 pop {r4, pc} =============================================================================== 3000c174 <_Thread_Tickle_timeslice>: void _Thread_Tickle_timeslice( void ) { Thread_Control *executing; executing = _Thread_Executing; 3000c174: e59f3058 ldr r3, [pc, #88] ; 3000c1d4 <_Thread_Tickle_timeslice+0x60> * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 3000c178: e92d4010 push {r4, lr} Thread_Control *executing; executing = _Thread_Executing; 3000c17c: e5934004 ldr r4, [r3, #4] /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 3000c180: e5d43074 ldrb r3, [r4, #116] ; 0x74 3000c184: e3530000 cmp r3, #0 3000c188: 08bd8010 popeq {r4, pc} return; if ( !_States_Is_ready( executing->current_state ) ) 3000c18c: e5943010 ldr r3, [r4, #16] 3000c190: e3530000 cmp r3, #0 3000c194: 18bd8010 popne {r4, pc} /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 3000c198: e594307c ldr r3, [r4, #124] ; 0x7c 3000c19c: e3530001 cmp r3, #1 3000c1a0: 18bd8010 popne {r4, pc} 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 ) { 3000c1a4: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED 3000c1a8: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000c1ac: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c1b0: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED 3000c1b4: 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(); 3000c1b8: e59f3018 ldr r3, [pc, #24] ; 3000c1d8 <_Thread_Tickle_timeslice+0x64><== NOT EXECUTED 3000c1bc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c1c0: 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; 3000c1c4: e59f3010 ldr r3, [pc, #16] ; 3000c1dc <_Thread_Tickle_timeslice+0x68><== NOT EXECUTED 3000c1c8: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000c1cc: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED 3000c1d0: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000b37c <_Thread_blocking_operation_Cancel>: #endif /* * The thread is not waiting on anything after this completes. */ the_thread->Wait.queue = NULL; 3000b37c: e3a03000 mov r3, #0 <== NOT EXECUTED Thread_blocking_operation_States sync_state __attribute__((unused)), #endif Thread_Control *the_thread, ISR_Level level ) { 3000b380: e92d4010 push {r4, lr} <== NOT EXECUTED #endif /* * The thread is not waiting on anything after this completes. */ the_thread->Wait.queue = NULL; 3000b384: 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 ) ) { 3000b388: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED Thread_blocking_operation_States sync_state __attribute__((unused)), #endif Thread_Control *the_thread, ISR_Level level ) { 3000b38c: 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 ) ) { 3000b390: e3530002 cmp r3, #2 <== NOT EXECUTED 3000b394: 1a000005 bne 3000b3b0 <_Thread_blocking_operation_Cancel+0x34><== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 3000b398: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000b39c: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 3000b3a0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); 3000b3a4: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 3000b3a8: eb0004b1 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED 3000b3ac: ea000000 b 3000b3b4 <_Thread_blocking_operation_Cancel+0x38><== NOT EXECUTED 3000b3b0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 3000b3b4: e59f1008 ldr r1, [pc, #8] ; 3000b3c4 <_Thread_blocking_operation_Cancel+0x48><== NOT EXECUTED 3000b3b8: 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 } 3000b3bc: e8bd4010 pop {r4, lr} <== NOT EXECUTED 3000b3c0: ea00003f b 3000b4c4 <_Thread_Clear_state> <== NOT EXECUTED =============================================================================== 3000eaf8 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 3000eaf8: e92d4030 push {r4, r5, lr} static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000eafc: e10f3000 mrs r3, CPSR 3000eb00: e3832080 orr r2, r3, #128 ; 0x80 3000eb04: e129f002 msr CPSR_fc, r2 return the_thread; } _ISR_Enable( level ); return NULL; } 3000eb08: e1a02000 mov r2, r0 3000eb0c: e4925004 ldr r5, [r2], #4 { ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 3000eb10: e1550002 cmp r5, r2 3000eb14: 0a000013 beq 3000eb68 <_Thread_queue_Dequeue_fifo+0x70> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 3000eb18: e5952000 ldr r2, [r5] the_thread = (Thread_Control *) 3000eb1c: e1a04005 mov r4, r5 head->next = new_first; 3000eb20: e5802000 str r2, [r0] new_first->previous = head; 3000eb24: e5820004 str r0, [r2, #4] _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; 3000eb28: e3a02000 mov r2, #0 3000eb2c: e5852044 str r2, [r5, #68] ; 0x44 if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 3000eb30: e5952050 ldr r2, [r5, #80] ; 0x50 3000eb34: e3520002 cmp r2, #2 3000eb38: 0a000001 beq 3000eb44 <_Thread_queue_Dequeue_fifo+0x4c> static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000eb3c: e129f003 msr CPSR_fc, r3 3000eb40: ea000004 b 3000eb58 <_Thread_queue_Dequeue_fifo+0x60> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 3000eb44: e3a02003 mov r2, #3 <== NOT EXECUTED 3000eb48: e5852050 str r2, [r5, #80] ; 0x50 <== NOT EXECUTED 3000eb4c: 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 ); 3000eb50: e2850048 add r0, r5, #72 ; 0x48 <== NOT EXECUTED 3000eb54: ebfff6c6 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 3000eb58: e1a00005 mov r0, r5 3000eb5c: e59f1014 ldr r1, [pc, #20] ; 3000eb78 <_Thread_queue_Dequeue_fifo+0x80> 3000eb60: ebfff257 bl 3000b4c4 <_Thread_Clear_state> 3000eb64: ea000001 b 3000eb70 <_Thread_queue_Dequeue_fifo+0x78> 3000eb68: e129f003 msr CPSR_fc, r3 return the_thread; } _ISR_Enable( level ); return NULL; 3000eb6c: e3a04000 mov r4, #0 } 3000eb70: e1a00004 mov r0, r4 3000eb74: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000bb34 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 3000bb34: e92d4030 push {r4, r5, lr} static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000bb38: e10f1000 mrs r1, CPSR 3000bb3c: e3813080 orr r3, r1, #128 ; 0x80 3000bb40: e129f003 msr CPSR_fc, r3 Chain_Node *new_second_node; Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); 3000bb44: e3a02000 mov r2, #0 for( index=0 ; 3000bb48: e1a03002 mov r3, r2 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 3000bb4c: e3a0c00c mov ip, #12 3000bb50: e004039c mul r4, ip, r3 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 3000bb54: e7905002 ldr r5, [r0, r2] 3000bb58: e2844004 add r4, r4, #4 3000bb5c: e0804004 add r4, r0, r4 _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { 3000bb60: e1550004 cmp r5, r4 3000bb64: 0a000009 beq 3000bb90 <_Thread_queue_Dequeue_priority+0x5c> */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 3000bb68: e3a03000 mov r3, #0 3000bb6c: e5853044 str r3, [r5, #68] ; 0x44 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 3000bb70: e5953038 ldr r3, [r5, #56] ; 0x38 3000bb74: e285c03c add ip, r5, #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 ) ) { 3000bb78: e153000c cmp r3, ip _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { the_thread = (Thread_Control *) _Chain_First( 3000bb7c: e1a04005 mov r4, r5 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; 3000bb80: e5952000 ldr r2, [r5] previous_node = the_thread->Object.Node.previous; 3000bb84: e5950004 ldr r0, [r5, #4] if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 3000bb88: 1a000007 bne 3000bbac <_Thread_queue_Dequeue_priority+0x78> 3000bb8c: ea000017 b 3000bbf0 <_Thread_queue_Dequeue_priority+0xbc> Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 3000bb90: e2833001 add r3, r3, #1 Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; 3000bb94: e3530004 cmp r3, #4 index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 3000bb98: e282200c add r2, r2, #12 Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; 3000bb9c: 1affffeb bne 3000bb50 <_Thread_queue_Dequeue_priority+0x1c> static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000bba0: e129f001 msr CPSR_fc, r1 /* * We did not find a thread to unblock. */ _ISR_Enable( level ); return NULL; 3000bba4: e3a04000 mov r4, #0 3000bba8: ea00001f b 3000bc2c <_Thread_queue_Dequeue_priority+0xf8> #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 3000bbac: e595c040 ldr ip, [r5, #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; 3000bbb0: e593e000 ldr lr, [r3] <== NOT EXECUTED previous_node->next = new_first_node; next_node->previous = new_first_node; 3000bbb4: e5823004 str r3, [r2, #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; 3000bbb8: e5803000 str r3, [r0] <== NOT EXECUTED next_node->previous = new_first_node; new_first_node->next = next_node; new_first_node->previous = previous_node; 3000bbbc: 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; 3000bbc0: e5832000 str r2, [r3] <== NOT EXECUTED new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 3000bbc4: e5950038 ldr r0, [r5, #56] ; 0x38 <== NOT EXECUTED 3000bbc8: e5952040 ldr r2, [r5, #64] ; 0x40 <== NOT EXECUTED 3000bbcc: e1500002 cmp r0, r2 <== NOT EXECUTED 3000bbd0: 0a000008 beq 3000bbf8 <_Thread_queue_Dequeue_priority+0xc4><== NOT EXECUTED /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 3000bbd4: e2832038 add r2, r3, #56 ; 0x38 <== NOT EXECUTED tail = _Chain_Tail( &new_first_thread->Wait.Block2n ); new_second_node->previous = head; head->next = new_second_node; 3000bbd8: 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; 3000bbdc: e58e2004 str r2, [lr, #4] <== NOT EXECUTED head->next = new_second_node; tail->previous = last_node; 3000bbe0: 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 ); 3000bbe4: 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; 3000bbe8: e58c3000 str r3, [ip] <== NOT EXECUTED 3000bbec: ea000001 b 3000bbf8 <_Thread_queue_Dequeue_priority+0xc4> <== NOT EXECUTED } } else { previous_node->next = next_node; 3000bbf0: e5802000 str r2, [r0] next_node->previous = previous_node; 3000bbf4: e5820004 str r0, [r2, #4] } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 3000bbf8: e5953050 ldr r3, [r5, #80] ; 0x50 3000bbfc: e3530002 cmp r3, #2 3000bc00: 0a000001 beq 3000bc0c <_Thread_queue_Dequeue_priority+0xd8> 3000bc04: e129f001 msr CPSR_fc, r1 3000bc08: ea000004 b 3000bc20 <_Thread_queue_Dequeue_priority+0xec> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 3000bc0c: e3a03003 mov r3, #3 <== NOT EXECUTED 3000bc10: e5853050 str r3, [r5, #80] ; 0x50 <== NOT EXECUTED 3000bc14: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); 3000bc18: e2850048 add r0, r5, #72 ; 0x48 <== NOT EXECUTED 3000bc1c: eb000294 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 3000bc20: e1a00005 mov r0, r5 3000bc24: e59f1008 ldr r1, [pc, #8] ; 3000bc34 <_Thread_queue_Dequeue_priority+0x100> 3000bc28: ebfffe25 bl 3000b4c4 <_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 ); } 3000bc2c: e1a00004 mov r0, r4 3000bc30: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000eb7c <_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 ) { 3000eb7c: e92d4010 push {r4, lr} 3000eb80: e1a03000 mov r3, r0 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000eb84: e10fc000 mrs ip, CPSR 3000eb88: e38c0080 orr r0, ip, #128 ; 0x80 3000eb8c: e129f000 msr CPSR_fc, r0 Thread_blocking_operation_States sync_state; ISR_Level level; _ISR_Disable( level ); sync_state = the_thread_queue->sync_state; 3000eb90: e5930030 ldr r0, [r3, #48] ; 0x30 the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 3000eb94: e3a04000 mov r4, #0 if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { 3000eb98: 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; 3000eb9c: e5834030 str r4, [r3, #48] ; 0x30 if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { 3000eba0: 1a000008 bne 3000ebc8 <_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; 3000eba4: 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 ); 3000eba8: e2834004 add r4, r3, #4 Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 3000ebac: e5831008 str r1, [r3, #8] ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; the_node->next = tail; 3000ebb0: e5814000 str r4, [r1] tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last; 3000ebb4: 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; 3000ebb8: e5821000 str r1, [r2] _Chain_Append_unprotected( &the_thread_queue->Queues.Fifo, &the_thread->Object.Node ); the_thread->Wait.queue = the_thread_queue; 3000ebbc: e5813044 str r3, [r1, #68] ; 0x44 static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000ebc0: e129f00c msr CPSR_fc, ip the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 3000ebc4: 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; 3000ebc8: e582c000 str ip, [r2] <== NOT EXECUTED return sync_state; } 3000ebcc: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000bcd8 <_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 ); 3000bcd8: e281303c add r3, r1, #60 ; 0x3c Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 3000bcdc: e591c014 ldr ip, [r1, #20] head->next = tail; 3000bce0: e5813038 str r3, [r1, #56] ; 0x38 head->previous = NULL; 3000bce4: e3a03000 mov r3, #0 3000bce8: e581303c str r3, [r1, #60] ; 0x3c 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 ) ) 3000bcec: e31c0020 tst ip, #32 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 3000bcf0: 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 ) { 3000bcf4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; head->previous = NULL; tail->previous = head; 3000bcf8: 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 ]; block_state = the_thread_queue->state; 3000bcfc: e5907038 ldr r7, [r0, #56] ; 0x38 RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number ( Priority_Control the_priority ) { return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER); 3000bd00: e1a0332c lsr r3, ip, #6 if ( _Thread_queue_Is_reverse_search( priority ) ) 3000bd04: 1a000026 bne 3000bda4 <_Thread_queue_Enqueue_priority+0xcc> * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 3000bd08: e3a0600c mov r6, #12 3000bd0c: e0030396 mul r3, r6, r3 3000bd10: e0808003 add r8, r0, r3 RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 3000bd14: e2833004 add r3, r3, #4 3000bd18: e0806003 add r6, r0, r3 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000bd1c: e10f4000 mrs r4, CPSR 3000bd20: e3843080 orr r3, r4, #128 ; 0x80 3000bd24: e129f003 msr CPSR_fc, r3 if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; 3000bd28: e3e05000 mvn r5, #0 _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_First( header ); 3000bd2c: e5983000 ldr r3, [r8] while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 3000bd30: ea00000b b 3000bd64 <_Thread_queue_Enqueue_priority+0x8c> search_priority = search_thread->current_priority; 3000bd34: e5935014 ldr r5, [r3, #20] if ( priority <= search_priority ) 3000bd38: e15c0005 cmp ip, r5 3000bd3c: 9a00000a bls 3000bd6c <_Thread_queue_Enqueue_priority+0x94> static inline void arm_interrupt_flash( uint32_t level ) { uint32_t arm_switch_reg; __asm__ volatile ( 3000bd40: e10fa000 mrs sl, CPSR 3000bd44: e129f004 msr CPSR_fc, r4 3000bd48: e129f00a msr CPSR_fc, sl RTEMS_INLINE_ROUTINE bool _States_Are_set ( States_Control the_states, States_Control mask ) { return ( (the_states & mask) != STATES_READY); 3000bd4c: e593a010 ldr sl, [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) ) { 3000bd50: e117000a tst r7, sl 3000bd54: 1a000001 bne 3000bd60 <_Thread_queue_Enqueue_priority+0x88> static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000bd58: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000bd5c: eaffffee b 3000bd1c <_Thread_queue_Enqueue_priority+0x44> <== NOT EXECUTED _ISR_Enable( level ); goto restart_forward_search; } search_thread = (Thread_Control *)search_thread->Object.Node.next; 3000bd60: 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 ) ) { 3000bd64: e1530006 cmp r3, r6 3000bd68: 1afffff1 bne 3000bd34 <_Thread_queue_Enqueue_priority+0x5c> } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 3000bd6c: e5906030 ldr r6, [r0, #48] ; 0x30 3000bd70: e3560001 cmp r6, #1 3000bd74: 1a000039 bne 3000be60 <_Thread_queue_Enqueue_priority+0x188> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 3000bd78: e3a02000 mov r2, #0 if ( priority == search_priority ) 3000bd7c: e15c0005 cmp ip, r5 if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 3000bd80: e5802030 str r2, [r0, #48] ; 0x30 if ( priority == search_priority ) 3000bd84: 0a00002b beq 3000be38 <_Thread_queue_Enqueue_priority+0x160> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 3000bd88: e5932004 ldr r2, [r3, #4] the_node = (Chain_Node *) the_thread; the_node->next = search_node; 3000bd8c: e5813000 str r3, [r1] the_node->previous = previous_node; 3000bd90: e5812004 str r2, [r1, #4] previous_node->next = the_node; 3000bd94: e5821000 str r1, [r2] search_node->previous = the_node; 3000bd98: e5831004 str r1, [r3, #4] the_thread->Wait.queue = the_thread_queue; 3000bd9c: e5810044 str r0, [r1, #68] ; 0x44 _ISR_Enable( level ); 3000bda0: ea00002b b 3000be54 <_Thread_queue_Enqueue_priority+0x17c> * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 3000bda4: e3a0600c mov r6, #12 3000bda8: e0260693 mla r6, r3, r6, r0 the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 3000bdac: e59f80b8 ldr r8, [pc, #184] ; 3000be6c <_Thread_queue_Enqueue_priority+0x194> 3000bdb0: e5d85000 ldrb r5, [r8] 3000bdb4: e2855001 add r5, r5, #1 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000bdb8: e10f4000 mrs r4, CPSR 3000bdbc: e3843080 orr r3, r4, #128 ; 0x80 3000bdc0: e129f003 msr CPSR_fc, r3 _ISR_Disable( level ); search_thread = (Thread_Control *) _Chain_Last( header ); 3000bdc4: e5963008 ldr r3, [r6, #8] while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 3000bdc8: ea00000b b 3000bdfc <_Thread_queue_Enqueue_priority+0x124> search_priority = search_thread->current_priority; 3000bdcc: e5935014 ldr r5, [r3, #20] if ( priority >= search_priority ) 3000bdd0: e15c0005 cmp ip, r5 3000bdd4: 2a00000a bcs 3000be04 <_Thread_queue_Enqueue_priority+0x12c> static inline void arm_interrupt_flash( uint32_t level ) { uint32_t arm_switch_reg; __asm__ volatile ( 3000bdd8: e10fa000 mrs sl, CPSR <== NOT EXECUTED 3000bddc: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000bde0: e129f00a msr CPSR_fc, sl <== NOT EXECUTED 3000bde4: e593a010 ldr sl, [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) ) { 3000bde8: e117000a tst r7, sl <== NOT EXECUTED 3000bdec: 1a000001 bne 3000bdf8 <_Thread_queue_Enqueue_priority+0x120><== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000bdf0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000bdf4: eaffffed b 3000bdb0 <_Thread_queue_Enqueue_priority+0xd8> <== NOT EXECUTED _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) search_thread->Object.Node.previous; 3000bdf8: 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 ) ) { 3000bdfc: e1530006 cmp r3, r6 3000be00: 1afffff1 bne 3000bdcc <_Thread_queue_Enqueue_priority+0xf4> } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 3000be04: e5906030 ldr r6, [r0, #48] ; 0x30 3000be08: e3560001 cmp r6, #1 3000be0c: 1a000013 bne 3000be60 <_Thread_queue_Enqueue_priority+0x188> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 3000be10: e3a02000 mov r2, #0 if ( priority == search_priority ) 3000be14: e15c0005 cmp ip, r5 if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 3000be18: e5802030 str r2, [r0, #48] ; 0x30 if ( priority == search_priority ) 3000be1c: 0a000005 beq 3000be38 <_Thread_queue_Enqueue_priority+0x160> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 3000be20: e5932000 ldr r2, [r3] the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 3000be24: e881000c stm r1, {r2, r3} search_node->next = the_node; next_node->previous = the_node; 3000be28: e5821004 str r1, [r2, #4] next_node = search_node->next; the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; search_node->next = the_node; 3000be2c: e5831000 str r1, [r3] next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; 3000be30: e5810044 str r0, [r1, #68] ; 0x44 _ISR_Enable( level ); 3000be34: ea000006 b 3000be54 <_Thread_queue_Enqueue_priority+0x17c> 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; 3000be38: 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 ); 3000be3c: e283c03c add ip, r3, #60 ; 0x3c <== NOT EXECUTED previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; 3000be40: e581c000 str ip, [r1] <== NOT EXECUTED the_node->previous = previous_node; 3000be44: e5812004 str r2, [r1, #4] <== NOT EXECUTED previous_node->next = the_node; 3000be48: e5821000 str r1, [r2] <== NOT EXECUTED search_node->previous = the_node; 3000be4c: e5831040 str r1, [r3, #64] ; 0x40 <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 3000be50: e5810044 str r0, [r1, #68] ; 0x44 <== NOT EXECUTED 3000be54: e129f004 msr CPSR_fc, r4 _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 3000be58: e3a00001 mov r0, #1 3000be5c: e8bd85f0 pop {r4, r5, r6, r7, r8, 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; 3000be60: e5824000 str r4, [r2] <== NOT EXECUTED return the_thread_queue->sync_state; 3000be64: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED } 3000be68: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED =============================================================================== 30010174 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread ) { 30010174: e92d4010 push {r4, lr} 30010178: e1a04001 mov r4, r1 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3001017c: e10f3000 mrs r3, CPSR 30010180: e3832080 orr r2, r3, #128 ; 0x80 30010184: e129f002 msr CPSR_fc, r2 30010188: e59f2060 ldr r2, [pc, #96] ; 300101f0 <_Thread_queue_Extract_fifo+0x7c> 3001018c: e5911010 ldr r1, [r1, #16] 30010190: e0012002 and r2, r1, r2 ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 30010194: e3520000 cmp r2, #0 30010198: 1a000001 bne 300101a4 <_Thread_queue_Extract_fifo+0x30> static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3001019c: 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 } 300101a0: e8bd8010 pop {r4, pc} { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 300101a4: e8940006 ldm r4, {r1, r2} next->previous = previous; 300101a8: e5812004 str r2, [r1, #4] previous->next = next; 300101ac: e5821000 str r1, [r2] return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 300101b0: e3a02000 mov r2, #0 300101b4: e5842044 str r2, [r4, #68] ; 0x44 if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 300101b8: e5942050 ldr r2, [r4, #80] ; 0x50 300101bc: e3520002 cmp r2, #2 300101c0: 0a000001 beq 300101cc <_Thread_queue_Extract_fifo+0x58> 300101c4: e129f003 msr CPSR_fc, r3 300101c8: ea000004 b 300101e0 <_Thread_queue_Extract_fifo+0x6c> 300101cc: e3a02003 mov r2, #3 <== NOT EXECUTED 300101d0: e5842050 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED 300101d4: 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 ); 300101d8: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 300101dc: ebfff124 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 300101e0: e59f100c ldr r1, [pc, #12] ; 300101f4 <_Thread_queue_Extract_fifo+0x80> 300101e4: e1a00004 mov r0, r4 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 300101e8: e8bd4010 pop {r4, lr} 300101ec: eaffecb4 b 3000b4c4 <_Thread_Clear_state> =============================================================================== 3000ebe8 <_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 ) { 3000ebe8: e92d4070 push {r4, r5, r6, lr} 3000ebec: e20220ff and r2, r2, #255 ; 0xff 3000ebf0: e1a04001 mov r4, r1 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000ebf4: e10f1000 mrs r1, CPSR 3000ebf8: e3813080 orr r3, r1, #128 ; 0x80 3000ebfc: 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); 3000ec00: e59f30b0 ldr r3, [pc, #176] ; 3000ecb8 <_Thread_queue_Extract_priority_helper+0xd0> 3000ec04: e5940010 ldr r0, [r4, #16] 3000ec08: 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 ) ) { 3000ec0c: e3530000 cmp r3, #0 3000ec10: 1a000000 bne 3000ec18 <_Thread_queue_Extract_priority_helper+0x30> _ISR_Enable( level ); 3000ec14: ea000017 b 3000ec78 <_Thread_queue_Extract_priority_helper+0x90> #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 3000ec18: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 3000ec1c: e8941001 ldm r4, {r0, ip} <== 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 ); 3000ec20: e284503c add r5, r4, #60 ; 0x3c <== NOT EXECUTED previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 3000ec24: e1530005 cmp r3, r5 <== NOT EXECUTED head->next = new_second_node; tail->previous = last_node; last_node->next = tail; } } else { previous_node->next = next_node; 3000ec28: 058c0000 streq r0, [ip] <== NOT EXECUTED next_node->previous = previous_node; 3000ec2c: 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 ) ) { 3000ec30: 0a00000e beq 3000ec70 <_Thread_queue_Extract_priority_helper+0x88><== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 3000ec34: e5945040 ldr r5, [r4, #64] ; 0x40 <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 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; 3000ec38: e5936000 ldr r6, [r3] <== NOT EXECUTED previous_node->next = new_first_node; next_node->previous = new_first_node; 3000ec3c: 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; 3000ec40: e58c3000 str r3, [ip] <== NOT EXECUTED next_node->previous = new_first_node; new_first_node->next = next_node; new_first_node->previous = previous_node; 3000ec44: e8831001 stm r3, {r0, ip} <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 3000ec48: e594c038 ldr ip, [r4, #56] ; 0x38 <== NOT EXECUTED 3000ec4c: e5940040 ldr r0, [r4, #64] ; 0x40 <== NOT EXECUTED 3000ec50: e15c0000 cmp ip, r0 <== NOT EXECUTED 3000ec54: 0a000005 beq 3000ec70 <_Thread_queue_Extract_priority_helper+0x88><== NOT EXECUTED /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 3000ec58: 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; 3000ec5c: 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; 3000ec60: e5860004 str r0, [r6, #4] <== NOT EXECUTED head->next = new_second_node; tail->previous = last_node; 3000ec64: 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 ); 3000ec68: 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; 3000ec6c: e5853000 str r3, [r5] <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 3000ec70: e3520000 cmp r2, #0 <== NOT EXECUTED 3000ec74: 0a000001 beq 3000ec80 <_Thread_queue_Extract_priority_helper+0x98><== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000ec78: e129f001 msr CPSR_fc, r1 3000ec7c: e8bd8070 pop {r4, r5, r6, pc} _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 3000ec80: e5943050 ldr r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000ec84: e3530002 cmp r3, #2 <== NOT EXECUTED 3000ec88: 0a000001 beq 3000ec94 <_Thread_queue_Extract_priority_helper+0xac><== NOT EXECUTED 3000ec8c: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 3000ec90: ea000004 b 3000eca8 <_Thread_queue_Extract_priority_helper+0xc0><== NOT EXECUTED 3000ec94: e3a03003 mov r3, #3 <== NOT EXECUTED 3000ec98: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000ec9c: 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 ); 3000eca0: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000eca4: ebfff672 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED 3000eca8: e59f100c ldr r1, [pc, #12] ; 3000ecbc <_Thread_queue_Extract_priority_helper+0xd4><== NOT EXECUTED 3000ecac: 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 } 3000ecb0: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED 3000ecb4: eafff202 b 3000b4c4 <_Thread_Clear_state> <== NOT EXECUTED =============================================================================== 3001ede4 <_Thread_queue_First_priority>: */ Thread_Control *_Thread_queue_First_priority ( Thread_queue_Control *the_thread_queue ) { 3001ede4: e92d4010 push {r4, lr} <== NOT EXECUTED 3001ede8: e3a02000 mov r2, #0 <== NOT EXECUTED uint32_t index; for( index=0 ; 3001edec: e1a03002 mov r3, r2 <== NOT EXECUTED 3001edf0: e3a0c00c mov ip, #12 <== NOT EXECUTED 3001edf4: e004039c mul r4, ip, r3 <== NOT EXECUTED return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Priority[ index ] ); } return NULL; } 3001edf8: e7901002 ldr r1, [r0, r2] <== NOT EXECUTED 3001edfc: e2844004 add r4, r4, #4 <== NOT EXECUTED 3001ee00: e0804004 add r4, r0, r4 <== NOT EXECUTED uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) 3001ee04: e1510004 cmp r1, r4 <== NOT EXECUTED 3001ee08: 0a000001 beq 3001ee14 <_Thread_queue_First_priority+0x30> <== NOT EXECUTED return (Thread_Control *) _Chain_First( 3001ee0c: e1a00001 mov r0, r1 <== NOT EXECUTED 3001ee10: e8bd8010 pop {r4, pc} <== NOT EXECUTED { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 3001ee14: e2833001 add r3, r3, #1 <== NOT EXECUTED Thread_queue_Control *the_thread_queue ) { uint32_t index; for( index=0 ; 3001ee18: e3530004 cmp r3, #4 <== NOT EXECUTED index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 3001ee1c: e282200c add r2, r2, #12 <== NOT EXECUTED Thread_queue_Control *the_thread_queue ) { uint32_t index; for( index=0 ; 3001ee20: 1afffff3 bne 3001edf4 <_Thread_queue_First_priority+0x10> <== 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; 3001ee24: e3a00000 mov r0, #0 <== NOT EXECUTED } 3001ee28: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000ecc0 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 3000ecc0: e1a01000 mov r1, r0 <== NOT EXECUTED Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 3000ecc4: 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 && 3000ecc8: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000eccc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ecd0: 0a000009 beq 3000ecfc <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 3000ecd4: e59f202c ldr r2, [pc, #44] ; 3000ed08 <_Thread_queue_Process_timeout+0x48><== NOT EXECUTED 3000ecd8: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 3000ecdc: e1510002 cmp r1, r2 <== NOT EXECUTED 3000ece0: 1a000005 bne 3000ecfc <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 3000ece4: e3530003 cmp r3, #3 <== NOT EXECUTED the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 3000ece8: 1590303c ldrne r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000ecec: 15813034 strne r3, [r1, #52] ; 0x34 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 3000ecf0: 13a03002 movne r3, #2 <== NOT EXECUTED 3000ecf4: 15803030 strne r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000ecf8: e12fff1e bx lr <== NOT EXECUTED } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 3000ecfc: e590303c ldr r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000ed00: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 3000ed04: eaffffb1 b 3000ebd0 <_Thread_queue_Extract> <== NOT EXECUTED =============================================================================== 3000bf30 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 3000bf30: 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 ) 3000bf34: e2504000 subs r4, r0, #0 <== NOT EXECUTED void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 3000bf38: 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 ) 3000bf3c: 0a000011 beq 3000bf88 <_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 ) { 3000bf40: e5942034 ldr r2, [r4, #52] ; 0x34 <== NOT EXECUTED 3000bf44: e3520001 cmp r2, #1 <== NOT EXECUTED 3000bf48: 1a00000e bne 3000bf88 <_Thread_queue_Requeue+0x58> <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000bf4c: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000bf50: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000bf54: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 3000bf58: e59f302c ldr r3, [pc, #44] ; 3000bf8c <_Thread_queue_Requeue+0x5c><== NOT EXECUTED 3000bf5c: e591c010 ldr ip, [r1, #16] <== NOT EXECUTED 3000bf60: 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 ) ) { 3000bf64: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bf68: 0a000005 beq 3000bf84 <_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; 3000bf6c: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); 3000bf70: eb000b1c bl 3000ebe8 <_Thread_queue_Extract_priority_helper><== NOT EXECUTED (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 3000bf74: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bf78: e1a01005 mov r1, r5 <== NOT EXECUTED 3000bf7c: e1a0200d mov r2, sp <== NOT EXECUTED 3000bf80: ebffff54 bl 3000bcd8 <_Thread_queue_Enqueue_priority> <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000bf84: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED } _ISR_Enable( level ); } } 3000bf88: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000bf90 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 3000bf90: e92d4001 push {r0, lr} <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000bf94: e1a0100d mov r1, sp <== NOT EXECUTED 3000bf98: ebfffe16 bl 3000b7f8 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 3000bf9c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000bfa0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bfa4: 1a000004 bne 3000bfbc <_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 ); 3000bfa8: eb000b44 bl 3000ecc0 <_Thread_queue_Process_timeout> <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 3000bfac: e59f300c ldr r3, [pc, #12] ; 3000bfc0 <_Thread_queue_Timeout+0x30><== NOT EXECUTED 3000bfb0: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000bfb4: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000bfb8: e5832000 str r2, [r3] <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 3000bfbc: e8bd8008 pop {r3, pc} <== NOT EXECUTED =============================================================================== 300186a4 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 300186a4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED 300186a8: e24dd01c sub sp, sp, #28 <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 300186ac: e28db010 add fp, sp, #16 <== NOT EXECUTED 300186b0: e28d6004 add r6, sp, #4 <== NOT EXECUTED 300186b4: e28b2004 add r2, fp, #4 <== NOT EXECUTED head->previous = NULL; 300186b8: e3a03000 mov r3, #0 <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 300186bc: e2868004 add r8, r6, #4 <== NOT EXECUTED 300186c0: e1a04000 mov r4, r0 <== NOT EXECUTED 300186c4: e58d2010 str r2, [sp, #16] <== NOT EXECUTED head->previous = NULL; 300186c8: e58d3014 str r3, [sp, #20] <== NOT EXECUTED tail->previous = head; 300186cc: e58db018 str fp, [sp, #24] <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 300186d0: e58d8004 str r8, [sp, #4] <== NOT EXECUTED head->previous = NULL; 300186d4: e58d3008 str r3, [sp, #8] <== NOT EXECUTED tail->previous = head; 300186d8: e58d600c str r6, [sp, #12] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail( const Chain_Control *the_chain ) { return &the_chain->Tail.Node; 300186dc: e58d2000 str r2, [sp] <== NOT EXECUTED static void _Timer_server_Process_tod_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 300186e0: e59f915c ldr r9, [pc, #348] ; 30018844 <_Timer_server_Body+0x1a0><== NOT EXECUTED Chain_Control *tmp; /* * 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; 300186e4: e584b078 str fp, [r4, #120] ; 0x78 <== NOT EXECUTED */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 300186e8: e284a030 add sl, r4, #48 ; 0x30 <== 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 ); 300186ec: e2847068 add r7, r4, #104 ; 0x68 <== NOT EXECUTED static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 300186f0: e59f2150 ldr r2, [pc, #336] ; 30018848 <_Timer_server_Body+0x1a4><== NOT EXECUTED */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 300186f4: e1a0000a mov r0, sl <== NOT EXECUTED static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 300186f8: e5923000 ldr r3, [r2] <== NOT EXECUTED /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 300186fc: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 30018700: e1a02006 mov r2, r6 <== NOT EXECUTED /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; 30018704: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 30018708: e0611003 rsb r1, r1, r3 <== NOT EXECUTED 3001870c: eb001078 bl 3001c8f4 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED static void _Timer_server_Process_tod_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 30018710: e5995000 ldr r5, [r9] <== NOT EXECUTED Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 30018714: e5942074 ldr r2, [r4, #116] ; 0x74 <== 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 ) { 30018718: e1550002 cmp r5, r2 <== NOT EXECUTED 3001871c: 9a000004 bls 30018734 <_Timer_server_Body+0x90> <== 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 ); 30018720: e0621005 rsb r1, r2, r5 <== NOT EXECUTED 30018724: e1a00007 mov r0, r7 <== NOT EXECUTED 30018728: e1a02006 mov r2, r6 <== NOT EXECUTED 3001872c: eb001070 bl 3001c8f4 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 30018730: ea000003 b 30018744 <_Timer_server_Body+0xa0> <== 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 ); 30018734: 31a00007 movcc r0, r7 <== NOT EXECUTED 30018738: 33a01001 movcc r1, #1 <== NOT EXECUTED 3001873c: 30652002 rsbcc r2, r5, r2 <== NOT EXECUTED 30018740: 3b001043 blcc 3001c854 <_Watchdog_Adjust> <== NOT EXECUTED } watchdogs->last_snapshot = snapshot; 30018744: e5845074 str r5, [r4, #116] ; 0x74 <== NOT EXECUTED } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 30018748: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED 3001874c: eb000287 bl 30019170 <_Chain_Get> <== NOT EXECUTED if ( timer == NULL ) { 30018750: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30018754: 0a000009 beq 30018780 <_Timer_server_Body+0xdc> <== NOT EXECUTED static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 30018758: e5953038 ldr r3, [r5, #56] ; 0x38 <== NOT EXECUTED 3001875c: e3530001 cmp r3, #1 <== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 30018760: 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 ) { 30018764: 0a000002 beq 30018774 <_Timer_server_Body+0xd0> <== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 30018768: e3530003 cmp r3, #3 <== NOT EXECUTED 3001876c: 1afffff5 bne 30018748 <_Timer_server_Body+0xa4> <== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 30018770: e1a00007 mov r0, r7 <== NOT EXECUTED 30018774: e2851010 add r1, r5, #16 <== NOT EXECUTED 30018778: eb001088 bl 3001c9a0 <_Watchdog_Insert> <== NOT EXECUTED 3001877c: eafffff1 b 30018748 <_Timer_server_Body+0xa4> <== 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 ); 30018780: ebffff95 bl 300185dc <== NOT EXECUTED tmp = ts->insert_chain; 30018784: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED if ( _Chain_Is_empty( insert_chain ) ) { 30018788: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3001878c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30018790: e1530002 cmp r3, r2 <== NOT EXECUTED ts->insert_chain = NULL; 30018794: 05845078 streq r5, [r4, #120] ; 0x78 <== NOT EXECUTED */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); tmp = ts->insert_chain; if ( _Chain_Is_empty( insert_chain ) ) { 30018798: 13a05001 movne r5, #1 <== NOT EXECUTED 3001879c: e129f000 msr CPSR_fc, r0 <== 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; while ( do_loop ) { 300187a0: e3550000 cmp r5, #0 <== NOT EXECUTED 300187a4: 1affffd1 bne 300186f0 <_Timer_server_Body+0x4c> <== 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 ) ) { 300187a8: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 300187ac: e1530008 cmp r3, r8 <== NOT EXECUTED 300187b0: 0a000012 beq 30018800 <_Timer_server_Body+0x15c> <== 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 ); 300187b4: ebffff88 bl 300185dc <== NOT EXECUTED initialized = false; } #endif return status; } 300187b8: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 300187bc: e1530008 cmp r3, r8 <== NOT EXECUTED 300187c0: 0a00000c beq 300187f8 <_Timer_server_Body+0x154> <== 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; 300187c4: e5932000 ldr r2, [r3] <== 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 ); watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { 300187c8: e3530000 cmp r3, #0 <== NOT EXECUTED head->next = new_first; 300187cc: e58d2004 str r2, [sp, #4] <== NOT EXECUTED new_first->previous = head; 300187d0: e5826004 str r6, [r2, #4] <== NOT EXECUTED 300187d4: 0a000007 beq 300187f8 <_Timer_server_Body+0x154> <== NOT EXECUTED watchdog->state = WATCHDOG_INACTIVE; 300187d8: e3a02000 mov r2, #0 <== NOT EXECUTED 300187dc: e5832008 str r2, [r3, #8] <== NOT EXECUTED 300187e0: 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 ); 300187e4: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 300187e8: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 300187ec: e1a0e00f mov lr, pc <== NOT EXECUTED 300187f0: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED } 300187f4: eaffffee b 300187b4 <_Timer_server_Body+0x110> <== NOT EXECUTED 300187f8: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 300187fc: eaffffb7 b 300186e0 <_Timer_server_Body+0x3c> <== NOT EXECUTED } else { ts->active = false; 30018800: e5c4507c strb r5, [r4, #124] ; 0x7c <== NOT EXECUTED /* * Block until there is something to do. */ _Thread_Disable_dispatch(); 30018804: ebffff78 bl 300185ec <_Thread_Disable_dispatch> <== NOT EXECUTED _Thread_Set_state( ts->thread, STATES_DELAYING ); 30018808: e3a01008 mov r1, #8 <== NOT EXECUTED 3001880c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018810: eb000e82 bl 3001c220 <_Thread_Set_state> <== NOT EXECUTED _Timer_server_Reset_interval_system_watchdog( ts ); 30018814: e1a00004 mov r0, r4 <== NOT EXECUTED 30018818: ebffff79 bl 30018604 <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED _Timer_server_Reset_tod_system_watchdog( ts ); 3001881c: e1a00004 mov r0, r4 <== NOT EXECUTED 30018820: ebffff8b bl 30018654 <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED _Thread_Enable_dispatch(); 30018824: eb000c4f bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED ts->active = true; 30018828: e3a03001 mov r3, #1 <== NOT EXECUTED 3001882c: 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 ); 30018830: e2840008 add r0, r4, #8 <== NOT EXECUTED 30018834: eb0010b1 bl 3001cb00 <_Watchdog_Remove> <== NOT EXECUTED static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 30018838: e2840040 add r0, r4, #64 ; 0x40 <== NOT EXECUTED 3001883c: eb0010af bl 3001cb00 <_Watchdog_Remove> <== NOT EXECUTED 30018840: eaffffa6 b 300186e0 <_Timer_server_Body+0x3c> <== NOT EXECUTED =============================================================================== 30018604 <_Timer_server_Reset_interval_system_watchdog>: } static void _Timer_server_Reset_interval_system_watchdog( Timer_server_Control *ts ) { 30018604: 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 ); 30018608: e2805008 add r5, r0, #8 <== NOT EXECUTED } static void _Timer_server_Reset_interval_system_watchdog( Timer_server_Control *ts ) { 3001860c: 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 ); 30018610: e1a00005 mov r0, r5 <== NOT EXECUTED 30018614: eb001139 bl 3001cb00 <_Watchdog_Remove> <== NOT EXECUTED { ISR_Level level; _Timer_server_Stop_interval_system_watchdog( ts ); _ISR_Disable( level ); 30018618: ebffffef bl 300185dc <== NOT EXECUTED initialized = false; } #endif return status; } 3001861c: 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 ); 30018620: e2842034 add r2, r4, #52 ; 0x34 <== NOT EXECUTED ISR_Level level; _Timer_server_Stop_interval_system_watchdog( ts ); _ISR_Disable( level ); if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 30018624: e1530002 cmp r3, r2 <== NOT EXECUTED 30018628: 0a000006 beq 30018648 <_Timer_server_Reset_interval_system_watchdog+0x44><== NOT EXECUTED Watchdog_Interval delta_interval = 3001862c: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 30018630: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 30018634: e59f0014 ldr r0, [pc, #20] ; 30018650 <_Timer_server_Reset_interval_system_watchdog+0x4c><== NOT EXECUTED 30018638: e1a01005 mov r1, r5 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 3001863c: e5843014 str r3, [r4, #20] <== NOT EXECUTED delta_interval ); } else { _ISR_Enable( level ); } } 30018640: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 30018644: ea0010d5 b 3001c9a0 <_Watchdog_Insert> <== NOT EXECUTED 30018648: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 3001864c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 30018654 <_Timer_server_Reset_tod_system_watchdog>: } static void _Timer_server_Reset_tod_system_watchdog( Timer_server_Control *ts ) { 30018654: 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 ); 30018658: e2805040 add r5, r0, #64 ; 0x40 <== NOT EXECUTED } static void _Timer_server_Reset_tod_system_watchdog( Timer_server_Control *ts ) { 3001865c: 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 ); 30018660: e1a00005 mov r0, r5 <== NOT EXECUTED 30018664: eb001125 bl 3001cb00 <_Watchdog_Remove> <== NOT EXECUTED { ISR_Level level; _Timer_server_Stop_tod_system_watchdog( ts ); _ISR_Disable( level ); 30018668: ebffffdb bl 300185dc <== NOT EXECUTED initialized = false; } #endif return status; } 3001866c: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED 30018670: e284206c add r2, r4, #108 ; 0x6c <== NOT EXECUTED ISR_Level level; _Timer_server_Stop_tod_system_watchdog( ts ); _ISR_Disable( level ); if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 30018674: e1530002 cmp r3, r2 <== NOT EXECUTED 30018678: 0a000006 beq 30018698 <_Timer_server_Reset_tod_system_watchdog+0x44><== NOT EXECUTED Watchdog_Interval delta_interval = 3001867c: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED 30018680: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 30018684: e59f0014 ldr r0, [pc, #20] ; 300186a0 <_Timer_server_Reset_tod_system_watchdog+0x4c><== NOT EXECUTED 30018688: e1a01005 mov r1, r5 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 3001868c: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED delta_interval ); } else { _ISR_Enable( level ); } } 30018690: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 30018694: ea0010c1 b 3001c9a0 <_Watchdog_Insert> <== NOT EXECUTED 30018698: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 3001869c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 3001884c <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 3001884c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED if ( ts->insert_chain == NULL ) { 30018850: e5906078 ldr r6, [r0, #120] ; 0x78 <== NOT EXECUTED static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 30018854: e1a04000 mov r4, r0 <== NOT EXECUTED if ( ts->insert_chain == NULL ) { 30018858: e3560000 cmp r6, #0 <== NOT EXECUTED static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 3001885c: e1a05001 mov r5, r1 <== NOT EXECUTED if ( ts->insert_chain == NULL ) { 30018860: 1a000039 bne 3001894c <_Timer_server_Schedule_operation_method+0x100><== NOT EXECUTED * is the reference point for the delta chain. Thus if we do not update the * reference point we have to add DT to the initial delta of the watchdog * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); 30018864: ebffff60 bl 300185ec <_Thread_Disable_dispatch> <== NOT EXECUTED if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 30018868: e5953038 ldr r3, [r5, #56] ; 0x38 <== NOT EXECUTED 3001886c: e3530001 cmp r3, #1 <== NOT EXECUTED 30018870: 1a000017 bne 300188d4 <_Timer_server_Schedule_operation_method+0x88><== NOT EXECUTED /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 30018874: ebffff58 bl 300185dc <== NOT EXECUTED snapshot = _Watchdog_Ticks_since_boot; 30018878: e59f30d8 ldr r3, [pc, #216] ; 30018958 <_Timer_server_Schedule_operation_method+0x10c><== 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 ); 3001887c: e284c034 add ip, r4, #52 ; 0x34 <== NOT EXECUTED 30018880: e5932000 ldr r2, [r3] <== NOT EXECUTED initialized = false; } #endif return status; } 30018884: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); snapshot = _Watchdog_Ticks_since_boot; last_snapshot = ts->Interval_watchdogs.last_snapshot; 30018888: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 3001888c: e153000c cmp r3, ip <== NOT EXECUTED 30018890: 0a000004 beq 300188a8 <_Timer_server_Schedule_operation_method+0x5c><== NOT EXECUTED /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; delta_interval = first_watchdog->delta_interval; 30018894: 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; 30018898: e0611002 rsb r1, r1, r2 <== NOT EXECUTED delta_interval = first_watchdog->delta_interval; if (delta_interval > delta) { 3001889c: e15c0001 cmp ip, r1 <== NOT EXECUTED delta_interval -= delta; 300188a0: 8061600c rsbhi r6, r1, ip <== NOT EXECUTED } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 300188a4: e5836010 str r6, [r3, #16] <== NOT EXECUTED } ts->Interval_watchdogs.last_snapshot = snapshot; 300188a8: e584203c str r2, [r4, #60] ; 0x3c <== NOT EXECUTED 300188ac: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED _ISR_Enable( level ); _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 300188b0: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 300188b4: e2851010 add r1, r5, #16 <== NOT EXECUTED 300188b8: eb001038 bl 3001c9a0 <_Watchdog_Insert> <== NOT EXECUTED if ( !ts->active ) { 300188bc: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 300188c0: e3530000 cmp r3, #0 <== NOT EXECUTED 300188c4: 1a00001e bne 30018944 <_Timer_server_Schedule_operation_method+0xf8><== NOT EXECUTED _Timer_server_Reset_interval_system_watchdog( ts ); 300188c8: e1a00004 mov r0, r4 <== NOT EXECUTED 300188cc: ebffff4c bl 30018604 <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED 300188d0: ea00001b b 30018944 <_Timer_server_Schedule_operation_method+0xf8><== NOT EXECUTED } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 300188d4: e3530003 cmp r3, #3 <== NOT EXECUTED 300188d8: 1a000019 bne 30018944 <_Timer_server_Schedule_operation_method+0xf8><== NOT EXECUTED /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 300188dc: ebffff3e bl 300185dc <== NOT EXECUTED initialized = false; } #endif return status; } 300188e0: e5942068 ldr r2, [r4, #104] ; 0x68 <== 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(); 300188e4: e59f3070 ldr r3, [pc, #112] ; 3001895c <_Timer_server_Schedule_operation_method+0x110><== NOT EXECUTED 300188e8: e284c06c add ip, r4, #108 ; 0x6c <== NOT EXECUTED last_snapshot = ts->TOD_watchdogs.last_snapshot; if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 300188ec: e152000c cmp r2, ip <== 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(); 300188f0: e5933000 ldr r3, [r3] <== NOT EXECUTED last_snapshot = ts->TOD_watchdogs.last_snapshot; 300188f4: e5941074 ldr r1, [r4, #116] ; 0x74 <== NOT EXECUTED if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 300188f8: 0a000008 beq 30018920 <_Timer_server_Schedule_operation_method+0xd4><== NOT EXECUTED first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 300188fc: e592c010 ldr ip, [r2, #16] <== NOT EXECUTED if ( snapshot > last_snapshot ) { 30018900: e1530001 cmp r3, r1 <== NOT EXECUTED } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 30018904: 908c6001 addls r6, ip, r1 <== NOT EXECUTED delta_interval += delta; 30018908: 90636006 rsbls r6, r3, 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 ) { 3001890c: 9a000002 bls 3001891c <_Timer_server_Schedule_operation_method+0xd0><== NOT EXECUTED /* * We advanced in time. */ delta = snapshot - last_snapshot; 30018910: e0611003 rsb r1, r1, r3 <== NOT EXECUTED if (delta_interval > delta) { 30018914: e15c0001 cmp ip, r1 <== NOT EXECUTED delta_interval -= delta; 30018918: 8061600c rsbhi r6, r1, ip <== NOT EXECUTED * Someone put us in the past. */ delta = last_snapshot - snapshot; delta_interval += delta; } first_watchdog->delta_interval = delta_interval; 3001891c: e5826010 str r6, [r2, #16] <== NOT EXECUTED } ts->TOD_watchdogs.last_snapshot = snapshot; 30018920: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED 30018924: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED _ISR_Enable( level ); _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 30018928: e2840068 add r0, r4, #104 ; 0x68 <== NOT EXECUTED 3001892c: e2851010 add r1, r5, #16 <== NOT EXECUTED 30018930: eb00101a bl 3001c9a0 <_Watchdog_Insert> <== NOT EXECUTED if ( !ts->active ) { 30018934: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 30018938: e3530000 cmp r3, #0 <== NOT EXECUTED _Timer_server_Reset_tod_system_watchdog( ts ); 3001893c: 01a00004 moveq r0, r4 <== NOT EXECUTED 30018940: 0bffff43 bleq 30018654 <_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 ); } } 30018944: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 30018948: ea000c06 b 3001b968 <_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 ); 3001894c: e5900078 ldr r0, [r0, #120] ; 0x78 <== NOT EXECUTED } } 30018950: e8bd4070 pop {r4, r5, r6, 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 ); 30018954: ea0001f2 b 30019124 <_Chain_Append> <== NOT EXECUTED =============================================================================== 3000c1e0 <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 3000c1e0: e1a03000 mov r3, r0 uint32_t seconds = add->tv_sec; /* Add the basics */ time->tv_sec += add->tv_sec; 3000c1e4: e5932000 ldr r2, [r3] uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { uint32_t seconds = add->tv_sec; 3000c1e8: e5910000 ldr r0, [r1] /* Add the basics */ time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; 3000c1ec: e593c004 ldr ip, [r3, #4] ) { uint32_t seconds = add->tv_sec; /* Add the basics */ time->tv_sec += add->tv_sec; 3000c1f0: e0822000 add r2, r2, r0 3000c1f4: e5832000 str r2, [r3] time->tv_nsec += add->tv_nsec; 3000c1f8: e5912004 ldr r2, [r1, #4] 3000c1fc: e08c2002 add r2, ip, r2 3000c200: e5832004 str r2, [r3, #4] /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 3000c204: e59fc02c ldr ip, [pc, #44] ; 3000c238 <_Timespec_Add_to+0x58> 3000c208: ea000006 b 3000c228 <_Timespec_Add_to+0x48> time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 3000c20c: e59f2028 ldr r2, [pc, #40] ; 3000c23c <_Timespec_Add_to+0x5c><== NOT EXECUTED time->tv_sec++; seconds++; 3000c210: 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; 3000c214: e0812002 add r2, r1, r2 <== NOT EXECUTED 3000c218: e5832004 str r2, [r3, #4] <== NOT EXECUTED time->tv_sec++; 3000c21c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c220: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000c224: 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 ) { 3000c228: e5931004 ldr r1, [r3, #4] 3000c22c: e151000c cmp r1, ip 3000c230: 8afffff5 bhi 3000c20c <_Timespec_Add_to+0x2c> time->tv_sec++; seconds++; } return seconds; } 3000c234: e12fff1e bx lr =============================================================================== 3000dd6c <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 3000dd6c: e92d40f0 push {r4, r5, r6, r7, lr} 3000dd70: e1a05002 mov r5, r2 * 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; 3000dd74: e5912004 ldr r2, [r1, #4] * 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; 3000dd78: e5917000 ldr r7, [r1] /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 3000dd7c: e590c000 ldr ip, [r0] left += lhs->tv_nsec; 3000dd80: e5906004 ldr r6, [r0, #4] right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 3000dd84: e59f0064 ldr r0, [pc, #100] ; 3000ddf0 <_Timespec_Divide+0x84> const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 3000dd88: e1a04003 mov r4, 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; 3000dd8c: e1a03fc2 asr r3, r2, #31 3000dd90: e0e32790 smlal r2, r3, r0, r7 if ( right == 0 ) { 3000dd94: e1921003 orrs r1, r2, r3 *ival_percentage = 0; 3000dd98: 05851000 streq r1, [r5] *fval_percentage = 0; 3000dd9c: 05841000 streq r1, [r4] 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 ) { 3000dda0: 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; 3000dda4: e1a07fc6 asr r7, r6, #31 <== NOT EXECUTED 3000dda8: e0e76c90 smlal r6, r7, r0, ip <== NOT EXECUTED * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 3000ddac: e59fc040 ldr ip, [pc, #64] ; 3000ddf4 <_Timespec_Divide+0x88><== NOT EXECUTED 3000ddb0: e0810c96 umull r0, r1, r6, ip <== NOT EXECUTED 3000ddb4: e021179c mla r1, ip, r7, r1 <== NOT EXECUTED 3000ddb8: eb003bf7 bl 3001cd9c <__udivdi3> <== NOT EXECUTED *ival_percentage = answer / 1000; 3000ddbc: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000ddc0: 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; 3000ddc4: e1a07000 mov r7, r0 <== NOT EXECUTED 3000ddc8: e1a06001 mov r6, r1 <== NOT EXECUTED *ival_percentage = answer / 1000; 3000ddcc: eb003bf2 bl 3001cd9c <__udivdi3> <== NOT EXECUTED *fval_percentage = answer % 1000; 3000ddd0: e1a01006 mov r1, r6 <== NOT EXECUTED * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 3000ddd4: e5850000 str r0, [r5] <== NOT EXECUTED *fval_percentage = answer % 1000; 3000ddd8: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000dddc: e1a00007 mov r0, r7 <== NOT EXECUTED 3000dde0: e3a03000 mov r3, #0 <== NOT EXECUTED 3000dde4: eb003cfe bl 3001d1e4 <__umoddi3> <== NOT EXECUTED 3000dde8: e5840000 str r0, [r4] <== NOT EXECUTED 3000ddec: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3000dd34 <_Timespec_Divide_by_integer>: void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 3000dd34: e92d4070 push {r4, r5, r6, lr} <== 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; 3000dd38: e59fc06c ldr ip, [pc, #108] ; 3000ddac <_Timespec_Divide_by_integer+0x78><== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; 3000dd3c: e590e000 ldr lr, [r0] <== NOT EXECUTED void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 3000dd40: e1a03001 mov r3, r1 <== NOT EXECUTED 3000dd44: 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; 3000dd48: e0821c9e umull r1, r2, lr, ip <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; 3000dd4c: e1a0500e mov r5, lr <== NOT EXECUTED 3000dd50: e1a06fc5 asr r6, r5, #31 <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 3000dd54: e022269c mla r2, ip, r6, r2 <== NOT EXECUTED t += time->tv_nsec; 3000dd58: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 3000dd5c: e0915000 adds r5, r1, r0 <== NOT EXECUTED 3000dd60: e0a26fc0 adc r6, r2, r0, asr #31 <== NOT EXECUTED 3000dd64: e1a01006 mov r1, r6 <== NOT EXECUTED 3000dd68: e1a02003 mov r2, r3 <== NOT EXECUTED 3000dd6c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000dd70: e3a03000 mov r3, #0 <== NOT EXECUTED 3000dd74: eb003a36 bl 3001c654 <__udivdi3> <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 3000dd78: e59f202c ldr r2, [pc, #44] ; 3000ddac <_Timespec_Divide_by_integer+0x78><== NOT EXECUTED 3000dd7c: e3a03000 mov r3, #0 <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 3000dd80: e1a06000 mov r6, r0 <== NOT EXECUTED 3000dd84: e1a05001 mov r5, r1 <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 3000dd88: eb003a31 bl 3001c654 <__udivdi3> <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 3000dd8c: e1a01005 mov r1, r5 <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 3000dd90: e5840000 str r0, [r4] <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 3000dd94: e59f2010 ldr r2, [pc, #16] ; 3000ddac <_Timespec_Divide_by_integer+0x78><== NOT EXECUTED 3000dd98: e1a00006 mov r0, r6 <== NOT EXECUTED 3000dd9c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000dda0: eb003b3d bl 3001ca9c <__umoddi3> <== NOT EXECUTED 3000dda4: e5840004 str r0, [r4, #4] <== NOT EXECUTED } 3000dda8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3001d130 <_Timespec_From_ticks>: struct timespec *time ) { uint32_t usecs; usecs = ticks * rtems_configuration_get_microseconds_per_tick(); 3001d130: e59f3038 ldr r3, [pc, #56] ; 3001d170 <_Timespec_From_ticks+0x40><== NOT EXECUTED void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 3001d134: e92d4030 push {r4, r5, lr} <== NOT EXECUTED uint32_t usecs; usecs = ticks * rtems_configuration_get_microseconds_per_tick(); 3001d138: e593500c ldr r5, [r3, #12] <== NOT EXECUTED void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 3001d13c: e1a04001 mov r4, r1 <== NOT EXECUTED uint32_t usecs; usecs = ticks * rtems_configuration_get_microseconds_per_tick(); 3001d140: e0050590 mul r5, r0, r5 <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 3001d144: e59f1028 ldr r1, [pc, #40] ; 3001d174 <_Timespec_From_ticks+0x44><== NOT EXECUTED 3001d148: e1a00005 mov r0, r5 <== NOT EXECUTED 3001d14c: ebfff644 bl 3001aa64 <__aeabi_uidiv> <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 3001d150: e59f101c ldr r1, [pc, #28] ; 3001d174 <_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; 3001d154: e5840000 str r0, [r4] <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 3001d158: e1a00005 mov r0, r5 <== NOT EXECUTED 3001d15c: ebfff6d8 bl 3001acc4 <__umodsi3> <== NOT EXECUTED 3001d160: e3a03ffa mov r3, #1000 ; 0x3e8 <== NOT EXECUTED 3001d164: e0030390 mul r3, r0, r3 <== NOT EXECUTED 3001d168: e5843004 str r3, [r4, #4] <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 3001d16c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED =============================================================================== 3001d178 <_Timespec_Is_valid>: bool _Timespec_Is_valid( const struct timespec *time ) { if ( !time ) 3001d178: e3500000 cmp r0, #0 <== NOT EXECUTED 3001d17c: 012fff1e bxeq lr <== NOT EXECUTED return false; if ( time->tv_sec < 0 ) 3001d180: e5903000 ldr r3, [r0] <== NOT EXECUTED 3001d184: e3530000 cmp r3, #0 <== NOT EXECUTED return false; 3001d188: b3a00000 movlt r0, #0 <== NOT EXECUTED ) { if ( !time ) return false; if ( time->tv_sec < 0 ) 3001d18c: b12fff1e bxlt lr <== NOT EXECUTED return false; if ( time->tv_nsec < 0 ) 3001d190: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 3001d194: e3530000 cmp r3, #0 <== NOT EXECUTED 3001d198: ba000004 blt 3001d1b0 <_Timespec_Is_valid+0x38> <== NOT EXECUTED #include #include #include bool _Timespec_Is_valid( 3001d19c: e59f0014 ldr r0, [pc, #20] ; 3001d1b8 <_Timespec_Is_valid+0x40><== NOT EXECUTED 3001d1a0: e1530000 cmp r3, r0 <== NOT EXECUTED 3001d1a4: 83a00000 movhi r0, #0 <== NOT EXECUTED 3001d1a8: 93a00001 movls r0, #1 <== NOT EXECUTED 3001d1ac: e12fff1e bx lr <== NOT EXECUTED if ( time->tv_sec < 0 ) return false; if ( time->tv_nsec < 0 ) return false; 3001d1b0: e3a00000 mov r0, #0 <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return false; return true; } 3001d1b4: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000dde8 <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 3000dde8: e5902000 ldr r2, [r0] 3000ddec: e5913000 ldr r3, [r1] 3000ddf0: e1520003 cmp r2, r3 return true; 3000ddf4: b3a00001 movlt r0, #1 bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 3000ddf8: b12fff1e bxlt lr return true; if ( lhs->tv_sec > rhs->tv_sec ) 3000ddfc: ca000005 bgt 3000de18 <_Timespec_Less_than+0x30> #include #include #include bool _Timespec_Less_than( 3000de00: e5900004 ldr r0, [r0, #4] 3000de04: e5913004 ldr r3, [r1, #4] 3000de08: e1500003 cmp r0, r3 3000de0c: a3a00000 movge r0, #0 3000de10: b3a00001 movlt r0, #1 3000de14: e12fff1e bx lr { if ( lhs->tv_sec < rhs->tv_sec ) return true; if ( lhs->tv_sec > rhs->tv_sec ) return false; 3000de18: e3a00000 mov r0, #0 <== NOT EXECUTED /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) return true; return false; } 3000de1c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3001d1bc <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 3001d1bc: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 3001d1c0: e5906000 ldr r6, [r0] <== NOT EXECUTED */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 3001d1c4: e1a05000 mov r5, r0 <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 3001d1c8: e3560000 cmp r6, #0 <== NOT EXECUTED 3001d1cc: 1a000002 bne 3001d1dc <_Timespec_To_ticks+0x20> <== NOT EXECUTED 3001d1d0: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED 3001d1d4: e3500000 cmp r0, #0 <== NOT EXECUTED 3001d1d8: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 3001d1dc: eb00007f bl 3001d3e0 <== NOT EXECUTED ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick(); 3001d1e0: e59f3020 ldr r3, [pc, #32] ; 3001d208 <_Timespec_To_ticks+0x4c><== NOT EXECUTED 3001d1e4: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3001d1e8: e593300c ldr r3, [r3, #12] <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 3001d1ec: e0040096 mul r4, r6, r0 <== NOT EXECUTED ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick(); 3001d1f0: e0010193 mul r1, r3, r1 <== NOT EXECUTED 3001d1f4: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 3001d1f8: ebfff619 bl 3001aa64 <__aeabi_uidiv> <== NOT EXECUTED if (ticks) 3001d1fc: e0940000 adds r0, r4, r0 <== NOT EXECUTED return ticks; return 1; 3001d200: 03a00001 moveq r0, #1 <== NOT EXECUTED } 3001d204: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000c3a4 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 3000c3a4: e92d41f0 push {r4, r5, r6, r7, r8, lr} the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 3000c3a8: e59f503c ldr r5, [pc, #60] ; 3000c3ec <_User_extensions_Fatal+0x48> void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 3000c3ac: e1a08000 mov r8, r0 3000c3b0: e1a07002 mov r7, r2 3000c3b4: e20160ff and r6, r1, #255 ; 0xff the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 3000c3b8: e5954008 ldr r4, [r5, #8] ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 3000c3bc: ea000007 b 3000c3e0 <_User_extensions_Fatal+0x3c> !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 3000c3c0: e5943030 ldr r3, [r4, #48] ; 0x30 3000c3c4: e3530000 cmp r3, #0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 3000c3c8: 11a00008 movne r0, r8 3000c3cc: 11a01006 movne r1, r6 3000c3d0: 11a02007 movne r2, r7 3000c3d4: 11a0e00f movne lr, pc 3000c3d8: 112fff13 bxne r3 Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 3000c3dc: e5944004 ldr r4, [r4, #4] ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 3000c3e0: e1540005 cmp r4, r5 3000c3e4: 1afffff5 bne 3000c3c0 <_User_extensions_Fatal+0x1c> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 3000c3e8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 3000dab4 <_User_extensions_Remove_set>: #include void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 3000dab4: e92d4010 push {r4, lr} 3000dab8: e1a04000 mov r4, r0 _Chain_Extract( &the_extension->Node ); 3000dabc: ebfff67c bl 3000b4b4 <_Chain_Extract> /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 3000dac0: e5943024 ldr r3, [r4, #36] ; 0x24 3000dac4: e3530000 cmp r3, #0 3000dac8: 08bd8010 popeq {r4, pc} _Chain_Extract( &the_extension->Switch.Node ); 3000dacc: e2840008 add r0, r4, #8 <== NOT EXECUTED } 3000dad0: 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 ); 3000dad4: eafff676 b 3000b4b4 <_Chain_Extract> <== NOT EXECUTED =============================================================================== 3000e108 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 3000e108: e92d41f0 push {r4, r5, r6, r7, r8, lr} 3000e10c: e1a04000 mov r4, r0 3000e110: e1a05002 mov r5, r2 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000e114: e10f3000 mrs r3, CPSR 3000e118: e3832080 orr r2, r3, #128 ; 0x80 3000e11c: e129f002 msr CPSR_fc, r2 } } _ISR_Enable( level ); } 3000e120: e1a06000 mov r6, r0 3000e124: 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 ) ) { 3000e128: e1520006 cmp r2, r6 3000e12c: 0a00001b beq 3000e1a0 <_Watchdog_Adjust+0x98> switch ( direction ) { 3000e130: 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; 3000e134: 03a08001 moveq r8, #1 <== NOT EXECUTED * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 3000e138: 0a000016 beq 3000e198 <_Watchdog_Adjust+0x90> <== NOT EXECUTED 3000e13c: e3510001 cmp r1, #1 <== NOT EXECUTED 3000e140: 1a000016 bne 3000e1a0 <_Watchdog_Adjust+0x98> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 3000e144: e5921010 ldr r1, [r2, #16] <== NOT EXECUTED 3000e148: e0815005 add r5, r1, r5 <== NOT EXECUTED 3000e14c: ea000004 b 3000e164 <_Watchdog_Adjust+0x5c> <== NOT EXECUTED RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 3000e150: e5942000 ldr r2, [r4] <== NOT EXECUTED break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 3000e154: e5927010 ldr r7, [r2, #16] <== NOT EXECUTED 3000e158: e1550007 cmp r5, r7 <== NOT EXECUTED 3000e15c: 2a000002 bcs 3000e16c <_Watchdog_Adjust+0x64> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; 3000e160: e0655007 rsb r5, r5, r7 <== NOT EXECUTED 3000e164: e5825010 str r5, [r2, #16] <== NOT EXECUTED break; 3000e168: ea00000c b 3000e1a0 <_Watchdog_Adjust+0x98> <== NOT EXECUTED } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 3000e16c: e5828010 str r8, [r2, #16] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000e170: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _ISR_Enable( level ); _Watchdog_Tickle( header ); 3000e174: e1a00004 mov r0, r4 <== NOT EXECUTED 3000e178: eb00008b bl 3000e3ac <_Watchdog_Tickle> <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000e17c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000e180: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000e184: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 3000e188: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000e18c: e1520006 cmp r2, r6 <== NOT EXECUTED 3000e190: 0a000002 beq 3000e1a0 <_Watchdog_Adjust+0x98> <== 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; 3000e194: e0675005 rsb r5, r7, r5 <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 3000e198: e3550000 cmp r5, #0 <== NOT EXECUTED 3000e19c: 1affffeb bne 3000e150 <_Watchdog_Adjust+0x48> <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000e1a0: e129f003 msr CPSR_fc, r3 } } _ISR_Enable( level ); } 3000e1a4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} =============================================================================== 3001c8f4 <_Watchdog_Adjust_to_chain>: { Watchdog_Interval units = units_arg; ISR_Level level; Watchdog_Control *first; if ( units <= 0 ) { 3001c8f4: e3510000 cmp r1, #0 <== NOT EXECUTED Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 3001c8f8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED Watchdog_Interval units = units_arg; ISR_Level level; Watchdog_Control *first; if ( units <= 0 ) { 3001c8fc: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3001c900: e10f5000 mrs r5, CPSR <== NOT EXECUTED 3001c904: e3853080 orr r3, r5, #128 ; 0x80 <== NOT EXECUTED 3001c908: 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; 3001c90c: 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 ); 3001c910: e2806004 add r6, 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 ); 3001c914: e2827004 add r7, r2, #4 <== NOT EXECUTED 3001c918: ea000001 b 3001c924 <_Watchdog_Adjust_to_chain+0x30> <== NOT EXECUTED } _ISR_Disable( level ); while ( 1 ) { if ( units <= 0 ) { 3001c91c: e3510000 cmp r1, #0 <== NOT EXECUTED 3001c920: 0a00001c beq 3001c998 <_Watchdog_Adjust_to_chain+0xa4> <== NOT EXECUTED break; } } _ISR_Enable( level ); } 3001c924: e590c000 ldr ip, [r0] <== NOT EXECUTED while ( 1 ) { if ( units <= 0 ) { break; } if ( _Chain_Is_empty( header ) ) { 3001c928: e15c0006 cmp ip, r6 <== NOT EXECUTED 3001c92c: 0a000019 beq 3001c998 <_Watchdog_Adjust_to_chain+0xa4> <== 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 ) { 3001c930: e59c4010 ldr r4, [ip, #16] <== NOT EXECUTED 3001c934: e1a0300c mov r3, ip <== NOT EXECUTED 3001c938: e1510004 cmp r1, r4 <== NOT EXECUTED first->delta_interval -= units; 3001c93c: 30611004 rsbcc r1, r1, r4 <== NOT EXECUTED 3001c940: 358c1010 strcc r1, [ip, #16] <== NOT EXECUTED break; 3001c944: 3a000013 bcc 3001c998 <_Watchdog_Adjust_to_chain+0xa4> <== 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; 3001c948: e0641001 rsb r1, r4, r1 <== NOT EXECUTED first->delta_interval = 0; 3001c94c: e58c8010 str r8, [ip, #16] <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 3001c950: e8931010 ldm r3, {r4, ip} <== NOT EXECUTED next->previous = previous; 3001c954: e584c004 str ip, [r4, #4] <== NOT EXECUTED previous->next = next; 3001c958: e58c4000 str r4, [ip] <== NOT EXECUTED Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 3001c95c: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED the_node->next = tail; 3001c960: e5837000 str r7, [r3] <== NOT EXECUTED tail->previous = the_node; old_last->next = the_node; 3001c964: 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; 3001c968: e5823008 str r3, [r2, #8] <== NOT EXECUTED old_last->next = the_node; the_node->previous = old_last; 3001c96c: e583c004 str ip, [r3, #4] <== NOT EXECUTED static inline void arm_interrupt_flash( uint32_t level ) { uint32_t arm_switch_reg; __asm__ volatile ( 3001c970: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3001c974: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED 3001c978: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED break; } } _ISR_Enable( level ); } 3001c97c: 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 ) ) 3001c980: e1530006 cmp r3, r6 <== NOT EXECUTED 3001c984: 0affffe4 beq 3001c91c <_Watchdog_Adjust_to_chain+0x28> <== NOT EXECUTED break; first = _Watchdog_First( header ); if ( first->delta_interval != 0 ) 3001c988: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001c98c: e35c0000 cmp ip, #0 <== NOT EXECUTED 3001c990: 0affffee beq 3001c950 <_Watchdog_Adjust_to_chain+0x5c> <== NOT EXECUTED 3001c994: eaffffe0 b 3001c91c <_Watchdog_Adjust_to_chain+0x28> <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3001c998: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED 3001c99c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 3000c514 <_Watchdog_Insert>: Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 3000c514: e59f30f4 ldr r3, [pc, #244] ; 3000c610 <_Watchdog_Insert+0xfc> void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 3000c518: e92d41f0 push {r4, r5, r6, r7, r8, lr} Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 3000c51c: e5934000 ldr r4, [r3] static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000c520: e10fc000 mrs ip, CPSR 3000c524: e38c3080 orr r3, ip, #128 ; 0x80 3000c528: 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_watchdog->state != WATCHDOG_INACTIVE ) { 3000c52c: e5913008 ldr r3, [r1, #8] 3000c530: e3530000 cmp r3, #0 3000c534: 0a000000 beq 3000c53c <_Watchdog_Insert+0x28> _ISR_Enable( level ); 3000c538: ea000032 b 3000c608 <_Watchdog_Insert+0xf4> <== NOT EXECUTED return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 3000c53c: e3a03001 mov r3, #1 3000c540: e5813008 str r3, [r1, #8] _Watchdog_Sync_count++; 3000c544: e59f30c8 ldr r3, [pc, #200] ; 3000c614 <_Watchdog_Insert+0x100> if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 3000c548: e59f60c8 ldr r6, [pc, #200] ; 3000c618 <_Watchdog_Insert+0x104> _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 3000c54c: e5932000 ldr r2, [r3] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 3000c550: e1a07006 mov r7, r6 _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 3000c554: e2822001 add r2, r2, #1 3000c558: e5832000 str r2, [r3] restart: delta_interval = the_watchdog->initial; 3000c55c: e591200c ldr r2, [r1, #12] RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 3000c560: e5903000 ldr r3, [r0] for ( after = _Watchdog_First( header ) ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 3000c564: e3520000 cmp r2, #0 3000c568: 0a000014 beq 3000c5c0 <_Watchdog_Insert+0xac> 3000c56c: e5935000 ldr r5, [r3] 3000c570: e3550000 cmp r5, #0 3000c574: 0a000011 beq 3000c5c0 <_Watchdog_Insert+0xac> break; if ( delta_interval < after->delta_interval ) { 3000c578: e5935010 ldr r5, [r3, #16] 3000c57c: e1520005 cmp r2, r5 after->delta_interval -= delta_interval; 3000c580: 30625005 rsbcc r5, r2, r5 3000c584: 35835010 strcc r5, [r3, #16] break; 3000c588: 3a00000c bcc 3000c5c0 <_Watchdog_Insert+0xac> static inline void arm_interrupt_flash( uint32_t level ) { uint32_t arm_switch_reg; __asm__ volatile ( 3000c58c: e10f8000 mrs r8, CPSR 3000c590: e129f00c msr CPSR_fc, ip 3000c594: e129f008 msr CPSR_fc, r8 delta_interval -= after->delta_interval; _ISR_Flash( level ); if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 3000c598: e5918008 ldr r8, [r1, #8] 3000c59c: e3580001 cmp r8, #1 3000c5a0: 1a000012 bne 3000c5f0 <_Watchdog_Insert+0xdc> goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 3000c5a4: e5968000 ldr r8, [r6] 3000c5a8: e1580004 cmp r8, r4 _Watchdog_Sync_level = insert_isr_nest_level; 3000c5ac: 85874000 strhi r4, [r7] goto restart; 3000c5b0: 8affffe9 bhi 3000c55c <_Watchdog_Insert+0x48> if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 3000c5b4: e0652002 rsb r2, r5, r2 exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 3000c5b8: e5933000 ldr r3, [r3] if ( _Watchdog_Sync_level > insert_isr_nest_level ) { _Watchdog_Sync_level = insert_isr_nest_level; goto restart; } } 3000c5bc: eaffffe8 b 3000c564 <_Watchdog_Insert+0x50> _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 3000c5c0: e5933004 ldr r3, [r3, #4] RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 3000c5c4: e3a00002 mov r0, #2 } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 3000c5c8: e5812010 str r2, [r1, #16] 3000c5cc: e5810008 str r0, [r1, #8] ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 3000c5d0: e5932000 ldr r2, [r3] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 3000c5d4: e5813004 str r3, [r1, #4] before_node = after_node->next; after_node->next = the_node; 3000c5d8: e5831000 str r1, [r3] _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; 3000c5dc: e59f3038 ldr r3, [pc, #56] ; 3000c61c <_Watchdog_Insert+0x108> the_node->next = before_node; before_node->previous = the_node; 3000c5e0: e5821004 str r1, [r2, #4] 3000c5e4: e5933000 ldr r3, [r3] Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 3000c5e8: e5812000 str r2, [r1] 3000c5ec: e5813014 str r3, [r1, #20] exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 3000c5f0: e59f3020 ldr r3, [pc, #32] ; 3000c618 <_Watchdog_Insert+0x104> 3000c5f4: e5834000 str r4, [r3] _Watchdog_Sync_count--; 3000c5f8: e59f3014 ldr r3, [pc, #20] ; 3000c614 <_Watchdog_Insert+0x100> 3000c5fc: e5932000 ldr r2, [r3] 3000c600: e2422001 sub r2, r2, #1 3000c604: e5832000 str r2, [r3] static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000c608: e129f00c msr CPSR_fc, ip 3000c60c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} =============================================================================== 3000dbf4 <_Watchdog_Report>: void _Watchdog_Report( const char *name, Watchdog_Control *watch ) { 3000dbf4: e92d401f push {r0, r1, r2, r3, r4, lr} <== NOT EXECUTED 3000dbf8: e1a03001 mov r3, r1 <== NOT EXECUTED printk( 3000dbfc: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3000dc00: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000dc04: e88d0009 stm sp, {r0, r3} <== NOT EXECUTED 3000dc08: e593001c ldr r0, [r3, #28] <== NOT EXECUTED 3000dc0c: 059f102c ldreq r1, [pc, #44] ; 3000dc40 <_Watchdog_Report+0x4c><== NOT EXECUTED 3000dc10: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3000dc14: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 3000dc18: 01a02001 moveq r2, r1 <== NOT EXECUTED 3000dc1c: e58d000c str r0, [sp, #12] <== NOT EXECUTED 3000dc20: e5930024 ldr r0, [r3, #36] ; 0x24 <== NOT EXECUTED 3000dc24: 159f2018 ldrne r2, [pc, #24] ; 3000dc44 <_Watchdog_Report+0x50><== NOT EXECUTED 3000dc28: e58d0010 str r0, [sp, #16] <== NOT EXECUTED 3000dc2c: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED 3000dc30: e59f0010 ldr r0, [pc, #16] ; 3000dc48 <_Watchdog_Report+0x54><== NOT EXECUTED 3000dc34: ebffe855 bl 30007d90 <== NOT EXECUTED watch, watch->routine, watch->id, watch->user_data ); } 3000dc38: e28dd014 add sp, sp, #20 <== NOT EXECUTED 3000dc3c: e8bd8000 pop {pc} <== NOT EXECUTED =============================================================================== 3000db7c <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 3000db7c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED 3000db80: e1a04000 mov r4, r0 <== NOT EXECUTED 3000db84: e1a05001 mov r5, r1 <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000db88: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000db8c: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000db90: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED ISR_Level level; Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); 3000db94: e59f004c ldr r0, [pc, #76] ; 3000dbe8 <_Watchdog_Report_chain+0x6c><== NOT EXECUTED 3000db98: e1a02005 mov r2, r5 <== NOT EXECUTED 3000db9c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000dba0: ebffe87a bl 30007d90 <== NOT EXECUTED printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); } 3000dba4: e4957004 ldr r7, [r5], #4 <== NOT EXECUTED ISR_Level level; Chain_Node *node; _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { 3000dba8: e1570005 cmp r7, r5 <== NOT EXECUTED 3000dbac: 0a000009 beq 3000dbd8 <_Watchdog_Report_chain+0x5c> <== NOT EXECUTED node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 3000dbb0: e1a01007 mov r1, r7 <== NOT EXECUTED 3000dbb4: e3a00000 mov r0, #0 <== NOT EXECUTED 3000dbb8: eb00000d bl 3000dbf4 <_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 ) 3000dbbc: 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 ) ; 3000dbc0: e1570005 cmp r7, r5 <== NOT EXECUTED 3000dbc4: 1afffff9 bne 3000dbb0 <_Watchdog_Report_chain+0x34> <== NOT EXECUTED { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 3000dbc8: e59f001c ldr r0, [pc, #28] ; 3000dbec <_Watchdog_Report_chain+0x70><== NOT EXECUTED 3000dbcc: e1a01004 mov r1, r4 <== NOT EXECUTED 3000dbd0: ebffe86e bl 30007d90 <== NOT EXECUTED 3000dbd4: ea000001 b 3000dbe0 <_Watchdog_Report_chain+0x64> <== NOT EXECUTED } else { printk( "Chain is empty\n" ); 3000dbd8: e59f0010 ldr r0, [pc, #16] ; 3000dbf0 <_Watchdog_Report_chain+0x74><== NOT EXECUTED 3000dbdc: ebffe86b bl 30007d90 <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000dbe0: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED } _ISR_Enable( level ); } 3000dbe4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 3000c718 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 3000c718: e92d40f0 push {r4, r5, r6, r7, lr} 3000c71c: e1a06000 mov r6, r0 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000c720: e10f7000 mrs r7, CPSR 3000c724: e3873080 orr r3, r7, #128 ; 0x80 3000c728: e129f003 msr CPSR_fc, r3 } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 3000c72c: e1a05000 mov r5, r0 3000c730: e4953004 ldr r3, [r5], #4 * volatile data - till, 2003/7 */ _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 3000c734: e1530005 cmp r3, r5 3000c738: 0a000018 beq 3000c7a0 <_Watchdog_Tickle+0x88> * 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) { 3000c73c: e5932010 ldr r2, [r3, #16] RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 3000c740: e1a04003 mov r4, r3 3000c744: e3520000 cmp r2, #0 3000c748: 0a000003 beq 3000c75c <_Watchdog_Tickle+0x44> the_watchdog->delta_interval--; 3000c74c: e2422001 sub r2, r2, #1 3000c750: e5832010 str r2, [r3, #16] if ( the_watchdog->delta_interval != 0 ) 3000c754: e3520000 cmp r2, #0 3000c758: 1a000010 bne 3000c7a0 <_Watchdog_Tickle+0x88> goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 3000c75c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c760: ebffffc3 bl 3000c674 <_Watchdog_Remove> <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000c764: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED _ISR_Enable( level ); switch( watchdog_state ) { 3000c768: e3500002 cmp r0, #2 <== NOT EXECUTED case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 3000c76c: 05940020 ldreq r0, [r4, #32] <== NOT EXECUTED 3000c770: 05941024 ldreq r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000c774: 01a0e00f moveq lr, pc <== NOT EXECUTED 3000c778: 0594f01c ldreq pc, [r4, #28] <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000c77c: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3000c780: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3000c784: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 3000c788: e5964000 ldr r4, [r6] <== NOT EXECUTED _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 3000c78c: e1540005 cmp r4, r5 <== NOT EXECUTED 3000c790: 0a000002 beq 3000c7a0 <_Watchdog_Tickle+0x88> <== NOT EXECUTED } _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && 3000c794: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 3000c798: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c79c: eaffffed b 3000c758 <_Watchdog_Tickle+0x40> <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000c7a0: e129f007 msr CPSR_fc, r7 (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 3000c7a4: e8bd80f0 pop {r4, r5, r6, r7, pc} =============================================================================== 3000c828 <_Workspace_Allocate_or_fatal_error>: 3000c828: e3a02000 mov r2, #0 * _Workspace_Allocate_or_fatal_error */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 3000c82c: e1a01000 mov r1, r0 3000c830: e52de004 push {lr} ; (str lr, [sp, #-4]!) 3000c834: e59f0018 ldr r0, [pc, #24] ; 3000c854 <_Workspace_Allocate_or_fatal_error+0x2c> 3000c838: e1a03002 mov r3, r2 3000c83c: eb00079e bl 3000e6bc <_Heap_Allocate_aligned_with_boundary> __builtin_return_address( 1 ), memory ); #endif if ( memory == NULL ) 3000c840: e3500000 cmp r0, #0 3000c844: 149df004 popne {pc} ; (ldrne pc, [sp], #4) _Internal_error_Occurred( 3000c848: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c84c: e3a02003 mov r2, #3 <== NOT EXECUTED 3000c850: ebfff792 bl 3000a6a0 <_Internal_error_Occurred> <== NOT EXECUTED =============================================================================== 3000c7a8 <_Workspace_Handler_initialization>: * _Workspace_Handler_initialization */ void _Workspace_Handler_initialization(void) { uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start; 3000c7a8: e59f3048 ldr r3, [pc, #72] ; 3000c7f8 <_Workspace_Handler_initialization+0x50> /* * _Workspace_Handler_initialization */ void _Workspace_Handler_initialization(void) { 3000c7ac: e92d4030 push {r4, r5, lr} uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start; 3000c7b0: e5935000 ldr r5, [r3] uintptr_t size = Configuration.work_space_size; 3000c7b4: e5934004 ldr r4, [r3, #4] if ( Configuration.do_zero_of_workspace ) 3000c7b8: e5d33028 ldrb r3, [r3, #40] ; 0x28 3000c7bc: e3530000 cmp r3, #0 memset( starting_address, 0, size ); 3000c7c0: 11a00005 movne r0, r5 3000c7c4: 13a01000 movne r1, #0 3000c7c8: 11a02004 movne r2, r4 3000c7cc: 1b0010ff blne 30010bd0 memory_available = _Heap_Initialize( 3000c7d0: e59f0024 ldr r0, [pc, #36] ; 3000c7fc <_Workspace_Handler_initialization+0x54> 3000c7d4: e1a01005 mov r1, r5 3000c7d8: e1a02004 mov r2, r4 3000c7dc: e3a03008 mov r3, #8 3000c7e0: ebfff71b bl 3000a454 <_Heap_Initialize> starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 3000c7e4: e3500000 cmp r0, #0 3000c7e8: 18bd8030 popne {r4, r5, pc} _Internal_error_Occurred( 3000c7ec: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c7f0: e3a02002 mov r2, #2 <== NOT EXECUTED 3000c7f4: ebfff7a9 bl 3000a6a0 <_Internal_error_Occurred> <== NOT EXECUTED =============================================================================== 300108dc : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 300108dc: 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 ) ) 300108e0: e2508000 subs r8, r0, #0 rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 300108e4: e1a04001 mov r4, r1 300108e8: e1a06003 mov r6, r3 Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 300108ec: 03a00003 moveq r0, #3 ) { Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 300108f0: 0a000026 beq 30010990 return RTEMS_INVALID_NAME; if ( !id ) 300108f4: e3530000 cmp r3, #0 return RTEMS_INVALID_ADDRESS; 300108f8: 03a00009 moveq r0, #9 CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 300108fc: 0a000023 beq 30010990 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 30010900: e3110010 tst r1, #16 30010904: 0a000004 beq 3001091c the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 30010908: e3a03000 mov r3, #0 <== NOT EXECUTED if ( maximum_waiters == 0 ) 3001090c: 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; 30010910: e58d3000 str r3, [sp] <== NOT EXECUTED if ( maximum_waiters == 0 ) 30010914: 1a000002 bne 30010924 <== NOT EXECUTED 30010918: ea00001b b 3001098c <== NOT EXECUTED return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 3001091c: e3a03001 mov r3, #1 30010920: e58d3000 str r3, [sp] 30010924: e59f3068 ldr r3, [pc, #104] ; 30010994 the_attributes.maximum_count = maximum_waiters; 30010928: e58d2004 str r2, [sp, #4] 3001092c: e5932000 ldr r2, [r3] 30010930: e2822001 add r2, r2, #1 30010934: 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 ); 30010938: e59f7058 ldr r7, [pc, #88] ; 30010998 3001093c: e1a00007 mov r0, r7 30010940: ebffef09 bl 3000c56c <_Objects_Allocate> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 30010944: e2505000 subs r5, r0, #0 30010948: 1a000002 bne 30010958 _Thread_Enable_dispatch(); 3001094c: ebfff328 bl 3000d5f4 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 30010950: e3a00005 mov r0, #5 <== NOT EXECUTED 30010954: ea00000d b 30010990 <== NOT EXECUTED } the_barrier->attribute_set = attribute_set; _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 30010958: e2850014 add r0, r5, #20 3001095c: e1a0100d mov r1, sp if ( !the_barrier ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 30010960: e5854010 str r4, [r5, #16] _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 30010964: eb00021d bl 300111e0 <_CORE_barrier_Initialize> #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30010968: e597201c ldr r2, [r7, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 3001096c: e5953008 ldr r3, [r5, #8] 30010970: e1d510b8 ldrh r1, [r5, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30010974: e7825101 str r5, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 30010978: e585800c str r8, [r5, #12] &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 3001097c: e5863000 str r3, [r6] _Thread_Enable_dispatch(); 30010980: ebfff31b bl 3000d5f4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30010984: e3a00000 mov r0, #0 30010988: ea000000 b 30010990 /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; 3001098c: e3a0000a mov r0, #10 <== NOT EXECUTED *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 30010990: e8bd81fc pop {r2, r3, r4, r5, r6, r7, r8, pc} =============================================================================== 30010a3c : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 30010a3c: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 30010a40: e2516000 subs r6, r1, #0 <== NOT EXECUTED rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 30010a44: e1a05000 mov r5, r0 <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) return RTEMS_INVALID_ADDRESS; 30010a48: 03a00009 moveq r0, #9 <== NOT EXECUTED ) { Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 30010a4c: 0a00000e beq 30010a8c <== NOT EXECUTED Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) _Objects_Get( &_Barrier_Information, id, location ); 30010a50: e59f0038 ldr r0, [pc, #56] ; 30010a90 <== NOT EXECUTED 30010a54: e1a01005 mov r1, r5 <== NOT EXECUTED 30010a58: e1a0200d mov r2, sp <== NOT EXECUTED 30010a5c: ebffefde bl 3000c9dc <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 30010a60: e59d4000 ldr r4, [sp] <== NOT EXECUTED 30010a64: e3540000 cmp r4, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30010a68: 13a00004 movne r0, #4 <== NOT EXECUTED if ( !released ) return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 30010a6c: 1a000006 bne 30010a8c <== NOT EXECUTED case OBJECTS_LOCAL: *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL ); 30010a70: e1a01005 mov r1, r5 <== NOT EXECUTED 30010a74: e1a02004 mov r2, r4 <== NOT EXECUTED 30010a78: e2800014 add r0, r0, #20 <== NOT EXECUTED 30010a7c: eb0001df bl 30011200 <_CORE_barrier_Release> <== NOT EXECUTED 30010a80: e5860000 str r0, [r6] <== NOT EXECUTED _Thread_Enable_dispatch(); 30010a84: ebfff2da bl 3000d5f4 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30010a88: e1a00004 mov r0, r4 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30010a8c: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 30010a94 : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 30010a94: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED 30010a98: e1a04000 mov r4, r0 <== NOT EXECUTED 30010a9c: e1a05001 mov r5, r1 <== NOT EXECUTED 30010aa0: e59f0048 ldr r0, [pc, #72] ; 30010af0 <== NOT EXECUTED 30010aa4: e1a01004 mov r1, r4 <== NOT EXECUTED 30010aa8: e28d2004 add r2, sp, #4 <== NOT EXECUTED 30010aac: ebffefca bl 3000c9dc <_Objects_Get> <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 30010ab0: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30010ab4: e3530000 cmp r3, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30010ab8: 13a00004 movne r0, #4 <== NOT EXECUTED { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 30010abc: 1a00000a bne 30010aec <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Wait( 30010ac0: e2800014 add r0, r0, #20 <== NOT EXECUTED 30010ac4: e58d3000 str r3, [sp] <== NOT EXECUTED 30010ac8: e1a01004 mov r1, r4 <== NOT EXECUTED 30010acc: e1a03005 mov r3, r5 <== NOT EXECUTED 30010ad0: e3a02001 mov r2, #1 <== NOT EXECUTED 30010ad4: eb0001d5 bl 30011230 <_CORE_barrier_Wait> <== NOT EXECUTED id, true, timeout, NULL ); _Thread_Enable_dispatch(); 30010ad8: ebfff2c5 bl 3000d5f4 <_Thread_Enable_dispatch> <== NOT EXECUTED return _Barrier_Translate_core_barrier_return_code( _Thread_Executing->Wait.return_code ); 30010adc: e59f3010 ldr r3, [pc, #16] ; 30010af4 <== NOT EXECUTED 30010ae0: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED true, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 30010ae4: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 30010ae8: eb000427 bl 30011b8c <_Barrier_Translate_core_barrier_return_code><== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30010aec: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 3000b1fc : uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 3000b1fc: e1a00c00 lsl r0, r0, #24 <== NOT EXECUTED 3000b200: e1800d81 orr r0, r0, r1, lsl #27 <== NOT EXECUTED (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 3000b204: e1800003 orr r0, r0, r3 <== NOT EXECUTED uint32_t node, uint32_t index ) { return _Objects_Build_id( api, class, node, index ); } 3000b208: e1800802 orr r0, r0, r2, lsl #16 <== NOT EXECUTED 3000b20c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b210 : char C1, char C2, char C3, char C4 ) { 3000b210: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); 3000b214: e20118ff and r1, r1, #16711680 ; 0xff0000 <== NOT EXECUTED char C1, char C2, char C3, char C4 ) { 3000b218: e1a02402 lsl r2, r2, #8 <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); 3000b21c: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED 3000b220: e2022cff and r2, r2, #65280 ; 0xff00 <== NOT EXECUTED char C1, char C2, char C3, char C4 ) { 3000b224: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); 3000b228: e1800002 orr r0, r0, r2 <== NOT EXECUTED } 3000b22c: e1800003 orr r0, r0, r3 <== NOT EXECUTED 3000b230: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000a28c : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 3000a28c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 3000a290: e1a04002 mov r4, r2 <== NOT EXECUTED 3000a294: 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 ); 3000a298: eb000124 bl 3000a730 <_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 ) { 3000a29c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a2a0: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED sc = rtems_event_send( task, events ); 3000a2a4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a2a8: e1a01005 mov r1, r5 <== NOT EXECUTED } return sc; } 3000a2ac: 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 ); 3000a2b0: eafffda5 b 3000994c <== NOT EXECUTED =============================================================================== 3000a2b4 : rtems_chain_control *chain, rtems_id task, rtems_event_set events, rtems_chain_node **node ) { 3000a2b4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 3000a2b8: 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 ); 3000a2bc: e1a01003 mov r1, r3 <== NOT EXECUTED 3000a2c0: e1a05002 mov r5, r2 <== NOT EXECUTED 3000a2c4: eb00013d bl 3000a7c0 <_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 ) { 3000a2c8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a2cc: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED sc = rtems_event_send( task, events ); 3000a2d0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a2d4: e1a01005 mov r1, r5 <== NOT EXECUTED } return sc; } 3000a2d8: 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 ); 3000a2dc: eafffd9a b 3000994c <== NOT EXECUTED =============================================================================== 3000a2e0 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 3000a2e0: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED 3000a2e4: e1a07000 mov r7, r0 <== NOT EXECUTED 3000a2e8: e1a06001 mov r6, r1 <== NOT EXECUTED 3000a2ec: e1a05002 mov r5, r2 <== NOT EXECUTED 3000a2f0: e1a0a003 mov sl, r3 <== NOT EXECUTED while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL ) { rtems_event_set out; sc = rtems_event_receive( 3000a2f4: e1a0800d mov r8, sp <== NOT EXECUTED 3000a2f8: ea000006 b 3000a318 <== NOT EXECUTED 3000a2fc: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a300: e1a01004 mov r1, r4 <== NOT EXECUTED 3000a304: e1a02005 mov r2, r5 <== NOT EXECUTED 3000a308: e1a0300d mov r3, sp <== NOT EXECUTED 3000a30c: ebfffd32 bl 300097dc <== NOT EXECUTED ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 3000a310: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a314: 1a000004 bne 3000a32c <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 3000a318: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a31c: eb00013b bl 3000a810 <_Chain_Get> <== NOT EXECUTED sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 3000a320: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000a324: 0afffff4 beq 3000a2fc <== NOT EXECUTED 3000a328: e3a00000 mov r0, #0 <== NOT EXECUTED timeout, &out ); } *node_ptr = node; 3000a32c: e58a4000 str r4, [sl] <== NOT EXECUTED return sc; } 3000a330: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED =============================================================================== 3000a334 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 3000a334: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 3000a338: e1a04002 mov r4, r2 <== NOT EXECUTED 3000a33c: 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 ); 3000a340: eb000149 bl 3000a86c <_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) { 3000a344: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a348: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED sc = rtems_event_send( task, events ); 3000a34c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a350: e1a01005 mov r1, r5 <== NOT EXECUTED } return sc; } 3000a354: 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 ); 3000a358: eafffd7b b 3000994c <== NOT EXECUTED =============================================================================== 300153cc : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 300153cc: e92d4010 push {r4, lr} <== NOT EXECUTED if ( !time_buffer ) 300153d0: e2514000 subs r4, r1, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 300153d4: 03a00009 moveq r0, #9 <== NOT EXECUTED rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { if ( !time_buffer ) 300153d8: 08bd8010 popeq {r4, pc} <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( option == RTEMS_CLOCK_GET_TOD ) 300153dc: e3500000 cmp r0, #0 <== NOT EXECUTED 300153e0: 1a000002 bne 300153f0 <== NOT EXECUTED return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 300153e4: 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; } 300153e8: 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 ); 300153ec: ea00002f b 300154b0 <== NOT EXECUTED if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH ) 300153f0: e3500001 cmp r0, #1 <== NOT EXECUTED 300153f4: 1a000002 bne 30015404 <== NOT EXECUTED return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 300153f8: 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; } 300153fc: 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); 30015400: ea000010 b 30015448 <== NOT EXECUTED if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) { 30015404: e3500002 cmp r0, #2 <== NOT EXECUTED 30015408: 1a000001 bne 30015414 <== NOT EXECUTED rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_since_boot(); 3001540c: eb000023 bl 300154a0 <== NOT EXECUTED 30015410: ea000002 b 30015420 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) { 30015414: e3500003 cmp r0, #3 <== NOT EXECUTED 30015418: 1a000003 bne 3001542c <== NOT EXECUTED rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_per_second(); 3001541c: eb000017 bl 30015480 <== NOT EXECUTED 30015420: e5840000 str r0, [r4] <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30015424: e3a00000 mov r0, #0 <== NOT EXECUTED 30015428: e8bd8010 pop {r4, pc} <== NOT EXECUTED } if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) 3001542c: e3500004 cmp r0, #4 <== NOT EXECUTED 30015430: 1a000002 bne 30015440 <== NOT EXECUTED return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 30015434: e1a00004 mov r0, r4 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; } 30015438: 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 ); 3001543c: ea00004d b 30015578 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 30015440: e3a0000a mov r0, #10 <== NOT EXECUTED } 30015444: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000a220 : rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { if ( !the_interval ) 3000a220: e3500000 cmp r0, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 3000a224: 03a00009 moveq r0, #9 <== NOT EXECUTED rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { if ( !the_interval ) 3000a228: 012fff1e bxeq lr <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 3000a22c: e59f301c ldr r3, [pc, #28] ; 3000a250 <== NOT EXECUTED 3000a230: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 3000a234: e3530000 cmp r3, #0 <== NOT EXECUTED return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch(); 3000a238: 159f3014 ldrne r3, [pc, #20] ; 3000a254 <== NOT EXECUTED { if ( !the_interval ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 3000a23c: 03a0000b moveq r0, #11 <== NOT EXECUTED *the_interval = _TOD_Seconds_since_epoch(); 3000a240: 15933000 ldrne r3, [r3] <== NOT EXECUTED 3000a244: 15803000 strne r3, [r0] <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000a248: 13a00000 movne r0, #0 <== NOT EXECUTED } 3000a24c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 30008e54 : #include #include rtems_interval rtems_clock_get_ticks_per_second(void) { return TOD_MICROSECONDS_PER_SECOND / 30008e54: e59f3010 ldr r3, [pc, #16] ; 30008e6c <== NOT EXECUTED #include #include #include rtems_interval rtems_clock_get_ticks_per_second(void) { 30008e58: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED return TOD_MICROSECONDS_PER_SECOND / 30008e5c: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 30008e60: e59f0008 ldr r0, [pc, #8] ; 30008e70 <== NOT EXECUTED 30008e64: eb002ab7 bl 30013948 <__aeabi_uidiv> <== NOT EXECUTED rtems_configuration_get_microseconds_per_tick(); } 30008e68: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 30008e74 : #include #include rtems_interval rtems_clock_get_ticks_since_boot(void) { return _Watchdog_Ticks_since_boot; 30008e74: e59f3004 ldr r3, [pc, #4] ; 30008e80 <== NOT EXECUTED 30008e78: e5930000 ldr r0, [r3] <== NOT EXECUTED } 30008e7c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 30015578 : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 30015578: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED if ( !time ) 3001557c: e2504000 subs r4, r0, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 30015580: 03a00009 moveq r0, #9 <== NOT EXECUTED rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { if ( !time ) 30015584: 0a000011 beq 300155d0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 30015588: e59f3044 ldr r3, [pc, #68] ; 300155d4 <== NOT EXECUTED 3001558c: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 30015590: e3530000 cmp r3, #0 <== NOT EXECUTED return RTEMS_NOT_DEFINED; 30015594: 03a0000b moveq r0, #11 <== NOT EXECUTED ) { if ( !time ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 30015598: 0a00000c beq 300155d0 <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3001559c: e10f5000 mrs r5, CPSR <== NOT EXECUTED 300155a0: e3853080 orr r3, r5, #128 ; 0x80 <== NOT EXECUTED 300155a4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED ISR_Level level; struct timespec now; suseconds_t useconds; _ISR_Disable(level); _TOD_Get( &now ); 300155a8: e1a0000d mov r0, sp <== NOT EXECUTED 300155ac: eb0010c4 bl 300198c4 <_TOD_Get> <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 300155b0: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED _ISR_Enable(level); useconds = (suseconds_t)now.tv_nsec; useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; time->tv_sec = now.tv_sec; 300155b4: e59d3000 ldr r3, [sp] <== NOT EXECUTED _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); useconds = (suseconds_t)now.tv_nsec; useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; 300155b8: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED time->tv_sec = now.tv_sec; 300155bc: e5843000 str r3, [r4] <== NOT EXECUTED _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); useconds = (suseconds_t)now.tv_nsec; useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; 300155c0: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 300155c4: eb006113 bl 3002da18 <__aeabi_idiv> <== NOT EXECUTED time->tv_sec = now.tv_sec; time->tv_usec = useconds; 300155c8: e5840004 str r0, [r4, #4] <== NOT EXECUTED return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; 300155cc: e3a00000 mov r0, #0 <== NOT EXECUTED } 300155d0: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 300090b8 : */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime ) 300090b8: e3500000 cmp r0, #0 <== NOT EXECUTED * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 300090bc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED if ( !uptime ) 300090c0: 0a000002 beq 300090d0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime_as_timespec( uptime ); 300090c4: eb00053e bl 3000a5c4 <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 300090c8: e3a00000 mov r0, #0 <== NOT EXECUTED 300090cc: 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; 300090d0: e3a00009 mov r0, #9 <== NOT EXECUTED _TOD_Get_uptime_as_timespec( uptime ); return RTEMS_SUCCESSFUL; } 300090d4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 30008ea0 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 30008ea0: e52de004 push {lr} ; (str lr, [sp, #-4]!) _TOD_Tickle_ticks(); 30008ea4: eb0004e7 bl 3000a248 <_TOD_Tickle_ticks> */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 30008ea8: e59f002c ldr r0, [pc, #44] ; 30008edc 30008eac: eb000e19 bl 3000c718 <_Watchdog_Tickle> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 30008eb0: eb000caf bl 3000c174 <_Thread_Tickle_timeslice> * otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void ) { return ( _Thread_Dispatch_necessary ); 30008eb4: e59f3024 ldr r3, [pc, #36] ; 30008ee0 30008eb8: e5d33010 ldrb r3, [r3, #16] if ( _Thread_Is_context_switch_necessary() && 30008ebc: e3530000 cmp r3, #0 30008ec0: 0a000003 beq 30008ed4 * otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 30008ec4: e59f3018 ldr r3, [pc, #24] ; 30008ee4 <== NOT EXECUTED 30008ec8: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008ecc: e3530000 cmp r3, #0 <== NOT EXECUTED _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 30008ed0: 0b0009fb bleq 3000b6c4 <_Thread_Dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 30008ed4: e3a00000 mov r0, #0 30008ed8: e49df004 pop {pc} ; (ldr pc, [sp], #4) =============================================================================== 30008ee8 : rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 30008ee8: e92d4070 push {r4, r5, r6, lr} RTEMS_API_Control *api; if ( !event_out ) 30008eec: e2535000 subs r5, r3, #0 30008ef0: 0a000010 beq 30008f38 return RTEMS_INVALID_ADDRESS; api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 30008ef4: e59f4044 ldr r4, [pc, #68] ; 30008f40 if ( _Event_sets_Is_empty( event_in ) ) { 30008ef8: e3500000 cmp r0, #0 RTEMS_API_Control *api; if ( !event_out ) return RTEMS_INVALID_ADDRESS; api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 30008efc: e5946004 ldr r6, [r4, #4] if ( _Event_sets_Is_empty( event_in ) ) { *event_out = api->pending_events; return RTEMS_SUCCESSFUL; 30008f00: 01a00000 moveq r0, r0 RTEMS_API_Control *api; if ( !event_out ) return RTEMS_INVALID_ADDRESS; api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 30008f04: e59660f4 ldr r6, [r6, #244] ; 0xf4 if ( _Event_sets_Is_empty( event_in ) ) { *event_out = api->pending_events; 30008f08: 05963000 ldreq r3, [r6] 30008f0c: 05853000 streq r3, [r5] if ( !event_out ) return RTEMS_INVALID_ADDRESS; api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; if ( _Event_sets_Is_empty( event_in ) ) { 30008f10: 08bd8070 popeq {r4, r5, r6, pc} rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 30008f14: e59fc028 ldr ip, [pc, #40] ; 30008f44 30008f18: e59ce000 ldr lr, [ip] 30008f1c: e28ee001 add lr, lr, #1 30008f20: e58ce000 str lr, [ip] *event_out = api->pending_events; return RTEMS_SUCCESSFUL; } _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); 30008f24: eb000007 bl 30008f48 <_Event_Seize> _Thread_Enable_dispatch(); 30008f28: eb000a29 bl 3000b7d4 <_Thread_Enable_dispatch> return( _Thread_Executing->Wait.return_code ); 30008f2c: e5943004 ldr r3, [r4, #4] 30008f30: e5930034 ldr r0, [r3, #52] ; 0x34 30008f34: e8bd8070 pop {r4, r5, r6, pc} ) { RTEMS_API_Control *api; if ( !event_out ) return RTEMS_INVALID_ADDRESS; 30008f38: e3a00009 mov r0, #9 <== NOT EXECUTED _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); _Thread_Enable_dispatch(); return( _Thread_Executing->Wait.return_code ); } 30008f3c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 3000b330 : rtems_status_code rtems_extension_create( rtems_name name, const rtems_extensions_table *extension_table, rtems_id *id ) { 3000b330: e92d41f0 push {r4, r5, r6, r7, r8, lr} Extension_Control *the_extension; if ( !id ) 3000b334: e2527000 subs r7, r2, #0 rtems_status_code rtems_extension_create( rtems_name name, const rtems_extensions_table *extension_table, rtems_id *id ) { 3000b338: e1a05000 mov r5, r0 3000b33c: e1a08001 mov r8, r1 Extension_Control *the_extension; if ( !id ) return RTEMS_INVALID_ADDRESS; 3000b340: 03a00009 moveq r0, #9 rtems_id *id ) { Extension_Control *the_extension; if ( !id ) 3000b344: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 3000b348: e3550000 cmp r5, #0 3000b34c: 0a00001c beq 3000b3c4 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 3000b350: e59f3074 ldr r3, [pc, #116] ; 3000b3cc 3000b354: e5932000 ldr r2, [r3] 3000b358: e2822001 add r2, r2, #1 3000b35c: 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 ); 3000b360: e59f6068 ldr r6, [pc, #104] ; 3000b3d0 3000b364: e1a00006 mov r0, r6 3000b368: eb000376 bl 3000c148 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 3000b36c: e2504000 subs r4, r0, #0 3000b370: 1a000002 bne 3000b380 _Thread_Enable_dispatch(); 3000b374: eb0007bf bl 3000d278 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 3000b378: e3a00005 mov r0, #5 <== NOT EXECUTED 3000b37c: 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; 3000b380: e284c024 add ip, r4, #36 ; 0x24 3000b384: e1a0e008 mov lr, r8 3000b388: e8be000f ldm lr!, {r0, r1, r2, r3} 3000b38c: e8ac000f stmia ip!, {r0, r1, r2, r3} 3000b390: e89e000f ldm lr, {r0, r1, r2, r3} 3000b394: e88c000f stm ip, {r0, r1, r2, r3} _User_extensions_Add_set( extension ); 3000b398: e2840010 add r0, r4, #16 3000b39c: eb000aa7 bl 3000de40 <_User_extensions_Add_set> #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000b3a0: e596201c ldr r2, [r6, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 3000b3a4: e5943008 ldr r3, [r4, #8] 3000b3a8: e1d410b8 ldrh r1, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000b3ac: e7824101 str r4, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 3000b3b0: e584500c str r5, [r4, #12] &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 3000b3b4: e5873000 str r3, [r7] _Thread_Enable_dispatch(); 3000b3b8: eb0007ae bl 3000d278 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000b3bc: e3a00000 mov r0, #0 3000b3c0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 3000b3c4: e3a00003 mov r0, #3 <== NOT EXECUTED ); *id = the_extension->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 3000b3c8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 3000bd98 : rtems_status_code rtems_extension_ident( rtems_name name, rtems_id *id ) { 3000bd98: e1a02000 mov r2, r0 <== NOT EXECUTED 3000bd9c: e1a03001 mov r3, r1 <== NOT EXECUTED 3000bda0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 3000bda4: e1a01002 mov r1, r2 <== NOT EXECUTED 3000bda8: e59f0010 ldr r0, [pc, #16] ; 3000bdc0 <== NOT EXECUTED 3000bdac: e3e02102 mvn r2, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000bdb0: eb00047a bl 3000cfa0 <_Objects_Name_to_id_u32> <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 3000bdb4: e59f3008 ldr r3, [pc, #8] ; 3000bdc4 <== NOT EXECUTED 3000bdb8: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 3000bdbc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 3000bd6c : #include const char *rtems_get_version_string(void) { return _RTEMS_version; } 3000bd6c: e59f0000 ldr r0, [pc, #0] ; 3000bd74 <== NOT EXECUTED 3000bd70: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000a2f0 : static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000a2f0: e10f0000 mrs r0, CPSR <== NOT EXECUTED 3000a2f4: e3803080 orr r3, r0, #128 ; 0x80 <== NOT EXECUTED 3000a2f8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED rtems_interrupt_level previous_level; _ISR_Disable( previous_level ); return previous_level; } 3000a2fc: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000a300 : static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000a300: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED void rtems_interrupt_enable( rtems_interrupt_level previous_level ) { _ISR_Enable( previous_level ); } 3000a304: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000a308 : static inline void arm_interrupt_flash( uint32_t level ) { uint32_t arm_switch_reg; __asm__ volatile ( 3000a308: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000a30c: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 3000a310: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED void rtems_interrupt_flash( rtems_interrupt_level previous_level ) { _ISR_Flash( previous_level ); } 3000a314: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000a318 : #undef rtems_interrupt_is_in_progress bool rtems_interrupt_is_in_progress( void ) { return _ISR_Is_in_progress(); 3000a318: e59f300c ldr r3, [pc, #12] ; 3000a32c <== NOT EXECUTED 3000a31c: e5930000 ldr r0, [r3] <== NOT EXECUTED } 3000a320: e2500000 subs r0, r0, #0 <== NOT EXECUTED 3000a324: 13a00001 movne r0, #1 <== NOT EXECUTED 3000a328: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 30009d20 : rtems_attribute rtems_interrupt_level_attribute( uint32_t level ) { return RTEMS_INTERRUPT_LEVEL(level); } 30009d20: e2000080 and r0, r0, #128 ; 0x80 <== NOT EXECUTED 30009d24: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000ff5c : void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3000ff5c: e59fc044 ldr ip, [pc, #68] ; 3000ffa8 rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 3000ff60: e1a03000 mov r3, r0 rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3000ff64: e59cc000 ldr ip, [ip] rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 3000ff68: e92d4010 push {r4, lr} rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3000ff6c: e150000c cmp r0, ip return RTEMS_INVALID_NUMBER; 3000ff70: 23a0000a movcs r0, #10 void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3000ff74: 28bd8010 popcs {r4, pc} return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 3000ff78: e59fc02c ldr ip, [pc, #44] ; 3000ffac 3000ff7c: e3a04018 mov r4, #24 3000ff80: e59cc000 ldr ip, [ip] 3000ff84: e023c394 mla r3, r4, r3, ip 3000ff88: e5933008 ldr r3, [r3, #8] return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 3000ff8c: e3530000 cmp r3, #0 3000ff90: 0a000002 beq 3000ffa0 3000ff94: e1a0e00f mov lr, pc 3000ff98: e12fff13 bx r3 3000ff9c: e8bd8010 pop {r4, pc} 3000ffa0: e1a00003 mov r0, r3 <== NOT EXECUTED } 3000ffa4: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000ffb0 : void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3000ffb0: e59fc044 ldr ip, [pc, #68] ; 3000fffc rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 3000ffb4: e1a03000 mov r3, r0 rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3000ffb8: e59cc000 ldr ip, [ip] rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 3000ffbc: e92d4010 push {r4, lr} rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3000ffc0: e150000c cmp r0, ip return RTEMS_INVALID_NUMBER; 3000ffc4: 23a0000a movcs r0, #10 void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3000ffc8: 28bd8010 popcs {r4, pc} return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 3000ffcc: e59fc02c ldr ip, [pc, #44] ; 30010000 3000ffd0: e3a04018 mov r4, #24 3000ffd4: e59cc000 ldr ip, [ip] 3000ffd8: e023c394 mla r3, r4, r3, ip 3000ffdc: e5933014 ldr r3, [r3, #20] return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 3000ffe0: e3530000 cmp r3, #0 3000ffe4: 0a000002 beq 3000fff4 3000ffe8: e1a0e00f mov lr, pc 3000ffec: e12fff13 bx r3 3000fff0: e8bd8010 pop {r4, pc} 3000fff4: e1a00003 mov r0, r3 <== NOT EXECUTED } 3000fff8: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 30010004 : void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010004: e59fc044 ldr ip, [pc, #68] ; 30010050 rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 30010008: e1a03000 mov r3, r0 rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3001000c: e59cc000 ldr ip, [ip] rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 30010010: e92d4010 push {r4, lr} rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010014: e150000c cmp r0, ip return RTEMS_INVALID_NUMBER; 30010018: 23a0000a movcs r0, #10 void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 3001001c: 28bd8010 popcs {r4, pc} return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 30010020: e59fc02c ldr ip, [pc, #44] ; 30010054 30010024: e3a04018 mov r4, #24 30010028: e59cc000 ldr ip, [ip] 3001002c: e023c394 mla r3, r4, r3, ip 30010030: e5933004 ldr r3, [r3, #4] return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 30010034: e3530000 cmp r3, #0 30010038: 0a000002 beq 30010048 3001003c: e1a0e00f mov lr, pc 30010040: e12fff13 bx r3 30010044: e8bd8010 pop {r4, pc} 30010048: e1a00003 mov r0, r3 <== NOT EXECUTED } 3001004c: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 30010058 : void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010058: e59fc044 ldr ip, [pc, #68] ; 300100a4 rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 3001005c: e1a03000 mov r3, r0 rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010060: e59cc000 ldr ip, [ip] rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 30010064: e92d4010 push {r4, lr} rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010068: e150000c cmp r0, ip return RTEMS_INVALID_NUMBER; 3001006c: 23a0000a movcs r0, #10 void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 30010070: 28bd8010 popcs {r4, pc} return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 30010074: e59fc02c ldr ip, [pc, #44] ; 300100a8 30010078: e3a04018 mov r4, #24 3001007c: e59cc000 ldr ip, [ip] 30010080: e023c394 mla r3, r4, r3, ip 30010084: e593300c ldr r3, [r3, #12] return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 30010088: e3530000 cmp r3, #0 3001008c: 0a000002 beq 3001009c 30010090: e1a0e00f mov lr, pc 30010094: e12fff13 bx r3 30010098: e8bd8010 pop {r4, pc} 3001009c: e1a00003 mov r0, r3 <== NOT EXECUTED } 300100a0: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000af08 : 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 ) { 3000af08: e92d4010 push {r4, lr} 3000af0c: e1a04000 mov r4, r0 rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) 3000af10: e59f0158 ldr r0, [pc, #344] ; 3000b070 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; 3000af14: e59f3158 ldr r3, [pc, #344] ; 3000b074 if ( rtems_interrupt_is_in_progress() ) 3000af18: 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; 3000af1c: e5933000 ldr r3, [r3] if ( rtems_interrupt_is_in_progress() ) 3000af20: e3500000 cmp r0, #0 return RTEMS_CALLED_FROM_ISR; 3000af24: 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() ) 3000af28: 18bd8010 popne {r4, pc} return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 3000af2c: e3520000 cmp r2, #0 3000af30: 0a000041 beq 3000b03c return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; if ( driver_table == NULL ) 3000af34: e3510000 cmp r1, #0 if ( registered_major == NULL ) return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 3000af38: e5823000 str r3, [r2] if ( driver_table == NULL ) 3000af3c: 0a00003e beq 3000b03c static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 3000af40: e5910000 ldr r0, [r1] 3000af44: e3500000 cmp r0, #0 3000af48: 1a00003f bne 3000b04c 3000af4c: e5910004 ldr r0, [r1, #4] 3000af50: e3500000 cmp r0, #0 3000af54: 1a00003c bne 3000b04c 3000af58: ea000037 b 3000b03c <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 3000af5c: e59f3114 ldr r3, [pc, #276] ; 3000b078 3000af60: e5930000 ldr r0, [r3] 3000af64: e2800001 add r0, r0, #1 3000af68: e5830000 str r0, [r3] if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 3000af6c: e3540000 cmp r4, #0 3000af70: e59f0104 ldr r0, [pc, #260] ; 3000b07c 3000af74: 1a000010 bne 3000afbc static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 3000af78: e59f30f4 ldr r3, [pc, #244] ; 3000b074 3000af7c: e593c000 ldr ip, [r3] 3000af80: e5903000 ldr r3, [r0] 3000af84: ea000006 b 3000afa4 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 3000af88: e5930000 ldr r0, [r3] 3000af8c: e3500000 cmp r0, #0 3000af90: 1a000030 bne 3000b058 3000af94: e5930004 ldr r0, [r3, #4] 3000af98: e3500000 cmp r0, #0 3000af9c: 1a00002d bne 3000b058 3000afa0: ea000001 b 3000afac 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 ) { 3000afa4: e154000c cmp r4, ip 3000afa8: 3afffff6 bcc 3000af88 } /* Assigns invalid value in case of failure */ *major = m; if ( m != n ) 3000afac: e154000c cmp r4, ip if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 3000afb0: e5824000 str r4, [r2] if ( m != n ) 3000afb4: 1a000011 bne 3000b000 3000afb8: ea000029 b 3000b064 <== NOT EXECUTED _Thread_Enable_dispatch(); return sc; } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; 3000afbc: e3a03018 mov r3, #24 <== NOT EXECUTED 3000afc0: e0030394 mul r3, r4, r3 <== NOT EXECUTED 3000afc4: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000afc8: 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; 3000afcc: e7903003 ldr r3, [r0, r3] <== NOT EXECUTED 3000afd0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000afd4: 13a03000 movne r3, #0 <== NOT EXECUTED 3000afd8: 1a000002 bne 3000afe8 <== NOT EXECUTED return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; } rtems_status_code rtems_io_register_driver( 3000afdc: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 3000afe0: e2733001 rsbs r3, r3, #1 <== NOT EXECUTED 3000afe4: 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 ) ) { 3000afe8: e3530000 cmp r3, #0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } *registered_major = major; 3000afec: 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 ) ) { 3000aff0: 1a000002 bne 3000b000 <== NOT EXECUTED _Thread_Enable_dispatch(); 3000aff4: eb00073d bl 3000ccf0 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_RESOURCE_IN_USE; 3000aff8: e3a0000c mov r0, #12 <== NOT EXECUTED 3000affc: e8bd8010 pop {r4, pc} <== NOT EXECUTED } *registered_major = major; } _IO_Driver_address_table [major] = *driver_table; 3000b000: e59f3074 ldr r3, [pc, #116] ; 3000b07c 3000b004: e3a0c018 mov ip, #24 3000b008: e5933000 ldr r3, [r3] 3000b00c: e1a0e001 mov lr, r1 3000b010: e02c3c94 mla ip, r4, ip, r3 3000b014: e8be000f ldm lr!, {r0, r1, r2, r3} 3000b018: e8ac000f stmia ip!, {r0, r1, r2, r3} 3000b01c: e89e0003 ldm lr, {r0, r1} 3000b020: e88c0003 stm ip, {r0, r1} _Thread_Enable_dispatch(); 3000b024: eb000731 bl 3000ccf0 <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 3000b028: e3a01000 mov r1, #0 3000b02c: e1a00004 mov r0, r4 3000b030: e1a02001 mov r2, r1 } 3000b034: e8bd4010 pop {r4, lr} _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 3000b038: ea001d12 b 30012488 if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 3000b03c: e3a00009 mov r0, #9 <== NOT EXECUTED 3000b040: e8bd8010 pop {r4, pc} <== NOT EXECUTED if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; 3000b044: e3a0000a mov r0, #10 <== NOT EXECUTED _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 3000b048: 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 ) 3000b04c: e1540003 cmp r4, r3 3000b050: 3affffc1 bcc 3000af5c 3000b054: eafffffa b 3000b044 <== NOT EXECUTED 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 ) { 3000b058: e2844001 add r4, r4, #1 3000b05c: e2833018 add r3, r3, #24 3000b060: eaffffcf b 3000afa4 if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 3000b064: eb000721 bl 3000ccf0 <_Thread_Enable_dispatch> <== NOT EXECUTED *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 3000b068: 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; 3000b06c: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000b080 : rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( rtems_interrupt_is_in_progress() ) 3000b080: e59f305c ldr r3, [pc, #92] ; 3000b0e4 */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 3000b084: e92d4010 push {r4, lr} if ( rtems_interrupt_is_in_progress() ) 3000b088: e5934000 ldr r4, [r3] 3000b08c: e3540000 cmp r4, #0 return RTEMS_CALLED_FROM_ISR; 3000b090: 13a00012 movne r0, #18 rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( rtems_interrupt_is_in_progress() ) 3000b094: 18bd8010 popne {r4, pc} return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { 3000b098: e59f3048 ldr r3, [pc, #72] ; 3000b0e8 3000b09c: e5933000 ldr r3, [r3] 3000b0a0: e1500003 cmp r0, r3 3000b0a4: 2a00000c bcs 3000b0dc 3000b0a8: e59f303c ldr r3, [pc, #60] ; 3000b0ec 3000b0ac: e5932000 ldr r2, [r3] 3000b0b0: e2822001 add r2, r2, #1 3000b0b4: e5832000 str r2, [r3] _Thread_Disable_dispatch(); memset( 3000b0b8: e59f3030 ldr r3, [pc, #48] ; 3000b0f0 &_IO_Driver_address_table[major], 3000b0bc: 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( 3000b0c0: e5933000 ldr r3, [r3] 3000b0c4: e1a01004 mov r1, r4 3000b0c8: e0203092 mla r0, r2, r0, r3 3000b0cc: eb0026d9 bl 30014c38 &_IO_Driver_address_table[major], 0, sizeof( rtems_driver_address_table ) ); _Thread_Enable_dispatch(); 3000b0d0: eb000706 bl 3000ccf0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000b0d4: e1a00004 mov r0, r4 3000b0d8: e8bd8010 pop {r4, pc} } return RTEMS_UNSATISFIED; 3000b0dc: e3a0000d mov r0, #13 <== NOT EXECUTED } 3000b0e0: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 300100ac : void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 300100ac: e59fc044 ldr ip, [pc, #68] ; 300100f8 rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 300100b0: e1a03000 mov r3, r0 rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 300100b4: e59cc000 ldr ip, [ip] rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 300100b8: e92d4010 push {r4, lr} rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 300100bc: e150000c cmp r0, ip return RTEMS_INVALID_NUMBER; 300100c0: 23a0000a movcs r0, #10 void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 300100c4: 28bd8010 popcs {r4, pc} return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 300100c8: e59fc02c ldr ip, [pc, #44] ; 300100fc 300100cc: e3a04018 mov r4, #24 300100d0: e59cc000 ldr ip, [ip] 300100d4: e023c394 mla r3, r4, r3, ip 300100d8: e5933010 ldr r3, [r3, #16] return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 300100dc: e3530000 cmp r3, #0 300100e0: 0a000002 beq 300100f0 300100e4: e1a0e00f mov lr, pc 300100e8: e12fff13 bx r3 300100ec: e8bd8010 pop {r4, pc} 300100f0: e1a00003 mov r0, r3 <== NOT EXECUTED } 300100f4: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000c0e0 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 3000c0e0: 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 ) 3000c0e4: e2508000 subs r8, r0, #0 <== NOT EXECUTED 3000c0e8: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED 3000c0ec: e59f4050 ldr r4, [pc, #80] ; 3000c144 <== NOT EXECUTED #endif #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) 3000c0f0: 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 ] ) 3000c0f4: e5b43004 ldr r3, [r4, #4]! <== NOT EXECUTED 3000c0f8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c0fc: 0a00000d beq 3000c138 <== NOT EXECUTED continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 3000c100: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED if ( !information ) 3000c104: e3560000 cmp r6, #0 <== NOT EXECUTED 3000c108: 13a05001 movne r5, #1 <== NOT EXECUTED 3000c10c: 1a000006 bne 3000c12c <== NOT EXECUTED 3000c110: ea000008 b 3000c138 <== NOT EXECUTED continue; for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 3000c114: e596301c ldr r3, [r6, #28] <== NOT EXECUTED 3000c118: e7930105 ldr r0, [r3, r5, lsl #2] <== NOT EXECUTED if ( !the_thread ) 3000c11c: e3500000 cmp r0, #0 <== NOT EXECUTED continue; (*routine)(the_thread); 3000c120: 11a0e00f movne lr, pc <== NOT EXECUTED 3000c124: 112fff18 bxne r8 <== NOT EXECUTED information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 3000c128: e2855001 add r5, r5, #1 <== NOT EXECUTED 3000c12c: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED 3000c130: e1550003 cmp r5, r3 <== NOT EXECUTED 3000c134: 9afffff6 bls 3000c114 <== NOT EXECUTED Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 3000c138: e1540007 cmp r4, r7 <== NOT EXECUTED 3000c13c: 1affffec bne 3000c0f4 <== NOT EXECUTED 3000c140: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 30015d8c : rtems_id id, const void *buffer, size_t size, uint32_t *count ) { 30015d8c: 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 ) 30015d90: e2517000 subs r7, r1, #0 rtems_id id, const void *buffer, size_t size, uint32_t *count ) { 30015d94: e1a04000 mov r4, r0 30015d98: e1a05002 mov r5, r2 30015d9c: e1a06003 mov r6, r3 register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status core_status; if ( !buffer ) 30015da0: 0a000015 beq 30015dfc return RTEMS_INVALID_ADDRESS; if ( !count ) 30015da4: e3530000 cmp r3, #0 30015da8: 0a000013 beq 30015dfc Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 30015dac: e59f0050 ldr r0, [pc, #80] ; 30015e04 30015db0: e1a01004 mov r1, r4 30015db4: e28d2008 add r2, sp, #8 30015db8: eb0013d0 bl 3001ad00 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 30015dbc: e59d3008 ldr r3, [sp, #8] 30015dc0: e3530000 cmp r3, #0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30015dc4: 13a00004 movne r0, #4 if ( !count ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 30015dc8: 1a00000c bne 30015e00 case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 30015dcc: e58d3000 str r3, [sp] 30015dd0: e1a01007 mov r1, r7 30015dd4: e1a03004 mov r3, r4 30015dd8: e1a02005 mov r2, r5 30015ddc: e2800014 add r0, r0, #20 30015de0: e58d6004 str r6, [sp, #4] 30015de4: eb000cfe bl 300191e4 <_CORE_message_queue_Broadcast> 30015de8: e1a04000 mov r4, r0 NULL, #endif count ); _Thread_Enable_dispatch(); 30015dec: eb0016dd bl 3001b968 <_Thread_Enable_dispatch> return 30015df0: e1a00004 mov r0, r4 30015df4: eb0000cc bl 3001612c <_Message_queue_Translate_core_message_queue_return_code> 30015df8: ea000000 b 30015e00 if ( !buffer ) return RTEMS_INVALID_ADDRESS; if ( !count ) return RTEMS_INVALID_ADDRESS; 30015dfc: e3a00009 mov r0, #9 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30015e00: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc} =============================================================================== 30011028 : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, rtems_id *id ) { 30011028: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 3001102c: e2507000 subs r7, r0, #0 uint32_t count, size_t max_message_size, rtems_attribute attribute_set, rtems_id *id ) { 30011030: e1a06001 mov r6, r1 30011034: e1a05002 mov r5, r2 30011038: e1a0a003 mov sl, r3 3001103c: e59d8020 ldr r8, [sp, #32] #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 30011040: 03a00003 moveq r0, #3 CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 30011044: 0a00002d beq 30011100 return RTEMS_INVALID_NAME; if ( !id ) 30011048: e3580000 cmp r8, #0 return RTEMS_INVALID_ADDRESS; 3001104c: 03a00009 moveq r0, #9 #endif if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 30011050: 0a00002a beq 30011100 if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 30011054: e3510000 cmp r1, #0 return RTEMS_INVALID_NUMBER; 30011058: 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 ) 3001105c: 0a000027 beq 30011100 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 30011060: e3520000 cmp r2, #0 return RTEMS_INVALID_SIZE; 30011064: 03a00008 moveq r0, #8 #endif if ( count == 0 ) return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 30011068: 0a000024 beq 30011100 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 3001106c: e59f3090 ldr r3, [pc, #144] ; 30011104 30011070: e5932000 ldr r2, [r3] 30011074: e2822001 add r2, r2, #1 30011078: e5832000 str r2, [r3] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 3001107c: eb0015a9 bl 30016728 <_Message_queue_Allocate> if ( !the_message_queue ) { 30011080: e2504000 subs r4, r0, #0 30011084: 1a000002 bne 30011094 _Thread_Enable_dispatch(); 30011088: eb000b78 bl 30013e70 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 3001108c: e3a00005 mov r0, #5 <== NOT EXECUTED 30011090: ea00001a b 30011100 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_message_queue->attribute_set = attribute_set; 30011094: e584a010 str sl, [r4, #16] if (_Attributes_Is_priority( attribute_set ) ) 30011098: e21aa004 ands sl, sl, #4 the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 3001109c: 13a03001 movne r3, #1 300110a0: 158d3000 strne r3, [sp] else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 300110a4: e2840014 add r0, r4, #20 300110a8: e1a0100d mov r1, sp 300110ac: e1a02006 mov r2, r6 300110b0: e1a03005 mov r3, r5 the_message_queue->attribute_set = attribute_set; 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; 300110b4: 058da000 streq sl, [sp] if ( ! _CORE_message_queue_Initialize( 300110b8: eb00044a bl 300121e8 <_CORE_message_queue_Initialize> 300110bc: e3500000 cmp r0, #0 300110c0: 1a000005 bne 300110dc */ RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 300110c4: e59f003c ldr r0, [pc, #60] ; 30011108 <== NOT EXECUTED 300110c8: e1a01004 mov r1, r4 <== NOT EXECUTED 300110cc: eb0007d2 bl 3001301c <_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(); 300110d0: eb000b66 bl 30013e70 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_UNSATISFIED; 300110d4: e3a0000d mov r0, #13 <== NOT EXECUTED 300110d8: ea000008 b 30011100 <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300110dc: e59f2024 ldr r2, [pc, #36] ; 30011108 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 300110e0: e5943008 ldr r3, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300110e4: e592201c ldr r2, [r2, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 300110e8: e1d410b8 ldrh r1, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300110ec: e7824101 str r4, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 300110f0: e584700c str r7, [r4, #12] &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 300110f4: e5883000 str r3, [r8] name, 0 ); #endif _Thread_Enable_dispatch(); 300110f8: eb000b5c bl 30013e70 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 300110fc: e3a00000 mov r0, #0 } 30011100: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} =============================================================================== 30015f9c : rtems_status_code rtems_message_queue_get_number_pending( rtems_id id, uint32_t *count ) { 30015f9c: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 30015fa0: e2514000 subs r4, r1, #0 <== NOT EXECUTED rtems_status_code rtems_message_queue_get_number_pending( rtems_id id, uint32_t *count ) { 30015fa4: e1a03000 mov r3, r0 <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) return RTEMS_INVALID_ADDRESS; 30015fa8: 03a00009 moveq r0, #9 <== NOT EXECUTED ) { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 30015fac: 0a00000b beq 30015fe0 <== NOT EXECUTED 30015fb0: e59f002c ldr r0, [pc, #44] ; 30015fe4 <== NOT EXECUTED 30015fb4: e1a01003 mov r1, r3 <== NOT EXECUTED 30015fb8: e1a0200d mov r2, sp <== NOT EXECUTED 30015fbc: eb00134f bl 3001ad00 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 30015fc0: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30015fc4: e3550000 cmp r5, #0 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30015fc8: 13a00004 movne r0, #4 <== NOT EXECUTED if ( !count ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 30015fcc: 1a000003 bne 30015fe0 <== NOT EXECUTED case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 30015fd0: e590305c ldr r3, [r0, #92] ; 0x5c <== NOT EXECUTED 30015fd4: e5843000 str r3, [r4] <== NOT EXECUTED _Thread_Enable_dispatch(); 30015fd8: eb001662 bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30015fdc: e1a00005 mov r0, r5 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30015fe0: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 30011140 : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 30011140: e92d4077 push {r0, r1, r2, r4, r5, r6, lr} register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 30011144: e2515000 subs r5, r1, #0 void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 30011148: e1a0c000 mov ip, r0 3001114c: e1a04002 mov r4, r2 30011150: e1a06003 mov r6, r3 register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 30011154: 0a00001a beq 300111c4 return RTEMS_INVALID_ADDRESS; if ( !size ) 30011158: e3520000 cmp r2, #0 3001115c: 0a000018 beq 300111c4 Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 30011160: e28d2008 add r2, sp, #8 30011164: e59f0060 ldr r0, [pc, #96] ; 300111cc 30011168: e1a0100c mov r1, ip 3001116c: eb0007ff bl 30013170 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 30011170: e59d2008 ldr r2, [sp, #8] 30011174: e1a03000 mov r3, r0 30011178: e3520000 cmp r2, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3001117c: 13a00004 movne r0, #4 if ( !size ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 30011180: 1a000010 bne 300111c8 if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 30011184: 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; 30011188: e2066001 and r6, r6, #1 3001118c: e2266001 eor r6, r6, #1 30011190: e58d2004 str r2, [sp, #4] 30011194: e58d6000 str r6, [sp] 30011198: e2830014 add r0, r3, #20 3001119c: e5931008 ldr r1, [r3, #8] 300111a0: e1a02005 mov r2, r5 300111a4: e1a03004 mov r3, r4 300111a8: eb00043c bl 300122a0 <_CORE_message_queue_Seize> buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 300111ac: eb000b2f bl 30013e70 <_Thread_Enable_dispatch> return _Message_queue_Translate_core_message_queue_return_code( _Thread_Executing->Wait.return_code 300111b0: e59f3018 ldr r3, [pc, #24] ; 300111d0 300111b4: e5933004 ldr r3, [r3, #4] size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 300111b8: e5930034 ldr r0, [r3, #52] ; 0x34 300111bc: eb000023 bl 30011250 <_Message_queue_Translate_core_message_queue_return_code> 300111c0: ea000000 b 300111c8 if ( !buffer ) return RTEMS_INVALID_ADDRESS; if ( !size ) return RTEMS_INVALID_ADDRESS; 300111c4: e3a00009 mov r0, #9 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 300111c8: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} =============================================================================== 3000b234 : int rtems_object_api_maximum_class( int api ) { return _Objects_API_maximum_class(api); 3000b234: ea0005e9 b 3000c9e0 <_Objects_API_maximum_class> <== NOT EXECUTED =============================================================================== 3000b238 : */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST ) 3000b238: e2400001 sub r0, r0, #1 <== NOT EXECUTED uint32_t api ) { if ( _Objects_Is_api_valid( api ) ) return 1; return -1; 3000b23c: e3500003 cmp r0, #3 <== NOT EXECUTED } 3000b240: 33a00001 movcc r0, #1 <== NOT EXECUTED 3000b244: 23e00000 mvncs r0, #0 <== NOT EXECUTED 3000b248: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b24c : ) { const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 3000b24c: e3500001 cmp r0, #1 <== NOT EXECUTED const char *rtems_object_get_api_class_name( int the_api, int the_class ) { 3000b250: 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 ) 3000b254: 0a000003 beq 3000b268 <== NOT EXECUTED api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 3000b258: e3500002 cmp r0, #2 <== NOT EXECUTED api_assoc = rtems_object_api_classic_assoc; 3000b25c: 059f002c ldreq r0, [pc, #44] ; 3000b290 <== 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 ) 3000b260: 1a000006 bne 3000b280 <== NOT EXECUTED 3000b264: ea000000 b 3000b26c <== 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; 3000b268: e59f0024 ldr r0, [pc, #36] ; 3000b294 <== 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 ); 3000b26c: eb0012bd bl 3000fd68 <== NOT EXECUTED if ( class_assoc ) 3000b270: e3500000 cmp r0, #0 <== NOT EXECUTED return class_assoc->name; 3000b274: 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 ) 3000b278: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED 3000b27c: ea000001 b 3000b288 <== 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"; 3000b280: e59f0010 ldr r0, [pc, #16] ; 3000b298 <== NOT EXECUTED 3000b284: 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"; 3000b288: e59f000c ldr r0, [pc, #12] ; 3000b29c <== NOT EXECUTED } 3000b28c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 3000b2a0 : }; const char *rtems_object_get_api_name( int api ) { 3000b2a0: e1a01000 mov r1, r0 <== NOT EXECUTED 3000b2a4: 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 ); 3000b2a8: e59f0010 ldr r0, [pc, #16] ; 3000b2c0 <== NOT EXECUTED 3000b2ac: eb0012ad bl 3000fd68 <== NOT EXECUTED if ( api_assoc ) 3000b2b0: e3500000 cmp r0, #0 <== NOT EXECUTED return api_assoc->name; 3000b2b4: 15900000 ldrne r0, [r0] <== NOT EXECUTED return "BAD CLASS"; 3000b2b8: 059f0004 ldreq r0, [pc, #4] ; 3000b2c4 <== NOT EXECUTED } 3000b2bc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED =============================================================================== 3000b2f8 : rtems_status_code rtems_object_get_class_information( int the_api, int the_class, rtems_object_api_class_information *info ) { 3000b2f8: e92d4010 push {r4, lr} <== NOT EXECUTED int i; /* * Validate parameters and look up information structure. */ if ( !info ) 3000b2fc: e2524000 subs r4, r2, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 3000b300: 03a00009 moveq r0, #9 <== NOT EXECUTED int i; /* * Validate parameters and look up information structure. */ if ( !info ) 3000b304: 08bd8010 popeq {r4, pc} <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 3000b308: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000b30c: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3000b310: eb000680 bl 3000cd18 <_Objects_Get_information> <== NOT EXECUTED if ( !obj_info ) 3000b314: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b318: 0a000014 beq 3000b370 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 3000b31c: 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; 3000b320: 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; 3000b324: e5843000 str r3, [r4] <== NOT EXECUTED info->maximum_id = obj_info->maximum_id; 3000b328: 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++ ) 3000b32c: 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; 3000b330: e5843004 str r3, [r4, #4] <== NOT EXECUTED info->auto_extend = obj_info->auto_extend; 3000b334: e5d03012 ldrb r3, [r0, #18] <== NOT EXECUTED info->maximum = obj_info->maximum; 3000b338: 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; 3000b33c: e5c4300c strb r3, [r4, #12] <== NOT EXECUTED info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 3000b340: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b344: ea000004 b 3000b35c <== NOT EXECUTED if ( !obj_info->local_table[i] ) 3000b348: e590c01c ldr ip, [r0, #28] <== NOT EXECUTED 3000b34c: 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++ ) 3000b350: e2833001 add r3, r3, #1 <== NOT EXECUTED if ( !obj_info->local_table[i] ) 3000b354: e35c0000 cmp ip, #0 <== NOT EXECUTED unallocated++; 3000b358: 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++ ) 3000b35c: e1530001 cmp r3, r1 <== NOT EXECUTED 3000b360: 9afffff8 bls 3000b348 <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 3000b364: e5842010 str r2, [r4, #16] <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000b368: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b36c: 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; 3000b370: e3a0000a mov r0, #10 <== NOT EXECUTED unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 3000b374: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000a60c : rtems_status_code rtems_object_get_classic_name( rtems_id id, rtems_name *name ) { 3000a60c: e92d4011 push {r0, r4, lr} <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 3000a610: e2514000 subs r4, r1, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 3000a614: 03a00009 moveq r0, #9 <== NOT EXECUTED ) { Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 3000a618: 0a000005 beq 3000a634 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; status = _Objects_Id_to_name( id, &name_u ); 3000a61c: e1a0100d mov r1, sp <== NOT EXECUTED 3000a620: eb0006a8 bl 3000c0c8 <_Objects_Id_to_name> <== NOT EXECUTED *name = name_u.name_u32; 3000a624: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a628: e5843000 str r3, [r4] <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 3000a62c: e59f3004 ldr r3, [pc, #4] ; 3000a638 <== NOT EXECUTED 3000a630: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED } 3000a634: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED =============================================================================== 3000a8e8 : Objects_Id id, size_t length, char *name ) { return _Objects_Get_name_as_string( id, length, name ); 3000a8e8: ea000732 b 3000c5b8 <_Objects_Get_name_as_string> <== NOT EXECUTED =============================================================================== 3000b37c : #undef rtems_object_id_api_maximum int rtems_object_id_api_maximum(void) { return OBJECTS_APIS_LAST; } 3000b37c: e3a00003 mov r0, #3 <== NOT EXECUTED 3000b380: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b384 : #undef rtems_object_id_api_minimum int rtems_object_id_api_minimum(void) { return OBJECTS_INTERNAL_API; } 3000b384: e3a00001 mov r0, #1 <== NOT EXECUTED 3000b388: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b38c : */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 3000b38c: e1a00c20 lsr r0, r0, #24 <== NOT EXECUTED int rtems_object_id_get_api( rtems_id id ) { return _Objects_Get_API( id ); } 3000b390: e2000007 and r0, r0, #7 <== NOT EXECUTED 3000b394: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b398 : int rtems_object_id_get_class( rtems_id id ) { return _Objects_Get_class( id ); } 3000b398: e1a00da0 lsr r0, r0, #27 <== NOT EXECUTED 3000b39c: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b3a0 : #undef rtems_object_id_get_index int rtems_object_id_get_index( rtems_id id ) { return _Objects_Get_index( id ); 3000b3a0: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED } 3000b3a4: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 3000b3a8: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b3ac : * 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; 3000b3ac: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED int rtems_object_id_get_node( rtems_id id ) { return _Objects_Get_node( id ); } 3000b3b0: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 3000b3b4: e12fff1e bx lr <== NOT EXECUTED =============================================================================== 3000b3b8 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 3000b3b8: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 3000b3bc: e2515000 subs r5, r1, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 3000b3c0: 03a00009 moveq r0, #9 <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 3000b3c4: 0a000016 beq 3000b424 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 3000b3c8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b3cc: 059f3054 ldreq r3, [pc, #84] ; 3000b428 <== NOT EXECUTED 3000b3d0: 11a04000 movne r4, r0 <== NOT EXECUTED 3000b3d4: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000b3d8: 05934008 ldreq r4, [r3, #8] <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 3000b3dc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b3e0: eb000647 bl 3000cd04 <_Objects_Get_information_id> <== NOT EXECUTED if ( !information ) 3000b3e4: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000b3e8: 0a00000c beq 3000b420 <== NOT EXECUTED return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 3000b3ec: e1a01004 mov r1, r4 <== NOT EXECUTED 3000b3f0: e1a0200d mov r2, sp <== NOT EXECUTED 3000b3f4: eb0006b2 bl 3000cec4 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 3000b3f8: 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 ); 3000b3fc: e1a01000 mov r1, r0 <== NOT EXECUTED switch ( location ) { 3000b400: e3540000 cmp r4, #0 <== NOT EXECUTED 3000b404: 1a000005 bne 3000b420 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 3000b408: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b40c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b410: eb00071a bl 3000d080 <_Objects_Set_name> <== NOT EXECUTED _Thread_Enable_dispatch(); 3000b414: eb0009dd bl 3000db90 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000b418: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b41c: ea000000 b 3000b424 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000b420: e3a00004 mov r0, #4 <== NOT EXECUTED } 3000b424: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 300161b8 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 300161b8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 300161bc: e2508000 subs r8, r0, #0 uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 300161c0: e1a05001 mov r5, r1 300161c4: e1a09002 mov r9, r2 300161c8: e1a0a003 mov sl, r3 register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 300161cc: 03a00003 moveq r0, #3 rtems_id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 300161d0: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc} return RTEMS_INVALID_NAME; if ( !starting_address ) 300161d4: e3510000 cmp r1, #0 300161d8: 0a000030 beq 300162a0 return RTEMS_INVALID_ADDRESS; if ( !id ) 300161dc: e59d2028 ldr r2, [sp, #40] ; 0x28 300161e0: e3520000 cmp r2, #0 300161e4: 0a00002d beq 300162a0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 300161e8: e3590000 cmp r9, #0 300161ec: 13530000 cmpne r3, #0 300161f0: 0a00002c beq 300162a8 300161f4: e1590003 cmp r9, r3 300161f8: 3a00002a bcc 300162a8 300161fc: e3130007 tst r3, #7 30016200: 1a000028 bne 300162a8 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 30016204: e2116007 ands r6, r1, #7 30016208: 1a000028 bne 300162b0 3001620c: e59f30a4 ldr r3, [pc, #164] ; 300162b8 30016210: e5932000 ldr r2, [r3] 30016214: e2822001 add r2, r2, #1 30016218: 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 ); 3001621c: e59f7098 ldr r7, [pc, #152] ; 300162bc 30016220: e1a00007 mov r0, r7 30016224: eb001189 bl 3001a850 <_Objects_Allocate> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 30016228: e2504000 subs r4, r0, #0 3001622c: 1a000002 bne 3001623c _Thread_Enable_dispatch(); 30016230: eb0015cc bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 30016234: e3a00005 mov r0, #5 <== NOT EXECUTED 30016238: 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; 3001623c: e59d3024 ldr r3, [sp, #36] ; 0x24 the_partition->number_of_used_blocks = 0; _Chain_Initialize( &the_partition->Memory, starting_address, 30016240: 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; 30016244: e584301c str r3, [r4, #28] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 30016248: e5845010 str r5, [r4, #16] the_partition->length = length; 3001624c: e5849014 str r9, [r4, #20] the_partition->buffer_size = buffer_size; 30016250: e584a018 str sl, [r4, #24] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 30016254: e5846020 str r6, [r4, #32] _Chain_Initialize( &the_partition->Memory, starting_address, 30016258: e1a00009 mov r0, r9 3001625c: eb005da7 bl 3002d900 <__aeabi_uidiv> 30016260: e284b024 add fp, r4, #36 ; 0x24 30016264: e1a02000 mov r2, r0 30016268: e1a01005 mov r1, r5 3001626c: e1a0000b mov r0, fp 30016270: e1a0300a mov r3, sl 30016274: eb000bca bl 300191a4 <_Chain_Initialize> #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30016278: e597201c ldr r2, [r7, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 3001627c: e1d410b8 ldrh r1, [r4, #8] 30016280: e5943008 ldr r3, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30016284: e7824101 str r4, [r2, r1, lsl #2] &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 30016288: e59d2028 ldr r2, [sp, #40] ; 0x28 information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 3001628c: e584800c str r8, [r4, #12] 30016290: e5823000 str r3, [r2] name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 30016294: eb0015b3 bl 3001b968 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30016298: e1a00006 mov r0, r6 3001629c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} if ( !starting_address ) return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; 300162a0: e3a00009 mov r0, #9 <== NOT EXECUTED 300162a4: 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; 300162a8: e3a00008 mov r0, #8 <== NOT EXECUTED 300162ac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; 300162b0: e3a00009 mov r0, #9 <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 300162b4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED =============================================================================== 300162c0 : */ rtems_status_code rtems_partition_delete( rtems_id id ) { 300162c0: e92d4031 push {r0, r4, r5, lr} 300162c4: e1a01000 mov r1, r0 Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) _Objects_Get( &_Partition_Information, id, location ); 300162c8: e1a0200d mov r2, sp 300162cc: e59f0050 ldr r0, [pc, #80] ; 30016324 300162d0: eb00128a bl 3001ad00 <_Objects_Get> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 300162d4: e59d3000 ldr r3, [sp] 300162d8: e1a04000 mov r4, r0 300162dc: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 300162e0: 13a00004 movne r0, #4 { register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 300162e4: 1a00000d bne 30016320 case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 300162e8: e5945020 ldr r5, [r4, #32] 300162ec: e3550000 cmp r5, #0 300162f0: 1a000008 bne 30016318 _Objects_Close( &_Partition_Information, &the_partition->Object ); 300162f4: e59f0028 ldr r0, [pc, #40] ; 30016324 300162f8: e1a01004 mov r1, r4 300162fc: eb001175 bl 3001a8d8 <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Partition_Free ( Partition_Control *the_partition ) { _Objects_Free( &_Partition_Information, &the_partition->Object ); 30016300: e59f001c ldr r0, [pc, #28] ; 30016324 30016304: e1a01004 mov r1, r4 30016308: eb001217 bl 3001ab6c <_Objects_Free> 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 3001630c: eb001595 bl 3001b968 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30016310: e1a00005 mov r0, r5 30016314: ea000001 b 30016320 } _Thread_Enable_dispatch(); 30016318: eb001592 bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_RESOURCE_IN_USE; 3001631c: e3a0000c mov r0, #12 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30016320: e8bd8038 pop {r3, r4, r5, pc} =============================================================================== 300163d0 : rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) { 300163d0: e92d4071 push {r0, r4, r5, r6, lr} 300163d4: e1a03000 mov r3, r0 300163d8: e1a04001 mov r4, r1 Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) _Objects_Get( &_Partition_Information, id, location ); 300163dc: e59f0088 ldr r0, [pc, #136] ; 3001646c 300163e0: e1a01003 mov r1, r3 300163e4: e1a0200d mov r2, sp 300163e8: eb001244 bl 3001ad00 <_Objects_Get> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 300163ec: e59d3000 ldr r3, [sp] 300163f0: e1a05000 mov r5, r0 300163f4: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 300163f8: 13a00004 movne r0, #4 { register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 300163fc: 1a000016 bne 3001645c ) { void *starting; void *ending; starting = the_partition->starting_address; 30016400: e5950010 ldr r0, [r5, #16] 30016404: e5953014 ldr r3, [r5, #20] 30016408: e0803003 add r3, r0, r3 const void *address, const void *base, const void *limit ) { return (address >= base && address <= limit); 3001640c: e1540003 cmp r4, r3 30016410: 83a03000 movhi r3, #0 30016414: 93a03001 movls r3, #1 30016418: e1540000 cmp r4, r0 3001641c: 33a03000 movcc r3, #0 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 30016420: e3530000 cmp r3, #0 30016424: 0a00000d beq 30016460 offset = (uint32_t) _Addresses_Subtract( the_buffer, the_partition->starting_address ); return ((offset % the_partition->buffer_size) == 0); 30016428: e0600004 rsb r0, r0, r4 3001642c: e5951018 ldr r1, [r5, #24] 30016430: eb005dca bl 3002db60 <__umodsi3> starting = the_partition->starting_address; ending = _Addresses_Add_offset( starting, the_partition->length ); return ( _Addresses_Is_in_range( the_buffer, starting, ending ) && 30016434: e2506000 subs r6, r0, #0 30016438: 1a000008 bne 30016460 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 3001643c: e2850024 add r0, r5, #36 ; 0x24 30016440: e1a01004 mov r1, r4 30016444: eb000b36 bl 30019124 <_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; 30016448: e5953020 ldr r3, [r5, #32] 3001644c: e2433001 sub r3, r3, #1 30016450: e5853020 str r3, [r5, #32] _Thread_Enable_dispatch(); 30016454: eb001543 bl 3001b968 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30016458: e1a00006 mov r0, r6 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3001645c: 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(); 30016460: eb001540 bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 30016464: e3a00009 mov r0, #9 <== NOT EXECUTED 30016468: eafffffb b 3001645c <== NOT EXECUTED =============================================================================== 30015820 : void *internal_start, void *external_start, uint32_t length, rtems_id *id ) { 30015820: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) 30015824: e250a000 subs sl, r0, #0 void *internal_start, void *external_start, uint32_t length, rtems_id *id ) { 30015828: e1a04001 mov r4, r1 3001582c: e1a05002 mov r5, r2 30015830: e1a09003 mov r9, r3 30015834: e59d6020 ldr r6, [sp, #32] register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 30015838: 03a00003 moveq r0, #3 rtems_id *id ) { register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) 3001583c: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} return RTEMS_INVALID_NAME; if ( !id ) 30015840: e3560000 cmp r6, #0 return RTEMS_INVALID_ADDRESS; 30015844: 03a00009 moveq r0, #9 register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 30015848: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} * id - port id * RTEMS_SUCCESSFUL - if successful * error code - if unsuccessful */ rtems_status_code rtems_port_create( 3001584c: e1828001 orr r8, r2, r1 return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 30015850: e2188007 ands r8, r8, #7 30015854: 1a000018 bne 300158bc rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 30015858: e59f3064 ldr r3, [pc, #100] ; 300158c4 3001585c: e5932000 ldr r2, [r3] 30015860: e2822001 add r2, r2, #1 30015864: e5832000 str r2, [r3] */ RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Allocate ( void ) { return (Dual_ported_memory_Control *) _Objects_Allocate( &_Dual_ported_memory_Information ); 30015868: e59f7058 ldr r7, [pc, #88] ; 300158c8 3001586c: e1a00007 mov r0, r7 30015870: eb0013f6 bl 3001a850 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 30015874: e3500000 cmp r0, #0 30015878: 1a000002 bne 30015888 _Thread_Enable_dispatch(); 3001587c: eb001839 bl 3001b968 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 30015880: e3a00005 mov r0, #5 30015884: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 30015888: e5903008 ldr r3, [r0, #8] 3001588c: e1d010b8 ldrh r1, [r0, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30015890: e597201c ldr r2, [r7, #28] } the_port->internal_base = internal_start; the_port->external_base = external_start; the_port->length = length - 1; 30015894: e2499001 sub r9, r9, #1 if ( !the_port ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 30015898: e5804010 str r4, [r0, #16] the_port->external_base = external_start; 3001589c: e5805014 str r5, [r0, #20] the_port->length = length - 1; 300158a0: e5809018 str r9, [r0, #24] 300158a4: e7820101 str r0, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 300158a8: e580a00c str sl, [r0, #12] &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 300158ac: e5863000 str r3, [r6] _Thread_Enable_dispatch(); 300158b0: eb00182c bl 3001b968 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 300158b4: e1a00008 mov r0, r8 300158b8: 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; 300158bc: e3a00009 mov r0, #9 <== NOT EXECUTED ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 300158c0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED =============================================================================== 30016470 : */ rtems_status_code rtems_rate_monotonic_cancel( rtems_id id ) { 30016470: e92d4031 push {r0, r4, r5, lr} 30016474: e1a01000 mov r1, r0 Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 30016478: e1a0200d mov r2, sp 3001647c: e59f004c ldr r0, [pc, #76] ; 300164d0 30016480: eb00121e bl 3001ad00 <_Objects_Get> Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 30016484: e59d4000 ldr r4, [sp] 30016488: e1a05000 mov r5, r0 3001648c: e3540000 cmp r4, #0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30016490: 13a00004 movne r0, #4 { Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 30016494: 1a00000c bne 300164cc case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 30016498: e59f3034 ldr r3, [pc, #52] ; 300164d4 3001649c: e5952040 ldr r2, [r5, #64] ; 0x40 300164a0: e5933004 ldr r3, [r3, #4] 300164a4: e1520003 cmp r2, r3 300164a8: 0a000002 beq 300164b8 _Thread_Enable_dispatch(); 300164ac: eb00152d bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_NOT_OWNER_OF_RESOURCE; 300164b0: e3a00017 mov r0, #23 <== NOT EXECUTED 300164b4: ea000004 b 300164cc <== NOT EXECUTED } (void) _Watchdog_Remove( &the_period->Timer ); 300164b8: e2850010 add r0, r5, #16 300164bc: eb00198f bl 3001cb00 <_Watchdog_Remove> the_period->state = RATE_MONOTONIC_INACTIVE; 300164c0: e5854038 str r4, [r5, #56] ; 0x38 _Thread_Enable_dispatch(); 300164c4: eb001527 bl 3001b968 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 300164c8: e1a00004 mov r0, r4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 300164cc: e8bd8038 pop {r3, r4, r5, pc} =============================================================================== 3000a23c : rtems_status_code rtems_rate_monotonic_create( rtems_name name, rtems_id *id ) { 3000a23c: e92d41f0 push {r4, r5, r6, r7, r8, lr} Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 3000a240: e2508000 subs r8, r0, #0 rtems_status_code rtems_rate_monotonic_create( rtems_name name, rtems_id *id ) { 3000a244: e1a06001 mov r6, r1 Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 3000a248: 03a00003 moveq r0, #3 rtems_id *id ) { Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 3000a24c: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} return RTEMS_INVALID_NAME; if ( !id ) 3000a250: e3510000 cmp r1, #0 3000a254: 0a000026 beq 3000a2f4 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 3000a258: e59f309c ldr r3, [pc, #156] ; 3000a2fc 3000a25c: e5932000 ldr r2, [r3] 3000a260: e2822001 add r2, r2, #1 3000a264: e5832000 str r2, [r3] * the inactive chain of free period control blocks. */ RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void ) { return (Rate_monotonic_Control *) _Objects_Allocate( &_Rate_monotonic_Information ); 3000a268: e59f7090 ldr r7, [pc, #144] ; 3000a300 3000a26c: e1a00007 mov r0, r7 3000a270: eb000794 bl 3000c0c8 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 3000a274: e2504000 subs r4, r0, #0 3000a278: 1a000002 bne 3000a288 _Thread_Enable_dispatch(); 3000a27c: eb000bff bl 3000d280 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 3000a280: e3a00005 mov r0, #5 <== NOT EXECUTED 3000a284: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED } the_period->owner = _Thread_Executing; 3000a288: e59f3074 ldr r3, [pc, #116] ; 3000a304 the_period->state = RATE_MONOTONIC_INACTIVE; 3000a28c: e3a05000 mov r5, #0 if ( !the_period ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 3000a290: e5933004 ldr r3, [r3, #4] the_period->state = RATE_MONOTONIC_INACTIVE; _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 3000a294: e1a01005 mov r1, r5 if ( !the_period ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 3000a298: 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 ); 3000a29c: e3a02038 mov r2, #56 ; 0x38 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; the_period->state = RATE_MONOTONIC_INACTIVE; 3000a2a0: e5845038 str r5, [r4, #56] ; 0x38 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 3000a2a4: e5845018 str r5, [r4, #24] the_watchdog->routine = routine; 3000a2a8: e584502c str r5, [r4, #44] ; 0x2c the_watchdog->id = id; 3000a2ac: e5845030 str r5, [r4, #48] ; 0x30 the_watchdog->user_data = user_data; 3000a2b0: e5845034 str r5, [r4, #52] ; 0x34 _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 3000a2b4: e2840054 add r0, r4, #84 ; 0x54 3000a2b8: eb002175 bl 30012894 3000a2bc: e3e03102 mvn r3, #-2147483648 ; 0x80000000 3000a2c0: e584305c str r3, [r4, #92] ; 0x5c 3000a2c4: e5843060 str r3, [r4, #96] ; 0x60 3000a2c8: e5843074 str r3, [r4, #116] ; 0x74 3000a2cc: e5843078 str r3, [r4, #120] ; 0x78 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000a2d0: e597201c ldr r2, [r7, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 3000a2d4: e5943008 ldr r3, [r4, #8] 3000a2d8: e1d410b8 ldrh r1, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 3000a2dc: e7824101 str r4, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 3000a2e0: e584800c str r8, [r4, #12] &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 3000a2e4: e5863000 str r3, [r6] _Thread_Enable_dispatch(); 3000a2e8: eb000be4 bl 3000d280 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000a2ec: e1a00005 mov r0, r5 3000a2f0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 3000a2f4: e3a00009 mov r0, #9 <== NOT EXECUTED ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 3000a2f8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 3000fd5c : rtems_status_code rtems_rate_monotonic_get_statistics( rtems_id id, rtems_rate_monotonic_period_statistics *statistics ) { 3000fd5c: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; rtems_rate_monotonic_period_statistics *dst; Rate_monotonic_Statistics *src; if ( !statistics ) 3000fd60: e2514000 subs r4, r1, #0 <== NOT EXECUTED rtems_status_code rtems_rate_monotonic_get_statistics( rtems_id id, rtems_rate_monotonic_period_statistics *statistics ) { 3000fd64: 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; 3000fd68: 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 ) 3000fd6c: 0a000025 beq 3000fe08 <== NOT EXECUTED 3000fd70: e59f0094 ldr r0, [pc, #148] ; 3000fe0c <== NOT EXECUTED 3000fd74: e1a01003 mov r1, r3 <== NOT EXECUTED 3000fd78: e1a0200d mov r2, sp <== NOT EXECUTED 3000fd7c: ebfff225 bl 3000c618 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 3000fd80: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000fd84: e3550000 cmp r5, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000fd88: 13a00004 movne r0, #4 <== NOT EXECUTED if ( !statistics ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 3000fd8c: 1a00001d bne 3000fe08 <== NOT EXECUTED case OBJECTS_LOCAL: dst = statistics; src = &the_period->Statistics; dst->count = src->count; 3000fd90: e5903054 ldr r3, [r0, #84] ; 0x54 <== NOT EXECUTED 3000fd94: e5843000 str r3, [r4] <== NOT EXECUTED dst->missed_count = src->missed_count; 3000fd98: e5903058 ldr r3, [r0, #88] ; 0x58 <== NOT EXECUTED 3000fd9c: e5843004 str r3, [r4, #4] <== NOT EXECUTED #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time ); 3000fda0: e280305c add r3, r0, #92 ; 0x5c <== NOT EXECUTED 3000fda4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED 3000fda8: e5842008 str r2, [r4, #8] <== NOT EXECUTED 3000fdac: e584300c str r3, [r4, #12] <== NOT EXECUTED _Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time ); 3000fdb0: e2803064 add r3, r0, #100 ; 0x64 <== NOT EXECUTED 3000fdb4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED 3000fdb8: e5842010 str r2, [r4, #16] <== NOT EXECUTED 3000fdbc: e5843014 str r3, [r4, #20] <== NOT EXECUTED _Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time ); 3000fdc0: e280306c add r3, r0, #108 ; 0x6c <== NOT EXECUTED 3000fdc4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED 3000fdc8: e5842018 str r2, [r4, #24] <== NOT EXECUTED 3000fdcc: e584301c str r3, [r4, #28] <== NOT EXECUTED _Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time ); 3000fdd0: e2803074 add r3, r0, #116 ; 0x74 <== NOT EXECUTED 3000fdd4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED 3000fdd8: e5842020 str r2, [r4, #32] <== NOT EXECUTED 3000fddc: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED _Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time ); 3000fde0: e280307c add r3, r0, #124 ; 0x7c <== NOT EXECUTED 3000fde4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED 3000fde8: e5842028 str r2, [r4, #40] ; 0x28 <== NOT EXECUTED 3000fdec: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED _Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time ); 3000fdf0: e2803084 add r3, r0, #132 ; 0x84 <== NOT EXECUTED 3000fdf4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED 3000fdf8: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED 3000fdfc: e5843034 str r3, [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(); 3000fe00: ebfff51e bl 3000d280 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000fe04: e1a00005 mov r0, r5 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000fe08: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 3000fe10 : rtems_status_code rtems_rate_monotonic_get_status( rtems_id id, rtems_rate_monotonic_period_status *status ) { 3000fe10: e92d4010 push {r4, lr} <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Period_time_t since_last_period; Rate_monotonic_Control *the_period; bool valid_status; if ( !status ) 3000fe14: e2514000 subs r4, r1, #0 <== NOT EXECUTED rtems_status_code rtems_rate_monotonic_get_status( rtems_id id, rtems_rate_monotonic_period_status *status ) { 3000fe18: e1a03000 mov r3, r0 <== NOT EXECUTED 3000fe1c: 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; 3000fe20: 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 ) 3000fe24: 0a000023 beq 3000feb8 <== NOT EXECUTED 3000fe28: e1a01003 mov r1, r3 <== NOT EXECUTED 3000fe2c: e28d2010 add r2, sp, #16 <== NOT EXECUTED 3000fe30: e59f0088 ldr r0, [pc, #136] ; 3000fec0 <== NOT EXECUTED 3000fe34: ebfff1f7 bl 3000c618 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 3000fe38: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3000fe3c: e1a03000 mov r3, r0 <== NOT EXECUTED 3000fe40: e3520000 cmp r2, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000fe44: 13a00004 movne r0, #4 <== NOT EXECUTED if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 3000fe48: 1a00001a bne 3000feb8 <== NOT EXECUTED case OBJECTS_LOCAL: status->owner = the_period->owner->Object.id; 3000fe4c: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED status->state = the_period->state; 3000fe50: 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; 3000fe54: 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 ) { 3000fe58: 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; 3000fe5c: e884000c stm r4, {r2, r3} <== 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 ); 3000fe60: 05843008 streq r3, [r4, #8] <== NOT EXECUTED 3000fe64: 0584300c streq r3, [r4, #12] <== NOT EXECUTED _Timespec_Set_to_zero( &status->executed_since_last_period ); 3000fe68: 05843010 streq r3, [r4, #16] <== NOT EXECUTED 3000fe6c: 05843014 streq r3, [r4, #20] <== NOT EXECUTED 3000fe70: 0a00000e beq 3000feb0 <== NOT EXECUTED } else { /* * Grab the current status. */ valid_status = 3000fe74: e1a0100d mov r1, sp <== NOT EXECUTED 3000fe78: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000fe7c: ebffe92d bl 3000a338 <_Rate_monotonic_Get_status> <== NOT EXECUTED _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) { 3000fe80: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fe84: 1a000002 bne 3000fe94 <== NOT EXECUTED _Thread_Enable_dispatch(); 3000fe88: ebfff4fc bl 3000d280 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_NOT_DEFINED; 3000fe8c: e3a0000b mov r0, #11 <== NOT EXECUTED 3000fe90: ea000008 b 3000feb8 <== NOT EXECUTED } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_To_timespec( 3000fe94: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED 3000fe98: e5842008 str r2, [r4, #8] <== NOT EXECUTED 3000fe9c: e584300c str r3, [r4, #12] <== NOT EXECUTED &since_last_period, &status->since_last_period ); _Timestamp_To_timespec( 3000fea0: e28d3008 add r3, sp, #8 <== NOT EXECUTED 3000fea4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED 3000fea8: e5842010 str r2, [r4, #16] <== NOT EXECUTED 3000feac: e5843014 str r3, [r4, #20] <== NOT EXECUTED status->since_last_period = since_last_period; status->executed_since_last_period = executed; #endif } _Thread_Enable_dispatch(); 3000feb0: ebfff4f2 bl 3000d280 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000feb4: e3a00000 mov r0, #0 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000feb8: e28dd014 add sp, sp, #20 <== NOT EXECUTED 3000febc: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 3000a53c : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 3000a53c: e92d40f1 push {r0, r4, r5, r6, r7, lr} 3000a540: e1a05000 mov r5, r0 3000a544: e1a04001 mov r4, r1 Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 3000a548: e59f016c ldr r0, [pc, #364] ; 3000a6bc 3000a54c: e1a01005 mov r1, r5 3000a550: e1a0200d mov r2, sp 3000a554: eb00082f bl 3000c618 <_Objects_Get> rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 3000a558: e59d3000 ldr r3, [sp] 3000a55c: e1a06000 mov r6, r0 3000a560: e3530000 cmp r3, #0 3000a564: 1a000051 bne 3000a6b0 case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 3000a568: e59f3150 ldr r3, [pc, #336] ; 3000a6c0 3000a56c: e5902040 ldr r2, [r0, #64] ; 0x40 3000a570: e5933004 ldr r3, [r3, #4] 3000a574: e1520003 cmp r2, r3 3000a578: 0a000002 beq 3000a588 _Thread_Enable_dispatch(); 3000a57c: eb000b3f bl 3000d280 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_NOT_OWNER_OF_RESOURCE; 3000a580: e3a04017 mov r4, #23 <== NOT EXECUTED 3000a584: ea00004a b 3000a6b4 <== NOT EXECUTED } if ( length == RTEMS_PERIOD_STATUS ) { 3000a588: e3540000 cmp r4, #0 3000a58c: 1a000005 bne 3000a5a8 switch ( the_period->state ) { 3000a590: e5903038 ldr r3, [r0, #56] ; 0x38 3000a594: e3530004 cmp r3, #4 3000a598: 959f2124 ldrls r2, [pc, #292] ; 3000a6c4 3000a59c: 97924103 ldrls r4, [r2, r3, lsl #2] case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 3000a5a0: eb000b36 bl 3000d280 <_Thread_Enable_dispatch> return( return_value ); 3000a5a4: ea000042 b 3000a6b4 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000a5a8: e10f7000 mrs r7, CPSR 3000a5ac: e3873080 orr r3, r7, #128 ; 0x80 3000a5b0: e129f003 msr CPSR_fc, r3 } _ISR_Disable( level ); if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 3000a5b4: e5903038 ldr r3, [r0, #56] ; 0x38 3000a5b8: e3530000 cmp r3, #0 3000a5bc: 1a000011 bne 3000a608 static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000a5c0: e129f007 msr CPSR_fc, r7 _ISR_Enable( level ); /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 3000a5c4: ebffff89 bl 3000a3f0 <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 3000a5c8: e3a03002 mov r3, #2 3000a5cc: e5863038 str r3, [r6, #56] ; 0x38 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 3000a5d0: e59f30f0 ldr r3, [pc, #240] ; 3000a6c8 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 3000a5d4: e3a07000 mov r7, #0 the_watchdog->routine = routine; 3000a5d8: e586302c str r3, [r6, #44] ; 0x2c _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 3000a5dc: e586403c str r4, [r6, #60] ; 0x3c Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 3000a5e0: e586401c str r4, [r6, #28] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 3000a5e4: e59f00e0 ldr r0, [pc, #224] ; 3000a6cc 3000a5e8: e2861010 add r1, r6, #16 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 3000a5ec: e5867018 str r7, [r6, #24] the_watchdog->routine = routine; the_watchdog->id = id; 3000a5f0: e5865030 str r5, [r6, #48] ; 0x30 the_watchdog->user_data = user_data; 3000a5f4: e5867034 str r7, [r6, #52] ; 0x34 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 3000a5f8: eb000ebd bl 3000e0f4 <_Watchdog_Insert> _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 3000a5fc: e1a04007 mov r4, r7 ); the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 3000a600: eb000b1e bl 3000d280 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000a604: ea00002a b 3000a6b4 } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 3000a608: e3530002 cmp r3, #2 3000a60c: 1a000019 bne 3000a678 /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 3000a610: ebffff93 bl 3000a464 <_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; 3000a614: e3a03001 mov r3, #1 3000a618: e5863038 str r3, [r6, #56] ; 0x38 the_period->next_length = length; 3000a61c: e586403c str r4, [r6, #60] ; 0x3c 3000a620: e129f007 msr CPSR_fc, r7 _ISR_Enable( level ); _Thread_Executing->Wait.id = the_period->Object.id; 3000a624: e59f3094 ldr r3, [pc, #148] ; 3000a6c0 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 3000a628: 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; 3000a62c: e5930004 ldr r0, [r3, #4] 3000a630: e5963008 ldr r3, [r6, #8] 3000a634: e5803020 str r3, [r0, #32] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 3000a638: eb000d13 bl 3000da8c <_Thread_Set_state> static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 3000a63c: e10f2000 mrs r2, CPSR 3000a640: e3823080 orr r3, r2, #128 ; 0x80 3000a644: 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; 3000a648: e3a01002 mov r1, #2 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); local_state = the_period->state; 3000a64c: e5963038 ldr r3, [r6, #56] ; 0x38 the_period->state = RATE_MONOTONIC_ACTIVE; 3000a650: e5861038 str r1, [r6, #56] ; 0x38 static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 3000a654: 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 ) 3000a658: e3530003 cmp r3, #3 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 3000a65c: 059f305c ldreq r3, [pc, #92] ; 3000a6c0 3000a660: 03a01901 moveq r1, #16384 ; 0x4000 3000a664: 05930004 ldreq r0, [r3, #4] 3000a668: 0b000a40 bleq 3000cf70 <_Thread_Clear_state> _Thread_Enable_dispatch(); 3000a66c: eb000b03 bl 3000d280 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000a670: e3a04000 mov r4, #0 <== NOT EXECUTED 3000a674: ea00000e b 3000a6b4 <== NOT EXECUTED } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 3000a678: e3530004 cmp r3, #4 <== NOT EXECUTED 3000a67c: 1a00000b bne 3000a6b0 <== NOT EXECUTED /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 3000a680: ebffff77 bl 3000a464 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED 3000a684: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 3000a688: e3a03002 mov r3, #2 <== NOT EXECUTED 3000a68c: e5863038 str r3, [r6, #56] ; 0x38 <== NOT EXECUTED the_period->next_length = length; 3000a690: e586403c str r4, [r6, #60] ; 0x3c <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 3000a694: e586401c str r4, [r6, #28] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 3000a698: e59f002c ldr r0, [pc, #44] ; 3000a6cc <== NOT EXECUTED 3000a69c: e2861010 add r1, r6, #16 <== NOT EXECUTED 3000a6a0: eb000e93 bl 3000e0f4 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_TIMEOUT; 3000a6a4: e3a04006 mov r4, #6 <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 3000a6a8: eb000af4 bl 3000d280 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TIMEOUT; 3000a6ac: ea000000 b 3000a6b4 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000a6b0: e3a04004 mov r4, #4 <== NOT EXECUTED } 3000a6b4: e1a00004 mov r0, r4 3000a6b8: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} =============================================================================== 3000a8dc : void rtems_rate_monotonic_report_statistics( void ) { rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin ); 3000a8dc: e59f1004 ldr r1, [pc, #4] ; 3000a8e8 <== NOT EXECUTED 3000a8e0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a8e4: eaffff79 b 3000a6d0 <== NOT EXECUTED =============================================================================== 3000a6d0 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 3000a6d0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, 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 ) 3000a6d4: e2514000 subs r4, r1, #0 <== NOT EXECUTED */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 3000a6d8: e24dd078 sub sp, sp, #120 ; 0x78 <== NOT EXECUTED 3000a6dc: 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 ) 3000a6e0: 0a000071 beq 3000a8ac <== NOT EXECUTED return; (*print)( context, "Period information by period\n" ); 3000a6e4: e59f11c8 ldr r1, [pc, #456] ; 3000a8b4 <== NOT EXECUTED 3000a6e8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a6ec: e12fff14 bx r4 <== NOT EXECUTED #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 3000a6f0: e59f11c0 ldr r1, [pc, #448] ; 3000a8b8 <== NOT EXECUTED 3000a6f4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a6f8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a6fc: e12fff14 bx r4 <== NOT EXECUTED (*print)( context, "--- Wall times are in seconds ---\n" ); 3000a700: e59f11b4 ldr r1, [pc, #436] ; 3000a8bc <== NOT EXECUTED 3000a704: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a708: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a70c: e12fff14 bx r4 <== NOT EXECUTED Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 3000a710: e59f11a8 ldr r1, [pc, #424] ; 3000a8c0 <== NOT EXECUTED 3000a714: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a718: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a71c: e12fff14 bx r4 <== NOT EXECUTED * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 3000a720: e28d7018 add r7, sp, #24 <== NOT EXECUTED #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 3000a724: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a728: e59f1194 ldr r1, [pc, #404] ; 3000a8c4 <== NOT EXECUTED 3000a72c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a730: 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 ; 3000a734: e59f818c ldr r8, [pc, #396] ; 3000a8c8 <== 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; 3000a738: e2873018 add r3, r7, #24 <== NOT EXECUTED 3000a73c: e58d3010 str r3, [sp, #16] <== NOT EXECUTED { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ 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; 3000a740: e2873030 add r3, r7, #48 ; 0x30 <== 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 ; 3000a744: e5986008 ldr r6, [r8, #8] <== NOT EXECUTED continue; #else (void) rtems_rate_monotonic_get_status( id, &the_status ); #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 3000a748: e28da070 add sl, sp, #112 ; 0x70 <== 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 ); 3000a74c: e28d9068 add r9, sp, #104 ; 0x68 <== NOT EXECUTED { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ 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; 3000a750: e58d3014 str r3, [sp, #20] <== 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 ; 3000a754: ea000051 b 3000a8a0 <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 3000a758: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a75c: e1a01007 mov r1, r7 <== NOT EXECUTED 3000a760: eb00157d bl 3000fd5c <== NOT EXECUTED if ( status != RTEMS_SUCCESSFUL ) 3000a764: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a768: 1a00004b bne 3000a89c <== 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 ); 3000a76c: e28d1050 add r1, sp, #80 ; 0x50 <== NOT EXECUTED 3000a770: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a774: eb0015a5 bl 3000fe10 <== NOT EXECUTED #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 3000a778: e3a01005 mov r1, #5 <== NOT EXECUTED 3000a77c: e1a0200a mov r2, sl <== NOT EXECUTED 3000a780: e59d0050 ldr r0, [sp, #80] ; 0x50 <== NOT EXECUTED 3000a784: eb0000ac bl 3000aa3c <== NOT EXECUTED /* * Print part of report line that is not dependent on granularity */ (*print)( context, 3000a788: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3000a78c: e59f1138 ldr r1, [pc, #312] ; 3000a8cc <== NOT EXECUTED 3000a790: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a794: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 3000a798: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a79c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000a7a0: e1a02006 mov r2, r6 <== NOT EXECUTED 3000a7a4: e1a0300a mov r3, sl <== NOT EXECUTED 3000a7a8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a7ac: e12fff14 bx r4 <== NOT EXECUTED ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 3000a7b0: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 3000a7b4: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a7b8: 1a000004 bne 3000a7d0 <== NOT EXECUTED (*print)( context, "\n" ); 3000a7bc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a7c0: e59f1108 ldr r1, [pc, #264] ; 3000a8d0 <== NOT EXECUTED 3000a7c4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a7c8: e12fff14 bx r4 <== NOT EXECUTED continue; 3000a7cc: ea000032 b 3000a89c <== 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 ); 3000a7d0: e1a02009 mov r2, r9 <== NOT EXECUTED 3000a7d4: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED 3000a7d8: eb000d55 bl 3000dd34 <_Timespec_Divide_by_integer> <== NOT EXECUTED (*print)( context, 3000a7dc: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 3000a7e0: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a7e4: eb004215 bl 3001b040 <__aeabi_idiv> <== NOT EXECUTED 3000a7e8: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000a7ec: e1a0b000 mov fp, r0 <== NOT EXECUTED 3000a7f0: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a7f4: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED 3000a7f8: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a7fc: eb00420f bl 3001b040 <__aeabi_idiv> <== NOT EXECUTED 3000a800: e59d3068 ldr r3, [sp, #104] ; 0x68 <== NOT EXECUTED 3000a804: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 3000a808: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a80c: e59d006c ldr r0, [sp, #108] ; 0x6c <== NOT EXECUTED 3000a810: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3000a814: eb004209 bl 3001b040 <__aeabi_idiv> <== NOT EXECUTED 3000a818: e1a0300b mov r3, fp <== NOT EXECUTED 3000a81c: e58d000c str r0, [sp, #12] <== NOT EXECUTED 3000a820: e59f10ac ldr r1, [pc, #172] ; 3000a8d4 <== NOT EXECUTED 3000a824: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000a828: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a82c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a830: 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); 3000a834: e1a02009 mov r2, r9 <== NOT EXECUTED 3000a838: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED 3000a83c: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 3000a840: eb000d3b bl 3000dd34 <_Timespec_Divide_by_integer> <== NOT EXECUTED (*print)( context, 3000a844: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a848: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED 3000a84c: eb0041fb bl 3001b040 <__aeabi_idiv> <== NOT EXECUTED 3000a850: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED 3000a854: e1a0b000 mov fp, r0 <== NOT EXECUTED 3000a858: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a85c: e59d0044 ldr r0, [sp, #68] ; 0x44 <== NOT EXECUTED 3000a860: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a864: eb0041f5 bl 3001b040 <__aeabi_idiv> <== NOT EXECUTED 3000a868: e59d3068 ldr r3, [sp, #104] ; 0x68 <== NOT EXECUTED 3000a86c: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 3000a870: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 3000a874: e59d006c ldr r0, [sp, #108] ; 0x6c <== NOT EXECUTED 3000a878: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3000a87c: eb0041ef bl 3001b040 <__aeabi_idiv> <== NOT EXECUTED 3000a880: e59f1050 ldr r1, [pc, #80] ; 3000a8d8 <== NOT EXECUTED 3000a884: e58d000c str r0, [sp, #12] <== NOT EXECUTED 3000a888: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED 3000a88c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a890: e1a0300b mov r3, fp <== NOT EXECUTED 3000a894: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a898: 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++ ) { 3000a89c: 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 ; 3000a8a0: e598300c ldr r3, [r8, #12] <== NOT EXECUTED 3000a8a4: e1560003 cmp r6, r3 <== NOT EXECUTED 3000a8a8: 9affffaa bls 3000a758 <== NOT EXECUTED the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 3000a8ac: e28dd078 add sp, sp, #120 ; 0x78 <== NOT EXECUTED 3000a8b0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED =============================================================================== 3000a8ec : 3000a8ec: e59f3038 ldr r3, [pc, #56] ; 3000a92c <== NOT EXECUTED /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 3000a8f0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED 3000a8f4: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000a8f8: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000a8fc: 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 ; 3000a900: e59f5028 ldr r5, [pc, #40] ; 3000a930 <== NOT EXECUTED 3000a904: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED 3000a908: ea000002 b 3000a918 <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { (void) rtems_rate_monotonic_reset_statistics( id ); 3000a90c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a910: eb000007 bl 3000a934 <== 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++ ) { 3000a914: 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 ; 3000a918: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3000a91c: e1540003 cmp r4, r3 <== NOT EXECUTED 3000a920: 9afffff9 bls 3000a90c <== NOT EXECUTED /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 3000a924: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 3000a928: ea000a54 b 3000d280 <_Thread_Enable_dispatch> <== NOT EXECUTED =============================================================================== 3000a934 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( rtems_id id ) { 3000a934: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED 3000a938: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a93c: e1a0200d mov r2, sp <== NOT EXECUTED 3000a940: e59f0044 ldr r0, [pc, #68] ; 3000a98c <== NOT EXECUTED 3000a944: eb000733 bl 3000c618 <_Objects_Get> <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 3000a948: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3000a94c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000a950: e3550000 cmp r5, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000a954: 13a00004 movne r0, #4 <== NOT EXECUTED { Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 3000a958: 1a00000a bne 3000a988 <== NOT EXECUTED case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 3000a95c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000a960: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 3000a964: e2840054 add r0, r4, #84 ; 0x54 <== NOT EXECUTED 3000a968: eb001fc9 bl 30012894 <== NOT EXECUTED 3000a96c: e3e03102 mvn r3, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000a970: e584305c str r3, [r4, #92] ; 0x5c <== NOT EXECUTED 3000a974: e5843060 str r3, [r4, #96] ; 0x60 <== NOT EXECUTED 3000a978: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED 3000a97c: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED _Thread_Enable_dispatch(); 3000a980: eb000a3e bl 3000d280 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000a984: e1a00005 mov r0, r5 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000a988: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 30016bdc : uintptr_t length, uintptr_t page_size, rtems_attribute attribute_set, rtems_id *id ) { 30016bdc: 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 ) ) 30016be0: e2509000 subs r9, r0, #0 uintptr_t length, uintptr_t page_size, rtems_attribute attribute_set, rtems_id *id ) { 30016be4: e1a06001 mov r6, r1 30016be8: e1a07002 mov r7, r2 30016bec: e1a08003 mov r8, r3 30016bf0: e59da024 ldr sl, [sp, #36] ; 0x24 30016bf4: 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; 30016bf8: 03a06003 moveq r6, #3 ) { rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 30016bfc: 0a000031 beq 30016cc8 return RTEMS_INVALID_NAME; if ( !starting_address ) 30016c00: e3560000 cmp r6, #0 30016c04: 0a00002e beq 30016cc4 return RTEMS_INVALID_ADDRESS; if ( !id ) 30016c08: e35b0000 cmp fp, #0 30016c0c: 0a00002c beq 30016cc4 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 30016c10: e59f30b8 ldr r3, [pc, #184] ; 30016cd0 * 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 ); 30016c14: e59f50b8 ldr r5, [pc, #184] ; 30016cd4 30016c18: e5930000 ldr r0, [r3] 30016c1c: eb00091a bl 3001908c <_API_Mutex_Lock> 30016c20: e1a00005 mov r0, r5 30016c24: eb000f09 bl 3001a850 <_Objects_Allocate> the_region = _Region_Allocate(); if ( !the_region ) 30016c28: e2504000 subs r4, r0, #0 return_status = RTEMS_TOO_MANY; 30016c2c: 03a06005 moveq r6, #5 _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Allocate(); if ( !the_region ) 30016c30: 0a00001f beq 30016cb4 return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 30016c34: e2840068 add r0, r4, #104 ; 0x68 30016c38: e1a01006 mov r1, r6 30016c3c: e1a02007 mov r2, r7 30016c40: e1a03008 mov r3, r8 30016c44: eb000de4 bl 3001a3dc <_Heap_Initialize> &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 30016c48: e3500000 cmp r0, #0 if ( !the_region ) return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 30016c4c: e584005c str r0, [r4, #92] ; 0x5c &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 30016c50: 1a000004 bne 30016c68 */ RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 30016c54: e1a00005 mov r0, r5 <== NOT EXECUTED 30016c58: e1a01004 mov r1, r4 <== NOT EXECUTED 30016c5c: eb000fc2 bl 3001ab6c <_Objects_Free> <== NOT EXECUTED _Region_Free( the_region ); return_status = RTEMS_INVALID_SIZE; 30016c60: e3a06008 mov r6, #8 <== NOT EXECUTED 30016c64: ea000012 b 30016cb4 <== NOT EXECUTED } else { the_region->starting_address = starting_address; 30016c68: 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( 30016c6c: 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; 30016c70: e3a06000 mov r6, #0 _Thread_queue_Initialize( 30016c74: 03a01000 moveq r1, #0 30016c78: 13a01001 movne r1, #1 30016c7c: e3a02040 mov r2, #64 ; 0x40 30016c80: e3a03006 mov r3, #6 } else { the_region->starting_address = starting_address; the_region->length = length; 30016c84: e5847054 str r7, [r4, #84] ; 0x54 the_region->page_size = page_size; 30016c88: e5848058 str r8, [r4, #88] ; 0x58 the_region->attribute_set = attribute_set; 30016c8c: e584a060 str sl, [r4, #96] ; 0x60 the_region->number_of_used_blocks = 0; 30016c90: e5846064 str r6, [r4, #100] ; 0x64 _Thread_queue_Initialize( 30016c94: e2840010 add r0, r4, #16 30016c98: eb0014ef bl 3001c05c <_Thread_queue_Initialize> #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30016c9c: e595201c ldr r2, [r5, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 30016ca0: e5943008 ldr r3, [r4, #8] 30016ca4: e1d410b8 ldrh r1, [r4, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30016ca8: e7824101 str r4, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 30016cac: e584900c str r9, [r4, #12] &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 30016cb0: e58b3000 str r3, [fp] return_status = RTEMS_SUCCESSFUL; } } _RTEMS_Unlock_allocator(); 30016cb4: e59f3014 ldr r3, [pc, #20] ; 30016cd0 30016cb8: e5930000 ldr r0, [r3] 30016cbc: eb00090b bl 300190f0 <_API_Mutex_Unlock> return return_status; 30016cc0: ea000000 b 30016cc8 if ( !starting_address ) return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; 30016cc4: e3a06009 mov r6, #9 <== NOT EXECUTED } } _RTEMS_Unlock_allocator(); return return_status; } 30016cc8: e1a00006 mov r0, r6 30016ccc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} =============================================================================== 30016d54 : rtems_status_code rtems_region_extend( rtems_id id, void *starting_address, uintptr_t length ) { 30016d54: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr} <== NOT EXECUTED bool extend_ok; Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; if ( !starting_address ) 30016d58: e2517000 subs r7, r1, #0 <== NOT EXECUTED rtems_status_code rtems_region_extend( rtems_id id, void *starting_address, uintptr_t length ) { 30016d5c: e1a04000 mov r4, r0 <== NOT EXECUTED 30016d60: 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; 30016d64: 03a05009 moveq r5, #9 <== NOT EXECUTED bool extend_ok; Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; if ( !starting_address ) 30016d68: 0a00001d beq 30016de4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 30016d6c: e59f3078 ldr r3, [pc, #120] ; 30016dec <== NOT EXECUTED 30016d70: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016d74: eb0008c4 bl 3001908c <_API_Mutex_Lock> <== NOT EXECUTED Objects_Id id, Objects_Locations *location ) { return (Region_Control *) _Objects_Get_no_protection( &_Region_Information, id, location ); 30016d78: e1a01004 mov r1, r4 <== NOT EXECUTED 30016d7c: e59f006c ldr r0, [pc, #108] ; 30016df0 <== NOT EXECUTED 30016d80: e1a0200d mov r2, sp <== NOT EXECUTED 30016d84: eb000fcd bl 3001acc0 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 30016d88: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30016d8c: e1a04000 mov r4, r0 <== NOT EXECUTED 30016d90: e3550000 cmp r5, #0 <== NOT EXECUTED break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 30016d94: 13a05004 movne r5, #4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 30016d98: 1a00000e bne 30016dd8 <== NOT EXECUTED case OBJECTS_LOCAL: extend_ok = _Heap_Extend( 30016d9c: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30016da0: e1a01007 mov r1, r7 <== NOT EXECUTED 30016da4: e1a02006 mov r2, r6 <== NOT EXECUTED 30016da8: e28d3004 add r3, sp, #4 <== NOT EXECUTED 30016dac: eb000bc7 bl 30019cd0 <_Heap_Extend> <== NOT EXECUTED starting_address, length, &amount_extended ); if ( extend_ok ) { 30016db0: 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; 30016db4: 03a05009 moveq r5, #9 <== NOT EXECUTED starting_address, length, &amount_extended ); if ( extend_ok ) { 30016db8: 0a000006 beq 30016dd8 <== NOT EXECUTED the_region->length += amount_extended; 30016dbc: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30016dc0: e5942054 ldr r2, [r4, #84] ; 0x54 <== NOT EXECUTED 30016dc4: e0822003 add r2, r2, r3 <== NOT EXECUTED 30016dc8: e5842054 str r2, [r4, #84] ; 0x54 <== NOT EXECUTED the_region->maximum_segment_size += amount_extended; 30016dcc: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED 30016dd0: e0823003 add r3, r2, r3 <== NOT EXECUTED 30016dd4: e584305c str r3, [r4, #92] ; 0x5c <== NOT EXECUTED default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30016dd8: e59f300c ldr r3, [pc, #12] ; 30016dec <== NOT EXECUTED 30016ddc: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016de0: eb0008c2 bl 300190f0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 30016de4: e1a00005 mov r0, r5 <== NOT EXECUTED 30016de8: e8bd80fc pop {r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 30016df4 : rtems_status_code rtems_region_get_free_information( rtems_id id, Heap_Information_block *the_info ) { 30016df4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) 30016df8: e2514000 subs r4, r1, #0 <== NOT EXECUTED rtems_status_code rtems_region_get_free_information( rtems_id id, Heap_Information_block *the_info ) { 30016dfc: 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; 30016e00: 03a05009 moveq r5, #9 <== NOT EXECUTED { Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) 30016e04: 0a000013 beq 30016e58 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 30016e08: e59f3050 ldr r3, [pc, #80] ; 30016e60 <== NOT EXECUTED 30016e0c: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016e10: eb00089d bl 3001908c <_API_Mutex_Lock> <== NOT EXECUTED 30016e14: e1a01005 mov r1, r5 <== NOT EXECUTED 30016e18: e59f0044 ldr r0, [pc, #68] ; 30016e64 <== NOT EXECUTED 30016e1c: e1a0200d mov r2, sp <== NOT EXECUTED 30016e20: eb000fa6 bl 3001acc0 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 30016e24: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30016e28: e3550000 cmp r5, #0 <== NOT EXECUTED break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 30016e2c: 13a05004 movne r5, #4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 30016e30: 1a000005 bne 30016e4c <== NOT EXECUTED case OBJECTS_LOCAL: the_info->Used.number = 0; 30016e34: e584500c str r5, [r4, #12] <== NOT EXECUTED the_info->Used.total = 0; 30016e38: e5845014 str r5, [r4, #20] <== NOT EXECUTED the_info->Used.largest = 0; 30016e3c: e5845010 str r5, [r4, #16] <== NOT EXECUTED _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); 30016e40: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30016e44: e1a01004 mov r1, r4 <== NOT EXECUTED 30016e48: eb000cce bl 3001a188 <_Heap_Get_free_information> <== NOT EXECUTED default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30016e4c: e59f300c ldr r3, [pc, #12] ; 30016e60 <== NOT EXECUTED 30016e50: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016e54: eb0008a5 bl 300190f0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 30016e58: e1a00005 mov r0, r5 <== NOT EXECUTED 30016e5c: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 30016e68 : rtems_status_code rtems_region_get_information( rtems_id id, Heap_Information_block *the_info ) { 30016e68: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) 30016e6c: e2514000 subs r4, r1, #0 <== NOT EXECUTED rtems_status_code rtems_region_get_information( rtems_id id, Heap_Information_block *the_info ) { 30016e70: 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; 30016e74: 03a05009 moveq r5, #9 <== NOT EXECUTED { Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) 30016e78: 0a00000f beq 30016ebc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 30016e7c: e59f3040 ldr r3, [pc, #64] ; 30016ec4 <== NOT EXECUTED 30016e80: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016e84: eb000880 bl 3001908c <_API_Mutex_Lock> <== NOT EXECUTED 30016e88: e1a01005 mov r1, r5 <== NOT EXECUTED 30016e8c: e59f0034 ldr r0, [pc, #52] ; 30016ec8 <== NOT EXECUTED 30016e90: e1a0200d mov r2, sp <== NOT EXECUTED 30016e94: eb000f89 bl 3001acc0 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 30016e98: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30016e9c: e3550000 cmp r5, #0 <== NOT EXECUTED break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 30016ea0: 13a05004 movne r5, #4 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: _Heap_Get_information( &the_region->Memory, the_info ); 30016ea4: 02800068 addeq r0, r0, #104 ; 0x68 <== NOT EXECUTED 30016ea8: 01a01004 moveq r1, r4 <== NOT EXECUTED 30016eac: 0b000cca bleq 3001a1dc <_Heap_Get_information> <== NOT EXECUTED default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30016eb0: e59f300c ldr r3, [pc, #12] ; 30016ec4 <== NOT EXECUTED 30016eb4: e5930000 ldr r0, [r3] <== NOT EXECUTED 30016eb8: eb00088c bl 300190f0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 30016ebc: e1a00005 mov r0, r5 <== NOT EXECUTED 30016ec0: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 30016ff8 : rtems_status_code rtems_region_get_segment_size( rtems_id id, void *segment, uintptr_t *size ) { 30016ff8: 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 ) 30016ffc: e2515000 subs r5, r1, #0 <== NOT EXECUTED rtems_status_code rtems_region_get_segment_size( rtems_id id, void *segment, uintptr_t *size ) { 30017000: e1a06000 mov r6, r0 <== NOT EXECUTED 30017004: e1a04002 mov r4, r2 <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_SUCCESSFUL; register Region_Control *the_region; if ( !segment ) 30017008: 0a000019 beq 30017074 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 3001700c: e3520000 cmp r2, #0 <== NOT EXECUTED 30017010: 0a000017 beq 30017074 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 30017014: e59f3064 ldr r3, [pc, #100] ; 30017080 <== NOT EXECUTED 30017018: e5930000 ldr r0, [r3] <== NOT EXECUTED 3001701c: eb00081a bl 3001908c <_API_Mutex_Lock> <== NOT EXECUTED 30017020: e59f005c ldr r0, [pc, #92] ; 30017084 <== NOT EXECUTED 30017024: e1a01006 mov r1, r6 <== NOT EXECUTED 30017028: e1a0200d mov r2, sp <== NOT EXECUTED 3001702c: eb000f23 bl 3001acc0 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 30017030: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30017034: e3530000 cmp r3, #0 <== NOT EXECUTED 30017038: 0a000002 beq 30017048 <== NOT EXECUTED void *segment, uintptr_t *size ) { Objects_Locations location; rtems_status_code return_status = RTEMS_SUCCESSFUL; 3001703c: e3530001 cmp r3, #1 <== NOT EXECUTED 30017040: 03a04004 moveq r4, #4 <== NOT EXECUTED 30017044: ea000005 b 30017060 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) ) 30017048: e1a02004 mov r2, r4 <== NOT EXECUTED 3001704c: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017050: e1a01005 mov r1, r5 <== NOT EXECUTED 30017054: eb000dc0 bl 3001a75c <_Heap_Size_of_alloc_area> <== NOT EXECUTED void *segment, uintptr_t *size ) { Objects_Locations location; rtems_status_code return_status = RTEMS_SUCCESSFUL; 30017058: e3500000 cmp r0, #0 <== NOT EXECUTED 3001705c: 03a04009 moveq r4, #9 <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30017060: e59f3018 ldr r3, [pc, #24] ; 30017080 <== NOT EXECUTED void *segment, uintptr_t *size ) { Objects_Locations location; rtems_status_code return_status = RTEMS_SUCCESSFUL; 30017064: 13a04000 movne r4, #0 <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30017068: e5930000 ldr r0, [r3] <== NOT EXECUTED 3001706c: eb00081f bl 300190f0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; 30017070: ea000000 b 30017078 <== NOT EXECUTED if ( !segment ) return RTEMS_INVALID_ADDRESS; if ( !size ) return RTEMS_INVALID_ADDRESS; 30017074: e3a04009 mov r4, #9 <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 30017078: e1a00004 mov r0, r4 <== NOT EXECUTED 3001707c: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED =============================================================================== 300170b8 : rtems_id id, void *segment, uintptr_t size, uintptr_t *old_size ) { 300170b8: 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 ) 300170bc: e2538000 subs r8, r3, #0 <== NOT EXECUTED rtems_id id, void *segment, uintptr_t size, uintptr_t *old_size ) { 300170c0: e1a05000 mov r5, r0 <== NOT EXECUTED 300170c4: e1a07001 mov r7, r1 <== NOT EXECUTED 300170c8: 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; 300170cc: 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 ) 300170d0: 0a000022 beq 30017160 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 300170d4: e59f408c ldr r4, [pc, #140] ; 30017168 <== NOT EXECUTED 300170d8: e5940000 ldr r0, [r4] <== NOT EXECUTED 300170dc: eb0007ea bl 3001908c <_API_Mutex_Lock> <== NOT EXECUTED 300170e0: e1a01005 mov r1, r5 <== NOT EXECUTED 300170e4: e59f0080 ldr r0, [pc, #128] ; 3001716c <== NOT EXECUTED 300170e8: e28d2008 add r2, sp, #8 <== NOT EXECUTED 300170ec: eb000ef3 bl 3001acc0 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 300170f0: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 300170f4: e1a05000 mov r5, r0 <== NOT EXECUTED 300170f8: e3530000 cmp r3, #0 <== NOT EXECUTED 300170fc: 1a000014 bne 30017154 <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 30017100: e28d300c add r3, sp, #12 <== NOT EXECUTED 30017104: e58d3000 str r3, [sp] <== NOT EXECUTED 30017108: e1a02006 mov r2, r6 <== NOT EXECUTED 3001710c: e28d3004 add r3, sp, #4 <== NOT EXECUTED 30017110: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017114: e1a01007 mov r1, r7 <== NOT EXECUTED 30017118: eb000d42 bl 3001a628 <_Heap_Resize_block> <== NOT EXECUTED segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 3001711c: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) 30017120: e2506000 subs r6, r0, #0 <== NOT EXECUTED segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 30017124: e5883000 str r3, [r8] <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) 30017128: 1a000003 bne 3001713c <== NOT EXECUTED _Region_Process_queue( the_region ); /* unlocks allocator */ 3001712c: e1a00005 mov r0, r5 <== NOT EXECUTED 30017130: eb001d4d bl 3001e66c <_Region_Process_queue> <== NOT EXECUTED else _RTEMS_Unlock_allocator(); if (status == HEAP_RESIZE_SUCCESSFUL) return RTEMS_SUCCESSFUL; 30017134: e1a00006 mov r0, r6 <== NOT EXECUTED 30017138: ea000008 b 30017160 <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 3001713c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017140: eb0007ea bl 300190f0 <_API_Mutex_Unlock> <== NOT EXECUTED if (status == HEAP_RESIZE_SUCCESSFUL) return RTEMS_SUCCESSFUL; if (status == HEAP_RESIZE_UNSATISFIED) return RTEMS_UNSATISFIED; 30017144: e3560001 cmp r6, #1 <== NOT EXECUTED 30017148: 13a00009 movne r0, #9 <== NOT EXECUTED 3001714c: 03a0000d moveq r0, #13 <== NOT EXECUTED 30017150: ea000002 b 30017160 <== NOT EXECUTED default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 30017154: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017158: eb0007e4 bl 300190f0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; 3001715c: e3a00004 mov r0, #4 <== NOT EXECUTED } 30017160: e28dd010 add sp, sp, #16 <== NOT EXECUTED 30017164: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 30017170 : rtems_status_code rtems_region_return_segment( rtems_id id, void *segment ) { 30017170: e92d4071 push {r0, r4, r5, r6, lr} uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 30017174: e59f3074 ldr r3, [pc, #116] ; 300171f0 rtems_status_code rtems_region_return_segment( rtems_id id, void *segment ) { 30017178: e1a05000 mov r5, r0 uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 3001717c: e5930000 ldr r0, [r3] rtems_status_code rtems_region_return_segment( rtems_id id, void *segment ) { 30017180: e1a04001 mov r4, r1 uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 30017184: eb0007c0 bl 3001908c <_API_Mutex_Lock> 30017188: e1a01005 mov r1, r5 3001718c: e59f0060 ldr r0, [pc, #96] ; 300171f4 30017190: e1a0200d mov r2, sp 30017194: eb000ec9 bl 3001acc0 <_Objects_Get_no_protection> the_region = _Region_Get( id, &location ); switch ( location ) { 30017198: e59d6000 ldr r6, [sp] 3001719c: e1a05000 mov r5, r0 300171a0: e3560000 cmp r6, #0 break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 300171a4: 13a06004 movne r6, #4 register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 300171a8: 1a00000b bne 300171dc RTEMS_INLINE_ROUTINE bool _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 300171ac: e2800068 add r0, r0, #104 ; 0x68 300171b0: e1a01004 mov r1, r4 300171b4: eb000b77 bl 30019f98 <_Heap_Free> #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 300171b8: e3500000 cmp r0, #0 return_status = RTEMS_INVALID_ADDRESS; 300171bc: 03a06009 moveq r6, #9 #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 300171c0: 0a000005 beq 300171dc return_status = RTEMS_INVALID_ADDRESS; else { the_region->number_of_used_blocks -= 1; 300171c4: e5953064 ldr r3, [r5, #100] ; 0x64 _Region_Process_queue(the_region); /* unlocks allocator */ 300171c8: 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; 300171cc: e2433001 sub r3, r3, #1 300171d0: e5853064 str r3, [r5, #100] ; 0x64 _Region_Process_queue(the_region); /* unlocks allocator */ 300171d4: eb001d24 bl 3001e66c <_Region_Process_queue> return RTEMS_SUCCESSFUL; 300171d8: ea000002 b 300171e8 default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 300171dc: e59f300c ldr r3, [pc, #12] ; 300171f0 <== NOT EXECUTED 300171e0: e5930000 ldr r0, [r3] <== NOT EXECUTED 300171e4: eb0007c1 bl 300190f0 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 300171e8: e1a00006 mov r0, r6 300171ec: e8bd8078 pop {r3, r4, r5, r6, pc} =============================================================================== 30009258 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 30009258: 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 ) ) 3000925c: e2507000 subs r7, r0, #0 uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 30009260: e24dd018 sub sp, sp, #24 30009264: e1a04001 mov r4, r1 30009268: e1a08002 mov r8, r2 3000926c: e1a09003 mov r9, r3 30009270: 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; 30009274: 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 ) ) 30009278: 0a00005d beq 300093f4 return RTEMS_INVALID_NAME; if ( !id ) 3000927c: e3560000 cmp r6, #0 return RTEMS_INVALID_ADDRESS; 30009280: 03a00009 moveq r0, #9 CORE_mutex_Status mutex_status; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 30009284: 0a00005a beq 300093f4 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 30009288: e21230c0 ands r3, r2, #192 ; 0xc0 3000928c: 0a000006 beq 300092ac */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE); 30009290: e2022030 and r2, r2, #48 ; 0x30 _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) && 30009294: e3520010 cmp r2, #16 30009298: 1a000054 bne 300093f0 3000929c: e3180004 tst r8, #4 300092a0: 0a000052 beq 300093f0 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 300092a4: e35300c0 cmp r3, #192 ; 0xc0 300092a8: 0a000050 beq 300093f0 _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 300092ac: e218a030 ands sl, r8, #48 ; 0x30 300092b0: 0a000002 beq 300092c0 300092b4: e3540001 cmp r4, #1 return RTEMS_INVALID_NUMBER; 300092b8: 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 ) ) 300092bc: 8a00004c bhi 300093f4 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 300092c0: e59f3134 ldr r3, [pc, #308] ; 300093fc 300092c4: e5932000 ldr r2, [r3] 300092c8: e2822001 add r2, r2, #1 300092cc: 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 ); 300092d0: e59f0128 ldr r0, [pc, #296] ; 30009400 300092d4: eb000508 bl 3000a6fc <_Objects_Allocate> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 300092d8: e2505000 subs r5, r0, #0 300092dc: 1a000002 bne 300092ec _Thread_Enable_dispatch(); 300092e0: eb00093b bl 3000b7d4 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 300092e4: e3a00005 mov r0, #5 300092e8: ea000041 b 300093f4 the_semaphore->attribute_set = attribute_set; /* * Initialize it as a counting semaphore. */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { 300092ec: e35a0000 cmp sl, #0 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_semaphore->attribute_set = attribute_set; 300092f0: e5858010 str r8, [r5, #16] 300092f4: e2083004 and r3, r8, #4 /* * Initialize it as a counting semaphore. */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { 300092f8: 1a00000d bne 30009334 /* * This effectively disables limit checking. */ the_semaphore_attr.maximum_count = 0xFFFFFFFF; if ( _Attributes_Is_priority( attribute_set ) ) 300092fc: e3530000 cmp r3, #0 the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 30009300: 13a03001 movne r3, #1 */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { /* * This effectively disables limit checking. */ the_semaphore_attr.maximum_count = 0xFFFFFFFF; 30009304: e3e02000 mvn r2, #0 30009308: e58d2010 str r2, [sp, #16] if ( _Attributes_Is_priority( attribute_set ) ) the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 3000930c: 158d3014 strne r3, [sp, #20] * 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( 30009310: e2850014 add r0, r5, #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; 30009314: e3a03000 mov r3, #0 the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM; _CORE_semaphore_Initialize( 30009318: e28d1010 add r1, sp, #16 3000931c: e1a02004 mov r2, r4 the_semaphore_attr.maximum_count = 0xFFFFFFFF; if ( _Attributes_Is_priority( attribute_set ) ) the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; else the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; 30009320: 058da014 streq sl, [sp, #20] /* * The following are just to make Purify happy. */ the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 30009324: e58d3000 str r3, [sp] the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM; 30009328: e58d300c str r3, [sp, #12] _CORE_semaphore_Initialize( 3000932c: eb000380 bl 3000a134 <_CORE_semaphore_Initialize> 30009330: ea000024 b 300093c8 } else { /* * 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 ) ) 30009334: e3530000 cmp r3, #0 the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 30009338: 13a03001 movne r3, #1 else the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 3000933c: e35a0010 cmp sl, #16 * style binary semaphore. This is the mutex style. */ if ( _Attributes_Is_priority( attribute_set ) ) the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO; 30009340: e58d3008 str r3, [sp, #8] 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; 30009344: 13a03001 movne r3, #1 30009348: 158d3000 strne r3, [sp] the_mutex_attr.only_owner_release = false; 3000934c: 13a03000 movne r3, #0 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 ) ) { 30009350: 1a00000d bne 3000938c the_mutex_attr.priority_ceiling = priority_ceiling; the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 30009354: e3a03000 mov r3, #0 30009358: e58d3000 str r3, [sp] the_mutex_attr.only_owner_release = false; 3000935c: e5cd3004 strb r3, [sp, #4] if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) { 30009360: e59d3008 ldr r3, [sp, #8] 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; 30009364: e58d900c str r9, [sp, #12] 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 ) { 30009368: e3530001 cmp r3, #1 3000936c: 1a000007 bne 30009390 if ( _Attributes_Is_inherit_priority( attribute_set ) ) { 30009370: e3180040 tst r8, #64 ; 0x40 the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 30009374: 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 ) ) { 30009378: 1a000002 bne 30009388 the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; the_mutex_attr.only_owner_release = true; } else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) { 3000937c: e3180080 tst r8, #128 ; 0x80 30009380: 0a000002 beq 30009390 the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 30009384: e3a02003 mov r2, #3 30009388: e58d2008 str r2, [sp, #8] the_mutex_attr.only_owner_release = true; } } } else /* must be simple binary semaphore */ { the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; the_mutex_attr.only_owner_release = false; 3000938c: e5cd3004 strb r3, [sp, #4] } mutex_status = _CORE_mutex_Initialize( 30009390: e3540001 cmp r4, #1 30009394: 13a02000 movne r2, #0 30009398: 03a02001 moveq r2, #1 3000939c: e2850014 add r0, r5, #20 300093a0: e1a0100d mov r1, sp 300093a4: eb0002a4 bl 30009e3c <_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 ) { 300093a8: e3500005 cmp r0, #5 300093ac: 1a000005 bne 300093c8 */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 300093b0: e59f0048 ldr r0, [pc, #72] ; 30009400 300093b4: e1a01005 mov r1, r5 300093b8: eb000596 bl 3000aa18 <_Objects_Free> _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 300093bc: eb000904 bl 3000b7d4 <_Thread_Enable_dispatch> return RTEMS_INVALID_PRIORITY; 300093c0: e3a00013 mov r0, #19 300093c4: ea00000a b 300093f4 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300093c8: e59f2030 ldr r2, [pc, #48] ; 30009400 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 300093cc: e5953008 ldr r3, [r5, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300093d0: e592201c ldr r2, [r2, #28] Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 300093d4: e1d510b8 ldrh r1, [r5, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 300093d8: e7825101 str r5, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 300093dc: e585700c str r7, [r5, #12] &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 300093e0: e5863000 str r3, [r6] the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 300093e4: eb0008fa bl 3000b7d4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 300093e8: e3a00000 mov r0, #0 300093ec: ea000000 b 300093f4 } if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; 300093f0: e3a0000b mov r0, #11 <== NOT EXECUTED 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 300093f4: e28dd018 add sp, sp, #24 300093f8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} =============================================================================== 30009404 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 30009404: e92d4011 push {r0, r4, lr} 30009408: e1a01000 mov r1, r0 Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) _Objects_Get( &_Semaphore_Information, id, location ); 3000940c: e1a0200d mov r2, sp 30009410: e59f0084 ldr r0, [pc, #132] ; 3000949c 30009414: eb0005d4 bl 3000ab6c <_Objects_Get> register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 30009418: e59d3000 ldr r3, [sp] 3000941c: e1a04000 mov r4, r0 30009420: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30009424: 13a00004 movne r0, #4 { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 30009428: 1a00001a bne 30009498 */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 3000942c: e5941010 ldr r1, [r4, #16] case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 30009430: e2111030 ands r1, r1, #48 ; 0x30 30009434: 0a00000c beq 3000946c if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 30009438: e5943064 ldr r3, [r4, #100] ; 0x64 3000943c: e3530000 cmp r3, #0 30009440: 1a000004 bne 30009458 30009444: e3510020 cmp r1, #32 30009448: 0a000002 beq 30009458 !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 3000944c: eb0008e0 bl 3000b7d4 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_RESOURCE_IN_USE; 30009450: e3a0000c mov r0, #12 <== NOT EXECUTED 30009454: ea00000f b 30009498 <== NOT EXECUTED } _CORE_mutex_Flush( 30009458: e2840014 add r0, r4, #20 3000945c: e3a01000 mov r1, #0 30009460: e3a02003 mov r2, #3 30009464: eb000273 bl 30009e38 <_CORE_mutex_Flush> 30009468: ea000002 b 30009478 &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 3000946c: e2840014 add r0, r4, #20 30009470: e3a02002 mov r2, #2 30009474: eb00032d bl 3000a130 <_CORE_semaphore_Flush> SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_SEMAPHORE_WAS_DELETED ); } _Objects_Close( &_Semaphore_Information, &the_semaphore->Object ); 30009478: e59f001c ldr r0, [pc, #28] ; 3000949c 3000947c: e1a01004 mov r1, r4 30009480: eb0004bf bl 3000a784 <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 30009484: e59f0010 ldr r0, [pc, #16] ; 3000949c 30009488: e1a01004 mov r1, r4 3000948c: eb000561 bl 3000aa18 <_Objects_Free> 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 30009490: eb0008cf bl 3000b7d4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30009494: e3a00000 mov r0, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30009498: e8bd8018 pop {r3, r4, pc} =============================================================================== 30011f9c : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 30011f9c: e92d4001 push {r0, lr} 30011fa0: e1a01000 mov r1, r0 30011fa4: e1a0200d mov r2, sp 30011fa8: e59f0044 ldr r0, [pc, #68] ; 30011ff4 30011fac: ebffe831 bl 3000c078 <_Objects_Get> register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 30011fb0: e59d3000 ldr r3, [sp] 30011fb4: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30011fb8: 13a00004 movne r0, #4 { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 30011fbc: 1a00000b bne 30011ff0 */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 30011fc0: e5901010 ldr r1, [r0, #16] 30011fc4: e2800014 add r0, r0, #20 case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 30011fc8: e2111030 ands r1, r1, #48 ; 0x30 30011fcc: 0a000003 beq 30011fe0 _CORE_mutex_Flush( 30011fd0: e1a01003 mov r1, r3 30011fd4: e3a02001 mov r2, #1 30011fd8: ebffe4d9 bl 3000b344 <_CORE_mutex_Flush> 30011fdc: ea000001 b 30011fe8 &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 30011fe0: e3a02001 mov r2, #1 <== NOT EXECUTED 30011fe4: ebffe594 bl 3000b63c <_CORE_semaphore_Flush> <== NOT EXECUTED &the_semaphore->Core_control.semaphore, SEND_OBJECT_WAS_DELETED, CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT ); } _Thread_Enable_dispatch(); 30011fe8: ebffeb40 bl 3000ccf0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30011fec: e3a00000 mov r0, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30011ff0: e8bd8008 pop {r3, pc} =============================================================================== 300094a0 : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 300094a0: e92d40f7 push {r0, r1, r2, r4, r5, r6, r7, lr} 300094a4: e1a04000 mov r4, r0 Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) _Objects_Get_isr_disable( &_Semaphore_Information, id, location, level ); 300094a8: e28d3004 add r3, sp, #4 300094ac: e1a06001 mov r6, r1 300094b0: e1a05002 mov r5, r2 300094b4: e59f00ec ldr r0, [pc, #236] ; 300095a8 300094b8: e1a01004 mov r1, r4 300094bc: e28d2008 add r2, sp, #8 300094c0: eb00058f bl 3000ab04 <_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 ) { 300094c4: e59d3008 ldr r3, [sp, #8] 300094c8: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 300094cc: 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 ) { 300094d0: 1a000033 bne 300095a4 300094d4: e5903010 ldr r3, [r0, #16] 300094d8: e59f70cc ldr r7, [pc, #204] ; 300095ac case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 300094dc: e2132030 ands r2, r3, #48 ; 0x30 300094e0: 0a00000b beq 30009514 _CORE_mutex_Seize( 300094e4: e59d3004 ldr r3, [sp, #4] */ RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait ( rtems_option option_set ) { return (option_set & RTEMS_NO_WAIT) ? true : false; 300094e8: e2062001 and r2, r6, #1 300094ec: e58d3000 str r3, [sp] 300094f0: e2800014 add r0, r0, #20 300094f4: e1a03005 mov r3, r5 300094f8: e1a01004 mov r1, r4 300094fc: e2222001 eor r2, r2, #1 30009500: eb000294 bl 30009f58 <_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 ); 30009504: e5973004 ldr r3, [r7, #4] id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 30009508: e5930034 ldr r0, [r3, #52] ; 0x34 3000950c: eb000047 bl 30009630 <_Semaphore_Translate_core_mutex_return_code> 30009510: ea000023 b 300095a4 { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 30009514: e5973004 ldr r3, [r7, #4] executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 30009518: e5832034 str r2, [r3, #52] ; 0x34 if ( the_semaphore->count != 0 ) { 3000951c: e590205c ldr r2, [r0, #92] ; 0x5c 30009520: e3520000 cmp r2, #0 30009524: 0a000004 beq 3000953c the_semaphore->count -= 1; 30009528: e2422001 sub r2, r2, #1 3000952c: e580205c str r2, [r0, #92] ; 0x5c 30009530: e59d3004 ldr r3, [sp, #4] 30009534: e129f003 msr CPSR_fc, r3 30009538: ea000015 b 30009594 _ISR_Enable( *level_p ); return; } if ( !wait ) { 3000953c: e3160001 tst r6, #1 30009540: 0a000004 beq 30009558 30009544: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 30009548: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED _ISR_Enable( *level_p ); executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 3000954c: e3a02001 mov r2, #1 <== NOT EXECUTED 30009550: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED 30009554: ea00000e b 30009594 <== NOT EXECUTED 30009558: e59f2050 ldr r2, [pc, #80] ; 300095b0 3000955c: e5921000 ldr r1, [r2] 30009560: e2811001 add r1, r1, #1 30009564: 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; 30009568: e3a02001 mov r2, #1 3000956c: 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; 30009570: e2800014 add r0, r0, #20 30009574: e5830044 str r0, [r3, #68] ; 0x44 executing->Wait.id = id; 30009578: e5834020 str r4, [r3, #32] 3000957c: e59d3004 ldr r3, [sp, #4] 30009580: e129f003 msr CPSR_fc, r3 _ISR_Enable( *level_p ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 30009584: e59f2028 ldr r2, [pc, #40] ; 300095b4 30009588: e1a01005 mov r1, r5 3000958c: eb0009a9 bl 3000bc38 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 30009590: eb00088f bl 3000b7d4 <_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 ); 30009594: e59f3010 ldr r3, [pc, #16] ; 300095ac 30009598: e5933004 ldr r3, [r3, #4] id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 3000959c: e5930034 ldr r0, [r3, #52] ; 0x34 300095a0: eb000026 bl 30009640 <_Semaphore_Translate_core_semaphore_return_code> break; } return RTEMS_INVALID_ID; } 300095a4: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc} =============================================================================== 30015c60 : void rtems_shutdown_executive( uint32_t result ) { if ( _System_state_Is_up( _System_state_Get() ) ) { 30015c60: e59f3028 ldr r3, [pc, #40] ; 30015c90 */ void rtems_shutdown_executive( uint32_t result ) { 30015c64: e52de004 push {lr} ; (str lr, [sp, #-4]!) if ( _System_state_Is_up( _System_state_Get() ) ) { 30015c68: e5932000 ldr r2, [r3] 30015c6c: e3520003 cmp r2, #3 30015c70: 02822001 addeq r2, r2, #1 30015c74: 05832000 streq 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 ); 30015c78: 059f0014 ldreq r0, [pc, #20] ; 30015c94 30015c7c: 0bffdbca bleq 3000cbac <_CPU_Context_restore> _System_state_Set( SYSTEM_STATE_SHUTDOWN ); _Thread_Stop_multitasking(); } _Internal_error_Occurred( 30015c80: e3a00000 mov r0, #0 <== NOT EXECUTED 30015c84: e3a01001 mov r1, #1 <== NOT EXECUTED 30015c88: e3a02014 mov r2, #20 <== NOT EXECUTED 30015c8c: ebffd283 bl 3000a6a0 <_Internal_error_Occurred> <== NOT EXECUTED =============================================================================== 30017684 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 30017684: e92d4011 push {r0, r4, lr} register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 30017688: e2514000 subs r4, r1, #0 return RTEMS_INVALID_NUMBER; 3001768c: 03a0000a moveq r0, #10 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 30017690: 0a000028 beq 30017738 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 30017694: e1a0100d mov r1, sp 30017698: eb0010bb bl 3001b98c <_Thread_Get> switch ( location ) { 3001769c: e59d3000 ldr r3, [sp] 300176a0: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 300176a4: 13a00004 movne r0, #4 if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); switch ( location ) { 300176a8: 1a000022 bne 30017738 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 300176ac: e59030f4 ldr r3, [r0, #244] ; 0xf4 asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 300176b0: e593200c ldr r2, [r3, #12] 300176b4: e3520000 cmp r2, #0 300176b8: 0a00001c beq 30017730 if ( asr->is_enabled ) { 300176bc: e5d32008 ldrb r2, [r3, #8] 300176c0: e3520000 cmp r2, #0 300176c4: 0a00000f beq 30017708 static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 300176c8: e10f2000 mrs r2, CPSR 300176cc: e3821080 orr r1, r2, #128 ; 0x80 300176d0: e129f001 msr CPSR_fc, r1 ) { ISR_Level _level; _ISR_Disable( _level ); *signal_set |= signals; 300176d4: e5931014 ldr r1, [r3, #20] 300176d8: e1814004 orr r4, r1, r4 300176dc: e5834014 str r4, [r3, #20] static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 300176e0: e129f002 msr CPSR_fc, r2 _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 300176e4: e59f3050 ldr r3, [pc, #80] ; 3001773c 300176e8: e5932000 ldr r2, [r3] 300176ec: e3520000 cmp r2, #0 300176f0: 0a00000b beq 30017724 300176f4: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 300176f8: e1500002 cmp r0, r2 <== NOT EXECUTED _Thread_Dispatch_necessary = true; 300176fc: 03a02001 moveq r2, #1 <== NOT EXECUTED 30017700: 05c32010 strbeq r2, [r3, #16] <== NOT EXECUTED 30017704: ea000006 b 30017724 <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 30017708: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3001770c: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 30017710: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 30017714: e5931018 ldr r1, [r3, #24] <== NOT EXECUTED 30017718: e1814004 orr r4, r1, r4 <== NOT EXECUTED 3001771c: e5834018 str r4, [r3, #24] <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 30017720: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 30017724: eb00108f bl 3001b968 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30017728: e3a00000 mov r0, #0 3001772c: ea000001 b 30017738 } _Thread_Enable_dispatch(); 30017730: eb00108c bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_NOT_DEFINED; 30017734: e3a0000b mov r0, #11 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30017738: e8bd8018 pop {r3, r4, pc} =============================================================================== 3000979c : */ rtems_status_code rtems_task_delete( rtems_id id ) { 3000979c: e92d4071 push {r0, r4, r5, r6, lr} register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 300097a0: e59f5068 ldr r5, [pc, #104] ; 30009810 */ rtems_status_code rtems_task_delete( rtems_id id ) { 300097a4: e1a04000 mov r4, r0 register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 300097a8: e5950000 ldr r0, [r5] 300097ac: eb00015b bl 30009d20 <_API_Mutex_Lock> the_thread = _Thread_Get( id, &location ); 300097b0: e1a00004 mov r0, r4 300097b4: e1a0100d mov r1, sp 300097b8: eb00080e bl 3000b7f8 <_Thread_Get> switch ( location ) { 300097bc: e59d6000 ldr r6, [sp] Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); the_thread = _Thread_Get( id, &location ); 300097c0: e1a04000 mov r4, r0 switch ( location ) { 300097c4: e3560000 cmp r6, #0 300097c8: 1a00000c bne 30009800 case OBJECTS_LOCAL: the_information = _Objects_Get_information_id( the_thread->Object.id ); 300097cc: e5900008 ldr r0, [r0, #8] 300097d0: eb0004ad bl 3000aa8c <_Objects_Get_information_id> 0 /* Not used */ ); } #endif _Thread_Close( the_information, the_thread ); 300097d4: e1a01004 mov r1, r4 300097d8: eb000749 bl 3000b504 <_Thread_Close> 300097dc: e5940008 ldr r0, [r4, #8] 300097e0: eb0004a9 bl 3000aa8c <_Objects_Get_information_id> 300097e4: e1a01004 mov r1, r4 300097e8: eb00048a bl 3000aa18 <_Objects_Free> _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 300097ec: e5950000 ldr r0, [r5] 300097f0: eb000163 bl 30009d84 <_API_Mutex_Unlock> _Thread_Enable_dispatch(); 300097f4: eb0007f6 bl 3000b7d4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 300097f8: e1a00006 mov r0, r6 300097fc: ea000002 b 3000980c case OBJECTS_ERROR: break; } _RTEMS_Unlock_allocator(); 30009800: e5950000 ldr r0, [r5] <== NOT EXECUTED 30009804: eb00015e bl 30009d84 <_API_Mutex_Unlock> <== NOT EXECUTED return RTEMS_INVALID_ID; 30009808: e3a00004 mov r0, #4 <== NOT EXECUTED } 3000980c: e8bd8078 pop {r3, r4, r5, r6, pc} =============================================================================== 3000b784 : rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 3000b784: e92d4071 push {r0, r4, r5, r6, lr} 3000b788: e1a05002 mov r5, r2 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000b78c: e59f209c ldr r2, [pc, #156] ; 3000b830 rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 3000b790: e1a03000 mov r3, r0 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000b794: e5d22004 ldrb r2, [r2, #4] rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 3000b798: e1a04001 mov r4, r1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000b79c: e3520000 cmp r2, #0 return RTEMS_NOT_CONFIGURED; 3000b7a0: 03a00016 moveq r0, #22 { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000b7a4: 0a000020 beq 3000b82c return RTEMS_NOT_CONFIGURED; if ( !note ) 3000b7a8: e3550000 cmp r5, #0 return RTEMS_INVALID_ADDRESS; 3000b7ac: 03a00009 moveq r0, #9 RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; if ( !note ) 3000b7b0: 0a00001d beq 3000b82c /* * 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 ) 3000b7b4: e351000f cmp r1, #15 return RTEMS_INVALID_NUMBER; 3000b7b8: 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 ) 3000b7bc: 8a00001a bhi 3000b82c /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 3000b7c0: e3530000 cmp r3, #0 3000b7c4: 0a000004 beq 3000b7dc _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 3000b7c8: e59f2064 ldr r2, [pc, #100] ; 3000b834 3000b7cc: e5922004 ldr r2, [r2, #4] /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 3000b7d0: e5922008 ldr r2, [r2, #8] 3000b7d4: e1530002 cmp r3, r2 3000b7d8: 1a000007 bne 3000b7fc _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 3000b7dc: e59f3050 ldr r3, [pc, #80] ; 3000b834 <== NOT EXECUTED *note = api->Notepads[ notepad ]; 3000b7e0: e2844008 add r4, r4, #8 <== NOT EXECUTED * Optimize the most likely case to avoid the Thread_Dispatch. */ 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 ]; 3000b7e4: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; 3000b7e8: 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 ]; 3000b7ec: e59330f4 ldr r3, [r3, #244] ; 0xf4 <== NOT EXECUTED 3000b7f0: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000b7f4: e5853000 str r3, [r5] <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000b7f8: ea00000b b 3000b82c <== NOT EXECUTED } the_thread = _Thread_Get( id, &location ); 3000b7fc: e1a0100d mov r1, sp 3000b800: eb0008bc bl 3000daf8 <_Thread_Get> switch ( location ) { 3000b804: e59d6000 ldr r6, [sp] 3000b808: e3560000 cmp r6, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000b80c: 13a00004 movne r0, #4 *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000b810: 1a000005 bne 3000b82c case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 3000b814: e59030f4 ldr r3, [r0, #244] ; 0xf4 3000b818: e2844008 add r4, r4, #8 3000b81c: e7933104 ldr r3, [r3, r4, lsl #2] 3000b820: e5853000 str r3, [r5] _Thread_Enable_dispatch(); 3000b824: eb0008aa bl 3000dad4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000b828: e1a00006 mov r0, r6 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000b82c: e8bd8078 pop {r3, r4, r5, r6, pc} =============================================================================== 30009814 : rtems_id *id ) { Objects_Name_or_id_lookup_errors status; if ( !id ) 30009814: e2523000 subs r3, r2, #0 rtems_status_code rtems_task_ident( rtems_name name, uint32_t node, rtems_id *id ) { 30009818: e92d4010 push {r4, lr} 3000981c: e1a0c000 mov ip, r0 30009820: e1a04001 mov r4, r1 Objects_Name_or_id_lookup_errors status; if ( !id ) 30009824: 0a00000d beq 30009860 return RTEMS_INVALID_ADDRESS; if ( name == OBJECTS_ID_OF_SELF ) { 30009828: e3500000 cmp r0, #0 3000982c: 1a000004 bne 30009844 *id = _Thread_Executing->Object.id; 30009830: e59f2030 ldr r2, [pc, #48] ; 30009868 <== NOT EXECUTED 30009834: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 30009838: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000983c: e5832000 str r2, [r3] <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30009840: e8bd8010 pop {r4, pc} <== NOT EXECUTED } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); 30009844: e59f0020 ldr r0, [pc, #32] ; 3000986c 30009848: e1a0100c mov r1, ip 3000984c: e1a02004 mov r2, r4 30009850: eb000512 bl 3000aca0 <_Objects_Name_to_id_u32> return _Status_Object_name_errors_to_status[ status ]; 30009854: e59f3014 ldr r3, [pc, #20] ; 30009870 30009858: e7930100 ldr r0, [r3, r0, lsl #2] 3000985c: e8bd8010 pop {r4, pc} ) { Objects_Name_or_id_lookup_errors status; if ( !id ) return RTEMS_INVALID_ADDRESS; 30009860: 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 ]; } 30009864: e8bd8010 pop {r4, pc} <== NOT EXECUTED =============================================================================== 30017a94 : */ rtems_status_code rtems_task_is_suspended( rtems_id id ) { 30017a94: e92d4011 push {r0, r4, lr} <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 30017a98: e1a0100d mov r1, sp <== NOT EXECUTED 30017a9c: eb000fba bl 3001b98c <_Thread_Get> <== NOT EXECUTED switch ( location ) { 30017aa0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30017aa4: e3530000 cmp r3, #0 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30017aa8: 13a00004 movne r0, #4 <== NOT EXECUTED { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 30017aac: 1a000007 bne 30017ad0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _States_Is_suspended ( States_Control the_states ) { return (the_states & STATES_SUSPENDED); 30017ab0: e5904010 ldr r4, [r0, #16] <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 30017ab4: e2144002 ands r4, r4, #2 <== NOT EXECUTED 30017ab8: 1a000002 bne 30017ac8 <== NOT EXECUTED _Thread_Enable_dispatch(); 30017abc: eb000fa9 bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30017ac0: e1a00004 mov r0, r4 <== NOT EXECUTED 30017ac4: ea000001 b 30017ad0 <== NOT EXECUTED } _Thread_Enable_dispatch(); 30017ac8: eb000fa6 bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_ALREADY_SUSPENDED; 30017acc: e3a0000f mov r0, #15 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30017ad0: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED =============================================================================== 3000a518 : rtems_status_code rtems_task_restart( rtems_id id, uint32_t argument ) { 3000a518: e92d4031 push {r0, r4, r5, lr} 3000a51c: e1a05001 mov r5, r1 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000a520: e1a0100d mov r1, sp 3000a524: eb0007df bl 3000c4a8 <_Thread_Get> switch ( location ) { 3000a528: e59d4000 ldr r4, [sp] 3000a52c: e3540000 cmp r4, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000a530: 13a00004 movne r0, #4 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000a534: 1a000009 bne 3000a560 case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 3000a538: e1a01004 mov r1, r4 3000a53c: e1a02005 mov r2, r5 3000a540: eb0009cb bl 3000cc74 <_Thread_Restart> 3000a544: e3500000 cmp r0, #0 3000a548: 0a000002 beq 3000a558 _Thread_Enable_dispatch(); 3000a54c: eb0007cc bl 3000c484 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000a550: e1a00004 mov r0, r4 3000a554: ea000001 b 3000a560 } _Thread_Enable_dispatch(); 3000a558: eb0007c9 bl 3000c484 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_INCORRECT_STATE; 3000a55c: e3a0000e mov r0, #14 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000a560: e8bd8038 pop {r3, r4, r5, pc} =============================================================================== 3000cc60 : */ rtems_status_code rtems_task_resume( rtems_id id ) { 3000cc60: e92d4011 push {r0, r4, lr} register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000cc64: e1a0100d mov r1, sp 3000cc68: eb0007f5 bl 3000ec44 <_Thread_Get> switch ( location ) { 3000cc6c: e59d4000 ldr r4, [sp] ) { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000cc70: e1a03000 mov r3, r0 switch ( location ) { 3000cc74: e3540000 cmp r4, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000cc78: 13a00004 movne r0, #4 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000cc7c: 1a000009 bne 3000cca8 */ RTEMS_INLINE_ROUTINE bool _States_Is_suspended ( States_Control the_states ) { return (the_states & STATES_SUSPENDED); 3000cc80: e5933010 ldr r3, [r3, #16] case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 3000cc84: e3130002 tst r3, #2 3000cc88: 0a000004 beq 3000cca0 _Thread_Resume( the_thread, true ); 3000cc8c: e3a01001 mov r1, #1 3000cc90: eb0009de bl 3000f410 <_Thread_Resume> _Thread_Enable_dispatch(); 3000cc94: eb0007e1 bl 3000ec20 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000cc98: e1a00004 mov r0, r4 3000cc9c: ea000001 b 3000cca8 } _Thread_Enable_dispatch(); 3000cca0: eb0007de bl 3000ec20 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_INCORRECT_STATE; 3000cca4: e3a0000e mov r0, #14 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000cca8: e8bd8018 pop {r3, r4, pc} =============================================================================== 3000b918 : rtems_status_code rtems_task_set_note( rtems_id id, uint32_t notepad, uint32_t note ) { 3000b918: e92d4071 push {r0, r4, r5, r6, lr} 3000b91c: e1a05002 mov r5, r2 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000b920: e59f2088 ldr r2, [pc, #136] ; 3000b9b0 rtems_status_code rtems_task_set_note( rtems_id id, uint32_t notepad, uint32_t note ) { 3000b924: e1a03000 mov r3, r0 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000b928: e5d22004 ldrb r2, [r2, #4] rtems_status_code rtems_task_set_note( rtems_id id, uint32_t notepad, uint32_t note ) { 3000b92c: e1a04001 mov r4, r1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000b930: e3520000 cmp r2, #0 return RTEMS_NOT_CONFIGURED; 3000b934: 03a00016 moveq r0, #22 { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 3000b938: 0a00001b beq 3000b9ac /* * 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 ) 3000b93c: e351000f cmp r1, #15 return RTEMS_INVALID_NUMBER; 3000b940: 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 ) 3000b944: 8a000018 bhi 3000b9ac /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 3000b948: e3530000 cmp r3, #0 3000b94c: 0a000004 beq 3000b964 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 3000b950: e59f205c ldr r2, [pc, #92] ; 3000b9b4 3000b954: e5922004 ldr r2, [r2, #4] /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 3000b958: e5922008 ldr r2, [r2, #8] 3000b95c: e1530002 cmp r3, r2 3000b960: 1a000006 bne 3000b980 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 3000b964: e59f3048 ldr r3, [pc, #72] ; 3000b9b4 <== NOT EXECUTED api->Notepads[ notepad ] = note; 3000b968: e2844008 add r4, r4, #8 <== NOT EXECUTED * Optimize the most likely case to avoid the Thread_Dispatch. */ 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 ]; 3000b96c: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; 3000b970: 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; 3000b974: e59330f4 ldr r3, [r3, #244] ; 0xf4 <== NOT EXECUTED 3000b978: e7835104 str r5, [r3, r4, lsl #2] <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000b97c: ea00000a b 3000b9ac <== NOT EXECUTED } the_thread = _Thread_Get( id, &location ); 3000b980: e1a0100d mov r1, sp 3000b984: eb00085b bl 3000daf8 <_Thread_Get> switch ( location ) { 3000b988: e59d6000 ldr r6, [sp] 3000b98c: e3560000 cmp r6, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000b990: 13a00004 movne r0, #4 api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000b994: 1a000004 bne 3000b9ac case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 3000b998: e59030f4 ldr r3, [r0, #244] ; 0xf4 3000b99c: e2844008 add r4, r4, #8 3000b9a0: e7835104 str r5, [r3, r4, lsl #2] _Thread_Enable_dispatch(); 3000b9a4: eb00084a bl 3000dad4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000b9a8: e1a00006 mov r0, r6 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000b9ac: e8bd8078 pop {r3, r4, r5, r6, pc} =============================================================================== 3000da24 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 3000da24: e92d4031 push {r0, r4, r5, lr} register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 3000da28: 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 ) { 3000da2c: e1a05002 mov r5, r2 register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 3000da30: 0a000004 beq 3000da48 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 ) ); 3000da34: e59f3074 ldr r3, [pc, #116] ; 3000dab0 3000da38: e5d33000 ldrb r3, [r3] 3000da3c: e1540003 cmp r4, r3 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 3000da40: 83a00013 movhi r0, #19 ) { register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 3000da44: 8a000018 bhi 3000daac !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 3000da48: e3550000 cmp r5, #0 return RTEMS_INVALID_ADDRESS; 3000da4c: 03a00009 moveq r0, #9 if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 3000da50: 0a000015 beq 3000daac return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 3000da54: e1a0100d mov r1, sp 3000da58: eb000854 bl 3000fbb0 <_Thread_Get> switch ( location ) { 3000da5c: e59d3000 ldr r3, [sp] 3000da60: e3530000 cmp r3, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000da64: 13a00004 movne r0, #4 if ( !old_priority ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000da68: 1a00000f bne 3000daac case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 3000da6c: e5903014 ldr r3, [r0, #20] if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 3000da70: 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; 3000da74: e5853000 str r3, [r5] if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 3000da78: 0a000009 beq 3000daa4 the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 3000da7c: 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; 3000da80: e5804018 str r4, [r0, #24] if ( the_thread->resource_count == 0 || 3000da84: e3530000 cmp r3, #0 3000da88: 0a000002 beq 3000da98 3000da8c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000da90: e1530004 cmp r3, r4 <== NOT EXECUTED 3000da94: 9a000002 bls 3000daa4 <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 3000da98: e1a01004 mov r1, r4 3000da9c: e3a02000 mov r2, #0 3000daa0: eb000736 bl 3000f780 <_Thread_Change_priority> } _Thread_Enable_dispatch(); 3000daa4: eb000838 bl 3000fb8c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000daa8: e3a00000 mov r0, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000daac: e8bd8038 pop {r3, r4, r5, pc} =============================================================================== 300098f4 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 300098f4: e92d4073 push {r0, r1, r4, r5, r6, lr} register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 300098f8: e2515000 subs r5, r1, #0 rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 300098fc: e1a06002 mov r6, r2 register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; 30009900: 03a00009 moveq r0, #9 ) { register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 30009904: 0a000011 beq 30009950 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 30009908: e28d1004 add r1, sp, #4 3000990c: eb0007b9 bl 3000b7f8 <_Thread_Get> switch ( location ) { 30009910: e59d4004 ldr r4, [sp, #4] 30009914: e3540000 cmp r4, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30009918: 13a00004 movne r0, #4 if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000991c: 1a00000b bne 30009950 case OBJECTS_LOCAL: if ( _Thread_Start( 30009920: e1a01004 mov r1, r4 30009924: e1a02005 mov r2, r5 30009928: e1a03004 mov r3, r4 3000992c: e58d6000 str r6, [sp] 30009930: eb0009fc bl 3000c128 <_Thread_Start> 30009934: e3500000 cmp r0, #0 30009938: 0a000002 beq 30009948 the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 3000993c: eb0007a4 bl 3000b7d4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30009940: e1a00004 mov r0, r4 30009944: ea000001 b 30009950 } _Thread_Enable_dispatch(); 30009948: eb0007a1 bl 3000b7d4 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_INCORRECT_STATE; 3000994c: e3a0000e mov r0, #14 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30009950: e8bd807c pop {r2, r3, r4, r5, r6, pc} =============================================================================== 3000cec4 : */ rtems_status_code rtems_task_suspend( rtems_id id ) { 3000cec4: e92d4011 push {r0, r4, lr} register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000cec8: e1a0100d mov r1, sp 3000cecc: eb0007c5 bl 3000ede8 <_Thread_Get> switch ( location ) { 3000ced0: e59d2000 ldr r2, [sp] ) { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 3000ced4: e1a03000 mov r3, r0 switch ( location ) { 3000ced8: e3520000 cmp r2, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000cedc: 13a00004 movne r0, #4 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 3000cee0: 1a000008 bne 3000cf08 */ RTEMS_INLINE_ROUTINE bool _States_Is_suspended ( States_Control the_states ) { return (the_states & STATES_SUSPENDED); 3000cee4: e5934010 ldr r4, [r3, #16] case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 3000cee8: e2144002 ands r4, r4, #2 3000ceec: 1a000003 bne 3000cf00 _Thread_Suspend( the_thread ); 3000cef0: eb000a1b bl 3000f764 <_Thread_Suspend> _Thread_Enable_dispatch(); 3000cef4: eb0007b2 bl 3000edc4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000cef8: e1a00004 mov r0, r4 3000cefc: ea000001 b 3000cf08 } _Thread_Enable_dispatch(); 3000cf00: eb0007af bl 3000edc4 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_ALREADY_SUSPENDED; 3000cf04: e3a0000f mov r0, #15 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 3000cf08: e8bd8018 pop {r3, r4, pc} =============================================================================== 3000a600 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 3000a600: e92d40f1 push {r0, r4, r5, r6, r7, lr} Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 3000a604: e2514000 subs r4, r1, #0 rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 3000a608: e1a05002 mov r5, r2 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) return RTEMS_INVALID_ADDRESS; 3000a60c: 03a00009 moveq r0, #9 { Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 3000a610: 0a000023 beq 3000a6a4 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 3000a614: e1a0100d mov r1, sp 3000a618: eb0007f6 bl 3000c5f8 <_Thread_Get> switch (location) { 3000a61c: e59d3000 ldr r3, [sp] rtems_task_variable_t *tvp, *new; if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 3000a620: e1a07000 mov r7, r0 switch (location) { 3000a624: e3530000 cmp r3, #0 case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 3000a628: 05906100 ldreq r6, [r0, #256] ; 0x100 if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 3000a62c: 0a000008 beq 3000a654 3000a630: ea00001a b 3000a6a0 <== 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) { 3000a634: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED 3000a638: e1530004 cmp r3, r4 <== NOT EXECUTED 3000a63c: 1a000003 bne 3000a650 <== NOT EXECUTED tvp->dtor = dtor; 3000a640: e5865010 str r5, [r6, #16] <== NOT EXECUTED _Thread_Enable_dispatch(); 3000a644: eb0007e2 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000a648: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a64c: ea000014 b 3000a6a4 <== NOT EXECUTED } tvp = (rtems_task_variable_t *)tvp->next; 3000a650: 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) { 3000a654: e3560000 cmp r6, #0 3000a658: 1afffff5 bne 3000a634 /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); 3000a65c: e3a00014 mov r0, #20 3000a660: eb000be6 bl 3000d600 <_Workspace_Allocate> if (new == NULL) { 3000a664: e3500000 cmp r0, #0 3000a668: 1a000002 bne 3000a678 _Thread_Enable_dispatch(); 3000a66c: eb0007d8 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_NO_MEMORY; 3000a670: e3a0001a mov r0, #26 <== NOT EXECUTED 3000a674: ea00000a b 3000a6a4 <== NOT EXECUTED } new->gval = *ptr; 3000a678: e5943000 ldr r3, [r4] new->ptr = ptr; 3000a67c: 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; 3000a680: e5803008 str r3, [r0, #8] new->ptr = ptr; new->dtor = dtor; new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 3000a684: e5973100 ldr r3, [r7, #256] ; 0x100 _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; new->ptr = ptr; new->dtor = dtor; 3000a688: e5805010 str r5, [r0, #16] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 3000a68c: e5803000 str r3, [r0] the_thread->task_variables = new; 3000a690: e5870100 str r0, [r7, #256] ; 0x100 _Thread_Enable_dispatch(); 3000a694: eb0007ce bl 3000c5d4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000a698: e1a00006 mov r0, r6 3000a69c: ea000000 b 3000a6a4 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000a6a0: e3a00004 mov r0, #4 <== NOT EXECUTED } 3000a6a4: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} =============================================================================== 3000a6a8 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 3000a6a8: e92d4011 push {r0, r4, lr} <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 3000a6ac: e2514000 subs r4, r1, #0 <== NOT EXECUTED 3000a6b0: 0a000016 beq 3000a710 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 3000a6b4: e1a0100d mov r1, sp <== NOT EXECUTED 3000a6b8: eb0007ce bl 3000c5f8 <_Thread_Get> <== NOT EXECUTED switch (location) { 3000a6bc: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a6c0: e3530000 cmp r3, #0 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; 3000a6c4: 05901100 ldreq r1, [r0, #256] ; 0x100 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 3000a6c8: 0a00000d beq 3000a704 <== NOT EXECUTED 3000a6cc: ea000011 b 3000a718 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 3000a6d0: e5912004 ldr r2, [r1, #4] <== NOT EXECUTED 3000a6d4: e1520004 cmp r2, r4 <== NOT EXECUTED 3000a6d8: 1a000007 bne 3000a6fc <== NOT EXECUTED 3000a6dc: e5912000 ldr r2, [r1] <== NOT EXECUTED if (prev) 3000a6e0: e3530000 cmp r3, #0 <== NOT EXECUTED prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 3000a6e4: 05802100 streq r2, [r0, #256] ; 0x100 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 3000a6e8: 15832000 strne r2, [r3] <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 3000a6ec: eb000028 bl 3000a794 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED _Thread_Enable_dispatch(); 3000a6f0: eb0007b7 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000a6f4: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a6f8: ea000007 b 3000a71c <== NOT EXECUTED } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 3000a6fc: e1a03001 mov r3, r1 <== NOT EXECUTED 3000a700: e5911000 ldr r1, [r1] <== NOT EXECUTED the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 3000a704: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a708: 1afffff0 bne 3000a6d0 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 3000a70c: eb0007b0 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) return RTEMS_INVALID_ADDRESS; 3000a710: e3a00009 mov r0, #9 <== NOT EXECUTED 3000a714: ea000000 b 3000a71c <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000a718: e3a00004 mov r0, #4 <== NOT EXECUTED } 3000a71c: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED =============================================================================== 3000a720 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 3000a720: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 3000a724: e2515000 subs r5, r1, #0 <== NOT EXECUTED rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 3000a728: e1a04002 mov r4, r2 <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 3000a72c: 0a000014 beq 3000a784 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 3000a730: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a734: 0a000012 beq 3000a784 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 3000a738: e1a0100d mov r1, sp <== NOT EXECUTED 3000a73c: eb0007ad bl 3000c5f8 <_Thread_Get> <== NOT EXECUTED switch (location) { 3000a740: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000a744: 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; 3000a748: 05903100 ldreq r3, [r0, #256] ; 0x100 <== NOT EXECUTED if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 3000a74c: 0a000009 beq 3000a778 <== NOT EXECUTED 3000a750: ea00000d b 3000a78c <== NOT EXECUTED /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 3000a754: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000a758: e1520005 cmp r2, r5 <== NOT EXECUTED 3000a75c: 1a000004 bne 3000a774 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 3000a760: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 3000a764: e5843000 str r3, [r4] <== NOT EXECUTED _Thread_Enable_dispatch(); 3000a768: eb000799 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 3000a76c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a770: ea000006 b 3000a790 <== NOT EXECUTED } tvp = (rtems_task_variable_t *)tvp->next; 3000a774: 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) { 3000a778: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a77c: 1afffff4 bne 3000a754 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 3000a780: eb000793 bl 3000c5d4 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !ptr ) return RTEMS_INVALID_ADDRESS; if ( !result ) return RTEMS_INVALID_ADDRESS; 3000a784: e3a00009 mov r0, #9 <== NOT EXECUTED 3000a788: ea000000 b 3000a790 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3000a78c: e3a00004 mov r0, #4 <== NOT EXECUTED } 3000a790: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 30009954 : 30009954: e59f3074 ldr r3, [pc, #116] ; 300099d0 */ rtems_status_code rtems_task_wake_after( rtems_interval ticks ) { 30009958: e92d4030 push {r4, r5, lr} 3000995c: e5932000 ldr r2, [r3] 30009960: e1a04000 mov r4, r0 30009964: e2822001 add r2, r2, #1 30009968: e5832000 str r2, [r3] _Thread_Disable_dispatch(); if ( ticks == 0 ) { 3000996c: e3500000 cmp r0, #0 30009970: 1a000003 bne 30009984 * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield(); 30009974: e59f3058 ldr r3, [pc, #88] ; 300099d4 30009978: e1a0e00f mov lr, pc 3000997c: e593f00c ldr pc, [r3, #12] 30009980: ea00000f b 300099c4 _Scheduler_Yield(); } else { _Thread_Set_state( _Thread_Executing, STATES_DELAYING ); 30009984: e59f504c ldr r5, [pc, #76] ; 300099d8 <== NOT EXECUTED 30009988: e3a01008 mov r1, #8 <== NOT EXECUTED 3000998c: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 30009990: eb000992 bl 3000bfe0 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( &_Thread_Executing->Timer, 30009994: e5951004 ldr r1, [r5, #4] <== NOT EXECUTED Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 30009998: e59f003c ldr r0, [pc, #60] ; 300099dc <== NOT EXECUTED _Thread_Disable_dispatch(); if ( ticks == 0 ) { _Scheduler_Yield(); } else { _Thread_Set_state( _Thread_Executing, STATES_DELAYING ); _Watchdog_Initialize( 3000999c: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 300099a0: e3a03000 mov r3, #0 <== NOT EXECUTED the_watchdog->routine = routine; 300099a4: e5810064 str r0, [r1, #100] ; 0x64 <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 300099a8: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED the_watchdog->routine = routine; the_watchdog->id = id; 300099ac: e5812068 str r2, [r1, #104] ; 0x68 <== NOT EXECUTED the_watchdog->user_data = user_data; 300099b0: e581306c str r3, [r1, #108] ; 0x6c <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 300099b4: e5814054 str r4, [r1, #84] ; 0x54 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 300099b8: e59f0020 ldr r0, [pc, #32] ; 300099e0 <== NOT EXECUTED 300099bc: e2811048 add r1, r1, #72 ; 0x48 <== NOT EXECUTED 300099c0: eb000ad3 bl 3000c514 <_Watchdog_Insert> <== NOT EXECUTED _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); } _Thread_Enable_dispatch(); 300099c4: eb000782 bl 3000b7d4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; } 300099c8: e3a00000 mov r0, #0 300099cc: e8bd8030 pop {r4, r5, pc} =============================================================================== 3000ab88 : rtems_time_of_day *time_buffer ) { Watchdog_Interval seconds; if ( !_TOD_Is_set ) 3000ab88: e59f30bc ldr r3, [pc, #188] ; 3000ac4c */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 3000ab8c: e92d40f0 push {r4, r5, r6, r7, lr} Watchdog_Interval seconds; if ( !_TOD_Is_set ) 3000ab90: e5d33000 ldrb r3, [r3] */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 3000ab94: e1a05000 mov r5, r0 Watchdog_Interval seconds; if ( !_TOD_Is_set ) 3000ab98: e3530000 cmp r3, #0 return RTEMS_NOT_DEFINED; 3000ab9c: 03a0000b moveq r0, #11 rtems_time_of_day *time_buffer ) { Watchdog_Interval seconds; if ( !_TOD_Is_set ) 3000aba0: 08bd80f0 popeq {r4, r5, r6, r7, pc} return RTEMS_NOT_DEFINED; if ( !time_buffer ) 3000aba4: e3550000 cmp r5, #0 return RTEMS_INVALID_ADDRESS; 3000aba8: 03a00009 moveq r0, #9 Watchdog_Interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !time_buffer ) 3000abac: 08bd80f0 popeq {r4, r5, r6, r7, pc} return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 3000abb0: e3a04000 mov r4, #0 3000abb4: e5854018 str r4, [r5, #24] if ( !_TOD_Validate( time_buffer ) ) 3000abb8: ebfffd1a bl 3000a028 <_TOD_Validate> 3000abbc: e1500004 cmp r0, r4 return RTEMS_INVALID_CLOCK; 3000abc0: 03a00014 moveq r0, #20 if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; if ( !_TOD_Validate( time_buffer ) ) 3000abc4: 08bd80f0 popeq {r4, r5, r6, r7, pc} return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 3000abc8: e1a00005 mov r0, r5 3000abcc: ebfffcf2 bl 30009f9c <_TOD_To_seconds> if ( seconds <= _TOD_Seconds_since_epoch() ) 3000abd0: e59f6078 ldr r6, [pc, #120] ; 3000ac50 time_buffer->ticks = 0; if ( !_TOD_Validate( time_buffer ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 3000abd4: e1a05000 mov r5, r0 if ( seconds <= _TOD_Seconds_since_epoch() ) 3000abd8: e5963000 ldr r3, [r6] 3000abdc: e1500003 cmp r0, r3 3000abe0: 9a000017 bls 3000ac44 3000abe4: e59f3068 ldr r3, [pc, #104] ; 3000ac54 3000abe8: e5932000 ldr r2, [r3] 3000abec: e2822001 add r2, r2, #1 3000abf0: e5832000 str r2, [r3] return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 3000abf4: e59f705c ldr r7, [pc, #92] ; 3000ac58 3000abf8: e3a01010 mov r1, #16 3000abfc: e5970004 ldr r0, [r7, #4] 3000ac00: eb0009a1 bl 3000d28c <_Thread_Set_state> _Watchdog_Initialize( &_Thread_Executing->Timer, 3000ac04: e5971004 ldr r1, [r7, #4] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 3000ac08: e59f204c ldr r2, [pc, #76] ; 3000ac5c if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); _Watchdog_Initialize( 3000ac0c: e5913008 ldr r3, [r1, #8] 3000ac10: e5812064 str r2, [r1, #100] ; 0x64 the_watchdog->id = id; 3000ac14: e5813068 str r3, [r1, #104] ; 0x68 &_Thread_Executing->Timer, _Thread_Delay_ended, _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_seconds( 3000ac18: e5963000 ldr r3, [r6] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 3000ac1c: e59f003c ldr r0, [pc, #60] ; 3000ac60 3000ac20: e0635005 rsb r5, r3, r5 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 3000ac24: e5814050 str r4, [r1, #80] ; 0x50 the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 3000ac28: e581406c str r4, [r1, #108] ; 0x6c Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 3000ac2c: e5815054 str r5, [r1, #84] ; 0x54 _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 3000ac30: e2811048 add r1, r1, #72 ; 0x48 3000ac34: eb000b09 bl 3000d860 <_Watchdog_Insert> &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 3000ac38: eb000790 bl 3000ca80 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 3000ac3c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac40: 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; 3000ac44: e3a00014 mov r0, #20 <== NOT EXECUTED &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 3000ac48: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 30009e34 : rtems_status_code rtems_timer_create( rtems_name name, rtems_id *id ) { 30009e34: e92d40f0 push {r4, r5, r6, r7, lr} Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 30009e38: e2506000 subs r6, r0, #0 rtems_status_code rtems_timer_create( rtems_name name, rtems_id *id ) { 30009e3c: e1a04001 mov r4, r1 Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 30009e40: 03a00003 moveq r0, #3 rtems_id *id ) { Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 30009e44: 08bd80f0 popeq {r4, r5, r6, r7, pc} return RTEMS_INVALID_NAME; if ( !id ) 30009e48: e3510000 cmp r1, #0 30009e4c: 0a00001b beq 30009ec0 30009e50: e59f3070 ldr r3, [pc, #112] ; 30009ec8 30009e54: e5932000 ldr r2, [r3] 30009e58: e2822001 add r2, r2, #1 30009e5c: 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 ); 30009e60: e59f5064 ldr r5, [pc, #100] ; 30009ecc 30009e64: e1a00005 mov r0, r5 30009e68: eb000399 bl 3000acd4 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 30009e6c: e3500000 cmp r0, #0 30009e70: 1a000002 bne 30009e80 _Thread_Enable_dispatch(); 30009e74: eb0007aa bl 3000bd24 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_TOO_MANY; 30009e78: e3a00005 mov r0, #5 <== NOT EXECUTED 30009e7c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED } the_timer->the_class = TIMER_DORMANT; 30009e80: e3a03004 mov r3, #4 30009e84: e5803038 str r3, [r0, #56] ; 0x38 Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 30009e88: e1d010b8 ldrh r1, [r0, #8] 30009e8c: e5903008 ldr r3, [r0, #8] #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 30009e90: e595201c ldr r2, [r5, #28] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 30009e94: e3a07000 mov r7, #0 30009e98: e5807018 str r7, [r0, #24] the_watchdog->routine = routine; 30009e9c: e580702c str r7, [r0, #44] ; 0x2c the_watchdog->id = id; 30009ea0: e5807030 str r7, [r0, #48] ; 0x30 the_watchdog->user_data = user_data; 30009ea4: e5807034 str r7, [r0, #52] ; 0x34 30009ea8: e7820101 str r0, [r2, r1, lsl #2] information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 30009eac: e580600c str r6, [r0, #12] &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 30009eb0: e5843000 str r3, [r4] _Thread_Enable_dispatch(); 30009eb4: eb00079a bl 3000bd24 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30009eb8: e1a00007 mov r0, r7 30009ebc: e8bd80f0 pop {r4, r5, r6, r7, pc} if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 30009ec0: e3a00009 mov r0, #9 <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 30009ec4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED =============================================================================== 30009ed0 : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 30009ed0: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 30009ed4: e2516000 subs r6, r1, #0 rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 30009ed8: e1a04000 mov r4, r0 30009edc: e1a05002 mov r5, r2 30009ee0: e1a07003 mov r7, r3 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; 30009ee4: 03a0000a moveq r0, #10 { Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 30009ee8: 0a000022 beq 30009f78 return RTEMS_INVALID_NUMBER; if ( !routine ) 30009eec: e3520000 cmp r2, #0 return RTEMS_INVALID_ADDRESS; 30009ef0: 03a00009 moveq r0, #9 ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; if ( !routine ) 30009ef4: 0a00001f beq 30009f78 Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 30009ef8: e59f007c ldr r0, [pc, #124] ; 30009f7c 30009efc: e1a01004 mov r1, r4 30009f00: e1a0200d mov r2, sp 30009f04: eb00048e bl 3000b144 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30009f08: e59d3000 ldr r3, [sp] 30009f0c: e1a08000 mov r8, r0 30009f10: e3530000 cmp r3, #0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30009f14: 13a00004 movne r0, #4 if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30009f18: 1a000016 bne 30009f78 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 30009f1c: e288a010 add sl, r8, #16 30009f20: e1a0000a mov r0, sl 30009f24: eb000b26 bl 3000cbc4 <_Watchdog_Remove> static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 30009f28: e10f2000 mrs r2, CPSR 30009f2c: e3823080 orr r3, r2, #128 ; 0x80 30009f30: 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 ) { 30009f34: e5983018 ldr r3, [r8, #24] 30009f38: e3530000 cmp r3, #0 30009f3c: 0a000001 beq 30009f48 static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 30009f40: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 30009f44: ea000009 b 30009f70 <== 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; 30009f48: e5883038 str r3, [r8, #56] ; 0x38 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 30009f4c: e5883018 str r3, [r8, #24] the_watchdog->routine = routine; 30009f50: e588502c str r5, [r8, #44] ; 0x2c the_watchdog->id = id; 30009f54: e5884030 str r4, [r8, #48] ; 0x30 the_watchdog->user_data = user_data; 30009f58: e5887034 str r7, [r8, #52] ; 0x34 30009f5c: e129f002 msr CPSR_fc, r2 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 30009f60: e59f0018 ldr r0, [pc, #24] ; 30009f80 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 30009f64: e588601c str r6, [r8, #28] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 30009f68: e1a0100a mov r1, sl 30009f6c: eb000abc bl 3000ca64 <_Watchdog_Insert> _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 30009f70: eb00076b bl 3000bd24 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 30009f74: e3a00000 mov r0, #0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30009f78: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} =============================================================================== 30018204 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 30018204: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} 30018208: e1a08003 mov r8, r3 Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 3001820c: e59f30c4 ldr r3, [pc, #196] ; 300182d8 rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 30018210: e1a04000 mov r4, r0 Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 30018214: e5d33000 ldrb r3, [r3] rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 30018218: e1a06001 mov r6, r1 Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 3001821c: e3530000 cmp r3, #0 rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 30018220: e1a05002 mov r5, r2 Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 30018224: 03a0000b moveq r0, #11 { Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 30018228: 0a000029 beq 300182d4 return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 3001822c: e1a00001 mov r0, r1 30018230: ebfff549 bl 3001575c <_TOD_Validate> 30018234: e3500000 cmp r0, #0 30018238: 0a000024 beq 300182d0 return RTEMS_INVALID_CLOCK; if ( !routine ) 3001823c: e3550000 cmp r5, #0 return RTEMS_INVALID_ADDRESS; 30018240: 03a00009 moveq r0, #9 return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; if ( !routine ) 30018244: 0a000022 beq 300182d4 return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 30018248: e1a00006 mov r0, r6 3001824c: ebfff51f bl 300156d0 <_TOD_To_seconds> if ( seconds <= _TOD_Seconds_since_epoch() ) 30018250: e59f7084 ldr r7, [pc, #132] ; 300182dc return RTEMS_INVALID_CLOCK; if ( !routine ) return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 30018254: e1a06000 mov r6, r0 if ( seconds <= _TOD_Seconds_since_epoch() ) 30018258: e5973000 ldr r3, [r7] 3001825c: e1500003 cmp r0, r3 30018260: 9a00001a bls 300182d0 30018264: e59f0074 ldr r0, [pc, #116] ; 300182e0 30018268: e1a01004 mov r1, r4 3001826c: e1a0200d mov r2, sp 30018270: eb000aa2 bl 3001ad00 <_Objects_Get> return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018274: e59da000 ldr sl, [sp] 30018278: e1a09000 mov r9, r0 3001827c: e35a0000 cmp sl, #0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30018280: 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 ) { 30018284: 1a000012 bne 300182d4 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 30018288: e289b010 add fp, r9, #16 3001828c: e1a0000b mov r0, fp 30018290: eb00121a bl 3001cb00 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY; 30018294: e3a03002 mov r3, #2 30018298: e5893038 str r3, [r9, #56] ; 0x38 _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( 3001829c: e5973000 ldr r3, [r7] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 300182a0: e59f003c ldr r0, [pc, #60] ; 300182e4 300182a4: e0636006 rsb r6, r3, r6 300182a8: e1a0100b mov r1, fp Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 300182ac: e589a018 str sl, [r9, #24] the_watchdog->routine = routine; 300182b0: e589502c str r5, [r9, #44] ; 0x2c the_watchdog->id = id; 300182b4: e5894030 str r4, [r9, #48] ; 0x30 the_watchdog->user_data = user_data; 300182b8: e5898034 str r8, [r9, #52] ; 0x34 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 300182bc: e589601c str r6, [r9, #28] _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 300182c0: eb0011b6 bl 3001c9a0 <_Watchdog_Insert> &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 300182c4: eb000da7 bl 3001b968 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 300182c8: e1a0000a mov r0, sl 300182cc: ea000000 b 300182d4 if ( !routine ) return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 300182d0: e3a00014 mov r0, #20 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 300182d4: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} =============================================================================== 300182e8 : rtems_status_code rtems_timer_get_information( rtems_id id, rtems_timer_information *the_info ) { 300182e8: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 300182ec: e2514000 subs r4, r1, #0 <== NOT EXECUTED rtems_status_code rtems_timer_get_information( rtems_id id, rtems_timer_information *the_info ) { 300182f0: e1a03000 mov r3, r0 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) return RTEMS_INVALID_ADDRESS; 300182f4: 03a00009 moveq r0, #9 <== NOT EXECUTED ) { Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 300182f8: 0a000011 beq 30018344 <== NOT EXECUTED 300182fc: e59f0044 ldr r0, [pc, #68] ; 30018348 <== NOT EXECUTED 30018300: e1a01003 mov r1, r3 <== NOT EXECUTED 30018304: e1a0200d mov r2, sp <== NOT EXECUTED 30018308: eb000a7c bl 3001ad00 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 3001830c: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30018310: e3550000 cmp r5, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30018314: 13a00004 movne r0, #4 <== NOT EXECUTED if ( !the_info ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018318: 1a000009 bne 30018344 <== NOT EXECUTED case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 3001831c: e5903038 ldr r3, [r0, #56] ; 0x38 <== NOT EXECUTED 30018320: e5843000 str r3, [r4] <== NOT EXECUTED the_info->initial = the_timer->Ticker.initial; 30018324: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 30018328: e5843004 str r3, [r4, #4] <== NOT EXECUTED the_info->start_time = the_timer->Ticker.start_time; 3001832c: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 30018330: e5843008 str r3, [r4, #8] <== NOT EXECUTED the_info->stop_time = the_timer->Ticker.stop_time; 30018334: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 30018338: e584300c str r3, [r4, #12] <== NOT EXECUTED _Thread_Enable_dispatch(); 3001833c: eb000d89 bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 30018340: e1a00005 mov r0, r5 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30018344: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED =============================================================================== 30018960 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 30018960: 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 ) && 30018964: e3500000 cmp r0, #0 <== NOT EXECUTED 30018968: e1a06001 mov r6, r1 <== NOT EXECUTED 3001896c: e1a08002 mov r8, r2 <== NOT EXECUTED 30018970: 01a07000 moveq r7, r0 <== NOT EXECUTED 30018974: 0a000004 beq 3001898c <== NOT EXECUTED ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 30018978: e59f3124 ldr r3, [pc, #292] ; 30018aa4 <== NOT EXECUTED 3001897c: 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 ) && 30018980: e1500007 cmp r0, r7 <== NOT EXECUTED 30018984: 83a07000 movhi r7, #0 <== NOT EXECUTED 30018988: 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 ) ) { 3001898c: e21770ff ands r7, r7, #255 ; 0xff <== NOT EXECUTED 30018990: 1a000003 bne 300189a4 <== NOT EXECUTED if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 30018994: e3700001 cmn r0, #1 <== NOT EXECUTED return RTEMS_INVALID_PRIORITY; 30018998: 13a00013 movne r0, #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 ) 3001899c: 1a00003f bne 30018aa0 <== NOT EXECUTED 300189a0: ea000000 b 300189a8 <== 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 ) ) { 300189a4: e1a07000 mov r7, r0 <== NOT EXECUTED /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 300189a8: e59f40f8 ldr r4, [pc, #248] ; 30018aa8 <== NOT EXECUTED } /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); 300189ac: ebffff0e bl 300185ec <_Thread_Disable_dispatch> <== NOT EXECUTED tmpInitialized = initialized; 300189b0: e5d45000 ldrb r5, [r4] <== NOT EXECUTED initialized = true; 300189b4: e3a03001 mov r3, #1 <== NOT EXECUTED 300189b8: e5c43000 strb r3, [r4] <== NOT EXECUTED _Thread_Enable_dispatch(); 300189bc: eb000be9 bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( tmpInitialized ) 300189c0: e3550000 cmp r5, #0 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; 300189c4: 13a0000e movne r0, #14 <== NOT EXECUTED _Thread_Disable_dispatch(); tmpInitialized = initialized; initialized = true; _Thread_Enable_dispatch(); if ( tmpInitialized ) 300189c8: 1a000034 bne 30018aa0 <== 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( 300189cc: e28d3008 add r3, sp, #8 <== NOT EXECUTED 300189d0: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 300189d4: e3888902 orr r8, r8, #32768 ; 0x8000 <== NOT EXECUTED 300189d8: e59f00cc ldr r0, [pc, #204] ; 30018aac <== NOT EXECUTED 300189dc: e1a01007 mov r1, r7 <== NOT EXECUTED 300189e0: e1a02006 mov r2, r6 <== NOT EXECUTED 300189e4: e3a03c01 mov r3, #256 ; 0x100 <== NOT EXECUTED 300189e8: e58d8000 str r8, [sp] <== NOT EXECUTED 300189ec: ebfffb53 bl 30017740 <== 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) { 300189f0: e3500000 cmp r0, #0 <== NOT EXECUTED initialized = false; 300189f4: 15c45000 strbne r5, [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) { 300189f8: 1a000028 bne 30018aa0 <== NOT EXECUTED */ #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return NULL; #endif return information->local_table[ index ]; 300189fc: e59f20ac ldr r2, [pc, #172] ; 30018ab0 <== NOT EXECUTED 30018a00: e1dd10b8 ldrh r1, [sp, #8] <== NOT EXECUTED 30018a04: e592201c ldr r2, [r2, #28] <== NOT EXECUTED 30018a08: e59d3008 ldr r3, [sp, #8] <== 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( 30018a0c: e7921101 ldr r1, [r2, r1, lsl #2] <== NOT EXECUTED 30018a10: e1a02004 mov r2, r4 <== NOT EXECUTED 30018a14: e5a21004 str r1, [r2, #4]! <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 30018a18: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED 30018a1c: e5841034 str r1, [r4, #52] ; 0x34 <== NOT EXECUTED head->previous = NULL; tail->previous = head; 30018a20: e2841034 add r1, r4, #52 ; 0x34 <== NOT EXECUTED 30018a24: e584103c str r1, [r4, #60] ; 0x3c <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 30018a28: e2841070 add r1, r4, #112 ; 0x70 <== NOT EXECUTED 30018a2c: e584106c str r1, [r4, #108] ; 0x6c <== NOT EXECUTED head->previous = NULL; tail->previous = head; 30018a30: e284106c add r1, r4, #108 ; 0x6c <== NOT EXECUTED 30018a34: e5841074 str r1, [r4, #116] ; 0x74 <== NOT EXECUTED Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 30018a38: e59f1074 ldr r1, [pc, #116] ; 30018ab4 <== NOT EXECUTED { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; head->previous = NULL; 30018a3c: e5840038 str r0, [r4, #56] ; 0x38 <== NOT EXECUTED 30018a40: e5841028 str r1, [r4, #40] ; 0x28 <== NOT EXECUTED 30018a44: e5841060 str r1, [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; 30018a48: e59f1068 ldr r1, [pc, #104] ; 30018ab8 <== NOT EXECUTED 30018a4c: e5840070 str r0, [r4, #112] ; 0x70 <== NOT EXECUTED 30018a50: e5841008 str r1, [r4, #8] <== NOT EXECUTED ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot; 30018a54: e59f1060 ldr r1, [pc, #96] ; 30018abc <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 30018a58: e5840014 str r0, [r4, #20] <== NOT EXECUTED 30018a5c: e5911000 ldr r1, [r1] <== NOT EXECUTED the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 30018a60: e5840030 str r0, [r4, #48] ; 0x30 <== NOT EXECUTED 30018a64: e5841040 str r1, [r4, #64] ; 0x40 <== NOT EXECUTED ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 30018a68: e59f1050 ldr r1, [pc, #80] ; 30018ac0 <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 30018a6c: e584004c str r0, [r4, #76] ; 0x4c <== NOT EXECUTED 30018a70: e5911000 ldr r1, [r1] <== NOT EXECUTED the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 30018a74: e5840068 str r0, [r4, #104] ; 0x68 <== NOT EXECUTED 30018a78: e5841078 str r1, [r4, #120] ; 0x78 <== NOT EXECUTED ts->active = false; /* * The default timer server is now available. */ _Timer_server = ts; 30018a7c: e59f1040 ldr r1, [pc, #64] ; 30018ac4 <== 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; 30018a80: e584007c str r0, [r4, #124] ; 0x7c <== NOT EXECUTED ts->active = false; 30018a84: e5c40080 strb r0, [r4, #128] ; 0x80 <== NOT EXECUTED /* * The default timer server is now available. */ _Timer_server = ts; 30018a88: e5812000 str r2, [r1] <== NOT EXECUTED /* * Start the timer server */ status = rtems_task_start( 30018a8c: e1a00003 mov r0, r3 <== NOT EXECUTED 30018a90: e59f1030 ldr r1, [pc, #48] ; 30018ac8 <== NOT EXECUTED void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 30018a94: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED 30018a98: e5843064 str r3, [r4, #100] ; 0x64 <== NOT EXECUTED 30018a9c: ebfffcd8 bl 30017e04 <== NOT EXECUTED initialized = false; } #endif return status; } 30018aa0: e8bd81fe pop {r1, r2, r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED =============================================================================== 3001837c : */ rtems_status_code rtems_timer_reset( rtems_id id ) { 3001837c: e92d4071 push {r0, r4, r5, r6, lr} 30018380: e1a01000 mov r1, r0 30018384: e1a0200d mov r2, sp 30018388: e59f0078 ldr r0, [pc, #120] ; 30018408 3001838c: eb000a5b bl 3001ad00 <_Objects_Get> Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018390: e59d5000 ldr r5, [sp] 30018394: e1a06000 mov r6, r0 30018398: e3550000 cmp r5, #0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 3001839c: 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 ) { 300183a0: 1a000016 bne 30018400 case OBJECTS_LOCAL: if ( the_timer->the_class == TIMER_INTERVAL ) { 300183a4: e5904038 ldr r4, [r0, #56] ; 0x38 300183a8: e3540000 cmp r4, #0 300183ac: 1a000006 bne 300183cc _Watchdog_Remove( &the_timer->Ticker ); 300183b0: e2806010 add r6, r0, #16 300183b4: e1a00006 mov r0, r6 300183b8: eb0011d0 bl 3001cb00 <_Watchdog_Remove> _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 300183bc: e59f0048 ldr r0, [pc, #72] ; 3001840c 300183c0: e1a01006 mov r1, r6 300183c4: eb001175 bl 3001c9a0 <_Watchdog_Insert> 300183c8: ea00000b b 300183fc } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 300183cc: 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; 300183d0: 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 ) { 300183d4: 1a000008 bne 300183fc <== NOT EXECUTED Timer_server_Control *timer_server = _Timer_server; 300183d8: e59f3030 ldr r3, [pc, #48] ; 30018410 <== NOT EXECUTED if ( !timer_server ) { _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } #endif _Watchdog_Remove( &the_timer->Ticker ); 300183dc: 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; 300183e0: e5934000 ldr r4, [r3] <== NOT EXECUTED if ( !timer_server ) { _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } #endif _Watchdog_Remove( &the_timer->Ticker ); 300183e4: eb0011c5 bl 3001cb00 <_Watchdog_Remove> <== NOT EXECUTED (*timer_server->schedule_operation)( timer_server, the_timer ); 300183e8: e1a00004 mov r0, r4 <== NOT EXECUTED 300183ec: e1a01006 mov r1, r6 <== NOT EXECUTED 300183f0: e1a0e00f mov lr, pc <== NOT EXECUTED 300183f4: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED rtems_id id ) { Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; 300183f8: 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(); 300183fc: eb000d59 bl 3001b968 <_Thread_Enable_dispatch> case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 30018400: e1a00004 mov r0, r4 30018404: e8bd8078 pop {r3, r4, r5, r6, pc} =============================================================================== 30018414 : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 30018414: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED 30018418: e1a08003 mov r8, r3 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; 3001841c: e59f30b8 ldr r3, [pc, #184] ; 300184dc <== NOT EXECUTED rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 30018420: e1a05000 mov r5, r0 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; 30018424: e5937000 ldr r7, [r3] <== NOT EXECUTED rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 30018428: 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 ) 3001842c: e3570000 cmp r7, #0 <== NOT EXECUTED rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 30018430: 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; 30018434: 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 ) 30018438: 0a000026 beq 300184d8 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !routine ) 3001843c: e3520000 cmp r2, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 30018440: 03a00009 moveq r0, #9 <== NOT EXECUTED Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !routine ) 30018444: 0a000023 beq 300184d8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 30018448: e3510000 cmp r1, #0 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 3001844c: 03a0000a moveq r0, #10 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !routine ) return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 30018450: 0a000020 beq 300184d8 <== NOT EXECUTED 30018454: e59f0084 ldr r0, [pc, #132] ; 300184e0 <== NOT EXECUTED 30018458: e1a01005 mov r1, r5 <== NOT EXECUTED 3001845c: e1a0200d mov r2, sp <== NOT EXECUTED 30018460: eb000a26 bl 3001ad00 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018464: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30018468: e1a0a000 mov sl, r0 <== NOT EXECUTED 3001846c: e3530000 cmp r3, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30018470: 13a00004 movne r0, #4 <== NOT EXECUTED if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018474: 1a000017 bne 300184d8 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 30018478: e28a0010 add r0, sl, #16 <== NOT EXECUTED 3001847c: eb00119f bl 3001cb00 <_Watchdog_Remove> <== NOT EXECUTED static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile ( 30018480: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30018484: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30018488: 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 ) { 3001848c: e59a2018 ldr r2, [sl, #24] <== NOT EXECUTED 30018490: e3520000 cmp r2, #0 <== NOT EXECUTED 30018494: 0a000001 beq 300184a0 <== NOT EXECUTED static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile ( 30018498: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 3001849c: ea00000b b 300184d0 <== 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; 300184a0: e3a01001 mov r1, #1 <== NOT EXECUTED 300184a4: e58a1038 str r1, [sl, #56] ; 0x38 <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 300184a8: e58a2018 str r2, [sl, #24] <== NOT EXECUTED the_watchdog->routine = routine; 300184ac: e58a602c str r6, [sl, #44] ; 0x2c <== NOT EXECUTED the_watchdog->id = id; 300184b0: e58a5030 str r5, [sl, #48] ; 0x30 <== NOT EXECUTED the_watchdog->user_data = user_data; 300184b4: e58a8034 str r8, [sl, #52] ; 0x34 <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 300184b8: e58a401c str r4, [sl, #28] <== NOT EXECUTED 300184bc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED _ISR_Enable( level ); (*timer_server->schedule_operation)( timer_server, the_timer ); 300184c0: e1a00007 mov r0, r7 <== NOT EXECUTED 300184c4: e1a0100a mov r1, sl <== NOT EXECUTED 300184c8: e1a0e00f mov lr, pc <== NOT EXECUTED 300184cc: e597f004 ldr pc, [r7, #4] <== NOT EXECUTED _Thread_Enable_dispatch(); 300184d0: eb000d24 bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 300184d4: e3a00000 mov r0, #0 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 300184d8: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED =============================================================================== 300184e4 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 300184e4: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED 300184e8: e1a0a003 mov sl, r3 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 300184ec: e59f30d8 ldr r3, [pc, #216] ; 300185cc <== NOT EXECUTED rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 300184f0: e1a04000 mov r4, r0 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 300184f4: e5936000 ldr r6, [r3] <== NOT EXECUTED rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 300184f8: e1a07001 mov r7, r1 <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) 300184fc: e3560000 cmp r6, #0 <== NOT EXECUTED rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 30018500: e1a05002 mov r5, r2 <== NOT EXECUTED Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; 30018504: 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 ) 30018508: 0a00002e beq 300185c8 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 3001850c: e59f30bc ldr r3, [pc, #188] ; 300185d0 <== NOT EXECUTED 30018510: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 30018514: e3530000 cmp r3, #0 <== NOT EXECUTED return RTEMS_NOT_DEFINED; 30018518: 03a0000b moveq r0, #11 <== NOT EXECUTED Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 3001851c: 0a000029 beq 300185c8 <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !routine ) 30018520: e3520000 cmp r2, #0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 30018524: 03a00009 moveq r0, #9 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 30018528: 0a000026 beq 300185c8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 3001852c: e1a00001 mov r0, r1 <== NOT EXECUTED 30018530: ebfff489 bl 3001575c <_TOD_Validate> <== NOT EXECUTED 30018534: e3500000 cmp r0, #0 <== NOT EXECUTED 30018538: 0a000021 beq 300185c4 <== NOT EXECUTED return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 3001853c: e1a00007 mov r0, r7 <== NOT EXECUTED 30018540: ebfff462 bl 300156d0 <_TOD_To_seconds> <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch() ) 30018544: e59f8088 ldr r8, [pc, #136] ; 300185d4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 30018548: e1a07000 mov r7, r0 <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch() ) 3001854c: e5983000 ldr r3, [r8] <== NOT EXECUTED 30018550: e1500003 cmp r0, r3 <== NOT EXECUTED 30018554: 9a00001a bls 300185c4 <== NOT EXECUTED 30018558: e59f0078 ldr r0, [pc, #120] ; 300185d8 <== NOT EXECUTED 3001855c: e1a01004 mov r1, r4 <== NOT EXECUTED 30018560: e1a0200d mov r2, sp <== NOT EXECUTED 30018564: eb0009e5 bl 3001ad00 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 30018568: e59d9000 ldr r9, [sp] <== NOT EXECUTED 3001856c: e1a0b000 mov fp, r0 <== NOT EXECUTED 30018570: e3590000 cmp r9, #0 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 30018574: 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 ) { 30018578: 1a000012 bne 300185c8 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 3001857c: e28b0010 add r0, fp, #16 <== NOT EXECUTED 30018580: eb00115e bl 3001cb00 <_Watchdog_Remove> <== NOT EXECUTED the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 30018584: e3a03003 mov r3, #3 <== NOT EXECUTED 30018588: e58b3038 str r3, [fp, #56] ; 0x38 <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 3001858c: e5983000 ldr r3, [r8] <== NOT EXECUTED (*timer_server->schedule_operation)( timer_server, the_timer ); 30018590: e1a00006 mov r0, r6 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 30018594: e0637007 rsb r7, r3, r7 <== NOT EXECUTED (*timer_server->schedule_operation)( timer_server, the_timer ); 30018598: e1a0100b mov r1, fp <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 3001859c: e58b9018 str r9, [fp, #24] <== NOT EXECUTED the_watchdog->routine = routine; 300185a0: e58b502c str r5, [fp, #44] ; 0x2c <== NOT EXECUTED the_watchdog->id = id; 300185a4: e58b4030 str r4, [fp, #48] ; 0x30 <== NOT EXECUTED the_watchdog->user_data = user_data; 300185a8: e58ba034 str sl, [fp, #52] ; 0x34 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 300185ac: e58b701c str r7, [fp, #28] <== NOT EXECUTED (*timer_server->schedule_operation)( timer_server, the_timer ); 300185b0: e1a0e00f mov lr, pc <== NOT EXECUTED 300185b4: e596f004 ldr pc, [r6, #4] <== NOT EXECUTED _Thread_Enable_dispatch(); 300185b8: eb000cea bl 3001b968 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; 300185bc: e1a00009 mov r0, r9 <== NOT EXECUTED 300185c0: ea000000 b 300185c8 <== 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; 300185c4: e3a00014 mov r0, #20 <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 300185c8: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED