3000f974 <TOD_MICROSECONDS_TO_TICKS>: /** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ microseconds_per_tick = rtems_configuration_get_microseconds_per_tick();
3000f974: e59f3030 ldr r3, [pc, #48] ; 3000f9ac <TOD_MICROSECONDS_TO_TICKS+0x38><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
3000f978: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ microseconds_per_tick = rtems_configuration_get_microseconds_per_tick();
3000f97c: e593500c ldr r5, [r3, #12] <== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
3000f980: e1a06000 mov r6, r0 <== NOT EXECUTED
* We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ microseconds_per_tick = rtems_configuration_get_microseconds_per_tick(); ticks = microseconds / microseconds_per_tick;
3000f984: e1a01005 mov r1, r5 <== NOT EXECUTED 3000f988: eb004a48 bl 300222b0 <__aeabi_uidiv> <== NOT EXECUTED
if ( (microseconds % microseconds_per_tick) != 0 )
3000f98c: e1a01005 mov r1, r5 <== NOT EXECUTED
* We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ microseconds_per_tick = rtems_configuration_get_microseconds_per_tick(); ticks = microseconds / microseconds_per_tick;
3000f990: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( (microseconds % microseconds_per_tick) != 0 )
3000f994: e1a00006 mov r0, r6 <== NOT EXECUTED 3000f998: eb004a8a bl 300223c8 <__umodsi3> <== NOT EXECUTED 3000f99c: e3500000 cmp r0, #0 <== NOT EXECUTED
ticks += 1;
3000f9a0: 12844001 addne r4, r4, #1 <== NOT EXECUTED
return ticks;
}
3000f9a4: e1a00004 mov r0, r4 <== NOT EXECUTED
3000f9a8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000b800 <TOD_MILLISECONDS_TO_TICKS>:
/**
* We should ensure the ticks not be truncated by integer division. We
* need to have it be greater than or equal to the requested time. It
* should not be shorter.
*/
milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick();
3000b800: e59f3040 ldr r3, [pc, #64] ; 3000b848 <TOD_MILLISECONDS_TO_TICKS+0x48><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000b804: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick();
3000b808: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000b80c: e1a06000 mov r6, r0 <== NOT EXECUTED
/** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick();
3000b810: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000b814: eb003d34 bl 3001acec <__aeabi_uidiv> <== NOT EXECUTED 3000b818: e1a05000 mov r5, r0 <== NOT EXECUTED
ticks = milliseconds / milliseconds_per_tick;
3000b81c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000b820: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b824: eb003d30 bl 3001acec <__aeabi_uidiv> <== NOT EXECUTED
if ( (milliseconds % milliseconds_per_tick) != 0 )
3000b828: e1a01005 mov r1, r5 <== NOT EXECUTED
* We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ milliseconds_per_tick = rtems_configuration_get_milliseconds_per_tick(); ticks = milliseconds / milliseconds_per_tick;
3000b82c: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( (milliseconds % milliseconds_per_tick) != 0 )
3000b830: e1a00006 mov r0, r6 <== NOT EXECUTED 3000b834: eb003d72 bl 3001ae04 <__umodsi3> <== NOT EXECUTED 3000b838: e3500000 cmp r0, #0 <== NOT EXECUTED
ticks += 1;
3000b83c: 12844001 addne r4, r4, #1 <== NOT EXECUTED
return ticks;
}
3000b840: e1a00004 mov r0, r4 <== NOT EXECUTED
3000b844: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30028990 <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 /
30028990: e59f3010 ldr r3, [pc, #16] ; 300289a8 <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)
{
30028994: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return (TOD_MICROSECONDS_PER_SECOND /
30028998: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3002899c: e59f0008 ldr r0, [pc, #8] ; 300289ac <TOD_TICKS_PER_SECOND_method+0x1c><== NOT EXECUTED 300289a0: ebff7105 bl 30004dbc <__aeabi_uidiv> <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick());
}
300289a4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300118a0 <_CORE_barrier_Wait>:
)
{
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
300118a0: e59fc074 ldr ip, [pc, #116] ; 3001191c <_CORE_barrier_Wait+0x7c>
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
300118a4: e92d40f0 push {r4, r5, r6, r7, lr}
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
300118a8: e59cc008 ldr ip, [ip, #8]
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
300118ac: e3a04000 mov r4, #0 300118b0: e58c4034 str r4, [ip, #52] ; 0x34
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
300118b4: e59d2014 ldr r2, [sp, #20]
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
300118b8: e10f4000 mrs r4, CPSR 300118bc: e3845080 orr r5, r4, #128 ; 0x80 300118c0: e129f005 msr CPSR_fc, r5
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
300118c4: e5906048 ldr r6, [r0, #72] ; 0x48
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
300118c8: e5905040 ldr r5, [r0, #64] ; 0x40
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
300118cc: e2866001 add r6, r6, #1
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
300118d0: e3550000 cmp r5, #0
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
300118d4: e5806048 str r6, [r0, #72] ; 0x48 300118d8: e3a05001 mov r5, #1
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
300118dc: 1a000006 bne 300118fc <_CORE_barrier_Wait+0x5c>
if ( the_barrier->number_of_waiting_threads ==
300118e0: e5907044 ldr r7, [r0, #68] ; 0x44 <== NOT EXECUTED 300118e4: e1560007 cmp r6, r7 <== NOT EXECUTED 300118e8: 1a000003 bne 300118fc <_CORE_barrier_Wait+0x5c> <== NOT EXECUTED
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
300118ec: e58c5034 str r5, [ip, #52] ; 0x34 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300118f0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
}
300118f4: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
_ISR_Enable( level );
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
300118f8: eaffffdc b 30011870 <_CORE_barrier_Release> <== NOT EXECUTED
300118fc: e5805030 str r5, [r0, #48] ; 0x30
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
30011900: e58c0044 str r0, [ip, #68] ; 0x44
executing->Wait.id = id;
30011904: e58c1020 str r1, [ip, #32] 30011908: e129f004 msr CPSR_fc, r4
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
3001190c: e59f200c ldr r2, [pc, #12] ; 30011920 <_CORE_barrier_Wait+0x80> 30011910: e1a01003 mov r1, r3
}
30011914: e8bd40f0 pop {r4, r5, r6, r7, lr}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
30011918: eafff27f b 3000e31c <_Thread_queue_Enqueue_with_handler>
30019d94 <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
30019d94: e590304c ldr r3, [r0, #76] ; 0x4c
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
30019d98: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
30019d9c: e1520003 cmp r2, r3
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
30019da0: e1a06000 mov r6, r0 30019da4: e1a0a001 mov sl, r1 30019da8: e1a07002 mov r7, r2 30019dac: e59d8020 ldr r8, [sp, #32]
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
30019db0: 8a000013 bhi 30019e04 <_CORE_message_queue_Broadcast+0x70>
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
30019db4: e5905048 ldr r5, [r0, #72] ; 0x48 30019db8: e3550000 cmp r5, #0
*count = 0;
30019dbc: 13a00000 movne r0, #0 30019dc0: 15880000 strne r0, [r8]
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
30019dc4: 0a000007 beq 30019de8 <_CORE_message_queue_Broadcast+0x54>
30019dc8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30019dcc: e594002c ldr r0, [r4, #44] ; 0x2c 30019dd0: e1a0100a mov r1, sl 30019dd4: e1a02007 mov r2, r7 30019dd8: eb001ca5 bl 30021074 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30019ddc: e5943028 ldr r3, [r4, #40] ; 0x28
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
30019de0: e2855001 add r5, r5, #1
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30019de4: e5837000 str r7, [r3]
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
30019de8: e1a00006 mov r0, r6 30019dec: eb000b29 bl 3001ca98 <_Thread_queue_Dequeue> 30019df0: e2504000 subs r4, r0, #0
30019df4: 1afffff4 bne 30019dcc <_CORE_message_queue_Broadcast+0x38>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
30019df8: e5885000 str r5, [r8]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30019dfc: e1a00004 mov r0, r4
30019e00: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
30019e04: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
30019e08: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30012b18 <_CORE_message_queue_Initialize>:
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
30012b18: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Check if allocated_message_size is aligned to uintptr-size boundary.
* If not, it will increase allocated_message_size to multiplicity of pointer
* size.
*/
if (allocated_message_size & (sizeof(uintptr_t) - 1)) {
30012b1c: e3130003 tst r3, #3
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
30012b20: e1a04000 mov r4, r0
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
30012b24: e3a00000 mov r0, #0
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
30012b28: e1a07001 mov r7, r1 30012b2c: e1a05002 mov r5, r2
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
30012b30: e5842044 str r2, [r4, #68] ; 0x44
the_message_queue->number_of_pending_messages = 0;
30012b34: e5840048 str r0, [r4, #72] ; 0x48
the_message_queue->maximum_message_size = maximum_message_size;
30012b38: e584304c str r3, [r4, #76] ; 0x4c
/*
* Check if allocated_message_size is aligned to uintptr-size boundary.
* If not, it will increase allocated_message_size to multiplicity of pointer
* size.
*/
if (allocated_message_size & (sizeof(uintptr_t) - 1)) {
30012b3c: 01a06003 moveq r6, r3
30012b40: 0a000003 beq 30012b54 <_CORE_message_queue_Initialize+0x3c>
allocated_message_size += sizeof(uintptr_t);
30012b44: e2836004 add r6, r3, #4 <== NOT EXECUTED
allocated_message_size &= ~(sizeof(uintptr_t) - 1);
30012b48: e3c66003 bic r6, r6, #3 <== NOT EXECUTED
/*
* Check for an overflow. It can occur while increasing allocated_message_size
* to multiplicity of uintptr_t above.
*/
if (allocated_message_size < maximum_message_size)
30012b4c: e1560003 cmp r6, r3 <== NOT EXECUTED
30012b50: 38bd80f0 popcc {r4, r5, r6, r7, pc} <== NOT EXECUTED
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
if ( !size_t_mult32_with_overflow(
30012b54: e2866010 add r6, r6, #16
size_t a,
size_t b,
size_t *c
)
{
long long x = (long long)a*b;
30012b58: e0810695 umull r0, r1, r5, r6
if ( x > SIZE_MAX )
30012b5c: e3e02000 mvn r2, #0 30012b60: e3a03000 mov r3, #0 30012b64: e1520000 cmp r2, r0 30012b68: e0d3c001 sbcs ip, r3, r1
*/
if ( !size_t_mult32_with_overflow(
(size_t) maximum_pending_messages,
allocated_message_size + sizeof(CORE_message_queue_Buffer_control),
&message_buffering_required ) )
return false;
30012b6c: b3a00000 movlt r0, #0
size_t *c
)
{
long long x = (long long)a*b;
if ( x > SIZE_MAX )
30012b70: b8bd80f0 poplt {r4, r5, r6, r7, pc}
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
30012b74: eb000b1d bl 300157f0 <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
30012b78: e3500000 cmp r0, #0
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
30012b7c: e1a01000 mov r1, r0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
30012b80: e584005c str r0, [r4, #92] ; 0x5c
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
30012b84: 0a000013 beq 30012bd8 <_CORE_message_queue_Initialize+0xc0>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
30012b88: e2840060 add r0, r4, #96 ; 0x60 30012b8c: e1a02005 mov r2, r5 30012b90: e1a03006 mov r3, r6 30012b94: ebffffcf bl 30012ad8 <_Chain_Initialize>
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
30012b98: e5971000 ldr r1, [r7]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
30012b9c: e2843050 add r3, r4, #80 ; 0x50 30012ba0: e2842054 add r2, r4, #84 ; 0x54
head->next = tail;
head->previous = NULL;
tail->previous = head;
30012ba4: e5843058 str r3, [r4, #88] ; 0x58 30012ba8: e2413001 sub r3, r1, #1 30012bac: e2731000 rsbs r1, r3, #0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
30012bb0: e5842050 str r2, [r4, #80] ; 0x50
head->previous = NULL;
30012bb4: e3a02000 mov r2, #0 30012bb8: e5842054 str r2, [r4, #84] ; 0x54 30012bbc: e1a00004 mov r0, r4 30012bc0: e0a11003 adc r1, r1, r3 30012bc4: e3a02080 mov r2, #128 ; 0x80 30012bc8: e3a03006 mov r3, #6 30012bcc: eb00090b bl 30015000 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
30012bd0: e3a00001 mov r0, #1
30012bd4: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
30012bd8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30012cc0 <_CORE_message_queue_Submit>:
)
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30012cc0: e590304c ldr r3, [r0, #76] ; 0x4c
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30012cc4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30012cc8: e1520003 cmp r2, r3
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30012ccc: e1a05000 mov r5, r0 30012cd0: e1a0a001 mov sl, r1 30012cd4: e1a04002 mov r4, r2 30012cd8: e59d7020 ldr r7, [sp, #32]
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
30012cdc: 83a00001 movhi r0, #1
)
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30012ce0: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
30012ce4: e5958048 ldr r8, [r5, #72] ; 0x48 30012ce8: e3580000 cmp r8, #0
30012cec: 1a00000b bne 30012d20 <_CORE_message_queue_Submit+0x60>
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
30012cf0: eb0007c8 bl 30014c18 <_Thread_queue_Dequeue>
if ( the_thread ) {
30012cf4: e2506000 subs r6, r0, #0
30012cf8: 0a000008 beq 30012d20 <_CORE_message_queue_Submit+0x60>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30012cfc: e596002c ldr r0, [r6, #44] ; 0x2c 30012d00: e1a0100a mov r1, sl 30012d04: e1a02004 mov r2, r4 30012d08: eb001a88 bl 30019730 <memcpy>
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30012d0c: e5963028 ldr r3, [r6, #40] ; 0x28
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30012d10: e1a00008 mov r0, r8
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30012d14: e5834000 str r4, [r3]
the_thread->Wait.count = (uint32_t) submit_type;
30012d18: e5867024 str r7, [r6, #36] ; 0x24
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30012d1c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
RTEMS_INLINE_ROUTINE CORE_message_queue_Buffer_control *
_CORE_message_queue_Allocate_message_buffer (
CORE_message_queue_Control *the_message_queue
)
{
return (CORE_message_queue_Buffer_control *)
30012d20: e2850060 add r0, r5, #96 ; 0x60 30012d24: ebffff5e bl 30012aa4 <_Chain_Get>
* No one waiting on the message queue at this time, so attempt to
* queue the message up for a future receive.
*/
the_message =
_CORE_message_queue_Allocate_message_buffer( the_message_queue );
if ( the_message ) {
30012d28: e2506000 subs r6, r0, #0
30012d2c: 0a00000a beq 30012d5c <_CORE_message_queue_Submit+0x9c>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
30012d30: e1a0100a mov r1, sl 30012d34: e1a02004 mov r2, r4 30012d38: e286000c add r0, r6, #12 30012d3c: eb001a7b bl 30019730 <memcpy>
size
);
the_message->Contents.size = size;
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
30012d40: e1a00005 mov r0, r5
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
30012d44: e5864008 str r4, [r6, #8]
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
30012d48: e1a01006 mov r1, r6 30012d4c: e1a02007 mov r2, r7 30012d50: eb001122 bl 300171e0 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30012d54: e3a00000 mov r0, #0
30012d58: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
}
#if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND)
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
30012d5c: e3a00002 mov r0, #2 <== NOT EXECUTED
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
30012d60: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000ada0 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
3000ada0: e92d40f0 push {r4, r5, r6, r7, lr}
3000ada4: e1a07003 mov r7, r3
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
3000ada8: e59f30b4 ldr r3, [pc, #180] ; 3000ae64 <_CORE_mutex_Seize+0xc4> 3000adac: e1a04000 mov r4, r0 3000adb0: e5933000 ldr r3, [r3] 3000adb4: e1a05001 mov r5, r1 3000adb8: e3530000 cmp r3, #0 3000adbc: e20260ff and r6, r2, #255 ; 0xff
3000adc0: 0a000007 beq 3000ade4 <_CORE_mutex_Seize+0x44>
3000adc4: ea000023 b 3000ae58 <_CORE_mutex_Seize+0xb8>
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
3000adc8: e59f3098 ldr r3, [pc, #152] ; 3000ae68 <_CORE_mutex_Seize+0xc8>
3000adcc: e5933000 ldr r3, [r3]
3000add0: e3530001 cmp r3, #1
3000add4: 83a00000 movhi r0, #0
3000add8: 81a01000 movhi r1, r0
3000addc: 83a02012 movhi r2, #18
3000ade0: 8b0001c0 blhi 3000b4e8 <_Internal_error_Occurred>
3000ade4: e1a00004 mov r0, r4
3000ade8: e28d1014 add r1, sp, #20
3000adec: eb001074 bl 3000efc4 <_CORE_mutex_Seize_interrupt_trylock>
3000adf0: e3500000 cmp r0, #0
3000adf4: 08bd80f0 popeq {r4, r5, r6, r7, pc}
3000adf8: e3560000 cmp r6, #0
3000adfc: e59f3068 ldr r3, [pc, #104] ; 3000ae6c <_CORE_mutex_Seize+0xcc>
3000ae00: 1a000005 bne 3000ae1c <_CORE_mutex_Seize+0x7c>
3000ae04: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
3000ae08: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
3000ae0c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
3000ae10: e3a02001 mov r2, #1 <== NOT EXECUTED
3000ae14: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
3000ae18: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000ae1c: e5933008 ldr r3, [r3, #8]
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000ae20: e3a02001 mov r2, #1 3000ae24: e5842030 str r2, [r4, #48] ; 0x30 3000ae28: e5834044 str r4, [r3, #68] ; 0x44 3000ae2c: e5835020 str r5, [r3, #32]
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000ae30: e59f302c ldr r3, [pc, #44] ; 3000ae64 <_CORE_mutex_Seize+0xc4> 3000ae34: e5932000 ldr r2, [r3]
++level;
3000ae38: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000ae3c: e5832000 str r2, [r3]
3000ae40: e59d3014 ldr r3, [sp, #20]
3000ae44: e129f003 msr CPSR_fc, r3
3000ae48: e1a00004 mov r0, r4
3000ae4c: e1a01007 mov r1, r7
3000ae50: ebffffb3 bl 3000ad24 <_CORE_mutex_Seize_interrupt_blocking>
3000ae54: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000ae58: e3560000 cmp r6, #0
3000ae5c: 1affffd9 bne 3000adc8 <_CORE_mutex_Seize+0x28>
3000ae60: eaffffdf b 3000ade4 <_CORE_mutex_Seize+0x44> <== NOT EXECUTED
3000efc4 <_CORE_mutex_Seize_interrupt_trylock>:
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
3000efc4: e1a03000 mov r3, r0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000efc8: e59f2104 ldr r2, [pc, #260] ; 3000f0d4 <_CORE_mutex_Seize_interrupt_trylock+0x110>
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000efcc: e593c050 ldr ip, [r3, #80] ; 0x50
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000efd0: e3a00000 mov r0, #0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000efd4: e5922008 ldr r2, [r2, #8]
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000efd8: e15c0000 cmp ip, r0
3000efdc: e92d4010 push {r4, lr}
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000efe0: e5820034 str r0, [r2, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000efe4: 0a00002a beq 3000f094 <_CORE_mutex_Seize_interrupt_trylock+0xd0>
the_mutex->lock = CORE_MUTEX_LOCKED;
3000efe8: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
3000efec: e5920008 ldr r0, [r2, #8]
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
3000eff0: e583205c str r2, [r3, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
3000eff4: e5830060 str r0, [r3, #96] ; 0x60
the_mutex->nest_count = 1;
3000eff8: e3a00001 mov r0, #1 3000effc: e5830054 str r0, [r3, #84] ; 0x54
*/
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
CORE_mutex_Attributes *the_attribute
)
{
return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
3000f000: e5930048 ldr r0, [r3, #72] ; 0x48
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000f004: e3500002 cmp r0, #2
3000f008: 0a000001 beq 3000f014 <_CORE_mutex_Seize_interrupt_trylock+0x50>
3000f00c: e3500003 cmp r0, #3
3000f010: 1a000029 bne 3000f0bc <_CORE_mutex_Seize_interrupt_trylock+0xf8>
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000f014: e592c01c ldr ip, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
3000f018: e3500003 cmp r0, #3
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000f01c: e28c4001 add r4, ip, #1 3000f020: e582401c str r4, [r2, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
3000f024: 1a000024 bne 3000f0bc <_CORE_mutex_Seize_interrupt_trylock+0xf8>
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
3000f028: e593004c ldr r0, [r3, #76] ; 0x4c
current = executing->current_priority;
3000f02c: e5924014 ldr r4, [r2, #20]
if ( current == ceiling ) {
3000f030: e1540000 cmp r4, r0
3000f034: 0a000020 beq 3000f0bc <_CORE_mutex_Seize_interrupt_trylock+0xf8>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
3000f038: 9a00000b bls 3000f06c <_CORE_mutex_Seize_interrupt_trylock+0xa8>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000f03c: e59f2094 ldr r2, [pc, #148] ; 3000f0d8 <_CORE_mutex_Seize_interrupt_trylock+0x114><== NOT EXECUTED 3000f040: e5920000 ldr r0, [r2] <== NOT EXECUTED
++level;
3000f044: e2800001 add r0, r0, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000f048: e5820000 str r0, [r2] <== NOT EXECUTED 3000f04c: e5912000 ldr r2, [r1] <== NOT EXECUTED 3000f050: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
3000f054: e3a02000 mov r2, #0 <== NOT EXECUTED 3000f058: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED 3000f05c: e593104c ldr r1, [r3, #76] ; 0x4c <== NOT EXECUTED 3000f060: ebfff4cc bl 3000c398 <_Thread_Change_priority> <== NOT EXECUTED
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
3000f064: ebfff5e4 bl 3000c7fc <_Thread_Enable_dispatch> <== NOT EXECUTED 3000f068: ea000015 b 3000f0c4 <_CORE_mutex_Seize_interrupt_trylock+0x100><== NOT EXECUTED
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
3000f06c: e3a00005 mov r0, #5 3000f070: e5820034 str r0, [r2, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000f074: e3a00001 mov r0, #1 3000f078: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
3000f07c: e3a00000 mov r0, #0 3000f080: e5830054 str r0, [r3, #84] ; 0x54
executing->resource_count--; /* undo locking above */
3000f084: e582c01c str ip, [r2, #28]
3000f088: e5913000 ldr r3, [r1]
3000f08c: e129f003 msr CPSR_fc, r3
3000f090: e8bd8010 pop {r4, pc}
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
3000f094: e593005c ldr r0, [r3, #92] ; 0x5c 3000f098: e1500002 cmp r0, r2
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000f09c: 13a00001 movne r0, #1
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
3000f0a0: 18bd8010 popne {r4, pc}
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
3000f0a4: e5932040 ldr r2, [r3, #64] ; 0x40 3000f0a8: e3520000 cmp r2, #0
3000f0ac: 1a000006 bne 3000f0cc <_CORE_mutex_Seize_interrupt_trylock+0x108>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
3000f0b0: e5932054 ldr r2, [r3, #84] ; 0x54 3000f0b4: e2822001 add r2, r2, #1 3000f0b8: e5832054 str r2, [r3, #84] ; 0x54 3000f0bc: e5913000 ldr r3, [r1] 3000f0c0: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
return 0;
3000f0c4: e3a00000 mov r0, #0
3000f0c8: e8bd8010 pop {r4, pc}
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000f0cc: e3a00001 mov r0, #1
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
3000f0d0: e8bd8010 pop {r4, pc}
3000ae70 <_CORE_mutex_Surrender>:
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
3000ae70: e92d4030 push {r4, r5, lr}
3000ae74: e1a04000 mov r4, r0
* allowed when the mutex in quetion is FIFO or simple Priority
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
3000ae78: e5d43044 ldrb r3, [r4, #68] ; 0x44
)
{
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
3000ae7c: e590005c ldr r0, [r0, #92] ; 0x5c
* allowed when the mutex in quetion is FIFO or simple Priority
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
3000ae80: e3530000 cmp r3, #0
3000ae84: 0a000004 beq 3000ae9c <_CORE_mutex_Surrender+0x2c>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000ae88: e59f30e8 ldr r3, [pc, #232] ; 3000af78 <_CORE_mutex_Surrender+0x108>
if ( !_Thread_Is_executing( holder ) )
3000ae8c: e5933008 ldr r3, [r3, #8] 3000ae90: e1500003 cmp r0, r3
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
3000ae94: 13a05002 movne r5, #2
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
if ( !_Thread_Is_executing( holder ) )
3000ae98: 1a000034 bne 3000af70 <_CORE_mutex_Surrender+0x100>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
3000ae9c: e5945054 ldr r5, [r4, #84] ; 0x54 3000aea0: e3550000 cmp r5, #0
3000aea4: 0a000031 beq 3000af70 <_CORE_mutex_Surrender+0x100>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000aea8: e2455001 sub r5, r5, #1
if ( the_mutex->nest_count != 0 ) {
3000aeac: e3550000 cmp r5, #0
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000aeb0: e5845054 str r5, [r4, #84] ; 0x54
/* Currently no API exercises this behavior. */
break;
}
#else
/* must be CORE_MUTEX_NESTING_ACQUIRES or we wouldn't be here */
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000aeb4: 13a05000 movne r5, #0
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
if ( the_mutex->nest_count != 0 ) {
3000aeb8: 1a00002c bne 3000af70 <_CORE_mutex_Surrender+0x100>
3000aebc: e5943048 ldr r3, [r4, #72] ; 0x48
/*
* Formally release the mutex before possibly transferring it to a
* blocked thread.
*/
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000aec0: e3530002 cmp r3, #2
3000aec4: 0a000001 beq 3000aed0 <_CORE_mutex_Surrender+0x60>
3000aec8: e3530003 cmp r3, #3
3000aecc: 1a000009 bne 3000aef8 <_CORE_mutex_Surrender+0x88>
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000aed0: e590301c ldr r3, [r0, #28] 3000aed4: e2433001 sub r3, r3, #1
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
3000aed8: e3530000 cmp r3, #0
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000aedc: e580301c str r3, [r0, #28]
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
3000aee0: 1a000004 bne 3000aef8 <_CORE_mutex_Surrender+0x88>
holder->real_priority != holder->current_priority ) {
3000aee4: e5901018 ldr r1, [r0, #24]
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
3000aee8: e5903014 ldr r3, [r0, #20] 3000aeec: e1510003 cmp r1, r3
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
3000aef0: 13a02001 movne r2, #1 3000aef4: 1b000527 blne 3000c398 <_Thread_Change_priority>
}
}
the_mutex->holder = NULL;
3000aef8: e3a05000 mov r5, #0 3000aefc: e584505c str r5, [r4, #92] ; 0x5c
the_mutex->holder_id = 0;
3000af00: e5845060 str r5, [r4, #96] ; 0x60
/*
* Now we check if another thread was waiting for this mutex. If so,
* transfer the mutex to that thread.
*/
if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
3000af04: e1a00004 mov r0, r4 3000af08: eb000703 bl 3000cb1c <_Thread_queue_Dequeue> 3000af0c: e3a02001 mov r2, #1 3000af10: e2503000 subs r3, r0, #0
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000af14: 05842050 streq r2, [r4, #80] ; 0x50
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000af18: 01a05003 moveq r5, r3
/*
* Now we check if another thread was waiting for this mutex. If so,
* transfer the mutex to that thread.
*/
if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
3000af1c: 0a000013 beq 3000af70 <_CORE_mutex_Surrender+0x100>
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000af20: e5931008 ldr r1, [r3, #8]
the_mutex->nest_count = 1;
3000af24: e5842054 str r2, [r4, #84] ; 0x54
switch ( the_mutex->Attributes.discipline ) {
3000af28: e5942048 ldr r2, [r4, #72] ; 0x48
} else
#endif
{
the_mutex->holder = the_thread;
3000af2c: e584305c str r3, [r4, #92] ; 0x5c
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000af30: e3520002 cmp r2, #2
case CORE_MUTEX_DISCIPLINES_FIFO:
case CORE_MUTEX_DISCIPLINES_PRIORITY:
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000af34: 0593201c ldreq r2, [r3, #28]
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000af38: e5841060 str r1, [r4, #96] ; 0x60
case CORE_MUTEX_DISCIPLINES_FIFO:
case CORE_MUTEX_DISCIPLINES_PRIORITY:
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000af3c: 02822001 addeq r2, r2, #1 3000af40: 0583201c streq r2, [r3, #28]
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000af44: 0a000009 beq 3000af70 <_CORE_mutex_Surrender+0x100>
3000af48: e3520003 cmp r2, #3 <== NOT EXECUTED 3000af4c: 1a000007 bne 3000af70 <_CORE_mutex_Surrender+0x100> <== NOT EXECUTED
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000af50: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000af54: e594104c ldr r1, [r4, #76] ; 0x4c <== NOT EXECUTED
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000af58: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000af5c: e583201c str r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000af60: e5933014 ldr r3, [r3, #20] <== NOT EXECUTED 3000af64: e1510003 cmp r1, r3 <== NOT EXECUTED
the_thread->current_priority){
_Thread_Change_priority(
3000af68: 31a02005 movcc r2, r5 <== NOT EXECUTED 3000af6c: 3b000509 blcc 3000c398 <_Thread_Change_priority> <== NOT EXECUTED
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
3000af70: e1a00005 mov r0, r5
3000af74: e8bd8030 pop {r4, r5, pc}
3000b32c <_Chain_Append_with_empty_check>:
bool _Chain_Append_with_empty_check(
Chain_Control *chain,
Chain_Node *node
)
{
3000b32c: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b330: e1a03000 mov r3, r0 <== NOT EXECUTED
3000b334: e10f4000 mrs r4, CPSR <== NOT EXECUTED
3000b338: e3842080 orr r2, r4, #128 ; 0x80 <== NOT EXECUTED
3000b33c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000b340: e280c004 add ip, r0, #4 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000b344: e5900000 ldr r0, [r0] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3000b348: e581c000 str ip, [r1] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000b34c: e06c2000 rsb r2, ip, r0 <== NOT EXECUTED 3000b350: e2720000 rsbs r0, r2, #0 <== NOT EXECUTED 3000b354: e0a00002 adc r0, r0, r2 <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3000b358: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
the_node->next = tail;
tail->previous = the_node;
3000b35c: e5831008 str r1, [r3, #8] <== NOT EXECUTED
old_last->next = the_node;
3000b360: e5821000 str r1, [r2] <== NOT EXECUTED
the_node->previous = old_last;
3000b364: e5812004 str r2, [r1, #4] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b368: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Disable( level );
was_empty = _Chain_Append_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return was_empty;
}
3000b36c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b39c <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
3000b39c: e92d4010 push {r4, lr} <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b3a0: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000b3a4: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000b3a8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
)
{
bool is_empty_now = true;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_first = head->next;
3000b3ac: e5902000 ldr r2, [r0] <== NOT EXECUTED
Chain_Node **the_node
)
{
bool is_empty_now = true;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3000b3b0: e280c004 add ip, r0, #4 <== NOT EXECUTED
Chain_Node *old_first = head->next;
if ( old_first != tail ) {
3000b3b4: e152000c cmp r2, ip <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
} else
*the_node = NULL;
3000b3b8: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000b3bc: 05813000 streq r3, [r1] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Get_with_empty_check_unprotected(
Chain_Control *the_chain,
Chain_Node **the_node
)
{
bool is_empty_now = true;
3000b3c0: 03a00001 moveq r0, #1 <== NOT EXECUTED
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_first = head->next;
if ( old_first != tail ) {
3000b3c4: 0a000006 beq 3000b3e4 <_Chain_Get_with_empty_check+0x48> <== NOT EXECUTED
Chain_Node *new_first = old_first->next;
3000b3c8: e5923000 ldr r3, [r2] <== NOT EXECUTED
head->next = new_first;
3000b3cc: e5803000 str r3, [r0] <== NOT EXECUTED
new_first->previous = head;
3000b3d0: e5830004 str r0, [r3, #4] <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
3000b3d4: e06c3003 rsb r3, ip, r3 <== NOT EXECUTED 3000b3d8: e2730000 rsbs r0, r3, #0 <== NOT EXECUTED
Chain_Node *new_first = old_first->next;
head->next = new_first;
new_first->previous = head;
*the_node = old_first;
3000b3dc: e5812000 str r2, [r1] <== NOT EXECUTED
is_empty_now = new_first == tail;
3000b3e0: e0a00003 adc r0, r0, r3 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b3e4: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Disable( level );
is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return is_empty_now;
}
3000b3e8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b420 <_Chain_Insert>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b420: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000b424: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000b428: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b42c: e5903000 ldr r3, [r0] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b430: e5810004 str r0, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b434: e5801000 str r1, [r0] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b438: e5831004 str r1, [r3, #4] <== NOT EXECUTED
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
3000b43c: e5813000 str r3, [r1] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b440: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
ISR_Level level;
_ISR_Disable( level );
_Chain_Insert_unprotected( after_node, node );
_ISR_Enable( level );
}
3000b444: e12fff1e bx lr <== NOT EXECUTED
3000b488 <_Chain_Prepend_with_empty_check>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b488: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000b48c: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000b490: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000b494: e5903000 ldr r3, [r0] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b498: e5810004 str r0, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b49c: e4801004 str r1, [r0], #4 <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b4a0: e5831004 str r1, [r3, #4] <== NOT EXECUTED
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
3000b4a4: e5813000 str r3, [r1] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b4a8: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Disable( level );
was_empty = _Chain_Prepend_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return was_empty;
}
3000b4ac: e0603003 rsb r3, r0, r3 <== NOT EXECUTED 3000b4b0: e2730000 rsbs r0, r3, #0 <== NOT EXECUTED 3000b4b4: e0a00003 adc r0, r0, r3 <== NOT EXECUTED 3000b4b8: e12fff1e bx lr <== NOT EXECUTED
30009cb4 <_Event_Seize>:
Thread_Control *executing,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
30009cb4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30009cb8: e59d401c ldr r4, [sp, #28]
rtems_event_set seized_events;
rtems_event_set pending_events;
ISR_Level level;
Thread_blocking_operation_States current_sync_state;
executing->Wait.return_code = RTEMS_SUCCESSFUL;
30009cbc: e3a0c000 mov ip, #0
Thread_Control *executing,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
30009cc0: e59da020 ldr sl, [sp, #32] 30009cc4: e59d5024 ldr r5, [sp, #36] ; 0x24 30009cc8: e59d6028 ldr r6, [sp, #40] ; 0x28
rtems_event_set seized_events;
rtems_event_set pending_events;
ISR_Level level;
Thread_blocking_operation_States current_sync_state;
executing->Wait.return_code = RTEMS_SUCCESSFUL;
30009ccc: e584c034 str ip, [r4, #52] ; 0x34
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30009cd0: e10f7000 mrs r7, CPSR 30009cd4: e387c080 orr ip, r7, #128 ; 0x80 30009cd8: e129f00c msr CPSR_fc, ip
_ISR_Disable( level );
pending_events = event->pending_events;
30009cdc: e59a8000 ldr r8, [sl]
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
30009ce0: e010c008 ands ip, r0, r8
30009ce4: 0a000007 beq 30009d08 <_Event_Seize+0x54>
30009ce8: e15c0000 cmp ip, r0
30009cec: 0a000001 beq 30009cf8 <_Event_Seize+0x44>
(seized_events == event_in || _Options_Is_any( option_set )) ) {
30009cf0: e3110002 tst r1, #2 <== NOT EXECUTED 30009cf4: 0a000003 beq 30009d08 <_Event_Seize+0x54> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
30009cf8: e1c8800c bic r8, r8, ip
event->pending_events =
30009cfc: e58a8000 str r8, [sl]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009d00: e129f007 msr CPSR_fc, r7 30009d04: ea000004 b 30009d1c <_Event_Seize+0x68>
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
30009d08: e3110001 tst r1, #1
30009d0c: 0a000004 beq 30009d24 <_Event_Seize+0x70>
30009d10: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
executing->Wait.return_code = RTEMS_UNSATISFIED;
30009d14: e3a0200d mov r2, #13 30009d18: e5842034 str r2, [r4, #52] ; 0x34
*event_out = seized_events;
30009d1c: e583c000 str ip, [r3]
return;
30009d20: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
* NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = option_set; executing->Wait.count = event_in; executing->Wait.return_argument = event_out;
30009d24: e5843028 str r3, [r4, #40] ; 0x28
*sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30009d28: e3a03001 mov r3, #1
* set properly when we are marked as in the event critical section. * * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = option_set;
30009d2c: e5841030 str r1, [r4, #48] ; 0x30
executing->Wait.count = event_in;
30009d30: e5840024 str r0, [r4, #36] ; 0x24
executing->Wait.return_argument = event_out;
*sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30009d34: e5853000 str r3, [r5] 30009d38: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
if ( ticks ) {
30009d3c: e3520000 cmp r2, #0
30009d40: 0a00000a beq 30009d70 <_Event_Seize+0xbc>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30009d44: e3a01000 mov r1, #0
_Watchdog_Initialize(
30009d48: e5943008 ldr r3, [r4, #8] 30009d4c: e5841050 str r1, [r4, #80] ; 0x50
the_watchdog->routine = routine;
30009d50: e59f1058 ldr r1, [pc, #88] ; 30009db0 <_Event_Seize+0xfc>
the_watchdog->id = id;
30009d54: e5843068 str r3, [r4, #104] ; 0x68
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30009d58: e5841064 str r1, [r4, #100] ; 0x64
the_watchdog->id = id; the_watchdog->user_data = user_data;
30009d5c: e584506c str r5, [r4, #108] ; 0x6c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30009d60: e5842054 str r2, [r4, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30009d64: e59f0048 ldr r0, [pc, #72] ; 30009db4 <_Event_Seize+0x100> 30009d68: e2841048 add r1, r4, #72 ; 0x48 30009d6c: eb000d7f bl 3000d370 <_Watchdog_Insert>
sync_state
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, wait_state );
30009d70: e1a00004 mov r0, r4 30009d74: e1a01006 mov r1, r6 30009d78: eb000ca5 bl 3000d014 <_Thread_Set_state>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30009d7c: e10f2000 mrs r2, CPSR 30009d80: e3823080 orr r3, r2, #128 ; 0x80 30009d84: e129f003 msr CPSR_fc, r3
_ISR_Disable( level );
current_sync_state = *sync_state;
30009d88: e5950000 ldr r0, [r5]
*sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
30009d8c: e3a03000 mov r3, #0
if ( current_sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
30009d90: e3500001 cmp r0, #1
_Thread_Set_state( executing, wait_state );
_ISR_Disable( level );
current_sync_state = *sync_state;
*sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
30009d94: e5853000 str r3, [r5]
if ( current_sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
30009d98: 1a000001 bne 30009da4 <_Event_Seize+0xf0>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009d9c: e129f002 msr CPSR_fc, r2
30009da0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
* The blocking thread was satisfied by an ISR or timed out. * * WARNING! Entering with interrupts disabled and returning with interrupts * enabled! */ _Thread_blocking_operation_Cancel( current_sync_state, executing, level );
30009da4: e1a01004 mov r1, r4 <== NOT EXECUTED
}
30009da8: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
* The blocking thread was satisfied by an ISR or timed out. * * WARNING! Entering with interrupts disabled and returning with interrupts * enabled! */ _Thread_blocking_operation_Cancel( current_sync_state, executing, level );
30009dac: ea000966 b 3000c34c <_Thread_blocking_operation_Cancel> <== NOT EXECUTED
30009e04 <_Event_Surrender>:
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
30009e04: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30009e08: e59d801c ldr r8, [sp, #28]
rtems_event_set pending_events;
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
option_set = the_thread->Wait.option;
30009e0c: e5906030 ldr r6, [r0, #48] ; 0x30
rtems_event_set event_in,
Event_Control *event,
Thread_blocking_operation_States *sync_state,
States_Control wait_state
)
{
30009e10: e1a04000 mov r4, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30009e14: e10f0000 mrs r0, CPSR 30009e18: e380c080 orr ip, r0, #128 ; 0x80 30009e1c: e129f00c msr CPSR_fc, ip
RTEMS_INLINE_ROUTINE void _Event_sets_Post(
rtems_event_set the_new_events,
rtems_event_set *the_event_set
)
{
*the_event_set |= the_new_events;
30009e20: e592c000 ldr ip, [r2] 30009e24: e181100c orr r1, r1, ip 30009e28: e5821000 str r1, [r2]
option_set = the_thread->Wait.option;
_ISR_Disable( level );
_Event_sets_Post( event_in, &event->pending_events );
pending_events = event->pending_events;
event_condition = the_thread->Wait.count;
30009e2c: e5945024 ldr r5, [r4, #36] ; 0x24
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
30009e30: e011c005 ands ip, r1, r5
30009e34: 0a000035 beq 30009f10 <_Event_Surrender+0x10c>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
30009e38: e59f70d8 ldr r7, [pc, #216] ; 30009f18 <_Event_Surrender+0x114> 30009e3c: e597a000 ldr sl, [r7] 30009e40: e35a0000 cmp sl, #0
30009e44: 0a000013 beq 30009e98 <_Event_Surrender+0x94>
30009e48: e5977008 ldr r7, [r7, #8] <== NOT EXECUTED 30009e4c: e1540007 cmp r4, r7 <== NOT EXECUTED 30009e50: 1a000010 bne 30009e98 <_Event_Surrender+0x94> <== NOT EXECUTED
_Thread_Is_executing( the_thread ) &&
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
30009e54: e5937000 ldr r7, [r3] <== NOT EXECUTED 30009e58: e2477001 sub r7, r7, #1 <== NOT EXECUTED
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
30009e5c: e3570001 cmp r7, #1 <== NOT EXECUTED 30009e60: 8a00000c bhi 30009e98 <_Event_Surrender+0x94> <== NOT EXECUTED
((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(*sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
30009e64: e15c0005 cmp ip, r5 <== NOT EXECUTED 30009e68: 0a000001 beq 30009e74 <_Event_Surrender+0x70> <== NOT EXECUTED 30009e6c: e3160002 tst r6, #2 <== NOT EXECUTED 30009e70: 0a000026 beq 30009f10 <_Event_Surrender+0x10c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
30009e74: e1c1100c bic r1, r1, ip <== NOT EXECUTED
event->pending_events = _Event_sets_Clear(
30009e78: e5821000 str r1, [r2] <== NOT EXECUTED
pending_events,
seized_events
);
the_thread->Wait.count = 0;
30009e7c: e3a02000 mov r2, #0 <== NOT EXECUTED 30009e80: e5842024 str r2, [r4, #36] ; 0x24 <== NOT EXECUTED
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
30009e84: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED 30009e88: e582c000 str ip, [r2] <== NOT EXECUTED
*sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
30009e8c: e3a02003 mov r2, #3 <== NOT EXECUTED 30009e90: e5832000 str r2, [r3] <== NOT EXECUTED 30009e94: ea00001d b 30009f10 <_Event_Surrender+0x10c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
30009e98: e5943010 ldr r3, [r4, #16]
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
30009e9c: e1180003 tst r8, r3
30009ea0: 0a00001a beq 30009f10 <_Event_Surrender+0x10c>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
30009ea4: e15c0005 cmp ip, r5
30009ea8: 0a000001 beq 30009eb4 <_Event_Surrender+0xb0>
30009eac: e3160002 tst r6, #2 <== NOT EXECUTED 30009eb0: 0a000016 beq 30009f10 <_Event_Surrender+0x10c> <== NOT EXECUTED
30009eb4: e1c1100c bic r1, r1, ip
event->pending_events = _Event_sets_Clear(
pending_events,
seized_events
);
the_thread->Wait.count = 0;
30009eb8: e3a03000 mov r3, #0
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Are_set( the_thread->current_state, wait_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
event->pending_events = _Event_sets_Clear(
30009ebc: e5821000 str r1, [r2]
pending_events,
seized_events
);
the_thread->Wait.count = 0;
30009ec0: e5843024 str r3, [r4, #36] ; 0x24
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
30009ec4: e5943028 ldr r3, [r4, #40] ; 0x28 30009ec8: e583c000 str ip, [r3]
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30009ecc: e10f3000 mrs r3, CPSR 30009ed0: e129f000 msr CPSR_fc, r0 30009ed4: e129f003 msr CPSR_fc, r3
_ISR_Flash( level );
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30009ed8: e5943050 ldr r3, [r4, #80] ; 0x50 30009edc: e3530002 cmp r3, #2
30009ee0: 0a000001 beq 30009eec <_Event_Surrender+0xe8>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009ee4: e129f000 msr CPSR_fc, r0 30009ee8: ea000004 b 30009f00 <_Event_Surrender+0xfc>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
30009eec: e3a03003 mov r3, #3 30009ef0: e5843050 str r3, [r4, #80] ; 0x50 30009ef4: e129f000 msr CPSR_fc, r0
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
30009ef8: e2840048 add r0, r4, #72 ; 0x48 30009efc: eb000d72 bl 3000d4cc <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30009f00: e59f1014 ldr r1, [pc, #20] ; 30009f1c <_Event_Surrender+0x118> 30009f04: e1a00004 mov r0, r4
}
return;
}
}
_ISR_Enable( level );
}
30009f08: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
30009f0c: ea00095f b 3000c490 <_Thread_Clear_state>
30009f10: e129f000 msr CPSR_fc, r0
30009f14: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
30009f20 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *arg
)
{
30009f20: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
30009f24: e1a04001 mov r4, r1 <== NOT EXECUTED
ISR_Level level;
Thread_blocking_operation_States *sync_state;
sync_state = arg;
the_thread = _Thread_Get( id, &location );
30009f28: e1a0100d mov r1, sp <== NOT EXECUTED 30009f2c: eb000a3a bl 3000c81c <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
30009f30: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30009f34: e3530000 cmp r3, #0 <== NOT EXECUTED 30009f38: 1a000014 bne 30009f90 <_Event_Timeout+0x70> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30009f3c: e10f2000 mrs r2, CPSR <== NOT EXECUTED 30009f40: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 30009f44: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
30009f48: e5803024 str r3, [r0, #36] ; 0x24 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
30009f4c: e59f3040 ldr r3, [pc, #64] ; 30009f94 <_Event_Timeout+0x74><== NOT EXECUTED
if ( _Thread_Is_executing( the_thread ) ) {
30009f50: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30009f54: e1500003 cmp r0, r3 <== NOT EXECUTED 30009f58: 1a000003 bne 30009f6c <_Event_Timeout+0x4c> <== NOT EXECUTED
if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
30009f5c: e5943000 ldr r3, [r4] <== NOT EXECUTED 30009f60: e3530001 cmp r3, #1 <== NOT EXECUTED
*sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
30009f64: 03a03002 moveq r3, #2 <== NOT EXECUTED 30009f68: 05843000 streq r3, [r4] <== NOT EXECUTED
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
30009f6c: e3a03006 mov r3, #6 <== NOT EXECUTED 30009f70: e5803034 str r3, [r0, #52] ; 0x34 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009f74: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30009f78: e59f1018 ldr r1, [pc, #24] ; 30009f98 <_Event_Timeout+0x78><== NOT EXECUTED 30009f7c: eb000943 bl 3000c490 <_Thread_Clear_state> <== NOT EXECUTED
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
30009f80: e59f3014 ldr r3, [pc, #20] ; 30009f9c <_Event_Timeout+0x7c><== NOT EXECUTED 30009f84: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
30009f88: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30009f8c: e5832000 str r2, [r3] <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
30009f90: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000f0dc <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f0dc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000f0e0: e1a08002 mov r8, r2
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
3000f0e4: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f0e8: e24dd01c sub sp, sp, #28 3000f0ec: e1a0b003 mov fp, r3
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
3000f0f0: e2913004 adds r3, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f0f4: e1a05000 mov r5, r0 3000f0f8: e1a06001 mov r6, r1
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
3000f0fc: e58d2000 str r2, [sp]
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
3000f100: e58d300c str r3, [sp, #12]
3000f104: 2a00006a bcs 3000f2b4 <_Heap_Allocate_aligned_with_boundary+0x1d8>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
3000f108: e35b0000 cmp fp, #0
3000f10c: 0a000003 beq 3000f120 <_Heap_Allocate_aligned_with_boundary+0x44>
if ( boundary < alloc_size ) {
3000f110: e15b0001 cmp fp, r1 <== NOT EXECUTED 3000f114: 3a000066 bcc 3000f2b4 <_Heap_Allocate_aligned_with_boundary+0x1d8><== NOT EXECUTED
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
3000f118: e3580000 cmp r8, #0 <== NOT EXECUTED 3000f11c: 01a08002 moveq r8, r2 <== NOT EXECUTED
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
3000f120: e59d2000 ldr r2, [sp]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000f124: e2663004 rsb r3, r6, #4
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
3000f128: e2822007 add r2, r2, #7
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
3000f12c: e595a008 ldr sl, [r5, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000f130: e3a07000 mov r7, #0
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
3000f134: e58d2014 str r2, [sp, #20]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000f138: e58d3018 str r3, [sp, #24]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000f13c: ea000048 b 3000f264 <_Heap_Allocate_aligned_with_boundary+0x188>
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
3000f140: e59a4004 ldr r4, [sl, #4] 3000f144: e59d200c ldr r2, [sp, #12] 3000f148: e1540002 cmp r4, r2
3000f14c: 9a00003f bls 3000f250 <_Heap_Allocate_aligned_with_boundary+0x174>
if ( alignment == 0 ) {
3000f150: e3580000 cmp r8, #0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000f154: 028a4008 addeq r4, sl, #8
3000f158: 0a00003d beq 3000f254 <_Heap_Allocate_aligned_with_boundary+0x178>
3000f15c: e28a2008 add r2, sl, #8
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000f160: e5953014 ldr r3, [r5, #20] 3000f164: e58d2008 str r2, [sp, #8]
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
3000f168: e59d2014 ldr r2, [sp, #20]
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000f16c: e58d3004 str r3, [sp, #4]
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
3000f170: e0639002 rsb r9, r3, r2
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000f174: e3c44001 bic r4, r4, #1
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000f178: e59d3018 ldr r3, [sp, #24]
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
3000f17c: e08a4004 add r4, sl, r4
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
3000f180: e0899004 add r9, r9, r4
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000f184: e0834004 add r4, r3, r4
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000f188: e1a00004 mov r0, r4 3000f18c: e1a01008 mov r1, r8 3000f190: eb002ae1 bl 30019d1c <__umodsi3> 3000f194: e0604004 rsb r4, r0, r4
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
3000f198: e1540009 cmp r4, r9
3000f19c: 9a000003 bls 3000f1b0 <_Heap_Allocate_aligned_with_boundary+0xd4>
3000f1a0: e1a00009 mov r0, r9 3000f1a4: e1a01008 mov r1, r8 3000f1a8: eb002adb bl 30019d1c <__umodsi3> 3000f1ac: e0604009 rsb r4, r0, r9
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
3000f1b0: e35b0000 cmp fp, #0
3000f1b4: 0a000014 beq 3000f20c <_Heap_Allocate_aligned_with_boundary+0x130>
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
3000f1b8: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
3000f1bc: e0849006 add r9, r4, r6 <== NOT EXECUTED
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
3000f1c0: e0822006 add r2, r2, r6 <== NOT EXECUTED 3000f1c4: e58d2010 str r2, [sp, #16] <== NOT EXECUTED 3000f1c8: ea000008 b 3000f1f0 <_Heap_Allocate_aligned_with_boundary+0x114><== NOT EXECUTED
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
3000f1cc: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000f1d0: e1500003 cmp r0, r3 <== NOT EXECUTED 3000f1d4: 3a00001d bcc 3000f250 <_Heap_Allocate_aligned_with_boundary+0x174><== NOT EXECUTED
return 0;
}
alloc_begin = boundary_line - alloc_size;
3000f1d8: e0664000 rsb r4, r6, r0 <== NOT EXECUTED 3000f1dc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f1e0: e1a01008 mov r1, r8 <== NOT EXECUTED 3000f1e4: eb002acc bl 30019d1c <__umodsi3> <== NOT EXECUTED 3000f1e8: e0604004 rsb r4, r0, r4 <== NOT EXECUTED
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
3000f1ec: e0849006 add r9, r4, r6 <== NOT EXECUTED 3000f1f0: e1a00009 mov r0, r9 <== NOT EXECUTED 3000f1f4: e1a0100b mov r1, fp <== NOT EXECUTED 3000f1f8: eb002ac7 bl 30019d1c <__umodsi3> <== NOT EXECUTED 3000f1fc: e0600009 rsb r0, r0, r9 <== NOT EXECUTED
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
3000f200: e1500009 cmp r0, r9 <== NOT EXECUTED 3000f204: 31540000 cmpcc r4, r0 <== NOT EXECUTED 3000f208: 3affffef bcc 3000f1cc <_Heap_Allocate_aligned_with_boundary+0xf0><== NOT EXECUTED
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
3000f20c: e59d2008 ldr r2, [sp, #8] 3000f210: e1540002 cmp r4, r2
3000f214: 3a00000d bcc 3000f250 <_Heap_Allocate_aligned_with_boundary+0x174>
3000f218: e1a00004 mov r0, r4 3000f21c: e59d1000 ldr r1, [sp] 3000f220: eb002abd bl 30019d1c <__umodsi3> 3000f224: e3e09007 mvn r9, #7 3000f228: e06a9009 rsb r9, sl, r9
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000f22c: e0899004 add r9, r9, r4
if ( free_size >= min_block_size || free_size == 0 ) {
return alloc_begin;
}
}
return 0;
3000f230: e59d2004 ldr r2, [sp, #4]
if ( alloc_begin >= alloc_begin_floor ) {
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
if ( free_size >= min_block_size || free_size == 0 ) {
3000f234: e0603009 rsb r3, r0, r9
return alloc_begin;
}
}
return 0;
3000f238: e1590000 cmp r9, r0 3000f23c: 11530002 cmpne r3, r2 3000f240: 33a09000 movcc r9, #0 3000f244: 23a09001 movcs r9, #1 3000f248: 31a04009 movcc r4, r9 3000f24c: ea000000 b 3000f254 <_Heap_Allocate_aligned_with_boundary+0x178>
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
3000f250: e3a04000 mov r4, #0
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
3000f254: e3540000 cmp r4, #0
);
}
}
/* Statistics */
++search_count;
3000f258: e2877001 add r7, r7, #1
if ( alloc_begin != 0 ) {
3000f25c: 1a000004 bne 3000f274 <_Heap_Allocate_aligned_with_boundary+0x198>
break;
}
block = block->next;
3000f260: e59aa008 ldr sl, [sl, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000f264: e15a0005 cmp sl, r5
3000f268: 1affffb4 bne 3000f140 <_Heap_Allocate_aligned_with_boundary+0x64>
3000f26c: e3a04000 mov r4, #0 3000f270: ea00000a b 3000f2a0 <_Heap_Allocate_aligned_with_boundary+0x1c4>
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000f274: e5953048 ldr r3, [r5, #72] ; 0x48
stats->searches += search_count;
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000f278: e1a00005 mov r0, r5
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000f27c: e2833001 add r3, r3, #1 3000f280: e5853048 str r3, [r5, #72] ; 0x48
stats->searches += search_count;
3000f284: e595304c ldr r3, [r5, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000f288: e1a0100a mov r1, sl
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
stats->searches += search_count;
3000f28c: e0833007 add r3, r3, r7 3000f290: e585304c str r3, [r5, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000f294: e1a02004 mov r2, r4 3000f298: e1a03006 mov r3, r6 3000f29c: ebfff046 bl 3000b3bc <_Heap_Block_allocate>
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
3000f2a0: e5953044 ldr r3, [r5, #68] ; 0x44
stats->max_search = search_count;
}
return (void *) alloc_begin;
3000f2a4: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
3000f2a8: e1530007 cmp r3, r7
stats->max_search = search_count;
3000f2ac: 35857044 strcc r7, [r5, #68] ; 0x44
}
return (void *) alloc_begin;
3000f2b0: ea000000 b 3000f2b8 <_Heap_Allocate_aligned_with_boundary+0x1dc>
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
3000f2b4: e3a00000 mov r0, #0
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000f2b8: e28dd01c add sp, sp, #28
3000f2bc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000b3bc <_Heap_Block_allocate>:
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000b3bc: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000b3c0: e591a004 ldr sl, [r1, #4]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000b3c4: e2426008 sub r6, r2, #8 3000b3c8: e1a04001 mov r4, r1 3000b3cc: e1a07003 mov r7, r3
Heap_Statistics *const stats = &heap->stats;
uintptr_t const alloc_area_begin = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_area_offset = alloc_begin - alloc_area_begin;
3000b3d0: e0613006 rsb r3, r1, r6
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000b3d4: e3ca1001 bic r1, sl, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000b3d8: e0849001 add r9, r4, r1
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000b3dc: e1a05000 mov r5, r0
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000b3e0: e5990004 ldr r0, [r9, #4]
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000b3e4: e3100001 tst r0, #1
/* Statistics */
--stats->free_blocks;
++stats->used_blocks;
stats->free_size -= _Heap_Block_size( block );
} else {
free_list_anchor = _Heap_Free_list_head( heap );
3000b3e8: 11a08005 movne r8, r5
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000b3ec: 1a00000c bne 3000b424 <_Heap_Block_allocate+0x68>
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
3000b3f0: e5940008 ldr r0, [r4, #8]
free_list_anchor = block->prev;
3000b3f4: e594800c ldr r8, [r4, #12]
Heap_Block *prev = block->prev;
prev->next = next;
3000b3f8: e5880008 str r0, [r8, #8]
next->prev = prev;
3000b3fc: e580800c str r8, [r0, #12]
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000b400: e5950038 ldr r0, [r5, #56] ; 0x38 3000b404: e2400001 sub r0, r0, #1 3000b408: e5850038 str r0, [r5, #56] ; 0x38
++stats->used_blocks;
3000b40c: e5950040 ldr r0, [r5, #64] ; 0x40 3000b410: e2800001 add r0, r0, #1 3000b414: e5850040 str r0, [r5, #64] ; 0x40
stats->free_size -= _Heap_Block_size( block );
3000b418: e5950030 ldr r0, [r5, #48] ; 0x30 3000b41c: e0611000 rsb r1, r1, r0 3000b420: e5851030 str r1, [r5, #48] ; 0x30
} else {
free_list_anchor = _Heap_Free_list_head( heap );
}
if ( alloc_area_offset < heap->page_size ) {
3000b424: e5951010 ldr r1, [r5, #16] 3000b428: e1530001 cmp r3, r1
3000b42c: 2a000005 bcs 3000b448 <_Heap_Block_allocate+0x8c>
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
_Heap_Block_split( heap, block, free_list_anchor, alloc_size );
3000b430: e1a00005 mov r0, r5 3000b434: e1a01004 mov r1, r4 3000b438: e1a02008 mov r2, r8 3000b43c: e0833007 add r3, r3, r7 3000b440: ebffff31 bl 3000b10c <_Heap_Block_split> 3000b444: ea000021 b 3000b4d0 <_Heap_Block_allocate+0x114>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000b448: e1a00002 mov r0, r2 3000b44c: eb003a32 bl 30019d1c <__umodsi3>
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000b450: e5952030 ldr r2, [r5, #48] ; 0x30
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000b454: e0606006 rsb r6, r0, r6
_Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
uintptr_t const new_block_begin = (uintptr_t) new_block;
uintptr_t const new_block_size = block_end - new_block_begin;
block_end = new_block_begin;
block_size = block_end - block_begin;
3000b458: e0643006 rsb r3, r4, r6
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000b45c: e0822003 add r2, r2, r3
if ( _Heap_Is_prev_used( block ) ) {
3000b460: e31a0001 tst sl, #1
uintptr_t block_end = block_begin + block_size;
Heap_Block *const new_block =
_Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
uintptr_t const new_block_begin = (uintptr_t) new_block;
uintptr_t const new_block_size = block_end - new_block_begin;
3000b464: e0669009 rsb r9, r6, r9
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000b468: e5852030 str r2, [r5, #48] ; 0x30
if ( _Heap_Is_prev_used( block ) ) {
3000b46c: 0a000009 beq 3000b498 <_Heap_Block_allocate+0xdc>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000b470: e5982008 ldr r2, [r8, #8]
new_block->next = next;
new_block->prev = block_before;
3000b474: e584800c str r8, [r4, #12]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
3000b478: e5842008 str r2, [r4, #8]
new_block->prev = block_before; block_before->next = new_block; next->prev = new_block;
3000b47c: e582400c str r4, [r2, #12]
_Heap_Free_list_insert_after( free_list_anchor, block );
free_list_anchor = block;
/* Statistics */
++stats->free_blocks;
3000b480: e5952038 ldr r2, [r5, #56] ; 0x38
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
3000b484: e5884008 str r4, [r8, #8] 3000b488: e2822001 add r2, r2, #1 3000b48c: e5852038 str r2, [r5, #56] ; 0x38 3000b490: e1a02004 mov r2, r4 3000b494: ea000005 b 3000b4b0 <_Heap_Block_allocate+0xf4>
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Prev_block(
const Heap_Block *block
)
{
return (Heap_Block *) ((uintptr_t) block - block->prev_size);
3000b498: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000b49c: e0624004 rsb r4, r2, r4 <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000b4a0: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000b4a4: e3c22001 bic r2, r2, #1 <== NOT EXECUTED
} else {
Heap_Block *const prev_block = _Heap_Prev_block( block );
uintptr_t const prev_block_size = _Heap_Block_size( prev_block );
block = prev_block;
block_size += prev_block_size;
3000b4a8: e0833002 add r3, r3, r2 <== NOT EXECUTED 3000b4ac: e1a02008 mov r2, r8 <== NOT EXECUTED
}
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
3000b4b0: e3831001 orr r1, r3, #1 3000b4b4: e5841004 str r1, [r4, #4]
new_block->prev_size = block_size;
new_block->size_and_flag = new_block_size;
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
3000b4b8: e1a00005 mov r0, r5
}
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
new_block->prev_size = block_size;
new_block->size_and_flag = new_block_size;
3000b4bc: e8860208 stm r6, {r3, r9}
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
3000b4c0: e1a01006 mov r1, r6 3000b4c4: e1a03007 mov r3, r7 3000b4c8: ebffff0f bl 3000b10c <_Heap_Block_split> 3000b4cc: e1a04006 mov r4, r6
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000b4d0: e5953030 ldr r3, [r5, #48] ; 0x30 3000b4d4: e5952034 ldr r2, [r5, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000b4d8: e1a00004 mov r0, r4
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000b4dc: e1520003 cmp r2, r3
stats->min_free_size = stats->free_size;
3000b4e0: 85853034 strhi r3, [r5, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000b4e4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
3000b10c <_Heap_Block_split>:
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000b10c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Heap_Statistics *const stats = &heap->stats;
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000b110: e5908014 ldr r8, [r0, #20]
uintptr_t alloc_size
)
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const page_size = heap->page_size;
3000b114: e590a010 ldr sl, [r0, #16]
uintptr_t const min_block_size = heap->min_block_size; uintptr_t const min_alloc_size = min_block_size - HEAP_BLOCK_HEADER_SIZE;
3000b118: e248b008 sub fp, r8, #8
return heap->stats.size;
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Max( uintptr_t a, uintptr_t b )
{
return a > b ? a : b;
3000b11c: e153000b cmp r3, fp 3000b120: 21a0b003 movcs fp, r3
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const used_size =
3000b124: e28bb008 add fp, fp, #8
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000b128: e1a05001 mov r5, r1
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000b12c: e5919004 ldr r9, [r1, #4] 3000b130: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000b134: e1a0100a mov r1, sl 3000b138: e1a0000b mov r0, fp 3000b13c: e1a06002 mov r6, r2 3000b140: eb003af5 bl 30019d1c <__umodsi3> 3000b144: e3c97001 bic r7, r9, #1
if ( remainder != 0 ) {
3000b148: e3500000 cmp r0, #0
uintptr_t const used_size =
_Heap_Max( alloc_size, min_alloc_size ) + HEAP_BLOCK_HEADER_SIZE;
uintptr_t const used_block_size = _Heap_Align_up( used_size, page_size );
uintptr_t const free_size = block_size + HEAP_ALLOC_BONUS - used_size;
3000b14c: e2872004 add r2, r7, #4
return value - remainder + alignment;
3000b150: 108ba00a addne sl, fp, sl
} else {
return value;
3000b154: 01a0a00b moveq sl, fp
uintptr_t const free_size_limit = min_block_size + HEAP_ALLOC_BONUS;
3000b158: e2888004 add r8, r8, #4
uintptr_t const used_size =
_Heap_Max( alloc_size, min_alloc_size ) + HEAP_BLOCK_HEADER_SIZE;
uintptr_t const used_block_size = _Heap_Align_up( used_size, page_size );
uintptr_t const free_size = block_size + HEAP_ALLOC_BONUS - used_size;
3000b15c: e06bb002 rsb fp, fp, r2
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
3000b160: 1060a00a rsbne sl, r0, sl
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000b164: e0853007 add r3, r5, r7
Heap_Block *next_block = _Heap_Block_at( block, block_size );
_HAssert( used_size <= block_size + HEAP_ALLOC_BONUS );
_HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS );
if ( free_size >= free_size_limit ) {
3000b168: e15b0008 cmp fp, r8
next_block->prev_size = free_block_size;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
_Heap_Protection_block_initialize( heap, free_block );
} else {
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000b16c: 35932004 ldrcc r2, [r3, #4] 3000b170: 33822001 orrcc r2, r2, #1
Heap_Block *next_block = _Heap_Block_at( block, block_size );
_HAssert( used_size <= block_size + HEAP_ALLOC_BONUS );
_HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS );
if ( free_size >= free_size_limit ) {
3000b174: 3a000023 bcc 3000b208 <_Heap_Block_split+0xfc>
_HAssert( used_block_size + free_block_size == block_size );
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
3000b178: e5941030 ldr r1, [r4, #48] ; 0x30
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000b17c: e2099001 and r9, r9, #1
_HAssert( used_size <= block_size + HEAP_ALLOC_BONUS );
_HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS );
if ( free_size >= free_size_limit ) {
Heap_Block *const free_block = _Heap_Block_at( block, used_block_size );
uintptr_t free_block_size = block_size - used_block_size;
3000b180: e06a7007 rsb r7, sl, r7
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000b184: e08a2005 add r2, sl, r5
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
block->size_and_flag = size | flag;
3000b188: e18aa009 orr sl, sl, r9 3000b18c: e585a004 str sl, [r5, #4]
_HAssert( used_block_size + free_block_size == block_size );
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
3000b190: e0811007 add r1, r1, r7 3000b194: e5841030 str r1, [r4, #48] ; 0x30
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000b198: e5931004 ldr r1, [r3, #4] 3000b19c: e3c11001 bic r1, r1, #1
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000b1a0: e0830001 add r0, r3, r1 3000b1a4: e5900004 ldr r0, [r0, #4]
if ( _Heap_Is_used( next_block ) ) {
3000b1a8: e3100001 tst r0, #1
3000b1ac: 0a000008 beq 3000b1d4 <_Heap_Block_split+0xc8>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000b1b0: e5961008 ldr r1, [r6, #8]
new_block->next = next;
new_block->prev = block_before;
3000b1b4: e582600c str r6, [r2, #12]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
3000b1b8: e5821008 str r1, [r2, #8]
new_block->prev = block_before; block_before->next = new_block; next->prev = new_block;
3000b1bc: e581200c str r2, [r1, #12]
_Heap_Free_list_insert_after( free_list_anchor, free_block );
/* Statistics */
++stats->free_blocks;
3000b1c0: e5941038 ldr r1, [r4, #56] ; 0x38
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
3000b1c4: e5862008 str r2, [r6, #8] 3000b1c8: e2811001 add r1, r1, #1 3000b1cc: e5841038 str r1, [r4, #56] ; 0x38 3000b1d0: ea000007 b 3000b1f4 <_Heap_Block_split+0xe8>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
3000b1d4: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
Heap_Block *prev = old_block->prev;
3000b1d8: e593300c ldr r3, [r3, #12] <== NOT EXECUTED
} else {
uintptr_t const next_block_size = _Heap_Block_size( next_block );
_Heap_Free_list_replace( next_block, free_block );
free_block_size += next_block_size;
3000b1dc: e0877001 add r7, r7, r1 <== NOT EXECUTED
new_block->next = next;
new_block->prev = prev;
3000b1e0: e582300c str r3, [r2, #12] <== NOT EXECUTED
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
3000b1e4: e5820008 str r0, [r2, #8] <== NOT EXECUTED
new_block->prev = prev;
next->prev = new_block;
3000b1e8: e580200c str r2, [r0, #12] <== NOT EXECUTED
prev->next = new_block;
3000b1ec: e5832008 str r2, [r3, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000b1f0: e0873002 add r3, r7, r2 <== NOT EXECUTED
next_block = _Heap_Block_at( free_block, free_block_size );
}
free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED;
3000b1f4: e3871001 orr r1, r7, #1 3000b1f8: e5821004 str r1, [r2, #4]
next_block->prev_size = free_block_size;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000b1fc: e5932004 ldr r2, [r3, #4]
next_block = _Heap_Block_at( free_block, free_block_size );
}
free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED;
next_block->prev_size = free_block_size;
3000b200: e5837000 str r7, [r3]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000b204: e3c22001 bic r2, r2, #1
_Heap_Protection_block_initialize( heap, free_block );
} else {
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000b208: e5832004 str r2, [r3, #4]
3000b20c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000f334 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
3000f334: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3000f338: e1a05001 mov r5, r1 <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
3000f33c: e5901020 ldr r1, [r0, #32] <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
3000f340: e24dd024 sub sp, sp, #36 ; 0x24 <== NOT EXECUTED
Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size;
3000f344: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
3000f348: e58d1010 str r1, [sp, #16] <== NOT EXECUTED
Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size;
3000f34c: e5901030 ldr r1, [r0, #48] ; 0x30 <== NOT EXECUTED
Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL;
3000f350: e3a08000 mov r8, #0 <== NOT EXECUTED
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
3000f354: e0956002 adds r6, r5, r2 <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t unused __attribute__((unused))
)
{
3000f358: e1a04000 mov r4, r0 <== NOT EXECUTED
Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size;
3000f35c: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL;
3000f360: e58d801c str r8, [sp, #28] <== NOT EXECUTED
Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size;
3000f364: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED
Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL;
3000f368: e58d8020 str r8, [sp, #32] <== NOT EXECUTED
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size;
3000f36c: e58d1018 str r1, [sp, #24] <== NOT EXECUTED
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
return 0;
3000f370: 21a00008 movcs r0, r8 <== NOT EXECUTED
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
3000f374: 2a000099 bcs 3000f5e0 <_Heap_Extend+0x2ac> <== NOT EXECUTED
return 0;
}
extend_area_ok = _Heap_Get_first_and_last_block(
3000f378: e28d101c add r1, sp, #28 <== NOT EXECUTED 3000f37c: e58d1000 str r1, [sp] <== NOT EXECUTED 3000f380: e28d1020 add r1, sp, #32 <== NOT EXECUTED 3000f384: e58d1004 str r1, [sp, #4] <== NOT EXECUTED 3000f388: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f38c: e1a01002 mov r1, r2 <== NOT EXECUTED 3000f390: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 3000f394: ebffefb4 bl 3000b26c <_Heap_Get_first_and_last_block> <== NOT EXECUTED
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
3000f398: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f39c: 0a00008f beq 3000f5e0 <_Heap_Extend+0x2ac> <== NOT EXECUTED 3000f3a0: e59da010 ldr sl, [sp, #16] <== NOT EXECUTED 3000f3a4: e1a07008 mov r7, r8 <== NOT EXECUTED 3000f3a8: e1a09008 mov r9, r8 <== NOT EXECUTED
return 0;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
3000f3ac: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED 3000f3b0: e1a03008 mov r3, r8 <== NOT EXECUTED 3000f3b4: e1a0c004 mov ip, r4 <== NOT EXECUTED 3000f3b8: ea000000 b 3000f3c0 <_Heap_Extend+0x8c> <== NOT EXECUTED 3000f3bc: e1a0100a mov r1, sl <== NOT EXECUTED
uintptr_t const sub_area_end = start_block->prev_size;
3000f3c0: e59a4000 ldr r4, [sl] <== NOT EXECUTED
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
3000f3c4: e1560001 cmp r6, r1 <== NOT EXECUTED 3000f3c8: 93a00000 movls r0, #0 <== NOT EXECUTED 3000f3cc: 83a00001 movhi r0, #1 <== NOT EXECUTED 3000f3d0: e1550004 cmp r5, r4 <== NOT EXECUTED 3000f3d4: 23a00000 movcs r0, #0 <== NOT EXECUTED 3000f3d8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f3dc: 1a00007e bne 3000f5dc <_Heap_Extend+0x2a8> <== NOT EXECUTED
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return 0;
}
if ( extend_area_end == sub_area_begin ) {
3000f3e0: e1560001 cmp r6, r1 <== NOT EXECUTED 3000f3e4: 01a0300a moveq r3, sl <== NOT EXECUTED 3000f3e8: 0a000001 beq 3000f3f4 <_Heap_Extend+0xc0> <== NOT EXECUTED
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
3000f3ec: e1560004 cmp r6, r4 <== NOT EXECUTED 3000f3f0: 31a0900a movcc r9, sl <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000f3f4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f3f8: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 3000f3fc: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000f400: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 3000f404: eb002b0e bl 3001a044 <__umodsi3> <== NOT EXECUTED 3000f408: e244b008 sub fp, r4, #8 <== NOT EXECUTED
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
3000f40c: e1540005 cmp r4, r5 <== NOT EXECUTED
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000f410: e060000b rsb r0, r0, fp <== NOT EXECUTED 3000f414: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3000f418: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
3000f41c: 01a07000 moveq r7, r0 <== NOT EXECUTED
start_block->prev_size = extend_area_end;
3000f420: 058a6000 streq r6, [sl] <== NOT EXECUTED
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
3000f424: 0a000000 beq 3000f42c <_Heap_Extend+0xf8> <== NOT EXECUTED 3000f428: 31a08000 movcc r8, r0 <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000f42c: e590a004 ldr sl, [r0, #4] <== NOT EXECUTED
} else if ( sub_area_end < extend_area_begin ) {
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
3000f430: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 3000f434: e3caa001 bic sl, sl, #1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000f438: e080a00a add sl, r0, sl <== NOT EXECUTED 3000f43c: e15a0002 cmp sl, r2 <== NOT EXECUTED 3000f440: 1affffdd bne 3000f3bc <_Heap_Extend+0x88> <== NOT EXECUTED 3000f444: e1a02009 mov r2, r9 <== NOT EXECUTED 3000f448: e1a09003 mov r9, r3 <== NOT EXECUTED
if ( extend_area_begin < heap->area_begin ) {
3000f44c: e59c3018 ldr r3, [ip, #24] <== NOT EXECUTED 3000f450: e1a0400c mov r4, ip <== NOT EXECUTED 3000f454: e1550003 cmp r5, r3 <== NOT EXECUTED
heap->area_begin = extend_area_begin;
3000f458: 358c5018 strcc r5, [ip, #24] <== NOT EXECUTED
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
if ( extend_area_begin < heap->area_begin ) {
3000f45c: 3a000002 bcc 3000f46c <_Heap_Extend+0x138> <== NOT EXECUTED
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
3000f460: e59c301c ldr r3, [ip, #28] <== NOT EXECUTED 3000f464: e1530006 cmp r3, r6 <== NOT EXECUTED
heap->area_end = extend_area_end;
3000f468: 358c601c strcc r6, [ip, #28] <== NOT EXECUTED
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
3000f46c: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 3000f470: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
extend_first_block->prev_size = extend_area_end;
3000f474: e5816000 str r6, [r1] <== NOT EXECUTED
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
3000f478: e0610003 rsb r0, r1, r3 <== NOT EXECUTED
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
3000f47c: e380c001 orr ip, r0, #1 <== NOT EXECUTED
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
3000f480: e5830000 str r0, [r3] <== NOT EXECUTED
extend_last_block->size_and_flag = 0;
3000f484: e3a00000 mov r0, #0 <== NOT EXECUTED
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
3000f488: e581c004 str ip, [r1, #4] <== NOT EXECUTED
extend_first_block_size | HEAP_PREV_BLOCK_USED;
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
3000f48c: e5830004 str r0, [r3, #4] <== NOT EXECUTED
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
3000f490: e5940020 ldr r0, [r4, #32] <== NOT EXECUTED 3000f494: e1500001 cmp r0, r1 <== NOT EXECUTED
heap->first_block = extend_first_block;
3000f498: 85841020 strhi r1, [r4, #32] <== NOT EXECUTED
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
3000f49c: 8a000002 bhi 3000f4ac <_Heap_Extend+0x178> <== NOT EXECUTED
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
3000f4a0: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000f4a4: e1510003 cmp r1, r3 <== NOT EXECUTED
heap->last_block = extend_last_block;
3000f4a8: 35843024 strcc r3, [r4, #36] ; 0x24 <== NOT EXECUTED
}
if ( merge_below_block != NULL ) {
3000f4ac: e3590000 cmp r9, #0 <== NOT EXECUTED 3000f4b0: 0a000010 beq 3000f4f8 <_Heap_Extend+0x1c4> <== NOT EXECUTED
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
3000f4b4: e594a010 ldr sl, [r4, #16] <== NOT EXECUTED
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
3000f4b8: e2855008 add r5, r5, #8 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000f4bc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000f4c0: e1a0100a mov r1, sl <== NOT EXECUTED 3000f4c4: eb002ade bl 3001a044 <__umodsi3> <== NOT EXECUTED
if ( remainder != 0 ) {
3000f4c8: e3500000 cmp r0, #0 <== NOT EXECUTED
return value - remainder + alignment;
3000f4cc: 1085500a addne r5, r5, sl <== NOT EXECUTED 3000f4d0: 10605005 rsbne r5, r0, r5 <== NOT EXECUTED
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
3000f4d4: e5993000 ldr r3, [r9] <== NOT EXECUTED
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
3000f4d8: e2451008 sub r1, r5, #8 <== NOT EXECUTED
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
3000f4dc: e5053008 str r3, [r5, #-8] <== NOT EXECUTED
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
3000f4e0: e0613009 rsb r3, r1, r9 <== NOT EXECUTED
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
3000f4e4: e3833001 orr r3, r3, #1 <== NOT EXECUTED 3000f4e8: e5053004 str r3, [r5, #-4] <== NOT EXECUTED
_Heap_Free_block( heap, new_first_block );
3000f4ec: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f4f0: ebffff7a bl 3000f2e0 <_Heap_Free_block> <== NOT EXECUTED 3000f4f4: ea000004 b 3000f50c <_Heap_Extend+0x1d8> <== NOT EXECUTED
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
3000f4f8: e3520000 cmp r2, #0 <== NOT EXECUTED
_Heap_Link_below(
3000f4fc: 159d3020 ldrne r3, [sp, #32] <== NOT EXECUTED
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
3000f500: 10632002 rsbne r2, r3, r2 <== NOT EXECUTED 3000f504: 13822001 orrne r2, r2, #1 <== NOT EXECUTED
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
3000f508: 15832004 strne r2, [r3, #4] <== NOT EXECUTED
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
3000f50c: e3570000 cmp r7, #0 <== NOT EXECUTED 3000f510: 0a000012 beq 3000f560 <_Heap_Extend+0x22c> <== NOT EXECUTED
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
3000f514: e2466008 sub r6, r6, #8 <== NOT EXECUTED
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
3000f518: e0676006 rsb r6, r7, r6 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000f51c: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED 3000f520: e1a00006 mov r0, r6 <== NOT EXECUTED 3000f524: eb002ac6 bl 3001a044 <__umodsi3> <== NOT EXECUTED
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
3000f528: e5972004 ldr r2, [r7, #4] <== NOT EXECUTED 3000f52c: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 3000f530: e0662002 rsb r2, r6, r2 <== NOT EXECUTED
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
3000f534: e0863007 add r3, r6, r7 <== NOT EXECUTED
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
3000f538: e3822001 orr r2, r2, #1 <== NOT EXECUTED
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
3000f53c: e5832004 str r2, [r3, #4] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000f540: e5973004 ldr r3, [r7, #4] <== NOT EXECUTED
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
3000f544: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f548: e2033001 and r3, r3, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
3000f54c: e1866003 orr r6, r6, r3 <== NOT EXECUTED 3000f550: e5876004 str r6, [r7, #4] <== NOT EXECUTED 3000f554: e1a01007 mov r1, r7 <== NOT EXECUTED 3000f558: ebffff60 bl 3000f2e0 <_Heap_Free_block> <== NOT EXECUTED 3000f55c: ea00000b b 3000f590 <_Heap_Extend+0x25c> <== NOT EXECUTED
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
3000f560: e3580000 cmp r8, #0 <== NOT EXECUTED 3000f564: 0a000009 beq 3000f590 <_Heap_Extend+0x25c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000f568: e5982004 ldr r2, [r8, #4] <== NOT EXECUTED
)
{
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
3000f56c: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 3000f570: e2022001 and r2, r2, #1 <== NOT EXECUTED 3000f574: e0681001 rsb r1, r8, r1 <== NOT EXECUTED
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
3000f578: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
block->size_and_flag = size | flag;
3000f57c: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000f580: e5882004 str r2, [r8, #4] <== NOT EXECUTED
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000f584: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000f588: e3822001 orr r2, r2, #1 <== NOT EXECUTED 3000f58c: e5832004 str r2, [r3, #4] <== NOT EXECUTED
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
3000f590: e3570000 cmp r7, #0 <== NOT EXECUTED 3000f594: 03590000 cmpeq r9, #0 <== NOT EXECUTED
_Heap_Free_block( heap, extend_first_block );
3000f598: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000f59c: 059d101c ldreq r1, [sp, #28] <== NOT EXECUTED 3000f5a0: 0bffff4e bleq 3000f2e0 <_Heap_Free_block> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
heap->last_block,
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
3000f5a4: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
3000f5a8: e5941020 ldr r1, [r4, #32] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000f5ac: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
3000f5b0: e0631001 rsb r1, r3, r1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000f5b4: e2022001 and r2, r2, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
3000f5b8: e1812002 orr r2, r1, r2 <== NOT EXECUTED 3000f5bc: e5832004 str r2, [r3, #4] <== NOT EXECUTED
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
3000f5c0: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 3000f5c4: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3000f5c8: e0630000 rsb r0, r3, r0 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
3000f5cc: e594302c ldr r3, [r4, #44] ; 0x2c <== NOT EXECUTED 3000f5d0: e0833000 add r3, r3, r0 <== NOT EXECUTED 3000f5d4: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
return extended_size;
3000f5d8: ea000000 b 3000f5e0 <_Heap_Extend+0x2ac> <== NOT EXECUTED
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return 0;
3000f5dc: e3a00000 mov r0, #0 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
return extended_size;
}
3000f5e0: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
3000f5e4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000f2e0 <_Heap_Free_block>:
{
Heap_Statistics *const stats = &heap->stats;
Heap_Block *first_free;
/* Statistics */
++stats->used_blocks;
3000f2e0: e5903040 ldr r3, [r0, #64] ; 0x40 <== NOT EXECUTED
#include <rtems/system.h>
#include <rtems/score/sysstate.h>
#include <rtems/score/heap.h>
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block )
{
3000f2e4: e92d4010 push {r4, lr} <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats;
Heap_Block *first_free;
/* Statistics */
++stats->used_blocks;
3000f2e8: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000f2ec: e5803040 str r3, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
3000f2f0: e5903050 ldr r3, [r0, #80] ; 0x50 <== NOT EXECUTED
#include <rtems/system.h>
#include <rtems/score/sysstate.h>
#include <rtems/score/heap.h>
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block )
{
3000f2f4: e1a04000 mov r4, r0 <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats;
Heap_Block *first_free;
/* Statistics */
++stats->used_blocks;
--stats->frees;
3000f2f8: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000f2fc: e5803050 str r3, [r0, #80] ; 0x50 <== NOT EXECUTED
/* * The _Heap_Free() will place the block to the head of free list. We want * the new block at the end of the free list. So that initial and earlier * areas are consumed first. */ _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) );
3000f300: e2811008 add r1, r1, #8 <== NOT EXECUTED 3000f304: eb0000b7 bl 3000f5e8 <_Heap_Free> <== NOT EXECUTED
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
3000f308: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
3000f30c: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
Heap_Block *prev = block->prev;
3000f310: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
prev->next = next;
next->prev = prev;
3000f314: e582100c str r1, [r2, #12] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
3000f318: e5812008 str r2, [r1, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_before(
Heap_Block *block_next,
Heap_Block *new_block
)
{
Heap_Block *prev = block_next->prev;
3000f31c: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
new_block->next = block_next;
3000f320: e5834008 str r4, [r3, #8] <== NOT EXECUTED
new_block->prev = prev;
3000f324: e583200c str r2, [r3, #12] <== NOT EXECUTED
prev->next = new_block;
3000f328: e5823008 str r3, [r2, #8] <== NOT EXECUTED
block_next->prev = new_block;
3000f32c: e584300c str r3, [r4, #12] <== NOT EXECUTED
first_free = _Heap_Free_list_first( heap ); _Heap_Free_list_remove( first_free ); _Heap_Free_list_insert_before( _Heap_Free_list_tail( heap ), first_free ); }
3000f330: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b29c <_Heap_Initialize>:
Heap_Control *heap,
void *heap_area_begin_ptr,
uintptr_t heap_area_size,
uintptr_t page_size
)
{
3000b29c: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr}
3000b2a0: e1a08002 mov r8, r2
uintptr_t min_block_size = 0;
bool area_ok = false;
Heap_Block *first_block = NULL;
Heap_Block *last_block = NULL;
if ( page_size == 0 ) {
3000b2a4: e2535000 subs r5, r3, #0
uintptr_t first_block_begin = 0; uintptr_t first_block_size = 0; uintptr_t last_block_begin = 0; uintptr_t min_block_size = 0; bool area_ok = false; Heap_Block *first_block = NULL;
3000b2a8: e3a02000 mov r2, #0
Heap_Control *heap,
void *heap_area_begin_ptr,
uintptr_t heap_area_size,
uintptr_t page_size
)
{
3000b2ac: e1a04000 mov r4, r0 3000b2b0: e1a06001 mov r6, r1
uintptr_t first_block_begin = 0; uintptr_t first_block_size = 0; uintptr_t last_block_begin = 0; uintptr_t min_block_size = 0; bool area_ok = false; Heap_Block *first_block = NULL;
3000b2b4: e58d2008 str r2, [sp, #8]
Heap_Block *last_block = NULL;
3000b2b8: e58d200c str r2, [sp, #12]
if ( page_size == 0 ) {
page_size = CPU_ALIGNMENT;
3000b2bc: 03a05008 moveq r5, #8
uintptr_t min_block_size = 0;
bool area_ok = false;
Heap_Block *first_block = NULL;
Heap_Block *last_block = NULL;
if ( page_size == 0 ) {
3000b2c0: 0a000004 beq 3000b2d8 <_Heap_Initialize+0x3c>
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
3000b2c4: e2153007 ands r3, r5, #7
return value - remainder + alignment;
3000b2c8: 12855008 addne r5, r5, #8 3000b2cc: 10635005 rsbne r5, r3, r5
page_size = CPU_ALIGNMENT;
} else {
page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT );
if ( page_size < CPU_ALIGNMENT ) {
3000b2d0: e3550007 cmp r5, #7
3000b2d4: 9a000034 bls 3000b3ac <_Heap_Initialize+0x110>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000b2d8: e1a01005 mov r1, r5 3000b2dc: e3a00010 mov r0, #16 3000b2e0: eb003a8d bl 30019d1c <__umodsi3>
if ( remainder != 0 ) {
3000b2e4: e3500000 cmp r0, #0
return value - remainder + alignment;
3000b2e8: 12857010 addne r7, r5, #16
return 0;
}
}
min_block_size = _Heap_Align_up( sizeof( Heap_Block ), page_size );
area_ok = _Heap_Get_first_and_last_block(
3000b2ec: e28d3008 add r3, sp, #8 3000b2f0: 10607007 rsbne r7, r0, r7
} else {
return value;
3000b2f4: 03a07010 moveq r7, #16 3000b2f8: e58d3000 str r3, [sp] 3000b2fc: e28d300c add r3, sp, #12 3000b300: e58d3004 str r3, [sp, #4] 3000b304: e1a00006 mov r0, r6 3000b308: e1a01008 mov r1, r8 3000b30c: e1a02005 mov r2, r5 3000b310: e1a03007 mov r3, r7 3000b314: ebffffbd bl 3000b210 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&first_block,
&last_block
);
if ( !area_ok ) {
3000b318: e3500000 cmp r0, #0
3000b31c: 0a000023 beq 3000b3b0 <_Heap_Initialize+0x114>
return 0;
}
memset(heap, 0, sizeof(*heap));
3000b320: e3a01000 mov r1, #0 3000b324: e3a02058 mov r2, #88 ; 0x58 3000b328: e1a00004 mov r0, r4 3000b32c: eb0018b3 bl 30011600 <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;
3000b330: e59d3008 ldr r3, [sp, #8]
last_block_begin = (uintptr_t) last_block;
3000b334: e59d200c ldr r2, [sp, #12]
uintptr_t page_size
)
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr;
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
3000b338: e0888006 add r8, r8, r6
heap->Protection.block_error = _Heap_Protection_block_error_default;
#endif
first_block_begin = (uintptr_t) first_block;
last_block_begin = (uintptr_t) last_block;
first_block_size = last_block_begin - first_block_begin;
3000b33c: e0630002 rsb r0, r3, r2
/* First block */
first_block->prev_size = heap_area_end;
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED;
3000b340: e3801001 orr r1, r0, #1
first_block_begin = (uintptr_t) first_block;
last_block_begin = (uintptr_t) last_block;
first_block_size = last_block_begin - first_block_begin;
/* First block */
first_block->prev_size = heap_area_end;
3000b344: e5838000 str r8, [r3]
first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED; first_block->next = _Heap_Free_list_tail( heap );
3000b348: e9830012 stmib r3, {r1, r4}
first_block->prev = _Heap_Free_list_head( heap );
3000b34c: e583400c str r4, [r3, #12]
heap->min_block_size = min_block_size; heap->area_begin = heap_area_begin; heap->area_end = heap_area_end; heap->first_block = first_block; heap->last_block = last_block; _Heap_Free_list_head( heap )->next = first_block;
3000b350: e5843008 str r3, [r4, #8]
/* Heap control */ heap->page_size = page_size; heap->min_block_size = min_block_size; heap->area_begin = heap_area_begin; heap->area_end = heap_area_end; heap->first_block = first_block;
3000b354: e5843020 str r3, [r4, #32]
heap->last_block = last_block; _Heap_Free_list_head( heap )->next = first_block; _Heap_Free_list_tail( heap )->prev = first_block;
3000b358: e584300c str r3, [r4, #12]
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
3000b35c: e0623003 rsb r3, r2, r3
heap->page_size = page_size; heap->min_block_size = min_block_size; heap->area_begin = heap_area_begin; heap->area_end = heap_area_end; heap->first_block = first_block; heap->last_block = last_block;
3000b360: e5842024 str r2, [r4, #36] ; 0x24
first_block->next = _Heap_Free_list_tail( heap );
first_block->prev = _Heap_Free_list_head( heap );
_Heap_Protection_block_initialize( heap, first_block );
/* Heap control */
heap->page_size = page_size;
3000b364: e5845010 str r5, [r4, #16]
heap->min_block_size = min_block_size;
3000b368: e5847014 str r7, [r4, #20]
heap->area_begin = heap_area_begin;
3000b36c: e5846018 str r6, [r4, #24]
heap->area_end = heap_area_end;
3000b370: e584801c str r8, [r4, #28]
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
block->size_and_flag = size | flag;
3000b374: e5823004 str r3, [r2, #4]
/* Statistics */
stats->size = first_block_size;
stats->free_size = first_block_size;
stats->min_free_size = first_block_size;
stats->free_blocks = 1;
3000b378: e3a03001 mov r3, #1
heap->last_block = last_block;
_Heap_Free_list_head( heap )->next = first_block;
_Heap_Free_list_tail( heap )->prev = first_block;
/* Last block */
last_block->prev_size = first_block_size;
3000b37c: e5820000 str r0, [r2]
/* Statistics */
stats->size = first_block_size;
stats->free_size = first_block_size;
stats->min_free_size = first_block_size;
stats->free_blocks = 1;
3000b380: e5843038 str r3, [r4, #56] ; 0x38
stats->max_free_blocks = 1;
3000b384: e584303c str r3, [r4, #60] ; 0x3c
stats->instance = instance++;
3000b388: e59f3028 ldr r3, [pc, #40] ; 3000b3b8 <_Heap_Initialize+0x11c>
last_block->size_and_flag = 0;
_Heap_Set_last_block_size( heap );
_Heap_Protection_block_initialize( heap, last_block );
/* Statistics */
stats->size = first_block_size;
3000b38c: e584002c str r0, [r4, #44] ; 0x2c
stats->free_size = first_block_size; stats->min_free_size = first_block_size; stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++;
3000b390: e5932000 ldr r2, [r3]
_Heap_Set_last_block_size( heap );
_Heap_Protection_block_initialize( heap, last_block );
/* Statistics */
stats->size = first_block_size;
stats->free_size = first_block_size;
3000b394: e5840030 str r0, [r4, #48] ; 0x30
stats->min_free_size = first_block_size; stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++;
3000b398: e5842028 str r2, [r4, #40] ; 0x28 3000b39c: e2822001 add r2, r2, #1
_Heap_Protection_block_initialize( heap, last_block );
/* Statistics */
stats->size = first_block_size;
stats->free_size = first_block_size;
stats->min_free_size = first_block_size;
3000b3a0: e5840034 str r0, [r4, #52] ; 0x34
stats->free_blocks = 1; stats->max_free_blocks = 1; stats->instance = instance++;
3000b3a4: e5832000 str r2, [r3]
);
_HAssert(
_Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size )
);
return first_block_size;
3000b3a8: ea000000 b 3000b3b0 <_Heap_Initialize+0x114>
} else {
page_size = _Heap_Align_up( page_size, CPU_ALIGNMENT );
if ( page_size < CPU_ALIGNMENT ) {
/* Integer overflow */
return 0;
3000b3ac: e3a00000 mov r0, #0 <== NOT EXECUTED
_HAssert(
_Heap_Is_aligned( _Heap_Alloc_area_of_block( last_block ), page_size )
);
return first_block_size;
}
3000b3b0: e28dd010 add sp, sp, #16
3000b3b4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000f798 <_Heap_No_extend>:
uintptr_t unused_2 __attribute__((unused)),
uintptr_t unused_3 __attribute__((unused))
)
{
return 0;
}
3000f798: e3a00000 mov r0, #0 <== NOT EXECUTED 3000f79c: e12fff1e bx lr <== NOT EXECUTED
3000f4b0 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
3000f4b0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3000f4b4: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000f4b8: e241a008 sub sl, r1, #8 3000f4bc: e1a00001 mov r0, r1 3000f4c0: e1a05001 mov r5, r1 3000f4c4: e5941010 ldr r1, [r4, #16] 3000f4c8: e1a08003 mov r8, r3 3000f4cc: e1a07002 mov r7, r2 3000f4d0: eb002a11 bl 30019d1c <__umodsi3> 3000f4d4: e59d601c ldr r6, [sp, #28]
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
*old_size = 0;
3000f4d8: e3a03000 mov r3, #0 3000f4dc: e5883000 str r3, [r8]
*new_size = 0;
3000f4e0: e5863000 str r3, [r6]
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000f4e4: e5943020 ldr r3, [r4, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000f4e8: e060100a rsb r1, r0, sl
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000f4ec: e1530001 cmp r3, r1
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
3000f4f0: 83a00002 movhi r0, #2
3000f4f4: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
3000f4f8: e5943024 ldr r3, [r4, #36] ; 0x24
3000f4fc: e1530001 cmp r3, r1
3000f500: 3a000035 bcc 3000f5dc <_Heap_Resize_block+0x12c>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000f504: e5913004 ldr r3, [r1, #4]
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t block_size = _Heap_Block_size( block );
uintptr_t block_end = block_begin + block_size;
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
3000f508: e265c004 rsb ip, r5, #4 3000f50c: e3c33001 bic r3, r3, #1
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t block_size = _Heap_Block_size( block );
uintptr_t block_end = block_begin + block_size;
3000f510: e0812003 add r2, r1, r3 3000f514: e5920004 ldr r0, [r2, #4]
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
3000f518: e08cc002 add ip, ip, r2 3000f51c: e3c00001 bic r0, r0, #1
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000f520: e082a000 add sl, r2, r0 3000f524: e59aa004 ldr sl, [sl, #4]
bool next_block_is_free = _Heap_Is_free( next_block );
_HAssert( _Heap_Is_block_in_heap( heap, next_block ) );
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
3000f528: e588c000 str ip, [r8]
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
3000f52c: e31a0001 tst sl, #1 3000f530: 13a0a000 movne sl, #0 3000f534: 03a0a001 moveq sl, #1
if ( next_block_is_free ) {
3000f538: e35a0000 cmp sl, #0
block_size += next_block_size;
alloc_size += next_block_size;
3000f53c: 108cc000 addne ip, ip, r0
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
if ( next_block_is_free ) {
block_size += next_block_size;
3000f540: 10833000 addne r3, r3, r0
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
3000f544: e157000c cmp r7, ip
return HEAP_RESIZE_UNSATISFIED;
3000f548: 83a00001 movhi r0, #1
if ( next_block_is_free ) {
block_size += next_block_size;
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
3000f54c: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
3000f550: e35a0000 cmp sl, #0
3000f554: 0a000011 beq 3000f5a0 <_Heap_Resize_block+0xf0>
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000f558: e591c004 ldr ip, [r1, #4] 3000f55c: e20cc001 and ip, ip, #1
block->size_and_flag = size | flag;
3000f560: e183c00c orr ip, r3, ip 3000f564: e581c004 str ip, [r1, #4]
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
3000f568: e592c008 ldr ip, [r2, #8]
Heap_Block *prev = block->prev;
3000f56c: e592200c ldr r2, [r2, #12]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000f570: e0833001 add r3, r3, r1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
3000f574: e582c008 str ip, [r2, #8]
next->prev = prev;
3000f578: e58c200c str r2, [ip, #12]
_Heap_Block_set_size( block, block_size );
_Heap_Free_list_remove( next_block );
next_block = _Heap_Block_at( block, block_size );
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000f57c: e5932004 ldr r2, [r3, #4] 3000f580: e3822001 orr r2, r2, #1 3000f584: e5832004 str r2, [r3, #4]
/* Statistics */
--stats->free_blocks;
3000f588: e5943038 ldr r3, [r4, #56] ; 0x38 3000f58c: e2433001 sub r3, r3, #1 3000f590: e5843038 str r3, [r4, #56] ; 0x38
stats->free_size -= next_block_size;
3000f594: e5943030 ldr r3, [r4, #48] ; 0x30 3000f598: e0600003 rsb r0, r0, r3 3000f59c: e5840030 str r0, [r4, #48] ; 0x30
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
3000f5a0: e1a02005 mov r2, r5 3000f5a4: e1a03007 mov r3, r7 3000f5a8: e1a00004 mov r0, r4 3000f5ac: ebffef82 bl 3000b3bc <_Heap_Block_allocate>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000f5b0: e5903004 ldr r3, [r0, #4] 3000f5b4: e3c33001 bic r3, r3, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000f5b8: e2833004 add r3, r3, #4
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
3000f5bc: e0655003 rsb r5, r5, r3 3000f5c0: e0800005 add r0, r0, r5 3000f5c4: e5860000 str r0, [r6]
/* Statistics */
++stats->resizes;
3000f5c8: e5943054 ldr r3, [r4, #84] ; 0x54
return HEAP_RESIZE_SUCCESSFUL;
3000f5cc: e3a00000 mov r0, #0
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
/* Statistics */
++stats->resizes;
3000f5d0: e2833001 add r3, r3, #1
3000f5d4: e5843054 str r3, [r4, #84] ; 0x54
3000f5d8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
3000f5dc: e3a00002 mov r0, #2 <== NOT EXECUTED
}
3000f5e0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3000bea4 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000bea4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
uintptr_t const page_size = heap->page_size;
3000bea8: e590c010 ldr ip, [r0, #16] <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000beac: e24dd030 sub sp, sp, #48 ; 0x30 <== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
3000beb0: e59f34f0 ldr r3, [pc, #1264] ; 3000c3a8 <_Heap_Walk+0x504> <== NOT EXECUTED 3000beb4: e59f84f0 ldr r8, [pc, #1264] ; 3000c3ac <_Heap_Walk+0x508> <== NOT EXECUTED 3000beb8: e31200ff tst r2, #255 ; 0xff <== NOT EXECUTED
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
3000bebc: e58dc020 str ip, [sp, #32] <== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size;
3000bec0: e590c014 ldr ip, [r0, #20] <== NOT EXECUTED
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
3000bec4: 11a08003 movne r8, r3 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000bec8: e59f34e0 ldr r3, [pc, #1248] ; 3000c3b0 <_Heap_Walk+0x50c> <== NOT EXECUTED
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000becc: e58dc028 str ip, [sp, #40] ; 0x28 <== NOT EXECUTED
Heap_Block *const first_block = heap->first_block;
3000bed0: e590c020 ldr ip, [r0, #32] <== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000bed4: e5933000 ldr r3, [r3] <== NOT EXECUTED
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
3000bed8: e58dc024 str ip, [sp, #36] ; 0x24 <== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
3000bedc: e590c024 ldr ip, [r0, #36] ; 0x24 <== NOT EXECUTED
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000bee0: e3530003 cmp r3, #3 <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000bee4: e1a05000 mov r5, r0 <== NOT EXECUTED 3000bee8: e1a04001 mov r4, r1 <== NOT EXECUTED
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
3000beec: e58dc02c str ip, [sp, #44] ; 0x2c <== NOT EXECUTED
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000bef0: 1a000120 bne 3000c378 <_Heap_Walk+0x4d4> <== NOT EXECUTED
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
3000bef4: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bef8: e59f24b4 ldr r2, [pc, #1204] ; 3000c3b4 <_Heap_Walk+0x510> <== NOT EXECUTED 3000befc: e58dc000 str ip, [sp] <== NOT EXECUTED 3000bf00: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED 3000bf04: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bf08: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000bf0c: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 3000bf10: e58dc00c str ip, [sp, #12] <== NOT EXECUTED 3000bf14: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED 3000bf18: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 3000bf1c: e58dc010 str ip, [sp, #16] <== NOT EXECUTED 3000bf20: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED 3000bf24: e58d3014 str r3, [sp, #20] <== NOT EXECUTED 3000bf28: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3000bf2c: e1a00001 mov r0, r1 <== NOT EXECUTED 3000bf30: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3000bf34: e3a01000 mov r1, #0 <== NOT EXECUTED 3000bf38: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3000bf3c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf40: e12fff18 bx r8 <== NOT EXECUTED
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
3000bf44: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000bf48: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000bf4c: 1a000006 bne 3000bf6c <_Heap_Walk+0xc8> <== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
3000bf50: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bf54: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bf58: e59f2458 ldr r2, [pc, #1112] ; 3000c3b8 <_Heap_Walk+0x514> <== NOT EXECUTED 3000bf5c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf60: e12fff18 bx r8 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bf64: e59d6020 ldr r6, [sp, #32] <== NOT EXECUTED 3000bf68: ea000103 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
3000bf6c: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3000bf70: e21c7007 ands r7, ip, #7 <== NOT EXECUTED
(*printer)(
3000bf74: 11a00004 movne r0, r4 <== NOT EXECUTED 3000bf78: 13a01001 movne r1, #1 <== NOT EXECUTED 3000bf7c: 159f2438 ldrne r2, [pc, #1080] ; 3000c3bc <_Heap_Walk+0x518><== NOT EXECUTED 3000bf80: 11a0300c movne r3, ip <== NOT EXECUTED 3000bf84: 1a000103 bne 3000c398 <_Heap_Walk+0x4f4> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bf88: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bf8c: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 3000bf90: ebffe43b bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
3000bf94: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000bf98: 0a000006 beq 3000bfb8 <_Heap_Walk+0x114> <== NOT EXECUTED
(*printer)(
3000bf9c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bfa0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bfa4: e59f2414 ldr r2, [pc, #1044] ; 3000c3c0 <_Heap_Walk+0x51c> <== NOT EXECUTED 3000bfa8: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bfac: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bfb0: e12fff18 bx r8 <== NOT EXECUTED 3000bfb4: ea000025 b 3000c050 <_Heap_Walk+0x1ac> <== NOT EXECUTED 3000bfb8: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bfbc: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 3000bfc0: e28c0008 add r0, ip, #8 <== NOT EXECUTED 3000bfc4: ebffe42e bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000bfc8: e2507000 subs r7, r0, #0 <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
3000bfcc: 11a00004 movne r0, r4 <== NOT EXECUTED 3000bfd0: 13a01001 movne r1, #1 <== NOT EXECUTED 3000bfd4: 159f23e8 ldrne r2, [pc, #1000] ; 3000c3c4 <_Heap_Walk+0x520><== NOT EXECUTED 3000bfd8: 159d3024 ldrne r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bfdc: 1a000041 bne 3000c0e8 <_Heap_Walk+0x244> <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000bfe0: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bfe4: e59c6004 ldr r6, [ip, #4] <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
3000bfe8: e2166001 ands r6, r6, #1 <== NOT EXECUTED
(*printer)(
3000bfec: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000bff0: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000bff4: 059f23cc ldreq r2, [pc, #972] ; 3000c3c8 <_Heap_Walk+0x524><== NOT EXECUTED 3000bff8: 0a000009 beq 3000c024 <_Heap_Walk+0x180> <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000bffc: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED 3000c000: e59ca004 ldr sl, [ip, #4] <== NOT EXECUTED 3000c004: e3caa001 bic sl, sl, #1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000c008: e08ca00a add sl, ip, sl <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000c00c: e59a6004 ldr r6, [sl, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
3000c010: e2166001 ands r6, r6, #1 <== NOT EXECUTED 3000c014: 1a000005 bne 3000c030 <_Heap_Walk+0x18c> <== NOT EXECUTED
(*printer)(
3000c018: e59f23ac ldr r2, [pc, #940] ; 3000c3cc <_Heap_Walk+0x528> <== NOT EXECUTED 3000c01c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c020: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c024: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c028: e12fff18 bx r8 <== NOT EXECUTED 3000c02c: ea0000d2 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED
);
return false;
}
if (
3000c030: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c034: e15a000c cmp sl, ip <== NOT EXECUTED 3000c038: 0a000006 beq 3000c058 <_Heap_Walk+0x1b4> <== NOT EXECUTED
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
3000c03c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c040: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c044: e59f2384 ldr r2, [pc, #900] ; 3000c3d0 <_Heap_Walk+0x52c> <== NOT EXECUTED 3000c048: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c04c: e12fff18 bx r8 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c050: e1a06007 mov r6, r7 <== NOT EXECUTED 3000c054: ea0000c8 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
3000c058: e5957010 ldr r7, [r5, #16] <== NOT EXECUTED
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
3000c05c: e5959008 ldr r9, [r5, #8] <== NOT EXECUTED
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
3000c060: e1a0b005 mov fp, r5 <== NOT EXECUTED 3000c064: ea000032 b 3000c134 <_Heap_Walk+0x290> <== NOT EXECUTED
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000c068: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 3000c06c: e1530009 cmp r3, r9 <== NOT EXECUTED 3000c070: 83a06000 movhi r6, #0 <== NOT EXECUTED 3000c074: 8a000003 bhi 3000c088 <_Heap_Walk+0x1e4> <== NOT EXECUTED 3000c078: e5956024 ldr r6, [r5, #36] ; 0x24 <== NOT EXECUTED 3000c07c: e1560009 cmp r6, r9 <== NOT EXECUTED 3000c080: 33a06000 movcc r6, #0 <== NOT EXECUTED 3000c084: 23a06001 movcs r6, #1 <== NOT EXECUTED
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
3000c088: e21660ff ands r6, r6, #255 ; 0xff <== NOT EXECUTED
(*printer)(
3000c08c: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000c090: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000c094: 059f2338 ldreq r2, [pc, #824] ; 3000c3d4 <_Heap_Walk+0x530><== NOT EXECUTED 3000c098: 0a000011 beq 3000c0e4 <_Heap_Walk+0x240> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000c09c: e2890008 add r0, r9, #8 <== NOT EXECUTED 3000c0a0: e1a01007 mov r1, r7 <== NOT EXECUTED 3000c0a4: ebffe3f6 bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000c0a8: e2506000 subs r6, r0, #0 <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
3000c0ac: 11a00004 movne r0, r4 <== NOT EXECUTED 3000c0b0: 13a01001 movne r1, #1 <== NOT EXECUTED 3000c0b4: 159f231c ldrne r2, [pc, #796] ; 3000c3d8 <_Heap_Walk+0x534><== NOT EXECUTED 3000c0b8: 11a03009 movne r3, r9 <== NOT EXECUTED 3000c0bc: 1a0000b5 bne 3000c398 <_Heap_Walk+0x4f4> <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000c0c0: e5993004 ldr r3, [r9, #4] <== NOT EXECUTED 3000c0c4: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000c0c8: e0893003 add r3, r9, r3 <== NOT EXECUTED 3000c0cc: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000c0d0: e21cc001 ands ip, ip, #1 <== NOT EXECUTED 3000c0d4: 0a000006 beq 3000c0f4 <_Heap_Walk+0x250> <== NOT EXECUTED
(*printer)(
3000c0d8: e59f22fc ldr r2, [pc, #764] ; 3000c3dc <_Heap_Walk+0x538> <== NOT EXECUTED 3000c0dc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c0e0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c0e4: e1a03009 mov r3, r9 <== NOT EXECUTED 3000c0e8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c0ec: e12fff18 bx r8 <== NOT EXECUTED 3000c0f0: ea0000a1 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED
);
return false;
}
if ( free_block->prev != prev_block ) {
3000c0f4: e599300c ldr r3, [r9, #12] <== NOT EXECUTED 3000c0f8: e153000b cmp r3, fp <== NOT EXECUTED 3000c0fc: 0a00000a beq 3000c12c <_Heap_Walk+0x288> <== NOT EXECUTED
(*printer)(
3000c100: e58d3000 str r3, [sp] <== NOT EXECUTED 3000c104: e58dc01c str ip, [sp, #28] <== NOT EXECUTED 3000c108: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c10c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c110: e59f22c8 ldr r2, [pc, #712] ; 3000c3e0 <_Heap_Walk+0x53c> <== NOT EXECUTED 3000c114: e1a03009 mov r3, r9 <== NOT EXECUTED 3000c118: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c11c: e12fff18 bx r8 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c120: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 3000c124: e1a0600c mov r6, ip <== NOT EXECUTED 3000c128: ea000093 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED
return false;
}
prev_block = free_block;
free_block = free_block->next;
3000c12c: e1a0b009 mov fp, r9 <== NOT EXECUTED 3000c130: e5999008 ldr r9, [r9, #8] <== NOT EXECUTED
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
3000c134: e1590005 cmp r9, r5 <== NOT EXECUTED 3000c138: 1affffca bne 3000c068 <_Heap_Walk+0x1c4> <== NOT EXECUTED 3000c13c: ea000000 b 3000c144 <_Heap_Walk+0x2a0> <== NOT EXECUTED
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
3000c140: e1a0a009 mov sl, r9 <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000c144: e59a6004 ldr r6, [sl, #4] <== NOT EXECUTED
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000c148: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000c14c: e3c6b001 bic fp, r6, #1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000c150: e08a900b add r9, sl, fp <== NOT EXECUTED
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000c154: e1530009 cmp r3, r9 <== NOT EXECUTED 3000c158: 83a03000 movhi r3, #0 <== NOT EXECUTED 3000c15c: 8a000003 bhi 3000c170 <_Heap_Walk+0x2cc> <== NOT EXECUTED 3000c160: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED 3000c164: e1530009 cmp r3, r9 <== NOT EXECUTED 3000c168: 33a03000 movcc r3, #0 <== NOT EXECUTED 3000c16c: 23a03001 movcs r3, #1 <== NOT EXECUTED
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
3000c170: e21330ff ands r3, r3, #255 ; 0xff <== NOT EXECUTED 3000c174: 1a000008 bne 3000c19c <_Heap_Walk+0x2f8> <== NOT EXECUTED 3000c178: e1a06003 mov r6, r3 <== NOT EXECUTED
(*printer)(
3000c17c: e58d9000 str r9, [sp] <== NOT EXECUTED 3000c180: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c184: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c188: e59f2254 ldr r2, [pc, #596] ; 3000c3e4 <_Heap_Walk+0x540> <== NOT EXECUTED 3000c18c: e1a0300a mov r3, sl <== NOT EXECUTED 3000c190: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c194: e12fff18 bx r8 <== NOT EXECUTED
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
3000c198: ea000077 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
3000c19c: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000c1a0: e1a0000b mov r0, fp <== NOT EXECUTED 3000c1a4: e05a700c subs r7, sl, ip <== NOT EXECUTED 3000c1a8: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 3000c1ac: 13a07001 movne r7, #1 <== NOT EXECUTED 3000c1b0: ebffe3b3 bl 30005084 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
3000c1b4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c1b8: 0a000005 beq 3000c1d4 <_Heap_Walk+0x330> <== NOT EXECUTED 3000c1bc: e3570000 cmp r7, #0 <== NOT EXECUTED
(*printer)(
3000c1c0: 158db000 strne fp, [sp] <== NOT EXECUTED 3000c1c4: 11a00004 movne r0, r4 <== NOT EXECUTED 3000c1c8: 13a01001 movne r1, #1 <== NOT EXECUTED 3000c1cc: 159f2214 ldrne r2, [pc, #532] ; 3000c3e8 <_Heap_Walk+0x544><== NOT EXECUTED 3000c1d0: 1a000014 bne 3000c228 <_Heap_Walk+0x384> <== NOT EXECUTED
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
3000c1d4: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 3000c1d8: e15b000c cmp fp, ip <== NOT EXECUTED 3000c1dc: 2a000009 bcs 3000c208 <_Heap_Walk+0x364> <== NOT EXECUTED 3000c1e0: e3570000 cmp r7, #0 <== NOT EXECUTED 3000c1e4: 0a000007 beq 3000c208 <_Heap_Walk+0x364> <== NOT EXECUTED
(*printer)(
3000c1e8: e88d1800 stm sp, {fp, ip} <== NOT EXECUTED
3000c1ec: e1a00004 mov r0, r4 <== NOT EXECUTED
3000c1f0: e3a01001 mov r1, #1 <== NOT EXECUTED
3000c1f4: e59f21f0 ldr r2, [pc, #496] ; 3000c3ec <_Heap_Walk+0x548> <== NOT EXECUTED
3000c1f8: e1a0300a mov r3, sl <== NOT EXECUTED
3000c1fc: e1a0e00f mov lr, pc <== NOT EXECUTED
3000c200: e12fff18 bx r8 <== NOT EXECUTED
3000c204: ea000065 b 3000c3a0 <_Heap_Walk+0x4fc> <== NOT EXECUTED
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
3000c208: e159000a cmp r9, sl <== NOT EXECUTED 3000c20c: 8a000009 bhi 3000c238 <_Heap_Walk+0x394> <== NOT EXECUTED 3000c210: e3570000 cmp r7, #0 <== NOT EXECUTED 3000c214: 0a000007 beq 3000c238 <_Heap_Walk+0x394> <== NOT EXECUTED
(*printer)(
3000c218: e59f21d0 ldr r2, [pc, #464] ; 3000c3f0 <_Heap_Walk+0x54c> <== NOT EXECUTED 3000c21c: e58d9000 str r9, [sp] <== NOT EXECUTED 3000c220: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c224: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c228: e1a0300a mov r3, sl <== NOT EXECUTED 3000c22c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c230: e12fff18 bx r8 <== NOT EXECUTED 3000c234: ea000059 b 3000c3a0 <_Heap_Walk+0x4fc> <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000c238: e5993004 ldr r3, [r9, #4] <== NOT EXECUTED 3000c23c: e2066001 and r6, r6, #1 <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
3000c240: e3130001 tst r3, #1 <== NOT EXECUTED 3000c244: 1a000036 bne 3000c324 <_Heap_Walk+0x480> <== NOT EXECUTED
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
3000c248: e59a200c ldr r2, [sl, #12] <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000c24c: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
return _Heap_Free_list_head(heap)->next;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_last( Heap_Control *heap )
{
return _Heap_Free_list_tail(heap)->prev;
3000c250: e595100c ldr r1, [r5, #12] <== NOT EXECUTED 3000c254: e1520003 cmp r2, r3 <== NOT EXECUTED 3000c258: 059f0194 ldreq r0, [pc, #404] ; 3000c3f4 <_Heap_Walk+0x550><== NOT EXECUTED 3000c25c: 0a000003 beq 3000c270 <_Heap_Walk+0x3cc> <== NOT EXECUTED
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
3000c260: e59f3190 ldr r3, [pc, #400] ; 3000c3f8 <_Heap_Walk+0x554> <== NOT EXECUTED 3000c264: e1520005 cmp r2, r5 <== NOT EXECUTED 3000c268: e59f018c ldr r0, [pc, #396] ; 3000c3fc <_Heap_Walk+0x558> <== NOT EXECUTED 3000c26c: 11a00003 movne r0, r3 <== NOT EXECUTED
block->next,
block->next == last_free_block ?
3000c270: e59a3008 ldr r3, [sl, #8] <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000c274: e1530001 cmp r3, r1 <== NOT EXECUTED 3000c278: 059f1180 ldreq r1, [pc, #384] ; 3000c400 <_Heap_Walk+0x55c><== NOT EXECUTED 3000c27c: 0a000003 beq 3000c290 <_Heap_Walk+0x3ec> <== NOT EXECUTED
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
3000c280: e59fc17c ldr ip, [pc, #380] ; 3000c404 <_Heap_Walk+0x560> <== NOT EXECUTED 3000c284: e1530005 cmp r3, r5 <== NOT EXECUTED 3000c288: e59f1168 ldr r1, [pc, #360] ; 3000c3f8 <_Heap_Walk+0x554> <== NOT EXECUTED 3000c28c: 01a0100c moveq r1, ip <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000c290: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000c294: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3000c298: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000c29c: e58d1010 str r1, [sp, #16] <== NOT EXECUTED 3000c2a0: e1a0300a mov r3, sl <== NOT EXECUTED 3000c2a4: e58db000 str fp, [sp] <== NOT EXECUTED 3000c2a8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c2ac: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c2b0: e59f2150 ldr r2, [pc, #336] ; 3000c408 <_Heap_Walk+0x564> <== NOT EXECUTED 3000c2b4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c2b8: e12fff18 bx r8 <== NOT EXECUTED
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
3000c2bc: e5993000 ldr r3, [r9] <== NOT EXECUTED 3000c2c0: e15b0003 cmp fp, r3 <== NOT EXECUTED 3000c2c4: 0a000008 beq 3000c2ec <_Heap_Walk+0x448> <== NOT EXECUTED
(*printer)(
3000c2c8: e98d0208 stmib sp, {r3, r9} <== NOT EXECUTED
3000c2cc: e58db000 str fp, [sp] <== NOT EXECUTED
3000c2d0: e1a00004 mov r0, r4 <== NOT EXECUTED
3000c2d4: e3a01001 mov r1, #1 <== NOT EXECUTED
3000c2d8: e59f212c ldr r2, [pc, #300] ; 3000c40c <_Heap_Walk+0x568> <== NOT EXECUTED
3000c2dc: e1a0300a mov r3, sl <== NOT EXECUTED
3000c2e0: e1a0e00f mov lr, pc <== NOT EXECUTED
3000c2e4: e12fff18 bx r8 <== NOT EXECUTED
3000c2e8: ea00002c b 3000c3a0 <_Heap_Walk+0x4fc> <== NOT EXECUTED
);
return false;
}
if ( !prev_used ) {
3000c2ec: e3560000 cmp r6, #0 <== NOT EXECUTED
(*printer)(
3000c2f0: 01a00004 moveq r0, r4 <== NOT EXECUTED 3000c2f4: 03a01001 moveq r1, #1 <== NOT EXECUTED 3000c2f8: 059f2110 ldreq r2, [pc, #272] ; 3000c410 <_Heap_Walk+0x56c><== NOT EXECUTED 3000c2fc: 01a0300a moveq r3, sl <== NOT EXECUTED 3000c300: 0affff78 beq 3000c0e8 <_Heap_Walk+0x244> <== NOT EXECUTED
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
3000c304: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000c308: ea000002 b 3000c318 <_Heap_Walk+0x474> <== NOT EXECUTED
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
3000c30c: e153000a cmp r3, sl <== NOT EXECUTED 3000c310: 0a000015 beq 3000c36c <_Heap_Walk+0x4c8> <== NOT EXECUTED
return true;
}
free_block = free_block->next;
3000c314: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
3000c318: e1530005 cmp r3, r5 <== NOT EXECUTED 3000c31c: 1afffffa bne 3000c30c <_Heap_Walk+0x468> <== NOT EXECUTED 3000c320: ea000018 b 3000c388 <_Heap_Walk+0x4e4> <== NOT EXECUTED
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
3000c324: e3560000 cmp r6, #0 <== NOT EXECUTED
(*printer)(
3000c328: e58db000 str fp, [sp] <== NOT EXECUTED
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
3000c32c: 0a000006 beq 3000c34c <_Heap_Walk+0x4a8> <== NOT EXECUTED
(*printer)(
3000c330: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c334: e3a01000 mov r1, #0 <== NOT EXECUTED 3000c338: e59f20d4 ldr r2, [pc, #212] ; 3000c414 <_Heap_Walk+0x570> <== NOT EXECUTED 3000c33c: e1a0300a mov r3, sl <== NOT EXECUTED 3000c340: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c344: e12fff18 bx r8 <== NOT EXECUTED 3000c348: ea000007 b 3000c36c <_Heap_Walk+0x4c8> <== NOT EXECUTED
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
3000c34c: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3000c350: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c354: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000c358: e1a01006 mov r1, r6 <== NOT EXECUTED 3000c35c: e59f20b4 ldr r2, [pc, #180] ; 3000c418 <_Heap_Walk+0x574> <== NOT EXECUTED 3000c360: e1a0300a mov r3, sl <== NOT EXECUTED 3000c364: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c368: e12fff18 bx r8 <== NOT EXECUTED
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
3000c36c: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3000c370: e159000c cmp r9, ip <== NOT EXECUTED 3000c374: 1affff71 bne 3000c140 <_Heap_Walk+0x29c> <== NOT EXECUTED
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
3000c378: e3a06001 mov r6, #1 <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000c37c: e1a00006 mov r0, r6 <== NOT EXECUTED
3000c380: e28dd030 add sp, sp, #48 ; 0x30 <== NOT EXECUTED
3000c384: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
3000c388: e59f208c ldr r2, [pc, #140] ; 3000c41c <_Heap_Walk+0x578> <== NOT EXECUTED 3000c38c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c390: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c394: e1a0300a mov r3, sl <== NOT EXECUTED 3000c398: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c39c: e12fff18 bx r8 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000c3a0: e3a06000 mov r6, #0 <== NOT EXECUTED 3000c3a4: eafffff4 b 3000c37c <_Heap_Walk+0x4d8> <== NOT EXECUTED
3000be60 <_Heap_Walk_print>:
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
3000be60: e92d000c push {r2, r3} <== NOT EXECUTED
3000be64: e92d4001 push {r0, lr} <== NOT EXECUTED
3000be68: e1a03000 mov r3, r0 <== NOT EXECUTED
va_list ap;
if ( error ) {
3000be6c: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
3000be70: 159f0024 ldrne r0, [pc, #36] ; 3000be9c <_Heap_Walk_print+0x3c><== NOT EXECUTED
} else {
printk( "PASS[%d]: ", source );
3000be74: 059f0024 ldreq r0, [pc, #36] ; 3000bea0 <_Heap_Walk_print+0x40><== NOT EXECUTED 3000be78: e1a01003 mov r1, r3 <== NOT EXECUTED 3000be7c: ebffee89 bl 300078a8 <printk> <== NOT EXECUTED
}
va_start( ap, fmt );
3000be80: e28d100c add r1, sp, #12 <== NOT EXECUTED
vprintk( fmt, ap );
3000be84: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
3000be88: e58d1000 str r1, [sp] <== NOT EXECUTED
vprintk( fmt, ap );
3000be8c: ebfff80d bl 30009ec8 <vprintk> <== NOT EXECUTED
va_end( ap ); }
3000be90: e8bd4008 pop {r3, lr} <== NOT EXECUTED
3000be94: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000be98: e12fff1e bx lr <== NOT EXECUTED
3000be54 <_Heap_Walk_print_nothing>:
int source,
bool error,
const char *fmt,
...
)
{
3000be54: e92d000c push {r2, r3} <== NOT EXECUTED
/* Do nothing */ }
3000be58: e28dd008 add sp, sp, #8 <== NOT EXECUTED 3000be5c: e12fff1e bx lr <== NOT EXECUTED
3000b4e8 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000b4e8: e92d4007 push {r0, r1, r2, lr}
3000b4ec: e20160ff and r6, r1, #255 ; 0xff
3000b4f0: e1a04000 mov r4, r0
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
3000b4f4: e58d0000 str r0, [sp]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
3000b4f8: e59f1040 ldr r1, [pc, #64] ; 3000b540 <_Internal_error_Occurred+0x58> 3000b4fc: e1a0000d mov r0, sp 3000b500: e1a05002 mov r5, r2
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
3000b504: e58d2008 str r2, [sp, #8] 3000b508: e5cd6004 strb r6, [sp, #4]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
3000b50c: eb000755 bl 3000d268 <_User_extensions_Iterate>
_User_extensions_Fatal( the_source, is_internal, the_error );
_Internal_errors_What_happened.the_source = the_source;
3000b510: e59f302c ldr r3, [pc, #44] ; 3000b544 <_Internal_error_Occurred+0x5c><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
3000b514: e3a02005 mov r2, #5 <== NOT EXECUTED 3000b518: e5834000 str r4, [r3] <== NOT EXECUTED
_Internal_errors_What_happened.is_internal = is_internal;
3000b51c: e5c36004 strb r6, [r3, #4] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
3000b520: e5835008 str r5, [r3, #8] <== NOT EXECUTED 3000b524: e59f301c ldr r3, [pc, #28] ; 3000b548 <_Internal_error_Occurred+0x60><== NOT EXECUTED 3000b528: e5832000 str r2, [r3] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b52c: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000b530: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000b534: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
3000b538: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b53c: eafffffe b 3000b53c <_Internal_error_Occurred+0x54> <== NOT EXECUTED
3000b9f0 <_Objects_Get>:
* always NULL.
*
* If the Id is valid but the object has not been created yet, then
* the local_table entry will be NULL.
*/
index = id - information->minimum_id + 1;
3000b9f0: e5903008 ldr r3, [r0, #8]
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000b9f4: e92d4030 push {r4, r5, lr}
* always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1;
3000b9f8: e2633001 rsb r3, r3, #1
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000b9fc: e1a04002 mov r4, r2
/*
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
3000ba00: e1d021b0 ldrh r2, [r0, #16]
* always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1;
3000ba04: e0833001 add r3, r3, r1
/*
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
3000ba08: e1530002 cmp r3, r2
/* * Object Id is not within this API and Class on this node. So * it may be global in a multiprocessing system. But it is clearly * invalid on a single processor system. */ *location = OBJECTS_ERROR;
3000ba0c: 83a03001 movhi r3, #1 3000ba10: 85843000 strhi r3, [r4]
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
3000ba14: 83a05000 movhi r5, #0
/*
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
3000ba18: 8a00000b bhi 3000ba4c <_Objects_Get+0x5c>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000ba1c: e59f2030 ldr r2, [pc, #48] ; 3000ba54 <_Objects_Get+0x64> 3000ba20: e5921000 ldr r1, [r2]
++level;
3000ba24: e2811001 add r1, r1, #1
_Thread_Dispatch_disable_level = level;
3000ba28: e5821000 str r1, [r2]
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000ba2c: e590201c ldr r2, [r0, #28] 3000ba30: e7925103 ldr r5, [r2, r3, lsl #2] 3000ba34: e3550000 cmp r5, #0
*location = OBJECTS_LOCAL;
3000ba38: 13a03000 movne r3, #0
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000ba3c: 1a000001 bne 3000ba48 <_Objects_Get+0x58>
/*
* Valid Id for this API, Class and Node but the object has not
* been allocated yet.
*/
_Thread_Enable_dispatch();
3000ba40: eb00036d bl 3000c7fc <_Thread_Enable_dispatch> <== NOT EXECUTED
*location = OBJECTS_ERROR;
3000ba44: e3a03001 mov r3, #1 <== NOT EXECUTED
3000ba48: e5843000 str r3, [r4]
_Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif }
3000ba4c: e1a00005 mov r0, r5
3000ba50: e8bd8030 pop {r4, r5, pc}
3000b924 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000b924: e1a01801 lsl r1, r1, #16
3000b928: e92d4030 push {r4, r5, lr}
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000b92c: e1b05821 lsrs r5, r1, #16
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000b930: e1a04000 mov r4, r0
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
3000b934: 01a00005 moveq r0, r5
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000b938: 08bd8030 popeq {r4, r5, pc}
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
3000b93c: eb000f4e bl 3000f67c <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
3000b940: e3500000 cmp r0, #0
3000b944: 08bd8030 popeq {r4, r5, pc}
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
3000b948: e1550000 cmp r5, r0
3000b94c: 8a00000a bhi 3000b97c <_Objects_Get_information+0x58>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
3000b950: e59f302c ldr r3, [pc, #44] ; 3000b984 <_Objects_Get_information+0x60>
3000b954: e7930104 ldr r0, [r3, r4, lsl #2]
3000b958: e3500000 cmp r0, #0
3000b95c: 08bd8030 popeq {r4, r5, pc}
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
3000b960: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !info )
3000b964: e3500000 cmp r0, #0
3000b968: 08bd8030 popeq {r4, r5, pc}
* In a multprocessing configuration, we may access remote objects.
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
3000b96c: e1d031b0 ldrh r3, [r0, #16]
return NULL;
3000b970: e3530000 cmp r3, #0
3000b974: 03a00000 moveq r0, #0
3000b978: e8bd8030 pop {r4, r5, pc}
the_class_api_maximum = _Objects_API_maximum_class( the_api );
if ( the_class_api_maximum == 0 )
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
3000b97c: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
3000b980: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b988 <_Objects_Get_isr_disable>:
{
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000b988: e590c008 ldr ip, [r0, #8]
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
3000b98c: e92d4010 push {r4, lr}
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000b990: e26cc001 rsb ip, ip, #1 3000b994: e08c1001 add r1, ip, r1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000b998: e10f4000 mrs r4, CPSR 3000b99c: e384c080 orr ip, r4, #128 ; 0x80 3000b9a0: e129f00c msr CPSR_fc, ip
_ISR_Disable( level );
if ( information->maximum >= index ) {
3000b9a4: e1d0c1b0 ldrh ip, [r0, #16] 3000b9a8: e15c0001 cmp ip, r1
3000b9ac: 3a00000a bcc 3000b9dc <_Objects_Get_isr_disable+0x54>
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000b9b0: e590001c ldr r0, [r0, #28] 3000b9b4: e7900101 ldr r0, [r0, r1, lsl #2] 3000b9b8: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3000b9bc: 13a01000 movne r1, #0 3000b9c0: 15821000 strne r1, [r2]
*level_p = level;
3000b9c4: 15834000 strne r4, [r3]
index = id - information->minimum_id + 1;
_ISR_Disable( level );
if ( information->maximum >= index ) {
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000b9c8: 18bd8010 popne {r4, pc}
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b9cc: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
*location = OBJECTS_LOCAL;
*level_p = level;
return the_object;
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
3000b9d0: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b9d4: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3000b9d8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b9dc: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
} _ISR_Enable( level ); *location = OBJECTS_ERROR;
3000b9e0: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b9e4: e5823000 str r3, [r2] <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
3000b9e8: e3a00000 mov r0, #0 <== NOT EXECUTED
#endif }
3000b9ec: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30015818 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
30015818: e92d4077 push {r0, r1, r2, r4, r5, r6, lr} <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
3001581c: e2515000 subs r5, r1, #0 <== NOT EXECUTED
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
30015820: e1a04002 mov r4, r2 <== NOT EXECUTED
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
return NULL;
30015824: 01a04005 moveq r4, r5 <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
30015828: 0a00002e beq 300158e8 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED
return NULL;
if ( name == NULL )
3001582c: e3540000 cmp r4, #0 <== NOT EXECUTED 30015830: 0a00002c beq 300158e8 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
30015834: e3500000 cmp r0, #0 <== NOT EXECUTED 30015838: 059f30b0 ldreq r3, [pc, #176] ; 300158f0 <_Objects_Get_name_as_string+0xd8><== NOT EXECUTED 3001583c: 11a06000 movne r6, r0 <== NOT EXECUTED 30015840: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED 30015844: 05936008 ldreq r6, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
30015848: e1a00006 mov r0, r6 <== NOT EXECUTED 3001584c: ebffe613 bl 3000f0a0 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
30015850: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return NULL;
30015854: 01a04003 moveq r4, r3 <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
information = _Objects_Get_information_id( tmpId );
if ( !information )
30015858: 0a000022 beq 300158e8 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
3001585c: e1a01006 mov r1, r6 <== NOT EXECUTED 30015860: e28d2008 add r2, sp, #8 <== NOT EXECUTED 30015864: ebffe645 bl 3000f180 <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
30015868: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3001586c: e3530000 cmp r3, #0 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
30015870: 13a04000 movne r4, #0 <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
if ( !information )
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
switch ( location ) {
30015874: 1a00001b bne 300158e8 <_Objects_Get_name_as_string+0xd0> <== NOT EXECUTED
if ( information->is_string ) {
s = the_object->name.name_p;
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
30015878: e590200c ldr r2, [r0, #12] <== NOT EXECUTED
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
3001587c: e5cd3004 strb r3, [sp, #4] <== NOT EXECUTED
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
30015880: e1a01c22 lsr r1, r2, #24 <== NOT EXECUTED 30015884: e5cd1000 strb r1, [sp] <== NOT EXECUTED
lname[ 1 ] = (u32_name >> 16) & 0xff;
30015888: e1a01822 lsr r1, r2, #16 <== NOT EXECUTED 3001588c: e5cd1001 strb r1, [sp, #1] <== NOT EXECUTED
lname[ 2 ] = (u32_name >> 8) & 0xff;
30015890: e1a01422 lsr r1, r2, #8 <== NOT EXECUTED 30015894: e5cd1002 strb r1, [sp, #2] <== NOT EXECUTED
lname[ 3 ] = (u32_name >> 0) & 0xff;
30015898: e5cd2003 strb r2, [sp, #3] <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3001589c: e1a01004 mov r1, r4 <== NOT EXECUTED 300158a0: e2455001 sub r5, r5, #1 <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
300158a4: e59f0048 ldr r0, [pc, #72] ; 300158f4 <_Objects_Get_name_as_string+0xdc><== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
300158a8: ea000006 b 300158c8 <_Objects_Get_name_as_string+0xb0> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
300158ac: e590c000 ldr ip, [r0] <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
300158b0: e2833001 add r3, r3, #1 <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
300158b4: e08cc002 add ip, ip, r2 <== NOT EXECUTED 300158b8: e5dcc001 ldrb ip, [ip, #1] <== NOT EXECUTED 300158bc: e31c0097 tst ip, #151 ; 0x97 <== NOT EXECUTED 300158c0: 03a0202a moveq r2, #42 ; 0x2a <== NOT EXECUTED 300158c4: e4c12001 strb r2, [r1], #1 <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
300158c8: e1530005 cmp r3, r5 <== NOT EXECUTED 300158cc: 2a000002 bcs 300158dc <_Objects_Get_name_as_string+0xc4> <== NOT EXECUTED 300158d0: e7dd2003 ldrb r2, [sp, r3] <== NOT EXECUTED 300158d4: e3520000 cmp r2, #0 <== NOT EXECUTED 300158d8: 1afffff3 bne 300158ac <_Objects_Get_name_as_string+0x94> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
300158dc: e3a03000 mov r3, #0 <== NOT EXECUTED 300158e0: e5c13000 strb r3, [r1] <== NOT EXECUTED
_Thread_Enable_dispatch();
300158e4: ebffe9ca bl 30010014 <_Thread_Enable_dispatch> <== NOT EXECUTED
return name;
}
return NULL; /* unreachable path */
}
300158e8: e1a00004 mov r0, r4 <== NOT EXECUTED
300158ec: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
300179f0 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
300179f0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
300179f4: e2507000 subs r7, r0, #0 <== NOT EXECUTED
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
300179f8: e1a04002 mov r4, r2 <== NOT EXECUTED 300179fc: e1a06003 mov r6, r3 <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
return NULL;
30017a00: 01a00007 moveq r0, r7 <== NOT EXECUTED
)
{
Objects_Control *object;
Objects_Id next_id;
if ( !information )
30017a04: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return NULL;
if ( !location_p )
30017a08: e3520000 cmp r2, #0 <== NOT EXECUTED
return NULL;
30017a0c: 01a00002 moveq r0, r2 <== NOT EXECUTED
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
30017a10: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return NULL;
if ( !next_id_p )
30017a14: e3530000 cmp r3, #0 <== NOT EXECUTED 30017a18: 0a000016 beq 30017a78 <_Objects_Get_next+0x88> <== NOT EXECUTED
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
30017a1c: e1b03801 lsls r3, r1, #16 <== NOT EXECUTED
next_id = information->minimum_id;
30017a20: 05975008 ldreq r5, [r7, #8] <== NOT EXECUTED
else
next_id = id;
30017a24: 11a05001 movne r5, r1 <== NOT EXECUTED
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
30017a28: e1d731b0 ldrh r3, [r7, #16] <== NOT EXECUTED 30017a2c: e1a02805 lsl r2, r5, #16 <== NOT EXECUTED 30017a30: e1530822 cmp r3, r2, lsr #16 <== NOT EXECUTED 30017a34: 2a000005 bcs 30017a50 <_Objects_Get_next+0x60> <== NOT EXECUTED
{
*location_p = OBJECTS_ERROR;
30017a38: e3a03001 mov r3, #1 <== NOT EXECUTED 30017a3c: e5843000 str r3, [r4] <== NOT EXECUTED
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
30017a40: e3e03000 mvn r3, #0 <== NOT EXECUTED 30017a44: e5863000 str r3, [r6] <== NOT EXECUTED
return 0;
30017a48: e3a00000 mov r0, #0 <== NOT EXECUTED
30017a4c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
30017a50: e1a01005 mov r1, r5 <== NOT EXECUTED 30017a54: e1a00007 mov r0, r7 <== NOT EXECUTED 30017a58: e1a02004 mov r2, r4 <== NOT EXECUTED 30017a5c: ebffddc7 bl 3000f180 <_Objects_Get> <== NOT EXECUTED
next_id++;
} while (*location_p != OBJECTS_LOCAL);
30017a60: e5943000 ldr r3, [r4] <== NOT EXECUTED
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
next_id++;
30017a64: e2855001 add r5, r5, #1 <== NOT EXECUTED
} while (*location_p != OBJECTS_LOCAL);
30017a68: e3530000 cmp r3, #0 <== NOT EXECUTED 30017a6c: 1affffed bne 30017a28 <_Objects_Get_next+0x38> <== NOT EXECUTED
*next_id_p = next_id;
30017a70: e5865000 str r5, [r6] <== NOT EXECUTED
return object;
30017a74: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
30017a78: e1a00003 mov r0, r3 <== NOT EXECUTED
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
30017a7c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000f1e8 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
3000f1e8: e92d4011 push {r0, r4, lr}
3000f1ec: e1a04001 mov r4, r1
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000f1f0: e2501000 subs r1, r0, #0 3000f1f4: 059f306c ldreq r3, [pc, #108] ; 3000f268 <_Objects_Id_to_name+0x80> 3000f1f8: 05933008 ldreq r3, [r3, #8] 3000f1fc: 05931008 ldreq r1, [r3, #8] 3000f200: e1a03c21 lsr r3, r1, #24 3000f204: e2033007 and r3, r3, #7
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
3000f208: e2432001 sub r2, r3, #1 3000f20c: e3520002 cmp r2, #2
3000f210: 8a00000d bhi 3000f24c <_Objects_Id_to_name+0x64>
3000f214: ea00000e b 3000f254 <_Objects_Id_to_name+0x6c>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000f218: e1a02da1 lsr r2, r1, #27
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
3000f21c: e7930102 ldr r0, [r3, r2, lsl #2]
if ( !information )
3000f220: e3500000 cmp r0, #0
3000f224: 0a000008 beq 3000f24c <_Objects_Id_to_name+0x64>
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
3000f228: e1a0200d mov r2, sp 3000f22c: ebffffd3 bl 3000f180 <_Objects_Get>
if ( !the_object )
3000f230: e3500000 cmp r0, #0
3000f234: 0a000004 beq 3000f24c <_Objects_Id_to_name+0x64>
return OBJECTS_INVALID_ID;
*name = the_object->name;
3000f238: e590300c ldr r3, [r0, #12] 3000f23c: e5843000 str r3, [r4]
_Thread_Enable_dispatch();
3000f240: eb000373 bl 30010014 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000f244: e3a00000 mov r0, #0 3000f248: ea000000 b 3000f250 <_Objects_Id_to_name+0x68>
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
3000f24c: e3a00003 mov r0, #3 <== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
3000f250: e8bd8018 pop {r3, r4, pc}
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
3000f254: e59f2010 ldr r2, [pc, #16] ; 3000f26c <_Objects_Id_to_name+0x84> 3000f258: e7923103 ldr r3, [r2, r3, lsl #2] 3000f25c: e3530000 cmp r3, #0
3000f260: 1affffec bne 3000f218 <_Objects_Id_to_name+0x30>
3000f264: eafffff8 b 3000f24c <_Objects_Id_to_name+0x64> <== NOT EXECUTED
3000bb28 <_Objects_Name_to_id_u32>:
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000bb28: e3530000 cmp r3, #0
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
3000bb2c: e92d4030 push {r4, r5, lr}
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
3000bb30: 03a00002 moveq r0, #2
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000bb34: 08bd8030 popeq {r4, r5, pc}
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
3000bb38: e3510000 cmp r1, #0
3000bb3c: 0a000017 beq 3000bba0 <_Objects_Name_to_id_u32+0x78>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
3000bb40: e1d041b0 ldrh r4, [r0, #16] 3000bb44: e3540000 cmp r4, #0
3000bb48: 0a000016 beq 3000bba8 <_Objects_Name_to_id_u32+0x80>
3000bb4c: e3720106 cmn r2, #-2147483647 ; 0x80000001 3000bb50: 13520000 cmpne r2, #0 3000bb54: 03a02001 moveq r2, #1
3000bb58: 0a00000e beq 3000bb98 <_Objects_Name_to_id_u32+0x70>
(node == OBJECTS_SEARCH_ALL_NODES ||
node == OBJECTS_SEARCH_LOCAL_NODE ||
3000bb5c: e3520001 cmp r2, #1 <== NOT EXECUTED 3000bb60: 1a00000e bne 3000bba0 <_Objects_Name_to_id_u32+0x78> <== NOT EXECUTED 3000bb64: ea00000b b 3000bb98 <_Objects_Name_to_id_u32+0x70> <== NOT EXECUTED
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
the_object = information->local_table[ index ];
3000bb68: e590c01c ldr ip, [r0, #28] 3000bb6c: e79cc102 ldr ip, [ip, r2, lsl #2]
if ( !the_object )
3000bb70: e35c0000 cmp ip, #0
3000bb74: 0a000006 beq 3000bb94 <_Objects_Name_to_id_u32+0x6c>
continue;
if ( name == the_object->name.name_u32 ) {
3000bb78: e59c500c ldr r5, [ip, #12] 3000bb7c: e1510005 cmp r1, r5
3000bb80: 1a000003 bne 3000bb94 <_Objects_Name_to_id_u32+0x6c>
*id = the_object->id;
3000bb84: e59c2008 ldr r2, [ip, #8]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000bb88: e3a00000 mov r0, #0
the_object = information->local_table[ index ];
if ( !the_object )
continue;
if ( name == the_object->name.name_u32 ) {
*id = the_object->id;
3000bb8c: e5832000 str r2, [r3]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000bb90: e8bd8030 pop {r4, r5, pc}
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
3000bb94: e2822001 add r2, r2, #1 3000bb98: e1520004 cmp r2, r4
3000bb9c: 9afffff1 bls 3000bb68 <_Objects_Name_to_id_u32+0x40>
if ( !id )
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
return OBJECTS_INVALID_NAME;
3000bba0: e3a00001 mov r0, #1 <== NOT EXECUTED
3000bba4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
return OBJECTS_INVALID_NAME;
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
3000bba8: e3a00001 mov r0, #1
#endif }
3000bbac: e8bd8030 pop {r4, r5, pc}
3000d920 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000d920: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000d924: e1a04001 mov r4, r1 <== NOT EXECUTED
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000d928: e1d013b8 ldrh r1, [r0, #56] ; 0x38 <== NOT EXECUTED 3000d92c: e1a00002 mov r0, r2 <== NOT EXECUTED
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000d930: e1a05002 mov r5, r2 <== NOT EXECUTED
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000d934: eb001a53 bl 30014288 <strnlen> <== NOT EXECUTED
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
3000d938: e3500001 cmp r0, #1 <== NOT EXECUTED 3000d93c: 85d53001 ldrbhi r3, [r5, #1] <== NOT EXECUTED 3000d940: e5d52000 ldrb r2, [r5] <== NOT EXECUTED 3000d944: 81a03803 lslhi r3, r3, #16 <== NOT EXECUTED 3000d948: 93a03602 movls r3, #2097152 ; 0x200000 <== NOT EXECUTED 3000d94c: e1a02c02 lsl r2, r2, #24 <== NOT EXECUTED 3000d950: e3500002 cmp r0, #2 <== NOT EXECUTED 3000d954: e1832002 orr r2, r3, r2 <== NOT EXECUTED 3000d958: 85d53002 ldrbhi r3, [r5, #2] <== NOT EXECUTED 3000d95c: 93a03a02 movls r3, #8192 ; 0x2000 <== NOT EXECUTED 3000d960: 81a03403 lslhi r3, r3, #8 <== NOT EXECUTED 3000d964: e3500003 cmp r0, #3 <== NOT EXECUTED 3000d968: e1822003 orr r2, r2, r3 <== NOT EXECUTED 3000d96c: 85d53003 ldrbhi r3, [r5, #3] <== NOT EXECUTED 3000d970: 93a03020 movls r3, #32 <== NOT EXECUTED 3000d974: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000d978: e584300c str r3, [r4, #12] <== NOT EXECUTED
);
}
return true;
}
3000d97c: e3a00001 mov r0, #1 <== NOT EXECUTED
3000d980: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000bc8c <_Protected_heap_Extend>:
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000bc8c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000bc90: e59f403c ldr r4, [pc, #60] ; 3000bcd4 <_Protected_heap_Extend+0x48><== NOT EXECUTED
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000bc94: e1a05000 mov r5, r0 <== NOT EXECUTED 3000bc98: e1a07001 mov r7, r1 <== NOT EXECUTED 3000bc9c: e1a06002 mov r6, r2 <== NOT EXECUTED
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000bca0: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000bca4: ebfffbb8 bl 3000ab8c <_API_Mutex_Lock> <== NOT EXECUTED
amount_extended = _Heap_Extend( the_heap, starting_address, size, 0 );
3000bca8: e1a01007 mov r1, r7 <== NOT EXECUTED 3000bcac: e1a02006 mov r2, r6 <== NOT EXECUTED 3000bcb0: e3a03000 mov r3, #0 <== NOT EXECUTED 3000bcb4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bcb8: eb000d9d bl 3000f334 <_Heap_Extend> <== NOT EXECUTED 3000bcbc: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
3000bcc0: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000bcc4: ebfffbc9 bl 3000abf0 <_API_Mutex_Unlock> <== NOT EXECUTED
return amount_extended != 0;
}
3000bcc8: e2950000 adds r0, r5, #0 <== NOT EXECUTED
3000bccc: 13a00001 movne r0, #1 <== NOT EXECUTED
3000bcd0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30010b50 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
30010b50: e92d4070 push {r4, r5, r6, lr}
if ( !the_heap )
30010b54: e2506000 subs r6, r0, #0
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
30010b58: e1a05001 mov r5, r1
if ( !the_heap )
return false;
30010b5c: 01a00006 moveq r0, r6
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
if ( !the_heap )
30010b60: 08bd8070 popeq {r4, r5, r6, pc}
return false;
if ( !the_info )
30010b64: e3510000 cmp r1, #0
30010b68: 0a000009 beq 30010b94 <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
30010b6c: e59f4028 ldr r4, [pc, #40] ; 30010b9c <_Protected_heap_Get_information+0x4c> 30010b70: e5940000 ldr r0, [r4] 30010b74: ebfff838 bl 3000ec5c <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
30010b78: e1a00006 mov r0, r6 30010b7c: e1a01005 mov r1, r5 30010b80: eb000e14 bl 300143d8 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
30010b84: e5940000 ldr r0, [r4] 30010b88: ebfff84c bl 3000ecc0 <_API_Mutex_Unlock>
return true;
30010b8c: e3a00001 mov r0, #1
30010b90: e8bd8070 pop {r4, r5, r6, pc}
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
30010b94: e1a00001 mov r0, r1 <== NOT EXECUTED
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
30010b98: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30010bfc <_Protected_heap_Walk>:
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
30010bfc: e59f3054 ldr r3, [pc, #84] ; 30010c58 <_Protected_heap_Walk+0x5c><== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
30010c00: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
30010c04: e5933000 ldr r3, [r3] <== NOT EXECUTED
30010c08: e1a06000 mov r6, r0 <== NOT EXECUTED
30010c0c: e3530000 cmp r3, #0 <== NOT EXECUTED
30010c10: e1a05001 mov r5, r1 <== NOT EXECUTED
30010c14: e20270ff and r7, r2, #255 ; 0xff <== NOT EXECUTED
30010c18: 1a00000b bne 30010c4c <_Protected_heap_Walk+0x50> <== NOT EXECUTED
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( _Thread_Dispatch_in_critical_section() == false ) {
_RTEMS_Lock_allocator();
30010c1c: e59f4038 ldr r4, [pc, #56] ; 30010c5c <_Protected_heap_Walk+0x60><== NOT EXECUTED 30010c20: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010c24: ebfff80c bl 3000ec5c <_API_Mutex_Lock> <== NOT EXECUTED
status = _Heap_Walk( the_heap, source, do_dump );
30010c28: e1a01005 mov r1, r5 <== NOT EXECUTED 30010c2c: e1a02007 mov r2, r7 <== NOT EXECUTED 30010c30: e1a00006 mov r0, r6 <== NOT EXECUTED 30010c34: ebfffc31 bl 3000fd00 <_Heap_Walk> <== NOT EXECUTED 30010c38: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
30010c3c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010c40: ebfff81e bl 3000ecc0 <_API_Mutex_Unlock> <== NOT EXECUTED
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
30010c44: e1a00005 mov r0, r5 <== NOT EXECUTED
30010c48: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( _Thread_Dispatch_in_critical_section() == false ) {
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
30010c4c: e1a02007 mov r2, r7 <== NOT EXECUTED
} return status; }
30010c50: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
if ( _Thread_Dispatch_in_critical_section() == false ) {
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
30010c54: eafffc29 b 3000fd00 <_Heap_Walk> <== NOT EXECUTED
3000ce88 <_RBTree_Iterate_unprotected>:
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
3000ce88: e3510000 cmp r1, #0 <== NOT EXECUTED
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
3000ce8c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000ce90: e1a07003 mov r7, r3 <== NOT EXECUTED
3000ce94: 13a03002 movne r3, #2 <== NOT EXECUTED
3000ce98: 03a03003 moveq r3, #3 <== NOT EXECUTED
3000ce9c: e1a04002 mov r4, r2 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000cea0: e1a06001 mov r6, r1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
3000cea4: e7905103 ldr r5, [r0, r3, lsl #2] <== NOT EXECUTED 3000cea8: ea00000b b 3000cedc <_RBTree_Iterate_unprotected+0x54> <== NOT EXECUTED
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
stop = (*visitor)( current, dir, visitor_arg );
3000ceac: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ceb0: e1a01006 mov r1, r6 <== NOT EXECUTED 3000ceb4: e1a02007 mov r2, r7 <== NOT EXECUTED 3000ceb8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000cebc: e12fff14 bx r4 <== NOT EXECUTED
current = _RBTree_Next_unprotected( current, dir );
3000cec0: e1a01006 mov r1, r6 <== NOT EXECUTED
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
stop = (*visitor)( current, dir, visitor_arg );
3000cec4: e1a08000 mov r8, r0 <== NOT EXECUTED
current = _RBTree_Next_unprotected( current, dir );
3000cec8: e1a00005 mov r0, r5 <== NOT EXECUTED 3000cecc: eb000005 bl 3000cee8 <_RBTree_Next_unprotected> <== NOT EXECUTED
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
3000ced0: e3580000 cmp r8, #0 <== NOT EXECUTED
stop = (*visitor)( current, dir, visitor_arg );
current = _RBTree_Next_unprotected( current, dir );
3000ced4: e1a05000 mov r5, r0 <== NOT EXECUTED
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
3000ced8: 18bd81f0 popne {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000cedc: e3550000 cmp r5, #0 <== NOT EXECUTED
3000cee0: 1afffff1 bne 3000ceac <_RBTree_Iterate_unprotected+0x24> <== NOT EXECUTED
3000cee4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000cee8 <_RBTree_Next_unprotected>:
const RBTree_Node *node,
RBTree_Direction dir
)
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
RBTree_Node *current = node->child [dir];
3000cee8: e2813001 add r3, r1, #1 3000ceec: e7903103 ldr r3, [r0, r3, lsl #2]
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
3000cef0: e2712001 rsbs r2, r1, #1 3000cef4: 33a02000 movcc r2, #0
RBTree_Node *next = NULL;
if ( current != NULL ) {
3000cef8: e3530000 cmp r3, #0
3000cefc: 1a000001 bne 3000cf08 <_RBTree_Next_unprotected+0x20>
3000cf00: ea000005 b 3000cf1c <_RBTree_Next_unprotected+0x34>
next = current;
while ( (current = current->child [opp_dir]) != NULL ) {
3000cf04: e1a03001 mov r3, r1 <== NOT EXECUTED
3000cf08: e2821001 add r1, r2, #1 3000cf0c: e7931101 ldr r1, [r3, r1, lsl #2] 3000cf10: e3510000 cmp r1, #0
3000cf14: 1afffffa bne 3000cf04 <_RBTree_Next_unprotected+0x1c>
3000cf18: ea000013 b 3000cf6c <_RBTree_Next_unprotected+0x84>
next = current;
}
} else {
RBTree_Node *parent = node->parent;
3000cf1c: e5903000 ldr r3, [r0]
if ( parent->parent && node == parent->child [opp_dir] ) {
3000cf20: e593c000 ldr ip, [r3] 3000cf24: e35c0000 cmp ip, #0
3000cf28: 0a000006 beq 3000cf48 <_RBTree_Next_unprotected+0x60>
3000cf2c: e2822001 add r2, r2, #1 3000cf30: e7932102 ldr r2, [r3, r2, lsl #2] 3000cf34: e1500002 cmp r0, r2
3000cf38: 1a000002 bne 3000cf48 <_RBTree_Next_unprotected+0x60>
3000cf3c: ea00000a b 3000cf6c <_RBTree_Next_unprotected+0x84>
next = parent;
} else {
while ( parent->parent && node == parent->child [dir] ) {
3000cf40: e1a00003 mov r0, r3 3000cf44: e1a03002 mov r3, r2 3000cf48: e5932000 ldr r2, [r3] 3000cf4c: e3520000 cmp r2, #0
3000cf50: 0a000004 beq 3000cf68 <_RBTree_Next_unprotected+0x80>
3000cf54: e281c001 add ip, r1, #1 3000cf58: e793c10c ldr ip, [r3, ip, lsl #2] 3000cf5c: e150000c cmp r0, ip
3000cf60: 0afffff6 beq 3000cf40 <_RBTree_Next_unprotected+0x58>
3000cf64: ea000000 b 3000cf6c <_RBTree_Next_unprotected+0x84>
RBTree_Direction dir
)
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
RBTree_Node *current = node->child [dir];
RBTree_Node *next = NULL;
3000cf68: e1a03002 mov r3, r2
}
}
}
return next;
}
3000cf6c: e1a00003 mov r0, r3 3000cf70: e12fff1e bx lr
3000c8bc <_RBTree_Sibling>:
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
3000c8bc: e2502000 subs r2, r0, #0 3000c8c0: 01a00002 moveq r0, r2 3000c8c4: 012fff1e bxeq lr
if(!(the_node->parent)) return NULL;
3000c8c8: e5923000 ldr r3, [r2] 3000c8cc: e3530000 cmp r3, #0
3000c8d0: 0a000006 beq 3000c8f0 <_RBTree_Sibling+0x34> if(!(the_node->parent->parent)) return NULL;
3000c8d4: e5930000 ldr r0, [r3] 3000c8d8: e3500000 cmp r0, #0 3000c8dc: 012fff1e bxeq lr
if(the_node == the_node->parent->child[RBT_LEFT])
3000c8e0: e5930004 ldr r0, [r3, #4] 3000c8e4: e1520000 cmp r2, r0
return the_node->parent->child[RBT_RIGHT];
3000c8e8: 05930008 ldreq r0, [r3, #8] 3000c8ec: e12fff1e bx lr
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
3000c8f0: e1a00003 mov r0, r3 <== NOT EXECUTED
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
else
return the_node->parent->child[RBT_LEFT];
}
3000c8f4: e12fff1e bx lr <== NOT EXECUTED
3000ed94 <_RTEMS_tasks_Delete_extension>:
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
3000ed94: e3a03000 mov r3, #0
static void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
3000ed98: e92d4070 push {r4, r5, r6, lr}
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
3000ed9c: e59160f8 ldr r6, [r1, #248] ; 0xf8
static void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
3000eda0: e1a04001 mov r4, r1
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
3000eda4: e58130f8 str r3, [r1, #248] ; 0xf8
while (tvp) {
3000eda8: ea000004 b 3000edc0 <_RTEMS_tasks_Delete_extension+0x2c>
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
3000edac: e1a01006 mov r1, r6 <== NOT EXECUTED 3000edb0: e1a00004 mov r0, r4 <== NOT EXECUTED
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
3000edb4: e5965000 ldr r5, [r6] <== NOT EXECUTED
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
3000edb8: eb00003d bl 3000eeb4 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
tvp = next;
3000edbc: e1a06005 mov r6, r5 <== NOT EXECUTED
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
3000edc0: e3560000 cmp r6, #0
3000edc4: 1afffff8 bne 3000edac <_RTEMS_tasks_Delete_extension+0x18>
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
3000edc8: e59400ec ldr r0, [r4, #236] ; 0xec 3000edcc: ebfffa4e bl 3000d70c <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
3000edd0: e58460ec str r6, [r4, #236] ; 0xec
}
3000edd4: e8bd8070 pop {r4, r5, r6, pc}
3000ed1c <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
3000ed1c: e59030f8 ldr r3, [r0, #248] ; 0xf8
while (tvp) {
3000ed20: ea000005 b 3000ed3c <_RTEMS_tasks_Switch_extension+0x20>
tvp->tval = *tvp->ptr;
3000ed24: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000ed28: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000ed2c: e583000c str r0, [r3, #12] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
3000ed30: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 3000ed34: e5820000 str r0, [r2] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
3000ed38: e5933000 ldr r3, [r3] <== NOT EXECUTED
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
3000ed3c: e3530000 cmp r3, #0
3000ed40: 1afffff7 bne 3000ed24 <_RTEMS_tasks_Switch_extension+0x8>
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
3000ed44: e59130f8 ldr r3, [r1, #248] ; 0xf8
while (tvp) {
3000ed48: ea000005 b 3000ed64 <_RTEMS_tasks_Switch_extension+0x48>
tvp->gval = *tvp->ptr;
3000ed4c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000ed50: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000ed54: e5831008 str r1, [r3, #8] <== NOT EXECUTED
*tvp->ptr = tvp->tval;
3000ed58: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3000ed5c: e5821000 str r1, [r2] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
3000ed60: e5933000 ldr r3, [r3] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
3000ed64: e3530000 cmp r3, #0
3000ed68: 1afffff7 bne 3000ed4c <_RTEMS_tasks_Switch_extension+0x30>
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
}
}
3000ed6c: e12fff1e bx lr
30031b20 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
30031b20: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
30031b24: e1a01000 mov r1, r0 <== NOT EXECUTED
30031b28: e1a0200d mov r2, sp <== NOT EXECUTED
30031b2c: e59f0088 ldr r0, [pc, #136] ; 30031bbc <_Rate_monotonic_Timeout+0x9c><== NOT EXECUTED
30031b30: ebff69c3 bl 3000c244 <_Objects_Get> <== NOT EXECUTED
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30031b34: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30031b38: e1a04000 mov r4, r0 <== NOT EXECUTED 30031b3c: e3530000 cmp r3, #0 <== NOT EXECUTED 30031b40: 1a00001c bne 30031bb8 <_Rate_monotonic_Timeout+0x98> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_thread = the_period->owner;
30031b44: e5900040 ldr r0, [r0, #64] ; 0x40 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_PERIOD);
30031b48: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
30031b4c: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 30031b50: 0a000006 beq 30031b70 <_Rate_monotonic_Timeout+0x50> <== NOT EXECUTED 30031b54: e5902020 ldr r2, [r0, #32] <== NOT EXECUTED 30031b58: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30031b5c: e1520003 cmp r2, r3 <== NOT EXECUTED 30031b60: 1a000002 bne 30031b70 <_Rate_monotonic_Timeout+0x50> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30031b64: e59f1054 ldr r1, [pc, #84] ; 30031bc0 <_Rate_monotonic_Timeout+0xa0><== NOT EXECUTED 30031b68: ebff6c3b bl 3000cc5c <_Thread_Clear_state> <== NOT EXECUTED 30031b6c: ea000006 b 30031b8c <_Rate_monotonic_Timeout+0x6c> <== NOT EXECUTED
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
30031b70: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 30031b74: e3530001 cmp r3, #1 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
30031b78: 13a03004 movne r3, #4 <== NOT EXECUTED 30031b7c: 15843038 strne r3, [r4, #56] ; 0x38 <== NOT EXECUTED
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
30031b80: 1a000008 bne 30031ba8 <_Rate_monotonic_Timeout+0x88> <== NOT EXECUTED
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
30031b84: e3a03003 mov r3, #3 <== NOT EXECUTED 30031b88: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
30031b8c: e1a00004 mov r0, r4 <== NOT EXECUTED 30031b90: ebffff55 bl 300318ec <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30031b94: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30031b98: e59f0024 ldr r0, [pc, #36] ; 30031bc4 <_Rate_monotonic_Timeout+0xa4><== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30031b9c: e584301c str r3, [r4, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30031ba0: e2841010 add r1, r4, #16 <== NOT EXECUTED 30031ba4: ebff6fe4 bl 3000db3c <_Watchdog_Insert> <== NOT EXECUTED
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
30031ba8: e59f3018 ldr r3, [pc, #24] ; 30031bc8 <_Rate_monotonic_Timeout+0xa8><== NOT EXECUTED 30031bac: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
30031bb0: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30031bb4: e5832000 str r2, [r3] <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
30031bb8: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000d554 <_Scheduler_CBS_Attach_thread>:
{
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d554: e59f3094 ldr r3, [pc, #148] ; 3000d5f0 <_Scheduler_CBS_Attach_thread+0x9c><== NOT EXECUTED
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000d558: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d55c: e5933000 ldr r3, [r3] <== NOT EXECUTED
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000d560: e1a05000 mov r5, r0 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d564: e1500003 cmp r0, r3 <== NOT EXECUTED
int _Scheduler_CBS_Attach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000d568: e1a04001 mov r4, r1 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d56c: 2a00001b bcs 3000d5e0 <_Scheduler_CBS_Attach_thread+0x8c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
the_thread = _Thread_Get(task_id, &location);
3000d570: e1a00001 mov r0, r1 <== NOT EXECUTED 3000d574: e1a0100d mov r1, sp <== NOT EXECUTED 3000d578: eb0003b5 bl 3000e454 <_Thread_Get> <== NOT EXECUTED
/* The routine _Thread_Get may disable dispatch and not enable again. */ if ( the_thread )
3000d57c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000d580: 0a000016 beq 3000d5e0 <_Scheduler_CBS_Attach_thread+0x8c> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000d584: eb0003aa bl 3000e434 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
3000d588: e5962088 ldr r2, [r6, #136] ; 0x88 <== NOT EXECUTED
/* Thread is already attached to a server. */
if ( sched_info->cbs_server )
3000d58c: e5920018 ldr r0, [r2, #24] <== NOT EXECUTED 3000d590: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d594: 1a000013 bne 3000d5e8 <_Scheduler_CBS_Attach_thread+0x94> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_FULL;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d598: e59f3054 ldr r3, [pc, #84] ; 3000d5f4 <_Scheduler_CBS_Attach_thread+0xa0><== NOT EXECUTED 3000d59c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d5a0: e7933105 ldr r3, [r3, r5, lsl #2] <== NOT EXECUTED 3000d5a4: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d5a8: 03e00018 mvneq r0, #24 <== NOT EXECUTED
/* Thread is already attached to a server. */
if ( sched_info->cbs_server )
return SCHEDULER_CBS_ERROR_FULL;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d5ac: 0a00000e beq 3000d5ec <_Scheduler_CBS_Attach_thread+0x98> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Server is already attached to a thread. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != -1 )
3000d5b0: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000d5b4: e3710001 cmn r1, #1 <== NOT EXECUTED 3000d5b8: 1a00000a bne 3000d5e8 <_Scheduler_CBS_Attach_thread+0x94> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_FULL;
_Scheduler_CBS_Server_list[server_id]->task_id = task_id;
3000d5bc: e5834000 str r4, [r3] <== NOT EXECUTED
sched_info->cbs_server = (void *) _Scheduler_CBS_Server_list[server_id];
3000d5c0: e5823018 str r3, [r2, #24] <== NOT EXECUTED
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
3000d5c4: e59f302c ldr r3, [pc, #44] ; 3000d5f8 <_Scheduler_CBS_Attach_thread+0xa4><== NOT EXECUTED 3000d5c8: e586307c str r3, [r6, #124] ; 0x7c <== NOT EXECUTED
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
3000d5cc: e3a03002 mov r3, #2 <== NOT EXECUTED 3000d5d0: e5863078 str r3, [r6, #120] ; 0x78 <== NOT EXECUTED
the_thread->is_preemptible = true;
3000d5d4: e3a03001 mov r3, #1 <== NOT EXECUTED 3000d5d8: e5c63070 strb r3, [r6, #112] ; 0x70 <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d5dc: ea000002 b 3000d5ec <_Scheduler_CBS_Attach_thread+0x98> <== NOT EXECUTED
the_thread = _Thread_Get(task_id, &location);
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread )
_Thread_Enable_dispatch();
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d5e0: e3e00011 mvn r0, #17 <== NOT EXECUTED 3000d5e4: ea000000 b 3000d5ec <_Scheduler_CBS_Attach_thread+0x98> <== NOT EXECUTED
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Server is already attached to a thread. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != -1 )
return SCHEDULER_CBS_ERROR_FULL;
3000d5e8: e3e00019 mvn r0, #25 <== NOT EXECUTED
the_thread->budget_callout = _Scheduler_CBS_Budget_callout;
the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
the_thread->is_preemptible = true;
return SCHEDULER_CBS_OK;
}
3000d5ec: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000da20 <_Scheduler_CBS_Budget_callout>:
Priority_Control new_priority;
Scheduler_CBS_Per_thread *sched_info;
Scheduler_CBS_Server_id server_id;
/* Put violating task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
3000da20: e59010ac ldr r1, [r0, #172] ; 0xac <== NOT EXECUTED
if ( the_thread->real_priority != new_priority )
3000da24: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
3000da28: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
Scheduler_CBS_Per_thread *sched_info;
Scheduler_CBS_Server_id server_id;
/* Put violating task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
if ( the_thread->real_priority != new_priority )
3000da2c: e1530001 cmp r3, r1 <== NOT EXECUTED
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
3000da30: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED
Scheduler_CBS_Server_id server_id;
/* Put violating task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
if ( the_thread->real_priority != new_priority )
the_thread->real_priority = new_priority;
3000da34: 15801018 strne r1, [r0, #24] <== NOT EXECUTED
if ( the_thread->current_priority != new_priority )
3000da38: e1530001 cmp r3, r1 <== NOT EXECUTED
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
3000da3c: e1a04000 mov r4, r0 <== NOT EXECUTED
/* Put violating task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
if ( the_thread->real_priority != new_priority )
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
_Thread_Change_priority(the_thread, new_priority, true);
3000da40: 13a02001 movne r2, #1 <== NOT EXECUTED 3000da44: 1b000161 blne 3000dfd0 <_Thread_Change_priority> <== NOT EXECUTED
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
3000da48: e5944088 ldr r4, [r4, #136] ; 0x88 <== NOT EXECUTED
if ( sched_info->cbs_server->cbs_budget_overrun ) {
3000da4c: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED 3000da50: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 3000da54: e3520000 cmp r2, #0 <== NOT EXECUTED 3000da58: 0a000006 beq 3000da78 <_Scheduler_CBS_Budget_callout+0x58> <== NOT EXECUTED
_Scheduler_CBS_Get_server_id(
3000da5c: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000da60: e1a0100d mov r1, sp <== NOT EXECUTED 3000da64: ebffffd6 bl 3000d9c4 <_Scheduler_CBS_Get_server_id> <== NOT EXECUTED
sched_info->cbs_server->task_id,
&server_id
);
sched_info->cbs_server->cbs_budget_overrun( server_id );
3000da68: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED 3000da6c: e59d0000 ldr r0, [sp] <== NOT EXECUTED 3000da70: e1a0e00f mov lr, pc <== NOT EXECUTED 3000da74: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED
} }
3000da78: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000d5fc <_Scheduler_CBS_Cleanup>:
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Cleanup (void)
{
3000d5fc: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000d600: e3a04000 mov r4, #0 <== NOT EXECUTED 3000d604: e59f603c ldr r6, [pc, #60] ; 3000d648 <_Scheduler_CBS_Cleanup+0x4c><== NOT EXECUTED 3000d608: e59f503c ldr r5, [pc, #60] ; 3000d64c <_Scheduler_CBS_Cleanup+0x50><== NOT EXECUTED 3000d60c: ea000005 b 3000d628 <_Scheduler_CBS_Cleanup+0x2c> <== NOT EXECUTED
if ( _Scheduler_CBS_Server_list[ i ] )
3000d610: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d614: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d618: e3530000 cmp r3, #0 <== NOT EXECUTED
_Scheduler_CBS_Destroy_server( i );
3000d61c: 11a00004 movne r0, r4 <== NOT EXECUTED 3000d620: 1b00003b blne 3000d714 <_Scheduler_CBS_Destroy_server> <== NOT EXECUTED
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000d624: e2844001 add r4, r4, #1 <== NOT EXECUTED 3000d628: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000d62c: e1540003 cmp r4, r3 <== NOT EXECUTED 3000d630: 3afffff6 bcc 3000d610 <_Scheduler_CBS_Cleanup+0x14> <== NOT EXECUTED
if ( _Scheduler_CBS_Server_list[ i ] )
_Scheduler_CBS_Destroy_server( i );
}
_Workspace_Free( _Scheduler_CBS_Server_list );
3000d634: e59f3010 ldr r3, [pc, #16] ; 3000d64c <_Scheduler_CBS_Cleanup+0x50><== NOT EXECUTED 3000d638: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000d63c: eb000740 bl 3000f344 <_Workspace_Free> <== NOT EXECUTED
return SCHEDULER_CBS_OK; }
3000d640: e3a00000 mov r0, #0 <== NOT EXECUTED
3000d644: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000d650 <_Scheduler_CBS_Create_server>:
)
{
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
3000d650: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
3000d654: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
3000d658: e3530000 cmp r3, #0 <== NOT EXECUTED
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
3000d65c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000d660: e1a05001 mov r5, r1 <== NOT EXECUTED 3000d664: e1a0a002 mov sl, r2 <== NOT EXECUTED
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
3000d668: da000023 ble 3000d6fc <_Scheduler_CBS_Create_server+0xac> <== NOT EXECUTED 3000d66c: e5903000 ldr r3, [r0] <== NOT EXECUTED 3000d670: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d674: da000020 ble 3000d6fc <_Scheduler_CBS_Create_server+0xac> <== NOT EXECUTED
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000d678: e59f308c ldr r3, [pc, #140] ; 3000d70c <_Scheduler_CBS_Create_server+0xbc><== NOT EXECUTED
if ( !_Scheduler_CBS_Server_list[i] )
3000d67c: e3a06000 mov r6, #0 <== NOT EXECUTED
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000d680: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d684: e59f3084 ldr r3, [pc, #132] ; 3000d710 <_Scheduler_CBS_Create_server+0xc0><== NOT EXECUTED 3000d688: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d68c: ea00000f b 3000d6d0 <_Scheduler_CBS_Create_server+0x80> <== NOT EXECUTED
if ( !_Scheduler_CBS_Server_list[i] )
3000d690: e4937004 ldr r7, [r3], #4 <== NOT EXECUTED 3000d694: e3570000 cmp r7, #0 <== NOT EXECUTED 3000d698: 1a00000b bne 3000d6cc <_Scheduler_CBS_Create_server+0x7c> <== NOT EXECUTED
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
3000d69c: e59f806c ldr r8, [pc, #108] ; 3000d710 <_Scheduler_CBS_Create_server+0xc0><== NOT EXECUTED
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
3000d6a0: e58a6000 str r6, [sl] <== NOT EXECUTED
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
3000d6a4: e3a00010 mov r0, #16 <== NOT EXECUTED
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
3000d6a8: e5989000 ldr r9, [r8] <== NOT EXECUTED
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
3000d6ac: eb00071e bl 3000f32c <_Workspace_Allocate> <== NOT EXECUTED
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
3000d6b0: e7890106 str r0, [r9, r6, lsl #2] <== NOT EXECUTED
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
3000d6b4: e59a2000 ldr r2, [sl] <== NOT EXECUTED 3000d6b8: e5983000 ldr r3, [r8] <== NOT EXECUTED 3000d6bc: e7933102 ldr r3, [r3, r2, lsl #2] <== NOT EXECUTED
if ( !the_server )
3000d6c0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d6c4: 1a000005 bne 3000d6e0 <_Scheduler_CBS_Create_server+0x90> <== NOT EXECUTED 3000d6c8: ea00000d b 3000d704 <_Scheduler_CBS_Create_server+0xb4> <== NOT EXECUTED
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000d6cc: e2866001 add r6, r6, #1 <== NOT EXECUTED 3000d6d0: e1560002 cmp r6, r2 <== NOT EXECUTED 3000d6d4: 1affffed bne 3000d690 <_Scheduler_CBS_Create_server+0x40> <== NOT EXECUTED
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
3000d6d8: e3e00019 mvn r0, #25 <== NOT EXECUTED
3000d6dc: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
the_server->task_id = -1;
3000d6e0: e3e02000 mvn r2, #0 <== NOT EXECUTED
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
3000d6e4: e8940003 ldm r4, {r0, r1} <== NOT EXECUTED
the_server->task_id = -1;
3000d6e8: e5832000 str r2, [r3] <== NOT EXECUTED
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
3000d6ec: e9830003 stmib r3, {r0, r1} <== NOT EXECUTED
the_server->task_id = -1; the_server->cbs_budget_overrun = budget_overrun_callback;
3000d6f0: e583500c str r5, [r3, #12] <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d6f4: e1a00007 mov r0, r7 <== NOT EXECUTED
3000d6f8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
if ( params->budget <= 0 ||
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d6fc: e3e00011 mvn r0, #17 <== NOT EXECUTED
3000d700: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
3000d704: e3e00010 mvn r0, #16 <== NOT EXECUTED
the_server->parameters = *params;
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
}
3000d708: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
3000d714 <_Scheduler_CBS_Destroy_server>:
)
{
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d714: e59f3064 ldr r3, [pc, #100] ; 3000d780 <_Scheduler_CBS_Destroy_server+0x6c><== NOT EXECUTED
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Destroy_server (
Scheduler_CBS_Server_id server_id
)
{
3000d718: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d71c: e5933000 ldr r3, [r3] <== NOT EXECUTED
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Destroy_server (
Scheduler_CBS_Server_id server_id
)
{
3000d720: e1a04000 mov r4, r0 <== NOT EXECUTED
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d724: e1500003 cmp r0, r3 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d728: 23e06011 mvncs r6, #17 <== NOT EXECUTED
)
{
int ret = SCHEDULER_CBS_OK;
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d72c: 2a000011 bcs 3000d778 <_Scheduler_CBS_Destroy_server+0x64> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d730: e59f504c ldr r5, [pc, #76] ; 3000d784 <_Scheduler_CBS_Destroy_server+0x70><== NOT EXECUTED 3000d734: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d738: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d73c: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d740: 03e06018 mvneq r6, #24 <== NOT EXECUTED
rtems_id tid;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d744: 0a00000b beq 3000d778 <_Scheduler_CBS_Destroy_server+0x64> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( (tid = _Scheduler_CBS_Server_list[server_id]->task_id) != -1 )
3000d748: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000d74c: e3710001 cmn r1, #1 <== NOT EXECUTED
int _Scheduler_CBS_Destroy_server (
Scheduler_CBS_Server_id server_id
)
{
int ret = SCHEDULER_CBS_OK;
3000d750: 03a06000 moveq r6, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( (tid = _Scheduler_CBS_Server_list[server_id]->task_id) != -1 )
3000d754: 0a000001 beq 3000d760 <_Scheduler_CBS_Destroy_server+0x4c> <== NOT EXECUTED
ret = _Scheduler_CBS_Detach_thread ( server_id, tid );
3000d758: eb00000a bl 3000d788 <_Scheduler_CBS_Detach_thread> <== NOT EXECUTED 3000d75c: e1a06000 mov r6, r0 <== NOT EXECUTED
_Workspace_Free( _Scheduler_CBS_Server_list[server_id] );
3000d760: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d764: e7930104 ldr r0, [r3, r4, lsl #2] <== NOT EXECUTED 3000d768: eb0006f5 bl 3000f344 <_Workspace_Free> <== NOT EXECUTED
_Scheduler_CBS_Server_list[server_id] = NULL;
3000d76c: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000d770: e3a02000 mov r2, #0 <== NOT EXECUTED 3000d774: e7832104 str r2, [r3, r4, lsl #2] <== NOT EXECUTED
return ret; }
3000d778: e1a00006 mov r0, r6 <== NOT EXECUTED
3000d77c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000d788 <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
3000d788: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
3000d78c: e1a05000 mov r5, r0 <== NOT EXECUTED
3000d790: e1a04001 mov r4, r1 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
the_thread = _Thread_Get(task_id, &location);
3000d794: e1a00001 mov r0, r1 <== NOT EXECUTED 3000d798: e1a0100d mov r1, sp <== NOT EXECUTED 3000d79c: eb00032c bl 3000e454 <_Thread_Get> <== NOT EXECUTED
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
3000d7a0: e2506000 subs r6, r0, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000d7a4: 1b000322 blne 3000e434 <_Thread_Enable_dispatch> <== NOT EXECUTED
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d7a8: e59f306c ldr r3, [pc, #108] ; 3000d81c <_Scheduler_CBS_Detach_thread+0x94><== NOT EXECUTED 3000d7ac: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d7b0: e1550003 cmp r5, r3 <== NOT EXECUTED 3000d7b4: 2a000016 bcs 3000d814 <_Scheduler_CBS_Detach_thread+0x8c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
3000d7b8: e3560000 cmp r6, #0 <== NOT EXECUTED 3000d7bc: 0a000014 beq 3000d814 <_Scheduler_CBS_Detach_thread+0x8c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d7c0: e59f3058 ldr r3, [pc, #88] ; 3000d820 <_Scheduler_CBS_Detach_thread+0x98><== NOT EXECUTED 3000d7c4: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d7c8: e7933105 ldr r3, [r3, r5, lsl #2] <== NOT EXECUTED 3000d7cc: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d7d0: 03e00018 mvneq r0, #24 <== NOT EXECUTED
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d7d4: 0a00000f beq 3000d818 <_Scheduler_CBS_Detach_thread+0x90> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Thread and server are not attached. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
3000d7d8: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d7dc: e1520004 cmp r2, r4 <== NOT EXECUTED 3000d7e0: 1a00000b bne 3000d814 <_Scheduler_CBS_Detach_thread+0x8c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
3000d7e4: e3e02000 mvn r2, #0 <== NOT EXECUTED 3000d7e8: e5832000 str r2, [r3] <== NOT EXECUTED
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info; sched_info->cbs_server = NULL;
3000d7ec: e5963088 ldr r3, [r6, #136] ; 0x88 <== NOT EXECUTED 3000d7f0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000d7f4: e5830018 str r0, [r3, #24] <== NOT EXECUTED
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
3000d7f8: e59630a0 ldr r3, [r6, #160] ; 0xa0 <== NOT EXECUTED 3000d7fc: e5863078 str r3, [r6, #120] ; 0x78 <== NOT EXECUTED
the_thread->budget_callout = the_thread->Start.budget_callout;
3000d800: e59630a4 ldr r3, [r6, #164] ; 0xa4 <== NOT EXECUTED 3000d804: e586307c str r3, [r6, #124] ; 0x7c <== NOT EXECUTED
the_thread->is_preemptible = the_thread->Start.is_preemptible;
3000d808: e5d6309c ldrb r3, [r6, #156] ; 0x9c <== NOT EXECUTED 3000d80c: e5c63070 strb r3, [r6, #112] ; 0x70 <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d810: ea000000 b 3000d818 <_Scheduler_CBS_Detach_thread+0x90> <== NOT EXECUTED
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Thread and server are not attached. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d814: e3e00011 mvn r0, #17 <== NOT EXECUTED
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
return SCHEDULER_CBS_OK;
}
3000d818: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000d824 <_Scheduler_CBS_Get_approved_budget>:
int _Scheduler_CBS_Get_approved_budget (
Scheduler_CBS_Server_id server_id,
time_t *approved_budget
)
{
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d824: e59f3030 ldr r3, [pc, #48] ; 3000d85c <_Scheduler_CBS_Get_approved_budget+0x38><== NOT EXECUTED 3000d828: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d82c: e1500003 cmp r0, r3 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d830: 23e00011 mvncs r0, #17 <== NOT EXECUTED
int _Scheduler_CBS_Get_approved_budget (
Scheduler_CBS_Server_id server_id,
time_t *approved_budget
)
{
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d834: 212fff1e bxcs lr <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d838: e59f3020 ldr r3, [pc, #32] ; 3000d860 <_Scheduler_CBS_Get_approved_budget+0x3c><== NOT EXECUTED 3000d83c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d840: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d844: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
*approved_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
3000d848: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d84c: 13a00000 movne r0, #0 <== NOT EXECUTED
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
*approved_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
3000d850: 15813000 strne r3, [r1] <== NOT EXECUTED
)
{
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d854: 03e00018 mvneq r0, #24 <== NOT EXECUTED
*approved_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
return SCHEDULER_CBS_OK;
}
3000d858: e12fff1e bx lr <== NOT EXECUTED
3000d864 <_Scheduler_CBS_Get_execution_time>:
)
{
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d864: e59f3090 ldr r3, [pc, #144] ; 3000d8fc <_Scheduler_CBS_Get_execution_time+0x98><== NOT EXECUTED
int _Scheduler_CBS_Get_execution_time (
Scheduler_CBS_Server_id server_id,
time_t *exec_time,
time_t *abs_time
)
{
3000d868: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d86c: e5933000 ldr r3, [r3] <== NOT EXECUTED
int _Scheduler_CBS_Get_execution_time (
Scheduler_CBS_Server_id server_id,
time_t *exec_time,
time_t *abs_time
)
{
3000d870: e1a04000 mov r4, r0 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d874: e1500003 cmp r0, r3 <== NOT EXECUTED
int _Scheduler_CBS_Get_execution_time (
Scheduler_CBS_Server_id server_id,
time_t *exec_time,
time_t *abs_time
)
{
3000d878: e1a05001 mov r5, r1 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d87c: 23e00011 mvncs r0, #17 <== NOT EXECUTED
)
{
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d880: 2a00001c bcs 3000d8f8 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d884: e59f6074 ldr r6, [pc, #116] ; 3000d900 <_Scheduler_CBS_Get_execution_time+0x9c><== NOT EXECUTED 3000d888: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000d88c: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d890: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d894: 03e00018 mvneq r0, #24 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d898: 0a000016 beq 3000d8f8 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) {
3000d89c: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000d8a0: e3700001 cmn r0, #1 <== NOT EXECUTED
*exec_time = 0;
3000d8a4: 03a00000 moveq r0, #0 <== NOT EXECUTED 3000d8a8: 05810000 streq r0, [r1] <== NOT EXECUTED
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) {
3000d8ac: 0a000011 beq 3000d8f8 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED
*exec_time = 0;
return SCHEDULER_CBS_OK;
}
the_thread = _Thread_Get(
3000d8b0: e1a0100d mov r1, sp <== NOT EXECUTED 3000d8b4: eb0002e6 bl 3000e454 <_Thread_Get> <== NOT EXECUTED
_Scheduler_CBS_Server_list[server_id]->task_id,
&location
);
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
3000d8b8: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000d8bc: 0a000008 beq 3000d8e4 <_Scheduler_CBS_Get_execution_time+0x80><== NOT EXECUTED
_Thread_Enable_dispatch();
3000d8c0: eb0002db bl 3000e434 <_Thread_Enable_dispatch> <== NOT EXECUTED
*exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget -
3000d8c4: e5963000 ldr r3, [r6] <== NOT EXECUTED
the_thread->cpu_time_budget;
}
else {
*exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
}
return SCHEDULER_CBS_OK;
3000d8c8: e3a00000 mov r0, #0 <== NOT EXECUTED
&location
);
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
_Thread_Enable_dispatch();
*exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget -
3000d8cc: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d8d0: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 3000d8d4: e5973074 ldr r3, [r7, #116] ; 0x74 <== NOT EXECUTED 3000d8d8: e0633002 rsb r3, r3, r2 <== NOT EXECUTED 3000d8dc: e5853000 str r3, [r5] <== NOT EXECUTED 3000d8e0: ea000004 b 3000d8f8 <_Scheduler_CBS_Get_execution_time+0x94><== NOT EXECUTED
the_thread->cpu_time_budget;
}
else {
*exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
3000d8e4: e5963000 ldr r3, [r6] <== NOT EXECUTED
} return SCHEDULER_CBS_OK;
3000d8e8: e1a00007 mov r0, r7 <== NOT EXECUTED
_Thread_Enable_dispatch();
*exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget -
the_thread->cpu_time_budget;
}
else {
*exec_time = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
3000d8ec: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000d8f0: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000d8f4: e5853000 str r3, [r5] <== NOT EXECUTED
} return SCHEDULER_CBS_OK; }
3000d8f8: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
3000d904 <_Scheduler_CBS_Get_parameters>:
int _Scheduler_CBS_Get_parameters (
Scheduler_CBS_Server_id server_id,
Scheduler_CBS_Parameters *params
)
{
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d904: e59f3038 ldr r3, [pc, #56] ; 3000d944 <_Scheduler_CBS_Get_parameters+0x40><== NOT EXECUTED 3000d908: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d90c: e1500003 cmp r0, r3 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d910: 23e00011 mvncs r0, #17 <== NOT EXECUTED
int _Scheduler_CBS_Get_parameters (
Scheduler_CBS_Server_id server_id,
Scheduler_CBS_Parameters *params
)
{
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d914: 212fff1e bxcs lr <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d918: e59f3028 ldr r3, [pc, #40] ; 3000d948 <_Scheduler_CBS_Get_parameters+0x44><== NOT EXECUTED 3000d91c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d920: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d924: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d928: 0a000003 beq 3000d93c <_Scheduler_CBS_Get_parameters+0x38> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
*params = _Scheduler_CBS_Server_list[server_id]->parameters;
3000d92c: e993000c ldmib r3, {r2, r3} <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d930: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
*params = _Scheduler_CBS_Server_list[server_id]->parameters;
3000d934: e881000c stm r1, {r2, r3} <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d938: e12fff1e bx lr <== NOT EXECUTED
)
{
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d93c: e3e00018 mvn r0, #24 <== NOT EXECUTED
*params = _Scheduler_CBS_Server_list[server_id]->parameters;
return SCHEDULER_CBS_OK;
}
3000d940: e12fff1e bx lr <== NOT EXECUTED
3000d94c <_Scheduler_CBS_Get_remaining_budget>:
)
{
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d94c: e59f3068 ldr r3, [pc, #104] ; 3000d9bc <_Scheduler_CBS_Get_remaining_budget+0x70><== NOT EXECUTED
int _Scheduler_CBS_Get_remaining_budget (
Scheduler_CBS_Server_id server_id,
time_t *remaining_budget
)
{
3000d950: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d954: e5933000 ldr r3, [r3] <== NOT EXECUTED
int _Scheduler_CBS_Get_remaining_budget (
Scheduler_CBS_Server_id server_id,
time_t *remaining_budget
)
{
3000d958: e1a04001 mov r4, r1 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d95c: e1500003 cmp r0, r3 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000d960: 23e00011 mvncs r0, #17 <== NOT EXECUTED
)
{
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000d964: 2a000013 bcs 3000d9b8 <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d968: e59f3050 ldr r3, [pc, #80] ; 3000d9c0 <_Scheduler_CBS_Get_remaining_budget+0x74><== NOT EXECUTED 3000d96c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000d970: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000d974: e3530000 cmp r3, #0 <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
3000d978: 03e00018 mvneq r0, #24 <== NOT EXECUTED
Objects_Locations location;
Thread_Control *the_thread;
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000d97c: 0a00000d beq 3000d9b8 <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) {
3000d980: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000d984: e3700001 cmn r0, #1 <== NOT EXECUTED
*remaining_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
3000d988: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED
if ( server_id >= _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
if ( _Scheduler_CBS_Server_list[server_id]->task_id == -1 ) {
3000d98c: 0a000007 beq 3000d9b0 <_Scheduler_CBS_Get_remaining_budget+0x64><== NOT EXECUTED
*remaining_budget = _Scheduler_CBS_Server_list[server_id]->parameters.budget;
return SCHEDULER_CBS_OK;
}
the_thread = _Thread_Get(
3000d990: e1a0100d mov r1, sp <== NOT EXECUTED 3000d994: eb0002ae bl 3000e454 <_Thread_Get> <== NOT EXECUTED
_Scheduler_CBS_Server_list[server_id]->task_id,
&location
);
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
3000d998: e2505000 subs r5, r0, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
*remaining_budget = the_thread->cpu_time_budget;
}
else {
*remaining_budget = 0;
3000d99c: 05845000 streq r5, [r4] <== NOT EXECUTED
}
return SCHEDULER_CBS_OK;
3000d9a0: 01a00005 moveq r0, r5 <== NOT EXECUTED
the_thread = _Thread_Get(
_Scheduler_CBS_Server_list[server_id]->task_id,
&location
);
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
3000d9a4: 0a000003 beq 3000d9b8 <_Scheduler_CBS_Get_remaining_budget+0x6c><== NOT EXECUTED
_Thread_Enable_dispatch();
3000d9a8: eb0002a1 bl 3000e434 <_Thread_Enable_dispatch> <== NOT EXECUTED
*remaining_budget = the_thread->cpu_time_budget;
3000d9ac: e5953074 ldr r3, [r5, #116] ; 0x74 <== NOT EXECUTED 3000d9b0: e5843000 str r3, [r4] <== NOT EXECUTED
}
else {
*remaining_budget = 0;
}
return SCHEDULER_CBS_OK;
3000d9b4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000d9b8: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000d9c4 <_Scheduler_CBS_Get_server_id>:
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000d9c4: e59f304c ldr r3, [pc, #76] ; 3000da18 <_Scheduler_CBS_Get_server_id+0x54><== NOT EXECUTED
int _Scheduler_CBS_Get_server_id (
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
3000d9c8: e92d4010 push {r4, lr} <== NOT EXECUTED
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000d9cc: e5934000 ldr r4, [r3] <== NOT EXECUTED 3000d9d0: e59f3044 ldr r3, [pc, #68] ; 3000da1c <_Scheduler_CBS_Get_server_id+0x58><== NOT EXECUTED 3000d9d4: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d9d8: e3a03000 mov r3, #0 <== NOT EXECUTED 3000d9dc: ea000009 b 3000da08 <_Scheduler_CBS_Get_server_id+0x44> <== NOT EXECUTED
if ( _Scheduler_CBS_Server_list[i] &&
3000d9e0: e492c004 ldr ip, [r2], #4 <== NOT EXECUTED 3000d9e4: e35c0000 cmp ip, #0 <== NOT EXECUTED 3000d9e8: 0a000005 beq 3000da04 <_Scheduler_CBS_Get_server_id+0x40> <== NOT EXECUTED 3000d9ec: e59cc000 ldr ip, [ip] <== NOT EXECUTED 3000d9f0: e15c0000 cmp ip, r0 <== NOT EXECUTED 3000d9f4: 1a000002 bne 3000da04 <_Scheduler_CBS_Get_server_id+0x40> <== NOT EXECUTED
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
3000d9f8: e5813000 str r3, [r1] <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000d9fc: e3a00000 mov r0, #0 <== NOT EXECUTED
3000da00: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_id task_id,
Scheduler_CBS_Server_id *server_id
)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
3000da04: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000da08: e1530004 cmp r3, r4 <== NOT EXECUTED 3000da0c: 1afffff3 bne 3000d9e0 <_Scheduler_CBS_Get_server_id+0x1c> <== NOT EXECUTED
_Scheduler_CBS_Server_list[i]->task_id == task_id ) {
*server_id = i;
return SCHEDULER_CBS_OK;
}
}
return SCHEDULER_CBS_ERROR_NOSERVER;
3000da10: e3e00018 mvn r0, #24 <== NOT EXECUTED
}
3000da14: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000da7c <_Scheduler_CBS_Initialize>:
int _Scheduler_CBS_Initialize(void)
{
3000da7c: e92d4010 push {r4, lr} <== NOT EXECUTED
unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
3000da80: e59f4050 ldr r4, [pc, #80] ; 3000dad8 <_Scheduler_CBS_Initialize+0x5c><== NOT EXECUTED 3000da84: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000da88: e1a00100 lsl r0, r0, #2 <== NOT EXECUTED 3000da8c: eb000626 bl 3000f32c <_Workspace_Allocate> <== NOT EXECUTED 3000da90: e59f3044 ldr r3, [pc, #68] ; 3000dadc <_Scheduler_CBS_Initialize+0x60><== NOT EXECUTED
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
3000da94: e3500000 cmp r0, #0 <== NOT EXECUTED
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
3000da98: e5830000 str r0, [r3] <== NOT EXECUTED 3000da9c: e1a00003 mov r0, r3 <== NOT EXECUTED
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
3000daa0: 13a03000 movne r3, #0 <== NOT EXECUTED 3000daa4: 15941000 ldrne r1, [r4] <== NOT EXECUTED 3000daa8: 11a02003 movne r2, r3 <== NOT EXECUTED
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
3000daac: 1a000003 bne 3000dac0 <_Scheduler_CBS_Initialize+0x44> <== NOT EXECUTED 3000dab0: ea000006 b 3000dad0 <_Scheduler_CBS_Initialize+0x54> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
_Scheduler_CBS_Server_list[i] = NULL;
3000dab4: e590c000 ldr ip, [r0] <== NOT EXECUTED 3000dab8: e78c2103 str r2, [ip, r3, lsl #2] <== NOT EXECUTED
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
3000dabc: e2833001 add r3, r3, #1 <== NOT EXECUTED 3000dac0: e1530001 cmp r3, r1 <== NOT EXECUTED 3000dac4: 1afffffa bne 3000dab4 <_Scheduler_CBS_Initialize+0x38> <== NOT EXECUTED
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
3000dac8: e3a00000 mov r0, #0 <== NOT EXECUTED
3000dacc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
3000dad0: e3e00010 mvn r0, #16 <== NOT EXECUTED
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
}
3000dad4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c6fc <_Scheduler_CBS_Release_job>:
{
Priority_Control new_priority;
Scheduler_CBS_Per_thread *sched_info =
(Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
Scheduler_CBS_Server *serv_info =
(Scheduler_CBS_Server *) sched_info->cbs_server;
3000c6fc: e5903088 ldr r3, [r0, #136] ; 0x88 <== NOT EXECUTED
if (deadline) {
3000c700: e3510000 cmp r1, #0 <== NOT EXECUTED
)
{
Priority_Control new_priority;
Scheduler_CBS_Per_thread *sched_info =
(Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
Scheduler_CBS_Server *serv_info =
3000c704: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED
(Scheduler_CBS_Server *) sched_info->cbs_server;
if (deadline) {
3000c708: 0a00000a beq 3000c738 <_Scheduler_CBS_Release_job+0x3c> <== NOT EXECUTED 3000c70c: e59f2044 ldr r2, [pc, #68] ; 3000c758 <_Scheduler_CBS_Release_job+0x5c><== NOT EXECUTED
/* Initializing or shifting deadline. */
if (serv_info)
3000c710: e3530000 cmp r3, #0 <== NOT EXECUTED
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
3000c714: 05923000 ldreq r3, [r2] <== NOT EXECUTED 3000c718: 00811003 addeq r1, r1, r3 <== NOT EXECUTED 3000c71c: 03c11102 biceq r1, r1, #-2147483648 ; 0x80000000 <== NOT EXECUTED
Scheduler_CBS_Server *serv_info =
(Scheduler_CBS_Server *) sched_info->cbs_server;
if (deadline) {
/* Initializing or shifting deadline. */
if (serv_info)
3000c720: 0a000009 beq 3000c74c <_Scheduler_CBS_Release_job+0x50> <== NOT EXECUTED
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
3000c724: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000c728: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000c72c: e0811002 add r1, r1, r2 <== NOT EXECUTED 3000c730: e3c11102 bic r1, r1, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000c734: ea000002 b 3000c744 <_Scheduler_CBS_Release_job+0x48> <== NOT EXECUTED
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
3000c738: e3530000 cmp r3, #0 <== NOT EXECUTED
new_priority = (_Watchdog_Ticks_since_boot + deadline)
& ~SCHEDULER_EDF_PRIO_MSB;
}
else {
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
3000c73c: e59010ac ldr r1, [r0, #172] ; 0xac <== NOT EXECUTED
}
/* Budget replenishment for the next job. */
if (serv_info)
3000c740: 0a000001 beq 3000c74c <_Scheduler_CBS_Release_job+0x50> <== NOT EXECUTED
the_thread->cpu_time_budget = serv_info->parameters.budget;
3000c744: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000c748: e5803074 str r3, [r0, #116] ; 0x74 <== NOT EXECUTED
the_thread->real_priority = new_priority;
_Thread_Change_priority(the_thread, new_priority, true);
3000c74c: e3a02001 mov r2, #1 <== NOT EXECUTED
/* Budget replenishment for the next job. */
if (serv_info)
the_thread->cpu_time_budget = serv_info->parameters.budget;
the_thread->real_priority = new_priority;
3000c750: e5801018 str r1, [r0, #24] <== NOT EXECUTED
_Thread_Change_priority(the_thread, new_priority, true);
3000c754: ea00010b b 3000cb88 <_Thread_Change_priority> <== NOT EXECUTED
3000db40 <_Scheduler_CBS_Set_parameters>:
int _Scheduler_CBS_Set_parameters (
Scheduler_CBS_Server_id server_id,
Scheduler_CBS_Parameters *params
)
{
if ( server_id >= _Scheduler_CBS_Maximum_servers )
3000db40: e59f3054 ldr r3, [pc, #84] ; 3000db9c <_Scheduler_CBS_Set_parameters+0x5c><== NOT EXECUTED 3000db44: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000db48: e1500003 cmp r0, r3 <== NOT EXECUTED 3000db4c: 2a00000e bcs 3000db8c <_Scheduler_CBS_Set_parameters+0x4c> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( params->budget <= 0 ||
3000db50: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 3000db54: e3530000 cmp r3, #0 <== NOT EXECUTED 3000db58: da00000b ble 3000db8c <_Scheduler_CBS_Set_parameters+0x4c> <== NOT EXECUTED 3000db5c: e5913000 ldr r3, [r1] <== NOT EXECUTED 3000db60: e3530000 cmp r3, #0 <== NOT EXECUTED 3000db64: da000008 ble 3000db8c <_Scheduler_CBS_Set_parameters+0x4c> <== NOT EXECUTED
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !_Scheduler_CBS_Server_list[server_id] )
3000db68: e59f3030 ldr r3, [pc, #48] ; 3000dba0 <_Scheduler_CBS_Set_parameters+0x60><== NOT EXECUTED 3000db6c: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000db70: e7933100 ldr r3, [r3, r0, lsl #2] <== NOT EXECUTED 3000db74: e3530000 cmp r3, #0 <== NOT EXECUTED 3000db78: 0a000005 beq 3000db94 <_Scheduler_CBS_Set_parameters+0x54> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NOSERVER;
_Scheduler_CBS_Server_list[server_id]->parameters = *params;
3000db7c: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
3000db80: e9830003 stmib r3, {r0, r1} <== NOT EXECUTED
return SCHEDULER_CBS_OK;
3000db84: e3a00000 mov r0, #0 <== NOT EXECUTED 3000db88: e12fff1e bx lr <== NOT EXECUTED
if ( params->budget <= 0 ||
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
3000db8c: e3e00011 mvn r0, #17 <== NOT EXECUTED 3000db90: e12fff1e bx lr <== NOT EXECUTED
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
3000db94: e3e00018 mvn r0, #24 <== NOT EXECUTED
_Scheduler_CBS_Server_list[server_id]->parameters = *params;
return SCHEDULER_CBS_OK;
}
3000db98: e12fff1e bx lr <== NOT EXECUTED
3000c75c <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
3000c75c: e92d4030 push {r4, r5, lr}
3000c760: e1a04000 mov r4, r0
Scheduler_CBS_Per_thread *sched_info;
Scheduler_CBS_Server *serv_info;
Priority_Control new_priority;
_Scheduler_EDF_Enqueue(the_thread);
3000c764: eb00003d bl 3000c860 <_Scheduler_EDF_Enqueue>
/* TODO: flash critical section? */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server;
3000c768: e5943088 ldr r3, [r4, #136] ; 0x88 3000c76c: e5933018 ldr r3, [r3, #24]
* Late unblock rule for deadline-driven tasks. The remaining time to
* deadline must be sufficient to serve the remaining computation time
* without increased utilization of this task. It might cause a deadline
* miss of another task.
*/
if (serv_info) {
3000c770: e3530000 cmp r3, #0
3000c774: 0a000012 beq 3000c7c4 <_Scheduler_CBS_Unblock+0x68>
time_t deadline = serv_info->parameters.deadline;
time_t budget = serv_info->parameters.budget;
time_t deadline_left = the_thread->cpu_time_budget;
time_t budget_left = the_thread->real_priority -
3000c778: e59f1094 ldr r1, [pc, #148] ; 3000c814 <_Scheduler_CBS_Unblock+0xb8><== NOT EXECUTED 3000c77c: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED 3000c780: e5911000 ldr r1, [r1] <== NOT EXECUTED
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
3000c784: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
*/
if (serv_info) {
time_t deadline = serv_info->parameters.deadline;
time_t budget = serv_info->parameters.budget;
time_t deadline_left = the_thread->cpu_time_budget;
time_t budget_left = the_thread->real_priority -
3000c788: e0611002 rsb r1, r1, r2 <== NOT EXECUTED
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
3000c78c: e0010190 mul r1, r0, r1 <== NOT EXECUTED 3000c790: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000c794: e5940074 ldr r0, [r4, #116] ; 0x74 <== NOT EXECUTED 3000c798: e0030390 mul r3, r0, r3 <== NOT EXECUTED 3000c79c: e1510003 cmp r1, r3 <== NOT EXECUTED 3000c7a0: da000007 ble 3000c7c4 <_Scheduler_CBS_Unblock+0x68> <== NOT EXECUTED
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
3000c7a4: e59410ac ldr r1, [r4, #172] ; 0xac <== NOT EXECUTED
if ( the_thread->real_priority != new_priority )
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
3000c7a8: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
if ( the_thread->real_priority != new_priority )
3000c7ac: e1520001 cmp r2, r1 <== NOT EXECUTED
the_thread->real_priority = new_priority;
3000c7b0: 15841018 strne r1, [r4, #24] <== NOT EXECUTED
if ( the_thread->current_priority != new_priority )
3000c7b4: e1530001 cmp r3, r1 <== NOT EXECUTED
_Thread_Change_priority(the_thread, new_priority, true);
3000c7b8: 11a00004 movne r0, r4 <== NOT EXECUTED 3000c7bc: 13a02001 movne r2, #1 <== NOT EXECUTED 3000c7c0: 1b0000f0 blne 3000cb88 <_Thread_Change_priority> <== NOT EXECUTED
* a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
3000c7c4: e59f504c ldr r5, [pc, #76] ; 3000c818 <_Scheduler_CBS_Unblock+0xbc>
3000c7c8: e5940014 ldr r0, [r4, #20]
3000c7cc: e595300c ldr r3, [r5, #12]
3000c7d0: e5931014 ldr r1, [r3, #20]
3000c7d4: e59f3040 ldr r3, [pc, #64] ; 3000c81c <_Scheduler_CBS_Unblock+0xc0>
3000c7d8: e1a0e00f mov lr, pc
3000c7dc: e593f030 ldr pc, [r3, #48] ; 0x30
3000c7e0: e3500000 cmp r0, #0
3000c7e4: d8bd8030 pople {r4, r5, pc}
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
3000c7e8: e5953008 ldr r3, [r5, #8]
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_higher_than( the_thread->current_priority,
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
3000c7ec: e585400c str r4, [r5, #12]
if ( _Thread_Executing->is_preemptible ||
3000c7f0: e5d33070 ldrb r3, [r3, #112] ; 0x70 3000c7f4: e3530000 cmp r3, #0
3000c7f8: 1a000002 bne 3000c808 <_Scheduler_CBS_Unblock+0xac>
3000c7fc: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
3000c800: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c804: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000c808: e3a03001 mov r3, #1
3000c80c: e5c53004 strb r3, [r5, #4]
3000c810: e8bd8030 pop {r4, r5, pc}
3000c820 <_Scheduler_EDF_Block>:
#include <rtems/score/thread.h>
void _Scheduler_EDF_Block(
Thread_Control *the_thread
)
{
3000c820: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000c824: e1a04000 mov r4, r0 <== NOT EXECUTED
_Scheduler_EDF_Extract( the_thread );
3000c828: eb000015 bl 3000c884 <_Scheduler_EDF_Extract> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
3000c82c: e59f3024 ldr r3, [pc, #36] ; 3000c858 <_Scheduler_EDF_Block+0x38><== NOT EXECUTED
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
3000c830: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 3000c834: e1a05003 mov r5, r3 <== NOT EXECUTED 3000c838: e1540002 cmp r4, r2 <== NOT EXECUTED
_Scheduler_EDF_Schedule();
3000c83c: 0b000040 bleq 3000c944 <_Scheduler_EDF_Schedule> <== NOT EXECUTED
if ( _Thread_Is_executing( the_thread ) )
3000c840: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000c844: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000c848: 059f3008 ldreq r3, [pc, #8] ; 3000c858 <_Scheduler_EDF_Block+0x38><== NOT EXECUTED
3000c84c: 03a02001 moveq r2, #1 <== NOT EXECUTED
3000c850: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED
3000c854: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000c85c <_Scheduler_EDF_Enqueue_first>:
void _Scheduler_EDF_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler_EDF_Enqueue(the_thread);
3000c85c: eaffffff b 3000c860 <_Scheduler_EDF_Enqueue> <== NOT EXECUTED
3000c884 <_Scheduler_EDF_Extract>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Extract(
Thread_Control *the_thread
)
{
3000c884: e92d4010 push {r4, lr} <== NOT EXECUTED
Scheduler_EDF_Per_thread *sched_info =
3000c888: e5904088 ldr r4, [r0, #136] ; 0x88 <== NOT EXECUTED
(Scheduler_EDF_Per_thread*) the_thread->scheduler_info;
RBTree_Node *node = &(sched_info->Node);
_RBTree_Extract( &_Scheduler_EDF_Ready_queue, node );
3000c88c: e59f0010 ldr r0, [pc, #16] ; 3000c8a4 <_Scheduler_EDF_Extract+0x20><== NOT EXECUTED 3000c890: e2841004 add r1, r4, #4 <== NOT EXECUTED 3000c894: eb000e8a bl 300102c4 <_RBTree_Extract> <== NOT EXECUTED
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
3000c898: e3a03000 mov r3, #0 <== NOT EXECUTED 3000c89c: e5843014 str r3, [r4, #20] <== NOT EXECUTED
}
3000c8a0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c8a8 <_Scheduler_EDF_Free>:
void _Scheduler_EDF_Free(
Thread_Control *the_thread
)
{
_Workspace_Free( the_thread->scheduler_info );
3000c8a8: e5900088 ldr r0, [r0, #136] ; 0x88 <== NOT EXECUTED 3000c8ac: ea0005ba b 3000df9c <_Workspace_Free> <== NOT EXECUTED
3000c814 <_Scheduler_EDF_Release_job>:
uint32_t deadline
)
{
Priority_Control new_priority;
if (deadline) {
3000c814: e3510000 cmp r1, #0 <== NOT EXECUTED
/* Initializing or shifting deadline. */
new_priority = (_Watchdog_Ticks_since_boot + deadline)
3000c818: 159f3018 ldrne r3, [pc, #24] ; 3000c838 <_Scheduler_EDF_Release_job+0x24><== NOT EXECUTED
& ~SCHEDULER_EDF_PRIO_MSB;
}
else {
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
3000c81c: 059010ac ldreq r1, [r0, #172] ; 0xac <== NOT EXECUTED
{
Priority_Control new_priority;
if (deadline) {
/* Initializing or shifting deadline. */
new_priority = (_Watchdog_Ticks_since_boot + deadline)
3000c820: 15933000 ldrne r3, [r3] <== NOT EXECUTED
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
}
the_thread->real_priority = new_priority;
_Thread_Change_priority(the_thread, new_priority, true);
3000c824: e3a02001 mov r2, #1 <== NOT EXECUTED
{
Priority_Control new_priority;
if (deadline) {
/* Initializing or shifting deadline. */
new_priority = (_Watchdog_Ticks_since_boot + deadline)
3000c828: 10811003 addne r1, r1, r3 <== NOT EXECUTED 3000c82c: 13c11102 bicne r1, r1, #-2147483648 ; 0x80000000 <== NOT EXECUTED
else {
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
}
the_thread->real_priority = new_priority;
3000c830: e5801018 str r1, [r0, #24] <== NOT EXECUTED
_Thread_Change_priority(the_thread, new_priority, true);
3000c834: ea0000aa b 3000cae4 <_Thread_Change_priority> <== NOT EXECUTED
3000c944 <_Scheduler_EDF_Schedule>:
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
3000c944: e59f3010 ldr r3, [pc, #16] ; 3000c95c <_Scheduler_EDF_Schedule+0x18><== NOT EXECUTED
{
RBTree_Node *first = _RBTree_First(&_Scheduler_EDF_Ready_queue, RBT_LEFT);
Scheduler_EDF_Per_thread *sched_info =
_RBTree_Container_of(first, Scheduler_EDF_Per_thread, Node);
_Thread_Heir = (Thread_Control *) sched_info->thread;
3000c948: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 3000c94c: e5132004 ldr r2, [r3, #-4] <== NOT EXECUTED 3000c950: e59f3008 ldr r3, [pc, #8] ; 3000c960 <_Scheduler_EDF_Schedule+0x1c><== NOT EXECUTED 3000c954: e583200c str r2, [r3, #12] <== NOT EXECUTED
}
3000c958: e12fff1e bx lr <== NOT EXECUTED
3000c85c <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
3000c85c: e92d4030 push {r4, r5, lr}
* a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_lower_than(
3000c860: e59f5050 ldr r5, [pc, #80] ; 3000c8b8 <_Scheduler_EDF_Unblock+0x5c>
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
3000c864: e1a04000 mov r4, r0
_Scheduler_EDF_Enqueue(the_thread);
3000c868: ebffffb0 bl 3000c730 <_Scheduler_EDF_Enqueue>
* a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( _Scheduler_Is_priority_lower_than(
3000c86c: e595300c ldr r3, [r5, #12]
3000c870: e5941014 ldr r1, [r4, #20]
3000c874: e5930014 ldr r0, [r3, #20]
3000c878: e59f303c ldr r3, [pc, #60] ; 3000c8bc <_Scheduler_EDF_Unblock+0x60>
3000c87c: e1a0e00f mov lr, pc
3000c880: e593f030 ldr pc, [r3, #48] ; 0x30
3000c884: e3500000 cmp r0, #0
3000c888: a8bd8030 popge {r4, r5, pc}
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
3000c88c: e5953008 ldr r3, [r5, #8]
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( _Scheduler_Is_priority_lower_than(
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
3000c890: e585400c str r4, [r5, #12]
if ( _Thread_Executing->is_preemptible ||
3000c894: e5d33070 ldrb r3, [r3, #112] ; 0x70 3000c898: e3530000 cmp r3, #0
3000c89c: 1a000002 bne 3000c8ac <_Scheduler_EDF_Unblock+0x50>
3000c8a0: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
3000c8a4: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c8a8: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000c8ac: e3a03001 mov r3, #1
3000c8b0: e5c53004 strb r3, [r5, #4]
3000c8b4: e8bd8030 pop {r4, r5, pc}
3000c994 <_Scheduler_EDF_Yield>:
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
{
3000c994: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
3000c998: e59f5050 ldr r5, [pc, #80] ; 3000c9f0 <_Scheduler_EDF_Yield+0x5c><== NOT EXECUTED
Scheduler_EDF_Per_thread *executing_info =
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
3000c99c: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
RBTree_Node *executing_node = &(executing_info->Node);
3000c9a0: e5936088 ldr r6, [r3, #136] ; 0x88 <== NOT EXECUTED 3000c9a4: e2866004 add r6, r6, #4 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c9a8: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000c9ac: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000c9b0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/*
* The RBTree has more than one node, enqueue behind the tasks
* with the same priority in case there are such ones.
*/
_RBTree_Extract( &_Scheduler_EDF_Ready_queue, executing_node );
3000c9b4: e59f7038 ldr r7, [pc, #56] ; 3000c9f4 <_Scheduler_EDF_Yield+0x60><== NOT EXECUTED 3000c9b8: e1a01006 mov r1, r6 <== NOT EXECUTED 3000c9bc: e1a00007 mov r0, r7 <== NOT EXECUTED 3000c9c0: eb000e3f bl 300102c4 <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert( &_Scheduler_EDF_Ready_queue, executing_node );
3000c9c4: e1a00007 mov r0, r7 <== NOT EXECUTED 3000c9c8: e1a01006 mov r1, r6 <== NOT EXECUTED 3000c9cc: eb000ec1 bl 300104d8 <_RBTree_Insert> <== NOT EXECUTED
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c9d0: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000c9d4: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000c9d8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Flash( level );
_Scheduler_EDF_Schedule();
3000c9dc: ebffffd8 bl 3000c944 <_Scheduler_EDF_Schedule> <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000c9e0: e3a03001 mov r3, #1 <== NOT EXECUTED 3000c9e4: e5c53004 strb r3, [r5, #4] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c9e8: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Enable( level );
}
3000c9ec: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000c10c <_Scheduler_priority_Tick>:
void _Scheduler_priority_Tick( void )
{
Thread_Control *executing;
executing = _Thread_Executing;
3000c10c: e59f3088 ldr r3, [pc, #136] ; 3000c19c <_Scheduler_priority_Tick+0x90>
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
3000c110: e92d4010 push {r4, lr}
Thread_Control *executing;
executing = _Thread_Executing;
3000c114: e5934008 ldr r4, [r3, #8]
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
3000c118: e5d43070 ldrb r3, [r4, #112] ; 0x70
3000c11c: e3530000 cmp r3, #0
3000c120: 08bd8010 popeq {r4, pc}
return;
if ( !_States_Is_ready( executing->current_state ) )
3000c124: e5943010 ldr r3, [r4, #16]
3000c128: e3530000 cmp r3, #0
3000c12c: 18bd8010 popne {r4, pc}
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
3000c130: e5943078 ldr r3, [r4, #120] ; 0x78 3000c134: e3530001 cmp r3, #1
3000c138: 0a000002 beq 3000c148 <_Scheduler_priority_Tick+0x3c>
3000c13c: e3530002 cmp r3, #2
3000c140: 18bd8010 popne {r4, pc}
3000c144: ea00000b b 3000c178 <_Scheduler_priority_Tick+0x6c> <== NOT EXECUTED
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
#endif
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
3000c148: e5943074 ldr r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000c14c: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000c150: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c154: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000c158: c8bd8010 popgt {r4, pc} <== NOT EXECUTED
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
3000c15c: e59f303c ldr r3, [pc, #60] ; 3000c1a0 <_Scheduler_priority_Tick+0x94><== NOT EXECUTED 3000c160: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c164: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield();
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000c168: e59f3034 ldr r3, [pc, #52] ; 3000c1a4 <_Scheduler_priority_Tick+0x98><== NOT EXECUTED
3000c16c: e5933000 ldr r3, [r3] <== NOT EXECUTED
3000c170: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000c174: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
3000c178: e5943074 ldr r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000c17c: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000c180: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c184: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED
3000c188: 18bd8010 popne {r4, pc} <== NOT EXECUTED
(*executing->budget_callout)( executing );
3000c18c: e1a00004 mov r0, r4 <== NOT EXECUTED
3000c190: e1a0e00f mov lr, pc <== NOT EXECUTED
3000c194: e594f07c ldr pc, [r4, #124] ; 0x7c <== NOT EXECUTED
3000c198: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c728 <_Scheduler_simple_Block>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Block(
Thread_Control *the_thread
)
{
3000c728: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000c72c: e1a04000 mov r4, r0 <== NOT EXECUTED
_Scheduler_simple_Extract(the_thread);
3000c730: eb00000d bl 3000c76c <_Scheduler_simple_Extract> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
3000c734: e59f3024 ldr r3, [pc, #36] ; 3000c760 <_Scheduler_simple_Block+0x38><== NOT EXECUTED
if ( _Thread_Is_heir( the_thread ) )
3000c738: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 3000c73c: e1a05003 mov r5, r3 <== NOT EXECUTED 3000c740: e1540002 cmp r4, r2 <== NOT EXECUTED
_Scheduler_simple_Schedule();
3000c744: 0b000042 bleq 3000c854 <_Scheduler_simple_Schedule> <== NOT EXECUTED
if ( _Thread_Is_executing( the_thread ) )
3000c748: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 3000c74c: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000c750: 059f3008 ldreq r3, [pc, #8] ; 3000c760 <_Scheduler_simple_Block+0x38><== NOT EXECUTED
3000c754: 03a02001 moveq r2, #1 <== NOT EXECUTED
3000c758: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED
3000c75c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000c768 <_Scheduler_simple_Enqueue>:
void _Scheduler_simple_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler_simple_Ready_queue_enqueue( the_thread );
3000c768: ea000024 b 3000c800 <_Scheduler_simple_Ready_queue_enqueue><== NOT EXECUTED
3000c764 <_Scheduler_simple_Enqueue_first>:
void _Scheduler_simple_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler_simple_Ready_queue_enqueue_first( the_thread );
3000c764: ea000014 b 3000c7bc <_Scheduler_simple_Ready_queue_enqueue_first><== NOT EXECUTED
3000c76c <_Scheduler_simple_Extract>:
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3000c76c: e890000c ldm r0, {r2, r3} <== NOT EXECUTED
next->previous = previous;
3000c770: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000c774: e5832000 str r2, [r3] <== NOT EXECUTED
void _Scheduler_simple_Extract(
Thread_Control *the_thread
)
{
_Chain_Extract_unprotected( &the_thread->Object.Node );
}
3000c778: e12fff1e bx lr <== NOT EXECUTED
3000c788 <_Scheduler_simple_Free>:
void _Scheduler_simple_Free(
Thread_Control *the_thread
)
{
}
3000c788: e12fff1e bx lr <== NOT EXECUTED
3000c800 <_Scheduler_simple_Ready_queue_enqueue>:
{
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
3000c800: e59f3048 ldr r3, [pc, #72] ; 3000c850 <_Scheduler_simple_Ready_queue_enqueue+0x50> 3000c804: e5933000 ldr r3, [r3]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000c808: e5932000 ldr r2, [r3]
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
3000c80c: e2831004 add r1, r3, #4
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
3000c810: ea000006 b 3000c830 <_Scheduler_simple_Ready_queue_enqueue+0x30>
current = (Thread_Control *) the_node;
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
3000c814: e590c014 ldr ip, [r0, #20] 3000c818: e5923014 ldr r3, [r2, #20] 3000c81c: e15c0003 cmp ip, r3
current = (Thread_Control *)current->Object.Node.previous;
3000c820: 35923004 ldrcc r3, [r2, #4]
break;
3000c824: 3a000003 bcc 3000c838 <_Scheduler_simple_Ready_queue_enqueue+0x38>
ready = (Chain_Control *)_Scheduler.information;
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
3000c828: e1a03002 mov r3, r2 <== NOT EXECUTED 3000c82c: e5922000 ldr r2, [r2] <== NOT EXECUTED
3000c830: e1520001 cmp r2, r1
3000c834: 1afffff6 bne 3000c814 <_Scheduler_simple_Ready_queue_enqueue+0x14>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000c838: e5932000 ldr r2, [r3]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000c83c: e5803004 str r3, [r0, #4]
before_node = after_node->next; after_node->next = the_node;
3000c840: e5830000 str r0, [r3]
the_node->next = before_node; before_node->previous = the_node;
3000c844: e5820004 str r0, [r2, #4]
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
3000c848: e5802000 str r2, [r0]
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000c84c: e12fff1e bx lr
3000c7bc <_Scheduler_simple_Ready_queue_enqueue_first>:
{
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
3000c7bc: e59f3038 ldr r3, [pc, #56] ; 3000c7fc <_Scheduler_simple_Ready_queue_enqueue_first+0x40><== NOT EXECUTED
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
3000c7c0: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000c7c4: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000c7c8: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000c7cc: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED 3000c7d0: e1520001 cmp r2, r1 <== NOT EXECUTED 3000c7d4: 8a000006 bhi 3000c7f4 <_Scheduler_simple_Ready_queue_enqueue_first+0x38><== NOT EXECUTED
current = (Thread_Control *)current->Object.Node.previous;
3000c7d8: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000c7dc: e5932000 ldr r2, [r3] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000c7e0: e5803004 str r3, [r0, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000c7e4: e5830000 str r0, [r3] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000c7e8: e5820004 str r0, [r2, #4] <== NOT EXECUTED
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
3000c7ec: e5802000 str r2, [r0] <== NOT EXECUTED
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
3000c7f0: e12fff1e bx lr <== NOT EXECUTED
* Do NOT need to check for end of chain because there is always
* at least one task on the ready chain -- the IDLE task. It can
* never block, should never attempt to obtain a semaphore or mutex,
* and thus will always be there.
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
3000c7f4: e5933000 ldr r3, [r3] <== NOT EXECUTED
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
current = (Thread_Control *)current->Object.Node.previous;
break;
}
}
3000c7f8: eafffff3 b 3000c7cc <_Scheduler_simple_Ready_queue_enqueue_first+0x10><== NOT EXECUTED
3000c854 <_Scheduler_simple_Schedule>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Schedule(void)
{
_Thread_Heir = (Thread_Control *) _Chain_First(
(Chain_Control *) _Scheduler.information
3000c854: e59f3010 ldr r3, [pc, #16] ; 3000c86c <_Scheduler_simple_Schedule+0x18><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000c858: e5933000 ldr r3, [r3] <== NOT EXECUTED
#include <rtems/score/thread.h>
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Schedule(void)
{
_Thread_Heir = (Thread_Control *) _Chain_First(
3000c85c: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c860: e59f3008 ldr r3, [pc, #8] ; 3000c870 <_Scheduler_simple_Schedule+0x1c><== NOT EXECUTED 3000c864: e583200c str r2, [r3, #12] <== NOT EXECUTED
(Chain_Control *) _Scheduler.information
);
}
3000c868: e12fff1e bx lr <== NOT EXECUTED
3000c874 <_Scheduler_simple_Unblock>:
#include <rtems/score/thread.h>
void _Scheduler_simple_Unblock(
Thread_Control *the_thread
)
{
3000c874: e92d4010 push {r4, lr}
3000c878: e1a04000 mov r4, r0
_Scheduler_simple_Ready_queue_enqueue(the_thread);
3000c87c: ebffffdf bl 3000c800 <_Scheduler_simple_Ready_queue_enqueue>
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
3000c880: e59f3038 ldr r3, [pc, #56] ; 3000c8c0 <_Scheduler_simple_Unblock+0x4c>
3000c884: e5942014 ldr r2, [r4, #20]
3000c888: e593100c ldr r1, [r3, #12]
3000c88c: e5911014 ldr r1, [r1, #20]
3000c890: e1520001 cmp r2, r1
3000c894: 28bd8010 popcs {r4, pc}
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
3000c898: e5931008 ldr r1, [r3, #8]
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
_Thread_Heir = the_thread;
3000c89c: e583400c str r4, [r3, #12]
if ( _Thread_Executing->is_preemptible ||
3000c8a0: e5d11070 ldrb r1, [r1, #112] ; 0x70 3000c8a4: e3510000 cmp r1, #0
3000c8a8: 1a000001 bne 3000c8b4 <_Scheduler_simple_Unblock+0x40>
3000c8ac: e3520000 cmp r2, #0 <== NOT EXECUTED
3000c8b0: 18bd8010 popne {r4, pc} <== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
3000c8b4: e3a02001 mov r2, #1
3000c8b8: e5c32004 strb r2, [r3, #4]
3000c8bc: e8bd8010 pop {r4, pc}
3000c8c4 <_Scheduler_simple_Yield>:
#include <rtems/score/scheduler.h>
#include <rtems/score/thread.h>
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Yield( void )
{
3000c8c4: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing;
executing = _Thread_Executing;
3000c8c8: e59f5048 ldr r5, [pc, #72] ; 3000c918 <_Scheduler_simple_Yield+0x54><== NOT EXECUTED 3000c8cc: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c8d0: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000c8d4: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000c8d8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3000c8dc: e894000c ldm r4, {r2, r3} <== NOT EXECUTED
{
/* extract */
_Chain_Extract_unprotected( &the_thread->Object.Node );
/* enqueue */
_Scheduler_simple_Ready_queue_enqueue( the_thread );
3000c8e0: e1a00004 mov r0, r4 <== NOT EXECUTED
next->previous = previous;
3000c8e4: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000c8e8: e5832000 str r2, [r3] <== NOT EXECUTED 3000c8ec: ebffffc3 bl 3000c800 <_Scheduler_simple_Ready_queue_enqueue><== NOT EXECUTED
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c8f0: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000c8f4: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000c8f8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_Scheduler_simple_Ready_queue_requeue(&_Scheduler, executing);
_ISR_Flash( level );
_Scheduler_simple_Schedule();
3000c8fc: ebffffd4 bl 3000c854 <_Scheduler_simple_Schedule> <== NOT EXECUTED
if ( !_Thread_Is_heir( executing ) )
3000c900: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3000c904: e1540003 cmp r4, r3 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
3000c908: 13a03001 movne r3, #1 <== NOT EXECUTED 3000c90c: 15c53004 strbne r3, [r5, #4] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c910: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level );
}
3000c914: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30026494 <_TOD_Get_uptime_as_timespec>:
#include <rtems/score/tod.h>
void _TOD_Get_uptime_as_timespec(
struct timespec *uptime
)
{
30026494: e92d40d3 push {r0, r1, r4, r6, r7, lr} <== NOT EXECUTED
30026498: e1a04000 mov r4, r0 <== NOT EXECUTED
3002649c: e59f103c ldr r1, [pc, #60] ; 300264e0 <_TOD_Get_uptime_as_timespec+0x4c><== NOT EXECUTED
300264a0: e1a0000d mov r0, sp <== NOT EXECUTED
300264a4: ebff94e9 bl 3000b850 <_TOD_Get_with_nanoseconds> <== NOT EXECUTED
Timestamp_Control uptime_ts;
/* assume time checked for NULL by caller */
_TOD_Get_uptime( &uptime_ts );
_Timestamp_To_timespec( &uptime_ts, uptime );
300264a8: e89d00c0 ldm sp, {r6, r7} <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
300264ac: e59f2030 ldr r2, [pc, #48] ; 300264e4 <_TOD_Get_uptime_as_timespec+0x50><== NOT EXECUTED 300264b0: e3a03000 mov r3, #0 <== NOT EXECUTED 300264b4: e1a00006 mov r0, r6 <== NOT EXECUTED 300264b8: e1a01007 mov r1, r7 <== NOT EXECUTED 300264bc: eb00a1fa bl 3004ecac <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
300264c0: e1a01007 mov r1, r7 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
300264c4: e5840000 str r0, [r4] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
300264c8: e59f2014 ldr r2, [pc, #20] ; 300264e4 <_TOD_Get_uptime_as_timespec+0x50><== NOT EXECUTED 300264cc: e1a00006 mov r0, r6 <== NOT EXECUTED 300264d0: e3a03000 mov r3, #0 <== NOT EXECUTED 300264d4: eb00a32f bl 3004f198 <__moddi3> <== NOT EXECUTED 300264d8: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
300264dc: e8bd80dc pop {r2, r3, r4, r6, r7, pc} <== NOT EXECUTED
3000b078 <_TOD_Tickle_ticks>:
void _TOD_Tickle_ticks( void )
{
Timestamp_Control tick;
uint32_t nanoseconds_per_tick;
nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick();
3000b078: e59f3074 ldr r3, [pc, #116] ; 3000b0f4 <_TOD_Tickle_ticks+0x7c>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
#include <rtems/config.h>
void _TOD_Tickle_ticks( void )
{
3000b07c: e92d4030 push {r4, r5, lr}
Timestamp_Control tick;
uint32_t nanoseconds_per_tick;
nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick();
3000b080: e5932010 ldr r2, [r3, #16]
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, nanoseconds_per_tick );
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000b084: e59f306c ldr r3, [pc, #108] ; 3000b0f8 <_TOD_Tickle_ticks+0x80>
uint32_t nanoseconds_per_tick;
nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick();
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, nanoseconds_per_tick );
3000b088: e3a01000 mov r1, #0
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000b08c: e593c000 ldr ip, [r3] 3000b090: e28cc001 add ip, ip, #1 3000b094: e583c000 str ip, [r3]
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
3000b098: e59f305c ldr r3, [pc, #92] ; 3000b0fc <_TOD_Tickle_ticks+0x84>
3000b09c: e2835008 add r5, r3, #8
3000b0a0: e8950030 ldm r5, {r4, r5}
3000b0a4: e0944002 adds r4, r4, r2
3000b0a8: e0a55001 adc r5, r5, r1
3000b0ac: e5834008 str r4, [r3, #8]
3000b0b0: e583500c str r5, [r3, #12]
3000b0b4: e8930030 ldm r3, {r4, r5}
3000b0b8: e0944002 adds r4, r4, r2
3000b0bc: e0a55001 adc r5, r5, r1
/* we do not care how much the uptime changed */
/* Update the current TOD */
_Timestamp_Add_to( &_TOD.now, &tick );
_TOD.seconds_trigger += nanoseconds_per_tick;
3000b0c0: e5931010 ldr r1, [r3, #16]
3000b0c4: e8830030 stm r3, {r4, r5}
3000b0c8: e0821001 add r1, r2, r1
if ( _TOD.seconds_trigger >= 1000000000UL ) {
3000b0cc: e59f202c ldr r2, [pc, #44] ; 3000b100 <_TOD_Tickle_ticks+0x88>
/* we do not care how much the uptime changed */
/* Update the current TOD */
_Timestamp_Add_to( &_TOD.now, &tick );
_TOD.seconds_trigger += nanoseconds_per_tick;
3000b0d0: e5831010 str r1, [r3, #16]
if ( _TOD.seconds_trigger >= 1000000000UL ) {
3000b0d4: e1510002 cmp r1, r2
3000b0d8: 98bd8030 popls {r4, r5, pc}
_TOD.seconds_trigger -= 1000000000UL;
3000b0dc: e59f2020 ldr r2, [pc, #32] ; 3000b104 <_TOD_Tickle_ticks+0x8c><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
3000b0e0: e59f0020 ldr r0, [pc, #32] ; 3000b108 <_TOD_Tickle_ticks+0x90><== NOT EXECUTED 3000b0e4: e0812002 add r2, r1, r2 <== NOT EXECUTED 3000b0e8: e5832010 str r2, [r3, #16] <== NOT EXECUTED
_Watchdog_Tickle_seconds();
}
}
3000b0ec: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
3000b0f0: ea00091e b 3000d570 <_Watchdog_Tickle> <== NOT EXECUTED
3000adac <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
3000adac: e92d4010 push {r4, lr}
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
3000adb0: e2504000 subs r4, r0, #0
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
3000adb4: 01a00004 moveq r0, r4
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
3000adb8: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
3000adbc: e59f309c ldr r3, [pc, #156] ; 3000ae60 <_TOD_Validate+0xb4> 3000adc0: e59f009c ldr r0, [pc, #156] ; 3000ae64 <_TOD_Validate+0xb8> 3000adc4: e593100c ldr r1, [r3, #12] 3000adc8: eb004330 bl 3001ba90 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
3000adcc: e5943018 ldr r3, [r4, #24] 3000add0: e1530000 cmp r3, r0
3000add4: 2a00001d bcs 3000ae50 <_TOD_Validate+0xa4>
(the_tod->ticks >= ticks_per_second) ||
3000add8: e5943014 ldr r3, [r4, #20] 3000addc: e353003b cmp r3, #59 ; 0x3b
3000ade0: 8a00001a bhi 3000ae50 <_TOD_Validate+0xa4>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
3000ade4: e5943010 ldr r3, [r4, #16] 3000ade8: e353003b cmp r3, #59 ; 0x3b
3000adec: 8a000017 bhi 3000ae50 <_TOD_Validate+0xa4>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
3000adf0: e594300c ldr r3, [r4, #12] 3000adf4: e3530017 cmp r3, #23
3000adf8: 8a000014 bhi 3000ae50 <_TOD_Validate+0xa4>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
3000adfc: e5943004 ldr r3, [r4, #4]
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
3000ae00: e3530000 cmp r3, #0
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
3000ae04: 01a00003 moveq r0, r3
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
3000ae08: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
3000ae0c: e353000c cmp r3, #12
3000ae10: 8a00000e bhi 3000ae50 <_TOD_Validate+0xa4>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
3000ae14: e5942000 ldr r2, [r4]
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
3000ae18: e59f1048 ldr r1, [pc, #72] ; 3000ae68 <_TOD_Validate+0xbc> 3000ae1c: e1520001 cmp r2, r1
3000ae20: 9a00000c bls 3000ae58 <_TOD_Validate+0xac>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
3000ae24: e5940008 ldr r0, [r4, #8]
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
3000ae28: e3500000 cmp r0, #0
3000ae2c: 08bd8010 popeq {r4, pc}
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
3000ae30: e3120003 tst r2, #3 3000ae34: e59f2030 ldr r2, [pc, #48] ; 3000ae6c <_TOD_Validate+0xc0>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
3000ae38: 0283300d addeq r3, r3, #13
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
3000ae3c: e7924103 ldr r4, [r2, r3, lsl #2]
const uint32_t _TOD_Days_per_month[ 2 ][ 13 ] = {
{ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
{ 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
};
bool _TOD_Validate(
3000ae40: e1500004 cmp r0, r4
3000ae44: 83a00000 movhi r0, #0
3000ae48: 93a00001 movls r0, #1
3000ae4c: e8bd8010 pop {r4, pc}
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
3000ae50: e3a00000 mov r0, #0 <== NOT EXECUTED
3000ae54: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ae58: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
3000ae5c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c398 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
3000c398: e92d40f0 push {r4, r5, r6, r7, lr}
3000c39c: e1a04000 mov r4, r0
3000c3a0: e1a05001 mov r5, r1
3000c3a4: e20260ff and r6, r2, #255 ; 0xff
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
3000c3a8: e5907010 ldr r7, [r0, #16]
/* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread );
3000c3ac: eb000327 bl 3000d050 <_Thread_Set_transient>
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
3000c3b0: e5943014 ldr r3, [r4, #20] 3000c3b4: e1530005 cmp r3, r5
_Thread_Set_priority( the_thread, new_priority );
3000c3b8: 11a00004 movne r0, r4 3000c3bc: 11a01005 movne r1, r5 3000c3c0: 1b00030c blne 3000cff8 <_Thread_Set_priority>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c3c4: e10f5000 mrs r5, CPSR 3000c3c8: e3853080 orr r3, r5, #128 ; 0x80 3000c3cc: e129f003 msr CPSR_fc, r3
/*
* If the thread has more than STATES_TRANSIENT set, then it is blocked,
* If it is blocked on a thread queue, then we need to requeue it.
*/
state = the_thread->current_state;
3000c3d0: e5942010 ldr r2, [r4, #16] 3000c3d4: e2077004 and r7, r7, #4
if ( state != STATES_TRANSIENT ) {
3000c3d8: e3520004 cmp r2, #4
3000c3dc: 0a00000b beq 3000c410 <_Thread_Change_priority+0x78>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
3000c3e0: e3570000 cmp r7, #0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
3000c3e4: 03c23004 biceq r3, r2, #4 <== NOT EXECUTED
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
3000c3e8: 05843010 streq r3, [r4, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c3ec: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
3000c3f0: e59f308c ldr r3, [pc, #140] ; 3000c484 <_Thread_Change_priority+0xec><== NOT EXECUTED 3000c3f4: e0023003 and r3, r2, r3 <== NOT EXECUTED
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
3000c3f8: e3530000 cmp r3, #0 <== NOT EXECUTED
3000c3fc: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
3000c400: e5940044 ldr r0, [r4, #68] ; 0x44 <== NOT EXECUTED 3000c404: e1a01004 mov r1, r4 <== NOT EXECUTED
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
3000c408: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
3000c40c: ea0002d4 b 3000cf64 <_Thread_queue_Requeue> <== NOT EXECUTED
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
3000c410: e3570000 cmp r7, #0
3000c414: 1a000009 bne 3000c440 <_Thread_Change_priority+0xa8>
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
if ( prepend_it )
3000c418: e3560000 cmp r6, #0
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
3000c41c: e5847010 str r7, [r4, #16]
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
3000c420: e1a00004 mov r0, r4 3000c424: e59f305c ldr r3, [pc, #92] ; 3000c488 <_Thread_Change_priority+0xf0>
if ( prepend_it )
3000c428: 0a000002 beq 3000c438 <_Thread_Change_priority+0xa0>
3000c42c: e1a0e00f mov lr, pc 3000c430: e593f028 ldr pc, [r3, #40] ; 0x28 3000c434: ea000001 b 3000c440 <_Thread_Change_priority+0xa8>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
3000c438: e1a0e00f mov lr, pc 3000c43c: e593f024 ldr pc, [r3, #36] ; 0x24
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000c440: e10f3000 mrs r3, CPSR 3000c444: e129f005 msr CPSR_fc, r5 3000c448: e129f003 msr CPSR_fc, r3
* This kernel routine implements the scheduling decision logic for
* the scheduler. It does NOT dispatch.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )
{
_Scheduler.Operations.schedule();
3000c44c: e59f3034 ldr r3, [pc, #52] ; 3000c488 <_Thread_Change_priority+0xf0> 3000c450: e1a0e00f mov lr, pc 3000c454: e593f008 ldr pc, [r3, #8]
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
3000c458: e59f302c ldr r3, [pc, #44] ; 3000c48c <_Thread_Change_priority+0xf4> 3000c45c: e5932008 ldr r2, [r3, #8]
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule();
if ( !_Thread_Is_executing_also_the_heir() &&
3000c460: e593100c ldr r1, [r3, #12] 3000c464: e1520001 cmp r2, r1
3000c468: 0a000003 beq 3000c47c <_Thread_Change_priority+0xe4>
3000c46c: e5d22070 ldrb r2, [r2, #112] ; 0x70 3000c470: e3520000 cmp r2, #0
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
3000c474: 13a02001 movne r2, #1 3000c478: 15c32004 strbne r2, [r3, #4]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c47c: e129f005 msr CPSR_fc, r5
3000c480: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000c660 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000c660: e92d4001 push {r0, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000c664: e1a0100d mov r1, sp <== NOT EXECUTED 3000c668: eb00006b bl 3000c81c <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000c66c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000c670: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c674: 1a000005 bne 3000c690 <_Thread_Delay_ended+0x30> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
3000c678: e59f1014 ldr r1, [pc, #20] ; 3000c694 <_Thread_Delay_ended+0x34><== NOT EXECUTED 3000c67c: ebffff83 bl 3000c490 <_Thread_Clear_state> <== NOT EXECUTED
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000c680: e59f3010 ldr r3, [pc, #16] ; 3000c698 <_Thread_Delay_ended+0x38><== NOT EXECUTED 3000c684: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3000c688: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000c68c: e5832000 str r2, [r3] <== NOT EXECUTED
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
3000c690: e8bd8008 pop {r3, pc} <== NOT EXECUTED
3000c81c <_Thread_Get>:
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
3000c81c: e1a02001 mov r2, r1
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
3000c820: e2501000 subs r1, r0, #0
3000c824: 1a000007 bne 3000c848 <_Thread_Get+0x2c>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000c828: e59f3074 ldr r3, [pc, #116] ; 3000c8a4 <_Thread_Get+0x88> 3000c82c: e5930000 ldr r0, [r3]
++level;
3000c830: e2800001 add r0, r0, #1
_Thread_Dispatch_disable_level = level;
3000c834: e5830000 str r0, [r3]
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
tp = _Thread_Executing;
3000c838: e59f3068 ldr r3, [pc, #104] ; 3000c8a8 <_Thread_Get+0x8c>
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
3000c83c: e5821000 str r1, [r2]
tp = _Thread_Executing;
3000c840: e5930008 ldr r0, [r3, #8]
goto done;
3000c844: e12fff1e bx lr
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
3000c848: e1a00c21 lsr r0, r1, #24 3000c84c: e2000007 and r0, r0, #7
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
3000c850: e2403001 sub r3, r0, #1 3000c854: e3530002 cmp r3, #2
3000c858: 9a00000d bls 3000c894 <_Thread_Get+0x78>
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
3000c85c: e3a03001 mov r3, #1 3000c860: e5823000 str r3, [r2]
{
uint32_t the_api;
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
3000c864: e3a00000 mov r0, #0
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
goto done;
3000c868: e12fff1e bx lr
}
api_information = _Objects_Information_table[ the_api ];
3000c86c: e59fc038 ldr ip, [pc, #56] ; 3000c8ac <_Thread_Get+0x90> 3000c870: e79c0100 ldr r0, [ip, r0, lsl #2]
* There is no way for this to happen if POSIX is enabled. But there
* is actually a test case in sp43 for this which trips it whether or
* not POSIX is enabled. So in the interest of safety, this is left
* on in all configurations.
*/
if ( !api_information ) {
3000c874: e3500000 cmp r0, #0
3000c878: 0a000002 beq 3000c888 <_Thread_Get+0x6c>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
3000c87c: e5900004 ldr r0, [r0, #4]
if ( !information ) {
3000c880: e3500000 cmp r0, #0
3000c884: 1a000001 bne 3000c890 <_Thread_Get+0x74>
*location = OBJECTS_ERROR;
3000c888: e5823000 str r3, [r2] <== NOT EXECUTED
goto done;
3000c88c: e12fff1e bx lr <== NOT EXECUTED
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
3000c890: eafffc56 b 3000b9f0 <_Objects_Get>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000c894: e1a03da1 lsr r3, r1, #27
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
3000c898: e3530001 cmp r3, #1
3000c89c: 0afffff2 beq 3000c86c <_Thread_Get+0x50>
3000c8a0: eaffffed b 3000c85c <_Thread_Get+0x40> <== NOT EXECUTED
3000d120 <_Thread_Start>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
3000d120: e590c010 ldr ip, [r0, #16]
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000d124: e92d4010 push {r4, lr}
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000d128: e21cc001 ands ip, ip, #1
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000d12c: e1a04000 mov r4, r0
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000d130: 0a00000c beq 3000d168 <_Thread_Start+0x48>
the_thread->Start.entry_point = (Thread_Entry) entry_point;
the_thread->Start.prototype = the_prototype;
the_thread->Start.pointer_argument = pointer_argument;
3000d134: e5803094 str r3, [r0, #148] ; 0x94
the_thread->Start.numeric_argument = numeric_argument;
3000d138: e59d3008 ldr r3, [sp, #8]
Thread_Entry_numeric_type numeric_argument
)
{
if ( _States_Is_dormant( the_thread->current_state ) ) {
the_thread->Start.entry_point = (Thread_Entry) entry_point;
3000d13c: e580208c str r2, [r0, #140] ; 0x8c
the_thread->Start.prototype = the_prototype;
3000d140: e5801090 str r1, [r0, #144] ; 0x90
the_thread->Start.pointer_argument = pointer_argument;
the_thread->Start.numeric_argument = numeric_argument;
3000d144: e5803098 str r3, [r0, #152] ; 0x98
_Thread_Load_environment( the_thread );
3000d148: eb000952 bl 3000f698 <_Thread_Load_environment>
_Thread_Ready( the_thread );
3000d14c: e1a00004 mov r0, r4 3000d150: eb0009e6 bl 3000f8f0 <_Thread_Ready>
);
}
static inline void _User_extensions_Thread_start( Thread_Control *started )
{
_User_extensions_Iterate(
3000d154: e1a00004 mov r0, r4 3000d158: e59f1010 ldr r1, [pc, #16] ; 3000d170 <_Thread_Start+0x50> 3000d15c: eb000041 bl 3000d268 <_User_extensions_Iterate>
_User_extensions_Thread_start( the_thread );
return true;
3000d160: e3a00001 mov r0, #1
3000d164: e8bd8010 pop {r4, pc}
}
return false;
3000d168: e1a0000c mov r0, ip <== NOT EXECUTED
}
3000d16c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c34c <_Thread_blocking_operation_Cancel>:
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
3000c34c: e3a03000 mov r3, #0 <== NOT EXECUTED
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000c350: e92d4010 push {r4, lr} <== NOT EXECUTED
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
3000c354: e5813044 str r3, [r1, #68] ; 0x44 <== NOT EXECUTED
/*
* If the sync state is timed out, this is very likely not needed.
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
3000c358: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000c35c: e1a04001 mov r4, r1 <== NOT EXECUTED
/*
* If the sync state is timed out, this is very likely not needed.
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
3000c360: e3530002 cmp r3, #2 <== NOT EXECUTED 3000c364: 1a000005 bne 3000c380 <_Thread_blocking_operation_Cancel+0x34><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000c368: e3a03003 mov r3, #3 <== NOT EXECUTED 3000c36c: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 3000c370: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000c374: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 3000c378: eb000453 bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED 3000c37c: ea000000 b 3000c384 <_Thread_blocking_operation_Cancel+0x38><== NOT EXECUTED 3000c380: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000c384: e59f1008 ldr r1, [pc, #8] ; 3000c394 <_Thread_blocking_operation_Cancel+0x48><== NOT EXECUTED 3000c388: e1a00004 mov r0, r4 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000c38c: e8bd4010 pop {r4, lr} <== NOT EXECUTED
3000c390: ea00003e b 3000c490 <_Thread_Clear_state> <== NOT EXECUTED
3000f6e4 <_Thread_queue_Dequeue_fifo>:
#include <rtems/score/tqdata.h>
Thread_Control *_Thread_queue_Dequeue_fifo(
Thread_queue_Control *the_thread_queue
)
{
3000f6e4: e92d4010 push {r4, lr}
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000f6e8: e10f3000 mrs r3, CPSR 3000f6ec: e3832080 orr r2, r3, #128 ; 0x80 3000f6f0: e129f002 msr CPSR_fc, r2
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000f6f4: e1a02000 mov r2, r0 3000f6f8: e4924004 ldr r4, [r2], #4
ISR_Level level;
Thread_Control *the_thread;
_ISR_Disable( level );
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
3000f6fc: e1540002 cmp r4, r2
3000f700: 0a000012 beq 3000f750 <_Thread_queue_Dequeue_fifo+0x6c>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
3000f704: e5942000 ldr r2, [r4]
head->next = new_first;
3000f708: e5802000 str r2, [r0]
new_first->previous = head;
3000f70c: e5820004 str r0, [r2, #4]
the_thread = (Thread_Control *)
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
3000f710: e3a02000 mov r2, #0 3000f714: e5842044 str r2, [r4, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000f718: e5942050 ldr r2, [r4, #80] ; 0x50 3000f71c: e3520002 cmp r2, #2
3000f720: 0a000001 beq 3000f72c <_Thread_queue_Dequeue_fifo+0x48>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f724: e129f003 msr CPSR_fc, r3 3000f728: ea000004 b 3000f740 <_Thread_queue_Dequeue_fifo+0x5c>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000f72c: e3a02003 mov r2, #3 <== NOT EXECUTED 3000f730: e5842050 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED 3000f734: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000f738: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000f73c: ebfff762 bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000f740: e1a00004 mov r0, r4 3000f744: e59f1014 ldr r1, [pc, #20] ; 3000f760 <_Thread_queue_Dequeue_fifo+0x7c> 3000f748: ebfff350 bl 3000c490 <_Thread_Clear_state> 3000f74c: ea000001 b 3000f758 <_Thread_queue_Dequeue_fifo+0x74> 3000f750: e129f003 msr CPSR_fc, r3
return the_thread;
}
_ISR_Enable( level );
return NULL;
3000f754: e3a04000 mov r4, #0
}
3000f758: e1a00004 mov r0, r4
3000f75c: e8bd8010 pop {r4, pc}
3000cb84 <_Thread_queue_Dequeue_priority>:
#include <rtems/score/tqdata.h>
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
3000cb84: e92d4030 push {r4, r5, lr}
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000cb88: e10f2000 mrs r2, CPSR 3000cb8c: e3823080 orr r3, r2, #128 ; 0x80 3000cb90: e129f003 msr CPSR_fc, r3
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000cb94: e3a03000 mov r3, #0
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
3000cb98: e3a0c00c mov ip, #12 3000cb9c: e001039c mul r1, ip, r3
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000cba0: e7904001 ldr r4, [r0, r1] 3000cba4: e0805001 add r5, r0, r1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000cba8: e2851004 add r1, r5, #4 3000cbac: e1540001 cmp r4, r1
3000cbb0: 0a000008 beq 3000cbd8 <_Thread_queue_Dequeue_priority+0x54>
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
3000cbb4: e3a03000 mov r3, #0 3000cbb8: e5843044 str r3, [r4, #68] ; 0x44
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000cbbc: e5943038 ldr r3, [r4, #56] ; 0x38
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000cbc0: e284c03c add ip, r4, #60 ; 0x3c
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
next_node = the_thread->Object.Node.next;
previous_node = the_thread->Object.Node.previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000cbc4: e153000c cmp r3, ip
dequeue:
the_thread->Wait.queue = NULL;
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
next_node = the_thread->Object.Node.next;
3000cbc8: e5941000 ldr r1, [r4]
previous_node = the_thread->Object.Node.previous;
3000cbcc: e5940004 ldr r0, [r4, #4]
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000cbd0: 1a000006 bne 3000cbf0 <_Thread_queue_Dequeue_priority+0x6c>
3000cbd4: ea000016 b 3000cc34 <_Thread_queue_Dequeue_priority+0xb0>
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000cbd8: e2833001 add r3, r3, #1
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000cbdc: e3530004 cmp r3, #4
3000cbe0: 1affffed bne 3000cb9c <_Thread_queue_Dequeue_priority+0x18>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000cbe4: e129f002 msr CPSR_fc, r2
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
return NULL;
3000cbe8: e3a04000 mov r4, #0 3000cbec: ea00001f b 3000cc70 <_Thread_queue_Dequeue_priority+0xec>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
3000cbf0: e594c040 ldr ip, [r4, #64] ; 0x40 <== NOT EXECUTED
next_node = the_thread->Object.Node.next;
previous_node = the_thread->Object.Node.previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
3000cbf4: e593e000 ldr lr, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3000cbf8: e5813004 str r3, [r1, #4] <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
previous_node->next = new_first_node;
3000cbfc: e5803000 str r3, [r0] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
3000cc00: e5830004 str r0, [r3, #4] <== NOT EXECUTED
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
previous_node->next = new_first_node;
next_node->previous = new_first_node;
new_first_node->next = next_node;
3000cc04: e5831000 str r1, [r3] <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
3000cc08: e5940038 ldr r0, [r4, #56] ; 0x38 <== NOT EXECUTED 3000cc0c: e5941040 ldr r1, [r4, #64] ; 0x40 <== NOT EXECUTED 3000cc10: e1500001 cmp r0, r1 <== NOT EXECUTED 3000cc14: 0a000008 beq 3000cc3c <_Thread_queue_Dequeue_priority+0xb8><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
3000cc18: e2831038 add r1, r3, #56 ; 0x38 <== NOT EXECUTED
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
head->next = new_second_node;
3000cc1c: e583e038 str lr, [r3, #56] ; 0x38 <== NOT EXECUTED
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
3000cc20: e58e1004 str r1, [lr, #4] <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
3000cc24: e583c040 str ip, [r3, #64] ; 0x40 <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
3000cc28: e283303c add r3, r3, #60 ; 0x3c <== NOT EXECUTED
new_second_node->previous = head;
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
3000cc2c: e58c3000 str r3, [ip] <== NOT EXECUTED 3000cc30: ea000001 b 3000cc3c <_Thread_queue_Dequeue_priority+0xb8> <== NOT EXECUTED
}
} else {
previous_node->next = next_node;
3000cc34: e5801000 str r1, [r0]
next_node->previous = previous_node;
3000cc38: e5810004 str r0, [r1, #4]
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000cc3c: e5943050 ldr r3, [r4, #80] ; 0x50 3000cc40: e3530002 cmp r3, #2
3000cc44: 0a000001 beq 3000cc50 <_Thread_queue_Dequeue_priority+0xcc>
3000cc48: e129f002 msr CPSR_fc, r2 3000cc4c: ea000004 b 3000cc64 <_Thread_queue_Dequeue_priority+0xe0>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000cc50: e3a03003 mov r3, #3 <== NOT EXECUTED 3000cc54: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000cc58: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000cc5c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000cc60: eb000219 bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000cc64: e1a00004 mov r0, r4 3000cc68: e59f1008 ldr r1, [pc, #8] ; 3000cc78 <_Thread_queue_Dequeue_priority+0xf4> 3000cc6c: ebfffe07 bl 3000c490 <_Thread_Clear_state>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
3000cc70: e1a00004 mov r0, r4
3000cc74: e8bd8030 pop {r4, r5, pc}
3000f764 <_Thread_queue_Enqueue_fifo>:
Thread_blocking_operation_States _Thread_queue_Enqueue_fifo (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
3000f764: e92d4010 push {r4, lr}
3000f768: e1a03000 mov r3, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000f76c: e10fc000 mrs ip, CPSR 3000f770: e38c0080 orr r0, ip, #128 ; 0x80 3000f774: e129f000 msr CPSR_fc, r0
Thread_blocking_operation_States sync_state;
ISR_Level level;
_ISR_Disable( level );
sync_state = the_thread_queue->sync_state;
3000f778: e5930030 ldr r0, [r3, #48] ; 0x30
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000f77c: e3a04000 mov r4, #0
if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
3000f780: e3500001 cmp r0, #1
ISR_Level level;
_ISR_Disable( level );
sync_state = the_thread_queue->sync_state;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000f784: e5834030 str r4, [r3, #48] ; 0x30
if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
3000f788: 1a000008 bne 3000f7b0 <_Thread_queue_Enqueue_fifo+0x4c>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3000f78c: e5932008 ldr r2, [r3, #8]
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
3000f790: e2834004 add r4, r3, #4
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
3000f794: e5831008 str r1, [r3, #8]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3000f798: e5814000 str r4, [r1]
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
3000f79c: e5812004 str r2, [r1, #4]
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
old_last->next = the_node;
3000f7a0: e5821000 str r1, [r2]
_Chain_Append_unprotected(
&the_thread_queue->Queues.Fifo,
&the_thread->Object.Node
);
the_thread->Wait.queue = the_thread_queue;
3000f7a4: e5813044 str r3, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f7a8: e129f00c msr CPSR_fc, ip
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000f7ac: e8bd8010 pop {r4, pc}
* For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level;
3000f7b0: e582c000 str ip, [r2] <== NOT EXECUTED
return sync_state; }
3000f7b4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000cd1c <_Thread_queue_Enqueue_priority>:
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3000cd1c: e281c03c add ip, r1, #60 ; 0x3c
head->next = tail;
3000cd20: e581c038 str ip, [r1, #56] ; 0x38
head->previous = NULL;
3000cd24: e3a0c000 mov ip, #0 3000cd28: e581c03c str ip, [r1, #60] ; 0x3c
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
3000cd2c: e591c014 ldr ip, [r1, #20]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3000cd30: e2813038 add r3, r1, #56 ; 0x38
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
3000cd34: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
head->next = tail;
head->previous = NULL;
tail->previous = head;
3000cd38: e5813040 str r3, [r1, #64] ; 0x40
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
3000cd3c: e3a0500c mov r5, #12
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
3000cd40: e1a0332c lsr r3, ip, #6
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
3000cd44: e31c0020 tst ip, #32
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
3000cd48: e0250593 mla r5, r3, r5, r0
block_state = the_thread_queue->state;
3000cd4c: e5908038 ldr r8, [r0, #56] ; 0x38
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
3000cd50: 159fa150 ldrne sl, [pc, #336] ; 3000cea8 <_Thread_queue_Enqueue_priority+0x18c>
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
3000cd54: 1a000022 bne 3000cde4 <_Thread_queue_Enqueue_priority+0xc8>
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
3000cd58: e285a004 add sl, r5, #4
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000cd5c: e10f4000 mrs r4, CPSR 3000cd60: e3843080 orr r3, r4, #128 ; 0x80 3000cd64: e129f003 msr CPSR_fc, r3 3000cd68: e1a06004 mov r6, r4
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
3000cd6c: e3e07000 mvn r7, #0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000cd70: e5953000 ldr r3, [r5]
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
3000cd74: ea00000b b 3000cda8 <_Thread_queue_Enqueue_priority+0x8c>
search_priority = search_thread->current_priority;
3000cd78: e5937014 ldr r7, [r3, #20]
if ( priority <= search_priority )
3000cd7c: e15c0007 cmp ip, r7
3000cd80: 9a00000a bls 3000cdb0 <_Thread_queue_Enqueue_priority+0x94>
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000cd84: e10f9000 mrs r9, CPSR 3000cd88: e129f004 msr CPSR_fc, r4 3000cd8c: e129f009 msr CPSR_fc, r9
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
3000cd90: e5939010 ldr r9, [r3, #16]
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
3000cd94: e1180009 tst r8, r9
3000cd98: 1a000001 bne 3000cda4 <_Thread_queue_Enqueue_priority+0x88>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000cd9c: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000cda0: eaffffed b 3000cd5c <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
3000cda4: e5933000 ldr r3, [r3]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
3000cda8: e153000a cmp r3, sl
3000cdac: 1afffff1 bne 3000cd78 <_Thread_queue_Enqueue_priority+0x5c>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
3000cdb0: e5905030 ldr r5, [r0, #48] ; 0x30 3000cdb4: e3550001 cmp r5, #1
3000cdb8: 1a000037 bne 3000ce9c <_Thread_queue_Enqueue_priority+0x180>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000cdbc: e3a02000 mov r2, #0
if ( priority == search_priority )
3000cdc0: e15c0007 cmp ip, r7
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000cdc4: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
3000cdc8: 0a000029 beq 3000ce74 <_Thread_queue_Enqueue_priority+0x158>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
3000cdcc: e5932004 ldr r2, [r3, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000cdd0: e5813000 str r3, [r1]
the_node->previous = previous_node;
3000cdd4: e5812004 str r2, [r1, #4]
previous_node->next = the_node;
3000cdd8: e5821000 str r1, [r2]
search_node->previous = the_node;
3000cddc: e5831004 str r1, [r3, #4] 3000cde0: ea000020 b 3000ce68 <_Thread_queue_Enqueue_priority+0x14c>
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
3000cde4: e5da7000 ldrb r7, [sl] 3000cde8: e2877001 add r7, r7, #1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000cdec: e10f4000 mrs r4, CPSR 3000cdf0: e3843080 orr r3, r4, #128 ; 0x80 3000cdf4: e129f003 msr CPSR_fc, r3 3000cdf8: e1a06004 mov r6, r4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
3000cdfc: e5953008 ldr r3, [r5, #8]
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
3000ce00: ea00000b b 3000ce34 <_Thread_queue_Enqueue_priority+0x118>
search_priority = search_thread->current_priority;
3000ce04: e5937014 ldr r7, [r3, #20]
if ( priority >= search_priority )
3000ce08: e15c0007 cmp ip, r7
3000ce0c: 2a00000a bcs 3000ce3c <_Thread_queue_Enqueue_priority+0x120>
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ce10: e10f9000 mrs r9, CPSR <== NOT EXECUTED 3000ce14: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000ce18: e129f009 msr CPSR_fc, r9 <== NOT EXECUTED 3000ce1c: e5939010 ldr r9, [r3, #16] <== NOT EXECUTED
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
3000ce20: e1180009 tst r8, r9 <== NOT EXECUTED 3000ce24: 1a000001 bne 3000ce30 <_Thread_queue_Enqueue_priority+0x114><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ce28: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3000ce2c: eaffffec b 3000cde4 <_Thread_queue_Enqueue_priority+0xc8> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
3000ce30: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
3000ce34: e1530005 cmp r3, r5
3000ce38: 1afffff1 bne 3000ce04 <_Thread_queue_Enqueue_priority+0xe8>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
3000ce3c: e5905030 ldr r5, [r0, #48] ; 0x30 3000ce40: e3550001 cmp r5, #1
3000ce44: 1a000014 bne 3000ce9c <_Thread_queue_Enqueue_priority+0x180>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000ce48: e3a02000 mov r2, #0
if ( priority == search_priority )
3000ce4c: e15c0007 cmp ip, r7
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000ce50: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
3000ce54: 0a000006 beq 3000ce74 <_Thread_queue_Enqueue_priority+0x158>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
3000ce58: e5932000 ldr r2, [r3]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
3000ce5c: e881000c stm r1, {r2, r3}
search_node->next = the_node;
3000ce60: e5831000 str r1, [r3]
next_node->previous = the_node;
3000ce64: e5821004 str r1, [r2, #4]
the_thread->Wait.queue = the_thread_queue;
3000ce68: e5810044 str r0, [r1, #68] ; 0x44 3000ce6c: e129f004 msr CPSR_fc, r4 3000ce70: ea000007 b 3000ce94 <_Thread_queue_Enqueue_priority+0x178>
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
3000ce74: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
3000ce78: e283c03c add ip, r3, #60 ; 0x3c <== NOT EXECUTED
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000ce7c: e581c000 str ip, [r1] <== NOT EXECUTED
the_node->previous = previous_node;
3000ce80: e5812004 str r2, [r1, #4] <== NOT EXECUTED
previous_node->next = the_node;
3000ce84: e5821000 str r1, [r2] <== NOT EXECUTED
search_node->previous = the_node;
3000ce88: e5831040 str r1, [r3, #64] ; 0x40 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
3000ce8c: e5810044 str r0, [r1, #68] ; 0x44 <== NOT EXECUTED 3000ce90: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000ce94: e3a00001 mov r0, #1
3000ce98: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
* For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level;
3000ce9c: e5826000 str r6, [r2] <== NOT EXECUTED
return the_thread_queue->sync_state;
3000cea0: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
}
3000cea4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
30010b64 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
30010b64: e92d4010 push {r4, lr}
30010b68: e1a04001 mov r4, r1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30010b6c: e10f3000 mrs r3, CPSR 30010b70: e3832080 orr r2, r3, #128 ; 0x80 30010b74: e129f002 msr CPSR_fc, r2 30010b78: e59f2060 ldr r2, [pc, #96] ; 30010be0 <_Thread_queue_Extract_fifo+0x7c> 30010b7c: e5911010 ldr r1, [r1, #16] 30010b80: e0012002 and r2, r1, r2
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
30010b84: e3520000 cmp r2, #0
30010b88: 1a000001 bne 30010b94 <_Thread_queue_Extract_fifo+0x30>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30010b8c: e129f003 msr CPSR_fc, r3
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
30010b90: e8bd8010 pop {r4, pc}
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
30010b94: e8940006 ldm r4, {r1, r2}
next->previous = previous;
30010b98: e5812004 str r2, [r1, #4]
previous->next = next;
30010b9c: e5821000 str r1, [r2]
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
30010ba0: e3a02000 mov r2, #0 30010ba4: e5842044 str r2, [r4, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30010ba8: e5942050 ldr r2, [r4, #80] ; 0x50 30010bac: e3520002 cmp r2, #2
30010bb0: 0a000001 beq 30010bbc <_Thread_queue_Extract_fifo+0x58>
30010bb4: e129f003 msr CPSR_fc, r3 30010bb8: ea000004 b 30010bd0 <_Thread_queue_Extract_fifo+0x6c>
30010bbc: e3a02003 mov r2, #3 <== NOT EXECUTED 30010bc0: e5842050 str r2, [r4, #80] ; 0x50 <== NOT EXECUTED 30010bc4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
30010bc8: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30010bcc: ebfff23e bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30010bd0: e59f100c ldr r1, [pc, #12] ; 30010be4 <_Thread_queue_Extract_fifo+0x80> 30010bd4: e1a00004 mov r0, r4
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
30010bd8: e8bd4010 pop {r4, lr}
30010bdc: eaffee2b b 3000c490 <_Thread_Clear_state>
3000f7d0 <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread,
bool requeuing
)
{
3000f7d0: e92d4070 push {r4, r5, r6, lr}
3000f7d4: e20220ff and r2, r2, #255 ; 0xff
3000f7d8: e1a04001 mov r4, r1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000f7dc: e10f1000 mrs r1, CPSR 3000f7e0: e3813080 orr r3, r1, #128 ; 0x80 3000f7e4: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
3000f7e8: e59f30ac ldr r3, [pc, #172] ; 3000f89c <_Thread_queue_Extract_priority_helper+0xcc> 3000f7ec: e5940010 ldr r0, [r4, #16] 3000f7f0: e0003003 and r3, r0, r3
Chain_Node *new_second_node;
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
3000f7f4: e3530000 cmp r3, #0
3000f7f8: 0a000017 beq 3000f85c <_Thread_queue_Extract_priority_helper+0x8c>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000f7fc: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000f800: e284503c add r5, r4, #60 ; 0x3c <== NOT EXECUTED
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000f804: e1530005 cmp r3, r5 <== NOT EXECUTED
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
previous_node = the_node->previous;
3000f808: e8941001 ldm r4, {r0, ip} <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
3000f80c: 058c0000 streq r0, [ip] <== NOT EXECUTED
next_node->previous = previous_node;
3000f810: 0580c004 streq ip, [r0, #4] <== NOT EXECUTED
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000f814: 0a00000e beq 3000f854 <_Thread_queue_Extract_priority_helper+0x84><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
3000f818: e5945040 ldr r5, [r4, #64] ; 0x40 <== NOT EXECUTED
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
3000f81c: e5936000 ldr r6, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3000f820: e5803004 str r3, [r0, #4] <== NOT EXECUTED
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
previous_node->next = new_first_node;
3000f824: e58c3000 str r3, [ip] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
3000f828: e8831001 stm r3, {r0, ip} <== NOT EXECUTED
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
3000f82c: e594c038 ldr ip, [r4, #56] ; 0x38 <== NOT EXECUTED 3000f830: e5940040 ldr r0, [r4, #64] ; 0x40 <== NOT EXECUTED 3000f834: e15c0000 cmp ip, r0 <== NOT EXECUTED 3000f838: 0a000005 beq 3000f854 <_Thread_queue_Extract_priority_helper+0x84><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
3000f83c: e2830038 add r0, r3, #56 ; 0x38 <== NOT EXECUTED
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
head->next = new_second_node;
3000f840: e5836038 str r6, [r3, #56] ; 0x38 <== NOT EXECUTED
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
3000f844: e5860004 str r0, [r6, #4] <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
3000f848: e5835040 str r5, [r3, #64] ; 0x40 <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
3000f84c: e283303c add r3, r3, #60 ; 0x3c <== NOT EXECUTED
new_second_node->previous = head;
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
3000f850: e5853000 str r3, [r5] <== NOT EXECUTED
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
3000f854: e3520000 cmp r2, #0 <== NOT EXECUTED 3000f858: 0a000001 beq 3000f864 <_Thread_queue_Extract_priority_helper+0x94><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f85c: e129f001 msr CPSR_fc, r1
3000f860: e8bd8070 pop {r4, r5, r6, pc}
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000f864: e5943050 ldr r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000f868: e3530002 cmp r3, #2 <== NOT EXECUTED 3000f86c: 0a000001 beq 3000f878 <_Thread_queue_Extract_priority_helper+0xa8><== NOT EXECUTED 3000f870: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 3000f874: ea000004 b 3000f88c <_Thread_queue_Extract_priority_helper+0xbc><== NOT EXECUTED 3000f878: e3a03003 mov r3, #3 <== NOT EXECUTED 3000f87c: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000f880: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000f884: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000f888: ebfff70f bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED 3000f88c: e59f100c ldr r1, [pc, #12] ; 3000f8a0 <_Thread_queue_Extract_priority_helper+0xd0><== NOT EXECUTED 3000f890: e1a00004 mov r0, r4 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000f894: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
3000f898: eafff2fc b 3000c490 <_Thread_Clear_state> <== NOT EXECUTED
3001f4a8 <_Thread_queue_First_priority>:
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3001f4a8: e3a03000 mov r3, #0 <== NOT EXECUTED
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
3001f4ac: e3a0100c mov r1, #12 <== NOT EXECUTED 3001f4b0: e0020391 mul r2, r1, r3 <== NOT EXECUTED 3001f4b4: e080c002 add ip, r0, r2 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3001f4b8: e7902002 ldr r2, [r0, r2] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3001f4bc: e28cc004 add ip, ip, #4 <== NOT EXECUTED 3001f4c0: e152000c cmp r2, ip <== NOT EXECUTED 3001f4c4: 1a000003 bne 3001f4d8 <_Thread_queue_First_priority+0x30> <== NOT EXECUTED
{
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3001f4c8: e2833001 add r3, r3, #1 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3001f4cc: e3530004 cmp r3, #4 <== NOT EXECUTED 3001f4d0: 1afffff6 bne 3001f4b0 <_Thread_queue_First_priority+0x8> <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
return (Thread_Control *) _Chain_First(
&the_thread_queue->Queues.Priority[ index ]
);
}
return NULL;
3001f4d4: e3a02000 mov r2, #0 <== NOT EXECUTED
}
3001f4d8: e1a00002 mov r0, r2 <== NOT EXECUTED 3001f4dc: e12fff1e bx lr <== NOT EXECUTED
3000f8a4 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
3000f8a4: e1a01000 mov r1, r0 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
3000f8a8: e5900044 ldr r0, [r0, #68] ; 0x44 <== NOT EXECUTED
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
3000f8ac: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000f8b0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f8b4: 0a000009 beq 3000f8e0 <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000f8b8: e59f202c ldr r2, [pc, #44] ; 3000f8ec <_Thread_queue_Process_timeout+0x48><== NOT EXECUTED 3000f8bc: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3000f8c0: e1510002 cmp r1, r2 <== NOT EXECUTED 3000f8c4: 1a000005 bne 3000f8e0 <_Thread_queue_Process_timeout+0x3c> <== NOT EXECUTED
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
3000f8c8: e3530003 cmp r3, #3 <== NOT EXECUTED
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
3000f8cc: 1590303c ldrne r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000f8d0: 15813034 strne r3, [r1, #52] ; 0x34 <== NOT EXECUTED
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
3000f8d4: 13a03002 movne r3, #2 <== NOT EXECUTED 3000f8d8: 15803030 strne r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000f8dc: e12fff1e bx lr <== NOT EXECUTED
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
3000f8e0: e590303c ldr r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000f8e4: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
3000f8e8: eaffffb2 b 3000f7b8 <_Thread_queue_Extract> <== NOT EXECUTED
3000cf64 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000cf64: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
/* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue )
3000cf68: e2504000 subs r4, r0, #0 <== NOT EXECUTED
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000cf6c: e1a05001 mov r5, r1 <== NOT EXECUTED
/* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue )
3000cf70: 0a000011 beq 3000cfbc <_Thread_queue_Requeue+0x58> <== NOT EXECUTED
/*
* If queueing by FIFO, there is nothing to do. This only applies to
* priority blocking discipline.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
3000cf74: e5942034 ldr r2, [r4, #52] ; 0x34 <== NOT EXECUTED 3000cf78: e3520001 cmp r2, #1 <== NOT EXECUTED 3000cf7c: 1a00000e bne 3000cfbc <_Thread_queue_Requeue+0x58> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000cf80: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000cf84: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000cf88: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 3000cf8c: e59f302c ldr r3, [pc, #44] ; 3000cfc0 <_Thread_queue_Requeue+0x5c><== NOT EXECUTED 3000cf90: e591c010 ldr ip, [r1, #16] <== NOT EXECUTED 3000cf94: e00c3003 and r3, ip, r3 <== NOT EXECUTED
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
3000cf98: e3530000 cmp r3, #0 <== NOT EXECUTED 3000cf9c: 0a000005 beq 3000cfb8 <_Thread_queue_Requeue+0x54> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000cfa0: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
3000cfa4: eb000a09 bl 3000f7d0 <_Thread_queue_Extract_priority_helper><== NOT EXECUTED
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
3000cfa8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cfac: e1a01005 mov r1, r5 <== NOT EXECUTED 3000cfb0: e1a0200d mov r2, sp <== NOT EXECUTED 3000cfb4: ebffff58 bl 3000cd1c <_Thread_queue_Enqueue_priority> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000cfb8: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
}
_ISR_Enable( level );
}
}
3000cfbc: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
3000cfc4 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000cfc4: e92d4001 push {r0, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000cfc8: e1a0100d mov r1, sp <== NOT EXECUTED 3000cfcc: ebfffe12 bl 3000c81c <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000cfd0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000cfd4: e3530000 cmp r3, #0 <== NOT EXECUTED 3000cfd8: 1a000004 bne 3000cff0 <_Thread_queue_Timeout+0x2c> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
3000cfdc: eb000a30 bl 3000f8a4 <_Thread_queue_Process_timeout> <== NOT EXECUTED
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000cfe0: e59f300c ldr r3, [pc, #12] ; 3000cff4 <_Thread_queue_Timeout+0x30><== NOT EXECUTED 3000cfe4: e5932000 ldr r2, [r3] <== NOT EXECUTED
--level;
3000cfe8: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000cfec: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Unnest_dispatch();
break;
}
}
3000cff0: e8bd8008 pop {r3, pc} <== NOT EXECUTED
300191bc <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
300191bc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
300191c0: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
300191c4: e28d8004 add r8, sp, #4 <== NOT EXECUTED 300191c8: e28d5010 add r5, sp, #16 <== NOT EXECUTED
head->previous = NULL;
300191cc: e3a03000 mov r3, #0 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
300191d0: e2889004 add r9, r8, #4 <== NOT EXECUTED 300191d4: e2856004 add r6, r5, #4 <== NOT EXECUTED 300191d8: e1a04000 mov r4, r0 <== NOT EXECUTED 300191dc: e58d9004 str r9, [sp, #4] <== NOT EXECUTED
head->previous = NULL;
300191e0: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
tail->previous = head;
300191e4: e58d800c str r8, [sp, #12] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
300191e8: e58d6010 str r6, [sp, #16] <== NOT EXECUTED
head->previous = NULL;
300191ec: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
tail->previous = head;
300191f0: e58d5018 str r5, [sp, #24] <== NOT EXECUTED
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
300191f4: e59f7178 ldr r7, [pc, #376] ; 30019374 <_Timer_server_Body+0x1b8><== NOT EXECUTED
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
300191f8: e5848078 str r8, [r4, #120] ; 0x78 <== NOT EXECUTED
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
300191fc: e5973000 ldr r3, [r7] <== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
30019200: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
30019204: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 30019208: e0611003 rsb r1, r1, r3 <== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
3001920c: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
30019210: e1a02005 mov r2, r5 <== NOT EXECUTED
30019214: eb001079 bl 3001d400 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED
30019218: e59f3158 ldr r3, [pc, #344] ; 30019378 <_Timer_server_Body+0x1bc><== NOT EXECUTED
3001921c: e59f2158 ldr r2, [pc, #344] ; 3001937c <_Timer_server_Body+0x1c0><== NOT EXECUTED
30019220: e8930003 ldm r3, {r0, r1} <== NOT EXECUTED
30019224: e3a03000 mov r3, #0 <== NOT EXECUTED
30019228: eb004b53 bl 3002bf7c <__divdi3> <== NOT EXECUTED
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
3001922c: e5942074 ldr r2, [r4, #116] ; 0x74 <== NOT EXECUTED 30019230: e1a0a000 mov sl, r0 <== NOT EXECUTED
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
30019234: e1500002 cmp r0, r2 <== NOT EXECUTED 30019238: 9a000004 bls 30019250 <_Timer_server_Body+0x94> <== NOT EXECUTED
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
3001923c: e062100a rsb r1, r2, sl <== NOT EXECUTED 30019240: e2840068 add r0, r4, #104 ; 0x68 <== NOT EXECUTED 30019244: e1a02005 mov r2, r5 <== NOT EXECUTED 30019248: eb00106c bl 3001d400 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 3001924c: ea000003 b 30019260 <_Timer_server_Body+0xa4> <== NOT EXECUTED
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
30019250: 32840068 addcc r0, r4, #104 ; 0x68 <== NOT EXECUTED 30019254: 33a01001 movcc r1, #1 <== NOT EXECUTED 30019258: 306a2002 rsbcc r2, sl, r2 <== NOT EXECUTED 3001925c: 3b00103f blcc 3001d360 <_Watchdog_Adjust> <== NOT EXECUTED
}
watchdogs->last_snapshot = snapshot;
30019260: e584a074 str sl, [r4, #116] ; 0x74 <== NOT EXECUTED
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
30019264: e284b068 add fp, r4, #104 ; 0x68 <== NOT EXECUTED
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
30019268: e284a030 add sl, r4, #48 ; 0x30 <== NOT EXECUTED
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
3001926c: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED 30019270: eb0002aa bl 30019d20 <_Chain_Get> <== NOT EXECUTED
if ( timer == NULL ) {
30019274: e2501000 subs r1, r0, #0 <== NOT EXECUTED 30019278: 0a000009 beq 300192a4 <_Timer_server_Body+0xe8> <== NOT EXECUTED
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
3001927c: e5913038 ldr r3, [r1, #56] ; 0x38 <== NOT EXECUTED 30019280: e3530001 cmp r3, #1 <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
30019284: 01a0000a moveq r0, sl <== NOT EXECUTED
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
30019288: 0a000002 beq 30019298 <_Timer_server_Body+0xdc> <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
3001928c: e3530003 cmp r3, #3 <== NOT EXECUTED 30019290: 1afffff5 bne 3001926c <_Timer_server_Body+0xb0> <== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
30019294: e1a0000b mov r0, fp <== NOT EXECUTED 30019298: e2811010 add r1, r1, #16 <== NOT EXECUTED 3001929c: eb00107c bl 3001d494 <_Watchdog_Insert> <== NOT EXECUTED 300192a0: eafffff1 b 3001926c <_Timer_server_Body+0xb0> <== NOT EXECUTED
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
300192a4: e58d1000 str r1, [sp] <== NOT EXECUTED 300192a8: ebffff97 bl 3001910c <arm_interrupt_disable> <== NOT EXECUTED
if ( _Chain_Is_empty( insert_chain ) ) {
300192ac: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 300192b0: e59d1000 ldr r1, [sp] <== NOT EXECUTED 300192b4: e1530009 cmp r3, r9 <== NOT EXECUTED 300192b8: 1a000006 bne 300192d8 <_Timer_server_Body+0x11c> <== NOT EXECUTED
ts->insert_chain = NULL;
300192bc: e5841078 str r1, [r4, #120] ; 0x78 <== NOT EXECUTED 300192c0: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
300192c4: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 300192c8: e1530006 cmp r3, r6 <== NOT EXECUTED
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
300192cc: 13a07000 movne r7, #0 <== NOT EXECUTED
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
300192d0: 1a000002 bne 300192e0 <_Timer_server_Body+0x124> <== NOT EXECUTED 300192d4: ea000011 b 30019320 <_Timer_server_Body+0x164> <== NOT EXECUTED 300192d8: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 300192dc: eaffffc6 b 300191fc <_Timer_server_Body+0x40> <== NOT EXECUTED
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
300192e0: ebffff89 bl 3001910c <arm_interrupt_disable> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
300192e4: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
300192e8: e1530006 cmp r3, r6 <== NOT EXECUTED 300192ec: 0a000009 beq 30019318 <_Timer_server_Body+0x15c> <== NOT EXECUTED
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
300192f0: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
new_first->previous = head;
300192f4: e5825004 str r5, [r2, #4] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
300192f8: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
300192fc: e5837008 str r7, [r3, #8] <== NOT EXECUTED 30019300: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
30019304: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 30019308: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 3001930c: e1a0e00f mov lr, pc <== NOT EXECUTED 30019310: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED
}
30019314: eafffff1 b 300192e0 <_Timer_server_Body+0x124> <== NOT EXECUTED 30019318: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 3001931c: eaffffb4 b 300191f4 <_Timer_server_Body+0x38> <== NOT EXECUTED
} else {
ts->active = false;
30019320: e3a03000 mov r3, #0 <== NOT EXECUTED 30019324: e5c4307c strb r3, [r4, #124] ; 0x7c <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
30019328: e59f3050 ldr r3, [pc, #80] ; 30019380 <_Timer_server_Body+0x1c4><== NOT EXECUTED 3001932c: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
30019330: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30019334: e5832000 str r2, [r3] <== NOT EXECUTED
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
30019338: e3a01008 mov r1, #8 <== NOT EXECUTED 3001933c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30019340: eb000f2f bl 3001d004 <_Thread_Set_state> <== NOT EXECUTED
_Timer_server_Reset_interval_system_watchdog( ts );
30019344: e1a00004 mov r0, r4 <== NOT EXECUTED 30019348: ebffff73 bl 3001911c <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED
_Timer_server_Reset_tod_system_watchdog( ts );
3001934c: e1a00004 mov r0, r4 <== NOT EXECUTED 30019350: ebffff85 bl 3001916c <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED
_Thread_Enable_dispatch();
30019354: eb000d07 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
ts->active = true;
30019358: e3a03001 mov r3, #1 <== NOT EXECUTED 3001935c: e5c4307c strb r3, [r4, #124] ; 0x7c <== NOT EXECUTED
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
30019360: e2840008 add r0, r4, #8 <== NOT EXECUTED 30019364: eb0010a1 bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
30019368: e2840040 add r0, r4, #64 ; 0x40 <== NOT EXECUTED 3001936c: eb00109f bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED 30019370: eaffff9f b 300191f4 <_Timer_server_Body+0x38> <== NOT EXECUTED
3001911c <_Timer_server_Reset_interval_system_watchdog>:
}
static void _Timer_server_Reset_interval_system_watchdog(
Timer_server_Control *ts
)
{
3001911c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
30019120: e2805008 add r5, r0, #8 <== NOT EXECUTED
}
static void _Timer_server_Reset_interval_system_watchdog(
Timer_server_Control *ts
)
{
30019124: e1a04000 mov r4, r0 <== NOT EXECUTED
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
30019128: e1a00005 mov r0, r5 <== NOT EXECUTED 3001912c: eb00112f bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED
{
ISR_Level level;
_Timer_server_Stop_interval_system_watchdog( ts );
_ISR_Disable( level );
30019130: ebfffff5 bl 3001910c <arm_interrupt_disable> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
30019134: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
30019138: e2842034 add r2, r4, #52 ; 0x34 <== NOT EXECUTED
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
3001913c: e1530002 cmp r3, r2 <== NOT EXECUTED 30019140: 0a000006 beq 30019160 <_Timer_server_Reset_interval_system_watchdog+0x44><== NOT EXECUTED
Watchdog_Interval delta_interval =
30019144: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30019148: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3001914c: e59f0014 ldr r0, [pc, #20] ; 30019168 <_Timer_server_Reset_interval_system_watchdog+0x4c><== NOT EXECUTED 30019150: e1a01005 mov r1, r5 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30019154: e5843014 str r3, [r4, #20] <== NOT EXECUTED
delta_interval
);
} else {
_ISR_Enable( level );
}
}
30019158: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3001915c: ea0010cc b 3001d494 <_Watchdog_Insert> <== NOT EXECUTED
30019160: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
30019164: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3001916c <_Timer_server_Reset_tod_system_watchdog>:
}
static void _Timer_server_Reset_tod_system_watchdog(
Timer_server_Control *ts
)
{
3001916c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
30019170: e2805040 add r5, r0, #64 ; 0x40 <== NOT EXECUTED
}
static void _Timer_server_Reset_tod_system_watchdog(
Timer_server_Control *ts
)
{
30019174: e1a04000 mov r4, r0 <== NOT EXECUTED
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
30019178: e1a00005 mov r0, r5 <== NOT EXECUTED 3001917c: eb00111b bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED
{
ISR_Level level;
_Timer_server_Stop_tod_system_watchdog( ts );
_ISR_Disable( level );
30019180: ebffffe1 bl 3001910c <arm_interrupt_disable> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
30019184: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
30019188: e284206c add r2, r4, #108 ; 0x6c <== NOT EXECUTED
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
3001918c: e1530002 cmp r3, r2 <== NOT EXECUTED 30019190: 0a000006 beq 300191b0 <_Timer_server_Reset_tod_system_watchdog+0x44><== NOT EXECUTED
Watchdog_Interval delta_interval =
30019194: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED 30019198: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001919c: e59f0014 ldr r0, [pc, #20] ; 300191b8 <_Timer_server_Reset_tod_system_watchdog+0x4c><== NOT EXECUTED 300191a0: e1a01005 mov r1, r5 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
300191a4: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED
delta_interval
);
} else {
_ISR_Enable( level );
}
}
300191a8: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
300191ac: ea0010b8 b 3001d494 <_Watchdog_Insert> <== NOT EXECUTED
300191b0: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
300191b4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30019384 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
30019384: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
30019388: e5906078 ldr r6, [r0, #120] ; 0x78 <== NOT EXECUTED
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
3001938c: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
30019390: e3560000 cmp r6, #0 <== NOT EXECUTED
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
30019394: e1a05001 mov r5, r1 <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
30019398: 1a000040 bne 300194a0 <_Timer_server_Schedule_operation_method+0x11c><== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3001939c: e59f3108 ldr r3, [pc, #264] ; 300194ac <_Timer_server_Schedule_operation_method+0x128><== NOT EXECUTED 300193a0: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
300193a4: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
300193a8: e5832000 str r2, [r3] <== NOT EXECUTED
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
300193ac: e5913038 ldr r3, [r1, #56] ; 0x38 <== NOT EXECUTED 300193b0: e3530001 cmp r3, #1 <== NOT EXECUTED 300193b4: 1a000017 bne 30019418 <_Timer_server_Schedule_operation_method+0x94><== NOT EXECUTED
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
300193b8: ebffff53 bl 3001910c <arm_interrupt_disable> <== NOT EXECUTED
snapshot = _Watchdog_Ticks_since_boot;
300193bc: e59f30ec ldr r3, [pc, #236] ; 300194b0 <_Timer_server_Schedule_operation_method+0x12c><== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
300193c0: e284c034 add ip, r4, #52 ; 0x34 <== NOT EXECUTED 300193c4: e5932000 ldr r2, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
300193c8: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
last_snapshot = ts->Interval_watchdogs.last_snapshot;
300193cc: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
300193d0: e153000c cmp r3, ip <== NOT EXECUTED 300193d4: 0a000004 beq 300193ec <_Timer_server_Schedule_operation_method+0x68><== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
300193d8: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
300193dc: e0611002 rsb r1, r1, r2 <== NOT EXECUTED
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
300193e0: e15c0001 cmp ip, r1 <== NOT EXECUTED
delta_interval -= delta;
300193e4: 8061600c rsbhi r6, r1, ip <== NOT EXECUTED
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
300193e8: e5836010 str r6, [r3, #16] <== NOT EXECUTED
}
ts->Interval_watchdogs.last_snapshot = snapshot;
300193ec: e584203c str r2, [r4, #60] ; 0x3c <== NOT EXECUTED 300193f0: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
300193f4: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 300193f8: e2851010 add r1, r5, #16 <== NOT EXECUTED 300193fc: eb001024 bl 3001d494 <_Watchdog_Insert> <== NOT EXECUTED
if ( !ts->active ) {
30019400: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 30019404: e3530000 cmp r3, #0 <== NOT EXECUTED 30019408: 1a000022 bne 30019498 <_Timer_server_Schedule_operation_method+0x114><== NOT EXECUTED
_Timer_server_Reset_interval_system_watchdog( ts );
3001940c: e1a00004 mov r0, r4 <== NOT EXECUTED 30019410: ebffff41 bl 3001911c <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED 30019414: ea00001f b 30019498 <_Timer_server_Schedule_operation_method+0x114><== NOT EXECUTED
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
30019418: e3530003 cmp r3, #3 <== NOT EXECUTED 3001941c: 1a00001d bne 30019498 <_Timer_server_Schedule_operation_method+0x114><== NOT EXECUTED
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
30019420: ebffff39 bl 3001910c <arm_interrupt_disable> <== NOT EXECUTED
30019424: e1a07000 mov r7, r0 <== NOT EXECUTED
30019428: e59f3084 ldr r3, [pc, #132] ; 300194b4 <_Timer_server_Schedule_operation_method+0x130><== NOT EXECUTED
3001942c: e59f2084 ldr r2, [pc, #132] ; 300194b8 <_Timer_server_Schedule_operation_method+0x134><== NOT EXECUTED
30019430: e8930003 ldm r3, {r0, r1} <== NOT EXECUTED
30019434: e3a03000 mov r3, #0 <== NOT EXECUTED
30019438: eb004acf bl 3002bf7c <__divdi3> <== NOT EXECUTED
3001943c: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
30019440: e284106c add r1, r4, #108 ; 0x6c <== NOT EXECUTED
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
30019444: e1530001 cmp r3, r1 <== NOT EXECUTED
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
30019448: e5942074 ldr r2, [r4, #116] ; 0x74 <== NOT EXECUTED
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
3001944c: 0a000008 beq 30019474 <_Timer_server_Schedule_operation_method+0xf0><== NOT EXECUTED
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
30019450: e5931010 ldr r1, [r3, #16] <== NOT EXECUTED
if ( snapshot > last_snapshot ) {
30019454: e1500002 cmp r0, r2 <== NOT EXECUTED
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
30019458: 90816002 addls r6, r1, r2 <== NOT EXECUTED
delta_interval += delta;
3001945c: 90606006 rsbls r6, r0, r6 <== NOT EXECUTED
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
if ( snapshot > last_snapshot ) {
30019460: 9a000002 bls 30019470 <_Timer_server_Schedule_operation_method+0xec><== NOT EXECUTED
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
30019464: e0622000 rsb r2, r2, r0 <== NOT EXECUTED
if (delta_interval > delta) {
30019468: e1510002 cmp r1, r2 <== NOT EXECUTED
delta_interval -= delta;
3001946c: 80626001 rsbhi r6, r2, r1 <== NOT EXECUTED
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
30019470: e5836010 str r6, [r3, #16] <== NOT EXECUTED
}
ts->TOD_watchdogs.last_snapshot = snapshot;
30019474: e5840074 str r0, [r4, #116] ; 0x74 <== NOT EXECUTED 30019478: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
3001947c: e2840068 add r0, r4, #104 ; 0x68 <== NOT EXECUTED 30019480: e2851010 add r1, r5, #16 <== NOT EXECUTED 30019484: eb001002 bl 3001d494 <_Watchdog_Insert> <== NOT EXECUTED
if ( !ts->active ) {
30019488: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3001948c: e3530000 cmp r3, #0 <== NOT EXECUTED
_Timer_server_Reset_tod_system_watchdog( ts );
30019490: 01a00004 moveq r0, r4 <== NOT EXECUTED 30019494: 0bffff34 bleq 3001916c <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
}
}
30019498: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
3001949c: ea000cb5 b 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
300194a0: e5900078 ldr r0, [r0, #120] ; 0x78 <== NOT EXECUTED
} }
300194a4: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
300194a8: ea000211 b 30019cf4 <_Chain_Append> <== NOT EXECUTED
3000d88c <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
3000d88c: e1a03000 mov r3, r0 <== NOT EXECUTED
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000d890: e5932000 ldr r2, [r3] <== NOT EXECUTED
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
uint32_t seconds = add->tv_sec;
3000d894: e5910000 ldr r0, [r1] <== NOT EXECUTED
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
3000d898: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000d89c: e0822000 add r2, r2, r0 <== NOT EXECUTED 3000d8a0: e5832000 str r2, [r3] <== NOT EXECUTED
time->tv_nsec += add->tv_nsec;
3000d8a4: e5912004 ldr r2, [r1, #4] <== NOT EXECUTED 3000d8a8: e08c2002 add r2, ip, r2 <== NOT EXECUTED 3000d8ac: e5832004 str r2, [r3, #4] <== NOT EXECUTED
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000d8b0: e59fc02c ldr ip, [pc, #44] ; 3000d8e4 <_Timespec_Add_to+0x58><== NOT EXECUTED 3000d8b4: ea000006 b 3000d8d4 <_Timespec_Add_to+0x48> <== NOT EXECUTED
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
3000d8b8: e59f2028 ldr r2, [pc, #40] ; 3000d8e8 <_Timespec_Add_to+0x5c><== NOT EXECUTED
time->tv_sec++;
seconds++;
3000d8bc: e2800001 add r0, r0, #1 <== NOT EXECUTED
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
3000d8c0: e0812002 add r2, r1, r2 <== NOT EXECUTED 3000d8c4: e5832004 str r2, [r3, #4] <== NOT EXECUTED
time->tv_sec++;
3000d8c8: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000d8cc: e2822001 add r2, r2, #1 <== NOT EXECUTED 3000d8d0: e5832000 str r2, [r3] <== NOT EXECUTED
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000d8d4: e5931004 ldr r1, [r3, #4] <== NOT EXECUTED 3000d8d8: e151000c cmp r1, ip <== NOT EXECUTED 3000d8dc: 8afffff5 bhi 3000d8b8 <_Timespec_Add_to+0x2c> <== NOT EXECUTED
time->tv_sec++;
seconds++;
}
return seconds;
}
3000d8e0: e12fff1e bx lr <== NOT EXECUTED
3000cf4c <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000cf4c: e92d40f0 push {r4, r5, r6, r7, lr}
* For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
3000cf50: e5914000 ldr r4, [r1]
right += rhs->tv_nsec;
3000cf54: e5911004 ldr r1, [r1, #4]
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000cf58: e1a06002 mov r6, r2 3000cf5c: e1a07003 mov r7, r3
* in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec;
3000cf60: e1a02001 mov r2, r1 3000cf64: e1a03fc1 asr r3, r1, #31 3000cf68: e59f106c ldr r1, [pc, #108] ; 3000cfdc <_Timespec_Divide+0x90>
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
3000cf6c: e590c000 ldr ip, [r0]
left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec;
3000cf70: e0e32491 smlal r2, r3, r1, r4
if ( right == 0 ) {
3000cf74: e1924003 orrs r4, r2, r3
*ival_percentage = 0;
3000cf78: 03a03000 moveq r3, #0
/* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec;
3000cf7c: e5900004 ldr r0, [r0, #4]
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
*ival_percentage = 0;
3000cf80: 05863000 streq r3, [r6]
*fval_percentage = 0;
3000cf84: 05873000 streq r3, [r7]
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
3000cf88: 08bd80f0 popeq {r4, r5, r6, r7, pc}
/* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec;
3000cf8c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000cf90: e1a05fc0 asr r5, r0, #31 <== NOT EXECUTED 3000cf94: e0e54c91 smlal r4, r5, r1, ip <== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
3000cf98: e59fc040 ldr ip, [pc, #64] ; 3000cfe0 <_Timespec_Divide+0x94><== NOT EXECUTED 3000cf9c: e0810c94 umull r0, r1, r4, ip <== NOT EXECUTED 3000cfa0: e021159c mla r1, ip, r5, r1 <== NOT EXECUTED 3000cfa4: eb003811 bl 3001aff0 <__udivdi3> <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000cfa8: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000cfac: e3a03000 mov r3, #0 <== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
3000cfb0: e1a05000 mov r5, r0 <== NOT EXECUTED 3000cfb4: e1a04001 mov r4, r1 <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000cfb8: eb00380c bl 3001aff0 <__udivdi3> <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000cfbc: e1a01004 mov r1, r4 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
3000cfc0: e5860000 str r0, [r6] <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000cfc4: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED
3000cfc8: e1a00005 mov r0, r5 <== NOT EXECUTED
3000cfcc: e3a03000 mov r3, #0 <== NOT EXECUTED
3000cfd0: eb00392a bl 3001b480 <__umoddi3> <== NOT EXECUTED
3000cfd4: e5870000 str r0, [r7] <== NOT EXECUTED
3000cfd8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3002686c <_Timespec_Divide_by_integer>:
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3002686c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30026870: e1a04002 mov r4, r2 <== NOT EXECUTED
* For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; t *= TOD_NANOSECONDS_PER_SECOND; t += time->tv_nsec;
30026874: e5902004 ldr r2, [r0, #4] <== NOT EXECUTED
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
t = time->tv_sec;
30026878: e590c000 ldr ip, [r0] <== NOT EXECUTED
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3002687c: e1a03001 mov r3, r1 <== NOT EXECUTED
* For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; t *= TOD_NANOSECONDS_PER_SECOND; t += time->tv_nsec;
30026880: e1a00002 mov r0, r2 <== NOT EXECUTED 30026884: e1a01fc2 asr r1, r2, #31 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
30026888: e59f2040 ldr r2, [pc, #64] ; 300268d0 <_Timespec_Divide_by_integer+0x64><== NOT EXECUTED 3002688c: e0e10c92 smlal r0, r1, r2, ip <== NOT EXECUTED 30026890: e1a02003 mov r2, r3 <== NOT EXECUTED 30026894: e3a03000 mov r3, #0 <== NOT EXECUTED 30026898: eb00a34c bl 3004f5d0 <__udivdi3> <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3002689c: e59f202c ldr r2, [pc, #44] ; 300268d0 <_Timespec_Divide_by_integer+0x64><== NOT EXECUTED 300268a0: e3a03000 mov r3, #0 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
300268a4: e1a06000 mov r6, r0 <== NOT EXECUTED 300268a8: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
300268ac: eb00a347 bl 3004f5d0 <__udivdi3> <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
300268b0: e1a01005 mov r1, r5 <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
300268b4: e5840000 str r0, [r4] <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
300268b8: e59f2010 ldr r2, [pc, #16] ; 300268d0 <_Timespec_Divide_by_integer+0x64><== NOT EXECUTED 300268bc: e1a00006 mov r0, r6 <== NOT EXECUTED 300268c0: e3a03000 mov r3, #0 <== NOT EXECUTED 300268c4: eb00a465 bl 3004fa60 <__umoddi3> <== NOT EXECUTED 300268c8: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
300268cc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30028814 <_Timespec_From_ticks>:
struct timespec *time
)
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
30028814: e59f3038 ldr r3, [pc, #56] ; 30028854 <_Timespec_From_ticks+0x40><== NOT EXECUTED
void _Timespec_From_ticks(
uint32_t ticks,
struct timespec *time
)
{
30028818: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
3002881c: e593500c ldr r5, [r3, #12] <== NOT EXECUTED
void _Timespec_From_ticks(
uint32_t ticks,
struct timespec *time
)
{
30028820: e1a04001 mov r4, r1 <== NOT EXECUTED
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
30028824: e0050590 mul r5, r0, r5 <== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
30028828: e59f1028 ldr r1, [pc, #40] ; 30028858 <_Timespec_From_ticks+0x44><== NOT EXECUTED 3002882c: e1a00005 mov r0, r5 <== NOT EXECUTED 30028830: ebff7161 bl 30004dbc <__aeabi_uidiv> <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
30028834: e59f101c ldr r1, [pc, #28] ; 30028858 <_Timespec_From_ticks+0x44><== NOT EXECUTED
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
30028838: e5840000 str r0, [r4] <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
3002883c: e1a00005 mov r0, r5 <== NOT EXECUTED 30028840: ebfff746 bl 30026560 <__umodsi3> <== NOT EXECUTED 30028844: e3a03ffa mov r3, #1000 ; 0x3e8 <== NOT EXECUTED 30028848: e0030390 mul r3, r0, r3 <== NOT EXECUTED 3002884c: e5843004 str r3, [r4, #4] <== NOT EXECUTED
TOD_NANOSECONDS_PER_MICROSECOND;
}
30028850: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3002885c <_Timespec_Is_valid>:
bool _Timespec_Is_valid(
const struct timespec *time
)
{
if ( !time )
3002885c: e3500000 cmp r0, #0 <== NOT EXECUTED 30028860: 012fff1e bxeq lr <== NOT EXECUTED
return false;
if ( time->tv_sec < 0 )
30028864: e5903000 ldr r3, [r0] <== NOT EXECUTED 30028868: e3530000 cmp r3, #0 <== NOT EXECUTED
return false;
3002886c: b3a00000 movlt r0, #0 <== NOT EXECUTED
)
{
if ( !time )
return false;
if ( time->tv_sec < 0 )
30028870: b12fff1e bxlt lr <== NOT EXECUTED
return false;
if ( time->tv_nsec < 0 )
30028874: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 30028878: e3530000 cmp r3, #0 <== NOT EXECUTED 3002887c: ba000004 blt 30028894 <_Timespec_Is_valid+0x38> <== NOT EXECUTED
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
30028880: e59f0014 ldr r0, [pc, #20] ; 3002889c <_Timespec_Is_valid+0x40><== NOT EXECUTED 30028884: e1530000 cmp r3, r0 <== NOT EXECUTED 30028888: 83a00000 movhi r0, #0 <== NOT EXECUTED 3002888c: 93a00001 movls r0, #1 <== NOT EXECUTED 30028890: e12fff1e bx lr <== NOT EXECUTED
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
30028894: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
30028898: e12fff1e bx lr <== NOT EXECUTED
3000cfe4 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
3000cfe4: e5902000 ldr r2, [r0] 3000cfe8: e5913000 ldr r3, [r1] 3000cfec: e1520003 cmp r2, r3
return true;
3000cff0: b3a00001 movlt r0, #1
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
3000cff4: b12fff1e bxlt lr
return true;
if ( lhs->tv_sec > rhs->tv_sec )
3000cff8: ca000005 bgt 3000d014 <_Timespec_Less_than+0x30>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Less_than(
3000cffc: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED 3000d000: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 3000d004: e1500003 cmp r0, r3 <== NOT EXECUTED 3000d008: a3a00000 movge r0, #0 <== NOT EXECUTED 3000d00c: b3a00001 movlt r0, #1 <== NOT EXECUTED 3000d010: e12fff1e bx lr <== NOT EXECUTED
{
if ( lhs->tv_sec < rhs->tv_sec )
return true;
if ( lhs->tv_sec > rhs->tv_sec )
return false;
3000d014: e3a00000 mov r0, #0
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
return true;
return false;
}
3000d018: e12fff1e bx lr
3000dfc4 <_Timespec_Subtract>:
const struct timespec *end,
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
3000dfc4: e591c004 ldr ip, [r1, #4] <== NOT EXECUTED 3000dfc8: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED
void _Timespec_Subtract(
const struct timespec *start,
const struct timespec *end,
struct timespec *result
)
{
3000dfcc: e92d4010 push {r4, lr} <== NOT EXECUTED
3000dfd0: e5914000 ldr r4, [r1] <== NOT EXECUTED
3000dfd4: e5901000 ldr r1, [r0] <== NOT EXECUTED
if (end->tv_nsec < start->tv_nsec) {
3000dfd8: e15c0003 cmp ip, r3 <== NOT EXECUTED
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000dfdc: e0611004 rsb r1, r1, r4 <== NOT EXECUTED 3000dfe0: b2411001 sublt r1, r1, #1 <== NOT EXECUTED 3000dfe4: b5821000 strlt r1, [r2] <== NOT EXECUTED
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
3000dfe8: b59f1014 ldrlt r1, [pc, #20] ; 3000e004 <_Timespec_Subtract+0x40><== NOT EXECUTED
} else {
result->tv_sec = end->tv_sec - start->tv_sec;
result->tv_nsec = end->tv_nsec - start->tv_nsec;
3000dfec: a063300c rsbge r3, r3, ip <== NOT EXECUTED
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
3000dff0: b08c1001 addlt r1, ip, r1 <== NOT EXECUTED 3000dff4: b0633001 rsblt r3, r3, r1 <== NOT EXECUTED
} else {
result->tv_sec = end->tv_sec - start->tv_sec;
3000dff8: a5821000 strge r1, [r2] <== NOT EXECUTED
result->tv_nsec = end->tv_nsec - start->tv_nsec;
3000dffc: e5823004 str r3, [r2, #4] <== NOT EXECUTED
3000e000: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300288a0 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
300288a0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
uint32_t ticks;
uint32_t nanoseconds_per_tick;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
300288a4: e5905000 ldr r5, [r0] <== NOT EXECUTED
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
300288a8: e1a06000 mov r6, r0 <== NOT EXECUTED
uint32_t ticks;
uint32_t nanoseconds_per_tick;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
300288ac: e3550000 cmp r5, #0 <== NOT EXECUTED 300288b0: 1a000002 bne 300288c0 <_Timespec_To_ticks+0x20> <== NOT EXECUTED 300288b4: e5904004 ldr r4, [r0, #4] <== NOT EXECUTED 300288b8: e3540000 cmp r4, #0 <== NOT EXECUTED 300288bc: 0a00000d beq 300288f8 <_Timespec_To_ticks+0x58> <== NOT EXECUTED
/** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
300288c0: eb000032 bl 30028990 <TOD_TICKS_PER_SECOND_method> <== NOT EXECUTED
nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick();
300288c4: e59f3034 ldr r3, [pc, #52] ; 30028900 <_Timespec_To_ticks+0x60><== NOT EXECUTED
/** * We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
300288c8: e0040095 mul r4, r5, r0 <== NOT EXECUTED
nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); ticks += time->tv_nsec / nanoseconds_per_tick;
300288cc: e5966004 ldr r6, [r6, #4] <== NOT EXECUTED
* We should ensure the ticks not be truncated by integer division. We * need to have it be greater than or equal to the requested time. It * should not be shorter. */ ticks = time->tv_sec * TOD_TICKS_PER_SECOND; nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick();
300288d0: e5935010 ldr r5, [r3, #16] <== NOT EXECUTED
ticks += time->tv_nsec / nanoseconds_per_tick;
300288d4: e1a00006 mov r0, r6 <== NOT EXECUTED 300288d8: e1a01005 mov r1, r5 <== NOT EXECUTED 300288dc: ebff7136 bl 30004dbc <__aeabi_uidiv> <== NOT EXECUTED
if ( (time->tv_nsec % nanoseconds_per_tick) != 0 )
300288e0: e1a01005 mov r1, r5 <== NOT EXECUTED
* need to have it be greater than or equal to the requested time. It * should not be shorter. */ ticks = time->tv_sec * TOD_TICKS_PER_SECOND; nanoseconds_per_tick = rtems_configuration_get_nanoseconds_per_tick(); ticks += time->tv_nsec / nanoseconds_per_tick;
300288e4: e0844000 add r4, r4, r0 <== NOT EXECUTED
if ( (time->tv_nsec % nanoseconds_per_tick) != 0 )
300288e8: e1a00006 mov r0, r6 <== NOT EXECUTED 300288ec: ebfff71b bl 30026560 <__umodsi3> <== NOT EXECUTED 300288f0: e3500000 cmp r0, #0 <== NOT EXECUTED
ticks += 1;
300288f4: 12844001 addne r4, r4, #1 <== NOT EXECUTED
return ticks;
}
300288f8: e1a00004 mov r0, r4 <== NOT EXECUTED
300288fc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000e75c <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
3000e75c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000e760: e1a04002 mov r4, r2 <== NOT EXECUTED
3000e764: e1a05003 mov r5, r3 <== NOT EXECUTED
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
3000e768: e891000c ldm r1, {r2, r3} <== NOT EXECUTED
3000e76c: e1921003 orrs r1, r2, r3 <== NOT EXECUTED
*_ival_percentage = 0;
3000e770: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000e774: 05843000 streq r3, [r4] <== NOT EXECUTED
*_fval_percentage = 0;
3000e778: 05853000 streq r3, [r5] <== NOT EXECUTED
uint32_t *_fval_percentage
)
{
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
3000e77c: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
* This looks odd but gives the results the proper precision.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
3000e780: e59fc044 ldr ip, [pc, #68] ; 3000e7cc <_Timestamp64_Divide+0x70><== NOT EXECUTED 3000e784: e5906000 ldr r6, [r0] <== NOT EXECUTED 3000e788: e590e004 ldr lr, [r0, #4] <== NOT EXECUTED 3000e78c: e0810c96 umull r0, r1, r6, ip <== NOT EXECUTED 3000e790: e0211e9c mla r1, ip, lr, r1 <== NOT EXECUTED 3000e794: eb0037c5 bl 3001c6b0 <__divdi3> <== NOT EXECUTED
*_ival_percentage = answer / 1000;
3000e798: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000e79c: e3a03000 mov r3, #0 <== NOT EXECUTED
* This looks odd but gives the results the proper precision.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
3000e7a0: e1a07000 mov r7, r0 <== NOT EXECUTED 3000e7a4: e1a06001 mov r6, r1 <== NOT EXECUTED
*_ival_percentage = answer / 1000;
3000e7a8: eb0037c0 bl 3001c6b0 <__divdi3> <== NOT EXECUTED
*_fval_percentage = answer % 1000;
3000e7ac: e1a01006 mov r1, r6 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
3000e7b0: e5840000 str r0, [r4] <== NOT EXECUTED
*_fval_percentage = answer % 1000;
3000e7b4: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED
3000e7b8: e1a00007 mov r0, r7 <== NOT EXECUTED
3000e7bc: e3a03000 mov r3, #0 <== NOT EXECUTED
3000e7c0: eb0038f5 bl 3001cb9c <__moddi3> <== NOT EXECUTED
3000e7c4: e5850000 str r0, [r5] <== NOT EXECUTED
3000e7c8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30010bc4 <_User_extensions_Remove_set>:
#include <rtems/score/userextimpl.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
30010bc4: e92d4010 push {r4, lr}
30010bc8: e1a04000 mov r4, r0
_Chain_Extract( &the_extension->Node );
30010bcc: eb0010d1 bl 30014f18 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
30010bd0: e5943024 ldr r3, [r4, #36] ; 0x24
30010bd4: e3530000 cmp r3, #0
30010bd8: 08bd8010 popeq {r4, pc}
_Chain_Extract( &the_extension->Switch.Node );
30010bdc: e2840008 add r0, r4, #8 <== NOT EXECUTED
}
30010be0: e8bd4010 pop {r4, lr} <== NOT EXECUTED
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
_Chain_Extract( &the_extension->Switch.Node );
30010be4: ea0010cb b 30014f18 <_Chain_Extract> <== NOT EXECUTED
3000d220 <_User_extensions_Thread_exitted_visitor>:
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
User_extensions_thread_exitted_extension callout = callouts->thread_exitted;
3000d220: e5923018 ldr r3, [r2, #24]
void _User_extensions_Thread_exitted_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
3000d224: e52de004 push {lr} ; (str lr, [sp, #-4]!)
User_extensions_thread_exitted_extension callout = callouts->thread_exitted;
if ( callout != NULL ) {
3000d228: e3530000 cmp r3, #0
3000d22c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
(*callout)( executing );
3000d230: e1a0e00f mov lr, pc <== NOT EXECUTED
3000d234: e12fff13 bx r3 <== NOT EXECUTED
3000d238: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ea08 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
3000ea08: e92d40f0 push {r4, r5, r6, r7, lr}
3000ea0c: e1a04000 mov r4, r0
3000ea10: e1a05002 mov r5, r2
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ea14: e10f3000 mrs r3, CPSR 3000ea18: e3832080 orr r2, r3, #128 ; 0x80 3000ea1c: e129f002 msr CPSR_fc, r2
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000ea20: e1a06000 mov r6, r0 3000ea24: e4962004 ldr r2, [r6], #4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
3000ea28: e1520006 cmp r2, r6
3000ea2c: 0a00001b beq 3000eaa0 <_Watchdog_Adjust+0x98>
switch ( direction ) {
3000ea30: e3510000 cmp r1, #0 <== NOT EXECUTED
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000ea34: 03a07001 moveq r7, #1 <== NOT EXECUTED
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
3000ea38: 0a000016 beq 3000ea98 <_Watchdog_Adjust+0x90> <== NOT EXECUTED 3000ea3c: e3510001 cmp r1, #1 <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
3000ea40: 05921010 ldreq r1, [r2, #16] <== NOT EXECUTED 3000ea44: 00815005 addeq r5, r1, r5 <== NOT EXECUTED
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
3000ea48: 1a000014 bne 3000eaa0 <_Watchdog_Adjust+0x98> <== NOT EXECUTED 3000ea4c: ea000004 b 3000ea64 <_Watchdog_Adjust+0x5c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000ea50: e5942000 ldr r2, [r4] <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
3000ea54: e5921010 ldr r1, [r2, #16] <== NOT EXECUTED 3000ea58: e1550001 cmp r5, r1 <== NOT EXECUTED 3000ea5c: 2a000002 bcs 3000ea6c <_Watchdog_Adjust+0x64> <== NOT EXECUTED
_Watchdog_First( header )->delta_interval -= units;
3000ea60: e0655001 rsb r5, r5, r1 <== NOT EXECUTED 3000ea64: e5825010 str r5, [r2, #16] <== NOT EXECUTED
break;
3000ea68: ea00000c b 3000eaa0 <_Watchdog_Adjust+0x98> <== NOT EXECUTED
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000ea6c: e5827010 str r7, [r2, #16] <== NOT EXECUTED
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
3000ea70: e0615005 rsb r5, r1, r5 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ea74: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
_Watchdog_Tickle( header );
3000ea78: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ea7c: eb000089 bl 3000eca8 <_Watchdog_Tickle> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ea80: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000ea84: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3000ea88: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000ea8c: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000ea90: e1520006 cmp r2, r6 <== NOT EXECUTED 3000ea94: 0a000001 beq 3000eaa0 <_Watchdog_Adjust+0x98> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000ea98: e3550000 cmp r5, #0 <== NOT EXECUTED 3000ea9c: 1affffeb bne 3000ea50 <_Watchdog_Adjust+0x48> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000eaa0: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
3000eaa4: e8bd80f0 pop {r4, r5, r6, r7, pc}
3001d400 <_Watchdog_Adjust_to_chain>:
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
3001d400: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001d404: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3001d408: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3001d40c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/*
* The first set happens in less than units, so take all of them
* off the chain and adjust units to reflect this.
*/
units -= first->delta_interval;
first->delta_interval = 0;
3001d410: e3a08000 mov r8, #0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3001d414: e2805004 add r5, r0, #4 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
3001d418: e2827004 add r7, r2, #4 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3001d41c: e5903000 ldr r3, [r0] <== NOT EXECUTED
Watchdog_Control *first;
_ISR_Disable( level );
while ( 1 ) {
if ( _Chain_Is_empty( header ) ) {
3001d420: e1530005 cmp r3, r5 <== NOT EXECUTED 3001d424: 0a000018 beq 3001d48c <_Watchdog_Adjust_to_chain+0x8c> <== NOT EXECUTED
/*
* If it is longer than "units" until the first element on the chain
* fires, then bump it and quit.
*/
if ( units < first->delta_interval ) {
3001d428: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001d42c: e151000c cmp r1, ip <== NOT EXECUTED
first->delta_interval -= units;
3001d430: 3061100c rsbcc r1, r1, ip <== NOT EXECUTED 3001d434: 35831010 strcc r1, [r3, #16] <== NOT EXECUTED
break;
3001d438: 3a000013 bcc 3001d48c <_Watchdog_Adjust_to_chain+0x8c> <== NOT EXECUTED
/*
* The first set happens in less than units, so take all of them
* off the chain and adjust units to reflect this.
*/
units -= first->delta_interval;
3001d43c: e06c1001 rsb r1, ip, r1 <== NOT EXECUTED
first->delta_interval = 0;
3001d440: e5838010 str r8, [r3, #16] <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3001d444: e8931040 ldm r3, {r6, ip} <== NOT EXECUTED
next->previous = previous;
3001d448: e586c004 str ip, [r6, #4] <== NOT EXECUTED
previous->next = next;
3001d44c: e58c6000 str r6, [ip] <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3001d450: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
the_node->next = tail;
3001d454: e5837000 str r7, [r3] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node;
3001d458: e58c3000 str r3, [ip] <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
3001d45c: e5823008 str r3, [r2, #8] <== NOT EXECUTED
old_last->next = the_node; the_node->previous = old_last;
3001d460: e583c004 str ip, [r3, #4] <== NOT EXECUTED
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3001d464: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3001d468: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED 3001d46c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3001d470: e5903000 ldr r3, [r0] <== NOT EXECUTED
_Chain_Extract_unprotected( &first->Node );
_Chain_Append_unprotected( to_fire, &first->Node );
_ISR_Flash( level );
if ( _Chain_Is_empty( header ) )
3001d474: e1530005 cmp r3, r5 <== NOT EXECUTED 3001d478: 0affffe7 beq 3001d41c <_Watchdog_Adjust_to_chain+0x1c> <== NOT EXECUTED
break;
first = _Watchdog_First( header );
if ( first->delta_interval != 0 )
3001d47c: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001d480: e35c0000 cmp ip, #0 <== NOT EXECUTED 3001d484: 0affffee beq 3001d444 <_Watchdog_Adjust_to_chain+0x44> <== NOT EXECUTED 3001d488: eaffffe3 b 3001d41c <_Watchdog_Adjust_to_chain+0x1c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001d48c: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
break;
}
}
_ISR_Enable( level );
}
3001d490: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000e564 <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
3000e564: e92d401f push {r0, r1, r2, r3, r4, lr} <== NOT EXECUTED
3000e568: e1a03001 mov r3, r1 <== NOT EXECUTED
printk(
3000e56c: e2501000 subs r1, r0, #0 <== NOT EXECUTED
3000e570: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
3000e574: 059f1034 ldreq r1, [pc, #52] ; 3000e5b0 <_Watchdog_Report+0x4c><== NOT EXECUTED
3000e578: e88d0009 stm sp, {r0, r3} <== NOT EXECUTED
3000e57c: e593001c ldr r0, [r3, #28] <== NOT EXECUTED
3000e580: 01a02001 moveq r2, r1 <== NOT EXECUTED
3000e584: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
3000e588: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
3000e58c: 159f2020 ldrne r2, [pc, #32] ; 3000e5b4 <_Watchdog_Report+0x50><== NOT EXECUTED
3000e590: e58d000c str r0, [sp, #12] <== NOT EXECUTED
3000e594: e5930024 ldr r0, [r3, #36] ; 0x24 <== NOT EXECUTED
3000e598: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
3000e59c: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
3000e5a0: e59f0010 ldr r0, [pc, #16] ; 3000e5b8 <_Watchdog_Report+0x54><== NOT EXECUTED
3000e5a4: ebffe570 bl 30007b6c <printk> <== NOT EXECUTED
watch,
watch->routine,
watch->id,
watch->user_data
);
}
3000e5a8: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3000e5ac: e8bd8000 pop {pc} <== NOT EXECUTED
3000e4e8 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
3000e4e8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000e4ec: e1a04000 mov r4, r0 <== NOT EXECUTED
3000e4f0: e1a05001 mov r5, r1 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000e4f4: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000e4f8: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000e4fc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
3000e500: e59f0050 ldr r0, [pc, #80] ; 3000e558 <_Watchdog_Report_chain+0x70><== NOT EXECUTED 3000e504: e1a02005 mov r2, r5 <== NOT EXECUTED 3000e508: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e50c: ebffe596 bl 30007b6c <printk> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000e510: e4957004 ldr r7, [r5], #4 <== NOT EXECUTED
if ( !_Chain_Is_empty( header ) ) {
3000e514: e1570005 cmp r7, r5 <== NOT EXECUTED 3000e518: 1a000004 bne 3000e530 <_Watchdog_Report_chain+0x48> <== NOT EXECUTED 3000e51c: ea000009 b 3000e548 <_Watchdog_Report_chain+0x60> <== NOT EXECUTED
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
3000e520: e1a01007 mov r1, r7 <== NOT EXECUTED 3000e524: e3a00000 mov r0, #0 <== NOT EXECUTED 3000e528: eb00000d bl 3000e564 <_Watchdog_Report> <== NOT EXECUTED
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
node != _Chain_Tail(header) ;
node = node->next )
3000e52c: e5977000 ldr r7, [r7] <== NOT EXECUTED
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
3000e530: e1570005 cmp r7, r5 <== NOT EXECUTED 3000e534: 1afffff9 bne 3000e520 <_Watchdog_Report_chain+0x38> <== NOT EXECUTED
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
3000e538: e59f001c ldr r0, [pc, #28] ; 3000e55c <_Watchdog_Report_chain+0x74><== NOT EXECUTED 3000e53c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000e540: ebffe589 bl 30007b6c <printk> <== NOT EXECUTED 3000e544: ea000001 b 3000e550 <_Watchdog_Report_chain+0x68> <== NOT EXECUTED
} else {
printk( "Chain is empty\n" );
3000e548: e59f0010 ldr r0, [pc, #16] ; 3000e560 <_Watchdog_Report_chain+0x78><== NOT EXECUTED 3000e54c: ebffe586 bl 30007b6c <printk> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000e550: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
}
_ISR_Enable( level );
}
3000e554: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000d570 <_Watchdog_Tickle>:
#include <rtems/score/watchdog.h>
void _Watchdog_Tickle(
Chain_Control *header
)
{
3000d570: e92d40f0 push {r4, r5, r6, r7, lr}
3000d574: e1a06000 mov r6, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d578: e10f7000 mrs r7, CPSR 3000d57c: e3873080 orr r3, r7, #128 ; 0x80 3000d580: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000d584: e1a05000 mov r5, r0 3000d588: e4954004 ldr r4, [r5], #4
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000d58c: e1540005 cmp r4, r5
3000d590: 0a000015 beq 3000d5ec <_Watchdog_Tickle+0x7c>
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
3000d594: e5943010 ldr r3, [r4, #16] 3000d598: e3530000 cmp r3, #0
3000d59c: 0a000003 beq 3000d5b0 <_Watchdog_Tickle+0x40>
the_watchdog->delta_interval--;
3000d5a0: e2433001 sub r3, r3, #1 3000d5a4: e5843010 str r3, [r4, #16]
if ( the_watchdog->delta_interval != 0 )
3000d5a8: e3530000 cmp r3, #0
3000d5ac: 1a00000e bne 3000d5ec <_Watchdog_Tickle+0x7c>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
3000d5b0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d5b4: ebffffc4 bl 3000d4cc <_Watchdog_Remove> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d5b8: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
switch( watchdog_state ) {
3000d5bc: e3500002 cmp r0, #2 <== NOT EXECUTED
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
3000d5c0: 05940020 ldreq r0, [r4, #32] <== NOT EXECUTED 3000d5c4: 05941024 ldreq r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000d5c8: 01a0e00f moveq lr, pc <== NOT EXECUTED 3000d5cc: 0594f01c ldreq pc, [r4, #28] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000d5d0: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3000d5d4: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3000d5d8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000d5dc: e5964000 ldr r4, [r6] <== NOT EXECUTED
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
3000d5e0: e1540005 cmp r4, r5 <== NOT EXECUTED
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
3000d5e4: 15943010 ldrne r3, [r4, #16] <== NOT EXECUTED 3000d5e8: 1affffee bne 3000d5a8 <_Watchdog_Tickle+0x38> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d5ec: e129f007 msr CPSR_fc, r7
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000d5f0: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000d71c <_Workspace_Allocate_or_fatal_error>:
3000d71c: e3a02000 mov r2, #0
}
void *_Workspace_Allocate_or_fatal_error(
size_t size
)
{
3000d720: e1a01000 mov r1, r0
3000d724: e52de004 push {lr} ; (str lr, [sp, #-4]!)
3000d728: e59f0018 ldr r0, [pc, #24] ; 3000d748 <_Workspace_Allocate_or_fatal_error+0x2c>
3000d72c: e1a03002 mov r3, r2
3000d730: eb000669 bl 3000f0dc <_Heap_Allocate_aligned_with_boundary>
__builtin_return_address( 1 ),
memory
);
#endif
if ( memory == NULL )
3000d734: e3500000 cmp r0, #0
3000d738: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
_Internal_error_Occurred(
3000d73c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000d740: e3a02003 mov r2, #3 <== NOT EXECUTED 3000d744: ebfff767 bl 3000b4e8 <_Internal_error_Occurred> <== NOT EXECUTED
3000b118 <check_and_merge.part.1>:
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
if (b->begin < a->begin) {
3000b118: e592c018 ldr ip, [r2, #24] <== NOT EXECUTED
return rtems_rbheap_chunk_of_node(
_RBTree_Next_unprotected(&chunk->tree_node, dir)
);
}
static void check_and_merge(
3000b11c: e92d4010 push {r4, lr} <== NOT EXECUTED
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
if (b->begin < a->begin) {
3000b120: e5934018 ldr r4, [r3, #24] <== NOT EXECUTED 3000b124: e154000c cmp r4, ip <== NOT EXECUTED 3000b128: 31a0c002 movcc ip, r2 <== NOT EXECUTED 3000b12c: 31a02003 movcc r2, r3 <== NOT EXECUTED 3000b130: 31a0300c movcc r3, ip <== NOT EXECUTED
a = b;
b = t;
}
a->size += b->size;
3000b134: e592401c ldr r4, [r2, #28] <== NOT EXECUTED 3000b138: e593c01c ldr ip, [r3, #28] <== NOT EXECUTED 3000b13c: e084c00c add ip, r4, ip <== NOT EXECUTED 3000b140: e582c01c str ip, [r2, #28] <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3000b144: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
3000b148: e593c000 ldr ip, [r3] <== NOT EXECUTED
previous = the_node->previous; next->previous = previous; previous->next = next;
3000b14c: e582c000 str ip, [r2] <== NOT EXECUTED
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
3000b150: e58c2004 str r2, [ip, #4] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b154: e5902000 ldr r2, [r0] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b158: e5830004 str r0, [r3, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b15c: e5803000 str r3, [r0] <== NOT EXECUTED
rtems_chain_extract_unprotected(&b->chain_node);
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
3000b160: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b164: e2831008 add r1, r3, #8 <== NOT EXECUTED
the_node->next = before_node;
3000b168: e5832000 str r2, [r3] <== NOT EXECUTED
before_node->previous = the_node;
3000b16c: e5823004 str r3, [r2, #4] <== NOT EXECUTED
} }
3000b170: e8bd4010 pop {r4, lr} <== NOT EXECUTED
}
a->size += b->size;
rtems_chain_extract_unprotected(&b->chain_node);
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
3000b174: ea00065c b 3000caec <_RBTree_Extract_unprotected> <== NOT EXECUTED
3000b108 <chunk_compare>:
static int chunk_compare(const rtems_rbtree_node *a, const rtems_rbtree_node *b)
{
const rtems_rbheap_chunk *left = rtems_rbheap_chunk_of_node(a);
const rtems_rbheap_chunk *right = rtems_rbheap_chunk_of_node(b);
return (int) (left->begin - right->begin);
3000b108: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 3000b10c: e5910010 ldr r0, [r1, #16] <== NOT EXECUTED
}
3000b110: e0600003 rsb r0, r0, r3 <== NOT EXECUTED 3000b114: e12fff1e bx lr <== NOT EXECUTED
30011020 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
30011020: e92d41f3 push {r0, r1, r4, r5, r6, r7, r8, lr}
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
30011024: e2508000 subs r8, r0, #0
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
30011028: e1a04001 mov r4, r1 3001102c: e1a06003 mov r6, r3
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30011030: 03a00003 moveq r0, #3
)
{
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
30011034: 0a000024 beq 300110cc <rtems_barrier_create+0xac>
return RTEMS_INVALID_NAME;
if ( !id )
30011038: e3530000 cmp r3, #0
return RTEMS_INVALID_ADDRESS;
3001103c: 03a00009 moveq r0, #9
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30011040: 0a000021 beq 300110cc <rtems_barrier_create+0xac>
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
30011044: e3110010 tst r1, #16
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
30011048: 03a03001 moveq r3, #1 3001104c: 058d3000 streq r3, [sp]
if ( !id )
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
30011050: 0a000004 beq 30011068 <rtems_barrier_create+0x48>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
30011054: e3a03000 mov r3, #0 <== NOT EXECUTED
if ( maximum_waiters == 0 )
30011058: e1520003 cmp r2, r3 <== NOT EXECUTED
if ( !id )
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
3001105c: e58d3000 str r3, [sp] <== NOT EXECUTED
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
30011060: 03a0000a moveq r0, #10 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
30011064: 0a000018 beq 300110cc <rtems_barrier_create+0xac> <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
30011068: e59f3060 ldr r3, [pc, #96] ; 300110d0 <rtems_barrier_create+0xb0>
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
3001106c: e58d2004 str r2, [sp, #4] 30011070: e5932000 ldr r2, [r3]
++level;
30011074: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
30011078: e5832000 str r2, [r3]
* This function allocates a barrier control block from
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Allocate( void )
{
return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information );
3001107c: e59f7050 ldr r7, [pc, #80] ; 300110d4 <rtems_barrier_create+0xb4> 30011080: e1a00007 mov r0, r7 30011084: ebffeeff bl 3000cc88 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
30011088: e2505000 subs r5, r0, #0
3001108c: 1a000002 bne 3001109c <rtems_barrier_create+0x7c>
_Thread_Enable_dispatch();
30011090: ebfff381 bl 3000de9c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30011094: e3a00005 mov r0, #5 <== NOT EXECUTED 30011098: ea00000b b 300110cc <rtems_barrier_create+0xac> <== NOT EXECUTED
}
the_barrier->attribute_set = attribute_set;
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
3001109c: e2850014 add r0, r5, #20 300110a0: e1a0100d mov r1, sp
if ( !the_barrier ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
300110a4: e5854010 str r4, [r5, #16]
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
300110a8: eb0001e6 bl 30011848 <_CORE_barrier_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300110ac: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300110b0: e5953008 ldr r3, [r5, #8] 300110b4: e1d510b8 ldrh r1, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300110b8: e7825101 str r5, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
300110bc: e585800c str r8, [r5, #12]
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
300110c0: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
300110c4: ebfff374 bl 3000de9c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300110c8: e3a00000 mov r0, #0
}
300110cc: e8bd81fc pop {r2, r3, r4, r5, r6, r7, r8, pc}
3000b994 <rtems_build_id>:
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000b994: e1a00c00 lsl r0, r0, #24 <== NOT EXECUTED 3000b998: e1800d81 orr r0, r0, r1, lsl #27 <== NOT EXECUTED
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
3000b99c: e1800003 orr r0, r0, r3 <== NOT EXECUTED
uint32_t node,
uint32_t index
)
{
return _Objects_Build_id( api, class, node, index );
}
3000b9a0: e1800802 orr r0, r0, r2, lsl #16 <== NOT EXECUTED 3000b9a4: e12fff1e bx lr <== NOT EXECUTED
3000b9a8 <rtems_build_name>:
char C1,
char C2,
char C3,
char C4
)
{
3000b9a8: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000b9ac: e20118ff and r1, r1, #16711680 ; 0xff0000 <== NOT EXECUTED
char C1,
char C2,
char C3,
char C4
)
{
3000b9b0: e1a02402 lsl r2, r2, #8 <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000b9b4: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED 3000b9b8: e2022cff and r2, r2, #65280 ; 0xff00 <== NOT EXECUTED
char C1,
char C2,
char C3,
char C4
)
{
3000b9bc: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000b9c0: e1800002 orr r0, r0, r2 <== NOT EXECUTED
}
3000b9c4: e1800003 orr r0, r0, r3 <== NOT EXECUTED 3000b9c8: e12fff1e bx lr <== NOT EXECUTED
3000ae0c <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
3000ae0c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000ae10: e1a04002 mov r4, r2 <== NOT EXECUTED
3000ae14: e1a05003 mov r5, r3 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Append_with_empty_check( chain, node );
3000ae18: eb000143 bl 3000b32c <_Chain_Append_with_empty_check> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
3000ae1c: e3500000 cmp r0, #0 <== NOT EXECUTED
3000ae20: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000ae24: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ae28: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000ae2c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
3000ae30: eafffd99 b 3000a49c <rtems_event_send> <== NOT EXECUTED
3000ae34 <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
3000ae34: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000ae38: e1a04001 mov r4, r1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_get_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node **node
)
{
return _Chain_Get_with_empty_check( chain, node );
3000ae3c: e1a01003 mov r1, r3 <== NOT EXECUTED 3000ae40: e1a05002 mov r5, r2 <== NOT EXECUTED 3000ae44: eb000154 bl 3000b39c <_Chain_Get_with_empty_check> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
3000ae48: e3500000 cmp r0, #0 <== NOT EXECUTED
3000ae4c: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000ae50: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ae54: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000ae58: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
sc = rtems_event_send( task, events );
3000ae5c: eafffd8e b 3000a49c <rtems_event_send> <== NOT EXECUTED
3000ae60 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
3000ae60: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000ae64: e1a07000 mov r7, r0 <== NOT EXECUTED
3000ae68: e1a06001 mov r6, r1 <== NOT EXECUTED
3000ae6c: e1a05002 mov r5, r2 <== NOT EXECUTED
3000ae70: e1a08003 mov r8, r3 <== NOT EXECUTED
3000ae74: ea000006 b 3000ae94 <rtems_chain_get_with_wait+0x34> <== NOT EXECUTED
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
3000ae78: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ae7c: e1a01004 mov r1, r4 <== NOT EXECUTED 3000ae80: e1a02005 mov r2, r5 <== NOT EXECUTED 3000ae84: e1a0300d mov r3, sp <== NOT EXECUTED 3000ae88: ebfffd24 bl 3000a320 <rtems_event_receive> <== NOT EXECUTED
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
3000ae8c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ae90: 1a000004 bne 3000aea8 <rtems_chain_get_with_wait+0x48> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
3000ae94: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ae98: eb000153 bl 3000b3ec <_Chain_Get> <== NOT EXECUTED
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
3000ae9c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3000aea0: 0afffff4 beq 3000ae78 <rtems_chain_get_with_wait+0x18> <== NOT EXECUTED 3000aea4: e3a00000 mov r0, #0 <== NOT EXECUTED
timeout,
&out
);
}
*node_ptr = node;
3000aea8: e5884000 str r4, [r8] <== NOT EXECUTED
return sc;
}
3000aeac: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000aeb0 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
3000aeb0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000aeb4: e1a04002 mov r4, r2 <== NOT EXECUTED
3000aeb8: e1a05003 mov r5, r3 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Prepend_with_empty_check( chain, node );
3000aebc: eb000171 bl 3000b488 <_Chain_Prepend_with_empty_check> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
3000aec0: e3500000 cmp r0, #0 <== NOT EXECUTED
3000aec4: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000aec8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aecc: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000aed0: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
3000aed4: eafffd70 b 3000a49c <rtems_event_send> <== NOT EXECUTED
3000ac44 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
3000ac44: e92d4010 push {r4, lr} <== NOT EXECUTED
if ( !time_buffer )
3000ac48: e2514000 subs r4, r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000ac4c: 03a00009 moveq r0, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
if ( !time_buffer )
3000ac50: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
3000ac54: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ac58: 1a000002 bne 3000ac68 <rtems_clock_get+0x24> <== NOT EXECUTED
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
3000ac5c: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
3000ac60: e8bd4010 pop {r4, lr} <== NOT EXECUTED
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
3000ac64: ea000034 b 3000ad3c <rtems_clock_get_tod> <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
3000ac68: e3500001 cmp r0, #1 <== NOT EXECUTED 3000ac6c: 1a000002 bne 3000ac7c <rtems_clock_get+0x38> <== NOT EXECUTED
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
3000ac70: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
3000ac74: e8bd4010 pop {r4, lr} <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
3000ac78: ea000010 b 3000acc0 <rtems_clock_get_seconds_since_epoch> <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
3000ac7c: e3500002 cmp r0, #2 <== NOT EXECUTED 3000ac80: 1a000001 bne 3000ac8c <rtems_clock_get+0x48> <== NOT EXECUTED
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
3000ac84: eb000028 bl 3000ad2c <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED 3000ac88: ea000002 b 3000ac98 <rtems_clock_get+0x54> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
3000ac8c: e3500003 cmp r0, #3 <== NOT EXECUTED 3000ac90: 1a000003 bne 3000aca4 <rtems_clock_get+0x60> <== NOT EXECUTED
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
3000ac94: eb00001c bl 3000ad0c <rtems_clock_get_ticks_per_second> <== NOT EXECUTED 3000ac98: e5840000 str r0, [r4] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000ac9c: e3a00000 mov r0, #0 <== NOT EXECUTED
3000aca0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
3000aca4: e3500004 cmp r0, #4 <== NOT EXECUTED 3000aca8: 1a000002 bne 3000acb8 <rtems_clock_get+0x74> <== NOT EXECUTED
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
3000acac: e1a00004 mov r0, r4 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
}
3000acb0: e8bd4010 pop {r4, lr} <== NOT EXECUTED
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
3000acb4: ea000059 b 3000ae20 <rtems_clock_get_tod_timeval> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
3000acb8: e3a0000a mov r0, #10 <== NOT EXECUTED
}
3000acbc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000aabc <rtems_clock_get_seconds_since_epoch>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
3000aabc: e92d4010 push {r4, lr}
if ( !the_interval )
3000aac0: e2504000 subs r4, r0, #0
return RTEMS_INVALID_ADDRESS;
3000aac4: 03a00009 moveq r0, #9
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
3000aac8: 08bd8010 popeq {r4, pc}
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
3000aacc: e59f302c ldr r3, [pc, #44] ; 3000ab00 <rtems_clock_get_seconds_since_epoch+0x44> 3000aad0: e5d32014 ldrb r2, [r3, #20] 3000aad4: e3520000 cmp r2, #0
3000aad8: 0a000006 beq 3000aaf8 <rtems_clock_get_seconds_since_epoch+0x3c>
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
3000aadc: e8930003 ldm r3, {r0, r1}
3000aae0: e59f201c ldr r2, [pc, #28] ; 3000ab04 <rtems_clock_get_seconds_since_epoch+0x48>
3000aae4: e3a03000 mov r3, #0
3000aae8: eb0046f0 bl 3001c6b0 <__divdi3>
3000aaec: e5840000 str r0, [r4]
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch();
return RTEMS_SUCCESSFUL;
3000aaf0: e3a00000 mov r0, #0
3000aaf4: e8bd8010 pop {r4, pc}
{
if ( !the_interval )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
3000aaf8: e3a0000b mov r0, #11 <== NOT EXECUTED
*the_interval = _TOD_Seconds_since_epoch();
return RTEMS_SUCCESSFUL;
}
3000aafc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30009b9c <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 /
30009b9c: e59f3010 ldr r3, [pc, #16] ; 30009bb4 <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)
{
30009ba0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return TOD_MICROSECONDS_PER_SECOND /
30009ba4: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 30009ba8: e59f0008 ldr r0, [pc, #8] ; 30009bb8 <rtems_clock_get_ticks_per_second+0x1c><== NOT EXECUTED 30009bac: eb004014 bl 30019c04 <__aeabi_uidiv> <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick();
}
30009bb0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009bbc <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;
30009bbc: e59f3004 ldr r3, [pc, #4] ; 30009bc8 <rtems_clock_get_ticks_since_boot+0xc><== NOT EXECUTED 30009bc0: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
30009bc4: e12fff1e bx lr <== NOT EXECUTED
30016e9c <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
30016e9c: e92d40d3 push {r0, r1, r4, r6, r7, lr} <== NOT EXECUTED
if ( !time )
30016ea0: e2504000 subs r4, r0, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30016ea4: 03a00009 moveq r0, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
30016ea8: 0a000017 beq 30016f0c <rtems_clock_get_tod_timeval+0x70> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
30016eac: e59f105c ldr r1, [pc, #92] ; 30016f10 <rtems_clock_get_tod_timeval+0x74><== NOT EXECUTED 30016eb0: e5d13014 ldrb r3, [r1, #20] <== NOT EXECUTED 30016eb4: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
30016eb8: 03a0000b moveq r0, #11 <== NOT EXECUTED
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD.is_set )
30016ebc: 0a000012 beq 30016f0c <rtems_clock_get_tod_timeval+0x70> <== NOT EXECUTED
)
{
Timestamp_Control snapshot_as_timestamp;
Timestamp_Control *snapshot_as_timestamp_ptr;
snapshot_as_timestamp_ptr =
30016ec0: e1a0000d mov r0, sp <== NOT EXECUTED 30016ec4: ebffd890 bl 3000d10c <_TOD_Get_with_nanoseconds> <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timeval(
const Timestamp64_Control *_timestamp,
struct timeval *_timeval
)
{
_timeval->tv_sec = (time_t) (*_timestamp / 1000000000U);
30016ec8: e59f2044 ldr r2, [pc, #68] ; 30016f14 <rtems_clock_get_tod_timeval+0x78><== NOT EXECUTED
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
30016ecc: e89000c0 ldm r0, {r6, r7} <== NOT EXECUTED
30016ed0: e3a03000 mov r3, #0 <== NOT EXECUTED
30016ed4: e1a00006 mov r0, r6 <== NOT EXECUTED
30016ed8: e1a01007 mov r1, r7 <== NOT EXECUTED
30016edc: ebffba54 bl 30005834 <__divdi3> <== NOT EXECUTED
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
30016ee0: e59f202c ldr r2, [pc, #44] ; 30016f14 <rtems_clock_get_tod_timeval+0x78><== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timeval(
const Timestamp64_Control *_timestamp,
struct timeval *_timeval
)
{
_timeval->tv_sec = (time_t) (*_timestamp / 1000000000U);
30016ee4: e5840000 str r0, [r4] <== NOT EXECUTED
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
30016ee8: e3a03000 mov r3, #0 <== NOT EXECUTED 30016eec: e1a00006 mov r0, r6 <== NOT EXECUTED 30016ef0: e1a01007 mov r1, r7 <== NOT EXECUTED 30016ef4: eb004c85 bl 3002a110 <__moddi3> <== NOT EXECUTED 30016ef8: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 30016efc: e3a03000 mov r3, #0 <== NOT EXECUTED 30016f00: ebffba4b bl 30005834 <__divdi3> <== NOT EXECUTED 30016f04: e5840004 str r0, [r4, #4] <== NOT EXECUTED
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
30016f08: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30016f0c: e8bd80dc pop {r2, r3, r4, r6, r7, pc} <== NOT EXECUTED
30025bb0 <rtems_clock_get_uptime>:
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
30025bb0: e3500000 cmp r0, #0 <== NOT EXECUTED
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
30025bb4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !uptime )
30025bb8: 0a000002 beq 30025bc8 <rtems_clock_get_uptime+0x18> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime_as_timespec( uptime );
30025bbc: eb000234 bl 30026494 <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30025bc0: e3a00000 mov r0, #0 <== NOT EXECUTED
30025bc4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
return RTEMS_INVALID_ADDRESS;
30025bc8: e3a00009 mov r0, #9 <== NOT EXECUTED
_TOD_Get_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
}
30025bcc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30015e68 <rtems_clock_get_uptime_seconds>:
#endif
#include <rtems/rtems/clock.h>
time_t rtems_clock_get_uptime_seconds( void )
{
30015e68: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30015e6c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30015e70: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30015e74: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
Timestamp_Control snapshot_as_timestamp;
struct timespec snapshot_as_timespec;
ISR_Level level;
_ISR_Disable( level );
snapshot_as_timestamp = _TOD.uptime;
30015e78: e59f2018 ldr r2, [pc, #24] ; 30015e98 <rtems_clock_get_uptime_seconds+0x30><== NOT EXECUTED
30015e7c: e2821008 add r1, r2, #8 <== NOT EXECUTED
30015e80: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30015e84: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30015e88: e59f200c ldr r2, [pc, #12] ; 30015e9c <rtems_clock_get_uptime_seconds+0x34><== NOT EXECUTED 30015e8c: e3a03000 mov r3, #0 <== NOT EXECUTED 30015e90: eb005839 bl 3002bf7c <__divdi3> <== NOT EXECUTED
_ISR_Enable( level );
_Timestamp_To_timespec( &snapshot_as_timestamp, &snapshot_as_timespec );
return snapshot_as_timespec.tv_sec;
}
30015e94: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30015ea0 <rtems_clock_get_uptime_timeval>:
#endif
#include <rtems/rtems/clock.h>
void rtems_clock_get_uptime_timeval( struct timeval *uptime )
{
30015ea0: e92d40d3 push {r0, r1, r4, r6, r7, lr} <== NOT EXECUTED
30015ea4: e1a04000 mov r4, r0 <== NOT EXECUTED
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
30015ea8: e59f1048 ldr r1, [pc, #72] ; 30015ef8 <rtems_clock_get_uptime_timeval+0x58><== NOT EXECUTED 30015eac: e1a0000d mov r0, sp <== NOT EXECUTED 30015eb0: eb001174 bl 3001a488 <_TOD_Get_with_nanoseconds> <== NOT EXECUTED
Timestamp_Control snapshot_as_timestamp;
_TOD_Get_uptime( &snapshot_as_timestamp );
_Timestamp_To_timeval( &snapshot_as_timestamp, uptime );
30015eb4: e89d00c0 ldm sp, {r6, r7} <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timeval(
const Timestamp64_Control *_timestamp,
struct timeval *_timeval
)
{
_timeval->tv_sec = (time_t) (*_timestamp / 1000000000U);
30015eb8: e59f203c ldr r2, [pc, #60] ; 30015efc <rtems_clock_get_uptime_timeval+0x5c><== NOT EXECUTED 30015ebc: e3a03000 mov r3, #0 <== NOT EXECUTED 30015ec0: e1a00006 mov r0, r6 <== NOT EXECUTED 30015ec4: e1a01007 mov r1, r7 <== NOT EXECUTED 30015ec8: eb00582b bl 3002bf7c <__divdi3> <== NOT EXECUTED
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
30015ecc: e59f2028 ldr r2, [pc, #40] ; 30015efc <rtems_clock_get_uptime_timeval+0x5c><== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timeval(
const Timestamp64_Control *_timestamp,
struct timeval *_timeval
)
{
_timeval->tv_sec = (time_t) (*_timestamp / 1000000000U);
30015ed0: e5840000 str r0, [r4] <== NOT EXECUTED
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
30015ed4: e3a03000 mov r3, #0 <== NOT EXECUTED 30015ed8: e1a00006 mov r0, r6 <== NOT EXECUTED 30015edc: e1a01007 mov r1, r7 <== NOT EXECUTED 30015ee0: eb005960 bl 3002c468 <__moddi3> <== NOT EXECUTED 30015ee4: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 30015ee8: e3a03000 mov r3, #0 <== NOT EXECUTED 30015eec: eb005822 bl 3002bf7c <__divdi3> <== NOT EXECUTED 30015ef0: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
30015ef4: e8bd80dc pop {r2, r3, r4, r6, r7, pc} <== NOT EXECUTED
30009be8 <rtems_clock_tick>:
#include <rtems/score/thread.h>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_tick( void )
{
30009be8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
_TOD_Tickle_ticks();
30009bec: eb000521 bl 3000b078 <_TOD_Tickle_ticks>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{
_Watchdog_Tickle( &_Watchdog_Ticks_chain );
30009bf0: e59f0034 ldr r0, [pc, #52] ; 30009c2c <rtems_clock_tick+0x44> 30009bf4: eb000e5d bl 3000d570 <_Watchdog_Tickle>
* scheduler which support standard RTEMS features, this includes
* time-slicing management.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Tick( void )
{
_Scheduler.Operations.tick();
30009bf8: e59f3030 ldr r3, [pc, #48] ; 30009c30 <rtems_clock_tick+0x48> 30009bfc: e1a0e00f mov lr, pc 30009c00: e593f038 ldr pc, [r3, #56] ; 0x38
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
return ( _Thread_Dispatch_necessary );
30009c04: e59f3028 ldr r3, [pc, #40] ; 30009c34 <rtems_clock_tick+0x4c> 30009c08: e5d33004 ldrb r3, [r3, #4]
_Watchdog_Tickle_ticks();
_Scheduler_Tick();
if ( _Thread_Is_context_switch_necessary() &&
30009c0c: e3530000 cmp r3, #0
30009c10: 0a000003 beq 30009c24 <rtems_clock_tick+0x3c>
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
30009c14: e59f301c ldr r3, [pc, #28] ; 30009c38 <rtems_clock_tick+0x50><== NOT EXECUTED 30009c18: e5933000 ldr r3, [r3] <== NOT EXECUTED 30009c1c: e3530000 cmp r3, #0 <== NOT EXECUTED
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
30009c20: 0b000a9d bleq 3000c69c <_Thread_Dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
30009c24: e3a00000 mov r0, #0
30009c28: e49df004 pop {pc} ; (ldr pc, [sp], #4)
3000df50 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000df50: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Extension_Control *the_extension;
if ( !id )
3000df54: e2527000 subs r7, r2, #0
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000df58: e1a05000 mov r5, r0 3000df5c: e1a08001 mov r8, r1
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000df60: 03a00009 moveq r0, #9
rtems_id *id
)
{
Extension_Control *the_extension;
if ( !id )
3000df64: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
3000df68: e3550000 cmp r5, #0
3000df6c: 0a00001c beq 3000dfe4 <rtems_extension_create+0x94>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000df70: e59f3074 ldr r3, [pc, #116] ; 3000dfec <rtems_extension_create+0x9c> 3000df74: e5932000 ldr r2, [r3]
++level;
3000df78: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000df7c: e5832000 str r2, [r3]
#ifndef __EXTENSION_MANAGER_inl
#define __EXTENSION_MANAGER_inl
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )
{
return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
3000df80: e59f6068 ldr r6, [pc, #104] ; 3000dff0 <rtems_extension_create+0xa0> 3000df84: e1a00006 mov r0, r6 3000df88: eb000358 bl 3000ecf0 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
3000df8c: e2504000 subs r4, r0, #0
3000df90: 1a000002 bne 3000dfa0 <rtems_extension_create+0x50>
_Thread_Enable_dispatch();
3000df94: eb00081e bl 30010014 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000df98: e3a00005 mov r0, #5 <== NOT EXECUTED
3000df9c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
3000dfa0: e284c024 add ip, r4, #36 ; 0x24
3000dfa4: e1a0e008 mov lr, r8
3000dfa8: e8be000f ldm lr!, {r0, r1, r2, r3}
3000dfac: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000dfb0: e89e000f ldm lr, {r0, r1, r2, r3}
3000dfb4: e88c000f stm ip, {r0, r1, r2, r3}
_User_extensions_Add_set( extension );
3000dfb8: e2840010 add r0, r4, #16 3000dfbc: eb000a72 bl 3001098c <_User_extensions_Add_set>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000dfc0: e596201c ldr r2, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000dfc4: e5943008 ldr r3, [r4, #8] 3000dfc8: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000dfcc: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000dfd0: e584500c str r5, [r4, #12]
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
3000dfd4: e5873000 str r3, [r7]
_Thread_Enable_dispatch();
3000dfd8: eb00080d bl 30010014 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000dfdc: e3a00000 mov r0, #0
3000dfe0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000dfe4: e3a00003 mov r0, #3 <== NOT EXECUTED
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000dfe8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c654 <rtems_extension_ident>:
rtems_status_code rtems_extension_ident(
rtems_name name,
rtems_id *id
)
{
3000c654: e1a02000 mov r2, r0 <== NOT EXECUTED
3000c658: e1a03001 mov r3, r1 <== NOT EXECUTED
3000c65c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
status = _Objects_Name_to_id_u32(
3000c660: e1a01002 mov r1, r2 <== NOT EXECUTED 3000c664: e59f0010 ldr r0, [pc, #16] ; 3000c67c <rtems_extension_ident+0x28><== NOT EXECUTED 3000c668: e3e02102 mvn r2, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000c66c: eb00049f bl 3000d8f0 <_Objects_Name_to_id_u32> <== NOT EXECUTED
OBJECTS_SEARCH_LOCAL_NODE,
id
);
return _Status_Object_name_errors_to_status[ status ];
}
3000c670: e59f3008 ldr r3, [pc, #8] ; 3000c680 <rtems_extension_ident+0x2c><== NOT EXECUTED
3000c674: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
3000c678: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c580 <rtems_get_version_string>:
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
}
3000c580: e59f0000 ldr r0, [pc] ; 3000c588 <rtems_get_version_string+0x8><== NOT EXECUTED 3000c584: e12fff1e bx lr <== NOT EXECUTED
3000ab44 <rtems_interrupt_disable>:
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ab44: e10f0000 mrs r0, CPSR <== NOT EXECUTED 3000ab48: e3803080 orr r3, r0, #128 ; 0x80 <== NOT EXECUTED 3000ab4c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_level previous_level;
_ISR_Disable( previous_level );
return previous_level;
}
3000ab50: e12fff1e bx lr <== NOT EXECUTED
3000ab54 <rtems_interrupt_enable>:
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ab54: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
void rtems_interrupt_enable(
rtems_interrupt_level previous_level
)
{
_ISR_Enable( previous_level );
}
3000ab58: e12fff1e bx lr <== NOT EXECUTED
3000ab5c <rtems_interrupt_flash>:
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000ab5c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000ab60: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 3000ab64: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
void rtems_interrupt_flash(
rtems_interrupt_level previous_level
)
{
_ISR_Flash( previous_level );
}
3000ab68: e12fff1e bx lr <== NOT EXECUTED
3000ab6c <rtems_interrupt_is_in_progress>:
#undef rtems_interrupt_is_in_progress
bool rtems_interrupt_is_in_progress( void )
{
return _ISR_Is_in_progress();
3000ab6c: e59f300c ldr r3, [pc, #12] ; 3000ab80 <rtems_interrupt_is_in_progress+0x14><== NOT EXECUTED 3000ab70: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
3000ab74: e2900000 adds r0, r0, #0 <== NOT EXECUTED 3000ab78: 13a00001 movne r0, #1 <== NOT EXECUTED 3000ab7c: e12fff1e bx lr <== NOT EXECUTED
3000ab84 <rtems_interrupt_level_body>:
Modes_Control rtems_interrupt_level_body(
uint32_t level
)
{
return RTEMS_INTERRUPT_LEVEL(level);
}
3000ab84: e2000080 and r0, r0, #128 ; 0x80 <== NOT EXECUTED 3000ab88: e12fff1e bx lr <== NOT EXECUTED
3001093c <rtems_io_close>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3001093c: e59fc044 ldr ip, [pc, #68] ; 30010988 <rtems_io_close+0x4c>
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010940: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010944: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010948: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
3001094c: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
30010950: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010954: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
30010958: e59fc02c ldr ip, [pc, #44] ; 3001098c <rtems_io_close+0x50> 3001095c: e3a04018 mov r4, #24 30010960: e59cc000 ldr ip, [ip] 30010964: e023c394 mla r3, r4, r3, ip 30010968: e5933008 ldr r3, [r3, #8]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
3001096c: e3530000 cmp r3, #0
30010970: 0a000002 beq 30010980 <rtems_io_close+0x44>
30010974: e1a0e00f mov lr, pc
30010978: e12fff13 bx r3
3001097c: e8bd8010 pop {r4, pc}
30010980: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010984: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30010990 <rtems_io_control>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010990: e59fc044 ldr ip, [pc, #68] ; 300109dc <rtems_io_control+0x4c>
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010994: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010998: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
3001099c: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300109a0: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
300109a4: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300109a8: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
300109ac: e59fc02c ldr ip, [pc, #44] ; 300109e0 <rtems_io_control+0x50> 300109b0: e3a04018 mov r4, #24 300109b4: e59cc000 ldr ip, [ip] 300109b8: e023c394 mla r3, r4, r3, ip 300109bc: e5933014 ldr r3, [r3, #20]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
300109c0: e3530000 cmp r3, #0
300109c4: 0a000002 beq 300109d4 <rtems_io_control+0x44>
300109c8: e1a0e00f mov lr, pc
300109cc: e12fff13 bx r3
300109d0: e8bd8010 pop {r4, pc}
300109d4: e1a00003 mov r0, r3 <== NOT EXECUTED
}
300109d8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300109e4 <rtems_io_open>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300109e4: e59fc044 ldr ip, [pc, #68] ; 30010a30 <rtems_io_open+0x4c>
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300109e8: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300109ec: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
300109f0: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300109f4: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
300109f8: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
300109fc: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
30010a00: e59fc02c ldr ip, [pc, #44] ; 30010a34 <rtems_io_open+0x50> 30010a04: e3a04018 mov r4, #24 30010a08: e59cc000 ldr ip, [ip] 30010a0c: e023c394 mla r3, r4, r3, ip 30010a10: e5933004 ldr r3, [r3, #4]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010a14: e3530000 cmp r3, #0
30010a18: 0a000002 beq 30010a28 <rtems_io_open+0x44>
30010a1c: e1a0e00f mov lr, pc
30010a20: e12fff13 bx r3
30010a24: e8bd8010 pop {r4, pc}
30010a28: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010a2c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30010a38 <rtems_io_read>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010a38: e59fc044 ldr ip, [pc, #68] ; 30010a84 <rtems_io_read+0x4c>
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010a3c: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010a40: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010a44: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010a48: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
30010a4c: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010a50: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
30010a54: e59fc02c ldr ip, [pc, #44] ; 30010a88 <rtems_io_read+0x50> 30010a58: e3a04018 mov r4, #24 30010a5c: e59cc000 ldr ip, [ip] 30010a60: e023c394 mla r3, r4, r3, ip 30010a64: e593300c ldr r3, [r3, #12]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010a68: e3530000 cmp r3, #0
30010a6c: 0a000002 beq 30010a7c <rtems_io_read+0x44>
30010a70: e1a0e00f mov lr, pc
30010a74: e12fff13 bx r3
30010a78: e8bd8010 pop {r4, pc}
30010a7c: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010a80: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000beb0 <rtems_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
)
{
3000beb0: e92d4010 push {r4, lr}
3000beb4: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000beb8: e59f0158 ldr r0, [pc, #344] ; 3000c018 <rtems_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;
3000bebc: e59f3158 ldr r3, [pc, #344] ; 3000c01c <rtems_io_register_driver+0x16c>
if ( rtems_interrupt_is_in_progress() )
3000bec0: e5900000 ldr r0, [r0]
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
3000bec4: e5933000 ldr r3, [r3]
if ( rtems_interrupt_is_in_progress() )
3000bec8: e3500000 cmp r0, #0
return RTEMS_CALLED_FROM_ISR;
3000becc: 13a00012 movne r0, #18
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000bed0: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
3000bed4: e3520000 cmp r2, #0
3000bed8: 0a000041 beq 3000bfe4 <rtems_io_register_driver+0x134>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
3000bedc: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
3000bee0: e5823000 str r3, [r2]
if ( driver_table == NULL )
3000bee4: 0a00003e beq 3000bfe4 <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;
3000bee8: e5910000 ldr r0, [r1] 3000beec: e3500000 cmp r0, #0
3000bef0: 1a00003f bne 3000bff4 <rtems_io_register_driver+0x144>
3000bef4: e5910004 ldr r0, [r1, #4] 3000bef8: e3500000 cmp r0, #0
3000befc: 1a00003c bne 3000bff4 <rtems_io_register_driver+0x144>
3000bf00: ea000037 b 3000bfe4 <rtems_io_register_driver+0x134> <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000bf04: e59f3114 ldr r3, [pc, #276] ; 3000c020 <rtems_io_register_driver+0x170> 3000bf08: e5930000 ldr r0, [r3]
++level;
3000bf0c: e2800001 add r0, r0, #1
_Thread_Dispatch_disable_level = level;
3000bf10: e5830000 str r0, [r3]
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
3000bf14: e3540000 cmp r4, #0 3000bf18: e59f0104 ldr r0, [pc, #260] ; 3000c024 <rtems_io_register_driver+0x174>
3000bf1c: 1a000010 bne 3000bf64 <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;
3000bf20: e59f30f4 ldr r3, [pc, #244] ; 3000c01c <rtems_io_register_driver+0x16c> 3000bf24: e593c000 ldr ip, [r3] 3000bf28: e5903000 ldr r3, [r0] 3000bf2c: ea000006 b 3000bf4c <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;
3000bf30: e5930000 ldr r0, [r3] 3000bf34: e3500000 cmp r0, #0
3000bf38: 1a000030 bne 3000c000 <rtems_io_register_driver+0x150>
3000bf3c: e5930004 ldr r0, [r3, #4] 3000bf40: e3500000 cmp r0, #0
3000bf44: 1a00002d bne 3000c000 <rtems_io_register_driver+0x150>
3000bf48: ea000001 b 3000bf54 <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 ) {
3000bf4c: e154000c cmp r4, ip
3000bf50: 1afffff6 bne 3000bf30 <rtems_io_register_driver+0x80>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
3000bf54: e154000c cmp r4, ip
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
3000bf58: e5824000 str r4, [r2]
if ( m != n )
3000bf5c: 1a000011 bne 3000bfa8 <rtems_io_register_driver+0xf8>
3000bf60: ea000029 b 3000c00c <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;
3000bf64: e3a03018 mov r3, #24 <== NOT EXECUTED 3000bf68: e0030394 mul r3, r4, r3 <== NOT EXECUTED 3000bf6c: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000bf70: e080c003 add ip, r0, r3 <== NOT EXECUTED
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000bf74: e7903003 ldr r3, [r0, r3] <== NOT EXECUTED 3000bf78: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bf7c: 13a03000 movne r3, #0 <== NOT EXECUTED 3000bf80: 1a000002 bne 3000bf90 <rtems_io_register_driver+0xe0> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
}
rtems_status_code rtems_io_register_driver(
3000bf84: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 3000bf88: e2733001 rsbs r3, r3, #1 <== NOT EXECUTED 3000bf8c: 33a03000 movcc r3, #0 <== NOT EXECUTED
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
3000bf90: e3530000 cmp r3, #0 <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
3000bf94: 15824000 strne r4, [r2] <== NOT EXECUTED
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
3000bf98: 1a000002 bne 3000bfa8 <rtems_io_register_driver+0xf8> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000bf9c: eb0007a2 bl 3000de2c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
3000bfa0: e3a0000c mov r0, #12 <== NOT EXECUTED
3000bfa4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
3000bfa8: e59f3074 ldr r3, [pc, #116] ; 3000c024 <rtems_io_register_driver+0x174>
3000bfac: e3a0c018 mov ip, #24
3000bfb0: e5933000 ldr r3, [r3]
3000bfb4: e1a0e001 mov lr, r1
3000bfb8: e02c3c94 mla ip, r4, ip, r3
3000bfbc: e8be000f ldm lr!, {r0, r1, r2, r3}
3000bfc0: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000bfc4: e89e0003 ldm lr, {r0, r1}
3000bfc8: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
3000bfcc: eb000796 bl 3000de2c <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
3000bfd0: e3a01000 mov r1, #0 3000bfd4: e1a00004 mov r0, r4 3000bfd8: e1a02001 mov r2, r1
}
3000bfdc: e8bd4010 pop {r4, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
3000bfe0: ea001cbb b 300132d4 <rtems_io_initialize>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
3000bfe4: e3a00009 mov r0, #9 <== NOT EXECUTED
3000bfe8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
3000bfec: e3a0000a mov r0, #10 <== NOT EXECUTED
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
3000bff0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
3000bff4: e1540003 cmp r4, r3
3000bff8: 2afffffb bcs 3000bfec <rtems_io_register_driver+0x13c>
3000bffc: eaffffc0 b 3000bf04 <rtems_io_register_driver+0x54>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
3000c000: e2844001 add r4, r4, #1 3000c004: e2833018 add r3, r3, #24 3000c008: eaffffcf b 3000bf4c <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();
3000c00c: eb000786 bl 3000de2c <_Thread_Enable_dispatch> <== NOT EXECUTED
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
3000c010: e3a00005 mov r0, #5 <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
3000c014: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c028 <rtems_io_unregister_driver>:
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000c028: e59f305c ldr r3, [pc, #92] ; 3000c08c <rtems_io_unregister_driver+0x64>
#include <string.h>
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
3000c02c: e92d4010 push {r4, lr}
if ( rtems_interrupt_is_in_progress() )
3000c030: e5934000 ldr r4, [r3] 3000c034: e3540000 cmp r4, #0
return RTEMS_CALLED_FROM_ISR;
3000c038: 13a00012 movne r0, #18
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000c03c: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
3000c040: e59f3048 ldr r3, [pc, #72] ; 3000c090 <rtems_io_unregister_driver+0x68> 3000c044: e5933000 ldr r3, [r3] 3000c048: e1500003 cmp r0, r3
3000c04c: 2a00000c bcs 3000c084 <rtems_io_unregister_driver+0x5c>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000c050: e59f303c ldr r3, [pc, #60] ; 3000c094 <rtems_io_unregister_driver+0x6c> 3000c054: e5932000 ldr r2, [r3]
++level;
3000c058: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000c05c: e5832000 str r2, [r3]
_Thread_Disable_dispatch();
memset(
3000c060: e59f3030 ldr r3, [pc, #48] ; 3000c098 <rtems_io_unregister_driver+0x70>
&_IO_Driver_address_table[major],
3000c064: e3a02018 mov r2, #24
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
3000c068: e5933000 ldr r3, [r3] 3000c06c: e1a01004 mov r1, r4 3000c070: e0203092 mla r0, r2, r0, r3 3000c074: eb002614 bl 300158cc <memset>
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
3000c078: eb00076b bl 3000de2c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000c07c: e1a00004 mov r0, r4
3000c080: e8bd8010 pop {r4, pc}
}
return RTEMS_UNSATISFIED;
3000c084: e3a0000d mov r0, #13 <== NOT EXECUTED
}
3000c088: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30010a8c <rtems_io_write>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010a8c: e59fc044 ldr ip, [pc, #68] ; 30010ad8 <rtems_io_write+0x4c>
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010a90: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010a94: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010a98: e92d4010 push {r4, lr}
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010a9c: e150000c cmp r0, ip
return RTEMS_INVALID_NUMBER;
30010aa0: 23a0000a movcs r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010aa4: 28bd8010 popcs {r4, pc}
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
30010aa8: e59fc02c ldr ip, [pc, #44] ; 30010adc <rtems_io_write+0x50> 30010aac: e3a04018 mov r4, #24 30010ab0: e59cc000 ldr ip, [ip] 30010ab4: e023c394 mla r3, r4, r3, ip 30010ab8: e5933010 ldr r3, [r3, #16]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010abc: e3530000 cmp r3, #0
30010ac0: 0a000002 beq 30010ad0 <rtems_io_write+0x44>
30010ac4: e1a0e00f mov lr, pc
30010ac8: e12fff13 bx r3
30010acc: e8bd8010 pop {r4, pc}
30010ad0: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010ad4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ca88 <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)
{
3000ca88: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
3000ca8c: e2508000 subs r8, r0, #0 <== NOT EXECUTED
3000ca90: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000ca94: e59f4050 ldr r4, [pc, #80] ; 3000caec <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)
3000ca98: e284700c add r7, r4, #12 <== NOT EXECUTED
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
3000ca9c: e5b43004 ldr r3, [r4, #4]! <== NOT EXECUTED 3000caa0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000caa4: 0a00000d beq 3000cae0 <rtems_iterate_over_all_threads+0x58><== NOT EXECUTED
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
3000caa8: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED
if ( !information )
3000caac: e3560000 cmp r6, #0 <== NOT EXECUTED 3000cab0: 13a05001 movne r5, #1 <== NOT EXECUTED 3000cab4: 1a000006 bne 3000cad4 <rtems_iterate_over_all_threads+0x4c><== NOT EXECUTED 3000cab8: ea000008 b 3000cae0 <rtems_iterate_over_all_threads+0x58> <== NOT EXECUTED
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
3000cabc: e596301c ldr r3, [r6, #28] <== NOT EXECUTED 3000cac0: e7930105 ldr r0, [r3, r5, lsl #2] <== NOT EXECUTED
if ( !the_thread )
3000cac4: e3500000 cmp r0, #0 <== NOT EXECUTED
continue;
(*routine)(the_thread);
3000cac8: 11a0e00f movne lr, pc <== NOT EXECUTED 3000cacc: 112fff18 bxne r8 <== NOT EXECUTED
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
3000cad0: e2855001 add r5, r5, #1 <== NOT EXECUTED 3000cad4: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED 3000cad8: e1550003 cmp r5, r3 <== NOT EXECUTED 3000cadc: 9afffff6 bls 3000cabc <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++ ) {
3000cae0: e1540007 cmp r4, r7 <== NOT EXECUTED
3000cae4: 1affffec bne 3000ca9c <rtems_iterate_over_all_threads+0x14><== NOT EXECUTED
3000cae8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300166b4 <rtems_message_queue_broadcast>:
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
300166b4: e92d40f7 push {r0, r1, r2, r4, r5, r6, r7, lr}
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
300166b8: e2517000 subs r7, r1, #0
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
300166bc: e1a04000 mov r4, r0 300166c0: e1a05002 mov r5, r2 300166c4: e1a06003 mov r6, r3
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
300166c8: 0a000014 beq 30016720 <rtems_message_queue_broadcast+0x6c>
return RTEMS_INVALID_ADDRESS;
if ( !count )
300166cc: e3530000 cmp r3, #0
300166d0: 0a000012 beq 30016720 <rtems_message_queue_broadcast+0x6c>
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
300166d4: e59f004c ldr r0, [pc, #76] ; 30016728 <rtems_message_queue_broadcast+0x74> 300166d8: e1a01004 mov r1, r4 300166dc: e28d2008 add r2, sp, #8 300166e0: eb0014a1 bl 3001b96c <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
300166e4: e59d3008 ldr r3, [sp, #8] 300166e8: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300166ec: 13a00004 movne r0, #4
if ( !count )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
300166f0: 1a00000b bne 30016724 <rtems_message_queue_broadcast+0x70>
case OBJECTS_LOCAL:
core_status = _CORE_message_queue_Broadcast(
300166f4: e88d0048 stm sp, {r3, r6}
300166f8: e1a01007 mov r1, r7
300166fc: e1a03004 mov r3, r4
30016700: e1a02005 mov r2, r5
30016704: e2800014 add r0, r0, #20
30016708: eb000da1 bl 30019d94 <_CORE_message_queue_Broadcast>
3001670c: e1a04000 mov r4, r0
NULL,
#endif
count
);
_Thread_Enable_dispatch();
30016710: eb001818 bl 3001c778 <_Thread_Enable_dispatch>
return
30016714: e1a00004 mov r0, r4 30016718: eb0000cd bl 30016a54 <_Message_queue_Translate_core_message_queue_return_code> 3001671c: ea000000 b 30016724 <rtems_message_queue_broadcast+0x70>
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !count )
return RTEMS_INVALID_ADDRESS;
30016720: e3a00009 mov r0, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30016724: e8bd80fe pop {r1, r2, r3, r4, r5, r6, r7, pc}
30011814 <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30011814: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr}
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
size_t max_packet_payload_size;
#endif
if ( !rtems_is_name_valid( name ) )
30011818: e2507000 subs r7, r0, #0
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3001181c: e1a06001 mov r6, r1 30011820: e1a05002 mov r5, r2 30011824: e1a0a003 mov sl, r3 30011828: e59d8020 ldr r8, [sp, #32]
bool is_global;
size_t max_packet_payload_size;
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3001182c: 03a00003 moveq r0, #3
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
size_t max_packet_payload_size;
#endif
if ( !rtems_is_name_valid( name ) )
30011830: 0a00002e beq 300118f0 <rtems_message_queue_create+0xdc>
return RTEMS_INVALID_NAME;
if ( !id )
30011834: e3580000 cmp r8, #0
return RTEMS_INVALID_ADDRESS;
30011838: 03a00009 moveq r0, #9
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
3001183c: 0a00002b beq 300118f0 <rtems_message_queue_create+0xdc>
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
30011840: e3510000 cmp r1, #0
return RTEMS_INVALID_NUMBER;
30011844: 03a0000a moveq r0, #10
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
30011848: 0a000028 beq 300118f0 <rtems_message_queue_create+0xdc>
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
3001184c: e3520000 cmp r2, #0
return RTEMS_INVALID_SIZE;
30011850: 03a00008 moveq r0, #8
#endif
if ( count == 0 )
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
30011854: 0a000025 beq 300118f0 <rtems_message_queue_create+0xdc>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
30011858: e59f3094 ldr r3, [pc, #148] ; 300118f4 <rtems_message_queue_create+0xe0> 3001185c: e5932000 ldr r2, [r3]
++level;
30011860: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
30011864: e5832000 str r2, [r3]
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
30011868: eb00155f bl 30016dec <_Message_queue_Allocate>
if ( !the_message_queue ) {
3001186c: e2504000 subs r4, r0, #0
30011870: 1a000002 bne 30011880 <rtems_message_queue_create+0x6c>
_Thread_Enable_dispatch();
30011874: eb000c1f bl 300148f8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30011878: e3a00005 mov r0, #5 <== NOT EXECUTED 3001187c: ea00001b b 300118f0 <rtems_message_queue_create+0xdc> <== NOT EXECUTED
#endif
the_message_queue->attribute_set = attribute_set;
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
30011880: e31a0004 tst sl, #4 30011884: 03a03000 moveq r3, #0 30011888: 13a03001 movne r3, #1
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
3001188c: e28d1004 add r1, sp, #4 30011890: e5213004 str r3, [r1, #-4]! 30011894: e584a010 str sl, [r4, #16]
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
30011898: e2840014 add r0, r4, #20 3001189c: e1a0100d mov r1, sp 300118a0: e1a02006 mov r2, r6 300118a4: e1a03005 mov r3, r5 300118a8: eb00049a bl 30012b18 <_CORE_message_queue_Initialize> 300118ac: e3500000 cmp r0, #0
300118b0: 1a000005 bne 300118cc <rtems_message_queue_create+0xb8>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
300118b4: e59f003c ldr r0, [pc, #60] ; 300118f8 <rtems_message_queue_create+0xe4><== NOT EXECUTED 300118b8: e1a01004 mov r1, r4 <== NOT EXECUTED 300118bc: eb000835 bl 30013998 <_Objects_Free> <== NOT EXECUTED
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
300118c0: eb000c0c bl 300148f8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
300118c4: e3a0000d mov r0, #13 <== NOT EXECUTED 300118c8: ea000008 b 300118f0 <rtems_message_queue_create+0xdc> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300118cc: e59f2024 ldr r2, [pc, #36] ; 300118f8 <rtems_message_queue_create+0xe4>
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300118d0: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300118d4: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300118d8: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300118dc: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
300118e0: e584700c str r7, [r4, #12]
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
300118e4: e5883000 str r3, [r8]
name,
0
);
#endif
_Thread_Enable_dispatch();
300118e8: eb000c02 bl 300148f8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300118ec: e3a00000 mov r0, #0
}
300118f0: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc}
300168c4 <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
300168c4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
300168c8: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
300168cc: e1a03000 mov r3, r0 <== NOT EXECUTED
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
300168d0: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
300168d4: 0a00000b beq 30016908 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED 300168d8: e59f002c ldr r0, [pc, #44] ; 3001690c <rtems_message_queue_get_number_pending+0x48><== NOT EXECUTED 300168dc: e1a01003 mov r1, r3 <== NOT EXECUTED 300168e0: e1a0200d mov r2, sp <== NOT EXECUTED 300168e4: eb001420 bl 3001b96c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
300168e8: e59d5000 ldr r5, [sp] <== NOT EXECUTED 300168ec: e3550000 cmp r5, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300168f0: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !count )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
300168f4: 1a000003 bne 30016908 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
300168f8: e590305c ldr r3, [r0, #92] ; 0x5c <== NOT EXECUTED 300168fc: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
30016900: eb00179c bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30016904: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30016908: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30011930 <rtems_message_queue_receive>:
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
30011930: e92d4077 push {r0, r1, r2, r4, r5, r6, lr}
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
30011934: e2515000 subs r5, r1, #0
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
30011938: e1a0c000 mov ip, r0 3001193c: e1a04002 mov r4, r2 30011940: e1a06003 mov r6, r3
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
30011944: 0a00001a beq 300119b4 <rtems_message_queue_receive+0x84>
return RTEMS_INVALID_ADDRESS;
if ( !size )
30011948: e3520000 cmp r2, #0
3001194c: 0a000018 beq 300119b4 <rtems_message_queue_receive+0x84>
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
30011950: e28d2008 add r2, sp, #8 30011954: e59f0060 ldr r0, [pc, #96] ; 300119bc <rtems_message_queue_receive+0x8c> 30011958: e1a0100c mov r1, ip 3001195c: eb000862 bl 30013aec <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30011960: e59d2008 ldr r2, [sp, #8] 30011964: e1a03000 mov r3, r0 30011968: e3520000 cmp r2, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001196c: 13a00004 movne r0, #4
if ( !size )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30011970: 1a000010 bne 300119b8 <rtems_message_queue_receive+0x88>
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
_CORE_message_queue_Seize(
30011974: e59d201c ldr r2, [sp, #28]
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
30011978: e2066001 and r6, r6, #1 3001197c: e2266001 eor r6, r6, #1 30011980: e58d2004 str r2, [sp, #4] 30011984: e58d6000 str r6, [sp] 30011988: e2830014 add r0, r3, #20 3001198c: e5931008 ldr r1, [r3, #8] 30011990: e1a02005 mov r2, r5 30011994: e1a03004 mov r3, r4 30011998: eb00048f bl 30012bdc <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
3001199c: eb000bd5 bl 300148f8 <_Thread_Enable_dispatch>
return _Message_queue_Translate_core_message_queue_return_code(
_Thread_Executing->Wait.return_code
300119a0: e59f3018 ldr r3, [pc, #24] ; 300119c0 <rtems_message_queue_receive+0x90> 300119a4: e5933008 ldr r3, [r3, #8]
size,
wait,
timeout
);
_Thread_Enable_dispatch();
return _Message_queue_Translate_core_message_queue_return_code(
300119a8: e5930034 ldr r0, [r3, #52] ; 0x34 300119ac: eb000023 bl 30011a40 <_Message_queue_Translate_core_message_queue_return_code> 300119b0: ea000000 b 300119b8 <rtems_message_queue_receive+0x88>
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
300119b4: e3a00009 mov r0, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300119b8: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc}
3000b9cc <rtems_object_api_maximum_class>:
int rtems_object_api_maximum_class(
int api
)
{
return _Objects_API_maximum_class(api);
3000b9cc: ea000622 b 3000d25c <_Objects_API_maximum_class> <== NOT EXECUTED
3000b9d0 <rtems_object_api_minimum_class>:
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
3000b9d0: e2400001 sub r0, r0, #1 <== NOT EXECUTED
int api
)
{
if ( _Objects_Is_api_valid( api ) )
return 1;
return -1;
3000b9d4: e3500003 cmp r0, #3 <== NOT EXECUTED
}
3000b9d8: 33a00001 movcc r0, #1 <== NOT EXECUTED 3000b9dc: 23e00000 mvncs r0, #0 <== NOT EXECUTED 3000b9e0: e12fff1e bx lr <== NOT EXECUTED
3000b9e4 <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
3000b9e4: e3500001 cmp r0, #1 <== NOT EXECUTED
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
3000b9e8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
3000b9ec: 0a000003 beq 3000ba00 <rtems_object_get_api_class_name+0x1c><== NOT EXECUTED
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
3000b9f0: e3500002 cmp r0, #2 <== NOT EXECUTED
api_assoc = rtems_object_api_classic_assoc;
3000b9f4: 059f002c ldreq r0, [pc, #44] ; 3000ba28 <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 )
3000b9f8: 1a000006 bne 3000ba18 <rtems_object_get_api_class_name+0x34><== NOT EXECUTED 3000b9fc: ea000000 b 3000ba04 <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;
3000ba00: e59f0024 ldr r0, [pc, #36] ; 3000ba2c <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 );
3000ba04: eb0011b5 bl 300100e0 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( class_assoc )
3000ba08: e3500000 cmp r0, #0 <== NOT EXECUTED
return class_assoc->name;
3000ba0c: 15900000 ldrne r0, [r0] <== NOT EXECUTED
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
3000ba10: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
3000ba14: ea000001 b 3000ba20 <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";
3000ba18: e59f0010 ldr r0, [pc, #16] ; 3000ba30 <rtems_object_get_api_class_name+0x4c><== NOT EXECUTED
3000ba1c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
return class_assoc->name;
return "BAD CLASS";
3000ba20: e59f000c ldr r0, [pc, #12] ; 3000ba34 <rtems_object_get_api_class_name+0x50><== NOT EXECUTED
}
3000ba24: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ba38 <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
3000ba38: e1a01000 mov r1, r0 <== NOT EXECUTED
3000ba3c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
3000ba40: e59f0010 ldr r0, [pc, #16] ; 3000ba58 <rtems_object_get_api_name+0x20><== NOT EXECUTED 3000ba44: eb0011a5 bl 300100e0 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( api_assoc )
3000ba48: e3500000 cmp r0, #0 <== NOT EXECUTED
return api_assoc->name;
3000ba4c: 15900000 ldrne r0, [r0] <== NOT EXECUTED
return "BAD CLASS";
3000ba50: 059f0004 ldreq r0, [pc, #4] ; 3000ba5c <rtems_object_get_api_name+0x24><== NOT EXECUTED
}
3000ba54: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ba90 <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
)
{
3000ba90: e92d4010 push {r4, lr} <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000ba94: e2524000 subs r4, r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000ba98: 03a00009 moveq r0, #9 <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000ba9c: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
3000baa0: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000baa4: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3000baa8: eb0006c1 bl 3000d5b4 <_Objects_Get_information> <== NOT EXECUTED
if ( !obj_info )
3000baac: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bab0: 0a000014 beq 3000bb08 <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;
3000bab4: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum;
3000bab8: e1d011b0 ldrh r1, [r0, #16] <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
3000babc: e5843000 str r3, [r4] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id;
3000bac0: e590300c ldr r3, [r0, #12] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000bac4: e3a02000 mov r2, #0 <== NOT EXECUTED
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
3000bac8: e5843004 str r3, [r4, #4] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
3000bacc: e5d03012 ldrb r3, [r0, #18] <== NOT EXECUTED
info->maximum = obj_info->maximum;
3000bad0: e5841008 str r1, [r4, #8] <== NOT EXECUTED
/* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend;
3000bad4: e5c4300c strb r3, [r4, #12] <== NOT EXECUTED
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000bad8: e3a03001 mov r3, #1 <== NOT EXECUTED 3000badc: ea000004 b 3000baf4 <rtems_object_get_class_information+0x64><== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000bae0: e590c01c ldr ip, [r0, #28] <== NOT EXECUTED 3000bae4: e79cc103 ldr ip, [ip, r3, lsl #2] <== NOT EXECUTED
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000bae8: e2833001 add r3, r3, #1 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000baec: e35c0000 cmp ip, #0 <== NOT EXECUTED
unallocated++;
3000baf0: 02822001 addeq r2, r2, #1 <== NOT EXECUTED
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000baf4: e1530001 cmp r3, r1 <== NOT EXECUTED 3000baf8: 9afffff8 bls 3000bae0 <rtems_object_get_class_information+0x50><== NOT EXECUTED
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
3000bafc: e5842010 str r2, [r4, #16] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000bb00: e3a00000 mov r0, #0 <== NOT EXECUTED
3000bb04: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( !info )
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
if ( !obj_info )
return RTEMS_INVALID_NUMBER;
3000bb08: e3a0000a mov r0, #10 <== NOT EXECUTED
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
3000bb0c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30014bf4 <rtems_object_get_name>:
Objects_Id id,
size_t length,
char *name
)
{
return _Objects_Get_name_as_string( id, length, name );
30014bf4: ea000307 b 30015818 <_Objects_Get_name_as_string> <== NOT EXECUTED
3000bb14 <rtems_object_id_api_maximum>:
#undef rtems_object_id_api_maximum
int rtems_object_id_api_maximum(void)
{
return OBJECTS_APIS_LAST;
}
3000bb14: e3a00003 mov r0, #3 <== NOT EXECUTED 3000bb18: e12fff1e bx lr <== NOT EXECUTED
3000bb1c <rtems_object_id_api_minimum>:
#undef rtems_object_id_api_minimum
int rtems_object_id_api_minimum(void)
{
return OBJECTS_INTERNAL_API;
}
3000bb1c: e3a00001 mov r0, #1 <== NOT EXECUTED 3000bb20: e12fff1e bx lr <== NOT EXECUTED
3000bb24 <rtems_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);
3000bb24: e1a00c20 lsr r0, r0, #24 <== NOT EXECUTED
int rtems_object_id_get_api(
rtems_id id
)
{
return _Objects_Get_API( id );
}
3000bb28: e2000007 and r0, r0, #7 <== NOT EXECUTED 3000bb2c: e12fff1e bx lr <== NOT EXECUTED
3000bb30 <rtems_object_id_get_class>:
int rtems_object_id_get_class(
rtems_id id
)
{
return _Objects_Get_class( id );
}
3000bb30: e1a00da0 lsr r0, r0, #27 <== NOT EXECUTED 3000bb34: e12fff1e bx lr <== NOT EXECUTED
3000bb38 <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 );
3000bb38: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
}
3000bb3c: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 3000bb40: e12fff1e bx lr <== NOT EXECUTED
3000bb44 <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;
3000bb44: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED
int rtems_object_id_get_node(
rtems_id id
)
{
return _Objects_Get_node( id );
}
3000bb48: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 3000bb4c: e12fff1e bx lr <== NOT EXECUTED
3000bb50 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
3000bb50: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
3000bb54: e2515000 subs r5, r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000bb58: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
3000bb5c: 0a000016 beq 3000bbbc <rtems_object_set_name+0x6c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000bb60: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bb64: 059f3054 ldreq r3, [pc, #84] ; 3000bbc0 <rtems_object_set_name+0x70><== NOT EXECUTED 3000bb68: 11a04000 movne r4, r0 <== NOT EXECUTED 3000bb6c: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED 3000bb70: 05934008 ldreq r4, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
3000bb74: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bb78: eb000688 bl 3000d5a0 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
3000bb7c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000bb80: 0a00000c beq 3000bbb8 <rtems_object_set_name+0x68> <== NOT EXECUTED
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
3000bb84: e1a01004 mov r1, r4 <== NOT EXECUTED 3000bb88: e1a0200d mov r2, sp <== NOT EXECUTED 3000bb8c: eb0006f3 bl 3000d760 <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
3000bb90: e59d4000 ldr r4, [sp] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
if ( !information )
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
3000bb94: e1a01000 mov r1, r0 <== NOT EXECUTED
switch ( location ) {
3000bb98: e3540000 cmp r4, #0 <== NOT EXECUTED 3000bb9c: 1a000005 bne 3000bbb8 <rtems_object_set_name+0x68> <== NOT EXECUTED
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
3000bba0: e1a02005 mov r2, r5 <== NOT EXECUTED 3000bba4: e1a00006 mov r0, r6 <== NOT EXECUTED 3000bba8: eb00075c bl 3000d920 <_Objects_Set_name> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000bbac: eb000a87 bl 3000e5d0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000bbb0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bbb4: ea000000 b 3000bbbc <rtems_object_set_name+0x6c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000bbb8: e3a00004 mov r0, #4 <== NOT EXECUTED
}
3000bbbc: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
30016ae0 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30016ae0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
30016ae4: e2508000 subs r8, r0, #0
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30016ae8: e1a05001 mov r5, r1 30016aec: e1a09002 mov r9, r2 30016af0: e1a0a003 mov sl, r3
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30016af4: 03a00003 moveq r0, #3
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
30016af8: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_INVALID_NAME;
if ( !starting_address )
30016afc: e3510000 cmp r1, #0
30016b00: 0a000030 beq 30016bc8 <rtems_partition_create+0xe8>
return RTEMS_INVALID_ADDRESS;
if ( !id )
30016b04: e59d2028 ldr r2, [sp, #40] ; 0x28 30016b08: e3520000 cmp r2, #0
30016b0c: 0a00002d beq 30016bc8 <rtems_partition_create+0xe8>
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
30016b10: e3590000 cmp r9, #0 30016b14: 13530000 cmpne r3, #0
30016b18: 0a00002c beq 30016bd0 <rtems_partition_create+0xf0>
30016b1c: e1590003 cmp r9, r3
30016b20: 3a00002a bcc 30016bd0 <rtems_partition_create+0xf0>
30016b24: e3130003 tst r3, #3
30016b28: 1a000028 bne 30016bd0 <rtems_partition_create+0xf0>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
30016b2c: e2116007 ands r6, r1, #7
30016b30: 1a000028 bne 30016bd8 <rtems_partition_create+0xf8>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
30016b34: e59f30a4 ldr r3, [pc, #164] ; 30016be0 <rtems_partition_create+0x100> 30016b38: e5932000 ldr r2, [r3]
++level;
30016b3c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
30016b40: e5832000 str r2, [r3]
* This function allocates a partition control block from
* the inactive chain of free partition control blocks.
*/
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )
{
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
30016b44: e59f7098 ldr r7, [pc, #152] ; 30016be4 <rtems_partition_create+0x104> 30016b48: e1a00007 mov r0, r7 30016b4c: eb001254 bl 3001b4a4 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
30016b50: e2504000 subs r4, r0, #0
30016b54: 1a000002 bne 30016b64 <rtems_partition_create+0x84>
_Thread_Enable_dispatch();
30016b58: eb001706 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30016b5c: e3a00005 mov r0, #5 <== NOT EXECUTED
30016b60: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
30016b64: e59d3024 ldr r3, [sp, #36] ; 0x24
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
30016b68: e1a0100a mov r1, sl
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
30016b6c: e584301c str r3, [r4, #28]
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
30016b70: e5845010 str r5, [r4, #16]
the_partition->length = length;
30016b74: e5849014 str r9, [r4, #20]
the_partition->buffer_size = buffer_size;
30016b78: e584a018 str sl, [r4, #24]
the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0;
30016b7c: e5846020 str r6, [r4, #32]
_Chain_Initialize( &the_partition->Memory, starting_address,
30016b80: e1a00009 mov r0, r9 30016b84: eb0051f4 bl 3002b35c <__aeabi_uidiv> 30016b88: e284b024 add fp, r4, #36 ; 0x24 30016b8c: e1a02000 mov r2, r0 30016b90: e1a01005 mov r1, r5 30016b94: e1a0000b mov r0, fp 30016b98: e1a0300a mov r3, sl 30016b9c: eb000c6c bl 30019d54 <_Chain_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30016ba0: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30016ba4: e1d410b8 ldrh r1, [r4, #8] 30016ba8: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30016bac: e7824101 str r4, [r2, r1, lsl #2]
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
30016bb0: e59d2028 ldr r2, [sp, #40] ; 0x28
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30016bb4: e584800c str r8, [r4, #12] 30016bb8: e5823000 str r3, [r2]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
30016bbc: eb0016ed bl 3001c778 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30016bc0: e1a00006 mov r0, r6
30016bc4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
30016bc8: e3a00009 mov r0, #9 <== NOT EXECUTED
30016bcc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
30016bd0: e3a00008 mov r0, #8 <== NOT EXECUTED
30016bd4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
30016bd8: e3a00009 mov r0, #9 <== NOT EXECUTED
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
30016bdc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30016be8 <rtems_partition_delete>:
#include <rtems/score/sysstate.h>
rtems_status_code rtems_partition_delete(
rtems_id id
)
{
30016be8: e92d4031 push {r0, r4, r5, lr}
30016bec: e1a01000 mov r1, r0
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
30016bf0: e1a0200d mov r2, sp 30016bf4: e59f0050 ldr r0, [pc, #80] ; 30016c4c <rtems_partition_delete+0x64> 30016bf8: eb00135b bl 3001b96c <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
30016bfc: e59d3000 ldr r3, [sp] 30016c00: e1a04000 mov r4, r0 30016c04: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30016c08: 13a00004 movne r0, #4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
30016c0c: 1a00000d bne 30016c48 <rtems_partition_delete+0x60>
case OBJECTS_LOCAL:
if ( the_partition->number_of_used_blocks == 0 ) {
30016c10: e5945020 ldr r5, [r4, #32] 30016c14: e3550000 cmp r5, #0
30016c18: 1a000008 bne 30016c40 <rtems_partition_delete+0x58>
_Objects_Close( &_Partition_Information, &the_partition->Object );
30016c1c: e59f0028 ldr r0, [pc, #40] ; 30016c4c <rtems_partition_delete+0x64> 30016c20: e1a01004 mov r1, r4 30016c24: eb001240 bl 3001b52c <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Partition_Free (
Partition_Control *the_partition
)
{
_Objects_Free( &_Partition_Information, &the_partition->Object );
30016c28: e59f001c ldr r0, [pc, #28] ; 30016c4c <rtems_partition_delete+0x64> 30016c2c: e1a01004 mov r1, r4 30016c30: eb0012ea bl 3001b7e0 <_Objects_Free>
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
30016c34: eb0016cf bl 3001c778 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30016c38: e1a00005 mov r0, r5 30016c3c: ea000001 b 30016c48 <rtems_partition_delete+0x60>
}
_Thread_Enable_dispatch();
30016c40: eb0016cc bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
30016c44: e3a0000c mov r0, #12 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30016c48: e8bd8038 pop {r3, r4, r5, pc}
30016cf8 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
30016cf8: e92d4071 push {r0, r4, r5, r6, lr}
30016cfc: e1a03000 mov r3, r0
30016d00: e1a04001 mov r4, r1
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
30016d04: e59f0088 ldr r0, [pc, #136] ; 30016d94 <rtems_partition_return_buffer+0x9c> 30016d08: e1a01003 mov r1, r3 30016d0c: e1a0200d mov r2, sp 30016d10: eb001315 bl 3001b96c <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
30016d14: e59d3000 ldr r3, [sp] 30016d18: e1a05000 mov r5, r0 30016d1c: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30016d20: 13a00004 movne r0, #4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
30016d24: 1a000016 bne 30016d84 <rtems_partition_return_buffer+0x8c>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
30016d28: e5950010 ldr r0, [r5, #16] 30016d2c: e5953014 ldr r3, [r5, #20] 30016d30: e0803003 add r3, r0, r3
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
30016d34: e1540003 cmp r4, r3 30016d38: 83a03000 movhi r3, #0 30016d3c: 93a03001 movls r3, #1 30016d40: e1540000 cmp r4, r0 30016d44: 33a03000 movcc r3, #0
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
30016d48: e3530000 cmp r3, #0
30016d4c: 0a00000d beq 30016d88 <rtems_partition_return_buffer+0x90>
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
30016d50: e0600004 rsb r0, r0, r4 30016d54: e5951018 ldr r1, [r5, #24] 30016d58: eb0051c5 bl 3002b474 <__umodsi3>
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
30016d5c: e2506000 subs r6, r0, #0
30016d60: 1a000008 bne 30016d88 <rtems_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 );
30016d64: e2850024 add r0, r5, #36 ; 0x24 30016d68: e1a01004 mov r1, r4 30016d6c: eb000be0 bl 30019cf4 <_Chain_Append>
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
30016d70: e5953020 ldr r3, [r5, #32] 30016d74: e2433001 sub r3, r3, #1 30016d78: e5853020 str r3, [r5, #32]
_Thread_Enable_dispatch();
30016d7c: eb00167d bl 3001c778 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30016d80: e1a00006 mov r0, r6
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30016d84: e8bd8078 pop {r3, r4, r5, r6, pc}
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
30016d88: eb00167a bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30016d8c: e3a00009 mov r0, #9 <== NOT EXECUTED 30016d90: eafffffb b 30016d84 <rtems_partition_return_buffer+0x8c> <== NOT EXECUTED
30016154 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
30016154: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
30016158: e250a000 subs sl, r0, #0
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
3001615c: e1a04001 mov r4, r1 30016160: e1a05002 mov r5, r2 30016164: e1a09003 mov r9, r3 30016168: e59d6020 ldr r6, [sp, #32]
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3001616c: 03a00003 moveq r0, #3
rtems_id *id
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
30016170: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
return RTEMS_INVALID_NAME;
if ( !id )
30016174: e3560000 cmp r6, #0
return RTEMS_INVALID_ADDRESS;
30016178: 03a00009 moveq r0, #9
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
3001617c: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
#include <rtems/rtems/dpmem.h>
#include <rtems/score/object.h>
#include <rtems/score/thread.h>
#include <rtems/rtems/dpmem.h>
rtems_status_code rtems_port_create(
30016180: e1828001 orr r8, r2, r1
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
30016184: e2188007 ands r8, r8, #7
30016188: 1a000018 bne 300161f0 <rtems_port_create+0x9c>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3001618c: e59f3064 ldr r3, [pc, #100] ; 300161f8 <rtems_port_create+0xa4> 30016190: e5932000 ldr r2, [r3]
++level;
30016194: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
30016198: e5832000 str r2, [r3]
* of free port control blocks.
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
3001619c: e59f7058 ldr r7, [pc, #88] ; 300161fc <rtems_port_create+0xa8> 300161a0: e1a00007 mov r0, r7 300161a4: eb0014be bl 3001b4a4 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
300161a8: e3500000 cmp r0, #0
300161ac: 1a000002 bne 300161bc <rtems_port_create+0x68>
_Thread_Enable_dispatch();
300161b0: eb001970 bl 3001c778 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
300161b4: e3a00005 mov r0, #5
300161b8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300161bc: e5903008 ldr r3, [r0, #8] 300161c0: e1d010b8 ldrh r1, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300161c4: e597201c ldr r2, [r7, #28]
}
the_port->internal_base = internal_start;
the_port->external_base = external_start;
the_port->length = length - 1;
300161c8: e2499001 sub r9, r9, #1
if ( !the_port ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
300161cc: e5804010 str r4, [r0, #16]
the_port->external_base = external_start;
300161d0: e5805014 str r5, [r0, #20]
the_port->length = length - 1;
300161d4: e5809018 str r9, [r0, #24] 300161d8: e7820101 str r0, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
300161dc: e580a00c str sl, [r0, #12]
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
300161e0: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
300161e4: eb001963 bl 3001c778 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300161e8: e1a00008 mov r0, r8
300161ec: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
!_Addresses_Is_aligned( external_start ) )
return RTEMS_INVALID_ADDRESS;
300161f0: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
300161f4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
30016d98 <rtems_rate_monotonic_cancel>:
#include <rtems/score/thread.h>
rtems_status_code rtems_rate_monotonic_cancel(
rtems_id id
)
{
30016d98: e92d4031 push {r0, r4, r5, lr}
30016d9c: e1a01000 mov r1, r0
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
30016da0: e1a0200d mov r2, sp 30016da4: e59f0060 ldr r0, [pc, #96] ; 30016e0c <rtems_rate_monotonic_cancel+0x74> 30016da8: eb0012ef bl 3001b96c <_Objects_Get>
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30016dac: e59d4000 ldr r4, [sp] 30016db0: e1a05000 mov r5, r0 30016db4: e3540000 cmp r4, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30016db8: 13a00004 movne r0, #4
{
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30016dbc: 1a000011 bne 30016e08 <rtems_rate_monotonic_cancel+0x70>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
30016dc0: e59f3048 ldr r3, [pc, #72] ; 30016e10 <rtems_rate_monotonic_cancel+0x78> 30016dc4: e5952040 ldr r2, [r5, #64] ; 0x40 30016dc8: e5933008 ldr r3, [r3, #8] 30016dcc: e1520003 cmp r2, r3
30016dd0: 0a000002 beq 30016de0 <rtems_rate_monotonic_cancel+0x48>
_Thread_Enable_dispatch();
30016dd4: eb001667 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_OWNER_OF_RESOURCE;
30016dd8: e3a00017 mov r0, #23 <== NOT EXECUTED 30016ddc: ea000009 b 30016e08 <rtems_rate_monotonic_cancel+0x70> <== NOT EXECUTED
}
(void) _Watchdog_Remove( &the_period->Timer );
30016de0: e2850010 add r0, r5, #16 30016de4: eb001a01 bl 3001d5f0 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Scheduler_Release_job(
Thread_Control *the_thread,
uint32_t length
)
{
_Scheduler.Operations.release_job(the_thread, length);
30016de8: e5950040 ldr r0, [r5, #64] ; 0x40 30016dec: e1a01004 mov r1, r4 30016df0: e59f301c ldr r3, [pc, #28] ; 30016e14 <rtems_rate_monotonic_cancel+0x7c>
the_period->state = RATE_MONOTONIC_INACTIVE;
30016df4: e5854038 str r4, [r5, #56] ; 0x38 30016df8: e1a0e00f mov lr, pc 30016dfc: e593f034 ldr pc, [r3, #52] ; 0x34
_Scheduler_Release_job(the_period->owner, 0);
_Thread_Enable_dispatch();
30016e00: eb00165c bl 3001c778 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30016e04: e1a00004 mov r0, r4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30016e08: e8bd8038 pop {r3, r4, r5, pc}
3000aacc <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000aacc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000aad0: e2508000 subs r8, r0, #0
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000aad4: e1a06001 mov r6, r1
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000aad8: 03a00003 moveq r0, #3
rtems_id *id
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000aadc: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_INVALID_NAME;
if ( !id )
3000aae0: e3510000 cmp r1, #0
3000aae4: 0a000027 beq 3000ab88 <rtems_rate_monotonic_create+0xbc>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000aae8: e59f30a0 ldr r3, [pc, #160] ; 3000ab90 <rtems_rate_monotonic_create+0xc4> 3000aaec: e5932000 ldr r2, [r3]
++level;
3000aaf0: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000aaf4: e5832000 str r2, [r3]
* This function allocates a period control block from
* the inactive chain of free period control blocks.
*/
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void )
{
return (Rate_monotonic_Control *)
3000aaf8: e59f7094 ldr r7, [pc, #148] ; 3000ab94 <rtems_rate_monotonic_create+0xc8> 3000aafc: e1a00007 mov r0, r7 3000ab00: eb0007bc bl 3000c9f8 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
3000ab04: e2504000 subs r4, r0, #0
3000ab08: 1a000002 bne 3000ab18 <rtems_rate_monotonic_create+0x4c>
_Thread_Enable_dispatch();
3000ab0c: eb000c98 bl 3000dd74 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000ab10: e3a00005 mov r0, #5 <== NOT EXECUTED
3000ab14: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
the_period->owner = _Thread_Executing;
3000ab18: e59f3078 ldr r3, [pc, #120] ; 3000ab98 <rtems_rate_monotonic_create+0xcc>
the_period->state = RATE_MONOTONIC_INACTIVE;
3000ab1c: e3a05000 mov r5, #0
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000ab20: e5933008 ldr r3, [r3, #8]
the_period->state = RATE_MONOTONIC_INACTIVE;
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000ab24: e1a01005 mov r1, r5
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000ab28: e5843040 str r3, [r4, #64] ; 0x40
the_period->state = RATE_MONOTONIC_INACTIVE;
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000ab2c: e3a02038 mov r2, #56 ; 0x38
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
the_period->state = RATE_MONOTONIC_INACTIVE;
3000ab30: e5845038 str r5, [r4, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000ab34: e5845018 str r5, [r4, #24]
the_watchdog->routine = routine;
3000ab38: e584502c str r5, [r4, #44] ; 0x2c
the_watchdog->id = id;
3000ab3c: e5845030 str r5, [r4, #48] ; 0x30
the_watchdog->user_data = user_data;
3000ab40: e5845034 str r5, [r4, #52] ; 0x34
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000ab44: e2840054 add r0, r4, #84 ; 0x54 3000ab48: eb0020dc bl 30012ec0 <memset>
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
3000ab4c: e59f2048 ldr r2, [pc, #72] ; 3000ab9c <rtems_rate_monotonic_create+0xd0> 3000ab50: e59f3048 ldr r3, [pc, #72] ; 3000aba0 <rtems_rate_monotonic_create+0xd4>
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000ab54: e1d410b8 ldrh r1, [r4, #8] 3000ab58: e584205c str r2, [r4, #92] ; 0x5c 3000ab5c: e5843060 str r3, [r4, #96] ; 0x60 3000ab60: e5842074 str r2, [r4, #116] ; 0x74 3000ab64: e5843078 str r3, [r4, #120] ; 0x78
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000ab68: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000ab6c: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000ab70: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000ab74: e584800c str r8, [r4, #12]
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
3000ab78: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
3000ab7c: eb000c7c bl 3000dd74 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ab80: e1a00005 mov r0, r5
3000ab84: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000ab88: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000ab8c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300314bc <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
300314bc: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
300314c0: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
300314c4: e1a03000 mov r3, r0 <== NOT EXECUTED
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
300314c8: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
300314cc: 0a000062 beq 3003165c <rtems_rate_monotonic_get_statistics+0x1a0><== NOT EXECUTED 300314d0: e59f0188 ldr r0, [pc, #392] ; 30031660 <rtems_rate_monotonic_get_statistics+0x1a4><== NOT EXECUTED 300314d4: e1a01003 mov r1, r3 <== NOT EXECUTED 300314d8: e1a0200d mov r2, sp <== NOT EXECUTED 300314dc: ebff6b58 bl 3000c244 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300314e0: e59d8000 ldr r8, [sp] <== NOT EXECUTED 300314e4: e1a05000 mov r5, r0 <== NOT EXECUTED 300314e8: e3580000 cmp r8, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300314ec: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300314f0: 1a000059 bne 3003165c <rtems_rate_monotonic_get_statistics+0x1a0><== NOT EXECUTED
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
300314f4: e5953054 ldr r3, [r5, #84] ; 0x54 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300314f8: e285705c add r7, r5, #92 ; 0x5c <== NOT EXECUTED
300314fc: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
switch ( location ) {
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
30031500: e5843000 str r3, [r4] <== NOT EXECUTED
dst->missed_count = src->missed_count;
30031504: e5953058 ldr r3, [r5, #88] ; 0x58 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30031508: e1a00006 mov r0, r6 <== NOT EXECUTED 3003150c: e5843004 str r3, [r4, #4] <== NOT EXECUTED 30031510: e1a01007 mov r1, r7 <== NOT EXECUTED 30031514: e59f2148 ldr r2, [pc, #328] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30031518: e3a03000 mov r3, #0 <== NOT EXECUTED 3003151c: eb0075e2 bl 3004ecac <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031520: e1a01007 mov r1, r7 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30031524: e5840008 str r0, [r4, #8] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031528: e59f2134 ldr r2, [pc, #308] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 3003152c: e1a00006 mov r0, r6 <== NOT EXECUTED 30031530: e3a03000 mov r3, #0 <== NOT EXECUTED 30031534: eb007717 bl 3004f198 <__moddi3> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30031538: e2857064 add r7, r5, #100 ; 0x64 <== NOT EXECUTED
3003153c: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
30031540: e584000c str r0, [r4, #12] <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30031544: e1a01007 mov r1, r7 <== NOT EXECUTED 30031548: e1a00006 mov r0, r6 <== NOT EXECUTED 3003154c: e59f2110 ldr r2, [pc, #272] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30031550: e3a03000 mov r3, #0 <== NOT EXECUTED 30031554: eb0075d4 bl 3004ecac <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031558: e1a01007 mov r1, r7 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
3003155c: e5840010 str r0, [r4, #16] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031560: e59f20fc ldr r2, [pc, #252] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED
30031564: e1a00006 mov r0, r6 <== NOT EXECUTED
30031568: e3a03000 mov r3, #0 <== NOT EXECUTED
3003156c: eb007709 bl 3004f198 <__moddi3> <== NOT EXECUTED
30031570: e285706c add r7, r5, #108 ; 0x6c <== NOT EXECUTED
30031574: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
30031578: e5840014 str r0, [r4, #20] <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
3003157c: e1a01007 mov r1, r7 <== NOT EXECUTED 30031580: e1a00006 mov r0, r6 <== NOT EXECUTED 30031584: e59f20d8 ldr r2, [pc, #216] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30031588: e3a03000 mov r3, #0 <== NOT EXECUTED 3003158c: eb0075c6 bl 3004ecac <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031590: e1a01007 mov r1, r7 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30031594: e5840018 str r0, [r4, #24] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031598: e59f20c4 ldr r2, [pc, #196] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED
3003159c: e1a00006 mov r0, r6 <== NOT EXECUTED
300315a0: e3a03000 mov r3, #0 <== NOT EXECUTED
300315a4: eb0076fb bl 3004f198 <__moddi3> <== NOT EXECUTED
300315a8: e2857074 add r7, r5, #116 ; 0x74 <== NOT EXECUTED
300315ac: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
300315b0: e584001c str r0, [r4, #28] <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
300315b4: e1a01007 mov r1, r7 <== NOT EXECUTED 300315b8: e1a00006 mov r0, r6 <== NOT EXECUTED 300315bc: e59f20a0 ldr r2, [pc, #160] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 300315c0: e3a03000 mov r3, #0 <== NOT EXECUTED 300315c4: eb0075b8 bl 3004ecac <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
300315c8: e1a01007 mov r1, r7 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
300315cc: e5840020 str r0, [r4, #32] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
300315d0: e59f208c ldr r2, [pc, #140] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED
300315d4: e1a00006 mov r0, r6 <== NOT EXECUTED
300315d8: e3a03000 mov r3, #0 <== NOT EXECUTED
300315dc: eb0076ed bl 3004f198 <__moddi3> <== NOT EXECUTED
300315e0: e285707c add r7, r5, #124 ; 0x7c <== NOT EXECUTED
300315e4: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
300315e8: e5840024 str r0, [r4, #36] ; 0x24 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
300315ec: e1a01007 mov r1, r7 <== NOT EXECUTED 300315f0: e1a00006 mov r0, r6 <== NOT EXECUTED 300315f4: e59f2068 ldr r2, [pc, #104] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 300315f8: e3a03000 mov r3, #0 <== NOT EXECUTED 300315fc: eb0075aa bl 3004ecac <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031600: e1a01007 mov r1, r7 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30031604: e5840028 str r0, [r4, #40] ; 0x28 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031608: e59f2054 ldr r2, [pc, #84] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED
3003160c: e1a00006 mov r0, r6 <== NOT EXECUTED
30031610: e3a03000 mov r3, #0 <== NOT EXECUTED
30031614: eb0076df bl 3004f198 <__moddi3> <== NOT EXECUTED
30031618: e2857084 add r7, r5, #132 ; 0x84 <== NOT EXECUTED
3003161c: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
30031620: e584002c str r0, [r4, #44] ; 0x2c <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30031624: e59f2038 ldr r2, [pc, #56] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED 30031628: e3a03000 mov r3, #0 <== NOT EXECUTED 3003162c: e1a00006 mov r0, r6 <== NOT EXECUTED 30031630: e1a01007 mov r1, r7 <== NOT EXECUTED 30031634: eb00759c bl 3004ecac <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031638: e59f2024 ldr r2, [pc, #36] ; 30031664 <rtems_rate_monotonic_get_statistics+0x1a8><== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
3003163c: e5840030 str r0, [r4, #48] ; 0x30 <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031640: e3a03000 mov r3, #0 <== NOT EXECUTED 30031644: e1a00006 mov r0, r6 <== NOT EXECUTED 30031648: e1a01007 mov r1, r7 <== NOT EXECUTED 3003164c: eb0076d1 bl 3004f198 <__moddi3> <== NOT EXECUTED 30031650: e5840034 str r0, [r4, #52] ; 0x34 <== NOT EXECUTED
dst->min_wall_time = src->min_wall_time;
dst->max_wall_time = src->max_wall_time;
dst->total_wall_time = src->total_wall_time;
#endif
_Thread_Enable_dispatch();
30031654: ebff6e5b bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30031658: e1a00008 mov r0, r8 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3003165c: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30031668 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
30031668: e92d40d0 push {r4, r6, r7, lr} <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
3003166c: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
30031670: e1a03000 mov r3, r0 <== NOT EXECUTED 30031674: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
return RTEMS_INVALID_ADDRESS;
30031678: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
3003167c: 0a000038 beq 30031764 <rtems_rate_monotonic_get_status+0xfc><== NOT EXECUTED 30031680: e1a01003 mov r1, r3 <== NOT EXECUTED 30031684: e28d2010 add r2, sp, #16 <== NOT EXECUTED 30031688: e59f00dc ldr r0, [pc, #220] ; 3003176c <rtems_rate_monotonic_get_status+0x104><== NOT EXECUTED 3003168c: ebff6aec bl 3000c244 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30031690: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 30031694: e1a03000 mov r3, r0 <== NOT EXECUTED 30031698: e3520000 cmp r2, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3003169c: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !status )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300316a0: 1a00002f bne 30031764 <rtems_rate_monotonic_get_status+0xfc><== NOT EXECUTED
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
300316a4: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED
status->state = the_period->state;
300316a8: e5933038 ldr r3, [r3, #56] ; 0x38 <== NOT EXECUTED
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
300316ac: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED
status->state = the_period->state;
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
300316b0: e3530000 cmp r3, #0 <== NOT EXECUTED
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
300316b4: e5842000 str r2, [r4] <== NOT EXECUTED
status->state = the_period->state;
300316b8: e5843004 str r3, [r4, #4] <== NOT EXECUTED
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timespec_Set_to_zero( &status->since_last_period );
300316bc: 05843008 streq r3, [r4, #8] <== NOT EXECUTED 300316c0: 0584300c streq r3, [r4, #12] <== NOT EXECUTED
_Timespec_Set_to_zero( &status->executed_since_last_period );
300316c4: 05843010 streq r3, [r4, #16] <== NOT EXECUTED 300316c8: 05843014 streq r3, [r4, #20] <== NOT EXECUTED 300316cc: 0a000022 beq 3003175c <rtems_rate_monotonic_get_status+0xf4><== NOT EXECUTED
} else {
/*
* Grab the current status.
*/
valid_status =
300316d0: e28d1008 add r1, sp, #8 <== NOT EXECUTED 300316d4: e1a0200d mov r2, sp <== NOT EXECUTED 300316d8: eb000025 bl 30031774 <_Rate_monotonic_Get_status> <== NOT EXECUTED
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
300316dc: e3500000 cmp r0, #0 <== NOT EXECUTED 300316e0: 1a000002 bne 300316f0 <rtems_rate_monotonic_get_status+0x88><== NOT EXECUTED
_Thread_Enable_dispatch();
300316e4: ebff6e37 bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
300316e8: e3a0000b mov r0, #11 <== NOT EXECUTED 300316ec: ea00001c b 30031764 <rtems_rate_monotonic_get_status+0xfc> <== NOT EXECUTED
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
300316f0: e28d7008 add r7, sp, #8 <== NOT EXECUTED
300316f4: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
300316f8: e59f2070 ldr r2, [pc, #112] ; 30031770 <rtems_rate_monotonic_get_status+0x108><== NOT EXECUTED 300316fc: e1a00006 mov r0, r6 <== NOT EXECUTED 30031700: e1a01007 mov r1, r7 <== NOT EXECUTED 30031704: e3a03000 mov r3, #0 <== NOT EXECUTED 30031708: eb007567 bl 3004ecac <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
3003170c: e1a01007 mov r1, r7 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30031710: e5840008 str r0, [r4, #8] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031714: e59f2054 ldr r2, [pc, #84] ; 30031770 <rtems_rate_monotonic_get_status+0x108><== NOT EXECUTED 30031718: e1a00006 mov r0, r6 <== NOT EXECUTED 3003171c: e3a03000 mov r3, #0 <== NOT EXECUTED 30031720: eb00769c bl 3004f198 <__moddi3> <== NOT EXECUTED
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
30031724: e89d00c0 ldm sp, {r6, r7} <== NOT EXECUTED
30031728: e584000c str r0, [r4, #12] <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
3003172c: e59f203c ldr r2, [pc, #60] ; 30031770 <rtems_rate_monotonic_get_status+0x108><== NOT EXECUTED 30031730: e3a03000 mov r3, #0 <== NOT EXECUTED 30031734: e1a00006 mov r0, r6 <== NOT EXECUTED 30031738: e1a01007 mov r1, r7 <== NOT EXECUTED 3003173c: eb00755a bl 3004ecac <__divdi3> <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031740: e1a01007 mov r1, r7 <== NOT EXECUTED
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
30031744: e5840010 str r0, [r4, #16] <== NOT EXECUTED
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
30031748: e59f2020 ldr r2, [pc, #32] ; 30031770 <rtems_rate_monotonic_get_status+0x108><== NOT EXECUTED 3003174c: e1a00006 mov r0, r6 <== NOT EXECUTED 30031750: e3a03000 mov r3, #0 <== NOT EXECUTED 30031754: eb00768f bl 3004f198 <__moddi3> <== NOT EXECUTED 30031758: e5840014 str r0, [r4, #20] <== NOT EXECUTED
status->since_last_period = since_last_period;
status->executed_since_last_period = executed;
#endif
}
_Thread_Enable_dispatch();
3003175c: ebff6e19 bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30031760: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30031764: e28dd014 add sp, sp, #20 <== NOT EXECUTED
30031768: e8bd80d0 pop {r4, r6, r7, pc} <== NOT EXECUTED
30031974 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
30031974: e92d40f1 push {r0, r4, r5, r6, r7, lr}
30031978: e1a05000 mov r5, r0
3003197c: e1a04001 mov r4, r1
30031980: e59f0180 ldr r0, [pc, #384] ; 30031b08 <rtems_rate_monotonic_period+0x194>
30031984: e1a01005 mov r1, r5
30031988: e1a0200d mov r2, sp
3003198c: ebff6a2c bl 3000c244 <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30031990: e59d3000 ldr r3, [sp] 30031994: e1a06000 mov r6, r0 30031998: e3530000 cmp r3, #0
3003199c: 1a000056 bne 30031afc <rtems_rate_monotonic_period+0x188>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
300319a0: e59f3164 ldr r3, [pc, #356] ; 30031b0c <rtems_rate_monotonic_period+0x198> 300319a4: e5902040 ldr r2, [r0, #64] ; 0x40 300319a8: e5933008 ldr r3, [r3, #8] 300319ac: e1520003 cmp r2, r3
300319b0: 0a000002 beq 300319c0 <rtems_rate_monotonic_period+0x4c>
_Thread_Enable_dispatch();
300319b4: ebff6d83 bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_OWNER_OF_RESOURCE;
300319b8: e3a04017 mov r4, #23 <== NOT EXECUTED 300319bc: ea00004f b 30031b00 <rtems_rate_monotonic_period+0x18c> <== NOT EXECUTED
}
if ( length == RTEMS_PERIOD_STATUS ) {
300319c0: e3540000 cmp r4, #0
300319c4: 1a000005 bne 300319e0 <rtems_rate_monotonic_period+0x6c>
switch ( the_period->state ) {
300319c8: e5903038 ldr r3, [r0, #56] ; 0x38 300319cc: e3530004 cmp r3, #4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300319d0: 959f2138 ldrls r2, [pc, #312] ; 30031b10 <rtems_rate_monotonic_period+0x19c> 300319d4: 97d24003 ldrbls r4, [r2, r3]
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
300319d8: ebff6d7a bl 3000cfc8 <_Thread_Enable_dispatch>
return( return_value );
300319dc: ea000047 b 30031b00 <rtems_rate_monotonic_period+0x18c>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
300319e0: e10f7000 mrs r7, CPSR 300319e4: e3873080 orr r3, r7, #128 ; 0x80 300319e8: e129f003 msr CPSR_fc, r3
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
300319ec: e5903038 ldr r3, [r0, #56] ; 0x38 300319f0: e3530000 cmp r3, #0
300319f4: 1a000011 bne 30031a40 <rtems_rate_monotonic_period+0xcc>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300319f8: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
the_period->next_length = length;
300319fc: e580403c str r4, [r0, #60] ; 0x3c
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
30031a00: ebffffb9 bl 300318ec <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
30031a04: e3a03002 mov r3, #2 30031a08: e5863038 str r3, [r6, #56] ; 0x38
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
30031a0c: e59f3100 ldr r3, [pc, #256] ; 30031b14 <rtems_rate_monotonic_period+0x1a0>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30031a10: e3a07000 mov r7, #0
the_watchdog->routine = routine;
30031a14: e586302c str r3, [r6, #44] ; 0x2c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30031a18: e586401c str r4, [r6, #28]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30031a1c: e59f00f4 ldr r0, [pc, #244] ; 30031b18 <rtems_rate_monotonic_period+0x1a4> 30031a20: e2861010 add r1, r6, #16
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30031a24: e5867018 str r7, [r6, #24]
the_watchdog->routine = routine; the_watchdog->id = id;
30031a28: e5865030 str r5, [r6, #48] ; 0x30
the_watchdog->user_data = user_data;
30031a2c: e5867034 str r7, [r6, #52] ; 0x34
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30031a30: ebff7041 bl 3000db3c <_Watchdog_Insert>
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
30031a34: e1a04007 mov r4, r7
id,
NULL
);
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
30031a38: ebff6d62 bl 3000cfc8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30031a3c: ea00002f b 30031b00 <rtems_rate_monotonic_period+0x18c>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
30031a40: e3530002 cmp r3, #2
30031a44: 1a000019 bne 30031ab0 <rtems_rate_monotonic_period+0x13c>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
30031a48: ebffff70 bl 30031810 <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
30031a4c: e3a03001 mov r3, #1 30031a50: e5863038 str r3, [r6, #56] ; 0x38
the_period->next_length = length;
30031a54: e586403c str r4, [r6, #60] ; 0x3c 30031a58: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
30031a5c: e59f30a8 ldr r3, [pc, #168] ; 30031b0c <rtems_rate_monotonic_period+0x198>
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
30031a60: e3a01901 mov r1, #16384 ; 0x4000
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
the_period->next_length = length;
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
30031a64: e5930008 ldr r0, [r3, #8] 30031a68: e5963008 ldr r3, [r6, #8] 30031a6c: e5803020 str r3, [r0, #32]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
30031a70: ebff6f5a bl 3000d7e0 <_Thread_Set_state>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30031a74: e10f2000 mrs r2, CPSR 30031a78: e3823080 orr r3, r2, #128 ; 0x80 30031a7c: e129f003 msr CPSR_fc, r3
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
30031a80: e3a01002 mov r1, #2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
30031a84: e5963038 ldr r3, [r6, #56] ; 0x38
the_period->state = RATE_MONOTONIC_ACTIVE;
30031a88: e5861038 str r1, [r6, #56] ; 0x38
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30031a8c: e129f002 msr CPSR_fc, r2
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
30031a90: e3530003 cmp r3, #3
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
30031a94: 059f3070 ldreq r3, [pc, #112] ; 30031b0c <rtems_rate_monotonic_period+0x198> 30031a98: 03a01901 moveq r1, #16384 ; 0x4000 30031a9c: 05930008 ldreq r0, [r3, #8] 30031aa0: 0bff6c6d bleq 3000cc5c <_Thread_Clear_state>
_Thread_Enable_dispatch();
30031aa4: ebff6d47 bl 3000cfc8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30031aa8: e3a04000 mov r4, #0 <== NOT EXECUTED 30031aac: ea000013 b 30031b00 <rtems_rate_monotonic_period+0x18c> <== NOT EXECUTED
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
30031ab0: e3530004 cmp r3, #4 <== NOT EXECUTED 30031ab4: 1a000010 bne 30031afc <rtems_rate_monotonic_period+0x188> <== NOT EXECUTED
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
30031ab8: ebffff54 bl 30031810 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED 30031abc: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
30031ac0: e3a03002 mov r3, #2 <== NOT EXECUTED 30031ac4: e5863038 str r3, [r6, #56] ; 0x38 <== NOT EXECUTED
the_period->next_length = length;
30031ac8: e586403c str r4, [r6, #60] ; 0x3c <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30031acc: e586401c str r4, [r6, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
30031ad0: e59f0040 ldr r0, [pc, #64] ; 30031b18 <rtems_rate_monotonic_period+0x1a4><== NOT EXECUTED 30031ad4: e2861010 add r1, r6, #16 <== NOT EXECUTED 30031ad8: ebff7017 bl 3000db3c <_Watchdog_Insert> <== NOT EXECUTED 30031adc: e5960040 ldr r0, [r6, #64] ; 0x40 <== NOT EXECUTED 30031ae0: e596103c ldr r1, [r6, #60] ; 0x3c <== NOT EXECUTED 30031ae4: e59f3030 ldr r3, [pc, #48] ; 30031b1c <rtems_rate_monotonic_period+0x1a8><== NOT EXECUTED 30031ae8: e1a0e00f mov lr, pc <== NOT EXECUTED 30031aec: e593f034 ldr pc, [r3, #52] ; 0x34 <== NOT EXECUTED
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
30031af0: e3a04006 mov r4, #6 <== NOT EXECUTED
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
30031af4: ebff6d33 bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TIMEOUT;
30031af8: ea000000 b 30031b00 <rtems_rate_monotonic_period+0x18c> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30031afc: e3a04004 mov r4, #4 <== NOT EXECUTED
}
30031b00: e1a00004 mov r0, r4
30031b04: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
30025fa8 <rtems_rate_monotonic_report_statistics>:
void rtems_rate_monotonic_report_statistics( void )
{
rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin );
30025fa8: e59f1004 ldr r1, [pc, #4] ; 30025fb4 <rtems_rate_monotonic_report_statistics+0xc><== NOT EXECUTED 30025fac: e3a00000 mov r0, #0 <== NOT EXECUTED 30025fb0: eaffff7f b 30025db4 <rtems_rate_monotonic_report_statistics_with_plugin><== NOT EXECUTED
30025db4 <rtems_rate_monotonic_report_statistics_with_plugin>:
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30025db4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
30025db8: e2514000 subs r4, r1, #0 <== NOT EXECUTED
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30025dbc: e24dd070 sub sp, sp, #112 ; 0x70 <== NOT EXECUTED 30025dc0: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
30025dc4: 0a00006b beq 30025f78 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c4><== NOT EXECUTED
return;
(*print)( context, "Period information by period\n" );
30025dc8: e59f11b0 ldr r1, [pc, #432] ; 30025f80 <rtems_rate_monotonic_report_statistics_with_plugin+0x1cc><== NOT EXECUTED 30025dcc: e1a0e00f mov lr, pc <== NOT EXECUTED 30025dd0: e12fff14 bx r4 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
30025dd4: e59f11a8 ldr r1, [pc, #424] ; 30025f84 <rtems_rate_monotonic_report_statistics_with_plugin+0x1d0><== NOT EXECUTED 30025dd8: e1a00005 mov r0, r5 <== NOT EXECUTED 30025ddc: e1a0e00f mov lr, pc <== NOT EXECUTED 30025de0: e12fff14 bx r4 <== NOT EXECUTED
(*print)( context, "--- Wall times are in seconds ---\n" );
30025de4: e59f119c ldr r1, [pc, #412] ; 30025f88 <rtems_rate_monotonic_report_statistics_with_plugin+0x1d4><== NOT EXECUTED 30025de8: e1a00005 mov r0, r5 <== NOT EXECUTED 30025dec: e1a0e00f mov lr, pc <== NOT EXECUTED 30025df0: e12fff14 bx r4 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
30025df4: e59f7190 ldr r7, [pc, #400] ; 30025f8c <rtems_rate_monotonic_report_statistics_with_plugin+0x1d8><== NOT EXECUTED
Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED "
30025df8: e59f1190 ldr r1, [pc, #400] ; 30025f90 <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc><== NOT EXECUTED 30025dfc: e1a00005 mov r0, r5 <== NOT EXECUTED 30025e00: e1a0e00f mov lr, pc <== NOT EXECUTED 30025e04: e12fff14 bx r4 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
30025e08: e1a00005 mov r0, r5 <== NOT EXECUTED 30025e0c: e59f1180 ldr r1, [pc, #384] ; 30025f94 <rtems_rate_monotonic_report_statistics_with_plugin+0x1e0><== NOT EXECUTED 30025e10: e1a0e00f mov lr, pc <== NOT EXECUTED 30025e14: e12fff14 bx r4 <== NOT EXECUTED
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
30025e18: e28d8028 add r8, sp, #40 ; 0x28 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
30025e1c: e5976008 ldr r6, [r7, #8] <== NOT EXECUTED 30025e20: ea000051 b 30025f6c <rtems_rate_monotonic_report_statistics_with_plugin+0x1b8><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
30025e24: e1a00006 mov r0, r6 <== NOT EXECUTED 30025e28: e28d1010 add r1, sp, #16 <== NOT EXECUTED 30025e2c: eb002da2 bl 300314bc <rtems_rate_monotonic_get_statistics> <== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL )
30025e30: e3500000 cmp r0, #0 <== NOT EXECUTED 30025e34: 1a00004b bne 30025f68 <rtems_rate_monotonic_report_statistics_with_plugin+0x1b4><== NOT EXECUTED
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
30025e38: e28d1048 add r1, sp, #72 ; 0x48 <== NOT EXECUTED 30025e3c: e1a00006 mov r0, r6 <== NOT EXECUTED 30025e40: eb002e08 bl 30031668 <rtems_rate_monotonic_get_status> <== NOT EXECUTED
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
30025e44: e3a01005 mov r1, #5 <== NOT EXECUTED 30025e48: e28d2068 add r2, sp, #104 ; 0x68 <== NOT EXECUTED 30025e4c: e59d0048 ldr r0, [sp, #72] ; 0x48 <== NOT EXECUTED 30025e50: ebffadde bl 300115d0 <rtems_object_get_name> <== NOT EXECUTED
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
30025e54: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30025e58: e59f1138 ldr r1, [pc, #312] ; 30025f98 <rtems_rate_monotonic_report_statistics_with_plugin+0x1e4><== NOT EXECUTED 30025e5c: e58d3000 str r3, [sp] <== NOT EXECUTED 30025e60: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 30025e64: e1a00005 mov r0, r5 <== NOT EXECUTED 30025e68: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 30025e6c: e1a02006 mov r2, r6 <== NOT EXECUTED 30025e70: e28d3068 add r3, sp, #104 ; 0x68 <== NOT EXECUTED 30025e74: e1a0e00f mov lr, pc <== NOT EXECUTED 30025e78: e12fff14 bx r4 <== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
30025e7c: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 30025e80: e3510000 cmp r1, #0 <== NOT EXECUTED 30025e84: 1a000004 bne 30025e9c <rtems_rate_monotonic_report_statistics_with_plugin+0xe8><== NOT EXECUTED
(*print)( context, "\n" );
30025e88: e1a00005 mov r0, r5 <== NOT EXECUTED 30025e8c: e59f1108 ldr r1, [pc, #264] ; 30025f9c <rtems_rate_monotonic_report_statistics_with_plugin+0x1e8><== NOT EXECUTED 30025e90: e1a0e00f mov lr, pc <== NOT EXECUTED 30025e94: e12fff14 bx r4 <== NOT EXECUTED
continue;
30025e98: ea000032 b 30025f68 <rtems_rate_monotonic_report_statistics_with_plugin+0x1b4><== NOT EXECUTED
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
30025e9c: e28d2060 add r2, sp, #96 ; 0x60 <== NOT EXECUTED 30025ea0: e1a00008 mov r0, r8 <== NOT EXECUTED 30025ea4: eb000270 bl 3002686c <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
30025ea8: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED 30025eac: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025eb0: eb009ffa bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025eb4: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 30025eb8: e1a0a000 mov sl, r0 <== NOT EXECUTED 30025ebc: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025ec0: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 30025ec4: e58d3000 str r3, [sp] <== NOT EXECUTED 30025ec8: eb009ff4 bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025ecc: e59d3060 ldr r3, [sp, #96] ; 0x60 <== NOT EXECUTED 30025ed0: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 30025ed4: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025ed8: e59d0064 ldr r0, [sp, #100] ; 0x64 <== NOT EXECUTED 30025edc: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 30025ee0: eb009fee bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025ee4: e1a0300a mov r3, sl <== NOT EXECUTED 30025ee8: e58d000c str r0, [sp, #12] <== NOT EXECUTED 30025eec: e59f10ac ldr r1, [pc, #172] ; 30025fa0 <rtems_rate_monotonic_report_statistics_with_plugin+0x1ec><== NOT EXECUTED 30025ef0: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 30025ef4: e1a00005 mov r0, r5 <== NOT EXECUTED 30025ef8: e1a0e00f mov lr, pc <== NOT EXECUTED 30025efc: e12fff14 bx r4 <== NOT EXECUTED
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
30025f00: e28d2060 add r2, sp, #96 ; 0x60 <== NOT EXECUTED 30025f04: e28d0040 add r0, sp, #64 ; 0x40 <== NOT EXECUTED 30025f08: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 30025f0c: eb000256 bl 3002686c <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
30025f10: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025f14: e59d0034 ldr r0, [sp, #52] ; 0x34 <== NOT EXECUTED 30025f18: eb009fe0 bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025f1c: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED 30025f20: e1a0a000 mov sl, r0 <== NOT EXECUTED 30025f24: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025f28: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED 30025f2c: e58d3000 str r3, [sp] <== NOT EXECUTED 30025f30: eb009fda bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025f34: e59d3060 ldr r3, [sp, #96] ; 0x60 <== NOT EXECUTED 30025f38: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 30025f3c: e3a01ffa mov r1, #1000 ; 0x3e8 <== NOT EXECUTED 30025f40: e59d0064 ldr r0, [sp, #100] ; 0x64 <== NOT EXECUTED 30025f44: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 30025f48: eb009fd4 bl 3004dea0 <__aeabi_idiv> <== NOT EXECUTED 30025f4c: e59f1050 ldr r1, [pc, #80] ; 30025fa4 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f0><== NOT EXECUTED 30025f50: e58d000c str r0, [sp, #12] <== NOT EXECUTED 30025f54: e59d2030 ldr r2, [sp, #48] ; 0x30 <== NOT EXECUTED 30025f58: e1a00005 mov r0, r5 <== NOT EXECUTED 30025f5c: e1a0300a mov r3, sl <== NOT EXECUTED 30025f60: e1a0e00f mov lr, pc <== NOT EXECUTED 30025f64: e12fff14 bx r4 <== NOT EXECUTED
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
30025f68: e2866001 add r6, r6, #1 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
30025f6c: e597300c ldr r3, [r7, #12] <== NOT EXECUTED 30025f70: e1560003 cmp r6, r3 <== NOT EXECUTED 30025f74: 9affffaa bls 30025e24 <rtems_rate_monotonic_report_statistics_with_plugin+0x70><== NOT EXECUTED
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
30025f78: e28dd070 add sp, sp, #112 ; 0x70 <== NOT EXECUTED
30025f7c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30025fb8 <rtems_rate_monotonic_reset_all_statistics>:
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
30025fb8: e59f3038 ldr r3, [pc, #56] ; 30025ff8 <rtems_rate_monotonic_reset_all_statistics+0x40><== NOT EXECUTED
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
30025fbc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30025fc0: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
30025fc4: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30025fc8: e5832000 str r2, [r3] <== NOT EXECUTED
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
30025fcc: e59f5028 ldr r5, [pc, #40] ; 30025ffc <rtems_rate_monotonic_reset_all_statistics+0x44><== NOT EXECUTED 30025fd0: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED 30025fd4: ea000002 b 30025fe4 <rtems_rate_monotonic_reset_all_statistics+0x2c><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
30025fd8: e1a00004 mov r0, r4 <== NOT EXECUTED 30025fdc: eb000007 bl 30026000 <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++ ) {
30025fe0: e2844001 add r4, r4, #1 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
30025fe4: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 30025fe8: e1540003 cmp r4, r3 <== NOT EXECUTED 30025fec: 9afffff9 bls 30025fd8 <rtems_rate_monotonic_reset_all_statistics+0x20><== NOT EXECUTED
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
30025ff0: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
30025ff4: eaff9bf3 b 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED
30026000 <rtems_rate_monotonic_reset_statistics>:
*/
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
30026000: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
30026004: e1a01000 mov r1, r0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
30026008: e1a0200d mov r2, sp <== NOT EXECUTED 3002600c: e59f0048 ldr r0, [pc, #72] ; 3002605c <rtems_rate_monotonic_reset_statistics+0x5c><== NOT EXECUTED 30026010: ebff988b bl 3000c244 <_Objects_Get> <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30026014: e59d4000 ldr r4, [sp] <== NOT EXECUTED 30026018: e1a05000 mov r5, r0 <== NOT EXECUTED 3002601c: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30026020: 13a00004 movne r0, #4 <== NOT EXECUTED
{
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30026024: 1a00000b bne 30026058 <rtems_rate_monotonic_reset_statistics+0x58><== NOT EXECUTED
case OBJECTS_LOCAL:
_Rate_monotonic_Reset_statistics( the_period );
30026028: e1a01004 mov r1, r4 <== NOT EXECUTED 3002602c: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 30026030: e2850054 add r0, r5, #84 ; 0x54 <== NOT EXECUTED 30026034: eb0048c2 bl 30038344 <memset> <== NOT EXECUTED 30026038: e59f2020 ldr r2, [pc, #32] ; 30026060 <rtems_rate_monotonic_reset_statistics+0x60><== NOT EXECUTED 3002603c: e59f3020 ldr r3, [pc, #32] ; 30026064 <rtems_rate_monotonic_reset_statistics+0x64><== NOT EXECUTED 30026040: e585205c str r2, [r5, #92] ; 0x5c <== NOT EXECUTED 30026044: e5853060 str r3, [r5, #96] ; 0x60 <== NOT EXECUTED 30026048: e5852074 str r2, [r5, #116] ; 0x74 <== NOT EXECUTED 3002604c: e5853078 str r3, [r5, #120] ; 0x78 <== NOT EXECUTED
_Thread_Enable_dispatch();
30026050: ebff9bdc bl 3000cfc8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30026054: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30026058: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000b29c <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
3000b29c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
void *ptr = NULL; rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment;
3000b2a0: e5906030 ldr r6, [r0, #48] ; 0x30 <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
3000b2a4: e1a05001 mov r5, r1 <== NOT EXECUTED 3000b2a8: e1a04000 mov r4, r0 <== NOT EXECUTED
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
3000b2ac: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b2b0: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b2b4: eb003f17 bl 3001af18 <__umodsi3> <== NOT EXECUTED
if (excess > 0) {
3000b2b8: e3500000 cmp r0, #0 <== NOT EXECUTED
value += alignment - excess;
3000b2bc: 10856006 addne r6, r5, r6 <== NOT EXECUTED 3000b2c0: 10606006 rsbne r6, r0, r6 <== NOT EXECUTED
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
if (excess > 0) {
3000b2c4: 01a06005 moveq r6, r5 <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
3000b2c8: e1550006 cmp r5, r6 <== NOT EXECUTED 3000b2cc: 83a00000 movhi r0, #0 <== NOT EXECUTED 3000b2d0: 93a00001 movls r0, #1 <== NOT EXECUTED 3000b2d4: e3550000 cmp r5, #0 <== NOT EXECUTED 3000b2d8: 03a00000 moveq r0, #0 <== NOT EXECUTED 3000b2dc: e3500000 cmp r0, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
3000b2e0: 11a02004 movne r2, r4 <== NOT EXECUTED 3000b2e4: 14923004 ldrne r3, [r2], #4 <== NOT EXECUTED
size_t size
)
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
3000b2e8: 13a07000 movne r7, #0 <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
3000b2ec: 1a000005 bne 3000b308 <rtems_rbheap_allocate+0x6c> <== NOT EXECUTED
3000b2f0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
3000b2f4: e593701c ldr r7, [r3, #28] <== NOT EXECUTED 3000b2f8: e1570006 cmp r7, r6 <== NOT EXECUTED 3000b2fc: 21a07003 movcs r7, r3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3000b300: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000b304: 33a07000 movcc r7, #0 <== NOT EXECUTED
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
3000b308: e2778001 rsbs r8, r7, #1 <== NOT EXECUTED 3000b30c: 33a08000 movcc r8, #0 <== NOT EXECUTED 3000b310: e1530002 cmp r3, r2 <== NOT EXECUTED 3000b314: 03a08000 moveq r8, #0 <== NOT EXECUTED 3000b318: e3580000 cmp r8, #0 <== NOT EXECUTED 3000b31c: 1afffff4 bne 3000b2f4 <rtems_rbheap_allocate+0x58> <== NOT EXECUTED
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
3000b320: e3570000 cmp r7, #0 <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
3000b324: 01a00007 moveq r0, r7 <== NOT EXECUTED
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
3000b328: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
uintptr_t free_size = free_chunk->size;
3000b32c: e597901c ldr r9, [r7, #28] <== NOT EXECUTED
if (free_size > aligned_size) {
3000b330: e1590006 cmp r9, r6 <== NOT EXECUTED 3000b334: 9a00001f bls 3000b3b8 <rtems_rbheap_allocate+0x11c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000b338: e1a0a004 mov sl, r4 <== NOT EXECUTED 3000b33c: e5ba500c ldr r5, [sl, #12]! <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000b340: e2843010 add r3, r4, #16 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
3000b344: e1550003 cmp r5, r3 <== NOT EXECUTED
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
3000b348: 15953000 ldrne r3, [r5] <== NOT EXECUTED
head->next = new_first;
3000b34c: 1584300c strne r3, [r4, #12] <== NOT EXECUTED
new_first->previous = head;
3000b350: 1583a004 strne sl, [r3, #4] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
3000b354: 1a000009 bne 3000b380 <rtems_rbheap_allocate+0xe4> <== NOT EXECUTED
{
rtems_chain_control *chain = &control->spare_descriptor_chain;
rtems_chain_node *chunk = rtems_chain_get_unprotected(chain);
if (chunk == NULL) {
(*control->extend_descriptors)(control);
3000b358: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b35c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b360: e594f034 ldr pc, [r4, #52] ; 0x34 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000b364: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
3000b368: e1530005 cmp r3, r5 <== NOT EXECUTED 3000b36c: 0a000018 beq 3000b3d4 <rtems_rbheap_allocate+0x138> <== NOT EXECUTED
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
3000b370: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
new_first->previous = head;
3000b374: e1a05003 mov r5, r3 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
3000b378: e584200c str r2, [r4, #12] <== NOT EXECUTED
new_first->previous = head;
3000b37c: e582a004 str sl, [r2, #4] <== NOT EXECUTED
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
3000b380: e5973018 ldr r3, [r7, #24] <== NOT EXECUTED
if (free_size > aligned_size) {
rtems_rbheap_chunk *new_chunk = get_chunk(control);
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
3000b384: e0669009 rsb r9, r6, r9 <== NOT EXECUTED
free_chunk->size = new_free_size;
3000b388: e587901c str r9, [r7, #28] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
3000b38c: e1a01005 mov r1, r5 <== NOT EXECUTED
new_chunk->begin = free_chunk->begin + new_free_size;
3000b390: e0899003 add r9, r9, r3 <== NOT EXECUTED 3000b394: e3a03000 mov r3, #0 <== NOT EXECUTED 3000b398: e5859018 str r9, [r5, #24] <== NOT EXECUTED
new_chunk->size = aligned_size;
3000b39c: e585601c str r6, [r5, #28] <== NOT EXECUTED 3000b3a0: e5853004 str r3, [r5, #4] <== NOT EXECUTED 3000b3a4: e4813008 str r3, [r1], #8 <== NOT EXECUTED
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
3000b3a8: e2840018 add r0, r4, #24 <== NOT EXECUTED 3000b3ac: eb000648 bl 3000ccd4 <_RBTree_Insert_unprotected> <== NOT EXECUTED
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
rtems_chain_set_off_chain(&new_chunk->chain_node);
insert_into_tree(chunk_tree, new_chunk);
ptr = (void *) new_chunk->begin;
3000b3b0: e5950018 ldr r0, [r5, #24] <== NOT EXECUTED
3000b3b4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3000b3b8: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
3000b3bc: e5970018 ldr r0, [r7, #24] <== NOT EXECUTED
next->previous = previous;
3000b3c0: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
3000b3c4: e5832000 str r2, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
3000b3c8: e5878004 str r8, [r7, #4] <== NOT EXECUTED
3000b3cc: e5878000 str r8, [r7] <== NOT EXECUTED
3000b3d0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
3000b3d4: e1a00008 mov r0, r8 <== NOT EXECUTED
}
}
}
return ptr;
}
3000b3d8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
3000b55c <rtems_rbheap_extend_descriptors_never>:
void rtems_rbheap_extend_descriptors_never(rtems_rbheap_control *control)
{
/* Do nothing */
}
3000b55c: e12fff1e bx lr <== NOT EXECUTED
3000b560 <rtems_rbheap_extend_descriptors_with_malloc>:
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
3000b560: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b564: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
3000b568: e3a00020 mov r0, #32 <== NOT EXECUTED 3000b56c: ebffeea1 bl 30006ff8 <malloc> <== NOT EXECUTED
if (chunk != NULL) {
3000b570: e3500000 cmp r0, #0 <== NOT EXECUTED
3000b574: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
3000b578: e284300c add r3, r4, #12 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b57c: e5803004 str r3, [r0, #4] <== NOT EXECUTED
before_node = after_node->next;
3000b580: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
after_node->next = the_node;
3000b584: e584000c str r0, [r4, #12] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b588: e5830004 str r0, [r3, #4] <== NOT EXECUTED
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
3000b58c: e5803000 str r3, [r0] <== NOT EXECUTED
3000b590: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b3dc <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
3000b3dc: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
3000b3e0: e2516000 subs r6, r1, #0 <== NOT EXECUTED
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
3000b3e4: e24dd020 sub sp, sp, #32 <== NOT EXECUTED 3000b3e8: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
3000b3ec: 0a000057 beq 3000b550 <rtems_rbheap_free+0x174> <== NOT EXECUTED
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
3000b3f0: e1a0000d mov r0, sp <== NOT EXECUTED 3000b3f4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000b3f8: e3a02020 mov r2, #32 <== NOT EXECUTED
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
3000b3fc: e3a04000 mov r4, #0 <== NOT EXECUTED 3000b400: eb001cfd bl 300127fc <memset> <== NOT EXECUTED
return rtems_rbheap_chunk_of_node(
3000b404: e08d3004 add r3, sp, r4 <== NOT EXECUTED
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
3000b408: e58d6018 str r6, [sp, #24] <== NOT EXECUTED
return rtems_rbheap_chunk_of_node(
3000b40c: e2837008 add r7, r3, #8 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
3000b410: e595601c ldr r6, [r5, #28] <== NOT EXECUTED 3000b414: ea00000d b 3000b450 <rtems_rbheap_free+0x74> <== NOT EXECUTED
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
3000b418: e1a00007 mov r0, r7 <== NOT EXECUTED 3000b41c: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b420: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b424: e595f028 ldr pc, [r5, #40] ; 0x28 <== NOT EXECUTED
if ( _RBTree_Is_equal( compare_result ) ) {
3000b428: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b42c: 1a000003 bne 3000b440 <rtems_rbheap_free+0x64> <== NOT EXECUTED
found = iter_node;
if ( the_rbtree->is_unique )
3000b430: e5d5302c ldrb r3, [r5, #44] ; 0x2c <== NOT EXECUTED 3000b434: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b438: 1a000007 bne 3000b45c <rtems_rbheap_free+0x80> <== NOT EXECUTED 3000b43c: e1a04006 mov r4, r6 <== NOT EXECUTED
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
3000b440: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b444: c3a00008 movgt r0, #8 <== NOT EXECUTED 3000b448: d3a00004 movle r0, #4 <== NOT EXECUTED 3000b44c: e7906006 ldr r6, [r0, r6] <== NOT EXECUTED
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
3000b450: e3560000 cmp r6, #0 <== NOT EXECUTED 3000b454: 1affffef bne 3000b418 <rtems_rbheap_free+0x3c> <== NOT EXECUTED 3000b458: e1a06004 mov r6, r4 <== NOT EXECUTED 3000b45c: e2464008 sub r4, r6, #8 <== NOT EXECUTED
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
3000b460: e3740008 cmn r4, #8 <== NOT EXECUTED
check_and_merge(free_chain, chunk_tree, chunk, pred);
} else {
sc = RTEMS_INCORRECT_STATE;
}
} else {
sc = RTEMS_INVALID_ID;
3000b464: 03a06004 moveq r6, #4 <== NOT EXECUTED
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
3000b468: 0a000038 beq 3000b550 <rtems_rbheap_free+0x174> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
3000b46c: e5163008 ldr r3, [r6, #-8] <== NOT EXECUTED 3000b470: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b474: 13a0a000 movne sl, #0 <== NOT EXECUTED 3000b478: 1a000002 bne 3000b488 <rtems_rbheap_free+0xac> <== NOT EXECUTED
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
3000b47c: e594a004 ldr sl, [r4, #4] <== NOT EXECUTED 3000b480: e27aa001 rsbs sl, sl, #1 <== NOT EXECUTED 3000b484: 33a0a000 movcc sl, #0 <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
3000b488: e23aa001 eors sl, sl, #1 <== NOT EXECUTED
check_and_merge(free_chain, chunk_tree, chunk, succ);
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
} else {
sc = RTEMS_INCORRECT_STATE;
3000b48c: 13a0600e movne r6, #14 <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
3000b490: 1a00002e bne 3000b550 <rtems_rbheap_free+0x174> <== NOT EXECUTED
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
3000b494: e2849008 add r9, r4, #8 <== NOT EXECUTED 3000b498: e1a0100a mov r1, sl <== NOT EXECUTED 3000b49c: e1a00009 mov r0, r9 <== NOT EXECUTED 3000b4a0: eb000690 bl 3000cee8 <_RBTree_Next_unprotected> <== NOT EXECUTED 3000b4a4: e3a01001 mov r1, #1 <== NOT EXECUTED 3000b4a8: e1a06000 mov r6, r0 <== NOT EXECUTED 3000b4ac: e2408008 sub r8, r0, #8 <== NOT EXECUTED 3000b4b0: e1a00009 mov r0, r9 <== NOT EXECUTED 3000b4b4: eb00068b bl 3000cee8 <_RBTree_Next_unprotected> <== NOT EXECUTED 3000b4b8: e2403008 sub r3, r0, #8 <== NOT EXECUTED
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
3000b4bc: e3730008 cmn r3, #8 <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
3000b4c0: e2857018 add r7, r5, #24 <== NOT EXECUTED
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
3000b4c4: 0a00000a beq 3000b4f4 <rtems_rbheap_free+0x118> <== NOT EXECUTED 3000b4c8: e5102008 ldr r2, [r0, #-8] <== NOT EXECUTED 3000b4cc: e3520000 cmp r2, #0 <== NOT EXECUTED 3000b4d0: 1a000002 bne 3000b4e0 <rtems_rbheap_free+0x104> <== NOT EXECUTED
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
3000b4d4: e510a004 ldr sl, [r0, #-4] <== NOT EXECUTED 3000b4d8: e27aa001 rsbs sl, sl, #1 <== NOT EXECUTED 3000b4dc: 33a0a000 movcc sl, #0 <== NOT EXECUTED
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
3000b4e0: e35a0000 cmp sl, #0 <== NOT EXECUTED 3000b4e4: 01a00005 moveq r0, r5 <== NOT EXECUTED 3000b4e8: 01a01007 moveq r1, r7 <== NOT EXECUTED 3000b4ec: 01a02004 moveq r2, r4 <== NOT EXECUTED 3000b4f0: 0bffff08 bleq 3000b118 <check_and_merge.part.1> <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b4f4: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000b4f8: e3780008 cmn r8, #8 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b4fc: e5845004 str r5, [r4, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b500: e5854000 str r4, [r5] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b504: e5834004 str r4, [r3, #4] <== NOT EXECUTED
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
3000b508: e5843000 str r3, [r4] <== NOT EXECUTED 3000b50c: 0a00000e beq 3000b54c <rtems_rbheap_free+0x170> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
3000b510: e5163008 ldr r3, [r6, #-8] <== NOT EXECUTED 3000b514: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b518: 13a06000 movne r6, #0 <== NOT EXECUTED 3000b51c: 1a000002 bne 3000b52c <rtems_rbheap_free+0x150> <== NOT EXECUTED
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
3000b520: e5166004 ldr r6, [r6, #-4] <== NOT EXECUTED 3000b524: e2766001 rsbs r6, r6, #1 <== NOT EXECUTED 3000b528: 33a06000 movcc r6, #0 <== NOT EXECUTED
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
3000b52c: e21660ff ands r6, r6, #255 ; 0xff <== NOT EXECUTED 3000b530: 1a000005 bne 3000b54c <rtems_rbheap_free+0x170> <== NOT EXECUTED 3000b534: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b538: e1a01007 mov r1, r7 <== NOT EXECUTED 3000b53c: e1a02004 mov r2, r4 <== NOT EXECUTED 3000b540: e1a03008 mov r3, r8 <== NOT EXECUTED 3000b544: ebfffef3 bl 3000b118 <check_and_merge.part.1> <== NOT EXECUTED 3000b548: ea000000 b 3000b550 <rtems_rbheap_free+0x174> <== NOT EXECUTED
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
3000b54c: e3a06000 mov r6, #0 <== NOT EXECUTED
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
3000b550: e1a00006 mov r0, r6 <== NOT EXECUTED
3000b554: e28dd020 add sp, sp, #32 <== NOT EXECUTED
3000b558: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
3000b178 <rtems_rbheap_initialize>:
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
3000b178: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
3000b17c: e2538000 subs r8, r3, #0 <== NOT EXECUTED
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
3000b180: e1a04000 mov r4, r0 <== NOT EXECUTED 3000b184: e1a05001 mov r5, r1 <== NOT EXECUTED 3000b188: e59d6024 ldr r6, [sp, #36] ; 0x24 <== NOT EXECUTED
}
} else {
sc = RTEMS_INVALID_ADDRESS;
}
} else {
sc = RTEMS_INVALID_NUMBER;
3000b18c: 03a0000a moveq r0, #10 <== NOT EXECUTED
void *handler_arg
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (alignment > 0) {
3000b190: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
3000b194: e081a002 add sl, r1, r2 <== NOT EXECUTED
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
3000b198: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b19c: e1a01008 mov r1, r8 <== NOT EXECUTED 3000b1a0: eb003f5c bl 3001af18 <__umodsi3> <== NOT EXECUTED
if (excess > 0) {
3000b1a4: e3500000 cmp r0, #0 <== NOT EXECUTED
value += alignment - excess;
3000b1a8: 10857008 addne r7, r5, r8 <== NOT EXECUTED 3000b1ac: 10607007 rsbne r7, r0, r7 <== NOT EXECUTED
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
if (excess > 0) {
3000b1b0: 01a07005 moveq r7, r5 <== NOT EXECUTED
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
3000b1b4: e1550007 cmp r5, r7 <== NOT EXECUTED 3000b1b8: 9155000a cmpls r5, sl <== NOT EXECUTED 3000b1bc: 2a000031 bcs 3000b288 <rtems_rbheap_initialize+0x110> <== NOT EXECUTED
return value;
}
static uintptr_t align_down(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
3000b1c0: e1a0000a mov r0, sl <== NOT EXECUTED 3000b1c4: e1a01008 mov r1, r8 <== NOT EXECUTED 3000b1c8: eb003f52 bl 3001af18 <__umodsi3> <== NOT EXECUTED
return value - excess;
3000b1cc: e060a00a rsb sl, r0, sl <== NOT EXECUTED
uintptr_t begin = (uintptr_t) area_begin;
uintptr_t end = begin + area_size;
uintptr_t aligned_begin = align_up(alignment, begin);
uintptr_t aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
3000b1d0: e157000a cmp r7, sl <== NOT EXECUTED 3000b1d4: 2a00002b bcs 3000b288 <rtems_rbheap_initialize+0x110> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3000b1d8: e2843004 add r3, r4, #4 <== NOT EXECUTED
head->next = tail;
3000b1dc: e5843000 str r3, [r4] <== NOT EXECUTED
{
the_rbtree->permanent_null = NULL;
the_rbtree->root = NULL;
the_rbtree->first[0] = NULL;
the_rbtree->first[1] = NULL;
the_rbtree->compare_function = compare_function;
3000b1e0: e59f30b0 ldr r3, [pc, #176] ; 3000b298 <rtems_rbheap_initialize+0x120><== NOT EXECUTED
head->previous = NULL;
3000b1e4: e3a05000 mov r5, #0 <== NOT EXECUTED 3000b1e8: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
the_rbtree->is_unique = is_unique;
3000b1ec: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b1f0: e5c4302c strb r3, [r4, #44] ; 0x2c <== NOT EXECUTED
rtems_chain_initialize_empty(free_chain);
rtems_chain_initialize_empty(&control->spare_descriptor_chain);
rtems_rbtree_initialize_empty(chunk_tree, chunk_compare, true);
control->alignment = alignment;
control->handler_arg = handler_arg;
3000b1f4: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3000b1f8: e284b010 add fp, r4, #16 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
3000b1fc: e284900c add r9, r4, #12 <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3000b200: e5845004 str r5, [r4, #4] <== NOT EXECUTED
tail->previous = head;
3000b204: e5844008 str r4, [r4, #8] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000b208: e584b00c str fp, [r4, #12] <== NOT EXECUTED
head->previous = NULL;
3000b20c: e5845010 str r5, [r4, #16] <== NOT EXECUTED
tail->previous = head;
3000b210: e5849014 str r9, [r4, #20] <== NOT EXECUTED
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
3000b214: e5845018 str r5, [r4, #24] <== NOT EXECUTED
the_rbtree->root = NULL;
3000b218: e584501c str r5, [r4, #28] <== NOT EXECUTED
the_rbtree->first[0] = NULL;
3000b21c: e5845020 str r5, [r4, #32] <== NOT EXECUTED
the_rbtree->first[1] = NULL;
3000b220: e5845024 str r5, [r4, #36] ; 0x24 <== NOT EXECUTED
rtems_rbheap_chunk *first = NULL;
rtems_chain_initialize_empty(free_chain);
rtems_chain_initialize_empty(&control->spare_descriptor_chain);
rtems_rbtree_initialize_empty(chunk_tree, chunk_compare, true);
control->alignment = alignment;
3000b224: e5848030 str r8, [r4, #48] ; 0x30 <== NOT EXECUTED
control->handler_arg = handler_arg;
3000b228: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
control->extend_descriptors = extend_descriptors;
3000b22c: e5846034 str r6, [r4, #52] ; 0x34 <== NOT EXECUTED
{
rtems_chain_control *chain = &control->spare_descriptor_chain;
rtems_chain_node *chunk = rtems_chain_get_unprotected(chain);
if (chunk == NULL) {
(*control->extend_descriptors)(control);
3000b230: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b234: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b238: e12fff16 bx r6 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
3000b23c: e594100c ldr r1, [r4, #12] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
3000b240: e151000b cmp r1, fp <== NOT EXECUTED 3000b244: 0a000011 beq 3000b290 <rtems_rbheap_initialize+0x118> <== NOT EXECUTED
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
3000b248: e5913000 ldr r3, [r1] <== NOT EXECUTED
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
3000b24c: e1a00004 mov r0, r4 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
3000b250: e584300c str r3, [r4, #12] <== NOT EXECUTED
new_first->previous = head;
3000b254: e5839004 str r9, [r3, #4] <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000b258: e5943000 ldr r3, [r4] <== NOT EXECUTED
control->extend_descriptors = extend_descriptors;
first = get_chunk(control);
if (first != NULL) {
first->begin = aligned_begin;
first->size = aligned_end - aligned_begin;
3000b25c: e067a00a rsb sl, r7, sl <== NOT EXECUTED
control->handler_arg = handler_arg;
control->extend_descriptors = extend_descriptors;
first = get_chunk(control);
if (first != NULL) {
first->begin = aligned_begin;
3000b260: e5817018 str r7, [r1, #24] <== NOT EXECUTED
first->size = aligned_end - aligned_begin;
3000b264: e581a01c str sl, [r1, #28] <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b268: e5814004 str r4, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b26c: e4801018 str r1, [r0], #24 <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b270: e5831004 str r1, [r3, #4] <== NOT EXECUTED
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
3000b274: e5813000 str r3, [r1] <== NOT EXECUTED
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
3000b278: e2811008 add r1, r1, #8 <== NOT EXECUTED 3000b27c: eb000694 bl 3000ccd4 <_RBTree_Insert_unprotected> <== NOT EXECUTED
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
3000b280: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b284: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_ADDRESS;
3000b288: e3a00009 mov r0, #9 <== NOT EXECUTED
3000b28c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
first->begin = aligned_begin;
first->size = aligned_end - aligned_begin;
add_to_chain(free_chain, first);
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
3000b290: e3a0001a mov r0, #26 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
3000b294: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
300176a4 <rtems_region_create>:
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
300176a4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
300176a8: e2509000 subs r9, r0, #0
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
300176ac: e1a06001 mov r6, r1 300176b0: e1a07002 mov r7, r2 300176b4: e1a08003 mov r8, r3 300176b8: e59da024 ldr sl, [sp, #36] ; 0x24 300176bc: e59db028 ldr fp, [sp, #40] ; 0x28
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
300176c0: 03a06003 moveq r6, #3
)
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
300176c4: 0a000031 beq 30017790 <rtems_region_create+0xec>
return RTEMS_INVALID_NAME;
if ( !starting_address )
300176c8: e3560000 cmp r6, #0
300176cc: 0a00002e beq 3001778c <rtems_region_create+0xe8>
return RTEMS_INVALID_ADDRESS;
if ( !id )
300176d0: e35b0000 cmp fp, #0
300176d4: 0a00002c beq 3001778c <rtems_region_create+0xe8>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
300176d8: e59f30b8 ldr r3, [pc, #184] ; 30017798 <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 );
300176dc: e59f50b8 ldr r5, [pc, #184] ; 3001779c <rtems_region_create+0xf8> 300176e0: e5930000 ldr r0, [r3] 300176e4: eb00095c bl 30019c5c <_API_Mutex_Lock> 300176e8: e1a00005 mov r0, r5 300176ec: eb000f6c bl 3001b4a4 <_Objects_Allocate>
the_region = _Region_Allocate();
if ( !the_region )
300176f0: e2504000 subs r4, r0, #0
return_status = RTEMS_TOO_MANY;
300176f4: 03a06005 moveq r6, #5
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Allocate();
if ( !the_region )
300176f8: 0a00001f beq 3001777c <rtems_region_create+0xd8>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
300176fc: e2840068 add r0, r4, #104 ; 0x68 30017700: e1a01006 mov r1, r6 30017704: e1a02007 mov r2, r7 30017708: e1a03008 mov r3, r8 3001770c: eb000e40 bl 3001b014 <_Heap_Initialize>
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
30017710: e3500000 cmp r0, #0
if ( !the_region )
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
30017714: e584005c str r0, [r4, #92] ; 0x5c
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
30017718: 1a000004 bne 30017730 <rtems_region_create+0x8c>
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
3001771c: e1a00005 mov r0, r5 <== NOT EXECUTED 30017720: e1a01004 mov r1, r4 <== NOT EXECUTED 30017724: eb00102d bl 3001b7e0 <_Objects_Free> <== NOT EXECUTED
_Region_Free( the_region );
return_status = RTEMS_INVALID_SIZE;
30017728: e3a06008 mov r6, #8 <== NOT EXECUTED 3001772c: ea000012 b 3001777c <rtems_region_create+0xd8> <== NOT EXECUTED
}
else {
the_region->starting_address = starting_address;
30017730: e5846050 str r6, [r4, #80] ; 0x50
the_region->length = length;
the_region->page_size = page_size;
the_region->attribute_set = attribute_set;
the_region->number_of_used_blocks = 0;
_Thread_queue_Initialize(
30017734: e31a0004 tst sl, #4
the_region->starting_address = starting_address;
the_region->length = length;
the_region->page_size = page_size;
the_region->attribute_set = attribute_set;
the_region->number_of_used_blocks = 0;
30017738: e3a06000 mov r6, #0
_Thread_queue_Initialize(
3001773c: 03a01000 moveq r1, #0 30017740: 13a01001 movne r1, #1 30017744: e3a02040 mov r2, #64 ; 0x40 30017748: e3a03006 mov r3, #6
}
else {
the_region->starting_address = starting_address;
the_region->length = length;
3001774c: e5847054 str r7, [r4, #84] ; 0x54
the_region->page_size = page_size;
30017750: e5848058 str r8, [r4, #88] ; 0x58
the_region->attribute_set = attribute_set;
30017754: e584a060 str sl, [r4, #96] ; 0x60
the_region->number_of_used_blocks = 0;
30017758: e5846064 str r6, [r4, #100] ; 0x64
_Thread_queue_Initialize(
3001775c: e2840010 add r0, r4, #16 30017760: eb0015c6 bl 3001ce80 <_Thread_queue_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30017764: e595201c ldr r2, [r5, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30017768: e5943008 ldr r3, [r4, #8] 3001776c: e1d410b8 ldrh r1, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30017770: e7824101 str r4, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30017774: e584900c str r9, [r4, #12]
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
30017778: e58b3000 str r3, [fp]
return_status = RTEMS_SUCCESSFUL;
}
}
_RTEMS_Unlock_allocator();
3001777c: e59f3014 ldr r3, [pc, #20] ; 30017798 <rtems_region_create+0xf4> 30017780: e5930000 ldr r0, [r3] 30017784: eb00094d bl 30019cc0 <_API_Mutex_Unlock>
return return_status;
30017788: ea000000 b 30017790 <rtems_region_create+0xec>
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3001778c: e3a06009 mov r6, #9 <== NOT EXECUTED
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
30017790: e1a00006 mov r0, r6
30017794: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
30017818 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
30017818: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
uintptr_t amount_extended;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
3001781c: e2517000 subs r7, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
30017820: e1a04000 mov r4, r0 <== NOT EXECUTED 30017824: e1a06002 mov r6, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
30017828: 03a05009 moveq r5, #9 <== NOT EXECUTED
uintptr_t amount_extended;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
3001782c: 0a00001c beq 300178a4 <rtems_region_extend+0x8c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
30017830: e59f3074 ldr r3, [pc, #116] ; 300178ac <rtems_region_extend+0x94><== NOT EXECUTED 30017834: e5930000 ldr r0, [r3] <== NOT EXECUTED 30017838: eb000907 bl 30019c5c <_API_Mutex_Lock> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
3001783c: e1a01004 mov r1, r4 <== NOT EXECUTED 30017840: e59f0068 ldr r0, [pc, #104] ; 300178b0 <rtems_region_extend+0x98><== NOT EXECUTED 30017844: e1a0200d mov r2, sp <== NOT EXECUTED 30017848: eb001039 bl 3001b934 <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
3001784c: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30017850: e1a04000 mov r4, r0 <== NOT EXECUTED 30017854: e3550000 cmp r5, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30017858: 13a05004 movne r5, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Get( id, &location );
switch ( location ) {
3001785c: 1a00000d bne 30017898 <rtems_region_extend+0x80> <== NOT EXECUTED
case OBJECTS_LOCAL:
amount_extended = _Heap_Extend(
30017860: e1a03005 mov r3, r5 <== NOT EXECUTED 30017864: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017868: e1a01007 mov r1, r7 <== NOT EXECUTED 3001786c: e1a02006 mov r2, r6 <== NOT EXECUTED 30017870: eb000c16 bl 3001a8d0 <_Heap_Extend> <== NOT EXECUTED
starting_address,
length,
0
);
if ( amount_extended > 0 ) {
30017874: e3500000 cmp r0, #0 <== NOT EXECUTED
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
} else {
return_status = RTEMS_INVALID_ADDRESS;
30017878: 03a05009 moveq r5, #9 <== NOT EXECUTED
starting_address,
length,
0
);
if ( amount_extended > 0 ) {
3001787c: 0a000005 beq 30017898 <rtems_region_extend+0x80> <== NOT EXECUTED
the_region->length += amount_extended;
30017880: e5943054 ldr r3, [r4, #84] ; 0x54 <== NOT EXECUTED 30017884: e0833000 add r3, r3, r0 <== NOT EXECUTED 30017888: e5843054 str r3, [r4, #84] ; 0x54 <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
3001788c: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED 30017890: e0830000 add r0, r3, r0 <== NOT EXECUTED 30017894: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30017898: e59f300c ldr r3, [pc, #12] ; 300178ac <rtems_region_extend+0x94><== NOT EXECUTED 3001789c: e5930000 ldr r0, [r3] <== NOT EXECUTED 300178a0: eb000906 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
300178a4: e1a00005 mov r0, r5 <== NOT EXECUTED
300178a8: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
300178b4 <rtems_region_get_free_information>:
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
300178b4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
300178b8: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
300178bc: e1a05000 mov r5, r0 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
300178c0: 03a05009 moveq r5, #9 <== NOT EXECUTED
{
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
300178c4: 0a000013 beq 30017918 <rtems_region_get_free_information+0x64><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
300178c8: e59f3050 ldr r3, [pc, #80] ; 30017920 <rtems_region_get_free_information+0x6c><== NOT EXECUTED 300178cc: e5930000 ldr r0, [r3] <== NOT EXECUTED 300178d0: eb0008e1 bl 30019c5c <_API_Mutex_Lock> <== NOT EXECUTED 300178d4: e1a01005 mov r1, r5 <== NOT EXECUTED 300178d8: e59f0044 ldr r0, [pc, #68] ; 30017924 <rtems_region_get_free_information+0x70><== NOT EXECUTED 300178dc: e1a0200d mov r2, sp <== NOT EXECUTED 300178e0: eb001013 bl 3001b934 <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
300178e4: e59d5000 ldr r5, [sp] <== NOT EXECUTED 300178e8: e3550000 cmp r5, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
300178ec: 13a05004 movne r5, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
300178f0: 1a000005 bne 3001790c <rtems_region_get_free_information+0x58><== NOT EXECUTED
case OBJECTS_LOCAL:
the_info->Used.number = 0;
300178f4: e584500c str r5, [r4, #12] <== NOT EXECUTED
the_info->Used.total = 0;
300178f8: e5845014 str r5, [r4, #20] <== NOT EXECUTED
the_info->Used.largest = 0;
300178fc: e5845010 str r5, [r4, #16] <== NOT EXECUTED
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
30017900: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017904: e1a01004 mov r1, r4 <== NOT EXECUTED 30017908: eb000d19 bl 3001ad74 <_Heap_Get_free_information> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
3001790c: e59f300c ldr r3, [pc, #12] ; 30017920 <rtems_region_get_free_information+0x6c><== NOT EXECUTED 30017910: e5930000 ldr r0, [r3] <== NOT EXECUTED 30017914: eb0008e9 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30017918: e1a00005 mov r0, r5 <== NOT EXECUTED
3001791c: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
30017928 <rtems_region_get_information>:
rtems_status_code rtems_region_get_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30017928: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
3001792c: e2515000 subs r5, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30017930: e1a06000 mov r6, r0 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
30017934: 03a06009 moveq r6, #9 <== NOT EXECUTED
{
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30017938: 0a00000e beq 30017978 <rtems_region_get_information+0x50> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
3001793c: e59f403c ldr r4, [pc, #60] ; 30017980 <rtems_region_get_information+0x58><== NOT EXECUTED 30017940: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017944: eb0008c4 bl 30019c5c <_API_Mutex_Lock> <== NOT EXECUTED 30017948: e1a01006 mov r1, r6 <== NOT EXECUTED 3001794c: e59f0030 ldr r0, [pc, #48] ; 30017984 <rtems_region_get_information+0x5c><== NOT EXECUTED 30017950: e1a0200d mov r2, sp <== NOT EXECUTED 30017954: eb000ff6 bl 3001b934 <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30017958: e59d6000 ldr r6, [sp] <== NOT EXECUTED 3001795c: e3560000 cmp r6, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30017960: 13a06004 movne r6, #4 <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Heap_Get_information( &the_region->Memory, the_info );
30017964: 02800068 addeq r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017968: 01a01005 moveq r1, r5 <== NOT EXECUTED 3001796c: 0b000d22 bleq 3001adfc <_Heap_Get_information> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30017970: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017974: eb0008d1 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30017978: e1a00006 mov r0, r6 <== NOT EXECUTED
3001797c: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
30017ab4 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
30017ab4: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
30017ab8: e2515000 subs r5, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
30017abc: e1a06000 mov r6, r0 <== NOT EXECUTED 30017ac0: e1a04002 mov r4, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
30017ac4: 0a000019 beq 30017b30 <rtems_region_get_segment_size+0x7c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !size )
30017ac8: e3520000 cmp r2, #0 <== NOT EXECUTED 30017acc: 0a000017 beq 30017b30 <rtems_region_get_segment_size+0x7c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30017ad0: e59f3064 ldr r3, [pc, #100] ; 30017b3c <rtems_region_get_segment_size+0x88><== NOT EXECUTED 30017ad4: e5930000 ldr r0, [r3] <== NOT EXECUTED 30017ad8: eb00085f bl 30019c5c <_API_Mutex_Lock> <== NOT EXECUTED 30017adc: e59f005c ldr r0, [pc, #92] ; 30017b40 <rtems_region_get_segment_size+0x8c><== NOT EXECUTED 30017ae0: e1a01006 mov r1, r6 <== NOT EXECUTED 30017ae4: e1a0200d mov r2, sp <== NOT EXECUTED 30017ae8: eb000f91 bl 3001b934 <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30017aec: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30017af0: e3530000 cmp r3, #0 <== NOT EXECUTED 30017af4: 0a000002 beq 30017b04 <rtems_region_get_segment_size+0x50> <== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
30017af8: e3530001 cmp r3, #1 <== NOT EXECUTED 30017afc: 03a04004 moveq r4, #4 <== NOT EXECUTED 30017b00: ea000005 b 30017b1c <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 ) )
30017b04: e1a02004 mov r2, r4 <== NOT EXECUTED 30017b08: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017b0c: e1a01005 mov r1, r5 <== NOT EXECUTED 30017b10: eb000e1f bl 3001b394 <_Heap_Size_of_alloc_area> <== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
30017b14: e3500000 cmp r0, #0 <== NOT EXECUTED 30017b18: 03a04009 moveq r4, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30017b1c: e59f3018 ldr r3, [pc, #24] ; 30017b3c <rtems_region_get_segment_size+0x88><== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
30017b20: 13a04000 movne r4, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30017b24: e5930000 ldr r0, [r3] <== NOT EXECUTED 30017b28: eb000864 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status;
30017b2c: ea000000 b 30017b34 <rtems_region_get_segment_size+0x80> <== NOT EXECUTED
if ( !segment )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
30017b30: e3a04009 mov r4, #9 <== NOT EXECUTED
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
30017b34: e1a00004 mov r0, r4 <== NOT EXECUTED
30017b38: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
30017b74 <rtems_region_resize_segment>:
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
30017b74: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
uintptr_t osize;
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
30017b78: e2538000 subs r8, r3, #0 <== NOT EXECUTED
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
30017b7c: e1a05000 mov r5, r0 <== NOT EXECUTED 30017b80: e1a07001 mov r7, r1 <== NOT EXECUTED 30017b84: e1a06002 mov r6, r2 <== NOT EXECUTED
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
return RTEMS_INVALID_ADDRESS;
30017b88: 03a00009 moveq r0, #9 <== NOT EXECUTED
uintptr_t osize;
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
30017b8c: 0a000022 beq 30017c1c <rtems_region_resize_segment+0xa8> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30017b90: e59f408c ldr r4, [pc, #140] ; 30017c24 <rtems_region_resize_segment+0xb0><== NOT EXECUTED 30017b94: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017b98: eb00082f bl 30019c5c <_API_Mutex_Lock> <== NOT EXECUTED 30017b9c: e1a01005 mov r1, r5 <== NOT EXECUTED 30017ba0: e59f0080 ldr r0, [pc, #128] ; 30017c28 <rtems_region_resize_segment+0xb4><== NOT EXECUTED 30017ba4: e28d2008 add r2, sp, #8 <== NOT EXECUTED 30017ba8: eb000f61 bl 3001b934 <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30017bac: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30017bb0: e1a05000 mov r5, r0 <== NOT EXECUTED 30017bb4: e3530000 cmp r3, #0 <== NOT EXECUTED 30017bb8: 1a000014 bne 30017c10 <rtems_region_resize_segment+0x9c> <== NOT EXECUTED
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
30017bbc: e28d3004 add r3, sp, #4 <== NOT EXECUTED 30017bc0: e58d3000 str r3, [sp] <== NOT EXECUTED 30017bc4: e1a02006 mov r2, r6 <== NOT EXECUTED 30017bc8: e28d300c add r3, sp, #12 <== NOT EXECUTED 30017bcc: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30017bd0: e1a01007 mov r1, r7 <== NOT EXECUTED 30017bd4: eb000da1 bl 3001b260 <_Heap_Resize_block> <== NOT EXECUTED
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
30017bd8: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
30017bdc: e2506000 subs r6, r0, #0 <== NOT EXECUTED
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
30017be0: e5883000 str r3, [r8] <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
30017be4: 1a000003 bne 30017bf8 <rtems_region_resize_segment+0x84> <== NOT EXECUTED
_Region_Process_queue( the_region ); /* unlocks allocator */
30017be8: e1a00005 mov r0, r5 <== NOT EXECUTED 30017bec: eb001c70 bl 3001edb4 <_Region_Process_queue> <== NOT EXECUTED
else
_RTEMS_Unlock_allocator();
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
30017bf0: e1a00006 mov r0, r6 <== NOT EXECUTED 30017bf4: ea000008 b 30017c1c <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();
30017bf8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017bfc: eb00082f bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
if (status == HEAP_RESIZE_UNSATISFIED)
return RTEMS_UNSATISFIED;
30017c00: e3560001 cmp r6, #1 <== NOT EXECUTED 30017c04: 13a00009 movne r0, #9 <== NOT EXECUTED 30017c08: 03a0000d moveq r0, #13 <== NOT EXECUTED 30017c0c: ea000002 b 30017c1c <rtems_region_resize_segment+0xa8> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30017c10: e5940000 ldr r0, [r4] <== NOT EXECUTED 30017c14: eb000829 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status;
30017c18: e3a00004 mov r0, #4 <== NOT EXECUTED
}
30017c1c: e28dd010 add sp, sp, #16 <== NOT EXECUTED
30017c20: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30017c2c <rtems_region_return_segment>:
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30017c2c: e92d4071 push {r0, r4, r5, r6, lr}
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
30017c30: e59f3074 ldr r3, [pc, #116] ; 30017cac <rtems_region_return_segment+0x80>
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30017c34: e1a05000 mov r5, r0
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
30017c38: e5930000 ldr r0, [r3]
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30017c3c: e1a04001 mov r4, r1
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
30017c40: eb000805 bl 30019c5c <_API_Mutex_Lock> 30017c44: e1a01005 mov r1, r5 30017c48: e59f0060 ldr r0, [pc, #96] ; 30017cb0 <rtems_region_return_segment+0x84> 30017c4c: e1a0200d mov r2, sp 30017c50: eb000f37 bl 3001b934 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
30017c54: e59d6000 ldr r6, [sp] 30017c58: e1a05000 mov r5, r0 30017c5c: e3560000 cmp r6, #0
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30017c60: 13a06004 movne r6, #4
register Region_Control *the_region;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
30017c64: 1a00000b bne 30017c98 <rtems_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 );
30017c68: e2800068 add r0, r0, #104 ; 0x68 30017c6c: e1a01004 mov r1, r4 30017c70: eb000bc3 bl 3001ab84 <_Heap_Free>
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
30017c74: e3500000 cmp r0, #0
return_status = RTEMS_INVALID_ADDRESS;
30017c78: 03a06009 moveq r6, #9
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
30017c7c: 0a000005 beq 30017c98 <rtems_region_return_segment+0x6c>
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
30017c80: e5953064 ldr r3, [r5, #100] ; 0x64
_Region_Process_queue(the_region); /* unlocks allocator */
30017c84: e1a00005 mov r0, r5
_Region_Debug_Walk( the_region, 4 );
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
30017c88: e2433001 sub r3, r3, #1 30017c8c: e5853064 str r3, [r5, #100] ; 0x64
_Region_Process_queue(the_region); /* unlocks allocator */
30017c90: eb001c47 bl 3001edb4 <_Region_Process_queue>
return RTEMS_SUCCESSFUL;
30017c94: ea000002 b 30017ca4 <rtems_region_return_segment+0x78>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30017c98: e59f300c ldr r3, [pc, #12] ; 30017cac <rtems_region_return_segment+0x80><== NOT EXECUTED 30017c9c: e5930000 ldr r0, [r3] <== NOT EXECUTED 30017ca0: eb000806 bl 30019cc0 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30017ca4: e1a00006 mov r0, r6
30017ca8: e8bd8078 pop {r3, r4, r5, r6, pc}
30009fa0 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
30009fa0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
30009fa4: e2507000 subs r7, r0, #0
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
30009fa8: e24dd018 sub sp, sp, #24 30009fac: e1a04001 mov r4, r1 30009fb0: e1a08002 mov r8, r2 30009fb4: e1a09003 mov r9, r3 30009fb8: e59d6038 ldr r6, [sp, #56] ; 0x38
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30009fbc: 03a00003 moveq r0, #3
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
30009fc0: 0a00005a beq 3000a130 <rtems_semaphore_create+0x190>
return RTEMS_INVALID_NAME;
if ( !id )
30009fc4: e3560000 cmp r6, #0
return RTEMS_INVALID_ADDRESS;
30009fc8: 03a00009 moveq r0, #9
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30009fcc: 0a000057 beq 3000a130 <rtems_semaphore_create+0x190>
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
30009fd0: e21230c0 ands r3, r2, #192 ; 0xc0
30009fd4: 0a000006 beq 30009ff4 <rtems_semaphore_create+0x54>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
30009fd8: e2022030 and r2, r2, #48 ; 0x30
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
30009fdc: e3520010 cmp r2, #16
30009fe0: 1a000051 bne 3000a12c <rtems_semaphore_create+0x18c>
30009fe4: e3180004 tst r8, #4
30009fe8: 0a00004f beq 3000a12c <rtems_semaphore_create+0x18c>
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
30009fec: e35300c0 cmp r3, #192 ; 0xc0
30009ff0: 0a00004d beq 3000a12c <rtems_semaphore_create+0x18c>
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
30009ff4: e218a030 ands sl, r8, #48 ; 0x30
30009ff8: 0a000002 beq 3000a008 <rtems_semaphore_create+0x68>
30009ffc: e3540001 cmp r4, #1
return RTEMS_INVALID_NUMBER;
3000a000: 83a0000a movhi r0, #10
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
3000a004: 8a000049 bhi 3000a130 <rtems_semaphore_create+0x190>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000a008: e59f3128 ldr r3, [pc, #296] ; 3000a138 <rtems_semaphore_create+0x198> 3000a00c: e5932000 ldr r2, [r3]
++level;
3000a010: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000a014: e5832000 str r2, [r3]
* This function allocates a semaphore control block from
* the inactive chain of free semaphore control blocks.
*/
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void )
{
return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information );
3000a018: e59f011c ldr r0, [pc, #284] ; 3000a13c <rtems_semaphore_create+0x19c> 3000a01c: eb00054f bl 3000b560 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
3000a020: e2505000 subs r5, r0, #0
3000a024: 1a000002 bne 3000a034 <rtems_semaphore_create+0x94>
_Thread_Enable_dispatch();
3000a028: eb0009f3 bl 3000c7fc <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
3000a02c: e3a00005 mov r0, #5 3000a030: ea00003e b 3000a130 <rtems_semaphore_create+0x190>
the_semaphore->attribute_set = attribute_set;
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
3000a034: e35a0000 cmp sl, #0
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
3000a038: e5858010 str r8, [r5, #16] 3000a03c: e2083004 and r3, r8, #4
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
3000a040: 1a00000b bne 3000a074 <rtems_semaphore_create+0xd4>
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
3000a044: e2933000 adds r3, r3, #0
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
3000a048: e3e02000 mvn r2, #0 3000a04c: e58d2010 str r2, [sp, #16]
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
3000a050: 13a03001 movne r3, #1
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
_CORE_semaphore_Initialize(
3000a054: e2850014 add r0, r5, #20 3000a058: e28d1010 add r1, sp, #16 3000a05c: e1a02004 mov r2, r4
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
3000a060: e58d3014 str r3, [sp, #20]
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
3000a064: e58da000 str sl, [sp]
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
3000a068: e58da00c str sl, [sp, #12]
_CORE_semaphore_Initialize(
3000a06c: eb0003c3 bl 3000af80 <_CORE_semaphore_Initialize> 3000a070: ea000023 b 3000a104 <rtems_semaphore_create+0x164>
/*
* It is either simple binary semaphore or a more powerful mutex
* style binary semaphore. This is the mutex style.
*/
if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
3000a074: e2933000 adds r3, r3, #0 3000a078: 13a03001 movne r3, #1
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
3000a07c: e35a0010 cmp sl, #16
/*
* It is either simple binary semaphore or a more powerful mutex
* style binary semaphore. This is the mutex style.
*/
if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
3000a080: e58d3008 str r3, [sp, #8] 3000a084: e3a02000 mov r2, #0
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
the_mutex_attr.only_owner_release = true;
}
}
} else /* must be simple binary semaphore */ {
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
3000a088: 13a03001 movne r3, #1 3000a08c: 158d3000 strne r3, [sp]
the_mutex_attr.only_owner_release = false;
3000a090: 15cd2004 strbne r2, [sp, #4]
if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
3000a094: 1a00000c bne 3000a0cc <rtems_semaphore_create+0x12c>
the_mutex_attr.priority_ceiling = priority_ceiling;
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
3000a098: e3530001 cmp r3, #1
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
3000a09c: e58d900c str r9, [sp, #12]
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
3000a0a0: e58d2000 str r2, [sp]
the_mutex_attr.only_owner_release = false;
3000a0a4: e5cd2004 strb r2, [sp, #4]
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
3000a0a8: 1a000007 bne 3000a0cc <rtems_semaphore_create+0x12c>
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
3000a0ac: e3180040 tst r8, #64 ; 0x40
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
3000a0b0: 13a02002 movne r2, #2
the_mutex_attr.priority_ceiling = priority_ceiling;
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
3000a0b4: 1a000002 bne 3000a0c4 <rtems_semaphore_create+0x124>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
the_mutex_attr.only_owner_release = true;
} else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
3000a0b8: e3180080 tst r8, #128 ; 0x80
3000a0bc: 0a000002 beq 3000a0cc <rtems_semaphore_create+0x12c>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
3000a0c0: e3a02003 mov r2, #3 3000a0c4: e58d2008 str r2, [sp, #8]
the_mutex_attr.only_owner_release = true;
3000a0c8: e5cd3004 strb r3, [sp, #4]
} else /* must be simple binary semaphore */ {
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
the_mutex_attr.only_owner_release = false;
}
mutex_status = _CORE_mutex_Initialize(
3000a0cc: e2443001 sub r3, r4, #1 3000a0d0: e2732000 rsbs r2, r3, #0 3000a0d4: e0a22003 adc r2, r2, r3 3000a0d8: e2850014 add r0, r5, #20 3000a0dc: e1a0100d mov r1, sp 3000a0e0: eb0002e1 bl 3000ac6c <_CORE_mutex_Initialize>
&the_semaphore->Core_control.mutex,
&the_mutex_attr,
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
3000a0e4: e3500005 cmp r0, #5
3000a0e8: 1a000005 bne 3000a104 <rtems_semaphore_create+0x164>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
3000a0ec: e59f0048 ldr r0, [pc, #72] ; 3000a13c <rtems_semaphore_create+0x19c> 3000a0f0: e1a01005 mov r1, r5 3000a0f4: eb0005e8 bl 3000b89c <_Objects_Free>
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
3000a0f8: eb0009bf bl 3000c7fc <_Thread_Enable_dispatch>
return RTEMS_INVALID_PRIORITY;
3000a0fc: e3a00013 mov r0, #19 3000a100: ea00000a b 3000a130 <rtems_semaphore_create+0x190>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a104: e59f2030 ldr r2, [pc, #48] ; 3000a13c <rtems_semaphore_create+0x19c>
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000a108: e5953008 ldr r3, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a10c: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000a110: e1d510b8 ldrh r1, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a114: e7825101 str r5, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000a118: e585700c str r7, [r5, #12]
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
3000a11c: e5863000 str r3, [r6]
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
3000a120: eb0009b5 bl 3000c7fc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a124: e3a00000 mov r0, #0 3000a128: ea000000 b 3000a130 <rtems_semaphore_create+0x190>
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
3000a12c: e3a0000b mov r0, #11 <== NOT EXECUTED
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000a130: e28dd018 add sp, sp, #24
3000a134: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
3000a140 <rtems_semaphore_delete>:
#endif
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
3000a140: e92d4011 push {r0, r4, lr}
3000a144: e1a01000 mov r1, r0
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
3000a148: e1a0200d mov r2, sp 3000a14c: e59f0084 ldr r0, [pc, #132] ; 3000a1d8 <rtems_semaphore_delete+0x98> 3000a150: eb000626 bl 3000b9f0 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
3000a154: e59d3000 ldr r3, [sp] 3000a158: e1a04000 mov r4, r0 3000a15c: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a160: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
3000a164: 1a00001a bne 3000a1d4 <rtems_semaphore_delete+0x94>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
3000a168: e5941010 ldr r1, [r4, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
3000a16c: e2111030 ands r1, r1, #48 ; 0x30
3000a170: 0a00000c beq 3000a1a8 <rtems_semaphore_delete+0x68>
if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
3000a174: e5943064 ldr r3, [r4, #100] ; 0x64 3000a178: e3530000 cmp r3, #0
3000a17c: 1a000004 bne 3000a194 <rtems_semaphore_delete+0x54>
3000a180: e3510020 cmp r1, #32
3000a184: 0a000002 beq 3000a194 <rtems_semaphore_delete+0x54>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
3000a188: eb00099b bl 3000c7fc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
3000a18c: e3a0000c mov r0, #12 <== NOT EXECUTED 3000a190: ea00000f b 3000a1d4 <rtems_semaphore_delete+0x94> <== NOT EXECUTED
}
_CORE_mutex_Flush(
3000a194: e2840014 add r0, r4, #20 3000a198: e3a01000 mov r1, #0 3000a19c: e3a02003 mov r2, #3 3000a1a0: eb0002b0 bl 3000ac68 <_CORE_mutex_Flush> 3000a1a4: ea000002 b 3000a1b4 <rtems_semaphore_delete+0x74>
&the_semaphore->Core_control.mutex,
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_MUTEX_WAS_DELETED
);
} else {
_CORE_semaphore_Flush(
3000a1a8: e2840014 add r0, r4, #20 3000a1ac: e3a02002 mov r2, #2 3000a1b0: eb000371 bl 3000af7c <_CORE_semaphore_Flush>
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_WAS_DELETED
);
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
3000a1b4: e59f001c ldr r0, [pc, #28] ; 3000a1d8 <rtems_semaphore_delete+0x98> 3000a1b8: e1a01004 mov r1, r4 3000a1bc: eb000509 bl 3000b5e8 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
3000a1c0: e59f0010 ldr r0, [pc, #16] ; 3000a1d8 <rtems_semaphore_delete+0x98> 3000a1c4: e1a01004 mov r1, r4 3000a1c8: eb0005b3 bl 3000b89c <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
3000a1cc: eb00098a bl 3000c7fc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a1d0: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000a1d4: e8bd8018 pop {r3, r4, pc}
30012df8 <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
30012df8: e92d4001 push {r0, lr}
30012dfc: e1a01000 mov r1, r0
30012e00: e1a0200d mov r2, sp
30012e04: e59f0044 ldr r0, [pc, #68] ; 30012e50 <rtems_semaphore_flush+0x58>
30012e08: ebffe8a6 bl 3000d0a8 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30012e0c: e59d3000 ldr r3, [sp] 30012e10: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30012e14: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30012e18: 1a00000b bne 30012e4c <rtems_semaphore_flush+0x54>
30012e1c: e5901010 ldr r1, [r0, #16] 30012e20: e2800014 add r0, r0, #20
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
30012e24: e2111030 ands r1, r1, #48 ; 0x30
30012e28: 0a000003 beq 30012e3c <rtems_semaphore_flush+0x44>
_CORE_mutex_Flush(
30012e2c: e1a01003 mov r1, r3 30012e30: e3a02001 mov r2, #1 30012e34: ebffe539 bl 3000c320 <_CORE_mutex_Flush> 30012e38: ea000001 b 30012e44 <rtems_semaphore_flush+0x4c>
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
30012e3c: e3a02001 mov r2, #1 <== NOT EXECUTED 30012e40: ebffe5fb bl 3000c634 <_CORE_semaphore_Flush> <== NOT EXECUTED
&the_semaphore->Core_control.semaphore,
SEND_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
);
}
_Thread_Enable_dispatch();
30012e44: ebffebf8 bl 3000de2c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30012e48: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30012e4c: e8bd8008 pop {r3, pc}
3000a1dc <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
3000a1dc: e92d4077 push {r0, r1, r2, r4, r5, r6, lr}
3000a1e0: e1a04000 mov r4, r0
Objects_Id id,
Objects_Locations *location,
ISR_Level *level
)
{
return (Semaphore_Control *)
3000a1e4: e28d3008 add r3, sp, #8 3000a1e8: e1a06001 mov r6, r1 3000a1ec: e1a05002 mov r5, r2 3000a1f0: e59f00f0 ldr r0, [pc, #240] ; 3000a2e8 <rtems_semaphore_obtain+0x10c> 3000a1f4: e1a01004 mov r1, r4 3000a1f8: e28d2004 add r2, sp, #4 3000a1fc: eb0005e1 bl 3000b988 <_Objects_Get_isr_disable>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
ISR_Level level;
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
3000a200: e59d3004 ldr r3, [sp, #4] 3000a204: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a208: 13a00004 movne r0, #4
register Semaphore_Control *the_semaphore;
Objects_Locations location;
ISR_Level level;
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
3000a20c: 1a000034 bne 3000a2e4 <rtems_semaphore_obtain+0x108>
3000a210: e5903010 ldr r3, [r0, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
3000a214: e2132030 ands r2, r3, #48 ; 0x30
3000a218: 0a00000c beq 3000a250 <rtems_semaphore_obtain+0x74>
_CORE_mutex_Seize(
3000a21c: e59d3008 ldr r3, [sp, #8]
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
3000a220: e2062001 and r2, r6, #1 3000a224: e58d3000 str r3, [sp] 3000a228: e2800014 add r0, r0, #20 3000a22c: e1a03005 mov r3, r5 3000a230: e1a01004 mov r1, r4 3000a234: e2222001 eor r2, r2, #1 3000a238: eb0002d8 bl 3000ada0 <_CORE_mutex_Seize>
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
_Thread_Executing->Wait.return_code );
3000a23c: e59f30a8 ldr r3, [pc, #168] ; 3000a2ec <rtems_semaphore_obtain+0x110> 3000a240: e5933008 ldr r3, [r3, #8]
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
3000a244: e5930034 ldr r0, [r3, #52] ; 0x34 3000a248: eb000047 bl 3000a36c <_Semaphore_Translate_core_mutex_return_code> 3000a24c: ea000024 b 3000a2e4 <rtems_semaphore_obtain+0x108>
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000a250: e59f3094 ldr r3, [pc, #148] ; 3000a2ec <rtems_semaphore_obtain+0x110> 3000a254: e5933008 ldr r3, [r3, #8]
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
3000a258: e5832034 str r2, [r3, #52] ; 0x34
if ( the_semaphore->count != 0 ) {
3000a25c: e590205c ldr r2, [r0, #92] ; 0x5c 3000a260: e3520000 cmp r2, #0
3000a264: 0a000004 beq 3000a27c <rtems_semaphore_obtain+0xa0>
the_semaphore->count -= 1;
3000a268: e2422001 sub r2, r2, #1 3000a26c: e580205c str r2, [r0, #92] ; 0x5c 3000a270: e59d3008 ldr r3, [sp, #8] 3000a274: e129f003 msr CPSR_fc, r3 3000a278: ea000015 b 3000a2d4 <rtems_semaphore_obtain+0xf8>
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
3000a27c: e3160001 tst r6, #1
3000a280: 0a000004 beq 3000a298 <rtems_semaphore_obtain+0xbc>
3000a284: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 3000a288: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( *level_p );
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
3000a28c: e3a02001 mov r2, #1 <== NOT EXECUTED 3000a290: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED 3000a294: ea00000e b 3000a2d4 <rtems_semaphore_obtain+0xf8> <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000a298: e59f2050 ldr r2, [pc, #80] ; 3000a2f0 <rtems_semaphore_obtain+0x114> 3000a29c: e5921000 ldr r1, [r2]
++level;
3000a2a0: e2811001 add r1, r1, #1
_Thread_Dispatch_disable_level = level;
3000a2a4: e5821000 str r1, [r2]
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000a2a8: e3a02001 mov r2, #1 3000a2ac: e5802044 str r2, [r0, #68] ; 0x44
return;
}
_Thread_Disable_dispatch();
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
3000a2b0: e2800014 add r0, r0, #20 3000a2b4: e5830044 str r0, [r3, #68] ; 0x44
executing->Wait.id = id;
3000a2b8: e5834020 str r4, [r3, #32] 3000a2bc: e59d3008 ldr r3, [sp, #8] 3000a2c0: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
3000a2c4: e59f2028 ldr r2, [pc, #40] ; 3000a2f4 <rtems_semaphore_obtain+0x118> 3000a2c8: e1a01005 mov r1, r5 3000a2cc: eb000a6a bl 3000cc7c <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
3000a2d0: eb000949 bl 3000c7fc <_Thread_Enable_dispatch>
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
_Thread_Executing->Wait.return_code );
3000a2d4: e59f3010 ldr r3, [pc, #16] ; 3000a2ec <rtems_semaphore_obtain+0x110> 3000a2d8: e5933008 ldr r3, [r3, #8]
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
3000a2dc: e5930034 ldr r0, [r3, #52] ; 0x34 3000a2e0: eb000025 bl 3000a37c <_Semaphore_Translate_core_semaphore_return_code>
break;
}
return RTEMS_INVALID_ID;
}
3000a2e4: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc}
3000a870 <rtems_shutdown_executive>:
void rtems_shutdown_executive(
uint32_t result
)
{
if ( _System_state_Is_up( _System_state_Get() ) ) {
3000a870: e59f3038 ldr r3, [pc, #56] ; 3000a8b0 <rtems_shutdown_executive+0x40>
*/
void rtems_shutdown_executive(
uint32_t result
)
{
3000a874: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if ( _System_state_Is_up( _System_state_Get() ) ) {
3000a878: e5932000 ldr r2, [r3] 3000a87c: e3520003 cmp r2, #3
3000a880: 1a000006 bne 3000a8a0 <rtems_shutdown_executive+0x30>
#if defined(RTEMS_SMP)
_SMP_Request_other_cores_to_shutdown();
#endif
_Per_CPU_Information[0].idle->Wait.return_code = result;
3000a884: e59f2028 ldr r2, [pc, #40] ; 3000a8b4 <rtems_shutdown_executive+0x44> 3000a888: e5922010 ldr r2, [r2, #16] 3000a88c: e5820034 str r0, [r2, #52] ; 0x34 3000a890: e3a02004 mov r2, #4 3000a894: e5832000 str r2, [r3]
* if we were running within the same context, it would work. * * And we will not return to this thread, so there is no point of * saving the context. */ _Context_Restart_self( &_Thread_BSP_context );
3000a898: e59f0018 ldr r0, [pc, #24] ; 3000a8b8 <rtems_shutdown_executive+0x48> 3000a89c: eb000c7f bl 3000daa0 <_CPU_Context_restore>
****** RETURN TO RTEMS_INITIALIZE_START_MULTITASKING() ******
****** AND THEN TO BOOT_CARD() ******
*******************************************************************
*******************************************************************/
}
_Internal_error_Occurred(
3000a8a0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a8a4: e3a01001 mov r1, #1 <== NOT EXECUTED 3000a8a8: e3a02014 mov r2, #20 <== NOT EXECUTED 3000a8ac: eb00030d bl 3000b4e8 <_Internal_error_Occurred> <== NOT EXECUTED
30018134 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
30018134: e92d4011 push {r0, r4, lr}
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
30018138: e2514000 subs r4, r1, #0
return RTEMS_INVALID_NUMBER;
3001813c: 03a0000a moveq r0, #10
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
30018140: 0a000025 beq 300181dc <rtems_signal_send+0xa8>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
30018144: e1a0100d mov r1, sp 30018148: eb001192 bl 3001c798 <_Thread_Get>
switch ( location ) {
3001814c: e59d3000 ldr r3, [sp] 30018150: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018154: 13a00004 movne r0, #4
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
30018158: 1a00001f bne 300181dc <rtems_signal_send+0xa8>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
3001815c: e59030ec ldr r3, [r0, #236] ; 0xec
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
30018160: e593200c ldr r2, [r3, #12] 30018164: e3520000 cmp r2, #0
30018168: 0a000019 beq 300181d4 <rtems_signal_send+0xa0>
if ( asr->is_enabled ) {
3001816c: e5d32008 ldrb r2, [r3, #8] 30018170: e3520000 cmp r2, #0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30018174: e10f2000 mrs r2, CPSR 30018178: e3821080 orr r1, r2, #128 ; 0x80 3001817c: e129f001 msr CPSR_fc, r1
30018180: 0a00000c beq 300181b8 <rtems_signal_send+0x84>
)
{
ISR_Level _level;
_ISR_Disable( _level );
*signal_set |= signals;
30018184: e5931014 ldr r1, [r3, #20] 30018188: e1814004 orr r4, r1, r4 3001818c: e5834014 str r4, [r3, #20]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30018190: e129f002 msr CPSR_fc, r2
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
30018194: e59f3044 ldr r3, [pc, #68] ; 300181e0 <rtems_signal_send+0xac> 30018198: e5932000 ldr r2, [r3] 3001819c: e3520000 cmp r2, #0
300181a0: 0a000008 beq 300181c8 <rtems_signal_send+0x94>
300181a4: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 300181a8: e1500002 cmp r0, r2 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
300181ac: 03a02001 moveq r2, #1 <== NOT EXECUTED 300181b0: 05c32004 strbeq r2, [r3, #4] <== NOT EXECUTED 300181b4: ea000003 b 300181c8 <rtems_signal_send+0x94> <== NOT EXECUTED 300181b8: e5931018 ldr r1, [r3, #24] <== NOT EXECUTED 300181bc: e1814004 orr r4, r1, r4 <== NOT EXECUTED 300181c0: e5834018 str r4, [r3, #24] <== NOT EXECUTED 300181c4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
300181c8: eb00116a bl 3001c778 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300181cc: e3a00000 mov r0, #0 300181d0: ea000001 b 300181dc <rtems_signal_send+0xa8>
}
_Thread_Enable_dispatch();
300181d4: eb001167 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
300181d8: e3a0000b mov r0, #11 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300181dc: e8bd8018 pop {r3, r4, pc}
3000a528 <rtems_task_delete>:
#include <rtems/score/apimutex.h>
rtems_status_code rtems_task_delete(
rtems_id id
)
{
3000a528: e92d4071 push {r0, r4, r5, r6, lr}
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
3000a52c: e59f5068 ldr r5, [pc, #104] ; 3000a59c <rtems_task_delete+0x74>
#include <rtems/score/apimutex.h>
rtems_status_code rtems_task_delete(
rtems_id id
)
{
3000a530: e1a04000 mov r4, r0
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
3000a534: e5950000 ldr r0, [r5] 3000a538: eb00017c bl 3000ab30 <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
3000a53c: e1a00004 mov r0, r4 3000a540: e1a0100d mov r1, sp 3000a544: eb0008b4 bl 3000c81c <_Thread_Get>
switch ( location ) {
3000a548: e59d6000 ldr r6, [sp]
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
the_thread = _Thread_Get( id, &location );
3000a54c: e1a04000 mov r4, r0
switch ( location ) {
3000a550: e3560000 cmp r6, #0
3000a554: 1a00000c bne 3000a58c <rtems_task_delete+0x64>
case OBJECTS_LOCAL:
the_information = _Objects_Get_information_id( the_thread->Object.id );
3000a558: e5900008 ldr r0, [r0, #8] 3000a55c: eb0004eb bl 3000b910 <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
3000a560: e1a01004 mov r1, r4 3000a564: eb0007d9 bl 3000c4d0 <_Thread_Close> 3000a568: e5940008 ldr r0, [r4, #8] 3000a56c: eb0004e7 bl 3000b910 <_Objects_Get_information_id> 3000a570: e1a01004 mov r1, r4 3000a574: eb0004c8 bl 3000b89c <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
3000a578: e5950000 ldr r0, [r5] 3000a57c: eb000184 bl 3000ab94 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
3000a580: eb00089d bl 3000c7fc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a584: e1a00006 mov r0, r6 3000a588: ea000002 b 3000a598 <rtems_task_delete+0x70>
case OBJECTS_ERROR:
break;
}
_RTEMS_Unlock_allocator();
3000a58c: e5950000 ldr r0, [r5] <== NOT EXECUTED 3000a590: eb00017f bl 3000ab94 <_API_Mutex_Unlock> <== NOT EXECUTED
return RTEMS_INVALID_ID;
3000a594: e3a00004 mov r0, #4 <== NOT EXECUTED
}
3000a598: e8bd8078 pop {r3, r4, r5, r6, pc}
3000c014 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c014: e92d4071 push {r0, r4, r5, r6, lr}
3000c018: e1a05002 mov r5, r2
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c01c: e59f2098 ldr r2, [pc, #152] ; 3000c0bc <rtems_task_get_note+0xa8>
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c020: e1a03000 mov r3, r0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c024: e5d22004 ldrb r2, [r2, #4]
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c028: e1a04001 mov r4, r1
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c02c: e3520000 cmp r2, #0
return RTEMS_NOT_CONFIGURED;
3000c030: 03a00016 moveq r0, #22
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c034: 0a00001f beq 3000c0b8 <rtems_task_get_note+0xa4>
return RTEMS_NOT_CONFIGURED;
if ( !note )
3000c038: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
3000c03c: 03a00009 moveq r0, #9
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
3000c040: 0a00001c beq 3000c0b8 <rtems_task_get_note+0xa4>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000c044: e351000f cmp r1, #15
return RTEMS_INVALID_NUMBER;
3000c048: 83a0000a movhi r0, #10
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000c04c: 8a000019 bhi 3000c0b8 <rtems_task_get_note+0xa4>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c050: e3530000 cmp r3, #0 3000c054: e59f2064 ldr r2, [pc, #100] ; 3000c0c0 <rtems_task_get_note+0xac>
3000c058: 0a000003 beq 3000c06c <rtems_task_get_note+0x58>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
3000c05c: e5921008 ldr r1, [r2, #8]
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c060: e5911008 ldr r1, [r1, #8] 3000c064: e1530001 cmp r3, r1
3000c068: 1a000006 bne 3000c088 <rtems_task_get_note+0x74>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
3000c06c: e5923008 ldr r3, [r2, #8] <== NOT EXECUTED
*note = api->Notepads[ notepad ];
3000c070: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000c074: e59330ec ldr r3, [r3, #236] ; 0xec <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000c078: e3a00000 mov r0, #0 <== NOT EXECUTED
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
3000c07c: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED 3000c080: e5853000 str r3, [r5] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000c084: ea00000b b 3000c0b8 <rtems_task_get_note+0xa4> <== NOT EXECUTED
}
the_thread = _Thread_Get( id, &location );
3000c088: e1a0100d mov r1, sp 3000c08c: eb000954 bl 3000e5e4 <_Thread_Get>
switch ( location ) {
3000c090: e59d6000 ldr r6, [sp] 3000c094: e3560000 cmp r6, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000c098: 13a00004 movne r0, #4
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000c09c: 1a000005 bne 3000c0b8 <rtems_task_get_note+0xa4>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
3000c0a0: e59030ec ldr r3, [r0, #236] ; 0xec 3000c0a4: e2844008 add r4, r4, #8 3000c0a8: e7933104 ldr r3, [r3, r4, lsl #2] 3000c0ac: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
3000c0b0: eb000943 bl 3000e5c4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000c0b4: e1a00006 mov r0, r6
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000c0b8: e8bd8078 pop {r3, r4, r5, r6, pc}
3000a5a0 <rtems_task_ident>:
rtems_id *id
)
{
Objects_Name_or_id_lookup_errors status;
if ( !id )
3000a5a0: e2523000 subs r3, r2, #0
rtems_status_code rtems_task_ident(
rtems_name name,
uint32_t node,
rtems_id *id
)
{
3000a5a4: e92d4010 push {r4, lr}
3000a5a8: e1a0c000 mov ip, r0
3000a5ac: e1a04001 mov r4, r1
Objects_Name_or_id_lookup_errors status;
if ( !id )
3000a5b0: 0a00000d beq 3000a5ec <rtems_task_ident+0x4c>
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
3000a5b4: e3500000 cmp r0, #0
3000a5b8: 1a000004 bne 3000a5d0 <rtems_task_ident+0x30>
*id = _Thread_Executing->Object.id;
3000a5bc: e59f2030 ldr r2, [pc, #48] ; 3000a5f4 <rtems_task_ident+0x54> 3000a5c0: e5922008 ldr r2, [r2, #8] 3000a5c4: e5922008 ldr r2, [r2, #8] 3000a5c8: e5832000 str r2, [r3]
return RTEMS_SUCCESSFUL;
3000a5cc: e8bd8010 pop {r4, pc}
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
3000a5d0: e59f0020 ldr r0, [pc, #32] ; 3000a5f8 <rtems_task_ident+0x58> 3000a5d4: e1a0100c mov r1, ip 3000a5d8: e1a02004 mov r2, r4 3000a5dc: eb000551 bl 3000bb28 <_Objects_Name_to_id_u32>
return _Status_Object_name_errors_to_status[ status ];
3000a5e0: e59f3014 ldr r3, [pc, #20] ; 3000a5fc <rtems_task_ident+0x5c>
3000a5e4: e7930100 ldr r0, [r3, r0, lsl #2]
3000a5e8: e8bd8010 pop {r4, pc}
)
{
Objects_Name_or_id_lookup_errors status;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000a5ec: e3a00009 mov r0, #9 <== NOT EXECUTED
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
return _Status_Object_name_errors_to_status[ status ];
}
3000a5f0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30018588 <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
rtems_id id
)
{
30018588: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3001858c: e1a0100d mov r1, sp <== NOT EXECUTED 30018590: eb001080 bl 3001c798 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
30018594: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30018598: e3530000 cmp r3, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001859c: 13a00004 movne r0, #4 <== NOT EXECUTED
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
300185a0: 1a000007 bne 300185c4 <rtems_task_is_suspended+0x3c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
300185a4: e5904010 ldr r4, [r0, #16] <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
300185a8: e2144002 ands r4, r4, #2 <== NOT EXECUTED 300185ac: 1a000002 bne 300185bc <rtems_task_is_suspended+0x34> <== NOT EXECUTED
_Thread_Enable_dispatch();
300185b0: eb001070 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300185b4: e1a00004 mov r0, r4 <== NOT EXECUTED 300185b8: ea000001 b 300185c4 <rtems_task_is_suspended+0x3c> <== NOT EXECUTED
}
_Thread_Enable_dispatch();
300185bc: eb00106d bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_ALREADY_SUSPENDED;
300185c0: e3a0000f mov r0, #15 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300185c4: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
3000ada0 <rtems_task_restart>:
rtems_status_code rtems_task_restart(
rtems_id id,
uint32_t argument
)
{
3000ada0: e92d4031 push {r0, r4, r5, lr}
3000ada4: e1a05001 mov r5, r1
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000ada8: e1a0100d mov r1, sp 3000adac: eb000876 bl 3000cf8c <_Thread_Get>
switch ( location ) {
3000adb0: e59d4000 ldr r4, [sp] 3000adb4: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000adb8: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000adbc: 1a000009 bne 3000ade8 <rtems_task_restart+0x48>
case OBJECTS_LOCAL:
if ( _Thread_Restart( the_thread, NULL, argument ) ) {
3000adc0: e1a01004 mov r1, r4 3000adc4: e1a02005 mov r2, r5 3000adc8: eb000a66 bl 3000d768 <_Thread_Restart> 3000adcc: e3500000 cmp r0, #0
3000add0: 0a000002 beq 3000ade0 <rtems_task_restart+0x40>
_Thread_Enable_dispatch();
3000add4: eb000864 bl 3000cf6c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000add8: e1a00004 mov r0, r4 3000addc: ea000001 b 3000ade8 <rtems_task_restart+0x48>
}
_Thread_Enable_dispatch();
3000ade0: eb000861 bl 3000cf6c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000ade4: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000ade8: e8bd8038 pop {r3, r4, r5, pc}
3000d7b0 <rtems_task_resume>:
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_resume(
rtems_id id
)
{
3000d7b0: e92d4011 push {r0, r4, lr}
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d7b4: e1a0100d mov r1, sp 3000d7b8: eb00086b bl 3000f96c <_Thread_Get>
switch ( location ) {
3000d7bc: e59d4000 ldr r4, [sp]
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d7c0: e1a03000 mov r3, r0
switch ( location ) {
3000d7c4: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000d7c8: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000d7cc: 1a000009 bne 3000d7f8 <rtems_task_resume+0x48>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
3000d7d0: e5933010 ldr r3, [r3, #16]
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
3000d7d4: e3130002 tst r3, #2
3000d7d8: 0a000004 beq 3000d7f0 <rtems_task_resume+0x40>
_Thread_Resume( the_thread );
3000d7dc: e3a01002 mov r1, #2 3000d7e0: eb00077e bl 3000f5e0 <_Thread_Clear_state>
_Thread_Enable_dispatch();
3000d7e4: eb000858 bl 3000f94c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000d7e8: e1a00004 mov r0, r4 3000d7ec: ea000001 b 3000d7f8 <rtems_task_resume+0x48>
}
_Thread_Enable_dispatch();
3000d7f0: eb000855 bl 3000f94c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000d7f4: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000d7f8: e8bd8018 pop {r3, r4, pc}
3000c1a8 <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000c1a8: e92d4071 push {r0, r4, r5, r6, lr}
3000c1ac: e1a05002 mov r5, r2
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c1b0: e59f2084 ldr r2, [pc, #132] ; 3000c23c <rtems_task_set_note+0x94>
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000c1b4: e1a03000 mov r3, r0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c1b8: e5d22004 ldrb r2, [r2, #4]
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000c1bc: e1a04001 mov r4, r1
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c1c0: e3520000 cmp r2, #0
return RTEMS_NOT_CONFIGURED;
3000c1c4: 03a00016 moveq r0, #22
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c1c8: 0a00001a beq 3000c238 <rtems_task_set_note+0x90>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000c1cc: e351000f cmp r1, #15
return RTEMS_INVALID_NUMBER;
3000c1d0: 83a0000a movhi r0, #10
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000c1d4: 8a000017 bhi 3000c238 <rtems_task_set_note+0x90>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c1d8: e3530000 cmp r3, #0 3000c1dc: e59f205c ldr r2, [pc, #92] ; 3000c240 <rtems_task_set_note+0x98>
3000c1e0: 0a000003 beq 3000c1f4 <rtems_task_set_note+0x4c>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
3000c1e4: e5921008 ldr r1, [r2, #8]
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c1e8: e5911008 ldr r1, [r1, #8] 3000c1ec: e1530001 cmp r3, r1
3000c1f0: 1a000005 bne 3000c20c <rtems_task_set_note+0x64>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
3000c1f4: e5923008 ldr r3, [r2, #8] <== NOT EXECUTED
api->Notepads[ notepad ] = note;
3000c1f8: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000c1fc: e59330ec ldr r3, [r3, #236] ; 0xec <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000c200: e3a00000 mov r0, #0 <== NOT EXECUTED
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
3000c204: e7835104 str r5, [r3, r4, lsl #2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000c208: ea00000a b 3000c238 <rtems_task_set_note+0x90> <== NOT EXECUTED
}
the_thread = _Thread_Get( id, &location );
3000c20c: e1a0100d mov r1, sp 3000c210: eb0008f3 bl 3000e5e4 <_Thread_Get>
switch ( location ) {
3000c214: e59d6000 ldr r6, [sp] 3000c218: e3560000 cmp r6, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000c21c: 13a00004 movne r0, #4
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000c220: 1a000004 bne 3000c238 <rtems_task_set_note+0x90>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
3000c224: e59030ec ldr r3, [r0, #236] ; 0xec 3000c228: e2844008 add r4, r4, #8 3000c22c: e7835104 str r5, [r3, r4, lsl #2]
_Thread_Enable_dispatch();
3000c230: eb0008e3 bl 3000e5c4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000c234: e1a00006 mov r0, r6
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000c238: e8bd8078 pop {r3, r4, r5, r6, pc}
3000e488 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
3000e488: e92d4031 push {r0, r4, r5, lr}
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000e48c: e2514000 subs r4, r1, #0
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
3000e490: e1a05002 mov r5, r2
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000e494: 0a000004 beq 3000e4ac <rtems_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 ) );
3000e498: e59f3074 ldr r3, [pc, #116] ; 3000e514 <rtems_task_set_priority+0x8c> 3000e49c: e5d33000 ldrb r3, [r3] 3000e4a0: e1540003 cmp r4, r3
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
3000e4a4: 83a00013 movhi r0, #19
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000e4a8: 8a000018 bhi 3000e510 <rtems_task_set_priority+0x88>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
3000e4ac: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
3000e4b0: 03a00009 moveq r0, #9
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
3000e4b4: 0a000015 beq 3000e510 <rtems_task_set_priority+0x88>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
3000e4b8: e1a0100d mov r1, sp 3000e4bc: eb0008ca bl 300107ec <_Thread_Get>
switch ( location ) {
3000e4c0: e59d3000 ldr r3, [sp] 3000e4c4: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000e4c8: 13a00004 movne r0, #4
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000e4cc: 1a00000f bne 3000e510 <rtems_task_set_priority+0x88>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
3000e4d0: e5903014 ldr r3, [r0, #20]
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
3000e4d4: e3540000 cmp r4, #0
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
3000e4d8: e5853000 str r3, [r5]
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
3000e4dc: 0a000009 beq 3000e508 <rtems_task_set_priority+0x80>
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
3000e4e0: e590301c ldr r3, [r0, #28]
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
the_thread->real_priority = new_priority;
3000e4e4: e5804018 str r4, [r0, #24]
if ( the_thread->resource_count == 0 ||
3000e4e8: e3530000 cmp r3, #0
3000e4ec: 0a000002 beq 3000e4fc <rtems_task_set_priority+0x74>
3000e4f0: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000e4f4: e1530004 cmp r3, r4 <== NOT EXECUTED 3000e4f8: 9a000002 bls 3000e508 <rtems_task_set_priority+0x80> <== NOT EXECUTED
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
3000e4fc: e1a01004 mov r1, r4 3000e500: e3a02000 mov r2, #0 3000e504: eb000797 bl 30010368 <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
3000e508: eb0008af bl 300107cc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000e50c: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000e510: e8bd8038 pop {r3, r4, r5, pc}
3000a684 <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
3000a684: e92d4073 push {r0, r1, r4, r5, r6, lr}
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
3000a688: e2515000 subs r5, r1, #0
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
3000a68c: e1a06002 mov r6, r2
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
3000a690: 03a00009 moveq r0, #9
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
3000a694: 0a000011 beq 3000a6e0 <rtems_task_start+0x5c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
3000a698: e28d1004 add r1, sp, #4 3000a69c: eb00085e bl 3000c81c <_Thread_Get>
switch ( location ) {
3000a6a0: e59d4004 ldr r4, [sp, #4] 3000a6a4: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a6a8: 13a00004 movne r0, #4
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000a6ac: 1a00000b bne 3000a6e0 <rtems_task_start+0x5c>
case OBJECTS_LOCAL:
if ( _Thread_Start(
3000a6b0: e1a01004 mov r1, r4 3000a6b4: e1a02005 mov r2, r5 3000a6b8: e1a03004 mov r3, r4 3000a6bc: e58d6000 str r6, [sp] 3000a6c0: eb000a96 bl 3000d120 <_Thread_Start> 3000a6c4: e3500000 cmp r0, #0
3000a6c8: 0a000002 beq 3000a6d8 <rtems_task_start+0x54>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
3000a6cc: eb00084a bl 3000c7fc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a6d0: e1a00004 mov r0, r4 3000a6d4: ea000001 b 3000a6e0 <rtems_task_start+0x5c>
}
_Thread_Enable_dispatch();
3000a6d8: eb000847 bl 3000c7fc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000a6dc: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000a6e0: e8bd807c pop {r2, r3, r4, r5, r6, pc}
3000da3c <rtems_task_suspend>:
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
3000da3c: e92d4011 push {r0, r4, lr}
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000da40: e1a0100d mov r1, sp 3000da44: eb00083b bl 3000fb38 <_Thread_Get>
switch ( location ) {
3000da48: e59d2000 ldr r2, [sp]
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000da4c: e1a03000 mov r3, r0
switch ( location ) {
3000da50: e3520000 cmp r2, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000da54: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000da58: 1a000009 bne 3000da84 <rtems_task_suspend+0x48>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
3000da5c: e5934010 ldr r4, [r3, #16]
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
3000da60: e2144002 ands r4, r4, #2
3000da64: 1a000004 bne 3000da7c <rtems_task_suspend+0x40>
_Thread_Suspend( the_thread );
3000da68: e3a01002 mov r1, #2 3000da6c: eb000a2f bl 30010330 <_Thread_Set_state>
_Thread_Enable_dispatch();
3000da70: eb000828 bl 3000fb18 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000da74: e1a00004 mov r0, r4 3000da78: ea000001 b 3000da84 <rtems_task_suspend+0x48>
}
_Thread_Enable_dispatch();
3000da7c: eb000825 bl 3000fb18 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_ALREADY_SUSPENDED;
3000da80: e3a0000f mov r0, #15 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000da84: e8bd8018 pop {r3, r4, pc}
30008ed4 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
30008ed4: e92d40f1 push {r0, r4, r5, r6, r7, lr}
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
30008ed8: e2514000 subs r4, r1, #0
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
30008edc: e1a05002 mov r5, r2
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
30008ee0: 03a00009 moveq r0, #9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
30008ee4: 0a000023 beq 30008f78 <rtems_task_variable_add+0xa4>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
30008ee8: e1a0100d mov r1, sp 30008eec: eb000795 bl 3000ad48 <_Thread_Get>
switch (location) {
30008ef0: e59d3000 ldr r3, [sp]
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
30008ef4: e1a07000 mov r7, r0
switch (location) {
30008ef8: e3530000 cmp r3, #0
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
30008efc: 059060f8 ldreq r6, [r0, #248] ; 0xf8
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
30008f00: 0a000008 beq 30008f28 <rtems_task_variable_add+0x54>
30008f04: ea00001a b 30008f74 <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) {
30008f08: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED 30008f0c: e1530004 cmp r3, r4 <== NOT EXECUTED 30008f10: 1a000003 bne 30008f24 <rtems_task_variable_add+0x50> <== NOT EXECUTED
tvp->dtor = dtor;
30008f14: e5865010 str r5, [r6, #16] <== NOT EXECUTED
_Thread_Enable_dispatch();
30008f18: eb000782 bl 3000ad28 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30008f1c: e3a00000 mov r0, #0 <== NOT EXECUTED 30008f20: ea000014 b 30008f78 <rtems_task_variable_add+0xa4> <== NOT EXECUTED
}
tvp = (rtems_task_variable_t *)tvp->next;
30008f24: e5966000 ldr r6, [r6] <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
30008f28: e3560000 cmp r6, #0
30008f2c: 1afffff5 bne 30008f08 <rtems_task_variable_add+0x34>
}
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
30008f30: e3a00014 mov r0, #20 30008f34: eb000b23 bl 3000bbc8 <_Workspace_Allocate>
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
30008f38: e3500000 cmp r0, #0
30008f3c: 1a000002 bne 30008f4c <rtems_task_variable_add+0x78>
_Thread_Enable_dispatch();
30008f40: eb000778 bl 3000ad28 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
30008f44: e3a0001a mov r0, #26 <== NOT EXECUTED 30008f48: ea00000a b 30008f78 <rtems_task_variable_add+0xa4> <== NOT EXECUTED
}
new->gval = *ptr;
30008f4c: e5943000 ldr r3, [r4]
new->ptr = ptr;
30008f50: e5804004 str r4, [r0, #4]
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
30008f54: e5803008 str r3, [r0, #8]
new->ptr = ptr;
new->dtor = dtor;
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
30008f58: e59730f8 ldr r3, [r7, #248] ; 0xf8
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
new->ptr = ptr;
new->dtor = dtor;
30008f5c: e5805010 str r5, [r0, #16]
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
30008f60: e5803000 str r3, [r0]
the_thread->task_variables = new;
30008f64: e58700f8 str r0, [r7, #248] ; 0xf8
_Thread_Enable_dispatch();
30008f68: eb00076e bl 3000ad28 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30008f6c: e1a00006 mov r0, r6 30008f70: ea000000 b 30008f78 <rtems_task_variable_add+0xa4>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30008f74: e3a00004 mov r0, #4 <== NOT EXECUTED
}
30008f78: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
30008f7c <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
30008f7c: e92d4011 push {r0, r4, lr}
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
30008f80: e2514000 subs r4, r1, #0
30008f84: 0a000016 beq 30008fe4 <rtems_task_variable_delete+0x68>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
30008f88: e1a0100d mov r1, sp 30008f8c: eb00076d bl 3000ad48 <_Thread_Get>
switch (location) {
30008f90: e59d3000 ldr r3, [sp] 30008f94: e3530000 cmp r3, #0
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
30008f98: 059010f8 ldreq r1, [r0, #248] ; 0xf8
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
switch (location) {
30008f9c: 0a00000d beq 30008fd8 <rtems_task_variable_delete+0x5c>
30008fa0: ea000011 b 30008fec <rtems_task_variable_delete+0x70> <== NOT EXECUTED
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
30008fa4: e5912004 ldr r2, [r1, #4] 30008fa8: e1520004 cmp r2, r4
30008fac: 1a000007 bne 30008fd0 <rtems_task_variable_delete+0x54>
30008fb0: e5912000 ldr r2, [r1]
if (prev)
30008fb4: e3530000 cmp r3, #0
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
30008fb8: 058020f8 streq r2, [r0, #248] ; 0xf8
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
30008fbc: 15832000 strne r2, [r3]
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
30008fc0: eb000028 bl 30009068 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
30008fc4: eb000757 bl 3000ad28 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30008fc8: e3a00000 mov r0, #0 30008fcc: ea000007 b 30008ff0 <rtems_task_variable_delete+0x74>
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
30008fd0: e1a03001 mov r3, r1 <== NOT EXECUTED 30008fd4: e5911000 ldr r1, [r1] <== NOT EXECUTED
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
30008fd8: e3510000 cmp r1, #0
30008fdc: 1afffff0 bne 30008fa4 <rtems_task_variable_delete+0x28>
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
30008fe0: eb000750 bl 3000ad28 <_Thread_Enable_dispatch> <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
30008fe4: e3a00009 mov r0, #9 <== NOT EXECUTED 30008fe8: ea000000 b 30008ff0 <rtems_task_variable_delete+0x74> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30008fec: e3a00004 mov r0, #4 <== NOT EXECUTED
}
30008ff0: e8bd8018 pop {r3, r4, pc}
30008ff4 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
30008ff4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
30008ff8: e2515000 subs r5, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
30008ffc: e1a04002 mov r4, r2 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
30009000: 0a000014 beq 30009058 <rtems_task_variable_get+0x64> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !result )
30009004: e3520000 cmp r2, #0 <== NOT EXECUTED 30009008: 0a000012 beq 30009058 <rtems_task_variable_get+0x64> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
3000900c: e1a0100d mov r1, sp <== NOT EXECUTED 30009010: eb00074c bl 3000ad48 <_Thread_Get> <== NOT EXECUTED
switch (location) {
30009014: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30009018: e3530000 cmp r3, #0 <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
3000901c: 059030f8 ldreq r3, [r0, #248] ; 0xf8 <== NOT EXECUTED
if ( !result )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
30009020: 0a000009 beq 3000904c <rtems_task_variable_get+0x58> <== NOT EXECUTED 30009024: ea00000d b 30009060 <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) {
30009028: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000902c: e1520005 cmp r2, r5 <== NOT EXECUTED 30009030: 1a000004 bne 30009048 <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;
30009034: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 30009038: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000903c: eb000739 bl 3000ad28 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30009040: e3a00000 mov r0, #0 <== NOT EXECUTED 30009044: ea000006 b 30009064 <rtems_task_variable_get+0x70> <== NOT EXECUTED
}
tvp = (rtems_task_variable_t *)tvp->next;
30009048: e5933000 ldr r3, [r3] <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
3000904c: e3530000 cmp r3, #0 <== NOT EXECUTED 30009050: 1afffff4 bne 30009028 <rtems_task_variable_get+0x34> <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
30009054: eb000733 bl 3000ad28 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
30009058: e3a00009 mov r0, #9 <== NOT EXECUTED 3000905c: ea000000 b 30009064 <rtems_task_variable_get+0x70> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009060: e3a00004 mov r0, #4 <== NOT EXECUTED
}
30009064: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
3000a6e4 <rtems_task_wake_after>:
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000a6e4: e59f3074 ldr r3, [pc, #116] ; 3000a760 <rtems_task_wake_after+0x7c>
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_wake_after(
rtems_interval ticks
)
{
3000a6e8: e92d4030 push {r4, r5, lr}
3000a6ec: e5932000 ldr r2, [r3]
3000a6f0: e1a04000 mov r4, r0
++level;
3000a6f4: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000a6f8: e5832000 str r2, [r3]
_Thread_Disable_dispatch();
if ( ticks == 0 ) {
3000a6fc: e3500000 cmp r0, #0
3000a700: 1a000003 bne 3000a714 <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();
3000a704: e59f3058 ldr r3, [pc, #88] ; 3000a764 <rtems_task_wake_after+0x80> 3000a708: e1a0e00f mov lr, pc 3000a70c: e593f00c ldr pc, [r3, #12] 3000a710: ea00000f b 3000a754 <rtems_task_wake_after+0x70>
_Scheduler_Yield();
} else {
_Thread_Set_state( _Thread_Executing, STATES_DELAYING );
3000a714: e59f504c ldr r5, [pc, #76] ; 3000a768 <rtems_task_wake_after+0x84><== NOT EXECUTED 3000a718: e3a01008 mov r1, #8 <== NOT EXECUTED 3000a71c: e5950008 ldr r0, [r5, #8] <== NOT EXECUTED 3000a720: eb000a3b bl 3000d014 <_Thread_Set_state> <== NOT EXECUTED
_Watchdog_Initialize(
&_Thread_Executing->Timer,
3000a724: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000a728: e59f003c ldr r0, [pc, #60] ; 3000a76c <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(
3000a72c: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a730: e3a03000 mov r3, #0 <== NOT EXECUTED
the_watchdog->routine = routine;
3000a734: e5810064 str r0, [r1, #100] ; 0x64 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a738: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id;
3000a73c: e5812068 str r2, [r1, #104] ; 0x68 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000a740: e581306c str r3, [r1, #108] ; 0x6c <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a744: e5814054 str r4, [r1, #84] ; 0x54 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a748: e59f0020 ldr r0, [pc, #32] ; 3000a770 <rtems_task_wake_after+0x8c><== NOT EXECUTED 3000a74c: e2811048 add r1, r1, #72 ; 0x48 <== NOT EXECUTED 3000a750: eb000b06 bl 3000d370 <_Watchdog_Insert> <== NOT EXECUTED
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
}
_Thread_Enable_dispatch();
3000a754: eb000828 bl 3000c7fc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL; }
3000a758: e3a00000 mov r0, #0
3000a75c: e8bd8030 pop {r4, r5, pc}
3000b5c0 <rtems_task_wake_when>:
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
3000b5c0: e92d40f0 push {r4, r5, r6, r7, lr}
Watchdog_Interval seconds;
if ( !_TOD.is_set )
3000b5c4: e59f60cc ldr r6, [pc, #204] ; 3000b698 <rtems_task_wake_when+0xd8>
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
3000b5c8: e1a04000 mov r4, r0
Watchdog_Interval seconds;
if ( !_TOD.is_set )
3000b5cc: e5d63014 ldrb r3, [r6, #20] 3000b5d0: e3530000 cmp r3, #0
return RTEMS_NOT_DEFINED;
3000b5d4: 03a0000b moveq r0, #11
rtems_time_of_day *time_buffer
)
{
Watchdog_Interval seconds;
if ( !_TOD.is_set )
3000b5d8: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
3000b5dc: e3540000 cmp r4, #0
return RTEMS_INVALID_ADDRESS;
3000b5e0: 03a00009 moveq r0, #9
Watchdog_Interval seconds;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
3000b5e4: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
3000b5e8: e3a05000 mov r5, #0 3000b5ec: e5845018 str r5, [r4, #24]
if ( !_TOD_Validate( time_buffer ) )
3000b5f0: ebfffcfa bl 3000a9e0 <_TOD_Validate> 3000b5f4: e1500005 cmp r0, r5
return RTEMS_INVALID_CLOCK;
3000b5f8: 03a00014 moveq r0, #20
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
3000b5fc: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
3000b600: e1a00004 mov r0, r4 3000b604: ebfffccd bl 3000a940 <_TOD_To_seconds>
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
3000b608: e59f208c ldr r2, [pc, #140] ; 3000b69c <rtems_task_wake_when+0xdc>
3000b60c: e1a07000 mov r7, r0
3000b610: e3a03000 mov r3, #0
3000b614: e8960003 ldm r6, {r0, r1}
3000b618: eb00420d bl 3001be54 <__divdi3>
if ( seconds <= _TOD_Seconds_since_epoch() )
3000b61c: e1570000 cmp r7, r0
3000b620: 9a00001a bls 3000b690 <rtems_task_wake_when+0xd0>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000b624: e59f3074 ldr r3, [pc, #116] ; 3000b6a0 <rtems_task_wake_when+0xe0> 3000b628: e5932000 ldr r2, [r3]
++level;
3000b62c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000b630: e5832000 str r2, [r3]
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
3000b634: e59f4068 ldr r4, [pc, #104] ; 3000b6a4 <rtems_task_wake_when+0xe4>
3000b638: e3a01010 mov r1, #16
3000b63c: e5940008 ldr r0, [r4, #8]
3000b640: eb000a6d bl 3000dffc <_Thread_Set_state>
3000b644: e8960003 ldm r6, {r0, r1}
_Watchdog_Initialize(
&_Thread_Executing->Timer,
3000b648: e5944008 ldr r4, [r4, #8]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000b64c: e59f2054 ldr r2, [pc, #84] ; 3000b6a8 <rtems_task_wake_when+0xe8>
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
_Watchdog_Initialize(
3000b650: e5943008 ldr r3, [r4, #8] 3000b654: e5842064 str r2, [r4, #100] ; 0x64
the_watchdog->id = id;
3000b658: e5843068 str r3, [r4, #104] ; 0x68 3000b65c: e59f2038 ldr r2, [pc, #56] ; 3000b69c <rtems_task_wake_when+0xdc> 3000b660: e3a03000 mov r3, #0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000b664: e5845050 str r5, [r4, #80] ; 0x50
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3000b668: e584506c str r5, [r4, #108] ; 0x6c 3000b66c: eb0041f8 bl 3001be54 <__divdi3>
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
3000b670: e0600007 rsb r0, r0, r7
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000b674: e5840054 str r0, [r4, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000b678: e2841048 add r1, r4, #72 ; 0x48 3000b67c: e59f0028 ldr r0, [pc, #40] ; 3000b6ac <rtems_task_wake_when+0xec> 3000b680: eb000b5c bl 3000e3f8 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
3000b684: eb000856 bl 3000d7e4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b688: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b68c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
3000b690: e3a00014 mov r0, #20 <== NOT EXECUTED
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000b694: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000a708 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
3000a708: e92d40f0 push {r4, r5, r6, r7, lr}
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
3000a70c: e2506000 subs r6, r0, #0
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
3000a710: e1a04001 mov r4, r1
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000a714: 03a00003 moveq r0, #3
rtems_id *id
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
3000a718: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_NAME;
if ( !id )
3000a71c: e3510000 cmp r1, #0
3000a720: 0a00001b beq 3000a794 <rtems_timer_create+0x8c>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000a724: e59f3070 ldr r3, [pc, #112] ; 3000a79c <rtems_timer_create+0x94> 3000a728: e5932000 ldr r2, [r3]
++level;
3000a72c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3000a730: e5832000 str r2, [r3]
* This function allocates a timer control block from
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void )
{
return (Timer_Control *) _Objects_Allocate( &_Timer_Information );
3000a734: e59f5064 ldr r5, [pc, #100] ; 3000a7a0 <rtems_timer_create+0x98> 3000a738: e1a00005 mov r0, r5 3000a73c: eb0003c0 bl 3000b644 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
3000a740: e3500000 cmp r0, #0
3000a744: 1a000002 bne 3000a754 <rtems_timer_create+0x4c>
_Thread_Enable_dispatch();
3000a748: eb000842 bl 3000c858 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000a74c: e3a00005 mov r0, #5 <== NOT EXECUTED
3000a750: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
}
the_timer->the_class = TIMER_DORMANT;
3000a754: e3a03004 mov r3, #4 3000a758: e5803038 str r3, [r0, #56] ; 0x38
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000a75c: e1d010b8 ldrh r1, [r0, #8] 3000a760: e5903008 ldr r3, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a764: e595201c ldr r2, [r5, #28]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a768: e3a07000 mov r7, #0 3000a76c: e5807018 str r7, [r0, #24]
the_watchdog->routine = routine;
3000a770: e580702c str r7, [r0, #44] ; 0x2c
the_watchdog->id = id;
3000a774: e5807030 str r7, [r0, #48] ; 0x30
the_watchdog->user_data = user_data;
3000a778: e5807034 str r7, [r0, #52] ; 0x34 3000a77c: e7820101 str r0, [r2, r1, lsl #2]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000a780: e580600c str r6, [r0, #12]
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
3000a784: e5843000 str r3, [r4]
_Thread_Enable_dispatch();
3000a788: eb000832 bl 3000c858 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a78c: e1a00007 mov r0, r7
3000a790: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000a794: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000a798: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000a7a4 <rtems_timer_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3000a7a4: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr}
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
3000a7a8: e2516000 subs r6, r1, #0
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3000a7ac: e1a04000 mov r4, r0 3000a7b0: e1a05002 mov r5, r2 3000a7b4: e1a07003 mov r7, r3
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
3000a7b8: 03a0000a moveq r0, #10
{
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
3000a7bc: 0a000022 beq 3000a84c <rtems_timer_fire_after+0xa8>
return RTEMS_INVALID_NUMBER;
if ( !routine )
3000a7c0: e3520000 cmp r2, #0
return RTEMS_INVALID_ADDRESS;
3000a7c4: 03a00009 moveq r0, #9
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
3000a7c8: 0a00001f beq 3000a84c <rtems_timer_fire_after+0xa8>
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
3000a7cc: e59f007c ldr r0, [pc, #124] ; 3000a850 <rtems_timer_fire_after+0xac> 3000a7d0: e1a01004 mov r1, r4 3000a7d4: e1a0200d mov r2, sp 3000a7d8: eb0004bd bl 3000bad4 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3000a7dc: e59d3000 ldr r3, [sp] 3000a7e0: e1a08000 mov r8, r0 3000a7e4: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a7e8: 13a00004 movne r0, #4
if ( !routine )
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3000a7ec: 1a000016 bne 3000a84c <rtems_timer_fire_after+0xa8>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3000a7f0: e288a010 add sl, r8, #16 3000a7f4: e1a0000a mov r0, sl 3000a7f8: eb000b4a bl 3000d528 <_Watchdog_Remove>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3000a7fc: e10f2000 mrs r2, CPSR 3000a800: e3823080 orr r3, r2, #128 ; 0x80 3000a804: e129f003 msr CPSR_fc, r3
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
3000a808: e5983018 ldr r3, [r8, #24] 3000a80c: e3530000 cmp r3, #0
3000a810: 0a000001 beq 3000a81c <rtems_timer_fire_after+0x78>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a814: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 3000a818: ea000009 b 3000a844 <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;
3000a81c: e5883038 str r3, [r8, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a820: e5883018 str r3, [r8, #24]
the_watchdog->routine = routine;
3000a824: e588502c str r5, [r8, #44] ; 0x2c
the_watchdog->id = id;
3000a828: e5884030 str r4, [r8, #48] ; 0x30
the_watchdog->user_data = user_data;
3000a82c: e5887034 str r7, [r8, #52] ; 0x34 3000a830: e129f002 msr CPSR_fc, r2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a834: e59f0018 ldr r0, [pc, #24] ; 3000a854 <rtems_timer_fire_after+0xb0>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a838: e588601c str r6, [r8, #28]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a83c: e1a0100a mov r1, sl 3000a840: eb000ae1 bl 3000d3cc <_Watchdog_Insert>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
3000a844: eb000803 bl 3000c858 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a848: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000a84c: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc}
30018d0c <rtems_timer_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018d0c: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD.is_set )
30018d10: e59f60dc ldr r6, [pc, #220] ; 30018df4 <rtems_timer_fire_when+0xe8>
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018d14: e1a0b003 mov fp, r3
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD.is_set )
30018d18: e5d63014 ldrb r3, [r6, #20]
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018d1c: e1a0a000 mov sl, r0
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD.is_set )
30018d20: e3530000 cmp r3, #0
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018d24: e1a04001 mov r4, r1 30018d28: e1a08002 mov r8, r2
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
30018d2c: 03a0000b moveq r0, #11
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD.is_set )
30018d30: 0a00002e beq 30018df0 <rtems_timer_fire_when+0xe4>
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
30018d34: e1a00001 mov r0, r1 30018d38: ebfff4d4 bl 30016090 <_TOD_Validate> 30018d3c: e3500000 cmp r0, #0
30018d40: 0a000029 beq 30018dec <rtems_timer_fire_when+0xe0>
return RTEMS_INVALID_CLOCK;
if ( !routine )
30018d44: e3580000 cmp r8, #0
return RTEMS_INVALID_ADDRESS;
30018d48: 03a00009 moveq r0, #9
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
30018d4c: 0a000027 beq 30018df0 <rtems_timer_fire_when+0xe4>
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
30018d50: e1a00004 mov r0, r4
30018d54: ebfff4a5 bl 30015ff0 <_TOD_To_seconds>
30018d58: e59f2098 ldr r2, [pc, #152] ; 30018df8 <rtems_timer_fire_when+0xec>
30018d5c: e1a07000 mov r7, r0
30018d60: e3a03000 mov r3, #0
30018d64: e8960003 ldm r6, {r0, r1}
30018d68: eb004c83 bl 3002bf7c <__divdi3>
if ( seconds <= _TOD_Seconds_since_epoch() )
30018d6c: e1570000 cmp r7, r0
30018d70: 9a00001d bls 30018dec <rtems_timer_fire_when+0xe0>
30018d74: e59f0080 ldr r0, [pc, #128] ; 30018dfc <rtems_timer_fire_when+0xf0> 30018d78: e1a0100a mov r1, sl 30018d7c: e1a0200d mov r2, sp 30018d80: eb000af9 bl 3001b96c <_Objects_Get>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018d84: e59d5000 ldr r5, [sp] 30018d88: e1a04000 mov r4, r0 30018d8c: e3550000 cmp r5, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018d90: 13a00004 movne r0, #4
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018d94: 1a000015 bne 30018df0 <rtems_timer_fire_when+0xe4>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
30018d98: e2849010 add r9, r4, #16
30018d9c: e1a00009 mov r0, r9
30018da0: eb001212 bl 3001d5f0 <_Watchdog_Remove>
30018da4: e8960003 ldm r6, {r0, r1}
the_timer->the_class = TIMER_TIME_OF_DAY;
30018da8: e3a03002 mov r3, #2 30018dac: e59f2044 ldr r2, [pc, #68] ; 30018df8 <rtems_timer_fire_when+0xec> 30018db0: e5843038 str r3, [r4, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30018db4: e5845018 str r5, [r4, #24] 30018db8: e3a03000 mov r3, #0
the_watchdog->routine = routine;
30018dbc: e584802c str r8, [r4, #44] ; 0x2c
the_watchdog->id = id;
30018dc0: e584a030 str sl, [r4, #48] ; 0x30
the_watchdog->user_data = user_data;
30018dc4: e584b034 str fp, [r4, #52] ; 0x34 30018dc8: eb004c6b bl 3002bf7c <__divdi3>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
30018dcc: e0600007 rsb r0, r0, r7
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
30018dd0: e584001c str r0, [r4, #28]
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
30018dd4: e1a01009 mov r1, r9 30018dd8: e59f0020 ldr r0, [pc, #32] ; 30018e00 <rtems_timer_fire_when+0xf4> 30018ddc: eb0011ac bl 3001d494 <_Watchdog_Insert>
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
30018de0: eb000e64 bl 3001c778 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30018de4: e1a00005 mov r0, r5 30018de8: ea000000 b 30018df0 <rtems_timer_fire_when+0xe4>
if ( !routine )
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
30018dec: e3a00014 mov r0, #20 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018df0: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
30018e04 <rtems_timer_get_information>:
rtems_status_code rtems_timer_get_information(
rtems_id id,
rtems_timer_information *the_info
)
{
30018e04: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
30018e08: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_timer_get_information(
rtems_id id,
rtems_timer_information *the_info
)
{
30018e0c: e1a03000 mov r3, r0 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
30018e10: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
30018e14: 0a000011 beq 30018e60 <rtems_timer_get_information+0x5c> <== NOT EXECUTED 30018e18: e59f0044 ldr r0, [pc, #68] ; 30018e64 <rtems_timer_get_information+0x60><== NOT EXECUTED 30018e1c: e1a01003 mov r1, r3 <== NOT EXECUTED 30018e20: e1a0200d mov r2, sp <== NOT EXECUTED 30018e24: eb000ad0 bl 3001b96c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018e28: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30018e2c: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018e30: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018e34: 1a000009 bne 30018e60 <rtems_timer_get_information+0x5c> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
30018e38: e5903038 ldr r3, [r0, #56] ; 0x38 <== NOT EXECUTED 30018e3c: e5843000 str r3, [r4] <== NOT EXECUTED
the_info->initial = the_timer->Ticker.initial;
30018e40: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 30018e44: e5843004 str r3, [r4, #4] <== NOT EXECUTED
the_info->start_time = the_timer->Ticker.start_time;
30018e48: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 30018e4c: e5843008 str r3, [r4, #8] <== NOT EXECUTED
the_info->stop_time = the_timer->Ticker.stop_time;
30018e50: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 30018e54: e584300c str r3, [r4, #12] <== NOT EXECUTED
_Thread_Enable_dispatch();
30018e58: eb000e46 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30018e5c: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018e60: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
300194bc <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
300194bc: e92d41f7 push {r0, r1, r2, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
300194c0: e3500000 cmp r0, #0 <== NOT EXECUTED 300194c4: e1a05001 mov r5, r1 <== NOT EXECUTED 300194c8: e1a08002 mov r8, r2 <== NOT EXECUTED 300194cc: 01a07000 moveq r7, r0 <== NOT EXECUTED 300194d0: 0a000004 beq 300194e8 <rtems_timer_initiate_server+0x2c> <== NOT EXECUTED
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
300194d4: e59f3148 ldr r3, [pc, #328] ; 30019624 <rtems_timer_initiate_server+0x168><== NOT EXECUTED 300194d8: e5d37000 ldrb r7, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
300194dc: e1500007 cmp r0, r7 <== NOT EXECUTED 300194e0: 83a07000 movhi r7, #0 <== NOT EXECUTED 300194e4: 93a07001 movls r7, #1 <== NOT EXECUTED
* Make sure the requested priority is valid. The if is
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
300194e8: e21770ff ands r7, r7, #255 ; 0xff <== NOT EXECUTED 300194ec: 1a000003 bne 30019500 <rtems_timer_initiate_server+0x44> <== NOT EXECUTED
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
300194f0: e3700001 cmn r0, #1 <== NOT EXECUTED
return RTEMS_INVALID_PRIORITY;
300194f4: 13a05013 movne r5, #19 <== NOT EXECUTED
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
300194f8: 1a000047 bne 3001961c <rtems_timer_initiate_server+0x160> <== NOT EXECUTED 300194fc: ea000000 b 30019504 <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 ) ) {
30019500: e1a07000 mov r7, r0 <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
30019504: e59f311c ldr r3, [pc, #284] ; 30019628 <rtems_timer_initiate_server+0x16c><== NOT EXECUTED 30019508: e5932000 ldr r2, [r3] <== NOT EXECUTED
++level;
3001950c: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
30019510: e5832000 str r2, [r3] <== NOT EXECUTED
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
30019514: e59f4110 ldr r4, [pc, #272] ; 3001962c <rtems_timer_initiate_server+0x170><== NOT EXECUTED
initialized = true;
30019518: e3a03001 mov r3, #1 <== NOT EXECUTED
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
3001951c: e5d46000 ldrb r6, [r4] <== NOT EXECUTED
initialized = true;
30019520: e5c43000 strb r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
30019524: eb000c93 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( tmpInitialized )
30019528: e3560000 cmp r6, #0 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3001952c: 13a0500e movne r5, #14 <== NOT EXECUTED
_Thread_Disable_dispatch();
tmpInitialized = initialized;
initialized = true;
_Thread_Enable_dispatch();
if ( tmpInitialized )
30019530: 1a000039 bne 3001961c <rtems_timer_initiate_server+0x160> <== NOT EXECUTED
* other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create(
30019534: e28d3008 add r3, sp, #8 <== NOT EXECUTED 30019538: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3001953c: e1a02005 mov r2, r5 <== NOT EXECUTED 30019540: e3888902 orr r8, r8, #32768 ; 0x8000 <== NOT EXECUTED 30019544: e59f00e4 ldr r0, [pc, #228] ; 30019630 <rtems_timer_initiate_server+0x174><== NOT EXECUTED 30019548: e1a01007 mov r1, r7 <== NOT EXECUTED 3001954c: e3a03c01 mov r3, #256 ; 0x100 <== NOT EXECUTED 30019550: e58d8000 str r8, [sp] <== NOT EXECUTED 30019554: ebfffb36 bl 30018234 <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) {
30019558: e2505000 subs r5, r0, #0 <== NOT EXECUTED
initialized = false;
3001955c: 15c46000 strbne r6, [r4] <== NOT EXECUTED
/* user may want floating point but we need */
/* system task specified for 0 priority */
attribute_set | RTEMS_SYSTEM_TASK,
&id /* get the id back */
);
if (status) {
30019560: 1a00002d bne 3001961c <rtems_timer_initiate_server+0x160> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
30019564: e59f30c8 ldr r3, [pc, #200] ; 30019634 <rtems_timer_initiate_server+0x178><== NOT EXECUTED 30019568: e1dd20b8 ldrh r2, [sp, #8] <== NOT EXECUTED 3001956c: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
/*
* We work with the TCB pointer, not the ID, so we need to convert
* to a TCB pointer from here out.
*/
ts->thread = (Thread_Control *)_Objects_Get_local_object(
30019570: e1a06004 mov r6, r4 <== NOT EXECUTED 30019574: e7933102 ldr r3, [r3, r2, lsl #2] <== NOT EXECUTED 30019578: e59d7008 ldr r7, [sp, #8] <== NOT EXECUTED 3001957c: e5a63004 str r3, [r6, #4]! <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
30019580: e2843038 add r3, r4, #56 ; 0x38 <== NOT EXECUTED 30019584: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
30019588: e2843034 add r3, r4, #52 ; 0x34 <== NOT EXECUTED 3001958c: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
30019590: e2843070 add r3, r4, #112 ; 0x70 <== NOT EXECUTED 30019594: e584306c str r3, [r4, #108] ; 0x6c <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
30019598: e284306c add r3, r4, #108 ; 0x6c <== NOT EXECUTED 3001959c: e5843074 str r3, [r4, #116] ; 0x74 <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
300195a0: e59f3090 ldr r3, [pc, #144] ; 30019638 <rtems_timer_initiate_server+0x17c><== NOT EXECUTED 300195a4: e59f2090 ldr r2, [pc, #144] ; 3001963c <rtems_timer_initiate_server+0x180><== NOT EXECUTED 300195a8: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300195ac: e5843060 str r3, [r4, #96] ; 0x60 <== NOT EXECUTED
/*
* Initialize the pointer to the timer schedule method so applications that
* do not use the Timer Server do not have to pull it in.
*/
ts->schedule_operation = _Timer_server_Schedule_operation_method;
300195b0: e59f3088 ldr r3, [pc, #136] ; 30019640 <rtems_timer_initiate_server+0x184><== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
300195b4: e5845038 str r5, [r4, #56] ; 0x38 <== NOT EXECUTED 300195b8: e5843008 str r3, [r4, #8] <== NOT EXECUTED
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
300195bc: e59f3080 ldr r3, [pc, #128] ; 30019644 <rtems_timer_initiate_server+0x188><== NOT EXECUTED 300195c0: e5845070 str r5, [r4, #112] ; 0x70 <== NOT EXECUTED 300195c4: e5933000 ldr r3, [r3] <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
300195c8: e5845014 str r5, [r4, #20] <== NOT EXECUTED 300195cc: e5843040 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED 300195d0: e59f3070 ldr r3, [pc, #112] ; 30019648 <rtems_timer_initiate_server+0x18c><== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
300195d4: e5845030 str r5, [r4, #48] ; 0x30 <== NOT EXECUTED
300195d8: e8930003 ldm r3, {r0, r1} <== NOT EXECUTED
300195dc: e3a03000 mov r3, #0 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
300195e0: e584504c str r5, [r4, #76] ; 0x4c <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
300195e4: e5845068 str r5, [r4, #104] ; 0x68 <== NOT EXECUTED
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
300195e8: e584702c str r7, [r4, #44] ; 0x2c <== NOT EXECUTED 300195ec: e5847064 str r7, [r4, #100] ; 0x64 <== NOT EXECUTED 300195f0: eb004a61 bl 3002bf7c <__divdi3> <== NOT EXECUTED
ts->active = false;
/*
* The default timer server is now available.
*/
_Timer_server = ts;
300195f4: e59f3050 ldr r3, [pc, #80] ; 3001964c <rtems_timer_initiate_server+0x190><== NOT EXECUTED
* do not use the Timer Server do not have to pull it in.
*/
ts->schedule_operation = _Timer_server_Schedule_operation_method;
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
300195f8: e5840078 str r0, [r4, #120] ; 0x78 <== NOT EXECUTED
_Timer_server = ts;
/*
* Start the timer server
*/
status = rtems_task_start(
300195fc: e59f104c ldr r1, [pc, #76] ; 30019650 <rtems_timer_initiate_server+0x194><== NOT EXECUTED
ts->schedule_operation = _Timer_server_Schedule_operation_method;
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
ts->insert_chain = NULL;
30019600: e584507c str r5, [r4, #124] ; 0x7c <== NOT EXECUTED
_Timer_server = ts;
/*
* Start the timer server
*/
status = rtems_task_start(
30019604: e1a00007 mov r0, r7 <== NOT EXECUTED
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
ts->insert_chain = NULL;
ts->active = false;
30019608: e5c45080 strb r5, [r4, #128] ; 0x80 <== NOT EXECUTED
_Timer_server = ts;
/*
* Start the timer server
*/
status = rtems_task_start(
3001960c: e1a02006 mov r2, r6 <== NOT EXECUTED
ts->active = false;
/*
* The default timer server is now available.
*/
_Timer_server = ts;
30019610: e5836000 str r6, [r3] <== NOT EXECUTED
/*
* Start the timer server
*/
status = rtems_task_start(
30019614: ebfffcb6 bl 300188f4 <rtems_task_start> <== NOT EXECUTED 30019618: e1a05000 mov r5, r0 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001961c: e1a00005 mov r0, r5 <== NOT EXECUTED
30019620: e8bd81fe pop {r1, r2, r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30018e98 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
30018e98: e92d4071 push {r0, r4, r5, r6, lr}
30018e9c: e1a01000 mov r1, r0
30018ea0: e1a0200d mov r2, sp
30018ea4: e59f0078 ldr r0, [pc, #120] ; 30018f24 <rtems_timer_reset+0x8c>
30018ea8: eb000aaf bl 3001b96c <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018eac: e59d5000 ldr r5, [sp] 30018eb0: e1a06000 mov r6, r0 30018eb4: e3550000 cmp r5, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018eb8: 13a04004 movne r4, #4
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018ebc: 1a000016 bne 30018f1c <rtems_timer_reset+0x84>
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
30018ec0: e5904038 ldr r4, [r0, #56] ; 0x38 30018ec4: e3540000 cmp r4, #0
30018ec8: 1a000006 bne 30018ee8 <rtems_timer_reset+0x50>
_Watchdog_Remove( &the_timer->Ticker );
30018ecc: e2806010 add r6, r0, #16 30018ed0: e1a00006 mov r0, r6 30018ed4: eb0011c5 bl 3001d5f0 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
30018ed8: e59f0048 ldr r0, [pc, #72] ; 30018f28 <rtems_timer_reset+0x90> 30018edc: e1a01006 mov r1, r6 30018ee0: eb00116b bl 3001d494 <_Watchdog_Insert> 30018ee4: ea00000b b 30018f18 <rtems_timer_reset+0x80>
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
30018ee8: e3540001 cmp r4, #1 <== NOT EXECUTED
/*
* Must be dormant or time of day timer (e.g. TIMER_DORMANT,
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
30018eec: 13a0400b movne r4, #11 <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
30018ef0: 1a000008 bne 30018f18 <rtems_timer_reset+0x80> <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
30018ef4: e59f3030 ldr r3, [pc, #48] ; 30018f2c <rtems_timer_reset+0x94><== NOT EXECUTED
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
30018ef8: e2800010 add r0, r0, #16 <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
Timer_server_Control *timer_server = _Timer_server;
30018efc: e5934000 ldr r4, [r3] <== NOT EXECUTED
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
30018f00: eb0011ba bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
30018f04: e1a00004 mov r0, r4 <== NOT EXECUTED 30018f08: e1a01006 mov r1, r6 <== NOT EXECUTED 30018f0c: e1a0e00f mov lr, pc <== NOT EXECUTED 30018f10: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
30018f14: e1a04005 mov r4, r5 <== NOT EXECUTED
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
}
_Thread_Enable_dispatch();
30018f18: eb000e16 bl 3001c778 <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018f1c: e1a00004 mov r0, r4
30018f20: e8bd8078 pop {r3, r4, r5, r6, pc}
30018f30 <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018f30: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
30018f34: e1a08003 mov r8, r3 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
30018f38: e59f30b8 ldr r3, [pc, #184] ; 30018ff8 <rtems_timer_server_fire_after+0xc8><== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018f3c: e1a05000 mov r5, r0 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
30018f40: e5937000 ldr r7, [r3] <== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018f44: e1a04001 mov r4, r1 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
30018f48: e3570000 cmp r7, #0 <== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30018f4c: e1a06002 mov r6, r2 <== NOT EXECUTED
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
30018f50: 03a0000e moveq r0, #14 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
30018f54: 0a000026 beq 30018ff4 <rtems_timer_server_fire_after+0xc4> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !routine )
30018f58: e3520000 cmp r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30018f5c: 03a00009 moveq r0, #9 <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !routine )
30018f60: 0a000023 beq 30018ff4 <rtems_timer_server_fire_after+0xc4> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
30018f64: e3510000 cmp r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
30018f68: 03a0000a moveq r0, #10 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
30018f6c: 0a000020 beq 30018ff4 <rtems_timer_server_fire_after+0xc4> <== NOT EXECUTED 30018f70: e59f0084 ldr r0, [pc, #132] ; 30018ffc <rtems_timer_server_fire_after+0xcc><== NOT EXECUTED 30018f74: e1a01005 mov r1, r5 <== NOT EXECUTED 30018f78: e1a0200d mov r2, sp <== NOT EXECUTED 30018f7c: eb000a7a bl 3001b96c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018f80: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30018f84: e1a0a000 mov sl, r0 <== NOT EXECUTED 30018f88: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018f8c: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
30018f90: 1a000017 bne 30018ff4 <rtems_timer_server_fire_after+0xc4> <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
30018f94: e28a0010 add r0, sl, #16 <== NOT EXECUTED 30018f98: eb001194 bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
30018f9c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30018fa0: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30018fa4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
30018fa8: e59a2018 ldr r2, [sl, #24] <== NOT EXECUTED 30018fac: e3520000 cmp r2, #0 <== NOT EXECUTED 30018fb0: 0a000001 beq 30018fbc <rtems_timer_server_fire_after+0x8c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30018fb4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED 30018fb8: ea00000b b 30018fec <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;
30018fbc: e3a01001 mov r1, #1 <== NOT EXECUTED 30018fc0: e58a1038 str r1, [sl, #56] ; 0x38 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30018fc4: e58a2018 str r2, [sl, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
30018fc8: e58a602c str r6, [sl, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
30018fcc: e58a5030 str r5, [sl, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
30018fd0: e58a8034 str r8, [sl, #52] ; 0x34 <== NOT EXECUTED
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
30018fd4: e58a401c str r4, [sl, #28] <== NOT EXECUTED 30018fd8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( level );
(*timer_server->schedule_operation)( timer_server, the_timer );
30018fdc: e1a00007 mov r0, r7 <== NOT EXECUTED 30018fe0: e1a0100a mov r1, sl <== NOT EXECUTED 30018fe4: e1a0e00f mov lr, pc <== NOT EXECUTED 30018fe8: e597f004 ldr pc, [r7, #4] <== NOT EXECUTED
_Thread_Enable_dispatch();
30018fec: eb000de1 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30018ff0: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018ff4: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30019000 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30019000: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
30019004: e1a0b003 mov fp, r3 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
30019008: e59f30ec ldr r3, [pc, #236] ; 300190fc <rtems_timer_server_fire_when+0xfc><== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001900c: e1a09000 mov r9, r0 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
30019010: e5935000 ldr r5, [r3] <== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
30019014: e1a04001 mov r4, r1 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
30019018: e3550000 cmp r5, #0 <== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001901c: e1a0a002 mov sl, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
30019020: 03a0000e moveq r0, #14 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
30019024: 0a000033 beq 300190f8 <rtems_timer_server_fire_when+0xf8> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
30019028: e59f60d0 ldr r6, [pc, #208] ; 30019100 <rtems_timer_server_fire_when+0x100><== NOT EXECUTED 3001902c: e5d63014 ldrb r3, [r6, #20] <== NOT EXECUTED 30019030: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
30019034: 03a0000b moveq r0, #11 <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
30019038: 0a00002e beq 300190f8 <rtems_timer_server_fire_when+0xf8> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
if ( !routine )
3001903c: e3520000 cmp r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
30019040: 03a00009 moveq r0, #9 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
30019044: 0a00002b beq 300190f8 <rtems_timer_server_fire_when+0xf8> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
30019048: e1a00001 mov r0, r1 <== NOT EXECUTED 3001904c: ebfff40f bl 30016090 <_TOD_Validate> <== NOT EXECUTED 30019050: e3500000 cmp r0, #0 <== NOT EXECUTED 30019054: 0a000026 beq 300190f4 <rtems_timer_server_fire_when+0xf4> <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
30019058: e1a00004 mov r0, r4 <== NOT EXECUTED
3001905c: ebfff3e3 bl 30015ff0 <_TOD_To_seconds> <== NOT EXECUTED
30019060: e59f209c ldr r2, [pc, #156] ; 30019104 <rtems_timer_server_fire_when+0x104><== NOT EXECUTED
30019064: e1a07000 mov r7, r0 <== NOT EXECUTED
30019068: e3a03000 mov r3, #0 <== NOT EXECUTED
3001906c: e8960003 ldm r6, {r0, r1} <== NOT EXECUTED
30019070: eb004bc1 bl 3002bf7c <__divdi3> <== NOT EXECUTED
if ( seconds <= _TOD_Seconds_since_epoch() )
30019074: e1570000 cmp r7, r0 <== NOT EXECUTED 30019078: 9a00001d bls 300190f4 <rtems_timer_server_fire_when+0xf4> <== NOT EXECUTED 3001907c: e59f0084 ldr r0, [pc, #132] ; 30019108 <rtems_timer_server_fire_when+0x108><== NOT EXECUTED 30019080: e1a01009 mov r1, r9 <== NOT EXECUTED 30019084: e1a0200d mov r2, sp <== NOT EXECUTED 30019088: eb000a37 bl 3001b96c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001908c: e59d8000 ldr r8, [sp] <== NOT EXECUTED 30019090: e1a04000 mov r4, r0 <== NOT EXECUTED 30019094: e3580000 cmp r8, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30019098: 13a00004 movne r0, #4 <== NOT EXECUTED
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001909c: 1a000015 bne 300190f8 <rtems_timer_server_fire_when+0xf8> <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
300190a0: e2840010 add r0, r4, #16 <== NOT EXECUTED
300190a4: eb001151 bl 3001d5f0 <_Watchdog_Remove> <== NOT EXECUTED
300190a8: e8960003 ldm r6, {r0, r1} <== NOT EXECUTED
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
300190ac: e3a03003 mov r3, #3 <== NOT EXECUTED 300190b0: e59f204c ldr r2, [pc, #76] ; 30019104 <rtems_timer_server_fire_when+0x104><== NOT EXECUTED 300190b4: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
300190b8: e5848018 str r8, [r4, #24] <== NOT EXECUTED 300190bc: e3a03000 mov r3, #0 <== NOT EXECUTED
the_watchdog->routine = routine;
300190c0: e584a02c str sl, [r4, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
300190c4: e5849030 str r9, [r4, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
300190c8: e584b034 str fp, [r4, #52] ; 0x34 <== NOT EXECUTED 300190cc: eb004baa bl 3002bf7c <__divdi3> <== NOT EXECUTED
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
300190d0: e0600007 rsb r0, r0, r7 <== NOT EXECUTED 300190d4: e584001c str r0, [r4, #28] <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
300190d8: e1a01004 mov r1, r4 <== NOT EXECUTED 300190dc: e1a00005 mov r0, r5 <== NOT EXECUTED 300190e0: e1a0e00f mov lr, pc <== NOT EXECUTED 300190e4: e595f004 ldr pc, [r5, #4] <== NOT EXECUTED
_Thread_Enable_dispatch();
300190e8: eb000da2 bl 3001c778 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300190ec: e1a00008 mov r0, r8 <== NOT EXECUTED 300190f0: ea000000 b 300190f8 <rtems_timer_server_fire_when+0xf8> <== NOT EXECUTED
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
300190f4: e3a00014 mov r0, #20 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300190f8: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3000ab44 <rtems_workspace_greedy_allocate>:
void *rtems_workspace_greedy_allocate(
const uintptr_t *block_sizes,
size_t block_count
)
{
3000ab44: e1a02001 mov r2, r1 <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000ab48: e59f102c ldr r1, [pc, #44] ; 3000ab7c <rtems_workspace_greedy_allocate+0x38><== NOT EXECUTED
3000ab4c: e1a03000 mov r3, r0 <== NOT EXECUTED
3000ab50: e5910000 ldr r0, [r1] <== NOT EXECUTED
3000ab54: e92d4010 push {r4, lr} <== NOT EXECUTED
++level;
3000ab58: e2800001 add r0, r0, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000ab5c: e5810000 str r0, [r1] <== NOT EXECUTED
void *opaque;
_Thread_Disable_dispatch();
opaque = _Heap_Greedy_allocate( &_Workspace_Area, block_sizes, block_count );
3000ab60: e59f0018 ldr r0, [pc, #24] ; 3000ab80 <rtems_workspace_greedy_allocate+0x3c><== NOT EXECUTED 3000ab64: e1a01003 mov r1, r3 <== NOT EXECUTED 3000ab68: eb00027e bl 3000b568 <_Heap_Greedy_allocate> <== NOT EXECUTED 3000ab6c: e1a04000 mov r4, r0 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000ab70: eb00084e bl 3000ccb0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return opaque;
}
3000ab74: e1a00004 mov r0, r4 <== NOT EXECUTED
3000ab78: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ab84 <rtems_workspace_greedy_free>:
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
3000ab84: e59f3020 ldr r3, [pc, #32] ; 3000abac <rtems_workspace_greedy_free+0x28><== NOT EXECUTED
void rtems_workspace_greedy_free( void *opaque )
{
3000ab88: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000ab8c: e5932000 ldr r2, [r3] <== NOT EXECUTED
3000ab90: e1a01000 mov r1, r0 <== NOT EXECUTED
++level;
3000ab94: e2822001 add r2, r2, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
3000ab98: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Disable_dispatch(); _Heap_Greedy_free( &_Workspace_Area, opaque );
3000ab9c: e59f000c ldr r0, [pc, #12] ; 3000abb0 <rtems_workspace_greedy_free+0x2c><== NOT EXECUTED 3000aba0: eb00029e bl 3000b620 <_Heap_Greedy_free> <== NOT EXECUTED
_Thread_Enable_dispatch(); }
3000aba4: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
void rtems_workspace_greedy_free( void *opaque )
{
_Thread_Disable_dispatch();
_Heap_Greedy_free( &_Workspace_Area, opaque );
_Thread_Enable_dispatch();
3000aba8: ea000840 b 3000ccb0 <_Thread_Enable_dispatch> <== NOT EXECUTED