3000f2c8 <TOD_MICROSECONDS_TO_TICKS>:
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
return (microseconds / rtems_configuration_get_microseconds_per_tick());
3000f2c8: e59f300c ldr r3, [pc, #12] ; 3000f2dc <TOD_MICROSECONDS_TO_TICKS+0x14><== NOT EXECUTED
#include <rtems/score/tod.h>
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 <TOD_MILLISECONDS_TO_TICKS>:
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
3000af1c: e59f3020 ldr r3, [pc, #32] ; 3000af44 <TOD_MILLISECONDS_TO_TICKS+0x28><== NOT EXECUTED
#include <rtems/score/tod.h>
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 <rtems/score/tod.h>
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 <TOD_TICKS_PER_SECOND_method>:
#include <rtems/config.h>
#include <rtems/score/tod.h>
uint32_t TOD_TICKS_PER_SECOND_method(void)
{
return (TOD_MICROSECONDS_PER_SECOND /
3001d3e0: e59f3010 ldr r3, [pc, #16] ; 3001d3f8 <TOD_TICKS_PER_SECOND_method+0x18><== NOT EXECUTED
#include <rtems/system.h>
#include <rtems/config.h>
#include <rtems/score/tod.h>
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 <TOD_TICKS_PER_SECOND_method+0x1c><== 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 <memcpy>
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 <memcpy>
_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 <memcpy>
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 <memset>
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 <printk> <== 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 <vprintk> <== 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 <strnlen> <== 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 <rtems/score/tqdata.h>
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 <arm_interrupt_disable> <== 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 <arm_interrupt_disable> <== 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 <arm_interrupt_disable> <== 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 <arm_interrupt_disable> <== 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 <arm_interrupt_disable> <== 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 <arm_interrupt_disable> <== 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 <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
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 <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
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 <TOD_TICKS_PER_SECOND_method> <== 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 <rtems/score/userext.h>
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 <printk> <== 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 <printk> <== 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 <printk> <== 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 <printk> <== 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 <memset>
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_barrier_create>:
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 <rtems_barrier_create+0xb4>
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 <rtems_barrier_create+0xb4>
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
30010900: e3110010 tst r1, #16
30010904: 0a000004 beq 3001091c <rtems_barrier_create+0x40>
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 <rtems_barrier_create+0x48> <== NOT EXECUTED 30010918: ea00001b b 3001098c <rtems_barrier_create+0xb0> <== 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 <rtems_barrier_create+0xb8>
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 <rtems_barrier_create+0xbc> 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 <rtems_barrier_create+0x7c>
_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 <rtems_barrier_create+0xb4> <== 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 <rtems_barrier_create+0xb4>
/* 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_barrier_release>:
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 <rtems_barrier_release+0x50> <== NOT EXECUTED
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
30010a50: e59f0038 ldr r0, [pc, #56] ; 30010a90 <rtems_barrier_release+0x54><== 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 <rtems_barrier_release+0x50> <== 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_barrier_wait>:
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 <rtems_barrier_wait+0x5c><== 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 <rtems_barrier_wait+0x58> <== 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 <rtems_barrier_wait+0x60><== 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 <rtems_build_id>:
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 <rtems_build_name>:
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_append_with_notification>:
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 <rtems_event_send> <== NOT EXECUTED
3000a2b4 <rtems_chain_get_with_notification>:
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 <rtems_event_send> <== NOT EXECUTED
3000a2e0 <rtems_chain_get_with_wait>:
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 <rtems_chain_get_with_wait+0x38> <== 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 <rtems_event_receive> <== 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 <rtems_chain_get_with_wait+0x4c> <== 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 <rtems_chain_get_with_wait+0x1c> <== 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_prepend_with_notification>:
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 <rtems_event_send> <== NOT EXECUTED
300153cc <rtems_clock_get>:
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 <rtems_clock_get+0x24> <== 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 <rtems_clock_get_tod> <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
300153f0: e3500001 cmp r0, #1 <== NOT EXECUTED 300153f4: 1a000002 bne 30015404 <rtems_clock_get+0x38> <== 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 <rtems_clock_get_seconds_since_epoch> <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
30015404: e3500002 cmp r0, #2 <== NOT EXECUTED 30015408: 1a000001 bne 30015414 <rtems_clock_get+0x48> <== NOT EXECUTED
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
3001540c: eb000023 bl 300154a0 <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED 30015410: ea000002 b 30015420 <rtems_clock_get+0x54> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
30015414: e3500003 cmp r0, #3 <== NOT EXECUTED 30015418: 1a000003 bne 3001542c <rtems_clock_get+0x60> <== NOT EXECUTED
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
3001541c: eb000017 bl 30015480 <rtems_clock_get_ticks_per_second> <== 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 <rtems_clock_get+0x74> <== 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 <rtems_clock_get_tod_timeval> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
30015440: e3a0000a mov r0, #10 <== NOT EXECUTED
}
30015444: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a220 <rtems_clock_get_seconds_since_epoch>:
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 <rtems_clock_get_seconds_since_epoch+0x30><== 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 <rtems_clock_get_seconds_since_epoch+0x34><== 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 <rtems_clock_get_ticks_per_second>:
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
rtems_interval rtems_clock_get_ticks_per_second(void)
{
return TOD_MICROSECONDS_PER_SECOND /
30008e54: e59f3010 ldr r3, [pc, #16] ; 30008e6c <rtems_clock_get_ticks_per_second+0x18><== NOT EXECUTED
#include <rtems/score/thread.h>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
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 <rtems_clock_get_ticks_per_second+0x1c><== 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 <rtems_clock_get_ticks_since_boot>:
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
rtems_interval rtems_clock_get_ticks_since_boot(void)
{
return _Watchdog_Ticks_since_boot;
30008e74: e59f3004 ldr r3, [pc, #4] ; 30008e80 <rtems_clock_get_ticks_since_boot+0xc><== NOT EXECUTED 30008e78: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
30008e7c: e12fff1e bx lr <== NOT EXECUTED
30015578 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
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 <rtems_clock_get_tod_timeval+0x58> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
30015588: e59f3044 ldr r3, [pc, #68] ; 300155d4 <rtems_clock_get_tod_timeval+0x5c><== 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 <rtems_clock_get_tod_timeval+0x58> <== 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_clock_get_uptime>:
*/
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 <rtems_clock_get_uptime+0x18> <== 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 <rtems_clock_tick>:
*
* 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 <rtems_clock_tick+0x3c> 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 <rtems_clock_tick+0x40> 30008eb8: e5d33010 ldrb r3, [r3, #16]
if ( _Thread_Is_context_switch_necessary() &&
30008ebc: e3530000 cmp r3, #0
30008ec0: 0a000003 beq 30008ed4 <rtems_clock_tick+0x34>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
30008ec4: e59f3018 ldr r3, [pc, #24] ; 30008ee4 <rtems_clock_tick+0x44><== 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_receive>:
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 <rtems_event_receive+0x50>
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
30008ef4: e59f4044 ldr r4, [pc, #68] ; 30008f40 <rtems_event_receive+0x58>
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 <rtems_event_receive+0x5c> 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_extension_create>:
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_extension_create+0x94>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b350: e59f3074 ldr r3, [pc, #116] ; 3000b3cc <rtems_extension_create+0x9c> 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 <rtems_extension_create+0xa0> 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 <rtems_extension_create+0x50>
_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_extension_ident>:
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 <rtems_extension_ident+0x28><== 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 <rtems_extension_ident+0x2c><== NOT EXECUTED
3000bdb8: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
3000bdbc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000bd6c <rtems_get_version_string>:
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
}
3000bd6c: e59f0000 ldr r0, [pc, #0] ; 3000bd74 <rtems_get_version_string+0x8><== NOT EXECUTED 3000bd70: e12fff1e bx lr <== NOT EXECUTED
3000a2f0 <rtems_interrupt_disable>:
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 <rtems_interrupt_enable>:
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 <rtems_interrupt_flash>:
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 <rtems_interrupt_is_in_progress>:
#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 <rtems_interrupt_is_in_progress+0x14><== 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_interrupt_level_attribute>:
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 <rtems_io_close>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3000ff5c: e59fc044 ldr ip, [pc, #68] ; 3000ffa8 <rtems_io_close+0x4c>
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 <rtems_io_close+0x50> 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 <rtems_io_close+0x44>
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 <rtems_io_control>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3000ffb0: e59fc044 ldr ip, [pc, #68] ; 3000fffc <rtems_io_control+0x4c>
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 <rtems_io_control+0x50> 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 <rtems_io_control+0x44>
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 <rtems_io_open>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010004: e59fc044 ldr ip, [pc, #68] ; 30010050 <rtems_io_open+0x4c>
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 <rtems_io_open+0x50> 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 <rtems_io_open+0x44>
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 <rtems_io_read>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010058: e59fc044 ldr ip, [pc, #68] ; 300100a4 <rtems_io_read+0x4c>
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 <rtems_io_read+0x50> 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 <rtems_io_read+0x44>
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_io_register_driver>:
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_io_register_driver+0x168>
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 <rtems_io_register_driver+0x16c>
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 <rtems_io_register_driver+0x134>
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 <rtems_io_register_driver+0x134>
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 <rtems_io_register_driver+0x144>
3000af4c: e5910004 ldr r0, [r1, #4] 3000af50: e3500000 cmp r0, #0
3000af54: 1a00003c bne 3000b04c <rtems_io_register_driver+0x144>
3000af58: ea000037 b 3000b03c <rtems_io_register_driver+0x134> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000af5c: e59f3114 ldr r3, [pc, #276] ; 3000b078 <rtems_io_register_driver+0x170> 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 <rtems_io_register_driver+0x174>
3000af74: 1a000010 bne 3000afbc <rtems_io_register_driver+0xb4>
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 <rtems_io_register_driver+0x16c> 3000af7c: e593c000 ldr ip, [r3] 3000af80: e5903000 ldr r3, [r0] 3000af84: ea000006 b 3000afa4 <rtems_io_register_driver+0x9c>
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 <rtems_io_register_driver+0x150>
3000af94: e5930004 ldr r0, [r3, #4] 3000af98: e3500000 cmp r0, #0
3000af9c: 1a00002d bne 3000b058 <rtems_io_register_driver+0x150>
3000afa0: ea000001 b 3000afac <rtems_io_register_driver+0xa4>
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 <rtems_io_register_driver+0x80>
}
/* 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 <rtems_io_register_driver+0xf8>
3000afb8: ea000029 b 3000b064 <rtems_io_register_driver+0x15c> <== 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 <rtems_io_register_driver+0xe0> <== 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 <rtems_io_register_driver+0xf8> <== 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 <rtems_io_register_driver+0x174>
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 <rtems_io_initialize>
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 <rtems_io_register_driver+0x54>
3000b054: eafffffa b 3000b044 <rtems_io_register_driver+0x13c> <== 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 <rtems_io_register_driver+0x9c>
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_io_unregister_driver>:
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_io_unregister_driver+0x64>
*/
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 <rtems_io_unregister_driver+0x68> 3000b09c: e5933000 ldr r3, [r3] 3000b0a0: e1500003 cmp r0, r3
3000b0a4: 2a00000c bcs 3000b0dc <rtems_io_unregister_driver+0x5c>
3000b0a8: e59f303c ldr r3, [pc, #60] ; 3000b0ec <rtems_io_unregister_driver+0x6c> 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 <rtems_io_unregister_driver+0x70>
&_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 <memset>
&_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 <rtems_io_write>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300100ac: e59fc044 ldr ip, [pc, #68] ; 300100f8 <rtems_io_write+0x4c>
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 <rtems_io_write+0x50> 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 <rtems_io_write+0x44>
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 <rtems_iterate_over_all_threads>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
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 <rtems_iterate_over_all_threads+0x64><== NOT EXECUTED
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
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 <rtems_iterate_over_all_threads+0x58><== 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 <rtems_iterate_over_all_threads+0x4c><== NOT EXECUTED 3000c110: ea000008 b 3000c138 <rtems_iterate_over_all_threads+0x58> <== 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 <rtems_iterate_over_all_threads+0x34><== 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 <rtems_iterate_over_all_threads+0x14><== NOT EXECUTED
3000c140: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30015d8c <rtems_message_queue_broadcast>:
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 <rtems_message_queue_broadcast+0x70>
return RTEMS_INVALID_ADDRESS;
if ( !count )
30015da4: e3530000 cmp r3, #0
30015da8: 0a000013 beq 30015dfc <rtems_message_queue_broadcast+0x70>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
30015dac: e59f0050 ldr r0, [pc, #80] ; 30015e04 <rtems_message_queue_broadcast+0x78> 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 <rtems_message_queue_broadcast+0x74>
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 <rtems_message_queue_broadcast+0x74>
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 <rtems_message_queue_create>:
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 <rtems_message_queue_create+0xd8>
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 <rtems_message_queue_create+0xd8>
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 <rtems_message_queue_create+0xd8>
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_message_queue_create+0xd8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3001106c: e59f3090 ldr r3, [pc, #144] ; 30011104 <rtems_message_queue_create+0xdc> 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 <rtems_message_queue_create+0x6c>
_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 <rtems_message_queue_create+0xd8> <== 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_message_queue_create+0xb4>
*/
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 <rtems_message_queue_create+0xe0><== 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 <rtems_message_queue_create+0xd8> <== 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 <rtems_message_queue_create+0xe0>
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_message_queue_get_number_pending>:
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 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED 30015fb0: e59f002c ldr r0, [pc, #44] ; 30015fe4 <rtems_message_queue_get_number_pending+0x48><== 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 <rtems_message_queue_get_number_pending+0x44><== 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 <rtems_message_queue_receive>:
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 <rtems_message_queue_receive+0x84>
return RTEMS_INVALID_ADDRESS;
if ( !size )
30011158: e3520000 cmp r2, #0
3001115c: 0a000018 beq 300111c4 <rtems_message_queue_receive+0x84>
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 <rtems_message_queue_receive+0x8c> 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 <rtems_message_queue_receive+0x88>
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 <rtems_message_queue_receive+0x90> 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 <rtems_message_queue_receive+0x88>
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 <rtems_object_api_maximum_class>:
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_object_api_minimum_class>:
*/
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 <rtems_object_get_api_class_name>:
)
{
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 <rtems_object_get_api_class_name+0x1c><== 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 <rtems_object_get_api_class_name+0x44><== 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 <rtems_object_get_api_class_name+0x34><== NOT EXECUTED 3000b264: ea000000 b 3000b26c <rtems_object_get_api_class_name+0x20> <== 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 <rtems_object_get_api_class_name+0x48><== 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 <rtems_assoc_ptr_by_local> <== 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 <rtems_object_get_api_class_name+0x3c> <== 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 <rtems_object_get_api_class_name+0x4c><== 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 <rtems_object_get_api_class_name+0x50><== NOT EXECUTED
}
3000b28c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b2a0 <rtems_object_get_api_name>:
};
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 <rtems_object_get_api_name+0x20><== NOT EXECUTED 3000b2ac: eb0012ad bl 3000fd68 <rtems_assoc_ptr_by_local> <== 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 <rtems_object_get_api_name+0x24><== NOT EXECUTED
}
3000b2bc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b2f8 <rtems_object_get_class_information>:
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 <rtems_object_get_class_information+0x78><== 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 <rtems_object_get_class_information+0x64><== 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 <rtems_object_get_class_information+0x50><== 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_object_get_classic_name>:
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 <rtems_object_get_classic_name+0x28> <== 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 <rtems_object_get_classic_name+0x2c><== NOT EXECUTED 3000a630: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
}
3000a634: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000a8e8 <rtems_object_get_name>:
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 <rtems_object_id_api_maximum>:
#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 <rtems_object_id_api_minimum>:
#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_object_id_get_api>:
*/
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 <rtems_object_id_get_class>:
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 <rtems_object_id_get_index>:
#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 <rtems_object_id_get_node>:
* 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_object_set_name>:
*/
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 <rtems_object_set_name+0x6c> <== 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 <rtems_object_set_name+0x70><== 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 <rtems_object_set_name+0x68> <== 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 <rtems_object_set_name+0x68> <== 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 <rtems_object_set_name+0x6c> <== 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 <rtems_partition_create>:
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 <rtems_partition_create+0xe8>
return RTEMS_INVALID_ADDRESS;
if ( !id )
300161dc: e59d2028 ldr r2, [sp, #40] ; 0x28 300161e0: e3520000 cmp r2, #0
300161e4: 0a00002d beq 300162a0 <rtems_partition_create+0xe8>
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 <rtems_partition_create+0xf0>
300161f4: e1590003 cmp r9, r3
300161f8: 3a00002a bcc 300162a8 <rtems_partition_create+0xf0>
300161fc: e3130007 tst r3, #7
30016200: 1a000028 bne 300162a8 <rtems_partition_create+0xf0>
!_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 <rtems_partition_create+0xf8>
3001620c: e59f30a4 ldr r3, [pc, #164] ; 300162b8 <rtems_partition_create+0x100> 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 <rtems_partition_create+0x104> 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 <rtems_partition_create+0x84>
_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_partition_delete>:
*/
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 <rtems_partition_delete+0x64> 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 <rtems_partition_delete+0x60>
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 <rtems_partition_delete+0x58>
_Objects_Close( &_Partition_Information, &the_partition->Object );
300162f4: e59f0028 ldr r0, [pc, #40] ; 30016324 <rtems_partition_delete+0x64> 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 <rtems_partition_delete+0x64> 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 <rtems_partition_delete+0x60>
}
_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_partition_return_buffer>:
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 <rtems_partition_return_buffer+0x9c> 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 <rtems_partition_return_buffer+0x8c>
)
{
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 <rtems_partition_return_buffer+0x90>
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_partition_return_buffer+0x90>
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 <rtems_partition_return_buffer+0x8c> <== NOT EXECUTED
30015820 <rtems_port_create>:
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_port_create+0x9c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30015858: e59f3064 ldr r3, [pc, #100] ; 300158c4 <rtems_port_create+0xa4> 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 <rtems_port_create+0xa8> 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 <rtems_port_create+0x68>
_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_rate_monotonic_cancel>:
*/
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 <rtems_rate_monotonic_cancel+0x60> 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 <rtems_rate_monotonic_cancel+0x5c>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
30016498: e59f3034 ldr r3, [pc, #52] ; 300164d4 <rtems_rate_monotonic_cancel+0x64> 3001649c: e5952040 ldr r2, [r5, #64] ; 0x40 300164a0: e5933004 ldr r3, [r3, #4] 300164a4: e1520003 cmp r2, r3
300164a8: 0a000002 beq 300164b8 <rtems_rate_monotonic_cancel+0x48>
_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 <rtems_rate_monotonic_cancel+0x5c> <== 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_rate_monotonic_create>:
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_rate_monotonic_create+0xb8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000a258: e59f309c ldr r3, [pc, #156] ; 3000a2fc <rtems_rate_monotonic_create+0xc0> 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 <rtems_rate_monotonic_create+0xc4> 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 <rtems_rate_monotonic_create+0x4c>
_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 <rtems_rate_monotonic_create+0xc8>
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 <memset> 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_rate_monotonic_get_statistics>:
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 <rtems_rate_monotonic_get_statistics+0xac><== NOT EXECUTED 3000fd70: e59f0094 ldr r0, [pc, #148] ; 3000fe0c <rtems_rate_monotonic_get_statistics+0xb0><== 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 <rtems_rate_monotonic_get_statistics+0xac><== 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_rate_monotonic_get_status>:
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 <rtems_rate_monotonic_get_status+0xa8><== NOT EXECUTED 3000fe28: e1a01003 mov r1, r3 <== NOT EXECUTED 3000fe2c: e28d2010 add r2, sp, #16 <== NOT EXECUTED 3000fe30: e59f0088 ldr r0, [pc, #136] ; 3000fec0 <rtems_rate_monotonic_get_status+0xb0><== 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 <rtems_rate_monotonic_get_status+0xa8><== 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 <rtems_rate_monotonic_get_status+0xa0><== 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 <rtems_rate_monotonic_get_status+0x84><== 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 <rtems_rate_monotonic_get_status+0xa8> <== 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_rate_monotonic_period>:
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 <rtems_rate_monotonic_period+0x180> 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 <rtems_rate_monotonic_period+0x174>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
3000a568: e59f3150 ldr r3, [pc, #336] ; 3000a6c0 <rtems_rate_monotonic_period+0x184> 3000a56c: e5902040 ldr r2, [r0, #64] ; 0x40 3000a570: e5933004 ldr r3, [r3, #4] 3000a574: e1520003 cmp r2, r3
3000a578: 0a000002 beq 3000a588 <rtems_rate_monotonic_period+0x4c>
_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 <rtems_rate_monotonic_period+0x178> <== NOT EXECUTED
}
if ( length == RTEMS_PERIOD_STATUS ) {
3000a588: e3540000 cmp r4, #0
3000a58c: 1a000005 bne 3000a5a8 <rtems_rate_monotonic_period+0x6c>
switch ( the_period->state ) {
3000a590: e5903038 ldr r3, [r0, #56] ; 0x38 3000a594: e3530004 cmp r3, #4 3000a598: 959f2124 ldrls r2, [pc, #292] ; 3000a6c4 <rtems_rate_monotonic_period+0x188> 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 <rtems_rate_monotonic_period+0x178>
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 <rtems_rate_monotonic_period+0xcc>
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 <rtems_rate_monotonic_period+0x18c>
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 <rtems_rate_monotonic_period+0x190> 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 <rtems_rate_monotonic_period+0x178>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
3000a608: e3530002 cmp r3, #2
3000a60c: 1a000019 bne 3000a678 <rtems_rate_monotonic_period+0x13c>
/*
* 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 <rtems_rate_monotonic_period+0x184>
_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 <rtems_rate_monotonic_period+0x184> 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 <rtems_rate_monotonic_period+0x178> <== NOT EXECUTED
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
3000a678: e3530004 cmp r3, #4 <== NOT EXECUTED 3000a67c: 1a00000b bne 3000a6b0 <rtems_rate_monotonic_period+0x174> <== 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 <rtems_rate_monotonic_period+0x190><== 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 <rtems_rate_monotonic_period+0x178> <== 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 <rtems_rate_monotonic_report_statistics>:
void rtems_rate_monotonic_report_statistics( void )
{
rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin );
3000a8dc: e59f1004 ldr r1, [pc, #4] ; 3000a8e8 <rtems_rate_monotonic_report_statistics+0xc><== NOT EXECUTED 3000a8e0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a8e4: eaffff79 b 3000a6d0 <rtems_rate_monotonic_report_statistics_with_plugin><== NOT EXECUTED
3000a6d0 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
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 <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc><== NOT EXECUTED
return;
(*print)( context, "Period information by period\n" );
3000a6e4: e59f11c8 ldr r1, [pc, #456] ; 3000a8b4 <rtems_rate_monotonic_report_statistics_with_plugin+0x1e4><== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x1e8><== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x1ec><== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f0><== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f4><== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f8><== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x1d0><== 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 <rtems_rate_monotonic_get_statistics> <== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL )
3000a764: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a768: 1a00004b bne 3000a89c <rtems_rate_monotonic_report_statistics_with_plugin+0x1cc><== 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 <rtems_rate_monotonic_get_status> <== 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 <rtems_object_get_name> <== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x1fc><== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x100><== NOT EXECUTED
(*print)( context, "\n" );
3000a7bc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a7c0: e59f1108 ldr r1, [pc, #264] ; 3000a8d0 <rtems_rate_monotonic_report_statistics_with_plugin+0x200><== NOT EXECUTED 3000a7c4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a7c8: e12fff14 bx r4 <== NOT EXECUTED
continue;
3000a7cc: ea000032 b 3000a89c <rtems_rate_monotonic_report_statistics_with_plugin+0x1cc><== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x204><== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x208><== 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 <rtems_rate_monotonic_report_statistics_with_plugin+0x88><== 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 <rtems_rate_monotonic_reset_all_statistics>:
3000a8ec: e59f3038 ldr r3, [pc, #56] ; 3000a92c <rtems_rate_monotonic_reset_all_statistics+0x40><== 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 <rtems_rate_monotonic_reset_all_statistics+0x44><== NOT EXECUTED 3000a904: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED 3000a908: ea000002 b 3000a918 <rtems_rate_monotonic_reset_all_statistics+0x2c><== 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 <rtems_rate_monotonic_reset_statistics><== 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 <rtems_rate_monotonic_reset_all_statistics+0x20><== 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_rate_monotonic_reset_statistics>:
*/
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 <rtems_rate_monotonic_reset_statistics+0x58><== 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 <rtems_rate_monotonic_reset_statistics+0x54><== 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 <memset> <== 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 <rtems_region_create>:
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 <rtems_region_create+0xec>
return RTEMS_INVALID_NAME;
if ( !starting_address )
30016c00: e3560000 cmp r6, #0
30016c04: 0a00002e beq 30016cc4 <rtems_region_create+0xe8>
return RTEMS_INVALID_ADDRESS;
if ( !id )
30016c08: e35b0000 cmp fp, #0
30016c0c: 0a00002c beq 30016cc4 <rtems_region_create+0xe8>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
30016c10: e59f30b8 ldr r3, [pc, #184] ; 30016cd0 <rtems_region_create+0xf4>
* 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 <rtems_region_create+0xf8> 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 <rtems_region_create+0xd8>
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_region_create+0x8c>
*/
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 <rtems_region_create+0xd8> <== 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 <rtems_region_create+0xf4> 30016cb8: e5930000 ldr r0, [r3] 30016cbc: eb00090b bl 300190f0 <_API_Mutex_Unlock>
return return_status;
30016cc0: ea000000 b 30016cc8 <rtems_region_create+0xec>
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_region_extend>:
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 <rtems_region_extend+0x90> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
30016d6c: e59f3078 ldr r3, [pc, #120] ; 30016dec <rtems_region_extend+0x98><== 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 <rtems_region_extend+0x9c><== 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 <rtems_region_extend+0x84> <== 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 <rtems_region_extend+0x84> <== 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 <rtems_region_extend+0x98><== 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_region_get_free_information>:
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 <rtems_region_get_free_information+0x64><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30016e08: e59f3050 ldr r3, [pc, #80] ; 30016e60 <rtems_region_get_free_information+0x6c><== 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 <rtems_region_get_free_information+0x70><== 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 <rtems_region_get_free_information+0x58><== 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 <rtems_region_get_free_information+0x6c><== 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_region_get_information>:
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 <rtems_region_get_information+0x54> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30016e7c: e59f3040 ldr r3, [pc, #64] ; 30016ec4 <rtems_region_get_information+0x5c><== 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 <rtems_region_get_information+0x60><== 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 <rtems_region_get_information+0x5c><== 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_region_get_segment_size>:
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 <rtems_region_get_segment_size+0x7c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !size )
3001700c: e3520000 cmp r2, #0 <== NOT EXECUTED 30017010: 0a000017 beq 30017074 <rtems_region_get_segment_size+0x7c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30017014: e59f3064 ldr r3, [pc, #100] ; 30017080 <rtems_region_get_segment_size+0x88><== 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 <rtems_region_get_segment_size+0x8c><== 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 <rtems_region_get_segment_size+0x50> <== 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 <rtems_region_get_segment_size+0x68> <== 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 <rtems_region_get_segment_size+0x88><== 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 <rtems_region_get_segment_size+0x80> <== 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_region_resize_segment>:
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 <rtems_region_resize_segment+0xa8> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
300170d4: e59f408c ldr r4, [pc, #140] ; 30017168 <rtems_region_resize_segment+0xb0><== 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 <rtems_region_resize_segment+0xb4><== 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 <rtems_region_resize_segment+0x9c> <== 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 <rtems_region_resize_segment+0x84> <== 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 <rtems_region_resize_segment+0xa8> <== 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 <rtems_region_resize_segment+0xa8> <== 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_region_return_segment>:
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_region_return_segment+0x80>
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 <rtems_region_return_segment+0x84> 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_region_return_segment+0x6c>
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 <rtems_region_return_segment+0x6c>
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 <rtems_region_return_segment+0x78>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
300171dc: e59f300c ldr r3, [pc, #12] ; 300171f0 <rtems_region_return_segment+0x80><== 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 <rtems_semaphore_create>:
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 <rtems_semaphore_create+0x19c>
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 <rtems_semaphore_create+0x19c>
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_semaphore_create+0x54>
*/
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 <rtems_semaphore_create+0x198>
3000929c: e3180004 tst r8, #4
300092a0: 0a000052 beq 300093f0 <rtems_semaphore_create+0x198>
_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 <rtems_semaphore_create+0x198>
_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 <rtems_semaphore_create+0x68>
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_semaphore_create+0x19c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
300092c0: e59f3134 ldr r3, [pc, #308] ; 300093fc <rtems_semaphore_create+0x1a4> 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 <rtems_semaphore_create+0x1a8> 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 <rtems_semaphore_create+0x94>
_Thread_Enable_dispatch();
300092e0: eb00093b bl 3000b7d4 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
300092e4: e3a00005 mov r0, #5 300092e8: ea000041 b 300093f4 <rtems_semaphore_create+0x19c>
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 <rtems_semaphore_create+0xdc>
/*
* 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 <rtems_semaphore_create+0x170>
} 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 <rtems_semaphore_create+0x134>
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 <rtems_semaphore_create+0x138>
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 <rtems_semaphore_create+0x130>
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 <rtems_semaphore_create+0x138>
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_semaphore_create+0x170>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
300093b0: e59f0048 ldr r0, [pc, #72] ; 30009400 <rtems_semaphore_create+0x1a8> 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 <rtems_semaphore_create+0x19c>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300093c8: e59f2030 ldr r2, [pc, #48] ; 30009400 <rtems_semaphore_create+0x1a8>
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 <rtems_semaphore_create+0x19c>
}
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 <rtems_semaphore_delete>:
#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 <rtems_semaphore_delete+0x98> 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_semaphore_delete+0x94>
*/
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 <rtems_semaphore_delete+0x68>
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 <rtems_semaphore_delete+0x54>
30009444: e3510020 cmp r1, #32
30009448: 0a000002 beq 30009458 <rtems_semaphore_delete+0x54>
!_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 <rtems_semaphore_delete+0x94> <== 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 <rtems_semaphore_delete+0x74>
&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 <rtems_semaphore_delete+0x98> 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 <rtems_semaphore_delete+0x98> 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 <rtems_semaphore_flush>:
#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 <rtems_semaphore_flush+0x58>
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_semaphore_flush+0x54>
*/
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 <rtems_semaphore_flush+0x44>
_CORE_mutex_Flush(
30011fd0: e1a01003 mov r1, r3 30011fd4: e3a02001 mov r2, #1 30011fd8: ebffe4d9 bl 3000b344 <_CORE_mutex_Flush> 30011fdc: ea000001 b 30011fe8 <rtems_semaphore_flush+0x4c>
&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_semaphore_obtain>:
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 <rtems_semaphore_obtain+0x108> 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 <rtems_semaphore_obtain+0x104>
300094d4: e5903010 ldr r3, [r0, #16] 300094d8: e59f70cc ldr r7, [pc, #204] ; 300095ac <rtems_semaphore_obtain+0x10c>
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
300094dc: e2132030 ands r2, r3, #48 ; 0x30
300094e0: 0a00000b beq 30009514 <rtems_semaphore_obtain+0x74>
_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 <rtems_semaphore_obtain+0x104>
{
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 <rtems_semaphore_obtain+0x9c>
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 <rtems_semaphore_obtain+0xf4>
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
3000953c: e3160001 tst r6, #1
30009540: 0a000004 beq 30009558 <rtems_semaphore_obtain+0xb8>
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 <rtems_semaphore_obtain+0xf4> <== NOT EXECUTED
30009558: e59f2050 ldr r2, [pc, #80] ; 300095b0 <rtems_semaphore_obtain+0x110> 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 <rtems_semaphore_obtain+0x114> 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 <rtems_semaphore_obtain+0x10c> 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 <rtems_shutdown_executive>:
void rtems_shutdown_executive(
uint32_t result
)
{
if ( _System_state_Is_up( _System_state_Get() ) ) {
30015c60: e59f3028 ldr r3, [pc, #40] ; 30015c90 <rtems_shutdown_executive+0x30>
*/
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 <rtems_shutdown_executive+0x34> 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_signal_send>:
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 <rtems_signal_send+0xb4>
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 <rtems_signal_send+0xb4>
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 <rtems_signal_send+0xac>
if ( asr->is_enabled ) {
300176bc: e5d32008 ldrb r2, [r3, #8] 300176c0: e3520000 cmp r2, #0
300176c4: 0a00000f beq 30017708 <rtems_signal_send+0x84>
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 <rtems_signal_send+0xb8> 300176e8: e5932000 ldr r2, [r3] 300176ec: e3520000 cmp r2, #0
300176f0: 0a00000b beq 30017724 <rtems_signal_send+0xa0>
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 <rtems_signal_send+0xa0> <== 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 <rtems_signal_send+0xb4>
}
_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_task_delete>:
*/
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_task_delete+0x74>
*/
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 <rtems_task_delete+0x64>
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 <rtems_task_delete+0x70>
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_task_get_note>:
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_task_get_note+0xac>
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 <rtems_task_get_note+0xa8>
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 <rtems_task_get_note+0xa8>
/*
* 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 <rtems_task_get_note+0xa8>
/*
* 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 <rtems_task_get_note+0x58>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
3000b7c8: e59f2064 ldr r2, [pc, #100] ; 3000b834 <rtems_task_get_note+0xb0> 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 <rtems_task_get_note+0x78>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
3000b7dc: e59f3050 ldr r3, [pc, #80] ; 3000b834 <rtems_task_get_note+0xb0><== 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 <rtems_task_get_note+0xa8> <== 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 <rtems_task_get_note+0xa8>
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_task_ident>:
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 <rtems_task_ident+0x4c>
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
30009828: e3500000 cmp r0, #0
3000982c: 1a000004 bne 30009844 <rtems_task_ident+0x30>
*id = _Thread_Executing->Object.id;
30009830: e59f2030 ldr r2, [pc, #48] ; 30009868 <rtems_task_ident+0x54><== 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 <rtems_task_ident+0x58> 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 <rtems_task_ident+0x5c>
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_task_is_suspended>:
*/
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 <rtems_task_is_suspended+0x3c> <== 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 <rtems_task_is_suspended+0x34> <== 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 <rtems_task_is_suspended+0x3c> <== 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_task_restart>:
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 <rtems_task_restart+0x48>
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 <rtems_task_restart+0x40>
_Thread_Enable_dispatch();
3000a54c: eb0007cc bl 3000c484 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a550: e1a00004 mov r0, r4 3000a554: ea000001 b 3000a560 <rtems_task_restart+0x48>
}
_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_task_resume>:
*/
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_task_resume+0x48>
*/
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 <rtems_task_resume+0x40>
_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 <rtems_task_resume+0x48>
}
_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_task_set_note>:
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_task_set_note+0x98>
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 <rtems_task_set_note+0x94>
/*
* 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 <rtems_task_set_note+0x94>
/*
* 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 <rtems_task_set_note+0x4c>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
3000b950: e59f205c ldr r2, [pc, #92] ; 3000b9b4 <rtems_task_set_note+0x9c> 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 <rtems_task_set_note+0x68>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
3000b964: e59f3048 ldr r3, [pc, #72] ; 3000b9b4 <rtems_task_set_note+0x9c><== 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 <rtems_task_set_note+0x94> <== 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 <rtems_task_set_note+0x94>
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_task_set_priority>:
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_task_set_priority+0x24>
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 <rtems_task_set_priority+0x8c> 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_task_set_priority+0x88>
!_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 <rtems_task_set_priority+0x88>
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 <rtems_task_set_priority+0x88>
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 <rtems_task_set_priority+0x80>
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 <rtems_task_set_priority+0x74>
3000da8c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000da90: e1530004 cmp r3, r4 <== NOT EXECUTED 3000da94: 9a000002 bls 3000daa4 <rtems_task_set_priority+0x80> <== 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_task_start>:
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 <rtems_task_start+0x5c>
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 <rtems_task_start+0x5c>
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 <rtems_task_start+0x54>
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 <rtems_task_start+0x5c>
}
_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_task_suspend>:
*/
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_task_suspend+0x44>
*/
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 <rtems_task_suspend+0x3c>
_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 <rtems_task_suspend+0x44>
}
_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_task_variable_add>:
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 <rtems_task_variable_add+0xa4>
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 <rtems_task_variable_add+0x54>
3000a630: ea00001a b 3000a6a0 <rtems_task_variable_add+0xa0> <== 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 <rtems_task_variable_add+0x50> <== 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 <rtems_task_variable_add+0xa4> <== 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 <rtems_task_variable_add+0x34>
/*
* 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 <rtems_task_variable_add+0x78>
_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 <rtems_task_variable_add+0xa4> <== 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 <rtems_task_variable_add+0xa4>
#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_task_variable_delete>:
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 <rtems_task_variable_delete+0x68> <== 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 <rtems_task_variable_delete+0x5c> <== NOT EXECUTED 3000a6cc: ea000011 b 3000a718 <rtems_task_variable_delete+0x70> <== 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 <rtems_task_variable_delete+0x54> <== 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 <rtems_task_variable_delete+0x74> <== 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 <rtems_task_variable_delete+0x28> <== 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 <rtems_task_variable_delete+0x74> <== 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_task_variable_get>:
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 <rtems_task_variable_get+0x64> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !result )
3000a730: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a734: 0a000012 beq 3000a784 <rtems_task_variable_get+0x64> <== 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 <rtems_task_variable_get+0x58> <== NOT EXECUTED 3000a750: ea00000d b 3000a78c <rtems_task_variable_get+0x6c> <== 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 <rtems_task_variable_get+0x54> <== 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 <rtems_task_variable_get+0x70> <== 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 <rtems_task_variable_get+0x34> <== 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 <rtems_task_variable_get+0x70> <== 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 <rtems_task_wake_after>:
30009954: e59f3074 ldr r3, [pc, #116] ; 300099d0 <rtems_task_wake_after+0x7c>
*/
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 <rtems_task_wake_after+0x30>
* 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 <rtems_task_wake_after+0x80> 30009978: e1a0e00f mov lr, pc 3000997c: e593f00c ldr pc, [r3, #12] 30009980: ea00000f b 300099c4 <rtems_task_wake_after+0x70>
_Scheduler_Yield();
} else {
_Thread_Set_state( _Thread_Executing, STATES_DELAYING );
30009984: e59f504c ldr r5, [pc, #76] ; 300099d8 <rtems_task_wake_after+0x84><== 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 <rtems_task_wake_after+0x88><== 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 <rtems_task_wake_after+0x8c><== 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_task_wake_when>:
rtems_time_of_day *time_buffer
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000ab88: e59f30bc ldr r3, [pc, #188] ; 3000ac4c <rtems_task_wake_when+0xc4>
*/
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 <rtems_task_wake_when+0xc8>
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 <rtems_task_wake_when+0xbc>
3000abe4: e59f3068 ldr r3, [pc, #104] ; 3000ac54 <rtems_task_wake_when+0xcc> 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 <rtems_task_wake_when+0xd0> 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 <rtems_task_wake_when+0xd4>
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 <rtems_task_wake_when+0xd8> 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_timer_create>:
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 <rtems_timer_create+0x8c>
30009e50: e59f3070 ldr r3, [pc, #112] ; 30009ec8 <rtems_timer_create+0x94> 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 <rtems_timer_create+0x98> 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 <rtems_timer_create+0x4c>
_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_timer_fire_after>:
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 <rtems_timer_fire_after+0xa8>
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 <rtems_timer_fire_after+0xa8>
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
30009ef8: e59f007c ldr r0, [pc, #124] ; 30009f7c <rtems_timer_fire_after+0xac> 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 <rtems_timer_fire_after+0xa8>
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 <rtems_timer_fire_after+0x78>
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 <rtems_timer_fire_after+0xa0> <== 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 <rtems_timer_fire_after+0xb0>
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_timer_fire_when>:
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_timer_fire_when+0xd4>
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 <rtems_timer_fire_when+0xd0>
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 <rtems_timer_fire_when+0xcc>
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 <rtems_timer_fire_when+0xd0>
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 <rtems_timer_fire_when+0xd8>
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 <rtems_timer_fire_when+0xcc>
30018264: e59f0074 ldr r0, [pc, #116] ; 300182e0 <rtems_timer_fire_when+0xdc> 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 <rtems_timer_fire_when+0xd0>
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 <rtems_timer_fire_when+0xe0> 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 <rtems_timer_fire_when+0xd0>
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_timer_get_information>:
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 <rtems_timer_get_information+0x5c> <== NOT EXECUTED 300182fc: e59f0044 ldr r0, [pc, #68] ; 30018348 <rtems_timer_get_information+0x60><== 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 <rtems_timer_get_information+0x5c> <== 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_timer_initiate_server>:
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 <rtems_timer_initiate_server+0x2c> <== NOT EXECUTED
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
30018978: e59f3124 ldr r3, [pc, #292] ; 30018aa4 <rtems_timer_initiate_server+0x144><== 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 <rtems_timer_initiate_server+0x44> <== 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 <rtems_timer_initiate_server+0x140> <== NOT EXECUTED 300189a0: ea000000 b 300189a8 <rtems_timer_initiate_server+0x48> <== 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 <rtems_timer_initiate_server+0x148><== 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 <rtems_timer_initiate_server+0x140> <== 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 <rtems_timer_initiate_server+0x14c><== 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 <rtems_task_create> <== 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 <rtems_timer_initiate_server+0x140> <== 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 <rtems_timer_initiate_server+0x150><== 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 <rtems_timer_initiate_server+0x154><== 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 <rtems_timer_initiate_server+0x158><== 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 <rtems_timer_initiate_server+0x15c><== 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 <rtems_timer_initiate_server+0x160><== 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 <rtems_timer_initiate_server+0x164><== 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 <rtems_timer_initiate_server+0x168><== 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 <rtems_task_start> <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
30018aa0: e8bd81fe pop {r1, r2, r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3001837c <rtems_timer_reset>:
*/
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 <rtems_timer_reset+0x8c>
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 <rtems_timer_reset+0x84>
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 <rtems_timer_reset+0x50>
_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 <rtems_timer_reset+0x90> 300183c0: e1a01006 mov r1, r6 300183c4: eb001175 bl 3001c9a0 <_Watchdog_Insert> 300183c8: ea00000b b 300183fc <rtems_timer_reset+0x80>
} 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 <rtems_timer_reset+0x80> <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
300183d8: e59f3030 ldr r3, [pc, #48] ; 30018410 <rtems_timer_reset+0x94><== 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_timer_server_fire_after>:
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 <rtems_timer_server_fire_after+0xc8><== 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 <rtems_timer_server_fire_after+0xc4> <== 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 <rtems_timer_server_fire_after+0xc4> <== 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 <rtems_timer_server_fire_after+0xc4> <== NOT EXECUTED 30018454: e59f0084 ldr r0, [pc, #132] ; 300184e0 <rtems_timer_server_fire_after+0xcc><== 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 <rtems_timer_server_fire_after+0xc4> <== 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 <rtems_timer_server_fire_after+0x8c> <== 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 <rtems_timer_server_fire_after+0xbc> <== 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_timer_server_fire_when>:
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 <rtems_timer_server_fire_when+0xe8><== 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 <rtems_timer_server_fire_when+0xe4> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
3001850c: e59f30bc ldr r3, [pc, #188] ; 300185d0 <rtems_timer_server_fire_when+0xec><== 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 <rtems_timer_server_fire_when+0xe4> <== 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 <rtems_timer_server_fire_when+0xe4> <== 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 <rtems_timer_server_fire_when+0xe0> <== 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 <rtems_timer_server_fire_when+0xf0><== 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 <rtems_timer_server_fire_when+0xe0> <== NOT EXECUTED 30018558: e59f0078 ldr r0, [pc, #120] ; 300185d8 <rtems_timer_server_fire_when+0xf4><== 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 <rtems_timer_server_fire_when+0xe4> <== 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 <rtems_timer_server_fire_when+0xe4> <== 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